cotal-ai 0.97.1 → 0.99.0

package/dist/daemon/client.js

@@ -8,6 +8,7 @@
  */
 import { connect as netConnect } from "node:net";
 import { randomUUID } from "node:crypto";
+import { inspectLock, processStartToken } from "@cotal-ai/core";
 import { DAEMON_PROTOCOL_VERSION, MAX_LINE_BYTES, EndpointRefusal, assertLinux, checkDir, checkSocket } from "./endpoint.js";
 import { encode } from "./protocol.js";
 /** Ask the daemon whether it could register with `space`. Nothing is registered either way. */
@@ -129,7 +130,11 @@ async function openVerified(opts) {
     assertLinux();
     const uid = opts.uid ?? process.geteuid();
     const { paths } = opts;
+    if (paths.lock !== undefined && opts.peerPid === undefined)
+        throw new Error("an explicit daemon home needs the peer pid check");
     try {
+        if (paths.parent !== undefined)
+            checkDir(paths.parent, uid);
         checkDir(paths.dir, uid);
         checkSocket(paths.socket, uid);
     }
@@ -151,6 +156,23 @@ async function openVerified(opts) {
         sock.destroy();
         throw new EndpointRefusal("PEER_UID_MISMATCH", `the process answering at ${paths.socket} runs as uid ${peer}, not ${uid}; nothing was sent`);
     }
+    if (paths.lock !== undefined) {
+        // Same uid is not enough for an explicit daemon home: the answering process must be the one
+        // holding that home's lifetime lock, the same process (pid and start token) the lock recorded.
+        let pid;
+        try {
+            pid = opts.peerPid(sock);
+        }
+        catch {
+            pid = undefined;
+        }
+        const held = inspectLock(paths.lock);
+        const owner = held.state === "active" ? held.owner : undefined;
+        if (pid === undefined || owner === undefined || owner.pid !== pid || owner.start === undefined || processStartToken(pid) !== owner.start) {
+            sock.destroy();
+            throw new EndpointRefusal("PEER_NOT_LOCK_OWNER", `the process answering at ${paths.socket} is not the daemon holding ${paths.lock}; nothing was sent`);
+        }
+    }
     return sock;
 }
 /** Ask the daemon to sign in, show its prompt, and return its single result. */

package/dist/daemon/command.js

@@ -19,14 +19,14 @@
  * ALREADY_RUNNING remedy). `state: "ready"` means the local control listener is bound and
  * verified; it says nothing about any mesh or Cloud connection.
  */
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { registry } from "@cotal-ai/core";
-import { CommandFailure, jsonFlag, plainFlag, presentationOf, renderReport, spaceFlag, terminalWidth, writeResult } from "@cotal-ai/workspace";
+import { CommandFailure, homeCotalDir, jsonFlag, plainFlag, presentationOf, renderReport, spaceFlag, terminalWidth, writeResult } from "@cotal-ai/workspace";
 import { peerCredentials } from "@cotal-ai/seat";
 import { normalizeIdpUrl } from "@cotal-ai/auth";
-import { EndpointRefusal, daemonPaths } from "./endpoint.js";
+import { EndpointRefusal, checkDir, daemonPaths, daemonPathsFor } from "./endpoint.js";
 import { serveDaemon } from "./server.js";
 import { connectCheckViaDaemon, loginViaDaemon, queryDaemon, registerViaDaemon, serviceViaDaemon } from "./client.js";
 export const daemonFlags = [
@@ -34,6 +34,7 @@ export const daemonFlags = [
     plainFlag,
     { name: "idp", type: "string", value: "<auth base URL>", description: "login: the provider's auth base URL, e.g. <origin>/api/auth" },
     { name: "client-id", type: "string", value: "<id>", description: "login: the OAuth device-flow client id" },
+    { name: "daemon-home", type: "string", value: "<abs dir>", description: "run or reach the daemon whose state lives in this directory (absolute, yours, mode 0700, not the Cotal home): its own sign-in, identity and registration, its own socket and lifetime lock. Without it, the default daemon" },
     spaceFlag,
 ];
 /** This binary's own version: the nearest package.json above this module (bin/ in a source run). */
@@ -54,6 +55,37 @@ export function binVersion() {
     throw new Error("cannot determine the cotal-ai version: no cotal-ai package.json above the daemon module");
 }
 const peerUid = (sock) => peerCredentials(sock).uid;
+const peerPid = (sock) => peerCredentials(sock).pid;
+function target(args) {
+    const raw = args.values["daemon-home"];
+    if (raw === undefined)
+        return { paths: daemonPaths() };
+    if (!raw || !isAbsolute(raw))
+        throw new CommandFailure("refused", "USAGE_INVALID", "--daemon-home needs an absolute directory path");
+    checkDir(raw);
+    const home = realpathSync(raw);
+    let cotalHome;
+    try {
+        cotalHome = realpathSync(homeCotalDir());
+    }
+    catch (e) {
+        if (e.code !== "ENOENT")
+            throw e;
+    }
+    if (home === cotalHome)
+        throw new CommandFailure("refused", "USAGE_INVALID", "--daemon-home cannot be the Cotal home; name a separate directory for this daemon's state");
+    return { paths: daemonPathsFor(home), home };
+}
+function resolveTarget(args) {
+    try {
+        return target(args);
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            throw new CommandFailure("refused", "TARGET_NOT_FOUND", "the --daemon-home directory does not exist; create it with mode 0700 first");
+        throw asFailure(e);
+    }
+}
 const REFUSAL = {
     UNSUPPORTED_PLATFORM: { code: "UNSUPPORTED" },
     NO_RUNTIME_DIR: { code: "TARGET_UNAVAILABLE", remedy: "run from a logged-in session with a per-user runtime directory (systemd-logind sets XDG_RUNTIME_DIR)" },
@@ -67,6 +99,8 @@ const REFUSAL = {
     SOCKET_WRONG_OWNER: { code: "PERMISSION_DENIED", remedy: "inspect the path; nothing was removed" },
     SOCKET_WRONG_MODE: { code: "PERMISSION_DENIED", remedy: "inspect the socket; nothing was sent" },
     PEER_UID_MISMATCH: { code: "PERMISSION_DENIED", remedy: "another user's process holds the daemon endpoint; nothing was sent" },
+    PEER_NOT_LOCK_OWNER: { code: "PERMISSION_DENIED", remedy: "the process at this daemon home's socket is not the daemon holding its lock; nothing was sent" },
+    LOCK_HELD: { code: "CONFLICT", remedy: "a daemon already serves this daemon home; run cotal daemon status with the same --daemon-home" },
 };
 function asFailure(e) {
     if (!(e instanceof EndpointRefusal))
@@ -79,9 +113,10 @@ function statusView(s) {
 }
 async function status(args) {
     const presentation = presentationOf(args.values);
+    const { paths } = resolveTarget(args);
     let reply;
     try {
-        reply = await queryDaemon({ paths: daemonPaths(), peerUid });
+        reply = await queryDaemon({ paths, peerUid, peerPid });
     }
     catch (e) {
         throw asFailure(e);
@@ -107,13 +142,14 @@ async function login(args) {
     }
     if (values["client-id"] !== undefined && !values["client-id"].trim())
         throw new CommandFailure("refused", "USAGE_INVALID", "--client-id cannot be empty");
+    const { paths } = resolveTarget(args);
     const abort = new AbortController();
     const onSignal = () => abort.abort();
     process.once("SIGINT", onSignal);
     let reply;
     try {
         reply = await loginViaDaemon({
-            paths: daemonPaths(), peerUid, idp, signal: abort.signal,
+            paths, peerUid, peerPid, idp, signal: abort.signal,
             ...(values["client-id"] !== undefined ? { clientId: values["client-id"] } : {}),
             onPrompt: (p) => {
                 process.stderr.write(`${renderReport({ sections: [{ title: "Approve sign-in", blocks: [
@@ -161,9 +197,10 @@ async function connectCheckCommand(args) {
     const space = args.values.space;
     if (typeof space !== "string" || !space)
         throw new CommandFailure("refused", "USAGE_INVALID", "cotal daemon connect-check needs --space <s>");
+    const { paths } = resolveTarget(args);
     let reply;
     try {
-        reply = await connectCheckViaDaemon({ paths: daemonPaths(), peerUid, space });
+        reply = await connectCheckViaDaemon({ paths, peerUid, peerPid, space });
     }
     catch (e) {
         throw asFailure(e);
@@ -198,9 +235,10 @@ async function registerCommand(args) {
     const space = args.values.space;
     if (typeof space !== "string" || !space)
         throw new CommandFailure("refused", "USAGE_INVALID", "cotal daemon register needs --space <s>");
+    const { paths } = resolveTarget(args);
     let reply;
     try {
-        reply = await registerViaDaemon({ paths: daemonPaths(), peerUid, space });
+        reply = await registerViaDaemon({ paths, peerUid, peerPid, space });
     }
     catch (e) {
         throw asFailure(e);
@@ -239,9 +277,10 @@ async function serviceCommand(args, op) {
     const space = args.values.space;
     if (typeof space !== "string" || !space)
         throw new CommandFailure("refused", "USAGE_INVALID", `cotal daemon ${op} needs --space <s>`);
+    const { paths } = resolveTarget(args);
     let reply;
     try {
-        reply = await serviceViaDaemon({ paths: daemonPaths(), peerUid, space, op });
+        reply = await serviceViaDaemon({ paths, peerUid, peerPid, space, op });
     }
     catch (e) {
         throw asFailure(e);
@@ -269,10 +308,11 @@ async function serviceCommand(args, op) {
                 ] },
         ] }));
 }
-async function serve() {
+async function serve(args) {
+    const { paths, home } = resolveTarget(args);
     let running;
     try {
-        running = await serveDaemon({ paths: daemonPaths(), version: binVersion(), peerUid, log: (l) => process.stderr.write(`${l}\n`) });
+        running = await serveDaemon({ paths, version: binVersion(), peerUid, log: (l) => process.stderr.write(`${l}\n`), ...(home !== undefined ? { sessionDir: home } : {}) });
     }
     catch (e) {
         throw asFailure(e);
@@ -291,7 +331,7 @@ async function run(args) {
     if (mode === "status")
         return status(args);
     if (mode === "serve")
-        return serve();
+        return serve(args);
     if (mode === "login")
         return login(args);
     if (mode === "connect-check")
@@ -310,14 +350,14 @@ const daemonCommand = {
     positionals: "<status|serve|login|connect-check|register|service-connect|service-disconnect|service-status>",
     flags: daemonFlags,
     subcommands: [
-        { name: "status", summary: "ask the running daemon for its status over the local endpoint", flagNames: ["json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
-        { name: "serve", summary: "run the daemon in the foreground and serve its local endpoint (refusals honor --json)", flagNames: ["json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
-        { name: "login", summary: "sign the running daemon in to a provider with device approval; the daemon keeps the session", flagNames: ["idp", "client-id", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
-        { name: "connect-check", summary: "ask the running daemon whether it could register with a space as its own service; registers nothing", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
-        { name: "register", summary: "ask the running daemon to request its own service registration with a space; the space owner must approve it, and it does not connect", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
-        { name: "service-connect", summary: "connect the running daemon to a space as its own approved service; succeeds only when the broker accepts the connection and the space accepts it as ready", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
-        { name: "service-disconnect", summary: "close the running daemon's service connection to a space", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
-        { name: "service-status", summary: "read the running daemon's service connection to a space, without contacting it", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
+        { name: "status", summary: "ask the running daemon for its status over the local endpoint", flagNames: ["daemon-home", "json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
+        { name: "serve", summary: "run the daemon in the foreground and serve its local endpoint (refusals honor --json)", flagNames: ["daemon-home", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
+        { name: "login", summary: "sign the running daemon in to a provider with device approval; the daemon keeps the session", flagNames: ["idp", "client-id", "daemon-home", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
+        { name: "connect-check", summary: "ask the running daemon whether it could register with a space as its own service; registers nothing", flagNames: ["space", "daemon-home", "json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
+        { name: "register", summary: "ask the running daemon to request its own service registration with a space; the space owner must approve it, and it does not connect", flagNames: ["space", "daemon-home", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
+        { name: "service-connect", summary: "connect the running daemon to a space as its own approved service; succeeds only when the broker accepts the connection and the space accepts it as ready", flagNames: ["space", "daemon-home", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
+        { name: "service-disconnect", summary: "close the running daemon's service connection to a space", flagNames: ["space", "daemon-home", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
+        { name: "service-status", summary: "read the running daemon's service connection to a space, without contacting it", flagNames: ["space", "daemon-home", "json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
     ],
     prepareMeshTarget: false,
     examples: ["cotal daemon serve", "cotal daemon status", "cotal daemon status --json", "cotal daemon login --idp https://example.org/api/auth", "cotal daemon connect-check --space acme", "cotal daemon register --space acme", "cotal daemon service-connect --space acme", "cotal daemon service-status --space acme"],

package/dist/daemon/endpoint.js

@@ -11,6 +11,7 @@
  * this uid, or not exactly 0700 is refused, never chmod-ed. Any pre-existing entry at the socket
  * path is refused, never removed, so this code never unlinks a socket it did not create.
  */
+import { createHash } from "node:crypto";
 import { lstatSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 /** Wire protocol version. A request naming any other version is refused before any effect. */
@@ -35,6 +36,17 @@ export function daemonPaths(env = process.env) {
     const dir = join(runtime, "cotal");
     return { dir, socket: join(dir, "daemon.sock") };
 }
+/**
+ * The endpoint of the daemon whose home is `daemonHome` (an absolute, canonical path):
+ * `$XDG_RUNTIME_DIR/cotal/home-<16 hex of sha256(daemonHome)>/daemon.sock`, with its lifetime lock
+ * at `<daemonHome>/daemon.lock`. Derived, so client and server agree with no extra record, and
+ * disjoint from the legacy socket.
+ */
+export function daemonPathsFor(daemonHome, env = process.env) {
+    const base = daemonPaths(env);
+    const dir = join(base.dir, `home-${createHash("sha256").update(daemonHome).digest("hex").slice(0, 16)}`);
+    return { parent: base.dir, dir, socket: join(dir, "daemon.sock"), lock: join(daemonHome, "daemon.lock") };
+}
 export function assertLinux(platform = process.platform) {
     if (platform !== "linux") {
         throw new EndpointRefusal("UNSUPPORTED_PLATFORM", `the local daemon endpoint is Linux only (this is ${platform})`);

package/dist/daemon/server.js

@@ -19,6 +19,7 @@ import { connectCheck } from "./connect.js";
 import { registerDaemon } from "./register.js";
 import { createServiceConnections } from "./service.js";
 import { homeCotalDir } from "@cotal-ai/workspace";
+import { acquireLock } from "@cotal-ai/core";
 /** Requests one connection may send. A sign-in needs two (start, cancel); status polling a few. */
 export const MAX_REQUESTS_PER_CONNECTION = 64;
 function listen(server, path) {
@@ -39,8 +40,33 @@ function listen(server, path) {
 export async function serveDaemon(opts) {
     assertLinux();
     const uid = opts.uid ?? process.geteuid();
+    const { paths } = opts;
+    // An explicit daemon home holds its lifetime lock before touching any endpoint path, so a second
+    // serve for the same home refuses here and never reaches the socket. The stock lock reclaims a dead
+    // owner's record; a stale socket is still refused below and never removed.
+    let lock;
+    if (paths.lock !== undefined) {
+        const path = paths.lock;
+        lock = acquireLock(path, {
+            waitMs: 0,
+            label: "cotal daemon",
+            onTimeout: (owner) => new EndpointRefusal("LOCK_HELD", `${path} is held by a live process (pid ${owner.pid}): a daemon already serves this daemon home. Nothing was changed`),
+        });
+    }
+    try {
+        return await serveLocked(opts, uid, lock);
+    }
+    catch (e) {
+        // Every failed start releases the lock it took. A started daemon releases it only in close().
+        lock?.release();
+        throw e;
+    }
+}
+async function serveLocked(opts, uid, lock) {
     const log = opts.log ?? (() => { });
     const { paths } = opts;
+    if (paths.parent !== undefined)
+        ensureDir(paths.parent, uid);
     const dirOutcome = ensureDir(paths.dir, uid);
     refuseExisting(paths.socket);
     const counters = { accepted: 0, peerRejected: 0, framesDecoded: 0, requestsRefused: 0, statusAnswered: 0, loginsStarted: 0, loginsRefused: 0, cancelsAnswered: 0, connectChecksAnswered: 0, registersAnswered: 0, serviceAnswered: 0 };
@@ -259,6 +285,10 @@ export async function serveDaemon(opts) {
                 if (e.code !== "ENOENT")
                     throw e;
             }
+            // The lock is released only once this daemon's own endpoint is gone. If its socket is still
+            // published (the removal above threw), the lock stays held until this process exits, so no
+            // other serve can start beside a live endpoint.
+            lock?.release();
         })();
         return closed;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cotal-ai",
-  "version": "0.97.1",
+  "version": "0.99.0",
   "description": "Cotal — lateral agent coordination over NATS. Run `npx cotal-ai` for the CLI.",
   "license": "Apache-2.0",
   "keywords": [
@@ -33,26 +33,26 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@cotal-ai/auth": "0.97.1",
-    "@cotal-ai/cli": "0.97.1",
-    "@cotal-ai/connector-core": "0.97.1",
-    "@cotal-ai/core": "0.97.1",
-    "@cotal-ai/delivery": "0.97.1",
-    "@cotal-ai/manager": "0.97.1",
-    "@cotal-ai/runtime": "0.97.1",
-    "@cotal-ai/seat": "0.97.1",
-    "@cotal-ai/workspace": "0.97.1"
+    "@cotal-ai/auth": "0.99.0",
+    "@cotal-ai/cli": "0.99.0",
+    "@cotal-ai/connector-core": "0.99.0",
+    "@cotal-ai/core": "0.99.0",
+    "@cotal-ai/delivery": "0.99.0",
+    "@cotal-ai/manager": "0.99.0",
+    "@cotal-ai/runtime": "0.99.0",
+    "@cotal-ai/seat": "0.99.0",
+    "@cotal-ai/workspace": "0.99.0"
   },
   "devDependencies": {
-    "@cotal-ai/connector-claude-code": "0.97.1",
-    "@cotal-ai/connector-codex": "0.97.1",
-    "@cotal-ai/connector-hermes": "0.97.1",
-    "@cotal-ai/connector-jcode": "0.97.1",
-    "@cotal-ai/connector-opencode": "0.97.1",
-    "@cotal-ai/linear": "0.97.1",
-    "@cotal-ai/pi": "0.97.1",
+    "@cotal-ai/connector-claude-code": "0.99.0",
+    "@cotal-ai/connector-codex": "0.99.0",
+    "@cotal-ai/connector-hermes": "0.99.0",
+    "@cotal-ai/connector-jcode": "0.99.0",
+    "@cotal-ai/connector-opencode": "0.99.0",
+    "@cotal-ai/linear": "0.99.0",
+    "@cotal-ai/pi": "0.99.0",
     "@cotal-ai/smoke-kit": "0.0.0",
-    "@cotal-ai/web": "0.97.1",
+    "@cotal-ai/web": "0.99.0",
     "@nats-io/jetstream": "^3.4.0",
     "@nats-io/transport-node": "^3.4.0",
     "typescript": "^5.9.3"