@aron98/load-lock 1.2.0 → 1.3.0

package/README.md

@@ -59,7 +59,8 @@ agent A (OpenCode)        agent B (Codex)         agent C (Claude Code)
 ```sh
 npm install -g @aron98/load-lock
 load-lock install --harness opencode     # or claude-code | codex | gemini-cli |
-                                         # copilot-cli | cline | roo-code | goose | generic
+                                         # copilot-cli | cline | roo-code | goose |
+                                         # omac (sandbox grants) | generic
 load-lock doctor
 ```
 
@@ -88,7 +89,7 @@ WSL2) share the host's budget instead of getting their own: bridge the
 daemon's Unix socket into the sandbox, set `LOAD_LOCK_NO_SPAWN=1` so the
 client never spawns a useless sandbox-local daemon, and optionally tag
 holds with `LOAD_LOCK_LABEL_PREFIX` (e.g. `bwrap:issue-42 build`).
-Ready-to-run per-sandbox recipes — live-verified for bubblewrap,
+Ready-to-run per-sandbox recipes — live-verified for bubblewrap and omac,
 contract-inspected for the rest, plus the cross-PID-namespace lease
 lifecycle — live in docs/OPERATIONS.md → "Sandboxes".
 

package/dist/adapters/opencode/tui.js

@@ -89,13 +89,17 @@ function dashboardLines(v, width, f) {
     const syncAge = v.lastSyncAt ? fmtDuration(Math.max(0, v.now - v.lastSyncAt)) : "never";
     push(`load-lock dashboard   ${STATE_LABEL[v.state] ?? v.state}   synced ${syncAge} ago`, stateColor(v.state, f));
     if (v.daemon) {
-        push(`daemon pid ${v.daemon.pid} · uptime ${fmtDuration(v.daemon.uptimeMs)} · config v${v.daemon.configVersion} · protocol v${v.daemon.protocolVersion} · events through #${v.latestEventId}`, f.dim);
+        push(`daemon pid ${v.daemon.pid} · uptime ${fmtDuration(v.daemon.uptimeMs)} · config v${v.daemon.configVersion} · protocol v${v.daemon.protocolVersion}` +
+            (v.daemon.daemonVersion ? ` · daemon v${v.daemon.daemonVersion}` : "") +
+            ` · events through #${v.latestEventId}`, f.dim);
     }
     else {
         push(`daemon unreachable — it auto-spawns on the next load-lock command`, f.dim);
     }
     if (v.daemonRestartNote)
         push(`note: ${v.daemonRestartNote}`, f.warn);
+    if (v.versionSkewNote)
+        push(`note: ${v.versionSkewNote}`, f.warn);
     if (v.machine) {
         const m = v.machine;
         const cg = m.cgroupCpuQuota != null ? ` · cgroup quota ${m.cgroupCpuQuota / 100} CPU` : "";

package/dist/cli/copies.d.ts

@@ -0,0 +1,28 @@
+export interface InstalledCopy {
+    /** Where this copy was found. */
+    source: "cli" | "path" | "opencode-cache";
+    /** Path of the copy's package root (its package.json's directory). */
+    path: string;
+    /** Version string, or null when the package.json could not be read. */
+    version: string | null;
+}
+/**
+ * Find the package.json of the @aron98/load-lock copy that contains the
+ * given file, by climbing parent directories. Best-effort: returns null if
+ * no enclosing package.json matches (or is readable).
+ */
+export declare function enclosingPackage(startDir: string, maxDepth?: number): {
+    path: string;
+    version: string | null;
+} | null;
+/** The copy of load-lock this process runs from (its own package root). */
+export declare function thisCopy(): InstalledCopy | null;
+/**
+ * All installed copies of load-lock detectable on this machine:
+ *  - "cli": the copy this process runs from.
+ *  - "path": any `load-lock` binary found on PATH (deduped by real path,
+ *    so a symlink to the running copy is recognized and not double-listed
+ *    — a copy is only listed under "path" when it differs from "cli").
+ *  - "opencode-cache": copies under opencode's private npm cache.
+ */
+export declare function findInstalledCopies(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): InstalledCopy[];

package/dist/cli/copies.js

@@ -0,0 +1,207 @@
+/**
+ * Installed-copy detection (issue #34): on a given machine several copies
+ * of load-lock commonly coexist — the globally-installed CLI on PATH, and
+ * the private copy opencode maintains under its npm cache (because
+ * `install --harness opencode` registers the bare package name, opencode
+ * installs and refreshes its own copy on its own schedule).
+ *
+ * All scanning is best-effort: missing paths, unreadable files, and
+ * unexpected layouts yield skipped entries or null versions — never a throw.
+ */
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { isWindows } from "../shared/transport.js";
+/** Package name of this package (used to find enclosing package roots). */
+const PKG_NAME = "@aron98/load-lock";
+/**
+ * Find the package.json of the @aron98/load-lock copy that contains the
+ * given file, by climbing parent directories. Best-effort: returns null if
+ * no enclosing package.json matches (or is readable).
+ */
+export function enclosingPackage(startDir, maxDepth = 12) {
+    let dir = startDir;
+    for (let i = 0; i < maxDepth; i++) {
+        const pkgPath = join(dir, "package.json");
+        try {
+            if (existsSync(pkgPath)) {
+                const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+                if (pkg?.name === PKG_NAME) {
+                    return { path: dir, version: typeof pkg.version === "string" ? pkg.version : null };
+                }
+                // A foreign package.json terminates the climb (e.g. a PATH bin
+                // inside some other tool's package).
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+/** The copy of load-lock this process runs from (its own package root). */
+export function thisCopy() {
+    // dist/cli/copies.js -> dist/cli -> ... -> <pkg>/package.json
+    const startDir = dirname(dirname(fileURLToPath(import.meta.url)));
+    const found = enclosingPackage(startDir);
+    if (!found)
+        return null;
+    return { source: "cli", path: found.path, version: found.version };
+}
+/**
+ * All installed copies of load-lock detectable on this machine:
+ *  - "cli": the copy this process runs from.
+ *  - "path": any `load-lock` binary found on PATH (deduped by real path,
+ *    so a symlink to the running copy is recognized and not double-listed
+ *    — a copy is only listed under "path" when it differs from "cli").
+ *  - "opencode-cache": copies under opencode's private npm cache.
+ */
+export function findInstalledCopies(platform = process.platform, env = process.env) {
+    const copies = [];
+    const seen = new Set();
+    const add = (c) => {
+        if (!c)
+            return;
+        let real;
+        try {
+            real = realpathSync(c.path);
+        }
+        catch {
+            real = c.path;
+        }
+        if (seen.has(real))
+            return;
+        seen.add(real);
+        copies.push(c);
+    };
+    add(thisCopy());
+    // --- PATH scan ------------------------------------------------------------
+    try {
+        const binNames = isWindows(platform)
+            ? ["load-lock.cmd", "load-lock.exe", "load-lock"]
+            : ["load-lock"];
+        const dirs = (env.PATH ?? "").split(isWindows(platform) ? ";" : ":").filter(Boolean);
+        for (const dir of dirs) {
+            for (const bin of binNames) {
+                try {
+                    const binPath = join(dir, bin);
+                    if (!statSync(binPath).isFile())
+                        continue;
+                    // A shim/wrapper script is not itself the copy — resolve through
+                    // its enclosing package (works for npm/bun global layouts where
+                    // the bin sits in <pkg>/bin or node_modules/.bin via a symlink).
+                    let realBin;
+                    try {
+                        realBin = realpathSync(binPath);
+                    }
+                    catch {
+                        realBin = binPath;
+                    }
+                    const found = enclosingPackage(dirname(realBin)) ?? enclosingPackage(dir);
+                    if (found)
+                        add({ source: "path", path: found.path, version: found.version });
+                }
+                catch {
+                    /* unreadable PATH entry — skip */
+                }
+            }
+        }
+    }
+    catch {
+        /* PATH scan is best-effort */
+    }
+    // --- opencode npm-cache scan ----------------------------------------------
+    // Layout (verified live): <cacheRoot>/opencode/npm/@aron98/load-lock@latest/<ts>/
+    // where "@aron98" and "load-lock@latest" are two nested directories (a
+    // normal npm scoped layout); URL-escaped single-directory variants like
+    // "@aron98%2Fload-lock@latest" also occur. Under each <ts>: either the
+    // real package at node_modules/@aron98/load-lock, or a top-level
+    // package.json (npm-install root).
+    try {
+        const cacheRoot = opencodeCacheRoot(platform, env);
+        if (cacheRoot) {
+            const npmDir = join(cacheRoot, "opencode", "npm");
+            if (existsSync(npmDir)) {
+                const scanTimestampDirs = (pkgBase) => {
+                    let tsDirs = [];
+                    try {
+                        tsDirs = readdirSync(pkgBase).filter((d) => statSync(join(pkgBase, d)).isDirectory());
+                    }
+                    catch {
+                        return;
+                    }
+                    for (const ts of tsDirs) {
+                        const nested = join(pkgBase, ts, "node_modules", "@aron98", "load-lock");
+                        const topLevel = join(pkgBase, ts);
+                        for (const cand of [nested, topLevel]) {
+                            try {
+                                const pkgPath = join(cand, "package.json");
+                                if (!existsSync(pkgPath))
+                                    continue;
+                                const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+                                if (pkg?.name !== PKG_NAME)
+                                    continue;
+                                add({
+                                    source: "opencode-cache",
+                                    path: cand,
+                                    version: typeof pkg.version === "string" ? pkg.version : null,
+                                });
+                                break;
+                            }
+                            catch {
+                                /* skip unreadable timestamp dir */
+                            }
+                        }
+                    }
+                };
+                let scopeDirs = [];
+                try {
+                    scopeDirs = readdirSync(npmDir).filter((d) => statSync(join(npmDir, d)).isDirectory());
+                }
+                catch {
+                    scopeDirs = [];
+                }
+                for (const scopeDir of scopeDirs) {
+                    if (scopeDir.startsWith("@aron98%2Fload-lock")) {
+                        // URL-escaped single-directory form.
+                        scanTimestampDirs(join(npmDir, scopeDir));
+                    }
+                    else if (scopeDir === "@aron98") {
+                        // Scoped layout: @aron98/<name>@<version-range>/<ts>/...
+                        let inner = [];
+                        try {
+                            inner = readdirSync(join(npmDir, scopeDir)).filter((d) => statSync(join(npmDir, scopeDir, d)).isDirectory());
+                        }
+                        catch {
+                            continue;
+                        }
+                        for (const nameDir of inner) {
+                            if (nameDir.startsWith("load-lock"))
+                                scanTimestampDirs(join(npmDir, scopeDir, nameDir));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        /* cache scan is best-effort */
+    }
+    return copies;
+}
+/** Cache root the way opencode resolves it (its npm cache lives under it). */
+function opencodeCacheRoot(platform, env) {
+    if (env.XDG_CACHE_HOME)
+        return env.XDG_CACHE_HOME;
+    if (platform === "win32")
+        return env.LOCALAPPDATA ?? null;
+    if (platform === "darwin")
+        return join(env.HOME ?? homedir(), "Library", "Caches");
+    return join(env.HOME ?? homedir(), ".cache");
+}

package/dist/cli/install.js

@@ -43,11 +43,22 @@
  *                   .cursor/rules/load-lock.mdc. Contract-tested against
  *                   the documented hooks JSON; not live-verified.
  *  - generic      : prints an MCP stdio config snippet (any MCP-capable harness).
+ *  - omac         : merges load-lock grants into omac's user-global sandbox
+ *                   profile (~/.config/omac/sandbox-profiles/default.json):
+ *                   filesystem.allow_unix_dir += the state dir (host-daemon
+ *                   socket bridge), filesystem.read += the installed package
+ *                   tree when load-lock lives outside any granted workdir
+ *                   (global bun/npm installs; gotcha verified live), and
+ *                   environment.allow_vars += "LOAD_LOCK_*". omac parses
+ *                   profiles strictly (unknown fields are errors) and never
+ *                   rewrites a profile it has created, so the installer only
+ *                   writes known fields and touches nothing else.
  */
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { POLICY_BRIEF } from "../policy/text.js";
+import { resolveStateDir } from "../shared/transport.js";
 const HOME = os.homedir();
 const PKG_NAME = "@aron98/load-lock";
 export function pkgRoot(binDir) {
@@ -948,6 +959,206 @@ function uninstallCursor(opts) {
     pruneEmptyDirs(cursorDir, cursorDir);
     return actions;
 }
+// --------------------------------------------------------------------- omac
+// omac (verified against 0.11.0) sandboxes agents with bubblewrap +
+// Landlock on Linux and strips the harness environment, allowing through
+// only what the user-global sandbox profile lists. Known profile fields
+// (strict parsing — unknown fields are hard errors): top-level `workdir`,
+// `network`, `filesystem`, `environment`; `workdir.access`,
+// `network.allow_domain`/`deny_domain`/`allow_tcp_connect`,
+// `filesystem.allow`/`read`/`write`/`allow_unix_dir`/`deny`,
+// `environment.allow_vars` — all lists of strings. omac never rewrites a
+// profile it has created, so the profile file is the whole extension
+// point and we only ever write known fields.
+const OMAC_LL_ENV_ENTRY = "LOAD_LOCK_*"; // allow_vars trailing-* prefix (verified: accepted by 0.11.0)
+/** omac's user-global sandbox profile (no project equivalent exists). */
+function omacProfileFile() {
+    return path.join(configHome(), "omac", "sandbox-profiles", "default.json");
+}
+/** Read + shape-check the profile; undefined when the file does not exist. */
+function omacReadProfile(file) {
+    if (!fs.existsSync(file))
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (e) {
+        throw new Error(`${file} is not valid JSON (${e instanceof Error ? e.message : String(e)}). omac parses ` +
+            `profiles strictly; load-lock refuses to overwrite it — fix or remove the file, then re-run install`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`${file} is not a JSON object; refusing to overwrite`);
+    }
+    return parsed;
+}
+/** The profile sub-object `key`, created when absent; refuses non-objects. */
+function omacSection(profile, key) {
+    const v = profile[key];
+    if (v === undefined) {
+        const section = {};
+        profile[key] = section;
+        return section;
+    }
+    if (typeof v !== "object" || v === null || Array.isArray(v)) {
+        throw new Error(`omac profile: "${key}" is not an object; refusing to overwrite`);
+    }
+    return v;
+}
+/**
+ * Merge string entries into section[key] (created only when something is
+ * added, so we never write empty arrays). Returns the entries actually
+ * added; refuses non-string-array values instead of mangling them.
+ */
+function omacMergeList(section, key, entries) {
+    const v = section[key];
+    let list;
+    if (v === undefined)
+        list = [];
+    else if (Array.isArray(v) && v.every((x) => typeof x === "string"))
+        list = [...v];
+    else
+        throw new Error(`omac profile: "${key}" is not an array of strings; refusing to overwrite`);
+    const added = entries.filter((e) => !list.includes(e));
+    if (added.length)
+        section[key] = [...list, ...added];
+    return added;
+}
+/**
+ * The installed package tree a sandboxed CLI must be able to *read*.
+ * Live-verified gotcha: a global bun/npm install grants the bin dir, but
+ * the launcher resolves the dist tree under `.../node_modules/@aron98/
+ * load-lock` — without a read grant the CLI dies with ERR_MODULE_NOT_FOUND
+ * before ever reaching the socket. Returns the realpath of the package
+ * root, or null when load-lock lives in a repo checkout / worktree (the
+ * nearest `.git`): there the agent's omac workdir grant already covers
+ * it, and a read grant would be noise.
+ */
+function omacReadGrant(P) {
+    let root = P.root;
+    try {
+        root = fs.realpathSync(root);
+    }
+    catch {
+        /* keep the unresolved path — omac grants are not existence-filtered */
+    }
+    for (let dir = root;;) {
+        if (fs.existsSync(path.join(dir, ".git")))
+            return null; // repo checkout / git worktree
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return root;
+}
+/**
+ * Remove our entries (match-own-entries style: exact current state dir,
+ * the "LOAD_LOCK_*" prefix entry, and read entries pointing at the
+ * current package root or at a global `node_modules/@aron98/load-lock`
+ * tree — the shape the installer writes). Keys whose lists we emptied are
+ * dropped; sections that become empty are dropped; the file is removed
+ * (and dirs pruned) when nothing user-owned remains.
+ */
+function uninstallOmac() {
+    const actions = [];
+    const file = omacProfileFile();
+    const profile = omacReadProfile(file);
+    if (!profile)
+        return actions; // nothing installed; uninstall never creates anything
+    const stateDir = resolveStateDir(process.platform, process.env);
+    const readTree = omacReadGrant(pkgPaths());
+    const globalPkgSuffix = path.join("node_modules", PKG_NAME);
+    let changed = false;
+    const drop = (sectionKey, key, isOurs) => {
+        const section = profile[sectionKey];
+        if (!section || typeof section !== "object" || Array.isArray(section))
+            return;
+        const list = section[key];
+        if (!Array.isArray(list) || !list.every((x) => typeof x === "string"))
+            return;
+        const kept = list.filter((e) => !isOurs(e));
+        if (kept.length === list.length)
+            return;
+        changed = true;
+        if (kept.length)
+            section[key] = kept;
+        else
+            delete section[key];
+    };
+    drop("filesystem", "allow_unix_dir", (e) => e === stateDir);
+    drop("filesystem", "read", (e) => (readTree !== null && e === readTree) || e.endsWith(globalPkgSuffix));
+    drop("environment", "allow_vars", (e) => e === OMAC_LL_ENV_ENTRY);
+    // prune sections our removals emptied (never anything the user still has)
+    for (const key of ["filesystem", "environment"]) {
+        const section = profile[key];
+        if (section && typeof section === "object" && !Array.isArray(section) && Object.keys(section).length === 0) {
+            delete profile[key];
+        }
+    }
+    if (!changed) {
+        actions.push(`no load-lock grants found in ${file}`);
+        return actions;
+    }
+    if (Object.keys(profile).length === 0) {
+        fs.rmSync(file);
+        actions.push(`removed ${file} (nothing else was in it)`);
+        pruneEmptyDirs(path.dirname(file), path.join(configHome(), "omac"));
+    }
+    else {
+        writeJson(file, profile);
+        actions.push(`removed load-lock grants from ${file}`);
+    }
+    return actions;
+}
+function installOmac(opts, P) {
+    const actions = [];
+    const file = omacProfileFile();
+    const existed = fs.existsSync(file);
+    const profile = omacReadProfile(file) ?? {};
+    const stateDir = resolveStateDir(process.platform, process.env);
+    const grants = [];
+    const fsSection = omacSection(profile, "filesystem");
+    grants.push(...omacMergeList(fsSection, "allow_unix_dir", [stateDir]));
+    const readTree = omacReadGrant(P);
+    if (readTree)
+        grants.push(...omacMergeList(fsSection, "read", [readTree]));
+    const envSection = omacSection(profile, "environment");
+    grants.push(...omacMergeList(envSection, "allow_vars", [OMAC_LL_ENV_ENTRY]));
+    // merge-only: never rewrite the file when nothing changed (idempotent
+    // re-install leaves the user's bytes untouched)
+    if (grants.length || !existed)
+        writeJson(file, profile);
+    if (!existed)
+        actions.push(`created ${file} (omac's user-global sandbox profile)`);
+    else if (grants.length)
+        actions.push(`grants merged into ${file}`);
+    else
+        actions.push(`all grants already present in ${file} — nothing to do`);
+    for (const g of grants) {
+        if (g === OMAC_LL_ENV_ENTRY) {
+            actions.push(`environment.allow_vars += "${OMAC_LL_ENV_ENTRY}" (prefix pattern; passes all four LOAD_LOCK_* vars through the sandbox env filter)`);
+        }
+        else if (g === stateDir) {
+            actions.push(`filesystem.allow_unix_dir += ${stateDir} (AF_UNIX connect to the host daemon socket + read/write on the state dir)`);
+        }
+        else {
+            actions.push(`filesystem.read += ${g} (installed package tree — the bin-dir grant alone is not enough; without this the CLI dies with ERR_MODULE_NOT_FOUND before reaching the socket)`);
+        }
+    }
+    if (!readTree) {
+        actions.push(`skipped filesystem.read: load-lock lives in a repo checkout (${P.root}) — the omac workdir grant already covers it`);
+    }
+    actions.push("set the values in your harness env (the grants only allow the names through): " +
+        "LOAD_LOCK_NO_SPAWN=1 (client-only; the daemon must run on the host, e.g. load-lock service start), " +
+        "LOAD_LOCK_LABEL_PREFIX=omac (dashboard shows holders as omac:<label>); " +
+        "LOAD_LOCK_SOCKET only if the default <state dir>/daemon.sock is not what the sandbox sees");
+    actions.push("label prefixes need load-lock >= 1.2.0 on BOTH ends: a daemon started before v1.2.0 " +
+        "silently strips the unknown labelPrefix field — upgrade and restart the daemon (load-lock service stop && load-lock service start)");
+    actions.push("verified live against omac 0.11.0 (bubblewrap + Landlock): sandboxed client -> host daemon " +
+        "round-trip, prefixed labels, LOAD_LOCK_NO_SPAWN error contract");
+    return actions;
+}
 // -------------------------------------------------------------------- public
 export async function installCommand(opts) {
     const P = pkgPaths(opts.binDir);
@@ -956,7 +1167,7 @@ export async function installCommand(opts) {
     }
     const harness = opts.harness;
     if (!harness)
-        throw new Error("install: --harness <opencode|claude-code|codex|cursor|gemini-cli|copilot-cli|cline|roo-code|goose|generic> is required");
+        throw new Error("install: --harness <opencode|claude-code|codex|cursor|gemini-cli|copilot-cli|cline|roo-code|goose|omac|generic> is required");
     let actions;
     switch (harness) {
         case "opencode":
@@ -992,6 +1203,9 @@ export async function installCommand(opts) {
         case "goose":
             actions = installGoose(opts, P);
             break;
+        case "omac":
+            actions = installOmac(opts, P);
+            break;
         case "generic":
         case "all":
         default:
@@ -1044,6 +1258,9 @@ export async function uninstallCommand(opts) {
         case "goose":
             actions = uninstallGoose();
             break;
+        case "omac":
+            actions = uninstallOmac();
+            break;
         default:
             throw new Error(`uninstall: unknown harness "${opts.harness}"`);
     }