cotal-ai 0.93.0 → 0.94.1

package/dist/daemon/client.js

@@ -0,0 +1,96 @@
+/**
+ * The client side of the local daemon endpoint, used by `cotal daemon status`.
+ *
+ * It refuses before connecting unless the directory and socket pass the same ownership and mode
+ * checks the server applies, and refuses after connecting, before writing a single byte, unless
+ * the kernel reports the listening peer as this same uid. So a squatter under another uid, or a
+ * socket in a loosened directory, never receives a request.
+ */
+import { connect as netConnect } from "node:net";
+import { randomUUID } from "node:crypto";
+import { DAEMON_PROTOCOL_VERSION, MAX_LINE_BYTES, EndpointRefusal, assertLinux, checkDir, checkSocket } from "./endpoint.js";
+import { encode } from "./protocol.js";
+function connectTo(path, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const s = netConnect(path);
+        const t = setTimeout(() => {
+            s.destroy();
+            reject(new Error(`timed out connecting to ${path}`));
+        }, timeoutMs);
+        s.once("connect", () => {
+            clearTimeout(t);
+            resolve(s);
+        });
+        s.once("error", (e) => {
+            clearTimeout(t);
+            if (e.code === "ENOENT" || e.code === "ECONNREFUSED")
+                reject(new EndpointRefusal("NOT_RUNNING", `no daemon answers at ${path}`));
+            else
+                reject(e);
+        });
+    });
+}
+function readLine(sock, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let buf = "";
+        const t = setTimeout(() => finish(new Error("timed out waiting for the daemon's reply")), timeoutMs);
+        const finish = (err, line) => {
+            clearTimeout(t);
+            sock.removeAllListeners("data");
+            sock.removeAllListeners("end");
+            sock.removeAllListeners("error");
+            if (err)
+                reject(err);
+            else
+                resolve(line);
+        };
+        sock.setEncoding("utf8");
+        sock.on("data", (chunk) => {
+            buf += chunk;
+            const nl = buf.indexOf("\n");
+            if (nl !== -1)
+                finish(undefined, buf.slice(0, nl));
+            else if (Buffer.byteLength(buf, "utf8") > MAX_LINE_BYTES)
+                finish(new Error("daemon reply exceeds the line limit"));
+        });
+        sock.once("end", () => finish(new Error("daemon closed the connection without a reply")));
+        sock.once("error", (e) => finish(e));
+    });
+}
+/** Send one request and return the daemon's parsed reply. */
+export async function queryDaemon(opts) {
+    assertLinux();
+    const uid = opts.uid ?? process.geteuid();
+    const timeoutMs = opts.timeoutMs ?? 5000;
+    const counters = opts.counters ?? { bytesWritten: 0 };
+    const { paths } = opts;
+    try {
+        checkDir(paths.dir, uid);
+        checkSocket(paths.socket, uid);
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            throw new EndpointRefusal("NOT_RUNNING", `no daemon endpoint at ${paths.socket}`);
+        throw e;
+    }
+    const sock = await connectTo(paths.socket, timeoutMs);
+    try {
+        let peer;
+        try {
+            peer = opts.peerUid(sock);
+        }
+        catch (e) {
+            throw new EndpointRefusal("PEER_UID_MISMATCH", `could not read the daemon's peer credentials: ${e.message}`);
+        }
+        if (peer !== uid)
+            throw new EndpointRefusal("PEER_UID_MISMATCH", `the process answering at ${paths.socket} runs as uid ${peer}, not ${uid}; nothing was sent`);
+        const line = opts.rawLine !== undefined ? `${opts.rawLine}\n` : encode({ v: DAEMON_PROTOCOL_VERSION, id: randomUUID().replaceAll("-", ""), op: "status" });
+        counters.bytesWritten += Buffer.byteLength(line, "utf8");
+        sock.write(line);
+        const reply = await readLine(sock, timeoutMs);
+        return JSON.parse(reply);
+    }
+    finally {
+        sock.destroy();
+    }
+}

package/dist/daemon/command.js

@@ -0,0 +1,116 @@
+/**
+ * `cotal daemon`: the local machine daemon's control surface, composed in this binary rather than
+ * in an `implementations/*` package so it can later wire `@cotal-ai/auth` and `@cotal-ai/manager`
+ * without one implementation importing another (AGENTS.md, repository map).
+ *
+ * This slice serves a local, authenticated status endpoint and nothing else: no sign-in, no
+ * Manager, no service install. Linux only. It is a foreground foundation, not a resilient machine
+ * service: a daemon killed without cleanup leaves its socket behind, and the next start refuses
+ * until the operator removes it (see the 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 { fileURLToPath } from "node:url";
+import { registry } from "@cotal-ai/core";
+import { CommandFailure, jsonFlag, plainFlag, presentationOf, writeResult } from "@cotal-ai/workspace";
+import { peerCredentials } from "@cotal-ai/seat";
+import { EndpointRefusal, daemonPaths } from "./endpoint.js";
+import { serveDaemon } from "./server.js";
+import { queryDaemon } from "./client.js";
+export const daemonFlags = [jsonFlag, plainFlag];
+/** This binary's own version: the nearest package.json above this module (bin/ in a source run). */
+export function binVersion() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 4; i++) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+            if (pkg.name === "cotal-ai" && typeof pkg.version === "string")
+                return pkg.version;
+        }
+        catch (e) {
+            if (e.code !== "ENOENT")
+                throw e;
+        }
+        dir = dirname(dir);
+    }
+    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 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)" },
+    NOT_RUNNING: { code: "TARGET_UNAVAILABLE", remedy: "start it with cotal daemon serve" },
+    ALREADY_RUNNING: { code: "CONFLICT", remedy: "run cotal daemon status: if it answers, a daemon is already running. If it refuses NOT_RUNNING, a previous daemon exited without cleanup and the entry is stale; confirm no cotal daemon process is running, then remove the socket path named above by hand and start again. The daemon never removes it for you" },
+    DIR_NOT_DIRECTORY: { code: "PERMISSION_DENIED", remedy: "inspect the path; nothing was changed" },
+    DIR_SYMLINK: { code: "PERMISSION_DENIED", remedy: "inspect the path; nothing was changed" },
+    DIR_WRONG_OWNER: { code: "PERMISSION_DENIED", remedy: "inspect the path; nothing was changed" },
+    DIR_WRONG_MODE: { code: "PERMISSION_DENIED", remedy: "inspect the directory; the daemon never changes the mode of an existing directory" },
+    SOCKET_NOT_SOCKET: { code: "PERMISSION_DENIED", remedy: "inspect the path; nothing was removed" },
+    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" },
+};
+function asFailure(e) {
+    if (!(e instanceof EndpointRefusal))
+        return e;
+    const r = REFUSAL[e.code];
+    return new CommandFailure("refused", r.code, e.message, { ...(r.remedy ? { remedy: r.remedy } : {}), native: { code: e.code } });
+}
+function statusView(s) {
+    return { sections: [{ title: "Daemon", blocks: [{ kind: "fields", rows: [["State", s.state], ["Version", s.version], ["Protocol", String(s.protocol)], ["PID", String(s.pid)], ["Started", s.startedAt], ["Uptime", `${Math.round(s.uptimeMs / 1000)}s`]] }] }] };
+}
+async function status(args) {
+    const presentation = presentationOf(args.values);
+    let reply;
+    try {
+        reply = await queryDaemon({ paths: daemonPaths(), peerUid });
+    }
+    catch (e) {
+        throw asFailure(e);
+    }
+    if (!reply.ok)
+        throw new CommandFailure("failed", "OPERATION_FAILED", `the daemon refused the status request: ${reply.error.code} ${reply.error.message}`);
+    writeResult(presentation, { command: "daemon status", target: null, result: reply.result }, statusView);
+}
+async function serve() {
+    let running;
+    try {
+        running = await serveDaemon({ paths: daemonPaths(), version: binVersion(), peerUid, log: (l) => process.stderr.write(`${l}\n`) });
+    }
+    catch (e) {
+        throw asFailure(e);
+    }
+    process.stdout.write(`daemon ready at ${running.paths.socket}\n`);
+    await new Promise((resolve) => {
+        const stop = () => void running.close().then(resolve, resolve);
+        process.once("SIGTERM", stop);
+        process.once("SIGINT", stop);
+    });
+}
+async function run(args) {
+    const [mode, ...rest] = args.positionals;
+    if (rest.length)
+        throw new CommandFailure("refused", "USAGE_INVALID", `cotal daemon ${mode} takes no positionals`);
+    if (mode === "status")
+        return status(args);
+    if (mode === "serve")
+        return serve();
+    throw new CommandFailure("refused", "USAGE_INVALID", mode === undefined ? "cotal daemon needs a mode: status or serve" : `unknown daemon mode ${JSON.stringify(mode)}`, { remedy: "cotal daemon status" });
+}
+const daemonCommand = {
+    kind: "command",
+    name: "daemon",
+    group: "Manager",
+    summary: "the local machine daemon (Linux): serve its control endpoint, read its status",
+    positionals: "<status|serve>",
+    flags: daemonFlags,
+    subcommands: [
+        { name: "status", summary: "ask the running daemon for its status over the local endpoint", 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 },
+    ],
+    prepareMeshTarget: false,
+    examples: ["cotal daemon serve", "cotal daemon status", "cotal daemon status --json"],
+    run,
+};
+registry.register(daemonCommand);

package/dist/daemon/endpoint.js

@@ -0,0 +1,113 @@
+/**
+ * The local control endpoint of `cotal daemon`, Linux only.
+ *
+ * Trust boundary, stated as it is: the kernel separates OS users, not processes of one user. The
+ * runtime directory is owned by the daemon's uid with mode 0700, the socket is 0600, and both ends
+ * read `SO_PEERCRED` through the stock `@cotal-ai/seat` helper and require the peer to be that same
+ * uid. Any process running as that uid can still reach the daemon and read its files; that user is
+ * the trust principal (see docs/connect-jcode.md, "Security limits").
+ *
+ * Nothing here repairs a path into shape. A pre-existing directory that is a symlink, not owned by
+ * 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 { lstatSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+/** Wire protocol version. A request naming any other version is refused before any effect. */
+export const DAEMON_PROTOCOL_VERSION = 1;
+/** Largest accepted request or response line, in bytes, including its newline. */
+export const MAX_LINE_BYTES = 64 * 1024;
+/** A refusal at the local endpoint, typed so callers and tests can count it. */
+export class EndpointRefusal extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "EndpointRefusal";
+        this.code = code;
+    }
+}
+/** The fixed endpoint location for this user: `$XDG_RUNTIME_DIR/cotal/daemon.sock`. */
+export function daemonPaths(env = process.env) {
+    const runtime = env.XDG_RUNTIME_DIR;
+    if (!runtime) {
+        throw new EndpointRefusal("NO_RUNTIME_DIR", "XDG_RUNTIME_DIR is not set, so there is no per-user runtime directory to hold the daemon socket");
+    }
+    const dir = join(runtime, "cotal");
+    return { dir, socket: join(dir, "daemon.sock") };
+}
+export function assertLinux(platform = process.platform) {
+    if (platform !== "linux") {
+        throw new EndpointRefusal("UNSUPPORTED_PLATFORM", `the local daemon endpoint is Linux only (this is ${platform})`);
+    }
+}
+function euid() {
+    if (typeof process.geteuid !== "function")
+        throw new EndpointRefusal("UNSUPPORTED_PLATFORM", "this platform has no effective uid");
+    return process.geteuid();
+}
+/** Refuse unless `dir` is a real directory owned by this uid with mode exactly 0700. */
+export function checkDir(dir, uid = euid()) {
+    const st = lstatSync(dir);
+    if (st.isSymbolicLink())
+        throw new EndpointRefusal("DIR_SYMLINK", `${dir} is a symlink; the daemon directory must be a real directory`);
+    if (!st.isDirectory())
+        throw new EndpointRefusal("DIR_NOT_DIRECTORY", `${dir} exists and is not a directory`);
+    if (st.uid !== uid)
+        throw new EndpointRefusal("DIR_WRONG_OWNER", `${dir} is owned by uid ${st.uid}, not ${uid}`);
+    const mode = st.mode & 0o777;
+    if (mode !== 0o700)
+        throw new EndpointRefusal("DIR_WRONG_MODE", `${dir} has mode ${mode.toString(8).padStart(4, "0")}, not 0700`);
+}
+/** Refuse unless `path` is a socket owned by this uid with mode exactly 0600. */
+export function checkSocket(path, uid = euid()) {
+    const st = lstatSync(path);
+    if (!st.isSocket())
+        throw new EndpointRefusal("SOCKET_NOT_SOCKET", `${path} exists and is not a socket`);
+    if (st.uid !== uid)
+        throw new EndpointRefusal("SOCKET_WRONG_OWNER", `${path} is owned by uid ${st.uid}, not ${uid}`);
+    const mode = st.mode & 0o777;
+    if (mode !== 0o600)
+        throw new EndpointRefusal("SOCKET_WRONG_MODE", `${path} has mode ${mode.toString(8).padStart(4, "0")}, not 0600`);
+}
+function exists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return false;
+        throw e;
+    }
+}
+/** Create the directory 0700 if absent; if present, check it and never change it. */
+export function ensureDir(dir, uid = euid()) {
+    if (!exists(dir)) {
+        try {
+            mkdirSync(dir, { mode: 0o700 });
+            checkDir(dir, uid);
+            return "created";
+        }
+        catch (e) {
+            // A concurrent creator won the race: fall through and check what is there now.
+            if (e.code !== "EEXIST")
+                throw e;
+        }
+    }
+    checkDir(dir, uid);
+    return "existing";
+}
+/**
+ * Refuse any pre-existing entry at the public socket path. There is no automatic stale-socket
+ * reclamation: a leftover socket from a crashed daemon is reported, never removed, because probing
+ * then unlinking is a race that can delete another starter's live socket. The operator removes a
+ * known-stale socket by hand; `link(2)` at bind time then gives exactly one winner.
+ */
+export function refuseExisting(path) {
+    if (!exists(path))
+        return;
+    const st = lstatSync(path);
+    if (!st.isSocket())
+        throw new EndpointRefusal("SOCKET_NOT_SOCKET", `${path} exists and is not a socket; nothing was removed`);
+    throw new EndpointRefusal("ALREADY_RUNNING", `${path} already exists (uid ${st.uid}); a daemon may be running, or a previous one exited without cleanup. Nothing was removed`);
+}

package/dist/daemon/protocol.js

@@ -0,0 +1,41 @@
+/**
+ * The closed, versioned wire contract of the local daemon endpoint: one JSON object per line.
+ *
+ * A request is exactly `{ v, id, op }`. Any other key, any other version, an unknown op, a line
+ * that is not a JSON object, or a line over {@link MAX_LINE_BYTES} is refused before any effect,
+ * with a typed error. Responses echo the request id when one could be read.
+ */
+import { DAEMON_PROTOCOL_VERSION, MAX_LINE_BYTES } from "./endpoint.js";
+export const DAEMON_OPS = ["status"];
+const REQUEST_KEYS = new Set(["v", "id", "op"]);
+const ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+/** Parse one line (without its newline). Pure: it decides, it does nothing. */
+export function parseRequest(line) {
+    if (Buffer.byteLength(line, "utf8") + 1 > MAX_LINE_BYTES)
+        return { ok: false, id: null, code: "LINE_TOO_LONG", message: `request exceeds ${MAX_LINE_BYTES} bytes` };
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        return { ok: false, id: null, code: "BAD_JSON", message: "request is not valid JSON" };
+    }
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return { ok: false, id: null, code: "NOT_OBJECT", message: "request must be a JSON object" };
+    const obj = raw;
+    const id = typeof obj.id === "string" && ID_PATTERN.test(obj.id) ? obj.id : null;
+    for (const k of Object.keys(obj)) {
+        if (!REQUEST_KEYS.has(k))
+            return { ok: false, id, code: "UNKNOWN_FIELD", message: `unknown request field ${JSON.stringify(k)}` };
+    }
+    if (obj.v !== DAEMON_PROTOCOL_VERSION)
+        return { ok: false, id, code: "BAD_VERSION", message: `unsupported protocol version ${JSON.stringify(obj.v)}; this daemon speaks ${DAEMON_PROTOCOL_VERSION}` };
+    if (id === null)
+        return { ok: false, id: null, code: "BAD_ID", message: "request id must be 1-64 characters of [A-Za-z0-9_-]" };
+    if (typeof obj.op !== "string" || !DAEMON_OPS.includes(obj.op))
+        return { ok: false, id, code: "UNKNOWN_OP", message: `unknown op ${JSON.stringify(obj.op)}` };
+    return { ok: true, request: { v: DAEMON_PROTOCOL_VERSION, id, op: obj.op } };
+}
+export function encode(msg) {
+    return `${JSON.stringify(msg)}\n`;
+}

package/dist/daemon/server.js

@@ -0,0 +1,169 @@
+/**
+ * The `cotal daemon serve` listener: binds the local endpoint, answers `status` once it is ready,
+ * and removes only its own socket on shutdown.
+ *
+ * Readiness is real: `status` can only be answered by a listener that has passed the directory
+ * check, found the public path empty, bound a private name, verified it is a 0600 socket owned by
+ * this uid, and published it with link(2), which yields exactly one winner among concurrent
+ * starters. A peer whose kernel-reported uid differs is dropped before one byte of its input is
+ * decoded.
+ */
+import { chmodSync, linkSync, unlinkSync, lstatSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { join } from "node:path";
+import { createServer } from "node:net";
+import { DAEMON_PROTOCOL_VERSION, MAX_LINE_BYTES, EndpointRefusal, assertLinux, checkSocket, ensureDir, refuseExisting } from "./endpoint.js";
+import { encode, parseRequest } from "./protocol.js";
+function listen(server, path) {
+    return new Promise((resolve, reject) => {
+        const onError = (e) => {
+            server.off("listening", onListening);
+            reject(e);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(path);
+    });
+}
+export async function serveDaemon(opts) {
+    assertLinux();
+    const uid = opts.uid ?? process.geteuid();
+    const log = opts.log ?? (() => { });
+    const { paths } = opts;
+    const dirOutcome = ensureDir(paths.dir, uid);
+    refuseExisting(paths.socket);
+    const counters = { accepted: 0, peerRejected: 0, framesDecoded: 0, requestsRefused: 0, statusAnswered: 0 };
+    const startedAt = new Date();
+    const status = () => ({
+        state: "ready",
+        protocol: DAEMON_PROTOCOL_VERSION,
+        version: opts.version,
+        pid: process.pid,
+        startedAt: startedAt.toISOString(),
+        uptimeMs: Date.now() - startedAt.getTime(),
+    });
+    const sockets = new Set();
+    const server = createServer({ allowHalfOpen: false, pauseOnConnect: true }, (sock) => {
+        sockets.add(sock);
+        sock.once("close", () => sockets.delete(sock));
+        sock.on("error", () => { });
+        let peer;
+        try {
+            peer = opts.peerUid(sock);
+        }
+        catch (e) {
+            counters.peerRejected++;
+            log(`daemon: peer credentials unreadable (${e.message}); dropped`);
+            sock.destroy();
+            return;
+        }
+        if (peer !== uid) {
+            counters.peerRejected++;
+            log(`daemon: peer uid ${peer} is not ${uid}; dropped before any frame was read`);
+            sock.destroy();
+            return;
+        }
+        counters.accepted++;
+        let buf = "";
+        let bufBytes = 0;
+        sock.setEncoding("utf8");
+        sock.on("data", (chunk) => {
+            buf += chunk;
+            bufBytes += Buffer.byteLength(chunk, "utf8");
+            // Enforce the line limit while buffering: an unterminated stream is cut off at the limit,
+            // never accumulated.
+            if (bufBytes > MAX_LINE_BYTES && !buf.includes("\n")) {
+                counters.requestsRefused++;
+                const r = { v: DAEMON_PROTOCOL_VERSION, id: null, ok: false, error: { code: "LINE_TOO_LONG", message: `request exceeds ${MAX_LINE_BYTES} bytes` } };
+                sock.removeAllListeners("data");
+                sock.end(encode(r));
+                sock.destroySoon();
+                buf = "";
+                bufBytes = 0;
+                return;
+            }
+            let nl;
+            while ((nl = buf.indexOf("\n")) !== -1) {
+                const line = buf.slice(0, nl);
+                buf = buf.slice(nl + 1);
+                bufBytes = Buffer.byteLength(buf, "utf8");
+                counters.framesDecoded++;
+                const parsed = parseRequest(line);
+                if (!parsed.ok) {
+                    counters.requestsRefused++;
+                    sock.write(encode({ v: DAEMON_PROTOCOL_VERSION, id: parsed.id, ok: false, error: { code: parsed.code, message: parsed.message } }));
+                    continue;
+                }
+                counters.statusAnswered++;
+                sock.write(encode({ v: DAEMON_PROTOCOL_VERSION, id: parsed.request.id, ok: true, result: status() }));
+            }
+        });
+        sock.resume();
+    });
+    // Bind on a private name inside the verified 0700 directory, then publish it at the fixed path
+    // with link(2), which refuses to replace anything already there. Node's server.close() unlinks
+    // whatever sits at the path it bound (measured on Node 24), so binding the private name means
+    // close() can only ever remove that name, never a socket another process later put at the
+    // public path. The private name is removed as soon as the link exists.
+    const bindPath = join(paths.dir, `.bind-${process.pid}-${randomBytes(6).toString("hex")}`);
+    // umask is process-wide; it is narrowed only around listen() and restored in `finally`. The
+    // directory is already verified 0700 and the bound socket is chmod-ed and re-checked below, so
+    // the umask is defense in depth, not the guarantee.
+    const previous = process.umask(0o177);
+    try {
+        await listen(server, bindPath);
+    }
+    finally {
+        process.umask(previous);
+    }
+    const abort = async (e) => {
+        await new Promise((r) => server.close(() => r()));
+        throw e;
+    };
+    try {
+        chmodSync(bindPath, 0o600);
+        checkSocket(bindPath, uid);
+        linkSync(bindPath, paths.socket);
+    }
+    catch (e) {
+        if (e.code === "EEXIST")
+            return abort(new EndpointRefusal("ALREADY_RUNNING", `another process published ${paths.socket} first; nothing was replaced`));
+        return abort(e);
+    }
+    unlinkSync(bindPath);
+    try {
+        checkSocket(paths.socket, uid);
+    }
+    catch (e) {
+        return abort(e);
+    }
+    const bound = lstatSync(paths.socket);
+    const boundDev = bound.dev, boundIno = bound.ino;
+    log(`daemon: ready at ${paths.socket}`);
+    let closed;
+    const close = () => {
+        closed ??= (async () => {
+            for (const s of sockets)
+                s.destroy();
+            await new Promise((r) => server.close(() => r()));
+            // Remove the public socket only if it is still the exact file (dev + ino) this process
+            // created; a replacement of any kind is left in place.
+            try {
+                const st = lstatSync(paths.socket);
+                if (st.isSocket() && st.uid === uid && st.dev === boundDev && st.ino === boundIno)
+                    unlinkSync(paths.socket);
+            }
+            catch (e) {
+                if (e.code !== "ENOENT")
+                    throw e;
+            }
+        })();
+        return closed;
+    };
+    return { paths, counters, dirOutcome, status, close };
+}
+export { EndpointRefusal };

package/dist/run.js

@@ -18,6 +18,7 @@ import "@cotal-ai/delivery"; // self-registers `deliver` — the server-side Pla
 import "@cotal-ai/runtime"; // self-registers `run` — the workflow-run operator surface (start/resume/ps/journal/answer)
 import "@cotal-ai/auth"; // self-registers login / logout — per-user IdP sessions (device-code sign-in)
 import "./docs.js"; // self-registers `docs`; the docs bundle loads only when `docs` runs
+import "./daemon/command.js"; // self-registers `daemon`: the local machine daemon's authenticated control endpoint (Linux)
 // Self-registers the `ag-ui.frame` part renderer, so `cotal console` and `cotal join` draw an event
 // frame instead of `[unrenderable part kind "ag-ui.frame"]`.
 //

package/package.json

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

package/seeded-connectors/claude/dist/app-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app-host.d.ts","sourceRoot":"","sources":["../src/app-host.ts"],"names":[],"mappings":"AAKA,OAAO,EAAiH,KAAK,WAAW,EAAkB,MAAM,0BAA0B,CAAC;AAS3L,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,OAAQ,SAAQ,WAAW;IAC1C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC5C;AA4CD,wBAAgB,aAAa,CAAC,CAAC,EAAE,cAAc,GAAG,OAAO,CA+IxD"}
+{"version":3,"file":"app-host.d.ts","sourceRoot":"","sources":["../src/app-host.ts"],"names":[],"mappings":"AAKA,OAAO,EAAiH,KAAK,WAAW,EAAkB,MAAM,0BAA0B,CAAC;AAS3L,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,OAAQ,SAAQ,WAAW;IAC1C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC5C;AA4CD,wBAAgB,aAAa,CAAC,CAAC,EAAE,cAAc,GAAG,OAAO,CAmJxD"}