ework-daemon 0.4.27 → 0.4.29

package/package.json

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

package/src/config.ts

@@ -28,12 +28,20 @@ export const configSchema = z.object({
   }),
   opencode: z.object({
     binary: z.string().default("opencode"),
-    baseWorkdir: z.string(),
+    baseWorkdir: z.string().default(
+      `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/ework-aio/opencode-workdir`
+    ),
     dbPath: z.string().default(
       `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`
     ),
     defaultModel: z.string().default(""),
   }),
+  pi: z.object({
+    binary: z.string().default("pi"),
+    provider: z.string().default("bailian"),
+    defaultModel: z.string().default(""),
+  }).optional(),
+  runtime: z.enum(["opencode", "pi"]).default("opencode"),
   work: z.object({
     capacity: z.coerce.number().int().positive().default(4),
     maxConcurrent: z.coerce.number().int().positive().default(4),
@@ -138,6 +146,12 @@ export function loadConfig(): Config {
         dbPath: process.env.OPENCODE_DB_PATH ?? `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`,
         defaultModel: process.env.WORK_DEFAULT_MODEL ?? TEST_DEFAULTS.opencode.defaultModel,
       },
+      pi: {
+        binary: process.env.WORK_PI_BINARY ?? "pi",
+        provider: process.env.WORK_PI_PROVIDER ?? "bailian",
+        defaultModel: process.env.WORK_PI_DEFAULT_MODEL ?? process.env.WORK_DEFAULT_MODEL ?? "",
+      },
+      runtime: (process.env.WORK_RUNTIME ?? "opencode").trim().toLowerCase() as "opencode" | "pi",
       work: readWorkSection(),
       db: readDbSection(TEST_DEFAULTS.db.path),
       completionCheck: process.env.COMPLETION_CHECK_API_KEY ? {
@@ -175,6 +189,12 @@ export function loadConfig(): Config {
       dbPath: process.env.OPENCODE_DB_PATH ?? `${process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share")}/opencode/opencode.db`,
       defaultModel: process.env.WORK_DEFAULT_MODEL ?? "",
     },
+    pi: {
+      binary: process.env.WORK_PI_BINARY ?? "pi",
+      provider: process.env.WORK_PI_PROVIDER ?? "bailian",
+      defaultModel: process.env.WORK_PI_DEFAULT_MODEL ?? process.env.WORK_DEFAULT_MODEL ?? "",
+    },
+    runtime: (process.env.WORK_RUNTIME ?? "opencode").trim().toLowerCase() as "opencode" | "pi",
     work: readWorkSection(),
     db: readDbSection(PRODUCTION_DB_DEFAULT),
     completionCheck: process.env.COMPLETION_CHECK_API_KEY ? {

package/src/index.ts

@@ -88,6 +88,13 @@ async function boot() {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 
+  process.on("unhandledRejection", (reason) => {
+    log.error("unhandledRejection (continuing):", reason);
+  });
+  process.on("uncaughtException", (err) => {
+    log.error("uncaughtException (continuing):", err);
+  });
+
   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`);

package/src/opencode.ts

@@ -9,6 +9,7 @@ import type { IssueTracker, TrackerRef, TrackerEvent, TrackerComment, Issue, OpS
 import { formatKey, parseKey } from "./trackers/types";
 import type { RuntimeBackend, RuntimeHandle } from "./runtime/types";
 import { OpencodeBackend } from "./runtime/opencode-backend";
+import { PiBackend } from "./runtime/pi-backend";
 
 // ─── Types ───
 
@@ -279,14 +280,18 @@ export function pickLastActive(sessions: OpSession[]): OpSession | undefined {
 // ─── Engine ───
 
 export interface EngineOptions {
-  /** DB-allocated logical daemon id (from Store.registerDaemon). */
   daemonId: number;
-  /** Workdir + session-resume strategy; defaults to RecloneStrategy. */
   takeover?: TakeoverStrategy;
-  /** Runtime backend (opencode/pi); defaults to OpencodeBackend. */
   backend?: RuntimeBackend;
 }
 
+function createDefaultBackend(cfg: Config): RuntimeBackend {
+  if (cfg.runtime === "pi" && cfg.pi) {
+    return new PiBackend(cfg.pi.binary, cfg.pi.provider, cfg.pi.defaultModel, cfg.childEnvDeny);
+  }
+  return new OpencodeBackend(cfg.opencode.binary, cfg.opencode.dbPath, cfg.childEnvDeny);
+}
+
 export class Engine {
   private cfg: Config;
   private store: Store;
@@ -342,7 +347,7 @@ export class Engine {
     this.trackers = trackers;
     this.daemonId = opts.daemonId;
     this.takeover = opts.takeover ?? new RecloneStrategy(cfg);
-    this.backend = opts.backend ?? new OpencodeBackend(cfg.opencode.binary, cfg.opencode.dbPath, cfg.childEnvDeny);
+    this.backend = opts.backend ?? createDefaultBackend(cfg);
     this.startGlobalObserver();
     void this.recover();
   }
@@ -557,8 +562,8 @@ export class Engine {
     const tracker = this.getTracker(ref.trackerType);
     const scopeKey = tracker.formatScopeKey(ref.scope);
 
-    if (this.paused && event.type === "issue_opened") {
-      log.info(`engine: paused — skipping issue_opened for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
+    if (this.paused && (event.type === "issue_opened" || event.type === "comment_created")) {
+      log.info(`engine: paused — skipping ${event.type} for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
       return;
     }
 
@@ -791,13 +796,11 @@ export class Engine {
 
     // Kill all running processes for this issue's sessions
     const sessions = await this.store.getSessionsForIssue(issue.id);
+    let killedCount = 0;
     for (const session of sessions) {
       const k = this.sessionKey(session, issue);
-      const proc = this.processes.get(k);
-      if (proc) {
-        this.stopping.add(k);
-        try { this.killProcessTree(proc.pid, "SIGTERM"); } catch { /* already dead */ }
-      }
+      const killed = await this.killSessionProcess(session, k);
+      if (killed) killedCount++;
       this.clearRuntimeState(k);
       const msgs = await this.store.getMessagesForSession(session.id);
       for (const msg of msgs) {
@@ -824,7 +827,7 @@ export class Engine {
     this.cloneUrls.delete(gcKey);
     this.senders.delete(gcKey);
 
-    log.info(`engine: issue closed, ${sessions.length} sessions paused for ${scopeKey}#${ref.issueId}`);
+    log.info(`engine: issue closed, ${killedCount}/${sessions.length} sessions killed for ${scopeKey}#${ref.issueId}`);
     void tracker.updateStatus(ref, "completed");
   }
 
@@ -837,13 +840,11 @@ export class Engine {
     if (!issue) return;
     this.stopObserver(issue.id);
     const sessions = await this.store.getSessionsForIssue(issue.id);
+    let killedCount = 0;
     for (const session of sessions) {
       const k = this.sessionKey(session, issue);
-      const proc = this.processes.get(k);
-      if (proc) {
-        this.stopping.add(k);
-        try { this.killProcessTree(proc.pid, "SIGTERM"); } catch { /* already dead */ }
-      }
+      const killed = await this.killSessionProcess(session, k);
+      if (killed) killedCount++;
       this.clearRuntimeState(k);
       const msgs = await this.store.getMessagesForSession(session.id);
       for (const msg of msgs) {
@@ -853,7 +854,7 @@ export class Engine {
       }
       await this.store.updateSession(session.id, { state: "idle", opencodePid: undefined });
     }
-    log.info(`engine: issue halted, ${sessions.length} sessions killed for ${scopeKey}#${ref.issueId}`);
+    log.info(`engine: issue halted, ${killedCount}/${sessions.length} sessions killed for ${scopeKey}#${ref.issueId}`);
     try { await tracker.createComment(ref, "[system] ⏸️ AI processing halted by user."); } catch { /* tracker unavailable */ }
   }
 
@@ -873,6 +874,36 @@ export class Engine {
     this.generation.delete(k);
   }
 
+  private async killSessionProcess(session: OpSession, k: string): Promise<boolean> {
+    const handle = this.processes.get(k);
+    if (handle) {
+      this.stopping.add(k);
+      try { this.killProcessTree(handle.pid, "SIGTERM"); } catch { /* already dead */ }
+      this.processes.delete(k);
+      return true;
+    }
+
+    const pid = session.opencodePid;
+    if (!pid) return false;
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return false;
+    }
+
+    log.info(`engine: killing orphaned pid=${pid} for ${k} (cross-restart)`);
+    this.stopping.add(k);
+    try {
+      this.killProcessTree(pid, "SIGTERM");
+      for (let i = 0; i < 30; i++) {
+        await new Promise(r => setTimeout(r, 100));
+        try { process.kill(pid, 0); } catch { break; }
+      }
+      try { process.kill(pid, "SIGKILL"); } catch { /* dead */ }
+    } catch { /* already dead */ }
+    return true;
+  }
+
   // ─── Preemptive Scheduler ───
 
   private async enqueueOrRun(session: OpSession, issue: Issue, prompt: string, sourceCommentId?: string, model?: string) {
@@ -978,7 +1009,7 @@ export class Engine {
       await this.store.updateSession(session.id, { opencodeSessionId: undefined });
     }
 
-    const model = msg.model || this.cfg.opencode.defaultModel;
+    const model = msg.model || (this.cfg.runtime === "pi" && this.cfg.pi ? this.cfg.pi.defaultModel : this.cfg.opencode.defaultModel);
     this.currentModel.set(k, model);
 
     if (msg.sourceCommentId) {
@@ -1388,16 +1419,20 @@ export class Engine {
   }
 
   private async runObserverCycle() {
-    // Multi-machine: periodically release stale owners so we can adopt their
-    // work, and only iterate issues/sessions this daemon owns.
     try {
       await this.store.releaseDeadOwners(this.cfg.work.leaseTtlMs);
     } catch (err) {
       log.error("engine: releaseDeadOwners failed:", (err as Error).message);
     }
 
-    const ownedIssues = (await this.store.listOwnedIssues(this.daemonId))
-      .filter((i) => this.observedIssues.has(i.id));
+    let ownedIssues;
+    try {
+      ownedIssues = (await this.store.listOwnedIssues(this.daemonId))
+        .filter((i) => this.observedIssues.has(i.id));
+    } catch (err) {
+      log.error("engine: listOwnedIssues failed:", (err as Error).message);
+      return;
+    }
 
     for (const issue of ownedIssues) {
       try {

package/src/runtime/pi-backend.ts

@@ -0,0 +1,167 @@
+import { spawn } from "bun";
+import { readdirSync, existsSync } from "fs";
+import { join } from "path";
+import { log } from "../logger";
+import type {
+  RuntimeBackend,
+  RuntimeSpawnOpts,
+  RuntimeSpawnCallbacks,
+  RuntimeHandle,
+  SessionOutputResult,
+} from "./types";
+
+export class PiBackend implements RuntimeBackend {
+  readonly name = "pi";
+
+  constructor(
+    private binary: string,
+    private provider: string,
+    private defaultModel: string | undefined,
+    private childEnvDeny: string[] = [],
+  ) {}
+
+  async spawn(opts: RuntimeSpawnOpts, cb: RuntimeSpawnCallbacks): Promise<RuntimeHandle> {
+    const args: string[] = [this.binary, "--mode", "json", "--print"];
+
+    const model = opts.model || this.defaultModel;
+    if (model) {
+      if (model.includes("/")) {
+        const slashIdx = model.indexOf("/");
+        const provider = model.slice(0, slashIdx);
+        const modelId = model.slice(slashIdx + 1);
+        args.push("--provider", provider, "--model", modelId);
+      } else {
+        args.push("--provider", this.provider, "--model", model);
+      }
+    } else {
+      args.push("--provider", this.provider);
+    }
+
+    if (opts.resumeSessionId) {
+      args.push("--session-id", opts.resumeSessionId);
+    }
+
+    args.push(opts.prompt);
+
+    const childEnv = { ...opts.env };
+    for (const key of this.childEnvDeny) delete childEnv[key];
+
+    const proc = spawn({
+      cmd: args,
+      cwd: opts.workdir,
+      env: childEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+    });
+
+    const stderrText = new Response(proc.stderr).text();
+
+    void this.readStdout(proc, cb);
+
+    return { pid: proc.pid, exited: proc.exited, stderrText };
+  }
+
+  private async readStdout(
+    proc: ReturnType<typeof spawn>,
+    cb: RuntimeSpawnCallbacks,
+  ): Promise<void> {
+    let captured = false;
+    const stdout = proc.stdout;
+    if (!stdout || typeof stdout === "number") return;
+    const reader = stdout.getReader();
+    const decoder = new TextDecoder();
+    let lineBuf = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      cb.onOutput();
+
+      if (!captured) {
+        lineBuf += decoder.decode(value, { stream: true });
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop()!;
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const ev = JSON.parse(line);
+            if (ev.type === "session" && ev.id) {
+              await cb.onSessionId(ev.id as string);
+              captured = true;
+              break;
+            }
+          } catch { /* not json */ }
+        }
+      }
+    }
+  }
+
+  async sessionExists(sessionId: string): Promise<boolean> {
+    const sessionDir = this.resolveSessionDir();
+    if (!existsSync(sessionDir)) return false;
+    try {
+      const files = readdirSync(sessionDir);
+      return files.some((f) => f.includes(sessionId) && f.endsWith(".jsonl"));
+    } catch {
+      return false;
+    }
+  }
+
+  async getSessionOutputTokens(sessionId: string | undefined): Promise<SessionOutputResult> {
+    if (!sessionId) return { hasOutput: true, tokenCount: 0 };
+
+    const filePath = this.findSessionFile(sessionId);
+    if (!filePath) return { hasOutput: true, tokenCount: 0 };
+
+    try {
+      const { readFileSync } = await import("fs");
+      const content = readFileSync(filePath, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      let totalTokens = 0;
+      let hasAssistant = false;
+
+      for (const line of lines) {
+        try {
+          const ev = JSON.parse(line);
+          if (ev.type === "message" && ev.message?.role === "assistant") {
+            hasAssistant = true;
+            const output = ev.message?.usage?.output ?? 0;
+            totalTokens += output;
+          }
+        } catch { /* skip */ }
+      }
+
+      return { hasOutput: hasAssistant && totalTokens > 0, tokenCount: totalTokens };
+    } catch {
+      return { hasOutput: true, tokenCount: 0 };
+    }
+  }
+
+  private resolveSessionDir(): string {
+    const envDir = process.env.PI_CODING_AGENT_SESSION_DIR;
+    if (envDir) return envDir;
+    const agentDir = process.env.PI_CODING_AGENT_DIR || join(process.env.HOME || "~", ".pi", "agent");
+    return join(agentDir, "sessions");
+  }
+
+  private findSessionFile(sessionId: string): string | null {
+    const sessionDir = this.resolveSessionDir();
+    if (!existsSync(sessionDir)) return null;
+    try {
+      const subdirs = readdirSync(sessionDir, { withFileTypes: true });
+      for (const dir of subdirs) {
+        if (!dir.isDirectory()) continue;
+        const dirPath = join(sessionDir, dir.name);
+        const files = readdirSync(dirPath);
+        for (const f of files) {
+          if (f.includes(sessionId) && f.endsWith(".jsonl")) {
+            return join(dirPath, f);
+          }
+        }
+      }
+    } catch { /* not found */ }
+    return null;
+  }
+}