refactor: remove all config.json legacy code

- Daemon now takes dbPath directly instead of configPath
- Removed watchConfig(), reloadConfig(), and the config.json auto-import
- Removed loadConfig() from config.ts (no longer needed)
- Removed importFromJson() from db.ts (no longer needed)
- Removed --config CLI flag (config is managed via the dashboard)
- All runtime data lives in ~/.relay/

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: adriandmitroca

src/cli.ts

@@ -26,10 +26,6 @@ function dataDir(): string {
   return join(process.env.HOME ?? "~", ".relay");
 }
 
-function resolveConfigPath(): string {
-  return getFlag("config") ?? join(dataDir(), "config.json");
-}
-
 function getCommand(): string {
   const args = process.argv.slice(2).filter((a) => !a.startsWith("--"));
   return args[0] ?? "help";
@@ -57,10 +53,10 @@ async function checkForUpdates() {
 }
 
 async function cmdStart() {
-  const configPath = resolveConfigPath();
   const dir = dataDir();
   await Bun.$`mkdir -p ${dir}`.quiet();
   const pidFile = join(dir, "relay.pid");
+  const dbPath = join(dir, "sqlite.db");
   const logLevel = getFlag("log-level");
   if (logLevel) setLogLevel(logLevel as "debug" | "info" | "warn" | "error");
 
@@ -81,7 +77,7 @@ async function cmdStart() {
   // Silent update check in background
   checkForUpdates().catch(() => {});
 
-  const daemon = new Daemon(configPath);
+  const daemon = new Daemon(dbPath);
 
   const cleanup = () => {
     try { unlinkSync(pidFile); } catch {}
@@ -236,7 +232,6 @@ ${BOLD}Usage:${RESET}
   relay help      Show this help
 
 ${BOLD}Options:${RESET}
-  --config <path>        Path to config.json (default: ~/.relay/config.json)
   --log-level <level>    Override log level (debug/info/warn/error)
 
 ${BOLD}Getting started:${RESET}

src/config.ts

@@ -78,34 +78,6 @@ const DEFAULTS = {
   allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
 };
 
-export async function loadConfig(configPath: string): Promise<Config> {
-  const file = Bun.file(configPath);
-  if (!(await file.exists())) {
-    throw new Error(`Config not found at ${configPath}. Run 'relay init' to create one.`);
-  }
-
-  let raw: Record<string, unknown>;
-  try {
-    raw = await file.json();
-  } catch {
-    throw new Error(`Config at ${configPath} is not valid JSON. Check for syntax errors.`);
-  }
-
-  const config: Config = {
-    workspaces: (raw.workspaces as WorkspaceConfig[]) ?? [],
-    pollIntervalSeconds: (raw.pollIntervalSeconds as number) ?? DEFAULTS.pollIntervalSeconds,
-    maxConcurrency: (raw.maxConcurrency as number) ?? DEFAULTS.maxConcurrency,
-    claudeTimeout: (raw.claudeTimeout as number) ?? DEFAULTS.claudeTimeout,
-    triageTimeout: (raw.triageTimeout as number) ?? DEFAULTS.triageTimeout,
-    triage: (raw.triage as boolean) ?? DEFAULTS.triage,
-    logLevel: (raw.logLevel as Config["logLevel"]) ?? DEFAULTS.logLevel,
-    allowedTools: (raw.allowedTools as string[]) ?? DEFAULTS.allowedTools,
-  };
-
-  validate(config);
-  return config;
-}
-
 export function findProjectConfig(config: Config, projectKey: string): { workspace: WorkspaceConfig; project: ProjectConfig } | null {
   for (const ws of config.workspaces) {
     const project = ws.projects.find((p) => p.key === projectKey);

src/daemon.ts

@@ -1,4 +1,4 @@
-import { loadConfig, allProjects, findProjectConfig, type Config, type ProjectConfig, type WorkspaceConfig } from "./config.ts";
+import { allProjects, findProjectConfig, type Config, type ProjectConfig, type WorkspaceConfig } from "./config.ts";
 import { IssueDB, ConfigDB, type IssueRow, type IssueStatus } from "./db.ts";
 import { PriorityQueue } from "./queue.ts";
 import { SentryAdapter } from "./sources/sentry.ts";
@@ -44,33 +44,19 @@ export class Daemon {
   private queue!: PriorityQueue<PipelineItem>;
   private workspaces: Map<string, WorkspaceRuntime> = new Map();
   private pollTimer: ReturnType<typeof setInterval> | null = null;
-  private configWatcher: ReturnType<typeof import("node:fs").watch> | null = null;
   private stopping = false;
-  private configPath: string;
+  private dbPath: string;
   private dashboard!: DashboardServer;
-  private baseDir: string;
 
-  constructor(configPath: string) {
-    this.configPath = configPath;
-    this.baseDir = dirname(configPath);
+  constructor(dbPath: string) {
+    this.dbPath = dbPath;
   }
 
   async start() {
     // Init DB
-    const dbPath = join(this.baseDir, "sqlite.db");
-    this.db = new IssueDB(dbPath);
+    this.db = new IssueDB(this.dbPath);
     this.configDB = new ConfigDB(this.db.getDatabase());
 
-    // Auto-import config.json if DB has no config
-    if (!this.configDB.hasConfig()) {
-      const configFile = Bun.file(this.configPath);
-      if (await configFile.exists()) {
-        const jsonConfig = await loadConfig(this.configPath);
-        this.configDB.importFromJson(jsonConfig);
-        logger.info("Auto-imported config.json into database");
-      }
-    }
-
     // Start dashboard (always — even without config for setup wizard)
     const isDev = process.env.DEV === "1";
     // Resolve dist/ relative to this source file so it works both in-repo and when
@@ -129,9 +115,6 @@ export class Daemon {
     // Start poll interval
     this.pollTimer = setInterval(() => this.poll(), this.config.pollIntervalSeconds * 1000);
 
-    // Watch config.json for hot reload (legacy support)
-    this.watchConfig();
-
     // Setup shutdown handlers
     this.setupShutdownHandlers();
 
@@ -223,11 +206,6 @@ export class Daemon {
     this.stopping = true;
     logger.info("Shutting down...");
 
-    if (this.configWatcher) {
-      this.configWatcher.close();
-      this.configWatcher = null;
-    }
-
     if (this.pollTimer) {
       clearInterval(this.pollTimer);
       this.pollTimer = null;
@@ -330,58 +308,6 @@ export class Daemon {
     }
   }
 
-  private watchConfig() {
-    const { watch } = require("node:fs") as typeof import("node:fs");
-    let debounce: ReturnType<typeof setTimeout> | null = null;
-
-    this.configWatcher = watch(this.configPath, () => {
-      if (debounce) clearTimeout(debounce);
-      debounce = setTimeout(() => this.reloadConfig(), 500);
-    });
-
-    logger.debug("Watching config for changes", { path: this.configPath });
-  }
-
-  private async reloadConfig() {
-    try {
-      const newConfig = await loadConfig(this.configPath);
-
-      // Restart poll timer if interval changed
-      if (newConfig.pollIntervalSeconds !== this.config.pollIntervalSeconds) {
-        if (this.pollTimer) clearInterval(this.pollTimer);
-        this.pollTimer = setInterval(() => this.poll(), newConfig.pollIntervalSeconds * 1000);
-        logger.info("Poll interval updated", { seconds: newConfig.pollIntervalSeconds });
-      }
-
-      if (newConfig.logLevel !== this.config.logLevel) {
-        setLogLevel(newConfig.logLevel);
-        logger.info("Log level updated", { level: newConfig.logLevel });
-      }
-
-      // Reinit workspaces if workspace config changed
-      const oldWsJson = JSON.stringify(this.config.workspaces);
-      const newWsJson = JSON.stringify(newConfig.workspaces);
-      if (oldWsJson !== newWsJson) {
-        for (const ws of this.workspaces.values()) {
-          ws.telegram?.stopPolling();
-        }
-        this.workspaces.clear();
-        this.config = newConfig;
-        this.initWorkspaces();
-        logger.info("Workspaces reinitialized");
-      } else {
-        this.config = newConfig;
-      }
-
-      logger.info("Config reloaded");
-
-      // Trigger immediate poll after reload
-      await this.poll();
-    } catch (err) {
-      logger.error("Config reload failed, keeping current config", { error: String(err) });
-    }
-  }
-
   private async poll() {
     if (this.stopping) return;
 
@@ -1090,7 +1016,7 @@ function buildPRBody(row: IssueRow): string {
 
 // When run directly
 if (import.meta.main) {
-  const configPath = process.argv[2] || join(process.cwd(), "config.json");
-  const daemon = new Daemon(configPath);
+  const dbPath = process.argv[2] || join(process.env.HOME ?? "~", ".relay", "sqlite.db");
+  const daemon = new Daemon(dbPath);
   await daemon.start();
 }

src/db.ts

@@ -615,60 +615,6 @@ export class ConfigDB {
     return row.count > 0;
   }
 
-  importFromJson(config: Config): void {
-    this.db.exec("BEGIN TRANSACTION");
-    try {
-      // Import settings
-      const settingsMap: Record<string, string> = {
-        pollIntervalSeconds: String(config.pollIntervalSeconds),
-        maxConcurrency: String(config.maxConcurrency),
-        claudeTimeout: String(config.claudeTimeout),
-        triageTimeout: String(config.triageTimeout),
-        triage: String(config.triage),
-        logLevel: config.logLevel,
-        allowedTools: JSON.stringify(config.allowedTools),
-      };
-      this.updateSettings(settingsMap);
-
-      // Import workspaces
-      for (const ws of config.workspaces) {
-        const wsRow = this.createWorkspace(ws.key);
-
-        if (ws.telegram) {
-          this.upsertTelegramConfig(wsRow.id, ws.telegram.botToken, ws.telegram.chatId);
-        }
-
-        for (const proj of ws.projects) {
-          const projRow = this.createProject(wsRow.id, {
-            key: proj.key,
-            repoPath: proj.repoPath,
-            baseBranch: proj.baseBranch,
-            testCommand: proj.testCommand,
-          });
-
-          if (proj.sources.sentry) {
-            this.upsertSourceConfig(projRow.id, "sentry", proj.sources.sentry as unknown as Record<string, unknown>);
-          }
-          if (proj.sources.asana) {
-            this.upsertSourceConfig(projRow.id, "asana", proj.sources.asana as unknown as Record<string, unknown>);
-          }
-          if (proj.sources.linear) {
-            this.upsertSourceConfig(projRow.id, "linear", proj.sources.linear as unknown as Record<string, unknown>);
-          }
-          if (proj.sources.jira) {
-            this.upsertSourceConfig(projRow.id, "jira", proj.sources.jira as unknown as Record<string, unknown>);
-          }
-        }
-      }
-
-      this.db.exec("COMMIT");
-      logger.info("Imported config from JSON to DB", { workspaces: config.workspaces.length });
-    } catch (err) {
-      this.db.exec("ROLLBACK");
-      throw err;
-    }
-  }
-
   toConfig(): Config {
     const settings = this.getSettings();
     const workspaces: WorkspaceConfig[] = [];