@anyslate/cli 0.1.0

package/README.md

@@ -0,0 +1,76 @@
+# @anyslate/cli
+
+Thin lifecycle-hook + checkpoint client for the AnySlate AI Memory Layer.
+
+All hook subcommands submit to your **Activity feed** via the `activity_submit` MCP tool (Phase 14). Low-risk same-session items auto-promote into canonical memory after a 30-second quiet period; ambiguous items wait for you to approve them in the desktop **AI Memory → Activity** panel.
+
+## Install
+
+```bash
+npm i -g @anyslate/cli
+# or
+npx @anyslate/cli --help
+```
+
+Requires Node ≥ 20.
+
+## Authenticate
+
+Mint an MCP token in the desktop app at **Settings → AI Memory → Connect**, then:
+
+```bash
+anyslate login --token as_mcp_your_token_here
+```
+
+Or set environment variables:
+
+```bash
+export ANYSLATE_MCP_TOKEN=as_mcp_your_token_here
+export ANYSLATE_API_URL=https://mcp.anyslate.io   # optional
+export ANYSLATE_HANDLE=h_xxx                       # optional, scope to one handle
+```
+
+Env vars override `~/.anyslate/cli.json`.
+
+## Subcommands
+
+```
+anyslate hook <session-start|post-tool-use|stop> [--strict]
+anyslate checkpoint --note "..." [--kind milestone] [--session <id>]
+anyslate upload-artifact --session <id> --kind <kind> [--file <path>]
+anyslate login --token <BEARER> [--handle <ID>] [--api-url <URL>]
+anyslate version | help
+```
+
+### `anyslate hook ...`
+
+Reads JSON event payload from stdin (Claude Code lifecycle event format). Fails open by default — a network blip logs a warning to stderr and exits 0 so your Claude Code session continues. Pass `--strict` to opt into exit 1 on failure (useful in CI smoke tests).
+
+`hook session-start` → `topic_shift`; `hook stop` → `conversation_end`; `hook post-tool-use` maps Edit/Write/MultiEdit → `artifact_produced`, Bash/Shell/Run → `task_completed`, everything else → `topic_shift`.
+
+### `anyslate checkpoint`
+
+User-initiated, exits non-zero on failure. Defaults `--kind milestone`, `--source api`. Allowed kinds: `topic_shift | decision_committed | task_completed | task_added | artifact_produced | milestone | conversation_end`.
+
+### `anyslate upload-artifact`
+
+Reads file or stdin, calls the `upload_artifact` MCP tool. Returns `cloud://artifact/<id>` on stdout. Allowed kinds: `code_block | file_path | error_message | shell_command | config_snippet | url_reference | fenced_quote`. 5 MB content cap.
+
+### `anyslate login`
+
+Writes `~/.anyslate/cli.json` with mode `0600`. Idempotent — preserves the apiUrl/handle if you only update the token.
+
+## Wiring into Claude Code
+
+See `docs/AI_MEMORY_LAYER/GUIDE.md` §6.5 for the full `~/.claude/settings.json` block.
+
+## Tests
+
+```bash
+npm test
+# 23 tests · node --test · no external deps
+```
+
+## License
+
+MIT

package/bin/anyslate.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { main } from '../src/index.mjs';
+
+main(process.argv.slice(2)).then(
+  (code) => process.exit(typeof code === 'number' ? code : 0),
+  (err) => {
+    process.stderr.write(`anyslate: ${err?.message ?? err}\n`);
+    process.exit(1);
+  }
+);

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@anyslate/cli",
+  "version": "0.1.0",
+  "description": "AnySlate CLI — lifecycle hooks + checkpoint / upload-artifact for AI memory capture. All hook subcommands submit to the Activity feed via the activity_submit MCP tool (Phase 14).",
+  "type": "module",
+  "bin": {
+    "anyslate": "./bin/anyslate.mjs"
+  },
+  "files": [
+    "bin",
+    "src/*.mjs",
+    "src/commands",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test 'src/__tests__/*.test.mjs'",
+    "publish:npm": "dotenv -e .env -- npm publish --access=public"
+  },
+  "devDependencies": {
+    "dotenv-cli": "^11.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": [
+    "anyslate",
+    "mcp",
+    "claude-code",
+    "ai",
+    "memory",
+    "lifecycle-hooks",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AnySlate/anyslate.git",
+    "directory": "cli"
+  }
+}

package/src/commands/checkpoint.mjs

@@ -0,0 +1,87 @@
+// `anyslate checkpoint` — submit an explicit checkpoint to the Activity feed.
+//
+// Unlike `hook`, this is user-initiated, so we surface failures directly
+// (exit 1 on error). Use this in CI or one-off scripts where you actually
+// want to know if the submit failed.
+
+import { loadConfig, requireToken } from '../config.mjs';
+import { callTool } from '../mcp-client.mjs';
+
+const ALLOWED_KINDS = new Set([
+  'topic_shift', 'decision_committed', 'task_completed', 'task_added',
+  'artifact_produced', 'milestone', 'conversation_end',
+]);
+
+/**
+ * @param {string[]} argv  arguments after `checkpoint`
+ * @returns {Promise<number>}
+ */
+export async function runCheckpoint(argv) {
+  const flags = parseFlags(argv);
+  if (!flags.note) {
+    process.stderr.write('usage: anyslate checkpoint --note <text> [--kind <kind>] [--session <id>] [--host <hint>] [--source <source>]\n');
+    process.stderr.write(`  kinds: ${[...ALLOWED_KINDS].join(', ')}\n`);
+    return 2;
+  }
+  const kind = flags.kind || 'milestone';
+  if (!ALLOWED_KINDS.has(kind)) {
+    process.stderr.write(`anyslate checkpoint: unsupported kind: ${kind}\n`);
+    return 2;
+  }
+
+  const cfg = loadConfig();
+  const tokenCheck = requireToken(cfg);
+  if (!tokenCheck.ok) {
+    process.stderr.write(`anyslate checkpoint: ${tokenCheck.error}\n`);
+    return 1;
+  }
+
+  const payload = {
+    notes: flags.note,
+    host_hint: flags.host || 'cli',
+  };
+  if (flags.session) payload.session_id = flags.session;
+  if (flags.confidence !== undefined) payload.confidence = flags.confidence;
+
+  const args = {
+    source: flags.source || 'api',
+    kind,
+    payload,
+  };
+  if (cfg.handle) args.handle = cfg.handle;
+  if (flags.session) args.session_id_hint = flags.session;
+
+  try {
+    const res = await callTool({
+      apiUrl: cfg.apiUrl,
+      token: cfg.mcpToken,
+      toolName: 'activity_submit',
+      args,
+    });
+    if (!res.ok) {
+      const msg = typeof res.data === 'string' ? res.data : JSON.stringify(res.data);
+      process.stderr.write(`anyslate checkpoint: server ${res.status} — ${msg}\n`);
+      return 1;
+    }
+    process.stdout.write(`${JSON.stringify(res.data)}\n`);
+    return 0;
+  } catch (e) {
+    process.stderr.write(`anyslate checkpoint: request failed (${e?.message ?? e})\n`);
+    return 1;
+  }
+}
+
+/** @param {string[]} argv */
+function parseFlags(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--note' && argv[i + 1]) out.note = argv[++i];
+    else if (a === '--kind' && argv[i + 1]) out.kind = argv[++i];
+    else if (a === '--session' && argv[i + 1]) out.session = argv[++i];
+    else if (a === '--host' && argv[i + 1]) out.host = argv[++i];
+    else if (a === '--source' && argv[i + 1]) out.source = argv[++i];
+    else if (a === '--confidence' && argv[i + 1]) out.confidence = Number(argv[++i]);
+  }
+  return out;
+}

package/src/commands/hook.mjs

@@ -0,0 +1,98 @@
+// `anyslate hook <subcommand>` — submit a lifecycle event to the Activity feed.
+//
+// Subcommands:
+//   anyslate hook session-start
+//   anyslate hook post-tool-use
+//   anyslate hook stop
+//
+// 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).
+
+import { loadConfig, requireToken } from '../config.mjs';
+import { callTool } from '../mcp-client.mjs';
+import { buildHookSubmission, parseHookEvent } from '../hooks.mjs';
+import { readStdin } from '../stdin.mjs';
+
+const ALLOWED = new Set(['session-start', 'post-tool-use', 'stop']);
+
+/**
+ * @param {string[]} argv  arguments after `hook`
+ * @returns {Promise<number>}
+ */
+export async function runHook(argv) {
+  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');
+    return 2;
+  }
+
+  const flags = parseFlags(argv.slice(1));
+  const strict = flags.strict;
+  const cfg = loadConfig();
+
+  const tokenCheck = requireToken(cfg);
+  if (!tokenCheck.ok) {
+    process.stderr.write(`anyslate hook ${sub}: ${tokenCheck.error}\n`);
+    return strict ? 1 : 0;
+  }
+
+  let stdinRaw = '';
+  try {
+    stdinRaw = await readStdin();
+  } catch (e) {
+    process.stderr.write(`anyslate hook ${sub}: stdin read failed (${e?.message ?? e})\n`);
+    return strict ? 1 : 0;
+  }
+
+  const event = parseHookEvent(stdinRaw);
+  const submission = buildHookSubmission({
+    hook: /** @type {any} */ (sub),
+    event,
+    host: flags.host || 'claude-code',
+    sessionId: flags.session,
+    notes: flags.note,
+  });
+
+  const args = {
+    source: submission.source,
+    kind: submission.kind,
+    payload: submission.payload,
+  };
+  if (cfg.handle) args.handle = cfg.handle;
+  if (submission.sessionIdHint) args.session_id_hint = submission.sessionIdHint;
+
+  try {
+    const res = await callTool({
+      apiUrl: cfg.apiUrl,
+      token: cfg.mcpToken,
+      toolName: 'activity_submit',
+      args,
+    });
+    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;
+    }
+    if (process.env.ANYSLATE_VERBOSE) {
+      process.stdout.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;
+  }
+}
+
+/** @param {string[]} argv */
+function parseFlags(argv) {
+  const out = { strict: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--strict') out.strict = true;
+    else if (a === '--session' && argv[i + 1]) { out.session = argv[++i]; }
+    else if (a === '--note' && argv[i + 1]) { out.note = argv[++i]; }
+    else if (a === '--host' && argv[i + 1]) { out.host = argv[++i]; }
+  }
+  return out;
+}

package/src/commands/login.mjs

@@ -0,0 +1,67 @@
+// `anyslate login` — write `~/.anyslate/cli.json` with the user's MCP token.
+//
+// Mint the token in the desktop app at Settings → AI Memory → Connect → Mint
+// MCP Token (Professional tier only). Then:
+//
+//   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 file is written with mode 0600 — only the current user can read it.
+
+import { mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * @param {string[]} argv  arguments after `login`
+ * @returns {Promise<number>}
+ */
+export async function runLogin(argv) {
+  const flags = parseFlags(argv);
+  if (!flags.token) {
+    process.stderr.write('usage: anyslate login --token <BEARER> [--handle <ID>] [--api-url <URL>]\n');
+    return 2;
+  }
+
+  const dir = join(homedir(), '.anyslate');
+  const path = join(dir, 'cli.json');
+  let existing = {};
+  try {
+    existing = JSON.parse(readFileSync(path, 'utf8')) || {};
+  } catch {
+    existing = {};
+  }
+
+  const next = {
+    ...existing,
+    mcp_token: flags.token,
+    handle: flags.handle ?? existing.handle ?? null,
+    apiUrl: flags.apiUrl ?? existing.apiUrl ?? 'https://mcp.anyslate.io',
+  };
+
+  try {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(path, JSON.stringify(next, null, 2), { mode: 0o600 });
+  } catch (e) {
+    process.stderr.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`);
+  return 0;
+}
+
+/** @param {string[]} argv */
+function parseFlags(argv) {
+  const out = {};
+  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];
+  }
+  return out;
+}

package/src/commands/upload-artifact.mjs

@@ -0,0 +1,110 @@
+// `anyslate upload-artifact` — upload a file (or stdin) as an MCP artifact.
+//
+// Usage:
+//   anyslate upload-artifact --session <id> --kind code_block --file ./diff.patch
+//   echo "..." | anyslate upload-artifact --session <id> --kind shell_command
+//
+// Returns the cloud://artifact/<id> URI on stdout (one per line) so callers
+// can pipe it into a subsequent `anyslate checkpoint --note ...` if desired.
+
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { loadConfig, requireToken } from '../config.mjs';
+import { callTool } from '../mcp-client.mjs';
+import { readStdin } from '../stdin.mjs';
+
+const ALLOWED_KINDS = new Set([
+  'code_block', 'file_path', 'error_message', 'shell_command',
+  'config_snippet', 'url_reference', 'fenced_quote',
+]);
+
+const MAX_CONTENT_BYTES = 5_000_000;
+
+/**
+ * @param {string[]} argv  arguments after `upload-artifact`
+ * @returns {Promise<number>}
+ */
+export async function runUploadArtifact(argv) {
+  const flags = parseFlags(argv);
+  if (!flags.session || !flags.kind) {
+    process.stderr.write('usage: anyslate upload-artifact --session <id> --kind <kind> [--file <path> | <stdin>] [--language <lang>] [--path-hint <name>]\n');
+    process.stderr.write(`  kinds: ${[...ALLOWED_KINDS].join(', ')}\n`);
+    return 2;
+  }
+  if (!ALLOWED_KINDS.has(flags.kind)) {
+    process.stderr.write(`anyslate upload-artifact: unsupported kind: ${flags.kind}\n`);
+    return 2;
+  }
+
+  const cfg = loadConfig();
+  const tokenCheck = requireToken(cfg);
+  if (!tokenCheck.ok) {
+    process.stderr.write(`anyslate upload-artifact: ${tokenCheck.error}\n`);
+    return 1;
+  }
+
+  let content;
+  let pathHint = flags.pathHint;
+  if (flags.file) {
+    try {
+      content = readFileSync(flags.file, 'utf8');
+      if (!pathHint) pathHint = basename(flags.file);
+    } catch (e) {
+      process.stderr.write(`anyslate upload-artifact: cannot read ${flags.file} (${e?.message ?? e})\n`);
+      return 1;
+    }
+  } else {
+    content = await readStdin();
+  }
+
+  if (!content || !content.length) {
+    process.stderr.write('anyslate upload-artifact: empty content (provide --file or pipe data on stdin)\n');
+    return 1;
+  }
+  if (Buffer.byteLength(content, 'utf8') > MAX_CONTENT_BYTES) {
+    process.stderr.write(`anyslate upload-artifact: content exceeds ${MAX_CONTENT_BYTES} byte cap\n`);
+    return 1;
+  }
+
+  const args = {
+    session_id: flags.session,
+    kind: flags.kind,
+    content,
+  };
+  if (cfg.handle) args.handle = cfg.handle;
+  if (flags.language) args.language = flags.language;
+  if (pathHint) args.path_hint = pathHint;
+
+  try {
+    const res = await callTool({
+      apiUrl: cfg.apiUrl,
+      token: cfg.mcpToken,
+      toolName: 'upload_artifact',
+      args,
+    });
+    if (!res.ok) {
+      const msg = typeof res.data === 'string' ? res.data : JSON.stringify(res.data);
+      process.stderr.write(`anyslate upload-artifact: server ${res.status} — ${msg}\n`);
+      return 1;
+    }
+    process.stdout.write(`${JSON.stringify(res.data)}\n`);
+    return 0;
+  } catch (e) {
+    process.stderr.write(`anyslate upload-artifact: request failed (${e?.message ?? e})\n`);
+    return 1;
+  }
+}
+
+/** @param {string[]} argv */
+function parseFlags(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--session' && argv[i + 1]) out.session = argv[++i];
+    else if (a === '--kind' && argv[i + 1]) out.kind = argv[++i];
+    else if (a === '--file' && argv[i + 1]) out.file = argv[++i];
+    else if (a === '--language' && argv[i + 1]) out.language = argv[++i];
+    else if ((a === '--path-hint' || a === '--path_hint') && argv[i + 1]) out.pathHint = argv[++i];
+  }
+  return out;
+}

package/src/config.mjs

@@ -0,0 +1,71 @@
+// Config resolution for anyslate-cli.
+//
+// Order of precedence (first non-empty wins):
+//   1. Environment variables (ANYSLATE_API_URL, ANYSLATE_MCP_TOKEN, ANYSLATE_HANDLE)
+//   2. ~/.anyslate/cli.json (preferred CLI config)
+//   3. ~/.anyslate/session.json (legacy, only the `mcp_token` / `handle` keys)
+//
+// Defaults:
+//   - apiUrl  → https://mcp.anyslate.io
+//
+// All file reads tolerate missing / unreadable files; the CLI fails open so
+// `anyslate hook session-start` never breaks a Claude Code session because of
+// a missing config — it just no-ops with a warning to stderr.
+
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const DEFAULT_API_URL = 'https://mcp.anyslate.io';
+
+const CONFIG_PATHS = [
+  () => join(homedir(), '.anyslate', 'cli.json'),
+  () => join(homedir(), '.anyslate', 'session.json'),
+];
+
+/**
+ * @param {NodeJS.ProcessEnv} env
+ * @param {() => string[]} [paths] override for tests
+ * @returns {{apiUrl: string, mcpToken: string|null, handle: string|null, source: string}}
+ */
+export function loadConfig(env = process.env, paths) {
+  const candidates = paths ? paths() : CONFIG_PATHS.map((fn) => fn());
+
+  /** @type {{apiUrl?: string, mcp_token?: string, handle?: string}} */
+  let fileConfig = {};
+  let source = 'env';
+  for (const p of candidates) {
+    try {
+      const raw = readFileSync(p, 'utf8');
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === 'object') {
+        fileConfig = parsed;
+        source = p;
+        break;
+      }
+    } catch {
+      // ignore — fall through to next candidate
+    }
+  }
+
+  const apiUrl = (env.ANYSLATE_API_URL || fileConfig.apiUrl || fileConfig.api_url || DEFAULT_API_URL).replace(/\/+$/, '');
+  const mcpToken = env.ANYSLATE_MCP_TOKEN || fileConfig.mcp_token || fileConfig.token || null;
+  const handle = env.ANYSLATE_HANDLE || fileConfig.handle || null;
+
+  return { apiUrl, mcpToken, handle, source };
+}
+
+/**
+ * @param {object} cfg
+ * @returns {{ok: true} | {ok: false, error: string}}
+ */
+export function requireToken(cfg) {
+  if (!cfg.mcpToken) {
+    return {
+      ok: false,
+      error:
+        'no MCP token configured. Run `anyslate login --token <BEARER>` or set ANYSLATE_MCP_TOKEN. Mint a token at Settings → AI Memory → Connect in the AnySlate desktop app.',
+    };
+  }
+  return { ok: true };
+}

package/src/hooks.mjs

@@ -0,0 +1,133 @@
+// 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
+// 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.
+
+const TRUNC_NOTES = 4_000;
+const TRUNC_EXCERPT = 16_000;
+
+/**
+ * @param {string|null|undefined} raw
+ * @returns {Record<string, unknown>}
+ */
+export function parseHookEvent(raw) {
+  if (!raw || !raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * @param {unknown} v
+ * @param {number} cap
+ */
+function clipString(v, cap) {
+  if (typeof v !== 'string') return undefined;
+  if (v.length <= cap) return v;
+  return v.slice(0, cap);
+}
+
+/**
+ * @param {object} args
+ * @param {'session-start'|'post-tool-use'|'stop'} args.hook
+ * @param {Record<string, unknown>} args.event  parsed stdin payload
+ * @param {string} [args.host]                  host_hint advisory
+ * @param {string} [args.sessionId]             explicit override (CLI flag)
+ * @param {string} [args.notes]                 explicit override (CLI flag)
+ * @returns {{source: string, kind: string, payload: Record<string, unknown>, sessionIdHint: string|null}}
+ */
+export function buildHookSubmission({ hook, event, host = 'claude-code', sessionId, notes }) {
+  const sessionIdHint =
+    sessionId ||
+    pickString(event.session_id) ||
+    pickString(event.sessionId) ||
+    null;
+
+  const toolName = pickString(event.tool_name) || pickString(event.toolName) || null;
+  const transcriptPath = pickString(event.transcript_path);
+
+  let kind;
+  let defaultNote;
+  switch (hook) {
+    case 'session-start':
+      kind = 'topic_shift';
+      defaultNote = 'Claude Code session started';
+      break;
+    case 'stop':
+      kind = 'conversation_end';
+      defaultNote = 'Claude Code session ended';
+      break;
+    case 'post-tool-use':
+      kind = mapToolToKind(toolName);
+      defaultNote = toolName
+        ? `Claude Code ${toolName} completed`
+        : 'Claude Code tool invocation completed';
+      break;
+    default:
+      throw new Error(`unknown hook: ${hook}`);
+  }
+
+  const conversationExcerpt = clipString(stringify(event.tool_response), TRUNC_EXCERPT);
+
+  const payload = stripUndefined({
+    notes: clipString(notes ?? defaultNote, TRUNC_NOTES),
+    session_id: sessionIdHint || undefined,
+    host_hint: host,
+    conversation_excerpt: conversationExcerpt,
+    tool_name: toolName ?? undefined,
+    transcript_path: transcriptPath,
+    confidence: hook === 'post-tool-use' ? 0.85 : 0.9,
+    client_checkpoint_id: pickString(event.client_checkpoint_id),
+  });
+
+  return {
+    source: 'cli_hook',
+    kind,
+    payload,
+    sessionIdHint,
+  };
+}
+
+/**
+ * @param {string|null} toolName
+ */
+function mapToolToKind(toolName) {
+  if (!toolName) return 'topic_shift';
+  const lower = toolName.toLowerCase();
+  if (lower === 'edit' || lower === 'write' || lower === 'multiedit' || lower === 'create') {
+    return 'artifact_produced';
+  }
+  if (lower === 'bash' || lower === 'shell' || lower === 'run') {
+    return 'task_completed';
+  }
+  return 'topic_shift';
+}
+
+function pickString(v) {
+  return typeof v === 'string' && v.length > 0 ? v : null;
+}
+
+function stringify(v) {
+  if (v == null) return undefined;
+  if (typeof v === 'string') return v;
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return undefined;
+  }
+}
+
+/** @template T @param {T} obj @returns {T} */
+function stripUndefined(obj) {
+  for (const k of Object.keys(obj)) {
+    if (obj[k] === undefined) delete obj[k];
+  }
+  return obj;
+}

package/src/index.mjs

@@ -0,0 +1,71 @@
+// anyslate CLI dispatcher.
+//
+//   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 version
+//   anyslate help
+
+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';
+
+const VERSION = '0.1.0';
+
+const HELP = `anyslate ${VERSION}
+
+usage:
+  anyslate hook <session-start|post-tool-use|stop> [--strict]
+      Submit a Claude Code lifecycle event to the AnySlate Activity feed.
+      Reads JSON event payload from stdin. Hooks fail open by default.
+
+  anyslate checkpoint --note "what happened" [--kind milestone] [--session <id>]
+      Submit an explicit checkpoint to the Activity feed (exits non-zero on
+      failure).
+
+  anyslate upload-artifact --session <id> --kind <kind> [--file <path>]
+      Upload a file (or stdin) as an MCP artifact. Returns cloud://artifact/<id>.
+
+  anyslate login --token <BEARER> [--handle <ID>] [--api-url <URL>]
+      Save credentials to ~/.anyslate/cli.json (mode 0600).
+
+env:
+  ANYSLATE_API_URL    override config (e.g. dev workers.dev URL)
+  ANYSLATE_MCP_TOKEN  override config token
+  ANYSLATE_HANDLE     override config handle
+  ANYSLATE_VERBOSE    if set, hooks print JSON results to stdout
+`;
+
+/**
+ * @param {string[]} argv
+ * @returns {Promise<number>}
+ */
+export async function main(argv) {
+  const cmd = argv[0];
+  switch (cmd) {
+    case 'hook':
+      return runHook(argv.slice(1));
+    case 'checkpoint':
+      return runCheckpoint(argv.slice(1));
+    case 'upload-artifact':
+      return runUploadArtifact(argv.slice(1));
+    case 'login':
+      return runLogin(argv.slice(1));
+    case 'version':
+    case '--version':
+    case '-v':
+      process.stdout.write(`${VERSION}\n`);
+      return 0;
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      process.stdout.write(HELP);
+      return 0;
+    default:
+      process.stderr.write(`anyslate: unknown command "${cmd}". Run \`anyslate help\` for usage.\n`);
+      return 2;
+  }
+}

package/src/mcp-client.mjs

@@ -0,0 +1,174 @@
+// Minimal JSON-RPC client for the AnySlate MCP service.
+//
+// The MCP service speaks the standard MCP JSON-RPC protocol. We only need
+// `tools/call` from the CLI — that one method covers `activity_submit`,
+// `checkpoint_session`, and `upload_artifact`.
+//
+// The server replies with `{ jsonrpc: '2.0', id, result | error }`. When the
+// server returns an MCP `result.content[0].text` block we additionally
+// JSON-parse it (the AnySlate dispatcher always returns JSON-encoded text).
+//
+// Streamable HTTP transport requires every non-initialize request to carry
+// an `Mcp-Session-Id` header (mcp-protocol.ts:2566). The CLI is one-shot per
+// invocation, so we run `initialize` first, capture the server-issued
+// session id from the response header, and reuse it for the `tools/call`.
+
+let nextRequestId = 1;
+
+async function readBody(res) {
+  const ctype = res.headers.get('content-type') || '';
+  // The MCP service may stream JSON-RPC results as text/event-stream
+  // ("data: { ... }\n\n"). Handle both content types so we don't lose the
+  // payload on the SSE branch.
+  if (ctype.includes('text/event-stream')) {
+    const text = await res.text();
+    for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('data:')) continue;
+      const json = trimmed.slice(5).trim();
+      if (!json) continue;
+      try {
+        return JSON.parse(json);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+async function initializeSession({ url, token, fetchImpl, ac }) {
+  const res = await fetchImpl(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      authorization: `Bearer ${token}`,
+      accept: 'application/json, text/event-stream',
+      'mcp-protocol-version': '2025-06-18',
+      'user-agent': 'anyslate-cli/0.1.0',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: nextRequestId++,
+      method: 'initialize',
+      params: {
+        protocolVersion: '2025-06-18',
+        capabilities: {},
+        clientInfo: { name: 'anyslate-cli', version: '0.1.0' },
+      },
+    }),
+    signal: ac.signal,
+  });
+  const sid = res.headers.get('mcp-session-id');
+  if (!res.ok) {
+    const raw = await readBody(res);
+    return { ok: false, status: res.status, sessionId: null, raw };
+  }
+  if (!sid) {
+    return { ok: false, status: res.status, sessionId: null, raw: { error: 'server omitted Mcp-Session-Id header on initialize' } };
+  }
+  // Best-effort `notifications/initialized` — server returns 202 and we
+  // proceed regardless. Required by spec; harmless if dropped on the floor.
+  try {
+    await fetchImpl(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${token}`,
+        accept: 'application/json, text/event-stream',
+        'mcp-protocol-version': '2025-06-18',
+        'mcp-session-id': sid,
+        'user-agent': 'anyslate-cli/0.1.0',
+      },
+      body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} }),
+      signal: ac.signal,
+    });
+  } catch {
+    // Swallow — we have the session id; the notification is advisory.
+  }
+  return { ok: true, status: res.status, sessionId: sid, raw: null };
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.apiUrl
+ * @param {string} opts.token  Bearer token (MCP token).
+ * @param {string} opts.toolName
+ * @param {Record<string, unknown>} opts.args
+ * @param {typeof fetch} [opts.fetchImpl]  override for tests
+ * @param {number} [opts.timeoutMs]
+ * @returns {Promise<{ ok: boolean, status: number, data: unknown, raw: unknown }>}
+ */
+export async function callTool({ apiUrl, token, toolName, args, fetchImpl = fetch, timeoutMs = 15000, sessionId: presetSessionId }) {
+  const url = `${apiUrl.replace(/\/+$/, '')}/mcp`;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+
+  try {
+    let sessionId = presetSessionId || null;
+    if (!sessionId) {
+      const init = await initializeSession({ url, token, fetchImpl, ac });
+      if (!init.ok) {
+        // Surface the auth/init failure exactly as if the tool call itself failed,
+        // so the CLI's existing error handling (server 401 etc.) keeps working.
+        const errLike = init.raw && typeof init.raw === 'object' && 'error' in init.raw
+          ? init.raw.error
+          : init.raw && typeof init.raw === 'object' && 'message' in init.raw
+            ? init.raw
+            : { message: `initialize failed (HTTP ${init.status})` };
+        return { ok: false, status: init.status, data: errLike, raw: init.raw };
+      }
+      sessionId = init.sessionId;
+    }
+
+    const id = nextRequestId++;
+    const body = {
+      jsonrpc: '2.0',
+      method: 'tools/call',
+      id,
+      params: { name: toolName, arguments: args },
+    };
+
+    const res = await fetchImpl(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${token}`,
+        accept: 'application/json, text/event-stream',
+        'mcp-protocol-version': '2025-06-18',
+        'mcp-session-id': sessionId,
+        'user-agent': 'anyslate-cli/0.1.0',
+      },
+      body: JSON.stringify(body),
+      signal: ac.signal,
+    });
+
+    const status = res.status;
+    const raw = await readBody(res);
+
+    if (raw && typeof raw === 'object' && 'error' in raw && raw.error) {
+      return { ok: false, status, data: raw.error, raw };
+    }
+
+    // `result.content[0].text` is the AnySlate dispatcher's JSON envelope.
+    const result = raw && typeof raw === 'object' ? raw.result : null;
+    const content = result && Array.isArray(result.content) ? result.content[0] : null;
+    if (content && content.type === 'text' && typeof content.text === 'string') {
+      try {
+        const parsed = JSON.parse(content.text);
+        return { ok: res.ok, status, data: parsed, raw };
+      } catch {
+        return { ok: res.ok, status, data: content.text, raw };
+      }
+    }
+
+    return { ok: res.ok, status, data: result, raw };
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/stdin.mjs

@@ -0,0 +1,32 @@
+// Read stdin to a single string with a soft cap.
+//
+// Hook events are tiny (Claude Code: <10 KB) but Bash transcript captures can
+// be larger. Cap at 1 MB to stay well below the activity_submit insert limits.
+
+const MAX_STDIN_BYTES = 1_000_000;
+
+/**
+ * @param {NodeJS.ReadableStream} [stream]
+ * @returns {Promise<string>}
+ */
+export async function readStdin(stream = process.stdin) {
+  if (stream.isTTY) return '';
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    stream.setEncoding('utf8');
+    stream.on('data', (chunk) => {
+      bytes += Buffer.byteLength(chunk);
+      if (bytes > MAX_STDIN_BYTES) {
+        // soft cap — keep what we have, stop reading
+        stream.removeAllListeners('data');
+        chunks.push(chunk);
+        resolve(chunks.join(''));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    stream.on('end', () => resolve(chunks.join('')));
+    stream.on('error', reject);
+  });
+}