kernelpm 0.1.0

package/dist/opencodeDriver.js

@@ -0,0 +1,611 @@
+"use strict";
+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.ServeOpencodeDriver = void 0;
+/**
+ * The kernelpm opencode driver.
+ *
+ * A driver operates exactly one opencode session. Instead of scraping an
+ * interactive TTY, it talks to a headless `opencode serve` process over HTTP:
+ * it creates the session, sends prompts through the async prompt endpoint and
+ * reads the conversation back from the server-sent event stream, normalizing
+ * opencode's structured parts into kernelpm chat events.
+ *
+ * Like the previous tmux/claude driver, auto-approval is structural: the serve
+ * process is launched with an inline permission config that allows everything,
+ * so opencode never stops to ask.
+ *
+ * One `opencode serve` process is run per session (scoped to the session's
+ * working directory, since opencode binds the cwd at server start). The port
+ * and opencode session id are persisted so a restarted daemon can reattach to
+ * the surviving serve instead of orphaning it.
+ */
+const child_process_1 = require("child_process");
+const net = __importStar(require("net"));
+const decisions_1 = require("./decisions");
+const POLL_MS = 1000;
+const HEALTH_TIMEOUT_MS = 30_000;
+const MAX_TOOL_SUMMARY = 400;
+/**
+ * Inline permission config: allow everything, including the two safety guards
+ * that default to "ask". Matches the old `--permission-mode bypassPermissions`.
+ */
+const ALLOW_ALL_PERMISSION = JSON.stringify({
+    '*': 'allow',
+    edit: 'allow',
+    bash: 'allow',
+    webfetch: 'allow',
+    task: 'allow',
+    external_directory: 'allow',
+    doom_loop: 'allow',
+});
+class ServeOpencodeDriver {
+    sessionId;
+    cwd;
+    title;
+    opts;
+    cb;
+    port = 0;
+    baseUrl = '';
+    child = null;
+    exited = false;
+    pollTimer = null;
+    opencodeId;
+    /** opencode session id of the most recently seen assistant message. */
+    lastAssistantMessageId = null;
+    lastAssistantText = '';
+    /** Accumulated parts per opencode message id (insertion-ordered). */
+    partsByMessage = new Map();
+    messageInfo = new Map();
+    emittedText = new Set();
+    emittedToolStart = new Set();
+    emittedToolEnd = new Set();
+    emittedTurn = new Set();
+    abort = null;
+    status = 'starting';
+    constructor(sessionId, cwd, title, opts, cb, initial) {
+        this.sessionId = sessionId;
+        this.cwd = cwd;
+        this.title = title;
+        this.opts = opts;
+        this.cb = cb;
+        this.opencodeId = initial?.opencodeId ?? null;
+        if (initial?.opencodePort)
+            this.port = initial.opencodePort;
+    }
+    async start(resume) {
+        this.emitStatus('starting');
+        await this.launchOrAttachServe();
+        await this.ensureSession(resume);
+        this.startStreaming();
+        this.startPoll();
+    }
+    async sendMessage(text) {
+        await this.prompt(text);
+        this.emitStatus('working');
+    }
+    async answer(option) {
+        await this.prompt(option.send);
+        this.emitStatus('working');
+    }
+    async isAlive() {
+        if (this.exited)
+            return false;
+        try {
+            const r = await this.http('/global/health');
+            return r.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    detach() {
+        this.stopWatching();
+    }
+    async kill() {
+        this.stopWatching();
+        if (this.opencodeId) {
+            try {
+                await this.http(`/session/${this.opencodeId}`, { method: 'DELETE' });
+            }
+            catch {
+                /* session may already be gone */
+            }
+        }
+        this.killServe();
+        this.emitStatus('exited');
+    }
+    /* --------------------------------- lifecycle ------------------------------- */
+    /** Reuse the surviving serve on the known port, or spawn a fresh one. */
+    async launchOrAttachServe() {
+        if (this.port && (await this.probeServe(this.port))) {
+            this.baseUrl = `http://127.0.0.1:${this.port}`;
+            return;
+        }
+        this.port = await freePort();
+        this.baseUrl = `http://127.0.0.1:${this.port}`;
+        const args = ['serve', '--port', String(this.port), '--hostname', '127.0.0.1'];
+        const env = { ...process.env, OPENCODE_PERMISSION: ALLOW_ALL_PERMISSION };
+        if (this.opts.model)
+            env.OPENCODE_CONFIG_CONTENT = JSON.stringify({ model: this.opts.model });
+        this.child = (0, child_process_1.spawn)('opencode', args, { cwd: this.cwd, env, stdio: ['ignore', 'inherit', 'inherit'] });
+        this.child.on('exit', () => {
+            this.exited = true;
+            this.emitStatus('exited');
+            this.stopWatching();
+        });
+        this.child.on('error', (err) => {
+            console.error(`[kernelpm] opencode serve error for ${this.sessionId}:`, err.message);
+        });
+        if (!(await this.waitForHealth())) {
+            throw new Error(this.exited
+                ? '`opencode serve` exited during startup — is opencode installed and logged in?'
+                : '`opencode serve` did not become healthy in time');
+        }
+        this.cb.onServeInfo?.({ opencodePort: this.port });
+    }
+    async ensureSession(resume) {
+        if (resume && this.opencodeId && (await this.sessionExists(this.opencodeId))) {
+            await this.seedFromHistory();
+            return;
+        }
+        this.opencodeId = await this.createSession();
+        this.cb.onServeInfo?.({ opencodeId: this.opencodeId });
+    }
+    async createSession() {
+        const body = {};
+        if (this.title)
+            body.title = this.title;
+        const r = await this.http('/session', { method: 'POST', body: JSON.stringify(body) });
+        if (!r.ok)
+            throw new Error(`could not create opencode session: ${await errText(r)}`);
+        const j = (await r.json());
+        return j.id;
+    }
+    async sessionExists(id) {
+        try {
+            const r = await this.http(`/session/${id}`);
+            return r.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Mark existing history as already-emitted so a reattach doesn't replay it. */
+    async seedFromHistory() {
+        const messages = await this.listMessages();
+        for (const m of messages) {
+            this.messageInfo.set(m.info.id, m.info);
+            const map = new Map();
+            this.partsByMessage.set(m.info.id, map);
+            for (const part of m.parts ?? []) {
+                map.set(part.id, part);
+                this.emittedText.add(part.id);
+                if (part.type === 'tool') {
+                    this.emittedToolStart.add(part.id);
+                    this.emittedToolEnd.add(part.id);
+                }
+            }
+            if (m.info.role === 'assistant' && m.info.time?.completed) {
+                this.emittedTurn.add(m.info.id);
+                this.lastAssistantMessageId = m.info.id;
+            }
+        }
+        this.cb.onServeInfo?.({ opencodeId: this.opencodeId });
+    }
+    /* ---------------------------------- watching ------------------------------- */
+    startStreaming() {
+        this.abort = new AbortController();
+        void this.runEventStream(this.abort.signal);
+    }
+    startPoll() {
+        if (this.pollTimer)
+            return;
+        this.pollTimer = setInterval(() => {
+            if (this.exited) {
+                this.emitStatus('exited');
+                this.stopWatching();
+            }
+        }, POLL_MS);
+    }
+    stopWatching() {
+        if (this.abort) {
+            this.abort.abort();
+            this.abort = null;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    async runEventStream(signal) {
+        while (!signal.aborted) {
+            try {
+                const r = await this.http('/event', { headers: { Accept: 'text/event-stream' }, signal });
+                if (!r.ok || !r.body) {
+                    if (this.exited)
+                        return;
+                    await delay(1000);
+                    continue;
+                }
+                await this.consumeSSE(r.body, signal);
+            }
+            catch (err) {
+                if (signal.aborted)
+                    return;
+                // network blip or serve gone — the exit handler / probe will surface it
+            }
+            if (!signal.aborted && !this.exited)
+                await delay(1000);
+        }
+    }
+    async consumeSSE(body, signal) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buf = '';
+        try {
+            while (!signal.aborted) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf('\n\n')) >= 0) {
+                    const raw = buf.slice(0, idx);
+                    buf = buf.slice(idx + 2);
+                    this.handleSSEEvent(raw);
+                }
+            }
+        }
+        catch {
+            /* stream closed — outer loop reconnects */
+        }
+        finally {
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                /* already released */
+            }
+        }
+    }
+    handleSSEEvent(raw) {
+        const data = raw
+            .split('\n')
+            .filter((l) => l.startsWith('data:'))
+            .map((l) => l.slice(5).replace(/^ /, ''))
+            .join('\n');
+        if (!data)
+            return;
+        let payload;
+        try {
+            payload = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        // `/global/event` wraps bus events; `/event` sends them raw. Tolerate both.
+        const ev = payload.payload ?? payload;
+        this.dispatchEvent(ev);
+    }
+    dispatchEvent(ev) {
+        if (!ev || typeof ev.type !== 'string')
+            return;
+        const p = ev.properties ?? {};
+        switch (ev.type) {
+            case 'message.part.updated':
+                this.onPart(p.part);
+                break;
+            case 'message.updated':
+                this.onMessage(p.info);
+                break;
+            case 'session.status':
+                this.onSessionStatus(p);
+                break;
+            case 'session.idle':
+                this.onSessionIdle(p);
+                break;
+            case 'session.updated':
+                this.onSessionUpdated(p.info);
+                break;
+            // message.removed / message.part.removed (revert), session.error, etc. are
+            // not part of kernelpm's append-only model — ignored.
+        }
+    }
+    onPart(part) {
+        if (!part || part.sessionID !== this.opencodeId)
+            return;
+        this.storePart(part);
+        if (part.type === 'tool')
+            this.handleToolLive(part);
+        // If this part landed after its message already completed, flush now.
+        const info = this.messageInfo.get(part.messageID);
+        if (info && info.role === 'assistant' && info.time?.completed)
+            this.flushMessage(part.messageID);
+    }
+    onMessage(info) {
+        if (!info || info.sessionID !== this.opencodeId)
+            return;
+        this.messageInfo.set(info.id, info);
+        if (info.role === 'assistant') {
+            this.lastAssistantMessageId = info.id;
+            if (info.time?.completed)
+                this.flushMessage(info.id);
+        }
+    }
+    onSessionStatus(p) {
+        if (p.sessionID !== this.opencodeId || !p.status)
+            return;
+        if (p.status.type === 'busy' || p.status.type === 'retry')
+            this.emitStatus('working');
+        else if (p.status.type === 'idle')
+            this.handleIdle();
+    }
+    onSessionIdle(p) {
+        if (p.sessionID !== this.opencodeId)
+            return;
+        this.handleIdle();
+    }
+    onSessionUpdated(info) {
+        if (!info || info.id !== this.opencodeId)
+            return;
+        if (typeof info.title === 'string' && info.title.trim() && info.title !== this.title) {
+            this.cb.onTitle(info.title.trim());
+        }
+    }
+    handleIdle() {
+        // Fallback for the rare case where a turn finished without a completed
+        // message.updated reaching us. flushMessage is idempotent.
+        if (this.lastAssistantMessageId)
+            this.flushMessage(this.lastAssistantMessageId);
+    }
+    /* ------------------------------- part emission ----------------------------- */
+    storePart(part) {
+        let m = this.partsByMessage.get(part.messageID);
+        if (!m) {
+            m = new Map();
+            this.partsByMessage.set(part.messageID, m);
+        }
+        m.set(part.id, part);
+    }
+    /** Stream tool start/result live as it happens (each is its own event). */
+    handleToolLive(part) {
+        const events = [];
+        this.emitToolEvents(part, events);
+        if (events.length) {
+            this.cb.onEvents(events);
+            const st = part.state?.status;
+            if (st === 'running' || st === 'pending')
+                this.emitStatus('working');
+        }
+    }
+    /** Emit tool_use (once) and tool_result (once on completion/error). */
+    emitToolEvents(part, events) {
+        const toolId = part.callID || part.id;
+        if (!this.emittedToolStart.has(part.id)) {
+            this.emittedToolStart.add(part.id);
+            events.push({
+                kind: 'tool_use',
+                toolId,
+                name: part.tool,
+                input: part.state?.input ?? {},
+            });
+        }
+        const st = part.state;
+        if (!st)
+            return;
+        if (st.status === 'completed' && !this.emittedToolEnd.has(part.id)) {
+            this.emittedToolEnd.add(part.id);
+            events.push({
+                kind: 'tool_result',
+                toolId,
+                ok: true,
+                summary: truncate(st.output || st.title || '', MAX_TOOL_SUMMARY),
+            });
+        }
+        else if (st.status === 'error' && !this.emittedToolEnd.has(part.id)) {
+            this.emittedToolEnd.add(part.id);
+            events.push({
+                kind: 'tool_result',
+                toolId,
+                ok: false,
+                summary: truncate(st.error || '', MAX_TOOL_SUMMARY),
+            });
+        }
+    }
+    /**
+     * Emit a finished assistant message in order: text/reasoning blocks and tool
+     * results, then a single `turn_complete`. Fires once per message. Text is
+     * message-granular (the whole block at once), matching how the app renders.
+     */
+    flushMessage(messageId) {
+        const info = this.messageInfo.get(messageId);
+        if (!info || info.role !== 'assistant' || !info.time?.completed)
+            return;
+        if (this.emittedTurn.has(messageId))
+            return;
+        const parts = this.partsByMessage.get(messageId);
+        const events = [];
+        let text = '';
+        if (parts) {
+            for (const part of parts.values()) {
+                if (part.type === 'text') {
+                    if (part.synthetic || part.ignored)
+                        continue;
+                    if (!this.emittedText.has(part.id)) {
+                        this.emittedText.add(part.id);
+                        events.push({ kind: 'assistant_text', text: part.text });
+                    }
+                    text += part.text;
+                }
+                else if (part.type === 'reasoning') {
+                    if (!this.emittedText.has(part.id)) {
+                        this.emittedText.add(part.id);
+                        events.push({ kind: 'assistant_thinking', text: part.text });
+                    }
+                }
+                else if (part.type === 'tool') {
+                    this.emitToolEvents(part, events);
+                    if (part.state?.status === 'completed')
+                        text += part.state.output || '';
+                }
+            }
+        }
+        events.push({ kind: 'turn_complete' });
+        this.emittedTurn.add(messageId);
+        this.lastAssistantMessageId = messageId;
+        this.lastAssistantText = text;
+        this.cb.onEvents(events);
+        const decision = (0, decisions_1.parseDecision)(text);
+        if (decision)
+            this.cb.onDecision(decision);
+        else
+            this.emitStatus('awaiting_input');
+    }
+    /* ---------------------------------- transport ------------------------------ */
+    async prompt(text) {
+        if (!this.opencodeId)
+            throw new Error('session not started');
+        const body = JSON.stringify({ parts: [{ type: 'text', text }] });
+        const r = await this.http(`/session/${this.opencodeId}/prompt_async`, {
+            method: 'POST',
+            body,
+        });
+        if (!r.ok && r.status !== 204) {
+            throw new Error(`opencode prompt failed: ${await errText(r)}`);
+        }
+    }
+    async listMessages() {
+        try {
+            const r = await this.http(`/session/${this.opencodeId}/message`);
+            if (!r.ok)
+                return [];
+            return (await r.json());
+        }
+        catch {
+            return [];
+        }
+    }
+    http(path, init = {}) {
+        return fetch(this.baseUrl + path, init);
+    }
+    async probeServe(port) {
+        try {
+            const r = await fetch(`http://127.0.0.1:${port}/global/health`);
+            if (!r.ok)
+                return false;
+            const j = (await r.json());
+            return j.healthy === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async waitForHealth() {
+        const start = Date.now();
+        while (Date.now() - start < HEALTH_TIMEOUT_MS) {
+            if (this.exited)
+                return false;
+            if (await this.probeServe(this.port))
+                return true;
+            await delay(250);
+        }
+        return false;
+    }
+    killServe() {
+        this.exited = true;
+        if (this.child) {
+            try {
+                this.child.kill('SIGTERM');
+            }
+            catch {
+                /* already gone */
+            }
+            const c = this.child;
+            setTimeout(() => {
+                try {
+                    if (!c.killed)
+                        c.kill('SIGKILL');
+                }
+                catch {
+                    /* ignore */
+                }
+            }, 3000).unref();
+            this.child = null;
+        }
+    }
+    emitStatus(status) {
+        if (status === this.status)
+            return;
+        this.status = status;
+        this.cb.onStatus(status);
+    }
+}
+exports.ServeOpencodeDriver = ServeOpencodeDriver;
+/* --------------------------------- helpers --------------------------------- */
+/** Grab an ephemeral free port from the OS for `opencode serve` to listen on. */
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.unref();
+        srv.on('error', reject);
+        srv.listen(0, '127.0.0.1', () => {
+            const addr = srv.address();
+            if (addr && typeof addr === 'object') {
+                const port = addr.port;
+                srv.close(() => resolve(port));
+            }
+            else {
+                srv.close();
+                reject(new Error('could not allocate a port'));
+            }
+        });
+    });
+}
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n) + '…' : s;
+}
+async function errText(r) {
+    try {
+        const t = await r.text();
+        return t.trim() || `${r.status} ${r.statusText}`;
+    }
+    catch {
+        return `${r.status} ${r.statusText}`;
+    }
+}

package/dist/protocol.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * kernelpm wire protocol.
+ *
+ * One JSON object per line, exchanged over the daemon's Unix control socket.
+ * The broker reuses these exact shapes app<->broker, wrapping each with a
+ * serverId for multiplexing (see backend/broker.ts). Keep this file dependency
+ * free — it is the single source of truth shared across daemon, broker and app.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTOCOL_VERSION = void 0;
+exports.PROTOCOL_VERSION = 1;