ework-daemon 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.3.0",
+  "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

@@ -57,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>;
@@ -170,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/server.ts

@@ -3,6 +3,7 @@ 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>;
@@ -48,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({
@@ -121,7 +123,6 @@ export function createServer(
     }
 
     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);
@@ -149,6 +150,39 @@ export function createServer(
       }
     }
 
+    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);
   }