kernelpm 0.1.0

package/dist/daemon.js

@@ -0,0 +1,189 @@
+"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.Daemon = exports.DAEMON_VERSION = void 0;
+exports.controlSocketPath = controlSocketPath;
+exports.pidPath = pidPath;
+exports.ensureToken = ensureToken;
+/**
+ * The daemon: a registry of live sessions plus the fan-out to attached clients.
+ * It owns the durable store, recovers sessions on startup (reattaching to
+ * surviving opencode serve processes or resuming their sessions), and exposes
+ * the operations the control socket maps the wire protocol onto.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const store_1 = require("./store");
+const session_1 = require("./session");
+exports.DAEMON_VERSION = '0.1.0';
+/** Default model when a session doesn't specify one (GLM Coding Plan). */
+const DEFAULT_MODEL = 'zai-coding-plan/glm-5.2';
+function controlSocketPath() {
+    return path.join((0, store_1.kernelpmHome)(), 'control.sock');
+}
+function pidPath() {
+    return path.join((0, store_1.kernelpmHome)(), 'daemon.pid');
+}
+async function ensureToken(home) {
+    const p = path.join(home, 'token');
+    try {
+        const existing = (await fs.promises.readFile(p, 'utf8')).trim();
+        if (existing)
+            return existing;
+    }
+    catch {
+        /* generate below */
+    }
+    const token = (0, crypto_1.randomUUID)();
+    await fs.promises.writeFile(p, token, { encoding: 'utf8', mode: 0o600 });
+    return token;
+}
+class Daemon {
+    token;
+    store = new store_1.Store();
+    sessions = new Map();
+    subs = new Map(); // sessionId -> subscribers
+    clients = new Set();
+    constructor(token) {
+        this.token = token;
+    }
+    async init() {
+        await this.store.init();
+        for (const meta of this.store.list()) {
+            if (meta.status === 'exited')
+                continue;
+            const session = this.spawn(meta);
+            try {
+                await session.start(true); // reattach if alive, resume if not
+            }
+            catch (err) {
+                console.error(`[kernelpm] could not recover session ${meta.id}:`, err);
+            }
+        }
+    }
+    list() {
+        return this.store.list();
+    }
+    get(id) {
+        return this.store.get(id);
+    }
+    async create(cwd, title, model) {
+        const id = (0, crypto_1.randomUUID)();
+        const now = Date.now();
+        const meta = {
+            id,
+            title: title?.trim() || defaultTitle(cwd),
+            cwd,
+            status: 'starting',
+            lastSeq: 0,
+            pendingDecision: null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.store.upsert(meta);
+        const session = this.spawn(meta, model);
+        await session.start(false);
+        return this.store.get(id) ?? meta;
+    }
+    send(id, text) {
+        return this.require(id).sendMessage(text);
+    }
+    answer(id, decisionId, optionId) {
+        return this.require(id).answer(decisionId, optionId);
+    }
+    kill(id) {
+        return this.require(id).kill();
+    }
+    restart(id) {
+        return this.require(id).restart();
+    }
+    /* ------------------------------ client fan-out ----------------------------- */
+    addClient(c) {
+        this.clients.add(c);
+    }
+    dropClient(c) {
+        this.clients.delete(c);
+        for (const set of this.subs.values())
+            set.delete(c);
+    }
+    /** Subscribe a client and replay everything it missed since `sinceSeq`. */
+    async attachClient(c, id, rid, sinceSeq = 0) {
+        const meta = this.store.get(id);
+        if (!meta) {
+            c.send({ t: 'error', rid, message: 'no such session' });
+            return;
+        }
+        let set = this.subs.get(id);
+        if (!set)
+            this.subs.set(id, (set = new Set()));
+        set.add(c); // subscribe first so no live event is missed; clients dedupe by seq
+        c.send({ t: 'attached', rid, id, lastSeq: meta.lastSeq });
+        for (const event of await this.store.readEvents(id, sinceSeq)) {
+            c.send({ t: 'event', id, event });
+        }
+        c.send({ t: 'status', id, meta });
+        if (meta.pendingDecision)
+            c.send({ t: 'decision', id, decision: meta.pendingDecision });
+    }
+    detachClient(c, id) {
+        this.subs.get(id)?.delete(c);
+    }
+    broadcast(id, msg) {
+        const set = this.subs.get(id);
+        if (set)
+            for (const c of set)
+                c.send(msg);
+    }
+    /* --------------------------------- internals ------------------------------- */
+    spawn(meta, model) {
+        const session = new session_1.Session(this.store, meta, (msg) => this.broadcast(meta.id, msg), {
+            model: model ?? DEFAULT_MODEL,
+        });
+        this.sessions.set(meta.id, session);
+        return session;
+    }
+    require(id) {
+        const s = this.sessions.get(id);
+        if (!s)
+            throw new Error('no such session');
+        return s;
+    }
+}
+exports.Daemon = Daemon;
+function defaultTitle(cwd) {
+    const base = path.basename(cwd.replace(/[\\/]+$/, ''));
+    return base || cwd;
+}

package/dist/decisions.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDecision = parseDecision;
+/**
+ * Turning a finished assistant turn into a tappable option set.
+ *
+ * When Claude ends a turn by asking the user to pick between numbered choices,
+ * we surface those as a `Decision` so the app can render chips. This is a
+ * heuristic over free text and deliberately conservative: it only fires when
+ * the message both contains a sequential `1. 2. 3.`-style list AND reads like a
+ * question (an interrogative cue). Anything it misses still renders as a normal
+ * assistant message the user can reply to by typing.
+ */
+const crypto_1 = require("crypto");
+const OPTION_RE = /^\s*(\d+)[.)]\s+(.+?)\s*$/;
+const CUE_RE = /\b(which|choose|select|option|options|prefer|pick|proceed|do you want|would you like|shall i)\b|\?/i;
+function parseDecision(text) {
+    if (!text || !text.trim())
+        return null;
+    const lines = text.split('\n');
+    const items = [];
+    let firstIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const m = OPTION_RE.exec(lines[i]);
+        if (m) {
+            if (firstIdx < 0)
+                firstIdx = i;
+            items.push({ n: Number(m[1]), label: m[2] });
+        }
+    }
+    if (items.length < 2)
+        return null;
+    // Must be a clean 1..n sequence — avoids matching scattered numbers.
+    if (!items.every((it, idx) => it.n === idx + 1))
+        return null;
+    if (!CUE_RE.test(text))
+        return null;
+    const prompt = lastNonEmpty(lines.slice(0, firstIdx)) || 'Choose an option';
+    const options = items.map((it) => ({
+        id: String(it.n),
+        label: truncate(it.label, 120),
+        send: String(it.n),
+    }));
+    return { id: (0, crypto_1.randomUUID)(), prompt: truncate(prompt, 240), options, createdAt: Date.now() };
+}
+function lastNonEmpty(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const t = lines[i].trim();
+        if (t)
+            return t;
+    }
+    return '';
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n) + '…' : s;
+}

package/dist/files.js

@@ -0,0 +1,226 @@
+"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.resolveInside = resolveInside;
+exports.buildTree = buildTree;
+exports.readProjectFile = readProjectFile;
+/**
+ * Read-only project filesystem access for the app's file explorer / reader.
+ *
+ * Everything is scoped to a session's working directory. Where the cwd is a git
+ * worktree we lean on git for both the file set (tracked + untracked, honouring
+ * .gitignore) and per-file status / diffs; otherwise we fall back to a plain,
+ * bounded directory walk. No writes ever happen here.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+/** Cap the tree so a huge (or non-git) directory can't blow up the payload. */
+const MAX_FILES = 5000;
+/** Cap a single file read (bytes). */
+const MAX_FILE_BYTES = 512 * 1024;
+function run(cmd, args, cwd) {
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)(cmd, args, { cwd, maxBuffer: 32 * 1024 * 1024 }, (err, stdout, stderr) => {
+            const code = err && typeof err.code === 'number' ? err.code : err ? 1 : 0;
+            resolve({ code, stdout: stdout ?? '', stderr: stderr ?? '' });
+        });
+    });
+}
+function fileType(name) {
+    return /\.(ts|tsx)$/.test(name) ? 'ts' : 'generic';
+}
+/** Resolve a project-relative path and refuse anything that escapes the cwd. */
+function resolveInside(cwd, rel) {
+    const base = path.resolve(cwd);
+    const abs = path.resolve(base, rel);
+    if (abs !== base && !abs.startsWith(base + path.sep)) {
+        throw new Error('path escapes the project directory');
+    }
+    return abs;
+}
+/** Map of project-relative path -> git status (modified | untracked). */
+async function gitStatus(cwd) {
+    const r = await run('git', ['status', '--porcelain', '-z'], cwd);
+    if (r.code !== 0)
+        return null; // not a git repo (or git missing)
+    const map = new Map();
+    const parts = r.stdout.split('\0').filter(Boolean);
+    for (let i = 0; i < parts.length; i++) {
+        const entry = parts[i];
+        const xy = entry.slice(0, 2);
+        let p = entry.slice(3);
+        // Renames/copies emit "old\0new"; the new path is the following token.
+        if (xy[0] === 'R' || xy[0] === 'C')
+            p = parts[++i] ?? p;
+        if (!p)
+            continue;
+        map.set(p, xy === '??' ? 'untracked' : 'modified');
+    }
+    return map;
+}
+/** The set of files to show: git-tracked + untracked (gitignore-aware). */
+async function gitFiles(cwd) {
+    const r = await run('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], cwd);
+    if (r.code !== 0)
+        return null;
+    return r.stdout.split('\0').filter(Boolean);
+}
+/** Fallback when cwd isn't a git repo: a bounded walk skipping heavy dirs. */
+async function walkFiles(cwd) {
+    const skip = new Set(['.git', 'node_modules', '.expo', 'dist', 'build', '.next', '.cache']);
+    const out = [];
+    const walk = async (dir, rel) => {
+        if (out.length >= MAX_FILES)
+            return;
+        let entries;
+        try {
+            entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (out.length >= MAX_FILES)
+                return;
+            if (e.name.startsWith('.git') || skip.has(e.name))
+                continue;
+            const childRel = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory())
+                await walk(path.join(dir, e.name), childRel);
+            else if (e.isFile())
+                out.push(childRel);
+        }
+    };
+    await walk(path.resolve(cwd), '');
+    return out;
+}
+/** Sort folders before files, alphabetically within each group. */
+function sortNodes(nodes) {
+    nodes.sort((a, b) => {
+        const af = a.type === 'folder';
+        const bf = b.type === 'folder';
+        return af === bf ? a.name.localeCompare(b.name) : af ? -1 : 1;
+    });
+    for (const n of nodes)
+        if (n.type === 'folder')
+            sortNodes(n.children);
+}
+/** Nest a flat list of relative file paths into a git-aware tree. */
+function nest(files, status) {
+    const root = [];
+    const folders = new Map();
+    for (const file of files) {
+        const parts = file.split('/');
+        let children = root;
+        let prefix = '';
+        for (let i = 0; i < parts.length - 1; i++) {
+            prefix = prefix ? `${prefix}/${parts[i]}` : parts[i];
+            let folder = folders.get(prefix);
+            if (!folder) {
+                folder = { name: parts[i], type: 'folder', path: prefix, children: [] };
+                folders.set(prefix, folder);
+                children.push(folder);
+            }
+            children = folder.children;
+        }
+        const name = parts[parts.length - 1];
+        children.push({ name, type: fileType(name), path: file, git: status?.get(file) ?? 'clean' });
+    }
+    sortNodes(root);
+    return root;
+}
+/** Build the git-aware file tree for a project working directory. */
+async function buildTree(cwd) {
+    const status = await gitStatus(cwd);
+    let files = await gitFiles(cwd);
+    if (!files)
+        files = await walkFiles(cwd);
+    if (files.length > MAX_FILES)
+        files = files.slice(0, MAX_FILES);
+    return nest(files, status);
+}
+/** Parse `git diff` output for one file into renderable diff lines. */
+function parseDiff(text) {
+    const out = [];
+    let oldNo = 0;
+    let newNo = 0;
+    let inHunk = false;
+    for (const line of text.split('\n')) {
+        if (line.startsWith('@@')) {
+            const m = /@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+            if (m) {
+                oldNo = Number(m[1]);
+                newNo = Number(m[2]);
+                inHunk = true;
+            }
+            continue;
+        }
+        if (!inHunk)
+            continue; // skip the diff/index/+++/--- header block
+        if (line.startsWith('\\'))
+            continue; // ""
+        const tag = line[0];
+        const code = line.slice(1);
+        if (tag === '+')
+            out.push({ type: 'add', newNo: newNo++, code });
+        else if (tag === '-')
+            out.push({ type: 'del', oldNo: oldNo++, code });
+        else
+            out.push({ type: 'ctx', oldNo: oldNo++, newNo: newNo++, code });
+    }
+    return out;
+}
+/** Read one project file: a diff when modified, otherwise its plain contents. */
+async function readProjectFile(cwd, rel) {
+    const abs = resolveInside(cwd, rel);
+    const status = await gitStatus(cwd);
+    const git = status?.get(rel) ?? 'clean';
+    if (git === 'modified') {
+        let d = (await run('git', ['diff', '--', rel], cwd)).stdout;
+        if (!d.trim())
+            d = (await run('git', ['diff', '--cached', '--', rel], cwd)).stdout;
+        const diff = parseDiff(d);
+        if (diff.length)
+            return { git, diff };
+        // staged-but-identical or binary: fall through to showing contents
+    }
+    const stat = await fs.promises.stat(abs);
+    if (stat.size > MAX_FILE_BYTES) {
+        return { git, lines: [`— archivo demasiado grande para mostrar (${Math.round(stat.size / 1024)} KB) —`] };
+    }
+    const text = await fs.promises.readFile(abs, 'utf8');
+    return { git, lines: text.split('\n') };
+}