@a5c-ai/babysitter-sdk 0.0.184 → 0.0.185

package/dist/harness/opencode.js

@@ -0,0 +1,578 @@
+"use strict";
+/**
+ * OpenCode harness adapter.
+ *
+ * Centralizes all OpenCode-specific behaviors:
+ *   - Session ID resolution (BABYSITTER_SESSION_ID, self-injected via shell.env hook)
+ *   - State directory conventions (global state dir by default)
+ *   - Session binding (run:create → state file with run association)
+ *   - Minimal stop hook handler (no native stop hook — in-turn model)
+ *   - Session-start hook handler (baseline state file creation)
+ *
+ * OpenCode characteristics:
+ *   - Go binary, CLI command: `opencode`
+ *   - Config directory: `.opencode/`
+ *   - Plugin system: JS/TS modules in `.opencode/plugins/` with hooks for
+ *     `tool.execute.before/after`, `session.idle`, `session.created`, `shell.env`
+ *   - NO blocking stop hook — `session.idle` is fire-and-forget
+ *   - Programmatic API: `@opencode-ai/sdk` with `session.create()`,
+ *     `session.prompt()`, `event.subscribe()` (SSE)
+ *   - Env vars: Does NOT inject distinctive env vars into plugins — weak
+ *     caller detection. The babysitter plugin self-injects
+ *     `BABYSITTER_SESSION_ID` via the `shell.env` hook.
+ *   - Loop mechanism: in-turn (no stop-hook, must use SDK loop driver or
+ *     in-turn orchestration)
+ *   - Capabilities: [HeadlessPrompt] only
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenCodeAdapter = createOpenCodeAdapter;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const journal_1 = require("../storage/journal");
+const runFiles_1 = require("../storage/runFiles");
+const effectIndex_1 = require("../runtime/replay/effectIndex");
+const session_1 = require("../session");
+const types_1 = require("./types");
+const context_1 = require("../prompts/context");
+const config_1 = require("../config");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const HARNESS_NAME = "opencode";
+function createHookLogger(hookName) {
+    const logDir = process.env.BABYSITTER_LOG_DIR || ".a5c/logs";
+    const logFile = logDir ? path.join(logDir, `${hookName}.log`) : null;
+    const context = {};
+    if (logFile) {
+        try {
+            (0, node_fs_1.mkdirSync)(logDir, { recursive: true });
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    function write(level, message) {
+        if (!logFile)
+            return;
+        const ts = new Date().toISOString();
+        const ctxParts = Object.entries(context).map(([k, v]) => `${k}=${v}`);
+        const ctxStr = ctxParts.length > 0 ? ` [${ctxParts.join(" ")}]` : "";
+        const line = `[${level}] ${ts}${ctxStr} ${message}\n`;
+        try {
+            (0, node_fs_1.appendFileSync)(logFile, line);
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    return {
+        info: (msg) => write("INFO", msg),
+        warn: (msg) => write("WARN", msg),
+        error: (msg) => write("ERROR", msg),
+        setContext: (key, value) => {
+            context[key] = value;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Stdin reader
+// ---------------------------------------------------------------------------
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
+// ---------------------------------------------------------------------------
+// Hook input parsing
+// ---------------------------------------------------------------------------
+function parseHookInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return {};
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Malformed JSON — treat as empty
+    }
+    return {};
+}
+function safeStr(obj, key) {
+    const val = obj[key];
+    return typeof val === "string" ? val : "";
+}
+// ---------------------------------------------------------------------------
+// Pending-by-kind helper
+// ---------------------------------------------------------------------------
+function countPendingByKind(records) {
+    const counts = new Map();
+    for (const record of records) {
+        const key = record.kind ?? "unknown";
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return Object.fromEntries(Array.from(counts.entries()).sort(([a], [b]) => a.localeCompare(b)));
+}
+// ---------------------------------------------------------------------------
+// Cleanup helper
+// ---------------------------------------------------------------------------
+async function cleanupSession(filePath) {
+    try {
+        await (0, session_1.deleteSessionFile)(filePath);
+    }
+    catch {
+        // Best-effort cleanup
+    }
+}
+// ---------------------------------------------------------------------------
+// State directory resolution
+// ---------------------------------------------------------------------------
+function resolveStateDirInternal(args) {
+    if (args.stateDir)
+        return path.resolve(args.stateDir);
+    return (0, config_1.getGlobalStateDir)();
+}
+// ---------------------------------------------------------------------------
+// Session ID resolution
+// ---------------------------------------------------------------------------
+function resolveSessionIdInternal(parsed) {
+    // 1. Explicit arg (highest priority)
+    if (parsed.sessionId)
+        return parsed.sessionId;
+    // 2. Cross-harness standard env var (self-injected by babysitter plugin's shell.env hook)
+    if (process.env.BABYSITTER_SESSION_ID)
+        return process.env.BABYSITTER_SESSION_ID;
+    // 3. OpenCode-specific env vars (set by babysitter plugin's shell.env hook)
+    if (process.env.OPENCODE_SESSION_ID)
+        return process.env.OPENCODE_SESSION_ID;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Stop hook handler (minimal — no native stop hook)
+// ---------------------------------------------------------------------------
+/**
+ * Handles the stop hook for OpenCode.
+ *
+ * OpenCode does NOT have a native stop hook that can block/restart the agent.
+ * This handler checks run status and returns approve/block as a decision, but
+ * the actual loop driving happens externally (in-turn model or SDK loop driver).
+ *
+ * When a run is still in progress (has pending effects or is not completed),
+ * we output a block decision with context for the next iteration. When the
+ * run is completed/failed or no run is bound, we allow exit.
+ */
+async function handleStopHookImpl(args) {
+    const { verbose } = args;
+    const log = createHookLogger("babysitter-opencode-stop-hook");
+    log.info("handleStopHook started (opencode)");
+    // 1. Read hook input JSON from stdin (if available)
+    let rawInput;
+    try {
+        rawInput = await readStdin();
+    }
+    catch {
+        rawInput = "";
+    }
+    finally {
+        if (typeof process.stdin.unref === "function") {
+            process.stdin.unref();
+        }
+    }
+    const hookInput = parseHookInput(rawInput);
+    // 2. Resolve session ID
+    const sessionId = safeStr(hookInput, "session_id") ||
+        process.env.BABYSITTER_SESSION_ID ||
+        process.env.OPENCODE_SESSION_ID ||
+        "";
+    if (!sessionId) {
+        log.info("No session ID — allowing exit");
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    log.setContext("session", sessionId);
+    // 3. Resolve state directory and read session state
+    const stateDir = resolveStateDirInternal(args);
+    const runsDir = args.runsDir || ".a5c/runs";
+    const filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    let sessionFile;
+    try {
+        if (!(await (0, session_1.sessionFileExists)(filePath))) {
+            log.info("No active session — allowing exit");
+            process.stdout.write("{}\n");
+            return 0;
+        }
+        sessionFile = await (0, session_1.readSessionFile)(filePath);
+    }
+    catch {
+        log.warn("Session file read error — allowing exit");
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    const { state } = sessionFile;
+    const runId = state.runId ?? "";
+    // 4. Check max iterations
+    if (state.maxIterations > 0 && state.iteration >= state.maxIterations) {
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] Max iterations (${state.maxIterations}) reached\n`);
+        }
+        await cleanupSession(filePath);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    // 5. If no run is bound, allow exit
+    if (!runId) {
+        log.info("No run associated with session — allowing exit");
+        await cleanupSession(filePath);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    log.setContext("run", runId);
+    // 6. Get run state
+    let runState = "";
+    let pendingKinds = "";
+    try {
+        const runDir = path.isAbsolute(runId)
+            ? runId
+            : path.join(runsDir, runId);
+        void (0, runFiles_1.readRunMetadata)(runDir);
+        const journal = await (0, journal_1.loadJournal)(runDir);
+        const index = await (0, effectIndex_1.buildEffectIndex)({ runDir, events: journal });
+        const hasCompleted = journal.some((e) => e.type === "RUN_COMPLETED");
+        const hasFailed = journal.some((e) => e.type === "RUN_FAILED");
+        const pendingRecords = index.listPendingEffects();
+        const pendingByKind = countPendingByKind(pendingRecords);
+        const kindKeys = Object.keys(pendingByKind);
+        if (kindKeys.length > 0) {
+            pendingKinds = kindKeys.join(", ");
+        }
+        if (hasCompleted) {
+            runState = "completed";
+        }
+        else if (hasFailed) {
+            runState = "failed";
+        }
+        else if (pendingRecords.length > 0) {
+            runState = "waiting";
+        }
+        else {
+            runState = "created";
+        }
+    }
+    catch {
+        runState = "";
+    }
+    log.info(`Run state: ${runState || "unknown"}`);
+    // 7. Allow exit if run is completed, failed, or state is unknown
+    if (runState === "completed" || runState === "failed" || !runState) {
+        await cleanupSession(filePath);
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    // 8. Run still in progress — output block decision with context
+    const nextIteration = state.iteration + 1;
+    const currentTime = (0, session_1.getCurrentTimestamp)();
+    const updatedState = {
+        ...state,
+        iteration: nextIteration,
+        lastIterationAt: currentTime,
+    };
+    try {
+        await (0, session_1.writeSessionFile)(filePath, updatedState, sessionFile.prompt ?? "");
+    }
+    catch {
+        log.warn("Failed to update session state");
+    }
+    const output = {
+        decision: "block",
+        reason: pendingKinds
+            ? `Babysitter iteration ${nextIteration} | Waiting on: ${pendingKinds}. Call 'babysitter run:iterate .a5c/runs/${runId} --json'.`
+            : `Babysitter iteration ${nextIteration} | Continue orchestration: call 'babysitter run:iterate .a5c/runs/${runId} --json'.`,
+    };
+    log.info(`Decision: block (iteration=${nextIteration})`);
+    if (verbose) {
+        process.stderr.write(`[hook:run stop] Blocking, iteration=${nextIteration}\n`);
+    }
+    process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// SessionStart hook handler
+// ---------------------------------------------------------------------------
+async function handleSessionStartHookImpl(args) {
+    const { verbose } = args;
+    const log = createHookLogger("babysitter-opencode-session-start-hook");
+    log.info("handleSessionStartHook started (opencode)");
+    // 1. Read hook input JSON from stdin
+    let rawInput;
+    try {
+        rawInput = await readStdin();
+    }
+    catch {
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    finally {
+        if (typeof process.stdin.unref === "function") {
+            process.stdin.unref();
+        }
+    }
+    const hookInput = parseHookInput(rawInput);
+    // 2. Resolve session ID
+    //    OpenCode does NOT auto-inject env vars — the babysitter plugin's
+    //    shell.env hook self-injects BABYSITTER_SESSION_ID.
+    const sessionId = safeStr(hookInput, "session_id") ||
+        process.env.BABYSITTER_SESSION_ID ||
+        process.env.OPENCODE_SESSION_ID ||
+        "";
+    if (!sessionId) {
+        log.info("No session ID — skipping state file creation");
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    log.setContext("session", sessionId);
+    log.info(`Session ID: ${sessionId}`);
+    // 3. Resolve state directory and create baseline session file
+    const stateDir = resolveStateDirInternal(args);
+    log.info(`Resolved stateDir: ${stateDir}`);
+    const filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    try {
+        if (!(await (0, session_1.sessionFileExists)(filePath))) {
+            const nowTs = (0, session_1.getCurrentTimestamp)();
+            const state = {
+                active: true,
+                iteration: 1,
+                maxIterations: 256,
+                runId: "",
+                startedAt: nowTs,
+                lastIterationAt: nowTs,
+                iterationTimes: [],
+            };
+            await (0, session_1.writeSessionFile)(filePath, state, "");
+            log.info(`Created session state: ${filePath}`);
+            if (verbose) {
+                process.stderr.write(`[hook:run session-start] Created session state: ${filePath}\n`);
+            }
+        }
+        else {
+            log.info(`Session state already exists: ${filePath}`);
+        }
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Failed to create session state: ${msg}`);
+        if (verbose) {
+            process.stderr.write(`[hook:run session-start] Failed to create session state: ${msg}\n`);
+        }
+    }
+    // 4. Output empty object
+    process.stdout.write("{}\n");
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Session binding (run:create flow)
+// ---------------------------------------------------------------------------
+async function bindSessionImpl(opts) {
+    const { sessionId, runId, maxIterations = 256, prompt, verbose } = opts;
+    // Resolve state directory
+    const stateDir = resolveStateDirInternal({
+        stateDir: opts.stateDir,
+        pluginRoot: opts.pluginRoot,
+    });
+    const filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    // Check for existing session (prevent re-entrant runs)
+    if (await (0, session_1.sessionFileExists)(filePath)) {
+        try {
+            const existing = await (0, session_1.readSessionFile)(filePath);
+            if (existing.state.runId && existing.state.runId !== runId) {
+                return {
+                    harness: HARNESS_NAME,
+                    sessionId,
+                    stateFile: filePath,
+                    error: `Session already associated with run: ${existing.state.runId}`,
+                };
+            }
+            // Update existing session with run ID
+            await (0, session_1.updateSessionState)(filePath, { runId, active: true }, { state: existing.state, prompt: existing.prompt });
+            if (verbose) {
+                process.stderr.write(`[run:create] Updated existing session ${sessionId} with run ${runId}\n`);
+            }
+            return { harness: HARNESS_NAME, sessionId, stateFile: filePath };
+        }
+        catch {
+            // Corrupted state file — overwrite
+        }
+    }
+    // Create new session state with run associated
+    const nowTs = (0, session_1.getCurrentTimestamp)();
+    const state = {
+        active: true,
+        iteration: 1,
+        maxIterations,
+        runId,
+        startedAt: nowTs,
+        lastIterationAt: nowTs,
+        iterationTimes: [],
+    };
+    try {
+        await (0, session_1.writeSessionFile)(filePath, state, prompt);
+    }
+    catch (e) {
+        return {
+            harness: HARNESS_NAME,
+            sessionId,
+            error: `Failed to write session state: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+    if (verbose) {
+        process.stderr.write(`[run:create] Session ${sessionId} initialized and bound to run ${runId}\n`);
+    }
+    return { harness: HARNESS_NAME, sessionId, stateFile: filePath };
+}
+// ---------------------------------------------------------------------------
+// Install helpers
+// ---------------------------------------------------------------------------
+function installOpenCodePlugin(_options) {
+    // OpenCode plugin installation is not yet automated.
+    // Plugins are JS/TS modules placed in .opencode/plugins/.
+    return {
+        harness: HARNESS_NAME,
+        summary: "OpenCode plugin installation is not yet automated. " +
+            "Place babysitter plugin files in .opencode/plugins/babysitter/ manually.",
+    };
+}
+// ---------------------------------------------------------------------------
+// Adapter factory
+// ---------------------------------------------------------------------------
+function createOpenCodeAdapter() {
+    return {
+        name: HARNESS_NAME,
+        isActive() {
+            // OpenCode does NOT inject distinctive env vars into plugin subprocesses.
+            // The babysitter plugin's shell.env hook self-injects BABYSITTER_SESSION_ID.
+            // OPENCODE_CONFIG is a real OpenCode env var that indicates OpenCode context.
+            return !!(process.env.BABYSITTER_SESSION_ID ||
+                process.env.OPENCODE_CONFIG);
+        },
+        autoResolvesSessionId() {
+            // OpenCode does not natively inject session IDs — the babysitter
+            // plugin's shell.env hook self-injects BABYSITTER_SESSION_ID.
+            return false;
+        },
+        getMissingSessionIdHint() {
+            return ("OpenCode does not auto-inject session IDs. Use --session-id explicitly, " +
+                "or ensure the babysitter plugin's shell.env hook is configured to set " +
+                "BABYSITTER_SESSION_ID.");
+        },
+        supportsHookType(hookType) {
+            // OpenCode plugin hooks: session.created, session.idle,
+            // tool.execute.before, tool.execute.after, shell.env
+            // Maps to SDK hook types:
+            //   session-start → session.created
+            //   pre-tool-use  → tool.execute.before
+            //   post-tool-use → tool.execute.after
+            // Note: NO stop hook — session.idle is fire-and-forget
+            const supported = [
+                "session-start",
+                "pre-tool-use",
+                "post-tool-use",
+            ];
+            return supported.includes(hookType);
+        },
+        getUnsupportedHookMessage(hookType) {
+            if (hookType === "stop") {
+                return ("OpenCode does not support a blocking stop hook. " +
+                    "The session.idle event is fire-and-forget. " +
+                    "Use in-turn orchestration or the SDK loop driver instead.");
+            }
+            return `Hook type "${hookType}" is not supported by the OpenCode adapter.`;
+        },
+        getCapabilities() {
+            // No StopHook, no SessionBinding natively, no MCP.
+            // HeadlessPrompt via @opencode-ai/sdk programmatic API.
+            return [types_1.HarnessCapability.HeadlessPrompt];
+        },
+        resolveSessionId(parsed) {
+            return resolveSessionIdInternal(parsed);
+        },
+        resolveStateDir(args) {
+            return resolveStateDirInternal(args);
+        },
+        resolvePluginRoot(args) {
+            const root = args.pluginRoot ||
+                process.env.OPENCODE_PLUGIN_ROOT;
+            return root ? path.resolve(root) : undefined;
+        },
+        bindSession(opts) {
+            return bindSessionImpl(opts);
+        },
+        handleStopHook(args) {
+            return handleStopHookImpl(args);
+        },
+        handleSessionStartHook(args) {
+            return handleSessionStartHookImpl(args);
+        },
+        findHookDispatcherPath(startCwd) {
+            // OpenCode plugins are in .opencode/plugins/, not standalone scripts.
+            // Walk up from startCwd looking for .opencode/plugins/babysitter/
+            let current = path.resolve(startCwd);
+            const root = path.parse(current).root;
+            while (current !== root) {
+                const candidate = path.join(current, ".opencode", "plugins", "babysitter", "index.js");
+                if ((0, node_fs_1.existsSync)(candidate))
+                    return candidate;
+                const tsCandidate = path.join(current, ".opencode", "plugins", "babysitter", "index.ts");
+                if ((0, node_fs_1.existsSync)(tsCandidate))
+                    return tsCandidate;
+                current = path.dirname(current);
+            }
+            return null;
+        },
+        installPlugin(options) {
+            return Promise.resolve(installOpenCodePlugin(options));
+        },
+        getPromptContext(opts) {
+            return (0, context_1.createOpenCodeContext)(opts);
+        },
+    };
+}

package/dist/harness/pi.d.ts

@@ -1,14 +1,4 @@
-/**
- * Oh-My-Pi harness adapter.
- *
- * Extends the SDK harness layer with "pi" support while reusing the
- * mature Claude stop/session-start hook handlers. The Pi adapter maps
- * Oh-My-Pi-specific environment conventions to the generic adapter interface.
- */
 import type { HarnessAdapter, HarnessInstallOptions, HarnessInstallResult } from "./types";
-export declare function installPiFamilyPlugin(args: {
-    harness: "pi" | "oh-my-pi";
-    options: HarnessInstallOptions;
-}): Promise<HarnessInstallResult>;
+export declare function installPiPlugin(options: HarnessInstallOptions): Promise<HarnessInstallResult>;
 export declare function createPiAdapter(): HarnessAdapter;
 //# sourceMappingURL=pi.d.ts.map

package/dist/harness/pi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../src/harness/pi.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EACV,cAAc,EAGd,qBAAqB,EACrB,oBAAoB,EAGrB,MAAM,SAAS,CAAC;AAsEjB,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,IAAI,GAAG,UAAU,CAAC;IAC3B,OAAO,EAAE,qBAAqB,CAAC;CAChC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA+BhC;AAED,wBAAgB,eAAe,IAAI,cAAc,CA6GhD"}
+{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../src/harness/pi.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EAGd,qBAAqB,EACrB,oBAAoB,EAGrB,MAAM,SAAS,CAAC;AAwHjB,wBAAsB,eAAe,CACnC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC,CAM/B;AAED,wBAAgB,eAAe,IAAI,cAAc,CAmFhD"}