@mnemom/mnemom 0.17.34-next.1 → 0.17.34-next.2

package/dist/host/owner.js

@@ -0,0 +1,121 @@
+/**
+ * Owner-side executor routes (S1 ROUTES exec_enroll, exec_enroll_poll, exec_list, exec_renew;
+ * C04). The owner's JWT is used for start, list and renew; the poll uses only the enrollment's
+ * poll secret. Nothing here is written to disk except the executor key, into the state file, by
+ * the caller. Bodies follow C04 (kind, runtime, contract_version declared at start); response
+ * fields beyond S1 are read defensively.
+ */
+import { randomUUID } from "node:crypto";
+import { routePath } from "../vendor/shared/durable-contract/routes.js";
+import { ENROLL_POLL_ERRORS } from "../vendor/shared/durable-contract/codes.js";
+import { errorCode } from "./client.js";
+export const EXECUTOR_CONTRACT = "durable-executor/v1";
+export function ownerApi(opts) {
+    const base = opts.apiUrl.replace(/\/+$/, "");
+    const send = async (url, method, auth, body) => {
+        const headers = { accept: "application/json" };
+        if (auth)
+            headers.authorization = `Bearer ${auth}`;
+        if (body !== undefined)
+            headers["content-type"] = "application/json";
+        if (method !== "GET")
+            headers["idempotency-key"] = randomUUID();
+        try {
+            const res = await opts.fetch(url, {
+                method,
+                headers,
+                ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            });
+            const text = await res.text();
+            let parsed = null;
+            try {
+                parsed = text ? JSON.parse(text) : null;
+            }
+            catch {
+                parsed = text;
+            }
+            return { status: res.status, body: parsed };
+        }
+        catch (e) {
+            return { status: 0, body: null, networkError: e.message };
+        }
+    };
+    return {
+        enrollStart: async (body) => send(`${base}${routePath("exec_enroll")}`, "POST", await opts.jwt(), body),
+        enrollPoll: (secret, approvalId) => send(`${base}${routePath("exec_enroll_poll")}`, "POST", secret, 
+        // The api reads the RFC 8628 device_code from the body; the Bearer copy stays for the auth class.
+        approvalId ? { device_code: secret, approval_id: approvalId } : { device_code: secret }),
+        list: async () => send(`${base}${routePath("exec_list")}`, "GET", await opts.jwt()),
+        renew: async (id) => send(`${base}${routePath("exec_renew", id)}`, "POST", await opts.jwt(), {}),
+    };
+}
+export function parseExecutorList(body) {
+    const arr = Array.isArray(body)
+        ? body
+        : body && typeof body === "object"
+            ? (body.executors ?? body.data)
+            : null;
+    if (!Array.isArray(arr))
+        return null;
+    const out = [];
+    for (const r of arr) {
+        if (!r || typeof r !== "object")
+            continue;
+        const o = r;
+        if (typeof o.id !== "string")
+            continue;
+        const g = typeof o.grant_expires_at === "string" ? Date.parse(o.grant_expires_at) : NaN;
+        const rl = o.risk_line_version;
+        out.push({
+            id: o.id.toLowerCase(),
+            revoked: o.revoked_at !== null && o.revoked_at !== undefined && o.revoked_at !== false,
+            grantExpiresAt: Number.isFinite(g) ? g : null,
+            riskLineVersion: typeof rl === "number"
+                ? rl
+                : typeof rl === "string" && /^\d+$/.test(rl)
+                    ? Number(rl)
+                    : null,
+            label: typeof o.label === "string" ? o.label : null,
+            orgId: typeof o.org_id === "string" ? o.org_id : null,
+        });
+    }
+    return out;
+}
+export function parseEnrollStart(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const o = body;
+    const secret = o.poll_secret ?? o.device_code;
+    if (typeof o.user_code !== "string" ||
+        typeof o.verification_uri_complete !== "string" ||
+        typeof secret !== "string")
+        return null;
+    return {
+        approvalId: typeof o.approval_id === "string" ? o.approval_id : null,
+        userCode: o.user_code,
+        verificationUri: o.verification_uri_complete,
+        expiresIn: typeof o.expires_in === "number" ? o.expires_in : 900,
+        interval: typeof o.interval === "number" && o.interval > 0 ? o.interval : 2,
+        pollSecret: secret,
+    };
+}
+export function classifyPoll(r) {
+    if (r.status === 200 || r.status === 201) {
+        const o = (r.body ?? {});
+        const id = o.executor_id;
+        const key = o.executor_key ?? o.key;
+        if (typeof id === "string" && typeof key === "string" && key !== "")
+            return { kind: "done", executorId: id.toLowerCase(), executorKey: key };
+        return { kind: "terminal", error: "malformed poll response" };
+    }
+    const e = errorCode(r.body);
+    if (e === "authorization_pending")
+        return { kind: "pending" };
+    if (e === "slow_down")
+        return { kind: "slow_down" };
+    if (e && ENROLL_POLL_ERRORS.includes(e))
+        return { kind: "terminal", error: e };
+    if (r.status === 0)
+        return { kind: "pending" };
+    return { kind: "terminal", error: e ?? `http ${r.status}` };
+}

package/dist/host/plist.d.ts

@@ -0,0 +1,16 @@
+export declare const THROTTLE_INTERVAL_S = 10;
+/** Env the installing shell may hand the daemon (values copied when set). */
+export declare const PLIST_ENV_PASS: string[];
+/** Never in a plist, whatever the allowlist says (static check, C12-R40). */
+export declare const PLIST_ENV_FORBIDDEN: RegExp;
+export interface PlistInput {
+    readonly label: string;
+    readonly programArguments: readonly string[];
+    readonly home: string;
+    readonly path: string;
+    readonly claudeBin: string;
+    readonly logFile: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+}
+export declare function plistEnv(input: PlistInput): Record<string, string>;
+export declare function renderPlist(input: PlistInput): string;

package/dist/host/plist.js

@@ -0,0 +1,85 @@
+/**
+ * The LaunchAgent plist (C12-R22, R27, R40; BACKBONE C2). User space, the instance label,
+ * absolute ProgramArguments ending in the hidden `agent host run`, RunAtLoad, KeepAlive,
+ * ThrottleInterval 10, AbandonProcessGroup, explicit PATH and HOME, the pinned claude path.
+ * EnvironmentVariables come from a closed allowlist: no secret, no MNEMOM_EXPERIMENTAL and no
+ * other experimental env (the daemon reads its gate from config.json).
+ */
+import { DAEMON_TEST_ENV_PASS } from "../durable/test-mode.mjs";
+export const THROTTLE_INTERVAL_S = 10;
+/** Env the installing shell may hand the daemon (values copied when set). */
+export const PLIST_ENV_PASS = [
+    "MNEMOM_API_URL",
+    "MNEMOM_GATEWAY_URL",
+    "MNEMOM_AGENT_GATEWAY",
+    "MNEMOM_HOST_INSTANCE",
+    "MNEMOM_HOST_TMUX_SOCKET",
+    "TMUX_TMPDIR",
+    "CLAUDE_CONFIG_DIR",
+    "TMPDIR",
+    "LANG",
+    "DISABLE_AUTOUPDATER",
+    "MNEMOM_DISABLE_AUTOUPDATE",
+    "MNEMOM_UPDATE_MODE",
+    ...DAEMON_TEST_ENV_PASS,
+];
+/** Never in a plist, whatever the allowlist says (static check, C12-R40). */
+export const PLIST_ENV_FORBIDDEN = /^(MNEMOM_EXPERIMENTAL|MNEMOM_API_KEY|MNEMOM_TOKEN|ANTHROPIC_API_KEY|.*_SECRET|.*_TOKEN)$/;
+const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+export function plistEnv(input) {
+    const out = {
+        HOME: input.home,
+        PATH: input.path,
+        MNEMOM_AGENT_CLI: input.claudeBin,
+    };
+    for (const k of PLIST_ENV_PASS) {
+        const v = input.env[k];
+        if (v)
+            out[k] = v;
+    }
+    return Object.fromEntries(Object.entries(out).filter(([k]) => !PLIST_ENV_FORBIDDEN.test(k)));
+}
+export function renderPlist(input) {
+    for (const a of input.programArguments)
+        if (!a)
+            throw new Error("empty ProgramArguments entry");
+    if (!input.programArguments[0].startsWith("/"))
+        throw new Error("ProgramArguments[0] must be absolute");
+    const env = plistEnv(input);
+    const lines = [
+        `<?xml version="1.0" encoding="UTF-8"?>`,
+        `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
+        `<plist version="1.0">`,
+        `<dict>`,
+        `\t<key>Label</key>`,
+        `\t<string>${xml(input.label)}</string>`,
+        `\t<key>ProgramArguments</key>`,
+        `\t<array>`,
+        ...input.programArguments.map((a) => `\t\t<string>${xml(a)}</string>`),
+        `\t</array>`,
+        `\t<key>RunAtLoad</key>`,
+        `\t<true/>`,
+        `\t<key>KeepAlive</key>`,
+        `\t<true/>`,
+        `\t<key>ThrottleInterval</key>`,
+        `\t<integer>${THROTTLE_INTERVAL_S}</integer>`,
+        `\t<key>AbandonProcessGroup</key>`,
+        `\t<true/>`,
+        `\t<key>WorkingDirectory</key>`,
+        `\t<string>${xml(input.home)}</string>`,
+        `\t<key>StandardOutPath</key>`,
+        `\t<string>${xml(input.logFile)}</string>`,
+        `\t<key>StandardErrorPath</key>`,
+        `\t<string>${xml(input.logFile)}</string>`,
+        `\t<key>EnvironmentVariables</key>`,
+        `\t<dict>`,
+        ...Object.keys(env)
+            .sort()
+            .flatMap((k) => [`\t\t<key>${xml(k)}</key>`, `\t\t<string>${xml(env[k])}</string>`]),
+        `\t</dict>`,
+        `</dict>`,
+        `</plist>`,
+        ``,
+    ];
+    return lines.join("\n");
+}

package/dist/host/procs.d.ts

@@ -0,0 +1,27 @@
+export interface PsRow {
+    readonly pid: number;
+    readonly ppid: number;
+    readonly argv: string;
+}
+export declare function parsePs(stdout: string): PsRow[];
+export declare function psTable(): PsRow[];
+/** The roots and every descendant, roots first. */
+export declare function treeOf(rows: readonly PsRow[], roots: readonly number[]): number[];
+export declare const isClaudeArgv: (argv: string) => boolean;
+export declare const isSeatProxyArgv: (argv: string) => boolean;
+export interface ProcDeps {
+    readonly ps: () => PsRow[];
+    readonly kill: (pid: number, sig: NodeJS.Signals | 0) => void;
+}
+export declare const defaultProcDeps: () => ProcDeps;
+export declare function alive(deps: ProcDeps, pid: number | null | undefined): boolean;
+/**
+ * SIGSTOP the whole tree first (so nothing forks a new child between the walk and the kill),
+ * then SIGKILL every pid. Returns the pids signalled.
+ */
+export declare function killTree(deps: ProcDeps, roots: readonly number[]): number[];
+/** The seat's claude and proxy pids from the ps tree under the pane pid. */
+export declare function seatPids(rows: readonly PsRow[], panePid: number): {
+    claude: number | null;
+    proxy: number | null;
+};

package/dist/host/procs.js

@@ -0,0 +1,105 @@
+/**
+ * Process-tree helpers for seats (C12-R11, R17, R19, R22 M22): liveness by pid, and killing a
+ * seat's whole tree (claude and its children, not just the pane). Only pids the daemon resolved
+ * from its own tagged panes ever reach killTree (C12-R12).
+ */
+import { execFileSync } from "node:child_process";
+export function parsePs(stdout) {
+    const out = [];
+    for (const line of stdout.split("\n")) {
+        const m = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+        if (m)
+            out.push({ pid: Number(m[1]), ppid: Number(m[2]), argv: m[3] });
+    }
+    return out;
+}
+export function psTable() {
+    try {
+        return parsePs(execFileSync("/bin/ps", ["-axo", "pid=,ppid=,command="], {
+            encoding: "utf8",
+            maxBuffer: 32 * 1024 * 1024,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/** The roots and every descendant, roots first. */
+export function treeOf(rows, roots) {
+    const kids = new Map();
+    for (const r of rows) {
+        const k = kids.get(r.ppid);
+        if (k)
+            k.push(r.pid);
+        else
+            kids.set(r.ppid, [r.pid]);
+    }
+    const out = [];
+    const seen = new Set();
+    const stack = [...roots];
+    while (stack.length) {
+        const p = stack.shift();
+        if (seen.has(p) || p <= 1)
+            continue;
+        seen.add(p);
+        out.push(p);
+        for (const k of kids.get(p) ?? [])
+            stack.push(k);
+    }
+    return out;
+}
+export const isClaudeArgv = (argv) => /(^|\/)claude(\s|$)|\/claude\/versions\/|(^|\/)claude-shim/.test(argv.split(/\s+--/)[0] ?? "");
+export const isSeatProxyArgv = (argv) => /agent host seat-proxy/.test(argv);
+export const defaultProcDeps = () => ({
+    ps: psTable,
+    kill: (pid, sig) => process.kill(pid, sig),
+});
+export function alive(deps, pid) {
+    if (!pid || pid <= 1)
+        return false;
+    try {
+        deps.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+}
+/**
+ * SIGSTOP the whole tree first (so nothing forks a new child between the walk and the kill),
+ * then SIGKILL every pid. Returns the pids signalled.
+ */
+export function killTree(deps, roots) {
+    const pids = treeOf(deps.ps(), roots.filter((p) => p > 1));
+    for (const r of roots)
+        if (r > 1 && !pids.includes(r))
+            pids.push(r);
+    const send = (pid, sig) => {
+        try {
+            deps.kill(pid, sig);
+        }
+        catch {
+            /* gone already */
+        }
+    };
+    for (const p of pids)
+        send(p, "SIGSTOP");
+    for (const p of pids)
+        send(p, "SIGKILL");
+    return pids;
+}
+/** The seat's claude and proxy pids from the ps tree under the pane pid. */
+export function seatPids(rows, panePid) {
+    const tree = treeOf(rows, [panePid]);
+    const byPid = new Map(rows.map((r) => [r.pid, r]));
+    let claude = null;
+    let proxy = null;
+    for (const p of tree) {
+        const a = byPid.get(p)?.argv ?? "";
+        if (claude === null && isClaudeArgv(a))
+            claude = p;
+        if (proxy === null && isSeatProxyArgv(a))
+            proxy = p;
+    }
+    return { claude, proxy };
+}

package/dist/host/run.d.ts

@@ -0,0 +1,66 @@
+import { type HostPaths, type HostInstance } from "./instance.js";
+import { type LoadedState } from "./state.js";
+import { type AutoContinueDeps } from "./auto-continue.js";
+export interface RunIo {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly home: string;
+    readonly err: (line: string) => void;
+}
+/** A tag that names this HOME on a shared tmux server (not secret: a hash of the path). */
+export declare const homeTag: (home: string) => string;
+/** The pinned claude: MNEMOM_AGENT_CLI when absolute, else `claude` on PATH, else null. */
+export declare function resolveClaudeBin(env: Readonly<Record<string, string | undefined>>): string | null;
+/** The argv that runs this CLI again: node + the real entry script. */
+export declare function cliExec(): string[];
+type Startup = {
+    kind: "exit";
+    code: number;
+    message: string;
+} | {
+    kind: "go";
+    paths: HostPaths;
+    instance: HostInstance;
+};
+/** The read-only part of startup: what `run` does before it takes the lock. */
+export declare function startupCheck(io: RunIo): Startup;
+/**
+ * The boot-bound nonce (C12-R06), bound on first use: the first call compares the recorded boot id
+ * with the OS one, writes a rotated nonce when they differ (or the record is unusable), and caches
+ * the result; later calls return it with no I/O.
+ */
+export declare function lazyNonce(stateFile: string, loaded: LoadedState, bootId: string, log: (line: string) => void): () => string;
+export declare function hostRun(io: RunIo): Promise<number>;
+/**
+ * The runtime file is written only while this daemon still locks the current host.lock. A replaced
+ * lock file means another daemon may own the state dir: stop instead of writing over its runtime.
+ */
+export declare function publishIfLockHeld(held: () => boolean, write: () => void, lost: () => void): void;
+/** For tests and status: the OS boot id (macOS sysctl). */
+export declare function sysctlBootId(): string;
+export declare const defaultHome: () => string;
+/** The interrupted turn of the transcript at `p` (auto-continue.ts), or null when it cannot be read. */
+export declare function interruptedAtFile(p: string, read: (p: string) => string): string | null;
+/** The fs calls the auto-continue markers make. */
+export interface MarkerFs {
+    existsSync(p: string): boolean;
+    mkdirSync(p: string, o: {
+        recursive: true;
+        mode: number;
+    }): unknown;
+    writeFileSync(p: string, data: string, o: {
+        flag: string;
+    }): void;
+}
+/**
+ * The auto-continue markers: one file per session and turn in `dir` (0700). The write is exclusive
+ * ("wx"), so marking a turn already marked throws and that turn is never continued twice.
+ */
+export declare function fileContinuedMarkers(dir: string, f: MarkerFs): Pick<AutoContinueDeps, "continued" | "markContinued">;
+/** Write the runtime file; a failed write is logged and the daemon goes on. */
+export declare function writeRuntimeOrLog(write: () => void, log: (line: string) => void): void;
+/**
+ * The daemon's last step. Another daemon owns the control socket path now ("left"): leave with
+ * exit, since a normal exit would unlink that daemon's socket.
+ */
+export declare function exitIfSocketLeft(released: "closed" | "left", exit: (code: number) => void): void;
+export {};