ework-daemon 0.2.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.2.2",
+  "version": "0.4.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),
@@ -54,6 +57,11 @@ export const configSchema = z.object({
     thresholdMs: z.coerce.number().positive(),
     maxNudges: z.coerce.number().int().nonnegative(),
   }).optional(),
+  file: z.object({
+    roots: z.array(z.string()).default([]),
+    maxLines: z.coerce.number().int().positive().default(2000),
+    maxBytes: z.coerce.number().int().positive().default(524288),
+  }).default({ roots: [], maxLines: 2000, maxBytes: 524288 }),
 });
 
 export type Config = z.infer<typeof configSchema>;
@@ -120,6 +128,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 +162,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),
@@ -165,5 +175,12 @@ export function loadConfig(): Config {
       thresholdMs: Number(process.env.DAEMON_STUCK_THRESHOLD_MS) || 30 * 60 * 1000,
       maxNudges: Number(process.env.DAEMON_MAX_STUCK_NUDGES) || 1,
     } : undefined,
+    file: {
+      roots: (process.env.WORK_FILE_ROOTS ?? "").split(":").filter(Boolean).length > 0
+        ? (process.env.WORK_FILE_ROOTS ?? "").split(":").filter(Boolean)
+        : [process.env.OPENCODE_BASE_WORKDIR].filter(Boolean) as string[],
+      maxLines: Number(process.env.WORK_FILE_MAX_LINES) || 2000,
+      maxBytes: Number(process.env.WORK_FILE_MAX_BYTES) || 524288,
+    },
   });
 }

package/src/file-api.ts

@@ -0,0 +1,200 @@
+import { realpathSync, statSync, readFileSync, openSync, readSync, closeSync, readdirSync } from "fs";
+import { isAbsolute, relative } from "path";
+import type { Config } from "./config";
+
+export class FileApiError extends Error {
+  status: number;
+  constructor(message: string, status: number) {
+    super(message);
+    this.name = "FileApiError";
+    this.status = status;
+  }
+}
+
+const DENY = [
+  /(^|\/)\.env\b/i,
+  /(^|\/)\.(ssh|gnupg|aws|config\/gitea)\b/i,
+  /(id_rsa|id_ed25519|id_ecdsa|id_dsa)\b/i,
+  /^\/(?:etc|proc|sys|dev|boot|root)\b/i,
+  /\/\.git\/(?:config|hooks|HEAD)\b/i,
+];
+
+function validateFilePath(cfg: Config, rawPath: string): string {
+  if (!rawPath || !isAbsolute(rawPath)) {
+    throw new FileApiError("path must be absolute", 400);
+  }
+  for (const re of DENY) if (re.test(rawPath)) {
+    throw new FileApiError("denied: sensitive path", 403);
+  }
+  let rp: string;
+  try {
+    rp = realpathSync(rawPath);
+  } catch {
+    throw new FileApiError("file not found", 404);
+  }
+  for (const re of DENY) if (re.test(rp)) {
+    throw new FileApiError("denied: sensitive path", 403);
+  }
+  const inRoot = cfg.file.roots.some((r) => {
+    if (!isAbsolute(r)) return false;
+    let rr: string;
+    try { rr = realpathSync(r); } catch { return false; }
+    const rel = relative(rr, rp);
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+  });
+  if (!inRoot) throw new FileApiError("denied: outside allowlisted roots", 403);
+  return rp;
+}
+
+function readSlice(path: string, start: number, len: number): Buffer {
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(len);
+    const got = readSync(fd, buf, 0, len, start);
+    return buf.subarray(0, got);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export interface DirEntry {
+  name: string;
+  isDir: boolean;
+  size: number;
+  mtime: number;
+}
+
+export function listDir(cfg: Config, rawPath: string): { path: string; entries: DirEntry[] } {
+  const rp = validateFilePath(cfg, rawPath);
+  let st: ReturnType<typeof statSync>;
+  try { st = statSync(rp); } catch { throw new FileApiError("stat failed", 404); }
+  if (!st.isDirectory()) throw new FileApiError("not a directory", 400);
+
+  const entries = readdirSync(rp, { withFileTypes: true }).map((d) => {
+    const full = `${rp}/${d.name}`;
+    try {
+      const s = statSync(full);
+      return { name: d.name, isDir: s.isDirectory(), size: s.size, mtime: s.mtimeMs };
+    } catch {
+      return { name: d.name, isDir: d.isDirectory(), size: 0, mtime: 0 };
+    }
+  });
+  entries.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  return { path: rp, entries };
+}
+
+export interface FileContent {
+  path: string;
+  size: number;
+  rows: { n: number; t: string }[];
+  mode: "tail" | "head";
+  byteCapped: boolean;
+  note: string;
+}
+
+export function readFile(
+  cfg: Config,
+  rawPath: string,
+  mode: "tail" | "head",
+  order: "asc" | "desc"
+): FileContent {
+  const rp = validateFilePath(cfg, rawPath);
+  let st: ReturnType<typeof statSync>;
+  try { st = statSync(rp); } catch { throw new FileApiError("stat failed", 404); }
+  if (!st.isFile()) throw new FileApiError("not a regular file", 400);
+
+  const cap = cfg.file.maxBytes;
+  let buf: Buffer;
+  let byteCapped = false;
+  if (st.size > cap) {
+    const start = mode === "tail" ? st.size - cap : 0;
+    buf = readSlice(rp, start, cap);
+    byteCapped = true;
+  } else {
+    try { buf = readFileSync(rp); } catch (e) {
+      throw new FileApiError(`read failed: ${(e as Error).message}`, 500);
+    }
+  }
+
+  const scanLen = Math.min(buf.length, 8192);
+  for (let i = 0; i < scanLen; i++) if (buf[i] === 0) {
+    throw new FileApiError("binary file (not viewable as text)", 415);
+  }
+
+  const text = buf.toString("utf-8");
+  let lines = text.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+
+  const totalLines = lines.length;
+  const n = cfg.file.maxLines;
+  let shown: string[];
+  let note: string;
+  let firstNum: number;
+
+  if (byteCapped) {
+    if (mode === "tail") {
+      shown = lines.slice(-n);
+      note = `(显示最后 ${shown.length} 行，共 ~${totalLines} 行，文件 ${st.size} 字节)`;
+      firstNum = totalLines - shown.length + 1;
+    } else {
+      shown = lines.slice(0, n);
+      note = `(显示最前 ${shown.length} 行，共 ~${totalLines} 行，文件 ${st.size} 字节)`;
+      firstNum = 1;
+    }
+  } else {
+    if (lines.length > n) {
+      shown = mode === "tail" ? lines.slice(-n) : lines.slice(0, n);
+      note = `(${totalLines} 行，显示 ${shown.length})`;
+      firstNum = mode === "tail" ? totalLines - shown.length + 1 : 1;
+    } else {
+      shown = lines;
+      note = "";
+      firstNum = 1;
+    }
+  }
+
+  let rows = shown.map((t, i) => ({ n: firstNum + i, t }));
+  if (order === "desc") rows = rows.reverse();
+
+  return { path: rp, size: st.size, rows, mode, byteCapped, note };
+}
+
+export interface FileDelta {
+  rows: { n: number; t: string }[];
+  size: number;
+  rotated: boolean;
+  capped: boolean;
+}
+
+export function readFileSince(cfg: Config, rawPath: string, afterOffset: number): FileDelta {
+  if (!Number.isFinite(afterOffset) || afterOffset < 0) {
+    throw new FileApiError("bad after offset", 400);
+  }
+  const rp = validateFilePath(cfg, rawPath);
+  let st: ReturnType<typeof statSync>;
+  try { st = statSync(rp); } catch { throw new FileApiError("stat failed", 404); }
+  if (!st.isFile()) throw new FileApiError("not a regular file", 400);
+
+  const size = st.size;
+  if (size < afterOffset) return { rows: [], size, rotated: true, capped: false };
+  if (size === afterOffset) return { rows: [], size, rotated: false, capped: false };
+  const cap = cfg.file.maxBytes;
+  const want = Math.min(size - afterOffset, cap);
+  const buf = readSlice(rp, afterOffset, want);
+  const scanLen = Math.min(buf.length, 8192);
+  for (let i = 0; i < scanLen; i++) if (buf[i] === 0) {
+    throw new FileApiError("binary file (not viewable as text)", 415);
+  }
+  const text = buf.toString("utf-8");
+  let lines = text.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  const capped = size - afterOffset >= cap;
+  if (capped && lines.length > 1) lines[0] = "(…前文已截断)";
+  const n = cfg.file.maxLines;
+  if (lines.length > n) lines = lines.slice(-n);
+  const rows = lines.map((t) => ({ n: 0, t }));
+  return { rows, size, rotated: false, capped };
+}

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,8 @@ 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 { listDir, readFile, readFileSince, FileApiError } from "./file-api";
 import { log, uptimeSeconds, version } from "./logger";
 
 type TrackerMap = Map<string, IssueTracker>;
@@ -19,6 +21,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> = {};
@@ -46,6 +49,7 @@ export function createServer(
   }
 
   async function handleApi(req: Request, pathname: string): Promise<Response> {
+    const url = new URL(req.url);
     if (pathname === "/api/status") {
       const status = await engine.getStatus();
       return json({
@@ -118,6 +122,67 @@ export function createServer(
       return json({ ok: true, stopped: wasKilled });
     }
 
+    if (pathname === "/api/opencode/sessions") {
+      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);
+      }
+    }
+
+    if (pathname === "/api/files/list") {
+      const filePath = url.searchParams.get("path") ?? "";
+      try {
+        return json(listDir(cfg, filePath));
+      } catch (e) {
+        if (e instanceof FileApiError) return json({ error: e.message }, e.status);
+        return json({ error: "list failed" }, 500);
+      }
+    }
+
+    if (pathname === "/api/files/read") {
+      const filePath = url.searchParams.get("path") ?? "";
+      const mode = (url.searchParams.get("mode") === "head" ? "head" : "tail") as "head" | "tail";
+      const order = (url.searchParams.get("order") === "asc" ? "asc" : "desc") as "asc" | "desc";
+      try {
+        return json(readFile(cfg, filePath, mode, order));
+      } catch (e) {
+        if (e instanceof FileApiError) return json({ error: e.message }, e.status);
+        return json({ error: "read failed" }, 500);
+      }
+    }
+
+    if (pathname === "/api/files/since") {
+      const filePath = url.searchParams.get("path") ?? "";
+      const after = Number(url.searchParams.get("after") ?? "0");
+      try {
+        return json(readFileSince(cfg, filePath, after));
+      } catch (e) {
+        if (e instanceof FileApiError) return json({ error: e.message }, e.status);
+        return json({ error: "read failed" }, 500);
+      }
+    }
+
     return json({ error: "not found" }, 404);
   }