cotal-ai 0.94.4 → 0.94.7

package/dist/daemon/client.js

@@ -10,6 +10,23 @@ 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";
+/** Ask the daemon whether it could register with `space`. Nothing is registered either way. */
+export async function connectCheckViaDaemon(opts) {
+    const sock = await openVerified({ ...opts, timeoutMs: 5000 });
+    try {
+        sock.write(encode({ v: DAEMON_PROTOCOL_VERSION, id: randomUUID().replaceAll("-", ""), op: "connect-check", space: opts.space }));
+        // The daemon's own network read is bounded by the stock client (30 s); allow a little more.
+        const reply = JSON.parse(await readLine(sock, 35_000));
+        if (!reply.ok)
+            return { ok: false, code: reply.error.code, message: reply.error.message };
+        if ("event" in reply || !("outcome" in reply.result) || !("space" in reply.result))
+            return { ok: false, code: "BAD_REPLY", message: "the daemon answered the connect check with something else" };
+        return { ok: true, result: reply.result };
+    }
+    finally {
+        sock.destroy();
+    }
+}
 function connectTo(path, timeoutMs) {
     return new Promise((resolve, reject) => {
         const s = netConnect(path);
@@ -59,10 +76,23 @@ function readLine(sock, timeoutMs) {
 }
 /** Send one request and return the daemon's parsed reply. */
 export async function queryDaemon(opts) {
+    const sock = await openVerified(opts);
+    try {
+        const line = opts.rawLine !== undefined ? `${opts.rawLine}\n` : encode({ v: DAEMON_PROTOCOL_VERSION, id: randomUUID().replaceAll("-", ""), op: "status" });
+        (opts.counters ?? { bytesWritten: 0 }).bytesWritten += Buffer.byteLength(line, "utf8");
+        sock.write(line);
+        const reply = await readLine(sock, opts.timeoutMs ?? 5000);
+        return JSON.parse(reply);
+    }
+    finally {
+        sock.destroy();
+    }
+}
+/** Connect only after the directory and socket checks pass, and keep the connection only when the
+ *  kernel reports the listener as this same uid. Nothing is written before both. */
+async function openVerified(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);
@@ -73,22 +103,68 @@ export async function queryDaemon(opts) {
             throw new EndpointRefusal("NOT_RUNNING", `no daemon endpoint at ${paths.socket}`);
         throw e;
     }
-    const sock = await connectTo(paths.socket, timeoutMs);
+    const sock = await connectTo(paths.socket, opts.timeoutMs ?? 5000);
+    let peer;
     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);
+        peer = opts.peerUid(sock);
+    }
+    catch (e) {
+        sock.destroy();
+        throw new EndpointRefusal("PEER_UID_MISMATCH", `could not read the daemon's peer credentials: ${e.message}`);
+    }
+    if (peer !== uid) {
+        sock.destroy();
+        throw new EndpointRefusal("PEER_UID_MISMATCH", `the process answering at ${paths.socket} runs as uid ${peer}, not ${uid}; nothing was sent`);
+    }
+    return sock;
+}
+/** Ask the daemon to sign in, show its prompt, and return its single result. */
+export async function loginViaDaemon(opts) {
+    const sock = await openVerified(opts);
+    try {
+        const id = randomUUID().replaceAll("-", "");
+        return await new Promise((resolve, reject) => {
+            let buf = "";
+            let attempt;
+            const cleanup = () => { sock.removeAllListeners("data"); sock.removeAllListeners("end"); sock.removeAllListeners("error"); opts.signal?.removeEventListener("abort", onAbort); };
+            const finish = (r) => { cleanup(); if (r instanceof Error)
+                reject(r);
+            else
+                resolve(r); };
+            const abandoned = { ok: false, code: "ABANDONED", message: "stopped before the daemon showed a prompt; the connection was closed, which cancels the sign-in on the daemon" };
+            const onAbort = () => {
+                if (!attempt)
+                    return finish(abandoned);
+                sock.write(encode({ v: DAEMON_PROTOCOL_VERSION, id: `${id}c`.slice(0, 64), op: "login-cancel", attempt }));
+            };
+            sock.setEncoding("utf8");
+            sock.on("data", (chunk) => {
+                buf += chunk;
+                if (Buffer.byteLength(buf, "utf8") > MAX_LINE_BYTES && !buf.includes("\n"))
+                    return finish(new Error("daemon reply exceeds the line limit"));
+                let nl;
+                while ((nl = buf.indexOf("\n")) !== -1) {
+                    const msg = JSON.parse(buf.slice(0, nl));
+                    buf = buf.slice(nl + 1);
+                    if (msg.id !== id)
+                        continue;
+                    if (!msg.ok)
+                        return finish({ ok: false, code: msg.error.code, message: msg.error.message });
+                    if ("event" in msg && msg.event === "login-prompt") {
+                        attempt = msg.attempt;
+                        opts.onPrompt(msg.prompt);
+                    }
+                    else if ("event" in msg && msg.event === "login-result")
+                        return finish({ ok: true, attempt: msg.attempt, result: msg.result });
+                }
+            });
+            sock.once("end", () => finish(new Error("the daemon closed the connection before the sign-in finished")));
+            sock.once("error", (e) => finish(e));
+            if (opts.signal?.aborted)
+                return finish(abandoned);
+            opts.signal?.addEventListener("abort", onAbort, { once: true });
+            sock.write(encode({ v: DAEMON_PROTOCOL_VERSION, id, op: "login-start", idp: opts.idp, ...(opts.clientId !== undefined ? { clientId: opts.clientId } : {}) }));
+        });
     }
     finally {
         sock.destroy();

package/dist/daemon/command.js

@@ -3,22 +3,35 @@
  * 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.
+ * This slice serves a local, authenticated endpoint for status, sign-in and a connection check, and
+ * nothing else: no registration, no Manager, no mesh or Cloud connection, no service install. Linux
+ * only. Sign-in runs inside the
+ * daemon through stock `establishIdpSession`, so the session lands in the machine-home Cotal
+ * directory where `cotal login` keeps it, and no token ever crosses the local endpoint. The
+ * connection check (`connect.ts`) reads the space's public account identity and keeps the daemon's
+ * own per-space identity, never a Manager's. 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 { CommandFailure, 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 { serveDaemon } from "./server.js";
-import { queryDaemon } from "./client.js";
-export const daemonFlags = [jsonFlag, plainFlag];
+import { connectCheckViaDaemon, loginViaDaemon, queryDaemon } from "./client.js";
+export const daemonFlags = [
+    jsonFlag,
+    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" },
+    spaceFlag,
+];
 /** 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));
@@ -73,6 +86,107 @@ async function status(args) {
         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);
 }
+/** Sign in through the running daemon. The daemon talks to the IdP and keeps the session; this
+ *  process only shows the approval prompt and the result, and never sees a token. Ctrl-C asks the
+ *  daemon to cancel the attempt and waits for its answer. */
+async function login(args) {
+    const presentation = presentationOf(args.values);
+    const values = args.values;
+    if (typeof values.idp !== "string")
+        throw new CommandFailure("refused", "USAGE_INVALID", "cotal daemon login needs --idp <auth base URL>");
+    let idp;
+    try {
+        idp = normalizeIdpUrl(values.idp);
+    }
+    catch {
+        throw new CommandFailure("refused", "USAGE_INVALID", "use an HTTPS provider auth URL, or an HTTP loopback IP URL, without embedded credentials, a query or a fragment");
+    }
+    if (values["client-id"] !== undefined && !values["client-id"].trim())
+        throw new CommandFailure("refused", "USAGE_INVALID", "--client-id cannot be empty");
+    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,
+            ...(values["client-id"] !== undefined ? { clientId: values["client-id"] } : {}),
+            onPrompt: (p) => {
+                process.stderr.write(`${renderReport({ sections: [{ title: "Approve sign-in", blocks: [
+                                { kind: "fields", rows: [["Provider", idp], ["Open", p.verificationUriComplete], ["Or open", p.verificationUri], ["Approval code", p.userCode], ["Expires", p.expiresAt]] },
+                                { kind: "lines", lines: [{ text: "Waiting for the provider's approval. The daemon keeps the session. Ctrl-C cancels this sign-in on this machine. Do not share the approval link or code.", tone: "hint" }] },
+                            ] }] }, presentation === "plain" ? "plain" : "rich", terminalWidth(process.stderr))}\n`);
+            },
+        });
+    }
+    catch (e) {
+        throw asFailure(e);
+    }
+    finally {
+        process.off("SIGINT", onSignal);
+    }
+    if (!reply.ok) {
+        if (reply.code === "LOGIN_IN_PROGRESS")
+            throw new CommandFailure("refused", "CONFLICT", reply.message, { native: { code: reply.code } });
+        if (reply.code === "ABANDONED")
+            throw new CommandFailure("refused", "USAGE_INVALID", reply.message, { native: { code: reply.code } });
+        throw new CommandFailure("failed", "OPERATION_FAILED", `the daemon refused the sign-in: ${reply.code} ${reply.message}`, { native: { code: reply.code } });
+    }
+    const r = reply.result;
+    if (r.outcome === "cancelled")
+        throw new CommandFailure("refused", "USAGE_INVALID", "the sign-in was cancelled on this machine; nothing was saved and nothing was revoked at the provider", { native: { code: "CANCELLED" } });
+    if (r.outcome === "failed") {
+        const native = { native: { code: r.reason.toUpperCase() } };
+        // Denied, expired and unreachable end before stock writes anything: refusals at the provider's
+        // boundary. Any other failure can come after stock saved the session, so it claims nothing about
+        // what was saved; `cotal daemon login` again replaces whatever is there.
+        if (r.reason === "unreachable")
+            throw new CommandFailure("refused", "DEPENDENCY_UNAVAILABLE", `${r.message}; no session was saved`, native);
+        if (r.reason === "denied" || r.reason === "expired")
+            throw new CommandFailure("refused", "PERMISSION_DENIED", `${r.message}; no session was saved`, native);
+        throw new CommandFailure("failed", "OPERATION_FAILED", `${r.message}; a session may have been saved before the failure, so sign in again`, native);
+    }
+    writeResult(presentation, { command: "daemon login", target: { idp }, result: { attempt: reply.attempt, ...r } }, () => ({ sections: [
+            { title: "Signed in", blocks: [{ kind: "fields", rows: [["Account", r.label || r.sub], ["Subject", r.sub], ["Provider", r.idp]] }, { kind: "lines", lines: [{ text: "The daemon holds this session in the machine's Cotal home. No session token is printed. Each space's grants decide access separately.", tone: "hint" }] }] },
+        ] }));
+}
+/** Ask the running daemon whether it could register with a space. The daemon reads the space's
+ *  public account identity and nothing else; no registration, credential or authority results. */
+async function connectCheckCommand(args) {
+    const presentation = presentationOf(args.values);
+    const space = args.values.space;
+    if (typeof space !== "string" || !space)
+        throw new CommandFailure("refused", "USAGE_INVALID", "cotal daemon connect-check needs --space <s>");
+    let reply;
+    try {
+        reply = await connectCheckViaDaemon({ paths: daemonPaths(), peerUid, space });
+    }
+    catch (e) {
+        throw asFailure(e);
+    }
+    if (!reply.ok)
+        throw new CommandFailure("refused", "USAGE_INVALID", `the daemon refused the connect check: ${reply.code} ${reply.message}`, { native: { code: reply.code } });
+    const r = reply.result;
+    const native = { native: { code: r.outcome.toUpperCase().replaceAll("-", "_") } };
+    if (r.outcome === "not-registered")
+        throw new CommandFailure("refused", "TARGET_NOT_FOUND", r.message, native);
+    if (r.outcome === "not-user-auth" || r.outcome === "unsupported-by-space")
+        throw new CommandFailure("refused", "UNSUPPORTED", r.message, native);
+    if (r.outcome === "not-signed-in")
+        throw new CommandFailure("refused", "AUTH_REQUIRED", r.message, native);
+    if (r.outcome === "unreachable")
+        throw new CommandFailure("refused", "DEPENDENCY_UNAVAILABLE", r.message, native);
+    if (r.outcome === "account-mismatch")
+        throw new CommandFailure("refused", "CONFLICT", r.message, native);
+    if (r.outcome !== "ready-to-register")
+        throw new CommandFailure("refused", "DEPENDENCY_UNAVAILABLE", r.message, native);
+    writeResult(presentation, { command: "daemon connect-check", target: { space }, result: r }, () => ({ sections: [
+            { title: "Ready to register", blocks: [
+                    { kind: "fields", rows: [["Space", r.space], ["Service", r.endpoint], ["Instance", r.instanceId], ["Account", r.accountPublicKey]] },
+                    { kind: "lines", lines: [{ text: "Nothing was registered. The space owner must approve this daemon before it can connect.", tone: "hint" }] },
+                ] },
+        ] }));
+}
 async function serve() {
     let running;
     try {
@@ -96,21 +210,27 @@ async function run(args) {
         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" });
+    if (mode === "login")
+        return login(args);
+    if (mode === "connect-check")
+        return connectCheckCommand(args);
+    throw new CommandFailure("refused", "USAGE_INVALID", mode === undefined ? "cotal daemon needs a mode: status, serve, login or connect-check" : `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>",
+    summary: "the local machine daemon (Linux): serve its control endpoint, read its status, sign it in, check whether it can connect to a space",
+    positionals: "<status|serve|login|connect-check>",
     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: "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 },
     ],
     prepareMeshTarget: false,
-    examples: ["cotal daemon serve", "cotal daemon status", "cotal daemon status --json"],
+    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"],
     run,
 };
 registry.register(daemonCommand);

package/dist/daemon/connect.js

@@ -0,0 +1,103 @@
+/**
+ * The daemon's connection readiness for one space (A2b.1). It answers whether this machine's daemon
+ * could register with the space as its own service, and if not, exactly why. It never registers,
+ * holds no bearer and starts nothing.
+ *
+ * Every input is stock: the mesh registry entry (`findMesh`), the machine's stock IdP session
+ * (`loadIdpSession`), and the registered auth provider's `serviceEndpointInfo`, which reads the
+ * space's stock service authority route (GET only, no redirects, closed parser). A 404 there means the
+ * space does not host service endpoints (stock `serviceEndpoints` is off by default); the daemon
+ * reports that, and never falls back to a Manager view, `manager.vitals` or static credentials.
+ *
+ * The daemon's identity is its own, separate from the stock Manager identity: one record per
+ * (machine home, space) under `<COTAL_HOME>/daemon/<space segment>/service-identity.json`, created
+ * once through stock `claimIdentityRecord` (exclusive create, one winner). It pins the space's
+ * DATA account on first sight; a later different account is a mismatch, never a silent repin. It
+ * holds no credential, owner, hostname or hardware id.
+ */
+import { join } from "node:path";
+import { assertLifecycleToken, isAccountNkey, mintLifecycleUid, resolveAuthProvider } from "@cotal-ai/core";
+import { claimIdentityRecord, findMesh, homeCotalDir, spaceSegment, userAuthStateDir, workspaceSecretStore } from "@cotal-ai/workspace";
+import { loadIdpSession } from "@cotal-ai/auth";
+/** The service name the daemon proposes for itself. Single-label names are reserved for reference
+ *  endpoints and a third-party name must be reverse-DNS, so this is the reverse-DNS of cotal.ai.
+ *  Binding it still needs the space operator's `name-bind`; the daemon never claims it. */
+export const DAEMON_ENDPOINT = "ai.cotal.machine";
+const KIND = "cotal-daemon-service-identity";
+/** Where this machine's daemon keeps its identity for `space`. */
+export function daemonIdentityFile(space, home = homeCotalDir()) {
+    return join(home, "daemon", spaceSegment(space), "service-identity.json");
+}
+function parseIdentity(space) {
+    return (raw) => {
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const o = raw;
+        const keys = Object.keys(o).sort().join(",");
+        if (keys !== "accountPublicKey,endpoint,instanceId,kind,space,v")
+            return undefined;
+        if (o.v !== 1 || o.kind !== KIND || o.space !== space || o.endpoint !== DAEMON_ENDPOINT || !isAccountNkey(o.accountPublicKey))
+            return undefined;
+        if (typeof o.instanceId !== "string")
+            return undefined;
+        try {
+            assertLifecycleToken(o.instanceId, "instanceId");
+        }
+        catch {
+            return undefined;
+        }
+        return o;
+    };
+}
+/** The fixed sentence per failure. Nothing from the remote side is quoted. */
+const SENTENCE = {
+    "not-registered": "this space is not registered on this machine; add it with `cotal meshes add`",
+    "not-user-auth": "this space does not use user sign-in, so the daemon cannot connect to it as its own service",
+    "not-signed-in": "this machine is not signed in to the space's provider; run `cotal daemon login --idp <url>`",
+    "unsupported-by-space": "the space's auth service does not host service endpoints, so the daemon cannot register with it",
+    unreachable: "the space's auth service could not be reached",
+    refused: "the space's auth service gave an answer the daemon cannot use",
+};
+/** Check readiness for `space`. `home` is the machine home where the stock session and the daemon's
+ *  own state live. */
+export async function connectCheck(space, home = homeCotalDir()) {
+    const entry = findMesh(space);
+    if (!entry)
+        return { outcome: "not-registered", space, message: SENTENCE["not-registered"] };
+    const ua = entry.mode === "user" ? entry.userAuth : undefined;
+    if (!ua)
+        return { outcome: "not-user-auth", space, message: SENTENCE["not-user-auth"] };
+    let session;
+    try {
+        session = loadIdpSession(home, ua.idp.url);
+    }
+    catch {
+        session = undefined;
+    }
+    if (!session)
+        return { outcome: "not-signed-in", space, message: SENTENCE["not-signed-in"] };
+    let accountPublicKey;
+    try {
+        const provider = resolveAuthProvider();
+        if (!provider.serviceEndpointInfo)
+            return { outcome: "unsupported-by-space", space, message: SENTENCE["unsupported-by-space"] };
+        const info = await provider.serviceEndpointInfo({ store: workspaceSecretStore(entry.root), dir: userAuthStateDir(entry.root, space, { readOnly: true }), space });
+        accountPublicKey = info.accountPublicKey;
+    }
+    catch (e) {
+        const status = e.httpStatus;
+        if (status === 404)
+            return { outcome: "unsupported-by-space", space, message: SENTENCE["unsupported-by-space"] };
+        if (status === undefined && e.outcome === "not-executed" && /did not return a response/.test(e.message))
+            return { outcome: "unreachable", space, message: SENTENCE.unreachable };
+        return { outcome: "refused", space, message: SENTENCE.refused };
+    }
+    const identity = claimIdentityRecord(daemonIdentityFile(space, home), "daemon service identity", parseIdentity(space), () => ({
+        v: 1, kind: KIND, space, endpoint: DAEMON_ENDPOINT, instanceId: mintLifecycleUid(), accountPublicKey,
+    }));
+    if (identity.accountPublicKey !== accountPublicKey)
+        return { outcome: "account-mismatch", space, pinnedAccountPublicKey: identity.accountPublicKey, observedAccountPublicKey: accountPublicKey,
+            message: "the space now answers with a different account than this daemon pinned; nothing was changed. Confirm the space was not replaced before removing the daemon's identity for it by hand" };
+    return { outcome: "ready-to-register", space, endpoint: DAEMON_ENDPOINT, instanceId: identity.instanceId, accountPublicKey,
+        message: "this daemon can ask the space to register it; the space owner must still approve it, and nothing has been registered" };
+}

package/dist/daemon/login.js

@@ -0,0 +1,111 @@
+/**
+ * The daemon's local sign-in: one attempt at a time, driven through stock `establishIdpSession`,
+ * which persists the session through the stock writer and fences persistence on its AbortSignal.
+ *
+ * Attempts are named by a daemon-minted id. A cancel names the attempt it means, so a cancel aimed
+ * at a finished attempt can never stop its successor. A cancel is answered only after the attempt
+ * has settled, meaning its result has been delivered to the requester, and it answers with what
+ * actually happened: `cancelled` when the stock fence stopped it before anything was persisted,
+ * `completed` when it had already finished (or finished while the cancel raced it), and `not-found`
+ * for an attempt this daemon never started or no longer remembers. Until that delivery the attempt
+ * stays in flight, so no second sign-in starts underneath an undelivered result.
+ *
+ * A failure crosses the endpoint as a fixed sentence per reason. Stock error text can quote the
+ * provider's answer, so none of it is relayed.
+ *
+ * Cancelling stops this local sign-in. It does not revoke anything at the IdP.
+ */
+import { randomBytes } from "node:crypto";
+import { establishIdpSession, IdpLoginCancelled, IdpUnreachableError } from "@cotal-ai/auth";
+/** The client id stock `cotal login` presents by default. */
+export const DEFAULT_CLIENT_ID = "cotal-cli";
+/** How many finished attempt ids are remembered, so a late cancel still gets a truthful answer. */
+const REMEMBERED = 16;
+/** The only failure text a requester sees. It never quotes the provider or a stock error. */
+const FAILURE = {
+    denied: "the sign-in was denied at the verification page",
+    expired: "the approval code expired before the sign-in was approved",
+    unreachable: "the provider could not be reached",
+    refused: "the provider's answer could not be used to sign in",
+};
+const failed = (reason) => ({ outcome: "failed", reason, message: FAILURE[reason] });
+export function createLoginCoordinator(opts) {
+    const establish = opts.establish ?? establishIdpSession;
+    let current;
+    const finished = new Map();
+    const remember = (id, outcome) => {
+        finished.set(id, outcome);
+        while (finished.size > REMEMBERED)
+            finished.delete(finished.keys().next().value);
+    };
+    const run = async (id, abort, req) => {
+        try {
+            const r = await establish({
+                dir: opts.sessionDir,
+                idpUrl: req.idp,
+                clientId: req.clientId ?? DEFAULT_CLIENT_ID,
+                signal: abort.signal,
+                onPrompt: (p) => req.onPrompt(id, {
+                    verificationUri: p.verificationUri,
+                    verificationUriComplete: p.verificationUriComplete,
+                    userCode: p.userCode,
+                    expiresAt: new Date(Date.now() + p.expiresInSec * 1000).toISOString(),
+                }),
+            });
+            return { outcome: "signed-in", idp: req.idp, sub: r.sub, ...(r.label ? { label: r.label } : {}), ...(r.previousSub ? { previousSub: r.previousSub } : {}) };
+        }
+        catch (e) {
+            if (e instanceof IdpLoginCancelled)
+                return { outcome: "cancelled" };
+            if (e instanceof IdpUnreachableError)
+                return failed("unreachable");
+            // Stock throws plain Errors for these two IdP answers; match their exact sentences.
+            const message = e instanceof Error ? e.message : "";
+            if (message.startsWith("idp login: the sign-in was denied at the verification page"))
+                return failed("denied");
+            if (message.startsWith("idp login: the device code expired"))
+                return failed("expired");
+            return failed("refused");
+        }
+    };
+    return {
+        start(req) {
+            if (current)
+                return undefined;
+            const id = randomBytes(16).toString("base64url").slice(0, 22);
+            const abort = new AbortController();
+            const settled = run(id, abort, req).then(async (result) => {
+                try {
+                    await req.onResult(id, result);
+                }
+                finally {
+                    remember(id, result.outcome);
+                    if (current?.id === id)
+                        current = undefined;
+                }
+                return result;
+            });
+            current = { id, abort, settled };
+            return { attempt: id, settled };
+        },
+        async cancel(attempt) {
+            if (current?.id === attempt) {
+                const live = current;
+                live.abort.abort();
+                const result = await live.settled;
+                return { outcome: result.outcome === "cancelled" ? "cancelled" : "completed", attempt };
+            }
+            const past = finished.get(attempt);
+            if (past === undefined)
+                return { outcome: "not-found", attempt };
+            return { outcome: past === "cancelled" ? "cancelled" : "completed", attempt };
+        },
+        async close() {
+            const live = current;
+            if (!live)
+                return;
+            live.abort.abort();
+            await live.settled;
+        },
+    };
+}

package/dist/daemon/protocol.js

@@ -1,14 +1,34 @@
 /**
  * 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.
+ * A request names `{ v, id, op }` plus exactly the fields its op declares. Any other key, any other
+ * version, an unknown op, a field of the wrong shape, 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.
+ *
+ * Sign-in streams: `login-start` answers with one `login-prompt` event, then exactly one
+ * `login-result` event, both tagged with the request id and the attempt id. No frame carries a
+ * session, token, JWT or device code; the verification URL and user code are the only IdP values
+ * the requester sees, because a person must type them.
  */
+import { normalizeIdpUrl } from "@cotal-ai/auth";
 import { DAEMON_PROTOCOL_VERSION, MAX_LINE_BYTES } from "./endpoint.js";
-export const DAEMON_OPS = ["status"];
-const REQUEST_KEYS = new Set(["v", "id", "op"]);
+export const DAEMON_OPS = ["status", "login-start", "login-cancel", "connect-check"];
+/** The fields each op takes besides `v`, `id` and `op`. Required ones must be present. */
+const OP_FIELDS = {
+    status: { required: [], optional: [] },
+    "login-start": { required: ["idp"], optional: ["clientId"] },
+    "login-cancel": { required: ["attempt"], optional: [] },
+    "connect-check": { required: ["space"], optional: [] },
+};
+const ENVELOPE_KEYS = new Set(["v", "id", "op"]);
 const ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+/** An attempt id is daemon-minted: 22 characters of base64url. */
+export const ATTEMPT_PATTERN = /^[A-Za-z0-9_-]{22}$/;
+const MAX_CLIENT_ID = 128;
+/** A space name as it appears in a subject token. */
+const SPACE_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+const bad = (id, message) => ({ ok: false, id, code: "BAD_FIELD", message });
 /** 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)
@@ -24,17 +44,43 @@ export function parseRequest(line) {
         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;
+    const op = typeof obj.op === "string" && DAEMON_OPS.includes(obj.op) ? obj.op : undefined;
+    const fields = op ? OP_FIELDS[op] : { required: [], optional: [] };
     for (const k of Object.keys(obj)) {
-        if (!REQUEST_KEYS.has(k))
+        if (!ENVELOPE_KEYS.has(k) && !fields.required.includes(k) && !fields.optional.includes(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))
+    if (!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 } };
+    const v = DAEMON_PROTOCOL_VERSION;
+    if (op === "status")
+        return { ok: true, request: { v, id, op } };
+    if (op === "login-cancel") {
+        if (typeof obj.attempt !== "string" || !ATTEMPT_PATTERN.test(obj.attempt))
+            return bad(id, "attempt must be the 22-character attempt id from login-prompt");
+        return { ok: true, request: { v, id, op, attempt: obj.attempt } };
+    }
+    if (op === "connect-check") {
+        if (typeof obj.space !== "string" || !SPACE_PATTERN.test(obj.space))
+            return bad(id, "space must be 1-64 characters of [A-Za-z0-9_-]");
+        return { ok: true, request: { v, id, op, space: obj.space } };
+    }
+    if (typeof obj.idp !== "string")
+        return bad(id, "idp must be the provider's auth base URL");
+    let idp;
+    try {
+        idp = normalizeIdpUrl(obj.idp);
+    }
+    catch {
+        return bad(id, "idp must be an HTTPS auth URL, or an HTTP loopback IP URL, without embedded credentials, a query or a fragment");
+    }
+    if (obj.clientId !== undefined && (typeof obj.clientId !== "string" || !obj.clientId.trim() || obj.clientId.length > MAX_CLIENT_ID))
+        return bad(id, `clientId must be a non-empty string of at most ${MAX_CLIENT_ID} characters`);
+    return { ok: true, request: { v, id, op, idp, ...(obj.clientId !== undefined ? { clientId: obj.clientId } : {}) } };
 }
 export function encode(msg) {
     return `${JSON.stringify(msg)}\n`;