ework-daemon 0.1.3 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Issue-driven AI development daemon. Spawns opencode subprocesses to resolve Gitea issues.",
   "module": "src/index.ts",
   "type": "module",
@@ -50,6 +50,7 @@
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "test:gitea": "bun run scripts/test-gitea.ts",
+    "test:mysql": "bash scripts/test-mysql.sh",
     "build": "bun build src/cli.ts --compile --outfile ework-daemon",
     "install-global": "bun run build && cp ework-daemon ~/.local/bin/"
   },
@@ -60,6 +61,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "mysql2": "^3.23.1",
     "zod": "^4.4.3"
   }
 }

package/src/config.ts

@@ -29,8 +29,21 @@ export const configSchema = z.object({
     binary: z.string().default("opencode"),
     baseWorkdir: z.string(),
   }),
+  work: z.object({
+    capacity: z.coerce.number().int().positive().default(4),
+    heartbeatMs: z.coerce.number().int().positive().default(10_000),
+    leaseTtlMs: z.coerce.number().int().positive().default(60_000),
+  }),
   db: z.object({
+    driver: z.enum(["sqlite", "mysql"]).default("sqlite"),
+    host: z.string().default("127.0.0.1"),
+    port: z.coerce.number().default(3306),
+    user: z.string().default("ework-daemon"),
+    password: z.string().default(""),
+    name: z.string().default("ework-daemon"),
     path: z.string(),
+    prefix: z.string().default(""),
+    skipCreate: z.boolean().default(false),
   }),
   completionCheck: z.object({
     apiKey: z.string(),
@@ -56,9 +69,33 @@ const TEST_DEFAULTS = {
   bot: { username: "ework-daemon-test", token: "test-bot-token" },
   daemon: { port: 3111, host: "0.0.0.0" },
   opencode: { binary: "opencode", baseWorkdir: join(tmpdir(), "ework-daemon-test") },
+  work: { capacity: 4, heartbeatMs: 10_000, leaseTtlMs: 60_000 },
   db: { path: join(process.cwd(), "test", "ework-daemon-test.db") },
 };
 
+function readWorkSection() {
+  return {
+    capacity: process.env.WORK_DAEMON_CAPACITY ? Number(process.env.WORK_DAEMON_CAPACITY) : 4,
+    heartbeatMs: process.env.WORK_DAEMON_HEARTBEAT_MS ? Number(process.env.WORK_DAEMON_HEARTBEAT_MS) : 10_000,
+    leaseTtlMs: process.env.WORK_DAEMON_LEASE_TTL_MS ? Number(process.env.WORK_DAEMON_LEASE_TTL_MS) : 60_000,
+  };
+}
+
+function readDbSection(fallbackPath: string) {
+  const driver = (process.env.WORK_DB_DRIVER ?? "sqlite").trim().toLowerCase();
+  return {
+    driver: (driver === "mysql" ? "mysql" : "sqlite") as "sqlite" | "mysql",
+    host: process.env.WORK_DB_HOST ?? "127.0.0.1",
+    port: process.env.WORK_DB_PORT ? Number(process.env.WORK_DB_PORT) : 3306,
+    user: process.env.WORK_DB_USER ?? "ework-daemon",
+    password: process.env.WORK_DB_PASSWORD ?? "",
+    name: process.env.WORK_DB_NAME ?? "ework-daemon",
+    path: process.env.WORK_DB_PATH ?? process.env.DAEMON_DB_PATH ?? fallbackPath,
+    prefix: process.env.WORK_DB_PREFIX ?? "",
+    skipCreate: process.env.WORK_DB_SKIP_CREATE === "1" || process.env.WORK_DB_SKIP_CREATE === "true",
+  };
+}
+
 export function loadConfig(): Config {
   const env = getEnv();
 
@@ -84,9 +121,8 @@ export function loadConfig(): Config {
         binary: process.env.OPENCODE_BINARY ?? TEST_DEFAULTS.opencode.binary,
         baseWorkdir: process.env.OPENCODE_BASE_WORKDIR ?? TEST_DEFAULTS.opencode.baseWorkdir,
       },
-      db: {
-        path: process.env.DAEMON_DB_PATH ?? TEST_DEFAULTS.db.path,
-      },
+      work: readWorkSection(),
+      db: readDbSection(TEST_DEFAULTS.db.path),
       completionCheck: process.env.COMPLETION_CHECK_API_KEY ? {
         apiKey: process.env.COMPLETION_CHECK_API_KEY,
         baseURL: process.env.COMPLETION_CHECK_BASE_URL ?? "",
@@ -118,9 +154,8 @@ export function loadConfig(): Config {
       binary: process.env.OPENCODE_BINARY ?? "opencode",
       baseWorkdir: process.env.OPENCODE_BASE_WORKDIR,
     },
-    db: {
-      path: process.env.DAEMON_DB_PATH ?? PRODUCTION_DB_DEFAULT,
-    },
+    work: readWorkSection(),
+    db: readDbSection(PRODUCTION_DB_DEFAULT),
     completionCheck: process.env.COMPLETION_CHECK_API_KEY ? {
       apiKey: process.env.COMPLETION_CHECK_API_KEY,
       baseURL: process.env.COMPLETION_CHECK_BASE_URL ?? "",

package/src/db.ts

@@ -0,0 +1,375 @@
+// Storage bootstrap. Owns the AsyncDatabase singleton. Two drivers behind one
+// AsyncDatabase surface: SQLite (bun:sqlite, default) and MySQL (mysql2/promise).
+// Driver picked by WORK_DB_DRIVER (sqlite|mysql). Schema runs in connect().
+// Callers MUST `await initDB()` once at boot before issuing queries.
+//
+// Table prefix: every table/index/constraint reference in SQL is written as a
+// {{name}} token; applyPrefix() rewrites {{name}} -> <WORK_DB_PREFIX>+name
+// before execution. Default prefix "" leaves SQL identical (backward-
+// compatible with existing ework-daemon.db files). WORK_DB_PREFIX is ENV-ONLY
+// — the prefix must be available before the DB is open, so it cannot live in
+// the DB itself (chicken-and-egg).
+//
+// Backward compat: WORK_DB_PATH falls back to DAEMON_DB_PATH (the legacy env
+// var) so existing single-machine deployments keep working without changes.
+
+import { Database, type SQLQueryBindings } from "bun:sqlite";
+import { createPool, type Pool, type PoolConnection, type ResultSetHeader } from "mysql2/promise";
+import { mkdirSync, readFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+// ---- public async interface (driver-agnostic) ----
+export interface DbRunResult {
+  /** Rowid of the last inserted row (SQLite lastInsertRowid / MySQL insertId). */
+  insertId: number;
+  /** Number of rows affected by the statement. */
+  changes: number;
+}
+
+export interface AsyncDatabase {
+  /** SELECT -> all matching rows. Empty array when none. */
+  all<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+  /** SELECT -> first matching row or null. */
+  get<T = unknown>(sql: string, params?: unknown[]): Promise<T | null>;
+  /** INSERT/UPDATE/DELETE -> insertId + affected-row count. */
+  run(sql: string, params?: unknown[]): Promise<DbRunResult>;
+  /** Execute DDL / raw statement (no params, no rows back). */
+  exec(sql: string): Promise<void>;
+  /** Run fn inside a transaction: commit on resolve, rollback on throw. */
+  transaction<T>(fn: () => Promise<T>): Promise<T>;
+  /** Release the connection/pool. Idempotent. */
+  close(): Promise<void>;
+  /** Driver dialect — lets callers branch on SQLite vs MySQL specifics. */
+  readonly dialect: "sqlite" | "mysql";
+}
+
+const DEFAULT_DB_PATH = join(
+  process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"),
+  "ework-daemon",
+  "ework-daemon.db"
+);
+
+// WORK_DB_PATH preferred; fall back to legacy DAEMON_DB_PATH for existing deploys.
+const DB_PATH = process.env.WORK_DB_PATH || process.env.DAEMON_DB_PATH || DEFAULT_DB_PATH;
+
+// ---- table prefix (env-only; read once at module load) ----
+// Validated as a safe SQL identifier prefix. Empty = no prefix (default,
+// backward-compatible). A non-empty prefix lets multiple ework-daemon
+// instances share one database without colliding on table names.
+const DB_PREFIX = (() => {
+  const raw = (process.env.WORK_DB_PREFIX ?? "").trim();
+  if (raw && !/^[A-Za-z_][A-Za-z0-9_]{0,31}$/.test(raw)) {
+    throw new Error(
+      `Invalid WORK_DB_PREFIX "${raw}": must match ^[A-Za-z_][A-Za-z0-9_]{0,31}$`
+    );
+  }
+  return raw;
+})();
+
+/** Rewrite {{table}} tokens -> <prefix>table. No-op when sql contains no tokens. */
+export function applyPrefix(sql: string): string {
+  if (!sql.includes("{{")) return sql;
+  return sql.replace(/\{\{(\w+)\}\}/g, (_m, name: string) => DB_PREFIX + name);
+}
+
+// ---- driver selection (env-only; read once at module load) ----
+const DB_DRIVER = (process.env.WORK_DB_DRIVER ?? "sqlite").trim().toLowerCase();
+const DB_SKIP_CREATE =
+  process.env.WORK_DB_SKIP_CREATE === "1" || process.env.WORK_DB_SKIP_CREATE === "true";
+if (DB_DRIVER !== "sqlite" && DB_DRIVER !== "mysql") {
+  throw new Error(`Unsupported WORK_DB_DRIVER "${DB_DRIVER}": must be "sqlite" or "mysql"`);
+}
+
+// ---- SqliteDriver: wraps bun:sqlite behind AsyncDatabase ----
+class SqliteDriver implements AsyncDatabase {
+  readonly dialect = "sqlite" as const;
+  private readonly db: Database;
+  private inTx = false;
+  private constructor(db: Database) {
+    this.db = db;
+  }
+
+  static async create(): Promise<SqliteDriver> {
+    const dir = dirname(DB_PATH);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const db = new Database(DB_PATH, { create: true, readwrite: true });
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    const schemaSql = applyPrefix(readFileSync(join(import.meta.dir, "schema-sqlite.sql"), "utf8"));
+    db.exec(schemaSql);
+    return new SqliteDriver(db);
+  }
+
+  async all<T = unknown>(sql: string, params: unknown[] = []): Promise<T[]> {
+    return this.db.query(applyPrefix(sql)).all(...(params as SQLQueryBindings[])) as T[];
+  }
+  async get<T = unknown>(sql: string, params: unknown[] = []): Promise<T | null> {
+    return (this.db.query(applyPrefix(sql)).get(...(params as SQLQueryBindings[])) as T | null) ?? null;
+  }
+  async run(sql: string, params: unknown[] = []): Promise<DbRunResult> {
+    const info = this.db.query(applyPrefix(sql)).run(...(params as SQLQueryBindings[])) as unknown as {
+      lastInsertRowid: number | bigint;
+      changes: number;
+    };
+    return { insertId: Number(info.lastInsertRowid), changes: info.changes };
+  }
+  async exec(sql: string): Promise<void> {
+    this.db.exec(applyPrefix(sql));
+  }
+  async transaction<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.inTx) {
+      // SQLite can't nest BEGIN without SAVEPOINT; current codebase has no
+      // nesting, so this safety net just runs the body inline.
+      return fn();
+    }
+    this.db.exec("BEGIN");
+    this.inTx = true;
+    try {
+      const r = await fn();
+      this.db.exec("COMMIT");
+      return r;
+    } catch (e) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+        /* already rolled back */
+      }
+      throw e;
+    } finally {
+      this.inTx = false;
+    }
+  }
+  async close(): Promise<void> {
+    try {
+      this.db.close();
+    } catch {
+      /* already closed */
+    }
+  }
+}
+
+// ---- MysqlDriver: wraps mysql2/promise behind AsyncDatabase ----
+// MySQL transactions must run on a single connection, so transaction() checks
+// out a connection, pins it as txConn, and routes all/get/run/exec through it
+// until commit/rollback. Outside a transaction, queries hit the pool. SQLite-
+// specific SQL (INSERT OR IGNORE) is translated to MySQL equivalents by
+// translateForMysql() so op.ts stays single-dialect.
+interface MysqlOptions {
+  host: string;
+  port: number;
+  user: string;
+  password: string;
+  database: string;
+  skipCreate: boolean;
+}
+
+function translateForMysql(sql: string): string {
+  return sql.replace(/INSERT OR IGNORE INTO/g, "INSERT IGNORE INTO");
+}
+
+class MysqlDriver implements AsyncDatabase {
+  readonly dialect = "mysql" as const;
+  private readonly pool: Pool;
+  private txConn: PoolConnection | null = null;
+  private constructor(pool: Pool) {
+    this.pool = pool;
+  }
+
+  private get conn(): Pool | PoolConnection {
+    return this.txConn ?? this.pool;
+  }
+
+  static async create(opts: MysqlOptions): Promise<MysqlDriver> {
+    const pool = createPool({
+      host: opts.host,
+      port: opts.port,
+      user: opts.user,
+      password: opts.password,
+      database: opts.database,
+      waitForConnections: true,
+      connectionLimit: 10,
+      charset: "utf8mb4",
+    });
+    const probe = await pool.getConnection();
+    try {
+      await probe.ping();
+    } finally {
+      probe.release();
+    }
+    if (!opts.skipCreate) {
+      const raw = applyPrefix(readFileSync(join(import.meta.dir, "schema-mysql.sql"), "utf8"));
+      // MySQL has no CREATE INDEX IF NOT EXISTS, so split into statements and
+      // tolerate ER_DUP_KEYNAME (1061) so re-runs stay idempotent. Comment lines
+      // are stripped first — they may contain ';' which would corrupt the split.
+      const schema = raw
+        .split("\n")
+        .filter((l) => !l.trimStart().startsWith("--"))
+        .join("\n");
+      for (const stmt of schema.split(";").map((s) => s.trim()).filter((s) => s.length > 0)) {
+        try {
+          await pool.query(stmt);
+        } catch (e) {
+          if (e && typeof e === "object" && "errno" in e && (e as { errno: number }).errno === 1061) continue;
+          throw e;
+        }
+      }
+    }
+    return new MysqlDriver(pool);
+  }
+
+  private prepare(sql: string): string {
+    return translateForMysql(applyPrefix(sql));
+  }
+
+  async all<T = unknown>(sql: string, params: unknown[] = []): Promise<T[]> {
+    const [rows] = await this.conn.query(this.prepare(sql), params);
+    return rows as T[];
+  }
+  async get<T = unknown>(sql: string, params: unknown[] = []): Promise<T | null> {
+    const [rows] = await this.conn.query(this.prepare(sql), params);
+    const arr = rows as T[];
+    return arr[0] ?? null;
+  }
+  async run(sql: string, params: unknown[] = []): Promise<DbRunResult> {
+    const [result] = await this.conn.query(this.prepare(sql), params);
+    const r = result as ResultSetHeader;
+    return { insertId: Number(r.insertId), changes: r.affectedRows };
+  }
+  async exec(sql: string): Promise<void> {
+    await this.conn.query(this.prepare(sql));
+  }
+  async transaction<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.txConn) return fn();
+    const conn = await this.pool.getConnection();
+    this.txConn = conn;
+    await conn.beginTransaction();
+    try {
+      const r = await fn();
+      await conn.commit();
+      return r;
+    } catch (e) {
+      try {
+        await conn.rollback();
+      } catch {
+        /* already rolled back */
+      }
+      throw e;
+    } finally {
+      this.txConn = null;
+      conn.release();
+    }
+  }
+  async close(): Promise<void> {
+    try {
+      await this.pool.end();
+    } catch {
+      /* already closed */
+    }
+  }
+}
+
+let _driver: AsyncDatabase | null = null;
+
+/** Initialize + connect the database. MUST be awaited once at boot. */
+export async function initDB(): Promise<AsyncDatabase> {
+  if (_driver) return _driver;
+  if (DB_DRIVER === "mysql") {
+    _driver = await MysqlDriver.create({
+      host: process.env.WORK_DB_HOST ?? "127.0.0.1",
+      port: Number(process.env.WORK_DB_PORT ?? 3306),
+      user: process.env.WORK_DB_USER ?? "ework-daemon",
+      password: process.env.WORK_DB_PASSWORD ?? "",
+      database: process.env.WORK_DB_NAME ?? "ework-daemon",
+      skipCreate: DB_SKIP_CREATE,
+    });
+  } else {
+    _driver = await SqliteDriver.create();
+  }
+  await runMigrations(_driver);
+  return _driver;
+}
+
+// Idempotent additive migrations for the multi-machine coordination layer
+// (Phase 1). The new daemons table is in the schema files; these ALTERs add
+// nullable columns to existing tables so an upgraded DB matches a fresh one.
+// Checked per-column so re-running on an already-migrated DB is a no-op.
+async function runMigrations(db: AsyncDatabase): Promise<void> {
+  const prefix = DB_PREFIX;
+  const tIssues = `${prefix}issues`;
+  const tSessions = `${prefix}op_sessions`;
+
+  const sqlite = db.dialect === "sqlite";
+
+  // Column-existence check branches on driver: SQLite has PRAGMA table_info,
+  // MySQL has information_schema.columns. Both return >=1 row if present.
+  const hasColumn = async (table: string, col: string): Promise<boolean> => {
+    if (sqlite) {
+      const rows = await db.all<{ name: string }>(
+        `PRAGMA table_info(${table})`
+      );
+      return rows.some((r) => r.name === col);
+    }
+    const row = await db.get<{ cnt: number }>(
+      `SELECT COUNT(*) AS cnt FROM information_schema.columns
+       WHERE table_schema = DATABASE() AND table_name = ? AND column_name = ?`,
+      [table, col]
+    );
+    return Number(row?.cnt ?? 0) > 0;
+  };
+
+  const ensureColumn = async (table: string, col: string, ddl: string): Promise<void> => {
+    if (await hasColumn(table, col)) return;
+    await db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+  };
+
+  // issues.owner_daemon_id — points at the leasing daemon (nullable = unclaimed).
+  await ensureColumn(
+    tIssues,
+    "owner_daemon_id",
+    sqlite
+      ? "owner_daemon_id INTEGER REFERENCES {{daemons}}(id)"
+      : "owner_daemon_id BIGINT NULL"
+  );
+
+  // op_sessions runtime-state columns (previously in-memory Maps; now persisted
+  // so a restarted daemon can recover the nudge/generation state).
+  await ensureColumn(tSessions, "last_output_at", "last_output_at VARCHAR(40)");
+  await ensureColumn(
+    tSessions,
+    "nudge_rounds",
+    sqlite ? "nudge_rounds INTEGER NOT NULL DEFAULT 0" : "nudge_rounds INT NOT NULL DEFAULT 0"
+  );
+  await ensureColumn(
+    tSessions,
+    "stuck_nudge_rounds",
+    sqlite ? "stuck_nudge_rounds INTEGER NOT NULL DEFAULT 0" : "stuck_nudge_rounds INT NOT NULL DEFAULT 0"
+  );
+  await ensureColumn(
+    tSessions,
+    "generation",
+    sqlite ? "generation INTEGER NOT NULL DEFAULT 0" : "generation INT NOT NULL DEFAULT 0"
+  );
+
+  // Index over owner_daemon_id — added after the column exists. SQLite tolerates
+  // IF NOT EXISTS; MySQL lacks it, so we tolerate ER_DUP_KEYNAME (1061) on re-runs.
+  if (sqlite) {
+    await db.exec(`CREATE INDEX IF NOT EXISTS idx_issues_owner ON ${tIssues}(owner_daemon_id)`);
+  } else {
+    try {
+      await db.exec(`CREATE INDEX idx_issues_owner ON ${tIssues}(owner_daemon_id)`);
+    } catch (e) {
+      if (e && typeof e === "object" && "errno" in e && (e as { errno: number }).errno === 1061) {
+        // index already exists — expected on re-runs
+      } else {
+        throw e;
+      }
+    }
+  }
+}
+
+/** Returns the initialized AsyncDatabase. Throws if initDB() wasn't awaited. */
+export function getDB(): AsyncDatabase {
+  if (!_driver) throw new Error("getDB() called before initDB(); await initDB() at boot first");
+  return _driver;
+}

package/src/index.ts

@@ -6,6 +6,8 @@ import { Engine } from "./opencode";
 import { log } from "./logger";
 import { GiteaTracker } from "./trackers/gitea-tracker";
 import type { IssueTracker } from "./trackers/types";
+import { initDB } from "./db";
+import { hostname } from "os";
 
 const config = loadConfig();
 const isTest = config.env === "test";
@@ -15,7 +17,8 @@ log.info(`  gitea: ${config.gitea.url}`);
 log.info(`  listen: ${config.daemon.host}:${config.daemon.port}`);
 log.info(`  opencode: ${config.opencode.binary}`);
 log.info(`  workdir: ${config.opencode.baseWorkdir}`);
-log.info(`  db: ${config.db.path}`);
+log.info(`  db: ${config.db.driver === "mysql" ? `${config.db.user}@${config.db.host}:${config.db.port}/${config.db.name}` : config.db.path}${config.db.prefix ? ` (prefix=${config.db.prefix})` : ""}`);
+log.info(`  work: capacity=${config.work.capacity} heartbeat=${config.work.heartbeatMs}ms leaseTtl=${config.work.leaseTtlMs}ms`);
 
 const giteaClient = new GiteaClient(config.gitea, config.bot.token);
 const giteaTracker = new GiteaTracker(
@@ -28,21 +31,46 @@ const giteaTracker = new GiteaTracker(
 const trackers = new Map<string, IssueTracker>();
 trackers.set("gitea", giteaTracker);
 
-const store = new Store(config.db.path);
-const engine = new Engine(config, store, trackers);
+async function boot() {
+  await initDB();
 
-const server = createServer(config, store, engine, trackers);
+  const store = new Store();
 
-async function shutdown(signal: string) {
-  log.info(`\n${signal} received, shutting down...`);
-  engine.destroy();
-  store.close();
-  process.exit(0);
-}
+  // Multi-machine coordination boot:
+  // 1. Release any stale owners (dead-daemon cleanup) so we can adopt orphans.
+  // 2. Register this daemon (adopts an orphan slot if available).
+  // 3. First-boot migration: claim all pre-existing ownerless issues.
+  await store.releaseDeadOwners(config.work.leaseTtlMs);
+  const displayName = hostname();
+  const internalEndpoint = `${config.daemon.host}:${config.daemon.port}`;
+  const daemonId = await store.registerDaemon(displayName, internalEndpoint, config.work.capacity, config.work.leaseTtlMs);
+  const claimed = await store.claimAllOwnerless(daemonId);
+  log.info(`  daemon registered: id=${daemonId} (adopted orphan slot if id was reused)`);
+  if (claimed > 0) log.info(`  first-boot migration: claimed ${claimed} previously-ownerless issue(s)`);
+
+  const engine = new Engine(config, store, trackers, { daemonId });
+  engine.startHeartbeat(config.work.heartbeatMs);
+  const server = createServer(config, store, engine, trackers);
+
+  async function shutdown(signal: string) {
+    log.info(`\n${signal} received, shutting down...`);
+    engine.destroy();
+    // Best-effort: mark this daemon drained so peers don't wait for lease expiry.
+    try { await store.markDaemonStatus(daemonId, "drained"); } catch { /* best-effort */ }
+    await store.close();
+    process.exit(0);
+  }
 
-process.on("SIGTERM", () => shutdown("SIGTERM"));
-process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+
+  const activeCount = (await store.listActiveIssues()).length;
+  log.info(`\n${isTest ? "🧪" : "✅"} ework-daemon ready at http://${server.hostname}:${server.port}/webhook`);
+  log.info(`   Configure Gitea webhook to POST to /webhook/gitea`);
+  log.info(`   Active issues: ${activeCount}`);
+}
 
-log.info(`\n${isTest ? "🧪" : "✅"} ework-daemon ready at http://${server.hostname}:${server.port}/webhook`);
-log.info(`   Configure Gitea webhook to POST to /webhook/gitea`);
-log.info(`   Active issues: ${store.listActiveIssues().length}`);
+void boot().catch((err) => {
+  log.error("boot failed:", err);
+  process.exit(1);
+});