@actario/cli 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

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.0";
+var CLI_VERSION = "0.1.2";
 
 // ../../apps/cli/src/print.ts
 var useColour = process.stdout.isTTY && !process.env.NO_COLOR;
@@ -3811,6 +3811,24 @@ var UNMASK_MARKER_TEXT = "This directory holds an Actario export with pseudonyms
 import { createReadStream as createReadStream3 } from "node:fs";
 import { readFile as readFile3, stat as stat3 } from "node:fs/promises";
 import { join as join15 } from "node:path";
+var CODE_BY_STATUS = {
+  400: "invalid_request",
+  401: "unauthorized",
+  403: "forbidden",
+  404: "not_found",
+  409: "conflict",
+  429: "rate_limited"
+};
+var fallbackMessage = (status, statusText, baseUrl) => {
+  if (status === 401 || status === 403) {
+    return `${baseUrl} rejected this token (${status}). It may be mistyped, revoked, or minted for a different workspace. Create a new one under Settings -> Access tokens, then link again.`;
+  }
+  if (status === 404) {
+    return `${baseUrl} has no Actario API at this path (404). Check the API URL -- it should be the workspace's base URL, nothing after the host.`;
+  }
+  if (status === 429) return `${baseUrl} is rate limiting this token. Wait a moment and retry.`;
+  return `${status} ${statusText}`;
+};
 async function request(opts, path, init = {}) {
   const attempts = init.attempts ?? 3;
   let lastError = null;
@@ -3826,13 +3844,22 @@ async function request(opts, path, init = {}) {
     if (res instanceof Error) {
       lastError = res;
     } else if (res.ok) {
-      return await res.json();
+      try {
+        return await res.json();
+      } catch {
+        throw new DistillError(
+          "invalid_request",
+          `${opts.baseUrl} answered ${path} with something that is not JSON. Check the API URL points at an Actario workspace.`,
+          void 0,
+          502
+        );
+      }
     } else if (res.status === 409 || res.status < 500) {
       const body = await res.json().catch(() => ({}));
       const err = body.error;
       throw new DistillError(
-        err?.code ?? "internal",
-        err?.message ?? `${res.status} ${res.statusText}`,
+        err?.code ?? CODE_BY_STATUS[res.status] ?? "internal",
+        err?.message ?? fallbackMessage(res.status, res.statusText, opts.baseUrl),
         err?.details,
         res.status
       );
@@ -4691,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";
@@ -4749,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();
@@ -4762,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;
     }
@@ -4804,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"));
@@ -4864,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.`);
   }
@@ -4879,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.",
@@ -5135,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();
@@ -5168,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;
@@ -5227,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) {
@@ -5242,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})`)}
@@ -5277,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.")}
@@ -5304,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) });
     }
@@ -5327,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
@@ -5363,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
 
@@ -5393,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,8 +1,8 @@
 {
   "name": "@actario/cli",
-  "version": "0.1.0",
+  "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": "UNLICENSED",
+  "license": "Apache-2.0",
   "type": "module",
   "bin": {
     "actario": "bin/actario.js"
@@ -10,6 +10,7 @@
   "files": [
     "bin",
     "dist",
+    "LICENSE",
     "README.md"
   ],
   "engines": {
@@ -34,5 +35,6 @@
     "capture",
     "redaction",
     "mcp"
-  ]
+  ],
+  "homepage": "https://github.com/actario/actario-plugin"
 }