kernelpm 0.1.0

package/dist/runtime.js

@@ -0,0 +1,153 @@
+"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.runDaemon = runDaemon;
+exports.startDaemonDetached = startDaemonDetached;
+exports.stopDaemon = stopDaemon;
+exports.isDaemonRunning = isDaemonRunning;
+/**
+ * Daemon lifecycle: run in the foreground, start detached (surviving SSH
+ * logout), stop, and probe whether it is up. The detached child re-invokes this
+ * same program with `daemon run`, preserving any loader flags (so it works both
+ * compiled and under tsx), with stdio redirected to daemon.log.
+ */
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const store_1 = require("./store");
+const daemon_1 = require("./daemon");
+const control_1 = require("./control");
+async function runDaemon() {
+    const home = (0, store_1.kernelpmHome)();
+    await fs.promises.mkdir(home, { recursive: true });
+    const token = await (0, daemon_1.ensureToken)(home);
+    const daemon = new daemon_1.Daemon(token);
+    await daemon.init();
+    const sockPath = (0, daemon_1.controlSocketPath)();
+    await safeUnlink(sockPath);
+    const server = (0, control_1.createControlServer)(daemon);
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(sockPath, () => resolve());
+    });
+    await fs.promises.writeFile((0, daemon_1.pidPath)(), String(process.pid), 'utf8');
+    console.log(`[kernelpm] daemon ${process.pid} listening on ${sockPath}`);
+    const shutdown = () => {
+        server.close();
+        safeUnlinkSync(sockPath);
+        safeUnlinkSync((0, daemon_1.pidPath)());
+        process.exit(0);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+}
+async function startDaemonDetached() {
+    const home = (0, store_1.kernelpmHome)();
+    await fs.promises.mkdir(home, { recursive: true });
+    if (await isDaemonRunning()) {
+        console.log('kernelpm daemon already running');
+        return;
+    }
+    const logFd = fs.openSync(path.join(home, 'daemon.log'), 'a');
+    const child = (0, child_process_1.spawn)(process.execPath, [...process.execArgv, process.argv[1], 'daemon', 'run'], { detached: true, stdio: ['ignore', logFd, logFd], env: process.env });
+    child.unref();
+    const up = await waitForSocket((0, daemon_1.controlSocketPath)(), 8000);
+    console.log(up
+        ? `kernelpm daemon started (pid ${child.pid})`
+        : 'kernelpm daemon did not come up in time — see daemon.log');
+}
+async function stopDaemon() {
+    let pid = 0;
+    try {
+        pid = Number((await fs.promises.readFile((0, daemon_1.pidPath)(), 'utf8')).trim());
+    }
+    catch {
+        /* no pid file */
+    }
+    if (pid) {
+        try {
+            process.kill(pid, 'SIGTERM');
+            console.log(`stopped kernelpm daemon ${pid}`);
+        }
+        catch {
+            console.log('kernelpm daemon not running');
+        }
+    }
+    else {
+        console.log('kernelpm daemon not running');
+    }
+    await safeUnlink((0, daemon_1.controlSocketPath)());
+}
+function isDaemonRunning() {
+    return new Promise((resolve) => {
+        const socket = net.createConnection((0, daemon_1.controlSocketPath)());
+        const finish = (v) => {
+            socket.destroy();
+            resolve(v);
+        };
+        socket.once('connect', () => finish(true));
+        socket.once('error', () => finish(false));
+        setTimeout(() => finish(false), 1000);
+    });
+}
+async function waitForSocket(_p, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await isDaemonRunning())
+            return true;
+        await delay(150);
+    }
+    return false;
+}
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function safeUnlink(p) {
+    try {
+        await fs.promises.unlink(p);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function safeUnlinkSync(p) {
+    try {
+        fs.unlinkSync(p);
+    }
+    catch {
+        /* ignore */
+    }
+}

package/dist/session.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+const opencodeDriver_1 = require("./opencodeDriver");
+class Session {
+    store;
+    meta;
+    push;
+    driver;
+    chain = Promise.resolve();
+    constructor(store, meta, push, opts = {}) {
+        this.store = store;
+        this.meta = meta;
+        this.push = push;
+        this.driver = new opencodeDriver_1.ServeOpencodeDriver(meta.id, meta.cwd, meta.title, opts, {
+            onEvents: (events) => this.onEvents(events),
+            onTitle: (title) => this.onTitle(title),
+            onStatus: (status) => this.onStatus(status),
+            onDecision: (decision) => this.onDecision(decision),
+            onServeInfo: (patch) => this.onServeInfo(patch),
+        }, { opencodeId: meta.opencodeId, opencodePort: meta.opencodePort });
+    }
+    start(resume) {
+        return this.driver.start(resume);
+    }
+    sendMessage(text) {
+        return this.enqueue(async () => {
+            if (this.meta.pendingDecision)
+                await this.clearDecision();
+            await this.driver.sendMessage(text);
+        });
+    }
+    answer(decisionId, optionId) {
+        return this.enqueue(async () => {
+            const d = this.meta.pendingDecision;
+            if (!d || d.id !== decisionId)
+                throw new Error('no matching pending decision');
+            const option = d.options.find((o) => o.id === optionId);
+            if (!option)
+                throw new Error('no such option');
+            await this.appendBody({ kind: 'user_text', text: option.label }); // show the pick
+            await this.clearDecision();
+            await this.driver.answer(option);
+        });
+    }
+    kill() {
+        return this.driver.kill();
+    }
+    restart() {
+        return this.driver.start(true);
+    }
+    detach() {
+        this.driver.detach();
+    }
+    /* ------------------------------ driver glue ------------------------------- */
+    onEvents(events) {
+        for (const body of events)
+            void this.enqueue(() => this.appendBody(body));
+    }
+    onTitle(title) {
+        void this.enqueue(() => this.patchMeta({ title }));
+    }
+    onStatus(status) {
+        void this.enqueue(() => this.patchMeta({ status }));
+    }
+    onDecision(decision) {
+        void this.enqueue(async () => {
+            await this.patchMeta({ pendingDecision: decision, status: 'awaiting_decision' });
+            this.push({ t: 'decision', id: this.meta.id, decision });
+        });
+    }
+    onServeInfo(patch) {
+        void this.enqueue(() => this.patchMeta(patch));
+    }
+    /* ------------------------------- primitives ------------------------------- */
+    async appendBody(body) {
+        const event = await this.store.append(this.meta.id, body);
+        if (!event)
+            return;
+        const m = this.store.get(this.meta.id);
+        if (m)
+            this.meta = m;
+        this.push({ t: 'event', id: this.meta.id, event });
+    }
+    async patchMeta(patch) {
+        const m = await this.store.patch(this.meta.id, patch);
+        if (m) {
+            this.meta = m;
+            this.push({ t: 'status', id: m.id, meta: m });
+        }
+    }
+    clearDecision() {
+        return this.patchMeta({ pendingDecision: null });
+    }
+    /** Serialize all store writes + pushes for this session. */
+    enqueue(fn) {
+        const next = this.chain.then(fn, fn);
+        this.chain = next.catch(() => undefined);
+        return next;
+    }
+}
+exports.Session = Session;

package/dist/store.js

@@ -0,0 +1,145 @@
+"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.Store = void 0;
+exports.kernelpmHome = kernelpmHome;
+/**
+ * Durable daemon state.
+ *
+ * Session metadata lives in `<KERNELPM_HOME>/sessions.json`; each session's
+ * normalized chat is an append-only log at `sessions/<id>.jsonl`. Together they
+ * let a reconnecting client (or a restarted daemon) rebuild every chat exactly,
+ * replaying only what a client missed via `readEvents(id, sinceSeq)`.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function kernelpmHome() {
+    return process.env.KERNELPM_HOME || path.join(os.homedir(), '.kernelpm');
+}
+class Store {
+    home = kernelpmHome();
+    sessionsDir = path.join(this.home, 'sessions');
+    statePath = path.join(this.home, 'sessions.json');
+    meta = new Map();
+    appendChains = new Map();
+    async init() {
+        await fs.promises.mkdir(this.sessionsDir, { recursive: true });
+        try {
+            const parsed = JSON.parse(await fs.promises.readFile(this.statePath, 'utf8'));
+            for (const [id, m] of Object.entries(parsed.sessions ?? {}))
+                this.meta.set(id, m);
+        }
+        catch {
+            /* fresh install */
+        }
+    }
+    list() {
+        return [...this.meta.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    get(id) {
+        return this.meta.get(id);
+    }
+    async upsert(meta) {
+        this.meta.set(meta.id, meta);
+        await this.persistMeta();
+    }
+    async patch(id, patch) {
+        const cur = this.meta.get(id);
+        if (!cur)
+            return undefined;
+        const next = { ...cur, ...patch, updatedAt: Date.now() };
+        this.meta.set(id, next);
+        await this.persistMeta();
+        return next;
+    }
+    /** Append one event, assigning the next seq. Persists the log line + meta. */
+    async append(id, body) {
+        const cur = this.meta.get(id);
+        if (!cur)
+            return undefined;
+        const event = { seq: cur.lastSeq + 1, ts: Date.now(), body };
+        cur.lastSeq = event.seq;
+        cur.updatedAt = event.ts;
+        await this.serializeAppend(id, () => fs.promises.appendFile(this.logPath(id), JSON.stringify(event) + '\n', 'utf8'));
+        await this.persistMeta();
+        return event;
+    }
+    async readEvents(id, sinceSeq = 0) {
+        let raw;
+        try {
+            raw = await fs.promises.readFile(this.logPath(id), 'utf8');
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const line of raw.split('\n')) {
+            if (!line)
+                continue;
+            try {
+                const ev = JSON.parse(line);
+                if (ev.seq > sinceSeq)
+                    out.push(ev);
+            }
+            catch {
+                /* skip corrupt line */
+            }
+        }
+        return out;
+    }
+    async remove(id) {
+        this.meta.delete(id);
+        await this.persistMeta();
+        await fs.promises.rm(this.logPath(id), { force: true });
+    }
+    logPath(id) {
+        return path.join(this.sessionsDir, `${id}.jsonl`);
+    }
+    /** Serialize appends per session so log lines never interleave. */
+    serializeAppend(id, fn) {
+        const prev = this.appendChains.get(id) ?? Promise.resolve();
+        const next = prev.then(fn, fn);
+        this.appendChains.set(id, next.catch(() => undefined));
+        return next;
+    }
+    async persistMeta() {
+        const state = { version: 1, sessions: Object.fromEntries(this.meta) };
+        const tmp = this.statePath + '.tmp';
+        await fs.promises.writeFile(tmp, JSON.stringify(state, null, 2), 'utf8');
+        await fs.promises.rename(tmp, this.statePath);
+    }
+}
+exports.Store = Store;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "kernelpm",
+  "version": "0.1.0",
+  "description": "kernelpm daemon — keeps opencode sessions alive on a server (via `opencode serve`) and exposes them over a local control socket.",
+  "license": "MIT",
+  "bin": {
+    "kernelpm": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx test/run.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.3.3"
+  }
+}