@anyslate/cli 0.1.0 → 0.3.0

package/src/credentials.mjs

@@ -0,0 +1,162 @@
+// Credential store for `~/.anyslate/cli.json`.
+//
+// WHY THIS IS ITS OWN MODULE. Before OAuth, exactly one command wrote this
+// file (`login`), once, interactively. With refresh tokens, ANY command can
+// write it — and hooks fire in parallel. Claude Code can run SessionStart,
+// PostToolUse and Stop from separate processes within the same second, and a
+// rotated refresh token that loses a write race is unrecoverable: the server
+// has already marked the old one replaced (oauth_refresh_tokens.replaced_by_id),
+// so the user silently drops to "re-login required" with no error anywhere.
+//
+// Two mechanisms, both required:
+//
+//   1. ATOMIC WRITE. Serialize to `cli.json.tmp-<pid>-<ts>` in the same
+//      directory, then rename(2) over the target. rename is atomic within a
+//      filesystem, so a concurrent reader sees either the whole old file or
+//      the whole new one — never a half-written one. Writing in place would
+//      let a reader observe a truncated file and conclude "no credentials".
+//
+//   2. READ-MODIFY-WRITE UNDER A LOCK. Every mutation re-reads from disk
+//      first and merges, so a racing process's rotated token survives. The
+//      lock (O_CREAT|O_EXCL, which is atomic) keeps two processes from both
+//      deciding to refresh and racing the server. Lock acquisition is
+//      best-effort with a stale-lock breaker: a crashed process must not wedge
+//      capture forever, so failing to take the lock proceeds unlocked rather
+//      than throwing.
+
+import { mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, openSync, closeSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { anyslateDir } from './config.mjs';
+
+export const CONFIG_FILE = 'cli.json';
+export const LOCK_FILE = 'cli-refresh.lock';
+
+/** A lock older than this belonged to a process that died holding it. */
+export const LOCK_STALE_MS = 30_000;
+export const LOCK_WAIT_MS = 10_000;
+
+export function cliConfigPath(env = process.env) {
+  return join(anyslateDir(env), CONFIG_FILE);
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {Record<string, any>}
+ */
+export function readConfigFile(env = process.env) {
+  try {
+    const parsed = JSON.parse(readFileSync(cliConfigPath(env), 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Serialize + rename. Never writes the target path in place.
+ *
+ * @param {Record<string, any>} next
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {string} the path written
+ */
+export function writeConfigFile(next, env = process.env) {
+  const dir = anyslateDir(env);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const path = join(dir, CONFIG_FILE);
+  const tmp = join(dir, `${CONFIG_FILE}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  try {
+    writeFileSync(tmp, JSON.stringify(next, null, 2), { mode: 0o600 });
+    renameSync(tmp, path);
+  } catch (e) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+      /* the temp file may not exist */
+    }
+    throw e;
+  }
+  return path;
+}
+
+/**
+ * Read-modify-write. `mutate` receives the CURRENT on-disk object (not a
+ * snapshot the caller took earlier) and returns the object to persist.
+ *
+ * @param {(current: Record<string, any>) => Record<string, any>} mutate
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {Record<string, any>} the persisted object
+ */
+export function updateConfigFile(mutate, env = process.env) {
+  const current = readConfigFile(env);
+  const next = mutate({ ...current }) ?? current;
+  writeConfigFile(next, env);
+  return next;
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * Run `fn` holding the refresh lock when possible.
+ *
+ * `fn` is given `{held}` so it can tell "I am the only refresher" from "I gave
+ * up waiting". It ALWAYS runs: a lock we could not take is a reason to be
+ * careful, never a reason to skip capture.
+ *
+ * @template T
+ * @param {(state: {held: boolean}) => Promise<T>|T} fn
+ * @param {{env?: NodeJS.ProcessEnv, waitMs?: number, staleMs?: number}} [opts]
+ * @returns {Promise<T>}
+ */
+export async function withRefreshLock(fn, opts = {}) {
+  const env = opts.env ?? process.env;
+  const waitMs = opts.waitMs ?? LOCK_WAIT_MS;
+  const staleMs = opts.staleMs ?? LOCK_STALE_MS;
+
+  let lockPath = null;
+  let held = false;
+  try {
+    const dir = anyslateDir(env);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    lockPath = join(dir, LOCK_FILE);
+  } catch {
+    return fn({ held: false });
+  }
+
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    try {
+      const fd = openSync(lockPath, 'wx', 0o600);
+      try {
+        writeFileSync(fd, `${process.pid} ${new Date().toISOString()}`);
+      } finally {
+        closeSync(fd);
+      }
+      held = true;
+      break;
+    } catch (e) {
+      if (e?.code !== 'EEXIST') break; // unwritable dir — proceed unlocked
+      let broke = false;
+      try {
+        if (Date.now() - statSync(lockPath).mtimeMs > staleMs) {
+          unlinkSync(lockPath);
+          broke = true;
+        }
+      } catch {
+        /* the holder released it between stat and unlink — just retry */
+      }
+      if (!broke) await sleep(40);
+    }
+  }
+
+  try {
+    return await fn({ held });
+  } finally {
+    if (held) {
+      try {
+        unlinkSync(lockPath);
+      } catch {
+        /* already gone */
+      }
+    }
+  }
+}

package/src/hooks.mjs

@@ -1,15 +1,44 @@
 // Hook payload shaping.
 //
 // Claude Code lifecycle hooks pipe a JSON event on stdin. We're tolerant:
-// missing / empty / non-JSON stdin is fine — we still produce a valid
+// missing / empty / non-JSON stdin is fine - we still produce a valid
 // activity_submit payload, just with less context. This keeps the CLI from
 // breaking a Claude Code session because of an unexpected hook shape.
 //
 // This module is pure (no I/O) so it can be unit-tested directly.
+//
+// ---------------------------------------------------------------------------
+// W13 — structured activity ledger
+// ---------------------------------------------------------------------------
+// Live testing showed a hook-style note ("Claude Code Bash completed") merges
+// as a no-op: decisions_added 0, tasks_added 0, tasks_completed 0. The
+// extractor is correct — the note genuinely contains nothing.
+//
+// So hooks now emit structured FACTS as first-class payload fields, derived
+// from the Claude Code event (tool_name + tool_input + tool_response):
+//
+//     files_touched : string[]
+//     commands_run  : string[]
+//     exit_status   : string | number
+//
+// INVARIANT: these are machine-derived observations and belong in a dedicated
+// activity/ledger section of the memory page. They must NEVER be folded into
+// Decisions or Open Tasks, which stay human/LLM-authored. That is why they are
+// separate fields and are deliberately NOT concatenated into `notes` — `notes`
+// is the prose channel the extractor mines for decisions and tasks, and
+// polluting it would manufacture fake decisions out of shell commands.
+//
+// There is no LLM call anywhere on this path (the Cost Governor is untouched).
 
 const TRUNC_NOTES = 4_000;
 const TRUNC_EXCERPT = 16_000;
 
+/** Caps for the structured ledger fields — keep the payload bounded. */
+const MAX_FILES = 50;
+const MAX_COMMANDS = 20;
+const MAX_COMMAND_CHARS = 2_000;
+const MAX_PATH_CHARS = 512;
+
 /**
  * @param {string|null|undefined} raw
  * @returns {Record<string, unknown>}
@@ -34,6 +63,99 @@ function clipString(v, cap) {
   return v.slice(0, cap);
 }
 
+/**
+ * File paths the tool call touched.
+ *
+ * @param {unknown} toolInput
+ * @param {unknown} toolResponse
+ * @returns {string[]}
+ */
+export function extractFilesTouched(toolInput, toolResponse) {
+  const out = [];
+  const push = (v) => {
+    if (typeof v !== 'string') return;
+    const s = v.trim();
+    if (!s || s.length > MAX_PATH_CHARS) return;
+    if (!out.includes(s)) out.push(s);
+  };
+
+  const scan = (obj) => {
+    if (!obj || typeof obj !== 'object') return;
+    for (const key of ['file_path', 'filePath', 'path', 'notebook_path', 'notebookPath']) {
+      push(obj[key]);
+    }
+    for (const key of ['file_paths', 'filePaths', 'paths', 'files']) {
+      const arr = obj[key];
+      if (Array.isArray(arr)) for (const v of arr) push(typeof v === 'string' ? v : v?.file_path);
+    }
+    // MultiEdit-style: edits: [{ file_path, ... }]
+    const edits = obj.edits ?? obj.changes;
+    if (Array.isArray(edits)) for (const e of edits) push(e?.file_path ?? e?.filePath ?? e?.path);
+  };
+
+  scan(toolInput);
+  scan(toolResponse);
+  return out.slice(0, MAX_FILES);
+}
+
+/**
+ * Shell commands the tool call ran.
+ *
+ * @param {unknown} toolInput
+ * @returns {string[]}
+ */
+export function extractCommandsRun(toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return [];
+  const out = [];
+  const push = (v) => {
+    if (typeof v !== 'string') return;
+    const s = v.trim();
+    if (!s) return;
+    const clipped = s.length > MAX_COMMAND_CHARS ? s.slice(0, MAX_COMMAND_CHARS) : s;
+    if (!out.includes(clipped)) out.push(clipped);
+  };
+  push(toolInput.command);
+  push(toolInput.cmd);
+  push(toolInput.script);
+  const arr = toolInput.commands;
+  if (Array.isArray(arr)) for (const v of arr) push(v);
+  return out.slice(0, MAX_COMMANDS);
+}
+
+/**
+ * Normalized outcome of the tool call. Returns `undefined` when the event
+ * carries no outcome signal at all — an absent field is honest, `"unknown"`
+ * is noise.
+ *
+ * @param {unknown} toolResponse
+ * @returns {string|number|undefined}
+ */
+export function extractExitStatus(toolResponse) {
+  if (toolResponse == null) return undefined;
+  if (typeof toolResponse !== 'object') return undefined;
+
+  for (const key of ['exit_code', 'exitCode', 'returncode', 'returnCode', 'status_code']) {
+    const v = toolResponse[key];
+    if (typeof v === 'number' && Number.isFinite(v)) return v;
+    if (typeof v === 'string' && v.trim() && Number.isFinite(Number(v))) return Number(v);
+  }
+  for (const key of ['is_error', 'isError', 'error']) {
+    const v = toolResponse[key];
+    if (v === true) return 'error';
+    if (typeof v === 'string' && v.trim()) return 'error';
+  }
+  for (const key of ['success', 'ok']) {
+    const v = toolResponse[key];
+    if (v === true) return 'success';
+    if (v === false) return 'error';
+  }
+  const status = toolResponse.status;
+  if (typeof status === 'string' && status.trim()) return status.trim();
+  if (typeof status === 'number' && Number.isFinite(status)) return status;
+  if (toolResponse.is_error === false || toolResponse.isError === false) return 'success';
+  return undefined;
+}
+
 /**
  * @param {object} args
  * @param {'session-start'|'post-tool-use'|'stop'} args.hook
@@ -52,6 +174,8 @@ export function buildHookSubmission({ hook, event, host = 'claude-code', session
 
   const toolName = pickString(event.tool_name) || pickString(event.toolName) || null;
   const transcriptPath = pickString(event.transcript_path);
+  const toolInput = event.tool_input ?? event.toolInput ?? null;
+  const toolResponse = event.tool_response ?? event.toolResponse ?? null;
 
   let kind;
   let defaultNote;
@@ -74,9 +198,26 @@ export function buildHookSubmission({ hook, event, host = 'claude-code', session
       throw new Error(`unknown hook: ${hook}`);
   }
 
-  const conversationExcerpt = clipString(stringify(event.tool_response), TRUNC_EXCERPT);
+  const conversationExcerpt = clipString(stringify(toolResponse), TRUNC_EXCERPT);
+
+  // W13 — structured ledger facts. Never merged into `notes`.
+  const filesTouched = extractFilesTouched(toolInput, toolResponse);
+  const commandsRun = extractCommandsRun(toolInput);
+  const exitStatus = extractExitStatus(toolResponse);
 
-  const payload = stripUndefined({
+  // Session boundaries are real ledger entries — "started work in /repo/x",
+  // "session ended" — not content-free pings. Without a ledger field the
+  // server classifies them as liveness-only and files them as `failed`, which
+  // would put two alarming rows in the user's Activity panel for every single
+  // Claude Code session, forever. `cwd` is what makes them legible on the
+  // page (it names the repo the work happened in).
+  const cwd =
+    pickString(event.cwd) ||
+    pickString(event.working_directory) ||
+    pickString(event.workingDirectory) ||
+    (typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : null);
+
+  const payload = stripEmpty({
     notes: clipString(notes ?? defaultNote, TRUNC_NOTES),
     session_id: sessionIdHint || undefined,
     host_hint: host,
@@ -85,6 +226,10 @@ export function buildHookSubmission({ hook, event, host = 'claude-code', session
     transcript_path: transcriptPath,
     confidence: hook === 'post-tool-use' ? 0.85 : 0.9,
     client_checkpoint_id: pickString(event.client_checkpoint_id),
+    files_touched: filesTouched.length ? filesTouched : undefined,
+    commands_run: commandsRun.length ? commandsRun : undefined,
+    exit_status: exitStatus,
+    cwd: cwd || undefined,
   });
 
   return {
@@ -102,9 +247,20 @@ function mapToolToKind(toolName) {
   if (!toolName) return 'topic_shift';
   const lower = toolName.toLowerCase();
   if (lower === 'edit' || lower === 'write' || lower === 'multiedit' || lower === 'create') {
-    return 'artifact_produced';
+    // NOT `artifact_produced`. That kind is a contract: "I stored an artifact,
+    // here is its ref in artifact_refs". A lifecycle hook stores nothing — it
+    // only observes that a file was touched, which W13 now carries properly in
+    // the `files_touched` ledger field.
+    //
+    // Claiming `artifact_produced` with an empty `artifact_refs` is precisely
+    // the "agent said it produced a file it never stored" shape that the
+    // server-side guard (activity-promote.ts:317) rejects, so every approved
+    // edit would have died with `artifact_refs_required`. It also tripped
+    // classifier rule #1, forcing a manual approval for every single edit —
+    // the busiest event in a Claude Code session.
+    return 'task_completed';
   }
-  if (lower === 'bash' || lower === 'shell' || lower === 'run') {
+  if (lower === 'bash' || lower === 'shell' || lower === 'run' || lower === 'gitcommit' || lower === 'git_commit' || lower === 'git commit') {
     return 'task_completed';
   }
   return 'topic_shift';
@@ -124,10 +280,16 @@ function stringify(v) {
   }
 }
 
-/** @template T @param {T} obj @returns {T} */
-function stripUndefined(obj) {
+/**
+ * Drop both `undefined` AND `null`. `pickString` yields `null` for absent
+ * fields, so `transcript_path: null` and `client_checkpoint_id: null` used to
+ * leak onto every single submission.
+ *
+ * @template T @param {T} obj @returns {T}
+ */
+function stripEmpty(obj) {
   for (const k of Object.keys(obj)) {
-    if (obj[k] === undefined) delete obj[k];
+    if (obj[k] === undefined || obj[k] === null) delete obj[k];
   }
   return obj;
 }

package/src/index.mjs

@@ -3,7 +3,9 @@
 //   anyslate hook <session-start|post-tool-use|stop>
 //   anyslate checkpoint --note "..."
 //   anyslate upload-artifact --session <id> --kind <kind> [--file <path>]
-//   anyslate login --token <bearer>
+//   anyslate login [--api-url <root>] | login --token <bearer>
+//   anyslate logout
+//   anyslate doctor
 //   anyslate version
 //   anyslate help
 
@@ -11,8 +13,13 @@ import { runHook } from './commands/hook.mjs';
 import { runCheckpoint } from './commands/checkpoint.mjs';
 import { runUploadArtifact } from './commands/upload-artifact.mjs';
 import { runLogin } from './commands/login.mjs';
+import { runLogout } from './commands/logout.mjs';
+import { runDoctor } from './commands/doctor.mjs';
+import { isCaptureDisabled, DISABLED_NOTICE } from './config.mjs';
+import { VERSION } from './version.mjs';
 
-const VERSION = '0.1.0';
+/** Subcommands that talk to the network on the user's behalf (capture). */
+const CAPTURE_COMMANDS = new Set(['hook', 'checkpoint', 'upload-artifact']);
 
 const HELP = `anyslate ${VERSION}
 
@@ -26,16 +33,51 @@ usage:
       failure).
 
   anyslate upload-artifact --session <id> --kind <kind> [--file <path>]
-      Upload a file (or stdin) as an MCP artifact. Returns cloud://artifact/<id>.
+      Upload a UTF-8 file (or stdin, up to 5 MB) as an MCP artifact.
+      Prints cloud://artifact/<id>.
+
+  anyslate login [--api-url <URL>] [--no-browser] [--timeout <seconds>]
+                 [--handle <ID>]
+      Sign in through your browser (OAuth 2.1 + PKCE). Opens the consent page,
+      waits on a loopback listener, then saves credentials to
+      ~/.anyslate/cli.json (mode 0600). Defaults to production; --api-url takes
+      the service ROOT (no /mcp suffix) and every OAuth endpoint is read from
+      that root's discovery documents. --no-browser prints the URL instead of
+      opening it. --timeout is how long to wait for the callback (default 180).
+      The access token is refreshed automatically as it nears expiry.
 
   anyslate login --token <BEARER> [--handle <ID>] [--api-url <URL>]
-      Save credentials to ~/.anyslate/cli.json (mode 0600).
+                 [--force] [--no-verify]
+      Static-token sign-in, for CI and air-gapped setups. Verifies the token
+      against the server, then writes the same config file. Exits non-zero and
+      writes nothing if verification fails. --force writes anyway; --no-verify
+      skips the live check.
+
+  anyslate logout [--local]
+      Revoke the OAuth session server-side (best effort), then remove the
+      stored credentials. apiUrl, handle and the cached client registration are
+      kept. --local skips revocation and only clears the local file.
+
+  anyslate doctor [--deep] [--refresh]
+      Diagnose the whole setup: config layers, auth mode (OAuth vs static
+      token) and token expiry, token format, URL shape, reachability, token
+      validity, scopes, handle binding, PATH, Claude Code hook wiring, and the
+      last run outcome. Exits non-zero on any FAIL.
+      --deep additionally writes one probe row to your Activity feed.
+      --refresh forces a real OAuth refresh round trip (rotates the token).
 
 env:
-  ANYSLATE_API_URL    override config (e.g. dev workers.dev URL)
+  ANYSLATE_API_URL    override config (service ROOT, e.g. dev workers.dev URL)
   ANYSLATE_MCP_TOKEN  override config token
-  ANYSLATE_HANDLE     override config handle
+  ANYSLATE_HANDLE     override config handle (handle ids are mh_-prefixed)
+  ANYSLATE_HOME       override ~/.anyslate
   ANYSLATE_VERBOSE    if set, hooks print JSON results to stdout
+  ANYSLATE_STDIN_TIMEOUT_MS
+                      idle timeout while reading stdin (default 10000; 0
+                      disables). Raise it for very slow pipes.
+  ANYSLATE_DISABLE=1  kill switch: hook / checkpoint / upload-artifact make no
+                      network call and exit 0. \`doctor\` and \`login\` still run
+                      so you can diagnose and set up while capture is off.
 `;
 
 /**
@@ -44,6 +86,15 @@ env:
  */
 export async function main(argv) {
   const cmd = argv[0];
+
+  // The kill switch is enforced centrally so no capture subcommand can miss it.
+  // Each capture command also re-checks, which keeps them safe when imported
+  // directly (tests, embedding).
+  if (CAPTURE_COMMANDS.has(cmd) && isCaptureDisabled(process.env)) {
+    process.stderr.write(`${DISABLED_NOTICE}\n`);
+    return 0;
+  }
+
   switch (cmd) {
     case 'hook':
       return runHook(argv.slice(1));
@@ -53,6 +104,10 @@ export async function main(argv) {
       return runUploadArtifact(argv.slice(1));
     case 'login':
       return runLogin(argv.slice(1));
+    case 'logout':
+      return runLogout(argv.slice(1));
+    case 'doctor':
+      return runDoctor(argv.slice(1));
     case 'version':
     case '--version':
     case '-v':

package/src/io.mjs

@@ -0,0 +1,30 @@
+// Injectable stdout/stderr.
+//
+// Commands must never reach for `process.stdout` directly: tests that
+// monkeypatch it also swallow the test reporter's own output, which silently
+// hides results. Every command takes `{stdout, stderr}` in its deps and
+// defaults to the real streams.
+
+/**
+ * @param {{stdout?: {write: (s: string) => unknown}, stderr?: {write: (s: string) => unknown}}} [deps]
+ */
+export function makeIo(deps = {}) {
+  return {
+    out: deps.stdout ?? process.stdout,
+    err: deps.stderr ?? process.stderr,
+  };
+}
+
+/** A collector usable anywhere an io stream is expected. */
+export function memoryStream() {
+  let text = '';
+  return {
+    write(chunk) {
+      text += String(chunk);
+      return true;
+    },
+    get text() {
+      return text;
+    },
+  };
+}