ework-daemon 0.4.27 → 0.4.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.4.27",
+  "version": "0.4.28",
   "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/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();
   }
@@ -978,7 +983,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) {

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;
+  }
+}