@actario/cli 0.1.1 → 0.1.2

package/README.md

@@ -11,22 +11,26 @@ land in an inbox for you to confirm before any other agent can see them.
 ## Install
 
 ```
-npx @actario/cli init
+npx @actario/cli login
 ```
 
 Or install it for real:
 
 ```
 npm install -g @actario/cli
-actario init
+actario login
 ```
 
-`init` asks for your workspace API URL and a capture token, checks the token
-before writing anything, and registers this machine as a source.
+`login` opens your browser at Actario: sign in with your own account, pick a
+workspace and approve. This machine is then linked -- no token to copy. On a
+machine without a browser (SSH, a container), `actario login --device` prints
+a URL and a short code to approve from any device. `actario init` still takes
+a pasted capture token if you prefer.
 
 ## Commands
 
 ```
+actario login         link this machine by signing in with the browser
 actario capture       capture, redact and upload new sessions
 actario analyze       analyse the captured batch here, on your own subscription
 actario status        local capture state, or one upload's progress

package/dist/actario.js

@@ -564,7 +564,7 @@ var flagBool = (a, k) => a.flags[k] === true || a.flags[k] === "true";
 var flagList = (a, k) => (flagString(a, k) ?? "").split(",").map((s) => s.trim()).filter(Boolean);
 
 // ../../apps/cli/src/version.ts
-var CLI_VERSION = "0.1.1";
+var CLI_VERSION = "0.1.2";
 
 // ../../apps/cli/src/print.ts
 var useColour = process.stdout.isTTY && !process.env.NO_COLOR;
@@ -4718,7 +4718,7 @@ ${dim("is safe to paste into a report as-is.")}
 
 // ../../apps/cli/src/commands/init.ts
 import { createInterface as createInterface2 } from "node:readline/promises";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 
 // ../../apps/cli/src/core/link.ts
 import { hostname } from "node:os";
@@ -4776,6 +4776,335 @@ async function linkMachine(opts) {
   return { config, identity, source, sourceCreated, sources };
 }
 
+// ../../apps/cli/src/commands/login.ts
+import { join as join21 } from "node:path";
+
+// ../../apps/cli/src/core/device-login.ts
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { hostname as hostname2 } from "node:os";
+var DEFAULT_API_URL = "https://distill-web-ten.vercel.app";
+function defaultApiUrl() {
+  return (readConfig().api_url ?? actarioEnv("API_URL") ?? DEFAULT_API_URL).replace(/\/+$/, "");
+}
+async function post(base, path, body) {
+  let res;
+  try {
+    res = await fetch(new URL(path, base), { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+  } catch (e) {
+    return { ok: false, status: 0, code: "network", message: e.message };
+  }
+  const json = await res.json().catch(() => null);
+  if (res.ok && json) return { ok: true, data: json };
+  return { ok: false, status: res.status, code: json?.error?.code ?? `http_${res.status}`, message: json?.error?.message ?? `${res.status} ${res.statusText}` };
+}
+function canOpenBrowser() {
+  if (process.platform === "win32" || process.platform === "darwin") return true;
+  return Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+}
+async function openInBrowser(url) {
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    return false;
+  }
+  if (u.protocol !== "https:" && u.protocol !== "http:" || !u.hostname || /[\s"'`]/.test(url)) return false;
+  if (!canOpenBrowser()) return false;
+  const plat = process.platform;
+  const [cmd, args] = plat === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", u.href]] : plat === "darwin" ? ["open", [u.href]] : ["xdg-open", [u.href]];
+  return new Promise((resolve4) => {
+    try {
+      const child = spawn(cmd, args, { stdio: "ignore", detached: true, windowsHide: true });
+      child.once("error", () => resolve4(false));
+      child.once("spawn", () => {
+        child.unref();
+        resolve4(true);
+      });
+    } catch {
+      resolve4(false);
+    }
+  });
+}
+var escapeHtml = (s) => s.replace(/[&<>"']/g, (c2) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c2]);
+function resultPage(title, body, ok2) {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Actario \xB7 ${escapeHtml(title)}</title>
+<style>
+:root{color-scheme:light dark;--bg:#fafafa;--ink:#18181b;--muted:#52525b;--line:#e4e4e7;--mark:${ok2 ? "#15803d" : "#b91c1c"}}
+@media (prefers-color-scheme:dark){:root{--bg:#0f0f10;--ink:#f4f4f5;--muted:#a1a1aa;--line:#27272a;--mark:${ok2 ? "#4ade80" : "#f87171"}}}
+body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif;display:grid;place-items:center;min-height:100vh;padding:16px;box-sizing:border-box}
+main{max-width:460px;border:1px solid var(--line);border-radius:12px;padding:24px 26px}
+h1{font-size:19px;margin:0 0 8px;display:flex;gap:10px;align-items:center}
+h1::before{content:"";width:10px;height:10px;border-radius:50%;background:var(--mark)}
+p{margin:0;color:var(--muted)}
+</style></head><body><main><h1>${escapeHtml(title)}</h1><p>${escapeHtml(body)}</p></main></body></html>`;
+}
+async function listenLoopback() {
+  const server = createServer();
+  await new Promise((resolve4, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve4());
+  });
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("no port");
+  return { server, port: addr.port };
+}
+var MAX_INTERVAL_MS = 3e4;
+async function startDeviceLogin(opts = {}) {
+  const apiUrl = (opts.apiUrl ?? defaultApiUrl()).replace(/\/+$/, "");
+  if (!/^https?:\/\//.test(apiUrl)) throw new DistillError("invalid_request", "api_url must start with http:// or https://");
+  const launch = opts.launch ?? openInBrowser;
+  const wantBrowser = opts.openBrowser ?? !actarioEnv("NO_BROWSER");
+  const canLaunch = wantBrowser && (opts.launch ? true : canOpenBrowser());
+  const requestCode = async (redirect) => {
+    const r = await post(apiUrl, "/api/v1/device/code", {
+      client_name: opts.clientName ?? "Actario CLI",
+      client_host: opts.label ?? hostname2(),
+      ...redirect ? { redirect_uri: redirect } : {}
+    });
+    if (r.ok) return r.data;
+    if (r.status === 404 || r.status === 405) {
+      throw new DistillError(
+        "not_found",
+        `${apiUrl} does not support signing in from Claude yet (no /api/v1/device/code). Link with a token from Settings \u2192 Access tokens instead.`
+      );
+    }
+    if (r.code === "network") throw new DistillError("internal", `Could not reach ${apiUrl}: ${r.message}`, void 0, 502);
+    throw new DistillError(r.code, r.message, void 0, r.status);
+  };
+  let local = null;
+  if (opts.loopback !== false && canLaunch) {
+    try {
+      local = await listenLoopback();
+    } catch {
+      local = null;
+    }
+  }
+  let s;
+  try {
+    s = await requestCode(local ? `http://127.0.0.1:${local.port}/callback` : null);
+  } catch (e) {
+    local?.server.close();
+    throw e;
+  }
+  const launched = canLaunch ? await launch(s.verification_uri_complete) : false;
+  if (local && !launched) {
+    local.server.close();
+    local = null;
+    s = await requestCode(null);
+  }
+  const prompt = {
+    verification_uri: s.verification_uri,
+    verification_uri_complete: s.verification_uri_complete,
+    user_code: s.user_code,
+    expires_in: s.expires_in,
+    browser_opened: launched,
+    loopback: local !== null
+  };
+  let cancelled = false;
+  let approvalCode = null;
+  let wake = null;
+  let state = { status: "waiting" };
+  const deadline = Date.now() + s.expires_in * 1e3;
+  let interval = Math.max(1, s.interval) * 1e3;
+  const sleep = (ms) => new Promise((resolve4) => {
+    const t = setTimeout(() => {
+      wake = null;
+      resolve4();
+    }, ms);
+    wake = () => {
+      clearTimeout(t);
+      wake = null;
+      resolve4();
+    };
+  });
+  const poll = async () => {
+    for (; ; ) {
+      if (cancelled) throw new DistillError("expired_token", "Sign-in was cancelled.");
+      if (Date.now() > deadline) throw new DistillError("expired_token", "The sign-in code expired before it was approved. Start again.");
+      const r = await post(apiUrl, "/api/v1/device/token", {
+        device_code: s.device_code,
+        ...approvalCode ? { approval_code: approvalCode } : {}
+      });
+      if (r.ok) return r.data;
+      if (r.code === "authorization_pending" || r.code === "network" || r.status >= 500) {
+        await sleep(interval);
+        continue;
+      }
+      if (r.code === "slow_down") {
+        interval = Math.min(MAX_INTERVAL_MS, interval + 5e3);
+        await sleep(interval);
+        continue;
+      }
+      if (r.code === "access_denied") throw new DistillError("access_denied", "The sign-in was declined in the browser. Nothing was linked.", void 0, 403);
+      throw new DistillError(r.code ?? "expired_token", r.message, void 0, r.status);
+    }
+  };
+  const revoke = async (tok) => {
+    if (!tok.token_id) return;
+    await fetch(new URL(`/api/v1/tokens/${tok.token_id}`, apiUrl), {
+      method: "DELETE",
+      headers: { authorization: `Bearer ${tok.access_token}` }
+    }).catch(() => void 0);
+  };
+  const done = (async () => {
+    const tok = await poll();
+    if (cancelled) {
+      await revoke(tok);
+      throw new DistillError("expired_token", "Sign-in was cancelled.");
+    }
+    let lastErr;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const linked = await linkMachine({
+          apiUrl,
+          token: tok.access_token,
+          ...opts.label ? { label: opts.label } : {},
+          ...opts.profile ? { profile: opts.profile } : {}
+        });
+        return { ...linked, email: tok.email, workspace_name: tok.workspace.name, api_url: apiUrl };
+      } catch (e) {
+        lastErr = e;
+        if (e.code !== "internal") break;
+        await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+      }
+    }
+    await revoke(tok);
+    const m = lastErr?.message ?? String(lastErr);
+    throw new DistillError(
+      lastErr?.code ?? "internal",
+      `Signed in, but registering this machine failed (${m}). The new key was revoked; run the sign-in again.`
+    );
+  })();
+  done.then(
+    () => {
+      state = { status: "linked" };
+    },
+    (e) => {
+      const err = e;
+      state = { status: "failed", error: { code: err.code ?? "internal", message: err.message } };
+    }
+  );
+  if (local) {
+    const expectedHost = `127.0.0.1:${local.port}`;
+    local.server.on("request", (req, res) => {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== "/callback" || req.method !== "GET" || req.headers.host !== expectedHost) {
+        res.writeHead(404, { "content-type": "text/plain" }).end("Not found");
+        return;
+      }
+      const status = url.searchParams.get("status");
+      const code = url.searchParams.get("code");
+      if (status === "approved" && code && /^[0-9a-f]{64}$/.test(code)) approvalCode ??= code;
+      else if (status !== "denied") {
+        res.writeHead(400, { "content-type": "text/plain" }).end("Bad request");
+        return;
+      }
+      wake?.();
+      const settled = Promise.race([
+        done.then((r) => ({ ok: true, r }), (e) => ({ ok: false, e })),
+        new Promise((resolve4) => setTimeout(() => resolve4(null), 15e3))
+      ]);
+      void settled.then((out) => {
+        const html = out === null ? resultPage("Almost there", "Approved. Actario is finishing the link on this machine; go back to Claude, it will confirm there.", true) : out.ok ? resultPage("Linked", `This machine is linked to ${out.r.workspace_name ?? "your workspace"}${out.r.email ? ` as ${out.r.email}` : ""}. You can close this tab and go back to Claude.`, true) : resultPage(out.e.code === "access_denied" ? "Declined" : "Not linked", out.e.message, false);
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "referrer-policy": "no-referrer" }).end(html);
+      });
+    });
+    const server = local.server;
+    const closeLocal = () => setTimeout(() => {
+      server.close();
+      server.closeAllConnections?.();
+    }, 2e4).unref();
+    done.then(closeLocal, closeLocal);
+    server.unref();
+  }
+  return {
+    prompt,
+    done,
+    state: () => state,
+    cancel: () => {
+      cancelled = true;
+      wake?.();
+    }
+  };
+}
+
+// ../../apps/cli/src/commands/login.ts
+async function loginCommand(args) {
+  const device = flagBool(args, "device");
+  const profile = flagString(args, "profile");
+  process.stdout.write(heading("Sign in to Actario"));
+  let login;
+  try {
+    login = await startDeviceLogin({
+      ...flagString(args, "api-url") ? { apiUrl: flagString(args, "api-url") } : {},
+      clientName: "Actario CLI",
+      ...flagString(args, "label") ? { label: flagString(args, "label") } : {},
+      ...profile === "medical" || profile === "general" ? { profile } : {},
+      ...device || flagBool(args, "no-browser") ? { loopback: false, openBrowser: false } : {}
+    });
+  } catch (e) {
+    process.stderr.write(`${red("Could not start the sign-in.")} ${e.message}
+`);
+    return 1;
+  }
+  const p = login.prompt;
+  if (p.browser_opened) {
+    process.stdout.write(`A browser tab should have opened. If it didn't, open this on THIS machine:
+
+  ${bold(p.verification_uri_complete)}
+
+${dim(`If approving ends on a "can't connect" page, press Ctrl-C and run ${bold("actario login --device")} instead.`)}
+`);
+  } else {
+    process.stdout.write(`On any device, open
+
+  ${bold(p.verification_uri)}
+
+and enter the code
+
+  ${bold(p.user_code)}
+
+`);
+  }
+  process.stdout.write(`${dim(`Check the page shows ${p.user_code}. The code expires in ${Math.round(p.expires_in / 60)} minutes.`)}
+`);
+  process.stdout.write(`${dim("Waiting for approval\u2026")}
+`);
+  const onInt = () => login.cancel();
+  process.once("SIGINT", onInt);
+  try {
+    const r = await login.done;
+    process.stdout.write(
+      `
+${green("Linked")}${r.email ? ` as ${r.email}` : ""} to ${bold(r.workspace_name ?? r.identity.workspace_id ?? "your workspace")}
+  source   ${r.source.id}${"label" in r.source && r.source.label ? dim(`  (${r.source.label}${r.sourceCreated ? ", created" : ""})`) : ""}
+  saved    ${dim(join21(actarioDir(), "config.json"))}
+${dim('The key is listed under Settings \u2192 Access tokens as "Claude \xB7 <this machine>"; revoke it there.')}
+`
+    );
+    process.stdout.write(heading("Sources on this machine"));
+    for (const s of r.sources) {
+      const mark = s.found ? green("found") : yellow("not found");
+      process.stdout.write(`  ${s.id.padEnd(24)} ${mark}  ${s.found ? dim(`~${s.approxUnits} unit(s)`) : dim(s.note ?? "")}
+`);
+    }
+    process.stdout.write(`
+Next: ${bold("actario capture --dry-run")} to see what would be uploaded.
+`);
+    return 0;
+  } catch (e) {
+    const err = e;
+    process.stderr.write(`
+${red(err.code === "access_denied" ? "Declined." : "Not linked.")} ${err.message}
+`);
+    return 1;
+  } finally {
+    process.off("SIGINT", onInt);
+  }
+}
+
 // ../../apps/cli/src/commands/init.ts
 async function initCommand(args) {
   const cfg = readConfig();
@@ -4789,10 +5118,14 @@ async function initCommand(args) {
   try {
     process.stdout.write(heading("Actario setup"));
     const apiUrl = flagString(args, "api-url") ?? await ask("API URL", cfg.api_url ?? "http://localhost:3000");
-    const token = flagString(args, "token") ?? await ask("Capture token (scope: capture)", cfg.token);
+    const token = flagString(args, "token") ?? await ask("Capture token (empty = sign in with the browser instead)", cfg.token);
     const profile = flagString(args, "profile") ?? await ask("Redaction profile (medical|general)", cfg.redaction_profile);
+    if (apiUrl && !token && interactive) {
+      rl?.close();
+      return loginCommand({ ...args, flags: { ...args.flags, "api-url": apiUrl, ...profile ? { profile } : {} } });
+    }
     if (!apiUrl || !token) {
-      process.stderr.write(`${red("Both an API URL and a token are needed.")}
+      process.stderr.write(`${red("Both an API URL and a token are needed.")} Or run ${bold("actario login")} to sign in with the browser.
 `);
       return 1;
     }
@@ -4831,8 +5164,8 @@ Nothing was written.
       `
 ${green("Linked")} as ${dim(r.identity.user_id ?? "user")} to workspace ${dim(r.identity.workspace_id ?? "(first membership)")}
   source   ${r.source.id}${"label" in r.source && r.source.label ? dim(`  (${r.source.label}${r.sourceCreated ? ", created" : ""})`) : ""}
-  saved    ${dim(join21(dir, "config.json"))}
-${dim(`Pseudonym salt at ${join21(dir, "salt")} -- never uploaded, back it up if you care about cross-capture linking.`)}
+  saved    ${dim(join22(dir, "config.json"))}
+${dim(`Pseudonym salt at ${join22(dir, "salt")} -- never uploaded, back it up if you care about cross-capture linking.`)}
 `
     );
     process.stdout.write(heading("Sources on this machine"));
@@ -4891,12 +5224,12 @@ function apiFromConfig() {
 }
 async function writeGuard() {
   const api = apiFromConfig();
-  if (!api) return fail("not_linked", "This machine is not linked to a workspace. Call `link` with an API URL and a capture token first.");
+  if (!api) return fail("not_linked", "This machine is not linked to a workspace. Call `link` first (with no arguments it signs the user in through the browser).");
   let me;
   try {
     me = await whoami(api);
   } catch (e) {
-    if (e instanceof DistillError && e.code === "unauthorized") return fail("unauthorized", "The configured token was rejected by the server. Re-link with a fresh token.");
+    if (e instanceof DistillError && e.code === "unauthorized") return fail("unauthorized", "The configured token was rejected by the server (revoked?). Call `link` again to sign in.");
     const msg = e instanceof Error ? e.message : String(e);
     return fail("internal", `Could not verify the token against ${api.baseUrl} (${msg}). Nothing was captured; retry when the API is reachable.`);
   }
@@ -4906,26 +5239,100 @@ async function writeGuard() {
 }
 function buildServer() {
   const server = new McpServer({ name: "actario-capture", version: CLI_VERSION });
+  let pending = null;
+  let starting = null;
+  const linkedBody = (r, via) => ({
+    linked: true,
+    via,
+    ...r.email ? { account: r.email } : {},
+    workspace_id: r.identity.workspace_id,
+    ...r.workspace_name ? { workspace_name: r.workspace_name } : {},
+    source: { id: r.source.id, label: "label" in r.source ? r.source.label : null, created: r.sourceCreated },
+    config_path: `${actarioDir()}/config.json`,
+    sources_on_this_machine: r.sources,
+    next: "Call `capture` (optionally with a `record` of this conversation), then `list_runs`, `read_run`, and `submit_daf`."
+  });
+  const awaitPending = async (seconds) => {
+    if (!pending) return fail("not_found", "No sign-in is in progress. Call `link` to start one.");
+    const p = pending;
+    const out = await Promise.race([
+      p.login.done.then((r) => ({ r }), (e) => ({ e })),
+      new Promise((resolve4) => setTimeout(() => resolve4(null), Math.max(0, seconds) * 1e3))
+    ]);
+    if (out === null) {
+      const left = Math.max(0, Math.round(p.login.prompt.expires_in - (Date.now() - p.startedAt) / 1e3));
+      return ok({
+        linked: false,
+        status: "waiting_for_approval",
+        verification_uri: p.login.prompt.verification_uri,
+        verification_uri_complete: p.login.prompt.verification_uri_complete,
+        user_code: p.login.prompt.user_code,
+        browser_opened: p.login.prompt.browser_opened,
+        expires_in_seconds: left,
+        server: new URL(p.login.prompt.verification_uri).host,
+        tell_the_user: p.login.prompt.browser_opened ? `A browser tab opened at the Actario sign-in page (${new URL(p.login.prompt.verification_uri).host}). Sign in, check the code is ${p.login.prompt.user_code}, pick a workspace and click Approve. (If no tab appeared, open ${p.login.prompt.verification_uri_complete}.)` : `Open ${p.login.prompt.verification_uri} on any device, sign in, and enter the code ${p.login.prompt.user_code}. Then pick a workspace and click Approve.`,
+        next: 'Show the user the URL and code above, then call `link_status` to wait for their approval (it waits up to ~45 s per call; call again if still waiting). If a browser tab opened but approving there fails to come back ("can\'t connect"), call `link` with method: "code".'
+      });
+    }
+    if (pending === p) pending = null;
+    if ("e" in out) return fail(out.e.code ?? "internal", out.e.message);
+    return ok(linkedBody(out.r, "browser"));
+  };
   server.registerTool("link", {
-    title: "Link this machine to an Actario workspace",
-    description: "Validate a capture token against the API, register (or find) this machine as a source, and save the config. Call once per machine. Refuses agent tokens and tokens without the capture scope. Nothing is written if validation fails.",
+    title: "Link this machine to an Actario account",
+    description: "Connect this machine to the user's Actario workspace so `capture` can upload. With no token (recommended): starts a browser sign-in -- a tab opens on the user's machine where they log in to their own Actario account and approve; if no browser can open, returns a URL and a short code to show the user (they can approve from any device). With a token: validates a capture token pasted from Settings instead. Either way it registers this machine as a source and saves the config. Refuses agent tokens and tokens without the capture scope. Nothing is written until the link succeeds.",
     inputSchema: {
-      api_url: z9.string().url().describe("Actario API base URL, e.g. https://distill-web-ten.vercel.app"),
-      token: z9.string().min(8).describe("A personal access token with the capture scope, from the web app's Settings page"),
+      api_url: z9.string().url().optional().describe(`Actario base URL. Defaults to the one already configured, else ACTARIO_API_URL, else ${DEFAULT_API_URL}`),
+      token: z9.string().min(8).optional().describe("Only if the user pasted one: a personal access token with the capture scope. Omit to sign in through the browser."),
       label: z9.string().min(1).max(80).optional().describe("Name for this machine on the Sources page. Defaults to the hostname."),
-      profile: z9.enum(["general", "medical"]).optional().describe("Redaction profile. medical is one-way and excludes this source from the corpus for good.")
+      profile: z9.enum(["general", "medical"]).optional().describe("Redaction profile. medical is one-way and excludes this source from the corpus for good."),
+      method: z9.enum(["auto", "code"]).optional().describe("Browser sign-in only. auto (default): open a browser on this machine if there is one (it comes back through localhost), else fall back to a code. code: skip the browser; just return a URL + code for the user to approve on any device."),
+      wait_seconds: z9.number().int().min(0).max(55).optional().describe("Browser sign-in only: how long to wait for approval before returning the URL and code. Default 45 if a browser opened, else 0."),
+      switch_server: z9.boolean().optional().describe("Required (true) to link to a different Actario server than the one this machine is linked to now. Only set it after the user confirmed the new URL.")
     }
   }, guarded(async (a) => {
-    const r = await linkMachine({ apiUrl: a.api_url, token: a.token, ...a.label ? { label: a.label } : {}, ...a.profile ? { profile: a.profile } : {} });
-    return ok({
-      linked: true,
-      workspace_id: r.identity.workspace_id,
-      source: { id: r.source.id, label: "label" in r.source ? r.source.label : null, created: r.sourceCreated },
-      config_path: `${actarioDir()}/config.json`,
-      sources_on_this_machine: r.sources,
-      next: "Call `capture` (optionally with a `record` of this conversation), then `list_runs`, `read_run`, and `submit_daf`."
-    });
+    const cfg = readConfig();
+    const target = (a.api_url ?? defaultApiUrl()).replace(/\/+$/, "");
+    if (cfg.api_url && cfg.token && cfg.api_url.replace(/\/+$/, "") !== target && !a.switch_server) {
+      return fail(
+        "confirm_required",
+        `This machine is linked to ${cfg.api_url}. Linking to ${target} instead would send future captures there. Ask the user to confirm that URL, then call \`link\` again with switch_server: true.`
+      );
+    }
+    if (a.token) {
+      pending?.login.cancel();
+      pending = null;
+      const r = await linkMachine({ apiUrl: target, token: a.token, ...a.label ? { label: a.label } : {}, ...a.profile ? { profile: a.profile } : {} });
+      return ok(linkedBody(r, "token"));
+    }
+    const key = JSON.stringify([target, a.method ?? "auto", a.label ?? null, a.profile ?? null]);
+    while (starting) await starting.catch(() => void 0);
+    if (!pending || pending.key !== key || pending.login.state().status !== "waiting") {
+      pending?.login.cancel();
+      pending = null;
+      const p = startDeviceLogin({
+        apiUrl: target,
+        clientName: "Claude (Actario MCP)",
+        ...a.label ? { label: a.label } : {},
+        ...a.profile ? { profile: a.profile } : {},
+        ...a.method === "code" ? { loopback: false, openBrowser: false } : {}
+      });
+      starting = p;
+      try {
+        pending = { login: await p, startedAt: Date.now(), key };
+      } finally {
+        starting = null;
+      }
+    }
+    return awaitPending(a.wait_seconds ?? (pending.login.prompt.browser_opened ? 45 : 0));
   }));
+  server.registerTool("link_status", {
+    title: "Finish a browser sign-in",
+    description: "After `link` returned a URL and code: wait for the user to approve in the browser, then finish linking. Returns linked:true when done, or the same URL/code if they have not approved yet (call again).",
+    inputSchema: {
+      wait_seconds: z9.number().int().min(0).max(55).optional().describe("How long to wait for approval in this call. Default 45.")
+    }
+  }, guarded(async (a) => awaitPending(a.wait_seconds ?? 45)));
   server.registerTool("capture", {
     title: "Capture sessions and upload them",
     description: "Run the capture pipeline on this machine: scan sources, redact, score, pack, upload, and keep the bundle locally for analysis. Pass `record` to capture THIS conversation: a distill.chat/v1 record (turns as said, no summarising, no redacting -- the pipeline redacts, with rules no flag reaches). Without `record`, scans the installed adapters. `dry_run` reports without uploading or changing state. Redaction cannot be disabled here.",
@@ -5162,7 +5569,7 @@ async function mcpCommand(_args) {
 }
 
 // ../../apps/cli/src/commands/reset-state.ts
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 async function resetStateCommand(args) {
   const sources = flagList(args, "sources");
   const state = readState();
@@ -5195,7 +5602,7 @@ async function resetStateCommand(args) {
     `
 ${green("Done.")} The next ${bold("actario capture")} will re-read everything from these sources.
 ${dim("The server deduplicates by content hash, so nothing is uploaded twice.")}
-${dim(`State file: ${join22(actarioDir(), "state.json")}`)}
+${dim(`State file: ${join23(actarioDir(), "state.json")}`)}
 `
   );
   return 0;
@@ -5254,7 +5661,7 @@ async function statusCommand(args) {
 
 // ../../apps/cli/src/commands/unmask.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync5, readdirSync, statSync, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename2, dirname as dirname4, join as join23, relative, resolve as resolve2, sep } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join24, relative, resolve as resolve2, sep } from "node:path";
 async function unmaskCommand(args) {
   const input = args.positional[0];
   if (!input) {
@@ -5269,8 +5676,8 @@ async function unmaskCommand(args) {
     return 1;
   }
   const home = actarioDir();
-  const saltPath = join23(home, "salt");
-  const mapPath = join23(home, "redaction_map.json.enc");
+  const saltPath = join24(home, "salt");
+  const mapPath = join24(home, "redaction_map.json.enc");
   if (!existsSync8(saltPath) || !existsSync8(mapPath)) {
     process.stderr.write(
       `${red("No redaction map on this machine.")} ${dim(`(${mapPath})`)}
@@ -5304,11 +5711,11 @@ ${dim("Pass --out to choose another.")}
   const members = isDir ? readDir(inputPath) : readZip(readFileSync5(inputPath)).map((m) => ({ name: m.name, data: m.data() }));
   const { members: out, report } = unmaskMembers(members, reverse);
   for (const m of out) {
-    const target = join23(outDir, ...m.name.split("/"));
+    const target = join24(outDir, ...m.name.split("/"));
     mkdirSync7(dirname4(target), { recursive: true });
     writeFileSync7(target, m.data);
   }
-  writeFileSync7(join23(outDir, UNMASK_MARKER_NAME), UNMASK_MARKER_TEXT, { mode: 384 });
+  writeFileSync7(join24(outDir, UNMASK_MARKER_NAME), UNMASK_MARKER_TEXT, { mode: 384 });
   const total = Object.values(report.replaced).reduce((a, b) => a + b, 0);
   process.stdout.write(heading(`Unmasked ${out.length} file(s) \u2192 ${outDir}`));
   if (total === 0) process.stdout.write(`  ${dim("No pseudonyms from this machine were found.")}
@@ -5331,13 +5738,13 @@ ${dim("Pass --out to choose another.")}
 function defaultOut(inputPath, isDir) {
   const base = basename2(inputPath);
   const stem = !isDir && base.toLowerCase().endsWith(".zip") ? base.slice(0, -4) : base;
-  return join23(dirname4(inputPath), `${stem}.unmasked`);
+  return join24(dirname4(inputPath), `${stem}.unmasked`);
 }
 function readDir(root) {
   const out = [];
   const walk = (dir) => {
     for (const name of readdirSync(dir)) {
-      const p = join23(dir, name);
+      const p = join24(dir, name);
       if (statSync(p).isDirectory()) walk(p);
       else out.push({ name: relative(root, p).split(sep).join("/"), data: readFileSync5(p) });
     }
@@ -5354,7 +5761,8 @@ var USAGE = `${bold("actario")} ${dim(`v${CLI_VERSION}`)}
                                ${dim("(separate from capture on purpose: a model failure never costs a capture)")}
   actario status [upload_id]    local capture state, or one upload's progress
   actario doctor [--schema]     diagnose sources and report format changes
-  actario init [options]        link this machine to a workspace
+  actario login [options]       link this machine by signing in with the browser
+  actario init [options]        link this machine with a pasted token
   actario reset-state          forget the high-water mark and re-read everything
                                ${dim("(needed after resetting a development database)")}
   actario unmask <zip|dir>     reverse pseudonyms in a downloaded export, locally
@@ -5390,6 +5798,11 @@ ${bold("init options")}
   --api-url URL  --token TOKEN  --profile medical|general  --label NAME
                            ${dim("the token is validated first; this machine is registered as a source (--source-id to reuse one)")}
 
+${bold("login options")}
+  --device                 no browser: print a URL + code to approve on any device
+  --no-browser             same as --device
+  --api-url URL  --label NAME  --profile medical|general
+
 ${bold("unmask options")}
   --out DIR                write here instead of <name>.unmasked/ next to the input
 
@@ -5420,6 +5833,7 @@ async function main(argv) {
     status: () => statusCommand(args),
     doctor: () => doctorCommand(args),
     init: () => initCommand(args),
+    login: () => loginCommand(args),
     "reset-state": () => resetStateCommand(args),
     unmask: () => unmaskCommand(args),
     mcp: () => mcpCommand(args)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actario/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Capture, redact and distil your AI coding sessions into decisions, facts and open questions. Runs on your machine; redaction happens before anything is uploaded.",
   "license": "Apache-2.0",
   "type": "module",