ework-daemon 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Issue-driven AI development daemon. Spawns opencode subprocesses to resolve Gitea issues.",
   "module": "src/index.ts",
   "type": "module",

package/src/config.ts

@@ -28,6 +28,9 @@ export const configSchema = z.object({
   opencode: z.object({
     binary: z.string().default("opencode"),
     baseWorkdir: z.string(),
+    dbPath: z.string().default(
+      `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`
+    ),
   }),
   work: z.object({
     capacity: z.coerce.number().int().positive().default(4),
@@ -120,6 +123,7 @@ export function loadConfig(): Config {
       opencode: {
         binary: process.env.OPENCODE_BINARY ?? TEST_DEFAULTS.opencode.binary,
         baseWorkdir: process.env.OPENCODE_BASE_WORKDIR ?? TEST_DEFAULTS.opencode.baseWorkdir,
+        dbPath: process.env.OPENCODE_DB_PATH ?? `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`,
       },
       work: readWorkSection(),
       db: readDbSection(TEST_DEFAULTS.db.path),
@@ -153,6 +157,7 @@ export function loadConfig(): Config {
     opencode: {
       binary: process.env.OPENCODE_BINARY ?? "opencode",
       baseWorkdir: process.env.OPENCODE_BASE_WORKDIR,
+      dbPath: process.env.OPENCODE_DB_PATH ?? `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`,
     },
     work: readWorkSection(),
     db: readDbSection(PRODUCTION_DB_DEFAULT),

package/src/index.ts

@@ -44,8 +44,10 @@ async function boot() {
   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 absorbed = await store.absorbSameHostDaemons(daemonId, displayName, internalEndpoint);
   const claimed = await store.claimAllOwnerless(daemonId);
   log.info(`  daemon registered: id=${daemonId} (adopted orphan slot if id was reused)`);
+  if (absorbed > 0) log.info(`  restart recovery: absorbed ${absorbed} issue(s) from previous incarnation`);
   if (claimed > 0) log.info(`  first-boot migration: claimed ${claimed} previously-ownerless issue(s)`);
 
   const engine = new Engine(config, store, trackers, { daemonId });

package/src/op.ts

@@ -378,6 +378,31 @@ export class Store {
     return ins.insertId;
   }
 
+  /**
+   * On restart, absorb ownership from a previous incarnation on the same host.
+   * Transfers issues + deletes stale daemon rows with matching display_name and
+   * endpoint. This fixes the boot-race where a killed daemon's lease hasn't
+   * expired yet, blocking the new daemon from claiming its own issues.
+   */
+  async absorbSameHostDaemons(
+    daemonId: number,
+    displayName: string,
+    endpoint: string,
+  ): Promise<number> {
+    const db = getDB();
+    const transferred = await db.run(
+      "UPDATE {{issues}} SET owner_daemon_id = ? WHERE owner_daemon_id IN (" +
+        "SELECT id FROM {{daemons}} WHERE display_name = ? AND internal_endpoint = ? AND id != ?" +
+        ")",
+      [daemonId, displayName, endpoint, daemonId],
+    );
+    await db.run(
+      "DELETE FROM {{daemons}} WHERE display_name = ? AND internal_endpoint = ? AND id != ?",
+      [displayName, endpoint, daemonId],
+    );
+    return transferred.changes;
+  }
+
   async heartbeat(daemonId: number): Promise<void> {
     await getDB().run(
       "UPDATE {{daemons}} SET last_heartbeat = ? WHERE id = ?",

package/src/opencode-reader.ts

@@ -0,0 +1,177 @@
+import { Database } from "bun:sqlite";
+import { openSync, closeSync, readFileSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// Read-only OpenCode session accessor. Mirrors the subset of ework-web's
+// OpencodeClient that the session pages need: list + export. The daemon
+// serves this via HTTP so remote web instances can proxy session data
+// without sharing a filesystem.
+
+export interface SessionListItem {
+  id: string;
+  title: string;
+  created: number;
+  updated: number;
+  directory?: string;
+  peakTokens?: number;
+  msgCount?: number;
+}
+
+export class OpencodeReader {
+  private readonly bin: string;
+  private readonly dbPath: string;
+  private readonly timeoutMs = 30_000;
+
+  constructor(bin: string, dbPath: string) {
+    this.bin = bin;
+    this.dbPath = dbPath;
+  }
+
+  async listSessions(limit: number): Promise<SessionListItem[]> {
+    let db: Database;
+    try {
+      db = new Database(this.dbPath, { readonly: true });
+    } catch {
+      return [];
+    }
+    try {
+      const rows = db
+        .prepare(
+          "SELECT s.id AS id, s.title AS title, s.time_created AS created, s.time_updated AS updated, s.directory AS directory, " +
+            "m.peak AS peakTokens, m.calls AS msgCount " +
+            "FROM session s LEFT JOIN (" +
+            "SELECT session_id, MAX(CAST(json_extract(data,'$.tokens.input') AS INT) + CAST(json_extract(data,'$.tokens.cache.read') AS INT) + CAST(json_extract(data,'$.tokens.cache.write') AS INT)) AS peak, " +
+            "COUNT(*) AS calls FROM message WHERE json_extract(data,'$.tokens.input') > 0 GROUP BY session_id" +
+            ") m ON m.session_id = s.id " +
+            "WHERE s.time_archived IS NULL ORDER BY s.time_updated DESC LIMIT ?"
+        )
+        .all(limit) as Array<{ id: unknown; title: unknown; created: unknown; updated: unknown; directory: unknown; peakTokens: unknown; msgCount: unknown }>;
+      return rows
+        .map((r) => {
+          const id = typeof r.id === "string" ? r.id : "";
+          if (!id) return null;
+          return {
+            id,
+            title: typeof r.title === "string" && r.title ? r.title : "(untitled)",
+            created: typeof r.created === "number" ? r.created : 0,
+            updated: typeof r.updated === "number" ? r.updated : 0,
+            directory: typeof r.directory === "string" ? r.directory : undefined,
+            peakTokens: typeof r.peakTokens === "number" && r.peakTokens > 0 ? r.peakTokens : undefined,
+            msgCount: typeof r.msgCount === "number" && r.msgCount > 0 ? r.msgCount : undefined,
+          } as SessionListItem;
+        })
+        .filter((x): x is SessionListItem => x !== null);
+    } catch {
+      return [];
+    } finally {
+      db.close();
+    }
+  }
+
+  async exportSession(id: string): Promise<unknown> {
+    const raw = await this.runJSON(["export", id]);
+    return raw;
+  }
+
+  async exportSessionRaw(id: string): Promise<string> {
+    const { stdout, code } = await this.run(["export", id]);
+    if (code !== 0) {
+      throw new Error(`opencode export ${id} → exit ${code}`);
+    }
+    return stdout;
+  }
+
+  private async runJSON(args: string[]): Promise<unknown> {
+    const { stdout, code, stderr } = await this.run(args);
+    if (code !== 0) {
+      const why = stderr.trim() || `exit ${code}`;
+      const status = /not found|no such/i.test(why) ? 404 : 502;
+      throw new OpencodeReaderError(`opencode ${args.join(" ")} failed: ${why}`, status);
+    }
+    const text = stdout.trim();
+    if (!text) return null;
+    const jsonText = stripNonJsonPreamble(text);
+    if (jsonText === null) {
+      throw new OpencodeReaderError(`opencode ${args.join(" ")}: non-JSON output`, 502);
+    }
+    try {
+      return JSON.parse(jsonText);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new OpencodeReaderError(`opencode ${args.join(" ")}: malformed JSON (${msg})`, 502);
+    }
+  }
+
+  private async run(args: string[]): Promise<{ stdout: string; stderr: string; code: number | null }> {
+    const tmp = join(tmpdir(), `ocd-${process.pid}-${Math.random().toString(36).slice(2)}.json`);
+    const fd = openSync(tmp, "w");
+    const proc = Bun.spawn([this.bin, ...args], {
+      stdout: fd,
+      stderr: "pipe",
+      env: process.env,
+    });
+    const killer = setTimeout(() => {
+      try { proc.kill(); } catch { /* already exited */ }
+    }, this.timeoutMs);
+    let stderr = "";
+    let code: number | null = null;
+    try {
+      stderr = await readCapped(proc.stderr, 64 * 1024);
+      code = await proc.exited;
+    } finally {
+      clearTimeout(killer);
+      try { closeSync(fd); } catch { /* already closed */ }
+    }
+    let stdout = "";
+    if (code === 0) {
+      try {
+        stdout = readFileSync(tmp, "utf-8");
+      } catch { /* temp file gone */ }
+    }
+    try { unlinkSync(tmp); } catch { /* best-effort cleanup */ }
+    return { stdout, stderr, code };
+  }
+}
+
+export class OpencodeReaderError extends Error {
+  status: number;
+  constructor(message: string, status: number) {
+    super(message);
+    this.name = "OpencodeReaderError";
+    this.status = status;
+  }
+}
+
+async function readCapped(stream: ReadableStream<Uint8Array> | null, cap: number): Promise<string> {
+  if (!stream) return "";
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) {
+        total += value.length;
+        if (total > cap) {
+          chunks.push(value.slice(0, cap - (total - value.length)));
+          break;
+        }
+        chunks.push(value);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return new TextDecoder().decode(Buffer.concat(chunks));
+}
+
+function stripNonJsonPreamble(s: string): string | null {
+  const i = s.indexOf("[");
+  const j = s.indexOf("{");
+  if (i === -1 && j === -1) return null;
+  if (i === -1) return s.slice(j);
+  if (j === -1) return s.slice(i);
+  return s.slice(Math.min(i, j));
+}

package/src/server.ts

@@ -2,6 +2,7 @@ import type { Config } from "./config";
 import type { Store } from "./op";
 import type { Engine } from "./opencode";
 import type { IssueTracker, TrackerEvent } from "./trackers/types";
+import { OpencodeReader, OpencodeReaderError } from "./opencode-reader";
 import { log, uptimeSeconds, version } from "./logger";
 
 type TrackerMap = Map<string, IssueTracker>;
@@ -19,6 +20,7 @@ export function createServer(
   engine: Engine,
   trackers: TrackerMap
 ) {
+  const reader = new OpencodeReader(cfg.opencode.binary, cfg.opencode.dbPath);
   async function handleWebhook(req: Request, tracker: IssueTracker): Promise<Response> {
     const rawBody = await req.text();
     const headers: Record<string, string | null> = {};
@@ -118,6 +120,35 @@ export function createServer(
       return json({ ok: true, stopped: wasKilled });
     }
 
+    if (pathname === "/api/opencode/sessions") {
+      const url = new URL(req.url);
+      const limit = Math.min(Math.max(Number(url.searchParams.get("limit") ?? "50"), 1), 500);
+      const sessions = await reader.listSessions(limit);
+      return json(sessions);
+    }
+
+    const ocExportMatch = pathname.match(/^\/api\/opencode\/sessions\/([A-Za-z0-9_-]+)\/export$/);
+    if (ocExportMatch) {
+      try {
+        const data = await reader.exportSession(ocExportMatch[1]!);
+        return json(data);
+      } catch (e) {
+        if (e instanceof OpencodeReaderError) return json({ error: e.message }, e.status);
+        return json({ error: "export failed" }, 502);
+      }
+    }
+
+    const ocRawMatch = pathname.match(/^\/api\/opencode\/sessions\/([A-Za-z0-9_-]+)\/raw$/);
+    if (ocRawMatch) {
+      try {
+        const raw = await reader.exportSessionRaw(ocRawMatch[1]!);
+        return json({ raw });
+      } catch (e) {
+        if (e instanceof OpencodeReaderError) return json({ error: e.message }, e.status);
+        return json({ error: "export failed" }, 502);
+      }
+    }
+
     return json({ error: "not found" }, 404);
   }