@anyslate/cli 0.1.0 → 0.3.0

package/src/commands/hook.mjs

@@ -1,4 +1,4 @@
-// `anyslate hook <subcommand>` — submit a lifecycle event to the Activity feed.
+// `anyslate hook <subcommand>` - submit a lifecycle event to the Activity feed.
 //
 // Subcommands:
 //   anyslate hook session-start
@@ -8,41 +8,77 @@
 // Hooks fail open: any error short-circuits to a stderr warning + exit 0 so a
 // misconfigured CLI never breaks the parent Claude Code session. Pass
 // --strict to opt into exit 1 on failure (useful for setup verification).
+//
+// Fail-open is correct policy. Fail-SILENT was the bug: Claude Code files
+// `exit 0 + stderr` as `hook_success` and nothing reads the stderr. So every
+// run is now persisted (W7) and, after N consecutive failures, SessionStart
+// escalates through a channel that actually renders.
+//
+// Tool-level errors (HTTP 200 + result.isError) now count as failures and are
+// therefore visible to --strict — previously a 403 handle denial printed
+// nothing and exited 0.
 
-import { loadConfig, requireToken } from '../config.mjs';
-import { callTool } from '../mcp-client.mjs';
+import { loadConfig, requireToken, apiUrlNormalizationNotice, DISABLED_NOTICE } from '../config.mjs';
+import { formatCallFailure } from '../mcp-client.mjs';
+import { callToolWithAuth, formatAuthFailure } from '../auth.mjs';
 import { buildHookSubmission, parseHookEvent } from '../hooks.mjs';
-import { readStdin } from '../stdin.mjs';
+import { readStdin, stdinTimeoutFromEnv } from '../stdin.mjs';
+import { recordRun, shouldEscalate, escalationPayload } from '../runlog.mjs';
+import { VERSION } from '../version.mjs';
+import { makeIo } from '../io.mjs';
 
 const ALLOWED = new Set(['session-start', 'post-tool-use', 'stop']);
 
 /**
  * @param {string[]} argv  arguments after `hook`
+ * @param {{env?: NodeJS.ProcessEnv, fetchImpl?: typeof fetch}} [deps]
  * @returns {Promise<number>}
  */
-export async function runHook(argv) {
+export async function runHook(argv, deps = {}) {
+  const env = deps.env ?? process.env;
+  const { out, err } = makeIo(deps);
   const sub = argv[0];
   if (!sub || !ALLOWED.has(sub)) {
-    process.stderr.write('usage: anyslate hook <session-start|post-tool-use|stop> [--strict] [--session <id>] [--note <text>] [--host <hint>]\n');
+    err.write('usage: anyslate hook <session-start|post-tool-use|stop> [--strict] [--session <id>] [--note <text>] [--host <hint>]\n');
     return 2;
   }
 
   const flags = parseFlags(argv.slice(1));
   const strict = flags.strict;
-  const cfg = loadConfig();
+  const cfg = loadConfig(env);
 
-  const tokenCheck = requireToken(cfg);
-  if (!tokenCheck.ok) {
-    process.stderr.write(`anyslate hook ${sub}: ${tokenCheck.error}\n`);
+  if (cfg.disabled) {
+    err.write(`${DISABLED_NOTICE}\n`);
+    return 0;
+  }
+
+  const prefix = `anyslate hook ${sub}`;
+  const fail = (message, extra = {}) => {
+    err.write(message);
+    const state = recordRun(
+      { command: `hook ${sub}`, ok: false, apiUrl: cfg.apiUrl, version: VERSION, error: message.trim(), exitCode: strict ? 1 : 0, ...extra },
+      env,
+    );
+    escalateIfNeeded(out, sub, state, message.trim());
     return strict ? 1 : 0;
+  };
+
+  const notice = apiUrlNormalizationNotice(cfg);
+  if (notice) err.write(notice);
+
+  // Credential PRESENCE only. An expired OAuth access token is not "missing" —
+  // callToolWithAuth refreshes it below — so gating on `cfg.mcpToken` here (as
+  // this did before OAuth) would turn every hour-old session into a silent
+  // no-capture with a misleading "no token configured" in the run log.
+  if (cfg.authMode === 'none') {
+    return fail(`${prefix}: ${requireToken({ mcpToken: null }).error}\n`);
   }
 
   let stdinRaw = '';
   try {
-    stdinRaw = await readStdin();
+    stdinRaw = await readStdin(deps.stdin ?? process.stdin, { timeoutMs: stdinTimeoutFromEnv(env) });
   } catch (e) {
-    process.stderr.write(`anyslate hook ${sub}: stdin read failed (${e?.message ?? e})\n`);
-    return strict ? 1 : 0;
+    return fail(`${prefix}: stdin read failed (${e?.message ?? e})\n`);
   }
 
   const event = parseHookEvent(stdinRaw);
@@ -63,27 +99,49 @@ export async function runHook(argv) {
   if (submission.sessionIdHint) args.session_id_hint = submission.sessionIdHint;
 
   try {
-    const res = await callTool({
-      apiUrl: cfg.apiUrl,
-      token: cfg.mcpToken,
+    // Never opens a browser: this path runs unattended inside Claude Code.
+    // A refresh failure surfaces as an ordinary failure and still exits 0.
+    const res = await callToolWithAuth({
+      cfg,
+      env,
       toolName: 'activity_submit',
       args,
+      fetchImpl: deps.fetchImpl,
     });
+    if (res.authWarning) err.write(`${res.authWarning}\n`);
     if (!res.ok) {
-      const msg = typeof res.data === 'string' ? res.data : JSON.stringify(res.data);
-      process.stderr.write(`anyslate hook ${sub}: server ${res.status} — ${msg}\n`);
-      return strict ? 1 : 0;
+      return fail(formatAuthFailure(prefix, res) ?? formatCallFailure(prefix, res), {
+        status: res.status,
+        isError: !!res.isError,
+        networkError: !!res.networkError,
+      });
     }
-    if (process.env.ANYSLATE_VERBOSE) {
-      process.stdout.write(`${JSON.stringify(res.data)}\n`);
+    recordRun(
+      { command: `hook ${sub}`, ok: true, apiUrl: cfg.apiUrl, status: res.status, version: VERSION, exitCode: 0 },
+      env,
+    );
+    if (env.ANYSLATE_VERBOSE) {
+      out.write(`${JSON.stringify(res.data)}\n`);
     }
     return 0;
   } catch (e) {
-    process.stderr.write(`anyslate hook ${sub}: request failed (${e?.message ?? e})\n`);
-    return strict ? 1 : 0;
+    return fail(`${prefix}: request failed (${e?.message ?? e})\n`);
   }
 }
 
+/**
+ * Escalate through a channel Claude Code renders — plain stderr on an exit-0
+ * hook is filed as `hook_success` and read by nobody.
+ *
+ * Only from SessionStart: PostToolUse exit 2 is a real blocking channel and
+ * must stay reserved for hard failures.
+ */
+function escalateIfNeeded(out, sub, state, error) {
+  if (sub !== 'session-start') return;
+  if (!shouldEscalate(state)) return;
+  out.write(escalationPayload({ ...state, error }));
+}
+
 /** @param {string[]} argv */
 function parseFlags(argv) {
   const out = { strict: false };

package/src/commands/login.mjs

@@ -1,67 +1,404 @@
-// `anyslate login` — write `~/.anyslate/cli.json` with the user's MCP token.
+// `anyslate login` - two credential paths, one config file.
 //
-// Mint the token in the desktop app at Settings → AI Memory → Connect → Mint
-// MCP Token (Professional tier only). Then:
+//   anyslate login                        OAuth browser flow (default, humans)
+//   anyslate login --api-url <root>       ... against dev / a local wrangler
+//   anyslate login --token as_mcp_…       static token (CI, air-gapped, scripts)
 //
-//   anyslate login --token <BEARER>
-//   anyslate login --token <BEARER> --handle <HANDLE_ID>
-//   anyslate login --token <BEARER> --api-url https://anyslate-mcp-service-development.<workers-dev-url>
+// The static-token path is UNCHANGED and stays first-class. It is the only one
+// that works where no browser exists, and a long-lived token is the right shape
+// for a CI secret. `--token` is therefore the switch between the two paths: its
+// presence selects the static flow, its absence selects OAuth.
 //
-// The file is written with mode 0600 — only the current user can read it.
+// Ordering in the static path is load-bearing and is preserved verbatim:
+//   1. token format,
+//   2. URL shape (MUST precede any token verdict — a wrong URL 404s before auth
+//      middleware and masks the real answer),
+//   3. one live GET {root}/mcp/auth/verify,
+//   4. scope warning,
+//   5. write ONLY on success.
+// `--force` writes anyway; `--no-verify` skips the probe (air-gapped setup).
+//
+// The OAuth path ends at the same place — one `/mcp/auth/verify` probe, the same
+// printed verdict line — so "logged in" means exactly one thing regardless of
+// how the credential was obtained.
 
-import { mkdirSync, writeFileSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { DEFAULT_API_URL, anyslateDir, isCaptureDisabled, normalizeApiRoot } from '../config.mjs';
+import { checkUrlShape, isValidTokenFormat, probeVerify, scopeWarning, tokenPreview } from '../verify.mjs';
+import { readConfigFile, writeConfigFile } from '../credentials.mjs';
+import {
+  DEFAULT_CALLBACK_TIMEOUT_S,
+  REGISTERED_REDIRECT_URI,
+  buildAuthorizeUrl,
+  discover,
+  exchangeCode,
+  generatePkce,
+  generateState,
+  openBrowser,
+  registerClient,
+  startCallbackServer,
+} from '../oauth.mjs';
+import { makeIo } from '../io.mjs';
+
+export const USAGE =
+  'usage: anyslate login [--api-url <URL>] [--no-browser] [--timeout <seconds>] [--handle <ID>]\n' +
+  '       anyslate login --token <BEARER> [--handle <ID>] [--api-url <URL>] [--force] [--no-verify]\n' +
+  '\n' +
+  '  With no --token, `login` opens your browser and signs you in with OAuth.\n' +
+  '  --token keeps the static-token path for CI and air-gapped setups.';
 
 /**
  * @param {string[]} argv  arguments after `login`
+ * @param {{fetchImpl?: typeof fetch, env?: NodeJS.ProcessEnv,
+ *          openBrowserImpl?: typeof openBrowser,
+ *          onAuthorizeUrl?: (url: string, ctx: object) => unknown}} [deps]
  * @returns {Promise<number>}
  */
-export async function runLogin(argv) {
+export async function runLogin(argv, deps = {}) {
   const flags = parseFlags(argv);
-  if (!flags.token) {
-    process.stderr.write('usage: anyslate login --token <BEARER> [--handle <ID>] [--api-url <URL>]\n');
+  if (flags.help) {
+    makeIo(deps).err.write(`${USAGE}\n`);
     return 2;
   }
+  return flags.token ? runTokenLogin(flags, deps) : runOauthLogin(flags, deps);
+}
+
+// ---------------------------------------------------------------------------
+// Shared
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the service root exactly as the static path always has: an explicit
+ * --api-url wins, else the stored value is inherited AND re-normalized so a
+ * previously-broken `/mcp`-suffixed apiUrl cannot survive a re-login.
+ */
+function resolveRoot(flags, existing, io) {
+  const merged = flags.apiUrl ?? existing.apiUrl ?? existing.api_url ?? DEFAULT_API_URL;
+  const shape = checkUrlShape(merged);
+  const root = shape.ok ? shape.root : normalizeApiRoot(merged);
+  if (shape.ok && shape.normalized) {
+    io.out.write(
+      `anyslate: apiUrl "${shape.original}" ends in /mcp — the CLI wants the service ROOT and appends /mcp itself.\n` +
+        `anyslate: using "${root}". Run \`anyslate login --api-url ${root}\` to persist.\n`,
+    );
+  }
+  return { shape, root };
+}
+
+function noteIfCaptureDisabled(env, io) {
+  if (!isCaptureDisabled(env)) return;
+  io.err.write(
+    'anyslate: note — ANYSLATE_DISABLE is set, so capture is off in this shell. `login` still writes your config.\n',
+  );
+}
 
-  const dir = join(homedir(), '.anyslate');
-  const path = join(dir, 'cli.json');
-  let existing = {};
+function hostOf(root) {
   try {
-    existing = JSON.parse(readFileSync(path, 'utf8')) || {};
+    return new URL(root).host;
   } catch {
-    existing = {};
+    return root;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Static token path (behaviour unchanged)
+// ---------------------------------------------------------------------------
+
+async function runTokenLogin(flags, deps) {
+  const env = deps.env ?? process.env;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const io = makeIo(deps);
+  const { out, err } = io;
+
+  noteIfCaptureDisabled(env, io);
+
+  const path = join(anyslateDir(env), 'cli.json');
+  const existing = readConfigFile(env);
+
+  // --- 1. Token format ----------------------------------------------------
+  if (!isValidTokenFormat(flags.token)) {
+    const msg =
+      `anyslate: that doesn't look like an AnySlate token (expected as_mcp_… or as_oauth_…, got "${tokenPreview(flags.token)}").\n` +
+      'anyslate: mint one in the desktop app at Avatar (top-right) → API Tokens → Create Token.\n';
+    if (!flags.force) {
+      err.write(msg);
+      return 1;
+    }
+    err.write(msg);
+    err.write('anyslate: --force given — writing anyway.\n');
+  }
+
+  // --- 2. URL shape (MUST precede any token verdict) ----------------------
+  const { shape, root } = resolveRoot(flags, existing, io);
+  if (!shape.ok) {
+    err.write(`${shape.message}\n`);
+    if (!flags.force) return 1;
+    err.write('anyslate: --force given — writing anyway.\n');
+  }
+
+  // --- 3. Live probe ------------------------------------------------------
+  let verified = null;
+  if (flags.noVerify) {
+    err.write('anyslate: --no-verify given — skipping the live connection check.\n');
+  } else {
+    verified = await probeVerify({ root, token: flags.token, fetchImpl });
+    if (!verified.ok) {
+      err.write(`${verified.message}\n`);
+      if (!flags.force) {
+        err.write(
+          'anyslate: nothing was written. Re-run with a working --token/--api-url, or `--force` to write anyway, or `--no-verify` to skip the check.\n',
+        );
+        return 1;
+      }
+      err.write('anyslate: --force given — writing anyway.\n');
+    } else {
+      out.write(`${verified.message}\n`);
+      // --- 4. Scope check (warn, never block) -----------------------------
+      const warning = scopeWarning(verified.scopes);
+      if (warning) err.write(`${warning}\n`);
+    }
   }
 
+  // --- 5. Write only on success (or --force / --no-verify) ----------------
   const next = {
     ...existing,
     mcp_token: flags.token,
     handle: flags.handle ?? existing.handle ?? null,
-    apiUrl: flags.apiUrl ?? existing.apiUrl ?? 'https://mcp.anyslate.io',
+    apiUrl: root,
   };
+  delete next.api_url; // collapse the legacy alias so only one key can drift
 
   try {
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    writeFileSync(path, JSON.stringify(next, null, 2), { mode: 0o600 });
+    writeConfigFile(next, env);
   } catch (e) {
-    process.stderr.write(`anyslate login: write failed (${e?.message ?? e})\n`);
+    err.write(`anyslate login: write failed (${e?.message ?? e})\n`);
     return 1;
   }
 
-  process.stdout.write(`anyslate: wrote ${path}\n`);
-  process.stdout.write(`  apiUrl: ${next.apiUrl}\n`);
-  process.stdout.write(`  handle: ${next.handle ?? '(none — bearer token only)'}\n`);
+  out.write(`anyslate: wrote ${path}\n`);
+  out.write(`  apiUrl: ${next.apiUrl}\n`);
+  out.write(`  handle: ${next.handle ?? '(none — bearer token only)'}\n`);
+  if (verified?.ok && verified.defaultHandleId) {
+    out.write(`  token is bound to handle: ${verified.defaultHandleId} (server-side scope)\n`);
+  }
+  out.write('anyslate: run `anyslate doctor` to verify the full setup.\n');
   return 0;
 }
 
+// ---------------------------------------------------------------------------
+// OAuth browser path
+// ---------------------------------------------------------------------------
+
+async function runOauthLogin(flags, deps) {
+  const env = deps.env ?? process.env;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const io = makeIo(deps);
+  const { out, err } = io;
+
+  if (flags.timeoutInvalid) {
+    err.write('anyslate: --timeout takes a positive number of seconds.\n');
+    return 2;
+  }
+
+  noteIfCaptureDisabled(env, io);
+
+  const existing = readConfigFile(env);
+  const { shape, root } = resolveRoot(flags, existing, io);
+  if (!shape.ok) {
+    err.write(`${shape.message}\n`);
+    return 1;
+  }
+  const host = hostOf(root);
+
+  // --- 1. Discovery. No guessed endpoint paths, ever. ---------------------
+  const discovery = await discover({ root, fetchImpl });
+  if (!discovery.ok) {
+    err.write(`${discovery.message}\n`);
+    return 1;
+  }
+
+  // --- 2. Client id: cached per root, because DCR is 10/hour --------------
+  const clients = existing.oauth_clients && typeof existing.oauth_clients === 'object' ? existing.oauth_clients : {};
+  let clientId = typeof clients[root] === 'string' && clients[root] ? clients[root] : null;
+  let registered = false;
+  if (clientId) {
+    out.write(`anyslate: reusing this CLI's registered OAuth client for ${host}.\n`);
+  } else {
+    const reg = await registerClient({
+      registrationEndpoint: discovery.registrationEndpoint,
+      redirectUri: REGISTERED_REDIRECT_URI,
+      fetchImpl,
+    });
+    if (!reg.ok) {
+      err.write(`${reg.message}\n`);
+      return 1;
+    }
+    clientId = reg.clientId;
+    registered = true;
+    // Persist immediately, BEFORE the browser round trip. A user who closes the
+    // consent tab must not burn a second registration on their next attempt.
+    try {
+      writeConfigFile({ ...readConfigFile(env), oauth_clients: { ...clients, [root]: clientId } }, env);
+    } catch {
+      err.write('anyslate: warning — could not cache the client registration; the next login will register again.\n');
+    }
+  }
+
+  // --- 3. PKCE + state ----------------------------------------------------
+  const pkce = generatePkce();
+  const state = generateState();
+
+  // --- 4. Loopback listener on an ephemeral port --------------------------
+  const timeoutMs = (flags.timeout ?? DEFAULT_CALLBACK_TIMEOUT_S) * 1000;
+  let listener;
+  try {
+    listener = await startCallbackServer({ state, timeoutMs });
+  } catch (e) {
+    err.write(`anyslate: could not bind a loopback port for the OAuth callback (${e?.message ?? e}).\n`);
+    return 1;
+  }
+
+  try {
+    const authorizeUrl = buildAuthorizeUrl({
+      authorizationEndpoint: discovery.authorizationEndpoint,
+      clientId,
+      redirectUri: listener.redirectUri,
+      codeChallenge: pkce.challenge,
+      state,
+      resource: discovery.resource,
+    });
+
+    // --- 5. Browser -------------------------------------------------------
+    out.write(`anyslate: signing in to ${host}${registered ? ' (registered this CLI)' : ''}.\n`);
+    if (flags.noBrowser) {
+      out.write('anyslate: --no-browser given. Open this URL to authorize:\n');
+    } else {
+      const opened = (deps.openBrowserImpl ?? openBrowser)(authorizeUrl);
+      out.write(
+        opened.ok
+          ? 'anyslate: opened your browser. If nothing appeared, open this URL:\n'
+          : `anyslate: could not launch a browser (${opened.error ?? 'unknown error'}). Open this URL:\n`,
+      );
+    }
+    // Printed on BOTH paths. A browser that reported success but silently failed
+    // to appear would otherwise leave the user at a hung prompt with no way in.
+    out.write(`\n  ${authorizeUrl}\n\n`);
+    out.write(`anyslate: waiting up to ${Math.round(timeoutMs / 1000)}s for the callback on ${listener.redirectUri} …\n`);
+
+    await deps.onAuthorizeUrl?.(authorizeUrl, { redirectUri: listener.redirectUri, state, root });
+
+    // --- 6. Callback (state validated inside the listener) ----------------
+    const callback = await listener.waitForResult();
+    if (!callback.ok) {
+      err.write(`${callback.message}\n`);
+      return 1;
+    }
+
+    // --- 7. Token exchange ------------------------------------------------
+    const exchanged = await exchangeCode({
+      tokenEndpoint: discovery.tokenEndpoint,
+      code: callback.code,
+      redirectUri: listener.redirectUri,
+      codeVerifier: pkce.verifier,
+      clientId,
+      resource: discovery.resource,
+      fetchImpl,
+    });
+    if (!exchanged.ok) {
+      err.write(`${exchanged.message}\n`);
+      return 1;
+    }
+
+    const oauth = {
+      client_id: clientId,
+      access_token: exchanged.tokens.access_token,
+      refresh_token: exchanged.tokens.refresh_token,
+      expires_at: exchanged.tokens.expires_at,
+      // Cached so an unattended refresh costs one request rather than three.
+      // Bound to `root` so switching environments re-discovers instead of
+      // reusing dev's token endpoint against prod.
+      token_endpoint: discovery.tokenEndpoint,
+      resource: discovery.resource,
+      root,
+    };
+
+    // --- 8. Verify, exactly as the static path does -----------------------
+    let verified = null;
+    if (flags.noVerify) {
+      err.write('anyslate: --no-verify given — skipping the live connection check.\n');
+    } else {
+      verified = await probeVerify({ root, token: oauth.access_token, fetchImpl });
+      if (verified.ok) {
+        out.write(`${verified.message}\n`);
+        const warning = scopeWarning(verified.scopes);
+        if (warning) err.write(`${warning}\n`);
+      } else {
+        err.write(`${verified.message}\n`);
+        if (!flags.force) {
+          err.write('anyslate: nothing was written. Re-run `anyslate login`, or pass --force to write anyway.\n');
+          return 1;
+        }
+        err.write('anyslate: --force given — writing anyway.\n');
+      }
+    }
+
+    // --- 9. Persist -------------------------------------------------------
+    const path = join(anyslateDir(env), 'cli.json');
+    let handle = null;
+    try {
+      const current = readConfigFile(env);
+      handle = flags.handle ?? current.handle ?? null;
+      const next = {
+        ...current,
+        apiUrl: root,
+        handle,
+        oauth_clients: { ...(current.oauth_clients ?? {}), [root]: clientId },
+        oauth,
+      };
+      delete next.api_url;
+      writeConfigFile(next, env);
+    } catch (e) {
+      err.write(`anyslate login: write failed (${e?.message ?? e})\n`);
+      return 1;
+    }
+
+    out.write(`anyslate: wrote ${path}\n`);
+    out.write(`  apiUrl: ${root}\n`);
+    out.write('  auth:   oauth (browser)\n');
+    out.write(`  handle: ${handle ?? '(none — bearer token only)'}\n`);
+    out.write(
+      `  access token expires ${oauth.expires_at}${
+        oauth.refresh_token ? '; it refreshes automatically' : ' (no refresh token issued)'
+      }\n`,
+    );
+    if (verified?.ok && verified.defaultHandleId) {
+      out.write(`  token is bound to handle: ${verified.defaultHandleId} (server-side scope)\n`);
+    }
+    out.write('anyslate: run `anyslate doctor` to verify the full setup.\n');
+    return 0;
+  } finally {
+    await listener.close();
+  }
+}
+
 /** @param {string[]} argv */
 function parseFlags(argv) {
-  const out = {};
+  const out = { force: false, noVerify: false, noBrowser: false, help: false };
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
     if (a === '--token' && argv[i + 1]) out.token = argv[++i];
     else if (a === '--handle' && argv[i + 1]) out.handle = argv[++i];
     else if ((a === '--api-url' || a === '--api_url') && argv[i + 1]) out.apiUrl = argv[++i];
+    else if (a === '--force') out.force = true;
+    else if (a === '--no-verify' || a === '--skip-verify') out.noVerify = true;
+    else if (a === '--no-browser') out.noBrowser = true;
+    else if (a === '--timeout' && argv[i + 1]) {
+      const seconds = Number(argv[++i]);
+      if (Number.isFinite(seconds) && seconds > 0) out.timeout = seconds;
+      else out.timeoutInvalid = true;
+    } else if (a === '--help' || a === '-h') out.help = true;
   }
   return out;
 }
+
+export const __testing = { parseFlags };