@anyslate/cli 0.1.0 → 0.3.0

package/src/runlog.mjs

@@ -0,0 +1,196 @@
+// W7 — persisted observability for a fail-open CLI.
+//
+// Exit 0 is correct policy: a network blip must never break a Claude Code
+// session. But the error strategy was "write to stderr", and Claude Code files
+// `exit 0 + stderr` as `hook_success` — 0 of 4,896 production hook_success
+// records carry stderr. The entire error channel had no receiver.
+//
+// So: persist every run. `~/.anyslate/cli-last-run.json` (mode 0600) plus a
+// capped NDJSON ring log. `anyslate doctor` reads them. Nothing here changes an
+// exit code.
+//
+// REDACTION: the record must never contain token material. Every value is run
+// through `redact()` before it is written, and there is a test asserting the
+// file never contains `as_mcp_` / `as_oauth_`.
+
+import { mkdirSync, readFileSync, writeFileSync, appendFileSync, statSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { anyslateDir } from './config.mjs';
+
+export const LAST_RUN_FILE = 'cli-last-run.json';
+export const RING_LOG_FILE = 'cli-runs.ndjson';
+
+/** Escalate only on persistence, not incidence. One failure is a blip. */
+export const ESCALATE_AFTER_CONSECUTIVE_FAILURES = 3;
+
+const RING_MAX_ENTRIES = 200;
+const RING_MAX_BYTES = 256 * 1024;
+
+const TOKEN_RE = /\b(as_mcp_|as_oauth_)[A-Za-z0-9_-]*/g;
+const BEARER_RE = /\bBearer\s+\S+/gi;
+
+/**
+ * Strip anything that looks like credential material from arbitrary data.
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+export function redact(value) {
+  if (value == null) return value;
+  if (typeof value === 'string') {
+    return value.replace(TOKEN_RE, '[redacted-token]').replace(BEARER_RE, 'Bearer [redacted]');
+  }
+  if (Array.isArray(value)) return value.map(redact);
+  if (typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (/token|secret|authorization|password|bearer/i.test(k)) {
+        out[k] = v == null ? v : '[redacted]';
+        continue;
+      }
+      out[k] = redact(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+export function lastRunPath(env = process.env) {
+  return join(anyslateDir(env), LAST_RUN_FILE);
+}
+export function ringLogPath(env = process.env) {
+  return join(anyslateDir(env), RING_LOG_FILE);
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {object|null}
+ */
+export function readLastRun(env = process.env) {
+  try {
+    const parsed = JSON.parse(readFileSync(lastRunPath(env), 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist the outcome of one CLI invocation.
+ *
+ * Never throws — an unwritable home directory must not turn a successful
+ * capture into a failure.
+ *
+ * @param {object} entry
+ * @param {string} entry.command
+ * @param {boolean} entry.ok
+ * @param {string} [entry.apiUrl]
+ * @param {number} [entry.status]
+ * @param {boolean} [entry.isError]
+ * @param {boolean} [entry.networkError]
+ * @param {unknown} [entry.error]
+ * @param {number} [entry.exitCode]
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {{consecutiveFailures: number, lastSuccessAt: string|null, failingSince: string|null}}
+ */
+export function recordRun(entry, env = process.env) {
+  const previous = readLastRun(env) || {};
+  const ts = new Date().toISOString();
+
+  const consecutiveFailures = entry.ok
+    ? 0
+    : Number.isFinite(previous.consecutive_failures)
+      ? Number(previous.consecutive_failures) + 1
+      : 1;
+  const lastSuccessAt = entry.ok ? ts : (previous.last_success_at ?? null);
+  const failingSince = entry.ok ? null : (previous.failing_since ?? ts);
+
+  const record = redact({
+    ts,
+    command: entry.command,
+    ok: !!entry.ok,
+    exit_code: entry.exitCode ?? (entry.ok ? 0 : 1),
+    api_url: entry.apiUrl ?? null,
+    endpoint: entry.apiUrl ? `${String(entry.apiUrl).replace(/\/+$/, '')}/mcp` : null,
+    http_status: entry.status ?? null,
+    is_error: entry.isError ?? false,
+    network_error: entry.networkError ?? false,
+    error: entry.error == null ? null : typeof entry.error === 'string' ? entry.error : JSON.stringify(entry.error),
+    consecutive_failures: consecutiveFailures,
+    last_success_at: lastSuccessAt,
+    failing_since: failingSince,
+    cli_version: entry.version ?? null,
+  });
+
+  try {
+    const dir = anyslateDir(env);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(join(dir, LAST_RUN_FILE), `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+    appendRing(dir, record);
+  } catch {
+    // Observability must never be load-bearing.
+  }
+
+  return { consecutiveFailures, lastSuccessAt, failingSince };
+}
+
+function appendRing(dir, record) {
+  const path = join(dir, RING_LOG_FILE);
+  try {
+    let size = 0;
+    try {
+      size = statSync(path).size;
+    } catch {
+      size = 0;
+    }
+    if (size > RING_MAX_BYTES) {
+      // Cheap rotation: keep the newest half.
+      try {
+        const lines = readFileSync(path, 'utf8').split('\n').filter(Boolean);
+        const keep = lines.slice(-Math.floor(RING_MAX_ENTRIES / 2));
+        writeFileSync(`${path}.tmp`, `${keep.join('\n')}\n`, { mode: 0o600 });
+        renameSync(`${path}.tmp`, path);
+      } catch {
+        writeFileSync(path, '', { mode: 0o600 });
+      }
+    }
+    appendFileSync(path, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Should a SessionStart hook escalate to the model/user?
+ *
+ * @param {{consecutiveFailures: number, failingSince: string|null}} state
+ * @returns {boolean}
+ */
+export function shouldEscalate(state) {
+  if (!state) return false;
+  if (state.consecutiveFailures >= ESCALATE_AFTER_CONSECUTIVE_FAILURES) return true;
+  if (state.failingSince) {
+    const since = Date.parse(state.failingSince);
+    if (Number.isFinite(since) && Date.now() - since > 24 * 60 * 60 * 1000) return true;
+  }
+  return false;
+}
+
+/**
+ * The structured stdout block Claude Code actually renders.
+ * `hook_system_message` and `hook_additional_context` are both verified working
+ * channels; plain stderr is not.
+ *
+ * @param {{consecutiveFailures: number, failingSince: string|null, error?: string|null}} state
+ * @returns {string}
+ */
+export function escalationPayload(state) {
+  const since = state.failingSince ? ` since ${String(state.failingSince).slice(0, 10)}` : '';
+  const because = state.error ? ` (${state.error})` : '';
+  return `${JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: `AnySlate capture has been failing${since}${because}. Run \`anyslate doctor\`.`,
+    },
+    systemMessage: 'AnySlate capture is failing — run `anyslate doctor`.',
+  })}\n`;
+}

package/src/stdin.mjs

@@ -1,32 +1,102 @@
-// Read stdin to a single string with a soft cap.
+// Read stdin to a single string with a soft cap and an idle timeout.
 //
 // 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.
+// be larger. Cap at 1 MB by default; `upload-artifact` raises it to 5 MB.
+//
+// The timeout is an **idle** timeout, reset on every chunk (defect #29). A
+// hook wired to a non-closing pipe (`sleep 300 | anyslate hook post-tool-use`)
+// previously hung forever: the 15 s AbortController is armed inside `callTool`,
+// which is never reached while stdin is still open. An idle timeout terminates
+// that case while still letting a slow 5 MB upload stream through.
+
+export const DEFAULT_MAX_STDIN_BYTES = 1_000_000;
+export const DEFAULT_STDIN_TIMEOUT_MS = 10_000;
 
-const MAX_STDIN_BYTES = 1_000_000;
+/**
+ * Resolve the idle timeout, honouring `ANYSLATE_STDIN_TIMEOUT_MS` (a tuning
+ * knob for slow pipes, and what the test-suite uses to avoid 10s waits).
+ *
+ * @param {NodeJS.ProcessEnv} [env]
+ * @param {number} [fallback]
+ * @returns {number}
+ */
+export function stdinTimeoutFromEnv(env = process.env, fallback = DEFAULT_STDIN_TIMEOUT_MS) {
+  const raw = env.ANYSLATE_STDIN_TIMEOUT_MS;
+  if (raw === undefined || raw === null || String(raw).trim() === '') return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
 
 /**
  * @param {NodeJS.ReadableStream} [stream]
+ * @param {{ maxBytes?: number, timeoutMs?: number }} [opts]
  * @returns {Promise<string>}
  */
-export async function readStdin(stream = process.stdin) {
+export async function readStdin(stream = process.stdin, opts = {}) {
   if (stream.isTTY) return '';
+  const maxBytes = opts.maxBytes ?? DEFAULT_MAX_STDIN_BYTES;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_STDIN_TIMEOUT_MS;
+
   return new Promise((resolve, reject) => {
     const chunks = [];
     let bytes = 0;
-    stream.setEncoding('utf8');
-    stream.on('data', (chunk) => {
+    let settled = false;
+    let timer = null;
+
+    const detach = () => {
+      if (timer) clearTimeout(timer);
+      timer = null;
+      stream.removeListener('data', onData);
+      stream.removeListener('end', onEnd);
+      stream.removeListener('error', onError);
+    };
+
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      detach();
+      resolve(value);
+    };
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      detach();
+      reject(err);
+    };
+
+    const arm = () => {
+      if (timer) clearTimeout(timer);
+      if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return;
+      timer = setTimeout(() => {
+        if (typeof stream.pause === 'function') stream.pause();
+        fail(
+          new Error(`stdin read timed out after ${Math.round(timeoutMs / 1000)}s — no EOF received`),
+        );
+      }, timeoutMs);
+    };
+
+    function onData(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(''));
+      chunks.push(chunk);
+      if (bytes > maxBytes) {
+        // soft cap - keep what we have, stop reading
+        if (typeof stream.pause === 'function') stream.pause();
+        finish(chunks.join(''));
         return;
       }
-      chunks.push(chunk);
-    });
-    stream.on('end', () => resolve(chunks.join('')));
-    stream.on('error', reject);
+      arm();
+    }
+    function onEnd() {
+      finish(chunks.join(''));
+    }
+    function onError(err) {
+      fail(err);
+    }
+
+    stream.setEncoding('utf8');
+    stream.on('data', onData);
+    stream.on('end', onEnd);
+    stream.on('error', onError);
+    arm();
   });
 }

package/src/verify.mjs

@@ -0,0 +1,262 @@
+// Shared connection verification — used by both `anyslate login` (W3) and
+// `anyslate doctor` (W4) so the two can never disagree about what "working"
+// means.
+//
+// ORDERING IS MANDATORY. A wrong URL 404s at `app.notFound()` (index.ts:113-115)
+// *before* any auth middleware runs, so a `/mcp`-suffixed apiUrl masks every
+// token verdict. URL shape must therefore be resolved before any token verdict
+// is trusted. That is exactly the state found live on this machine: a
+// double-`/mcp` URL AND a revoked token, and the 404 hid the revocation.
+//
+// Side-effect disclosure (do NOT claim this is quiet): `/mcp/auth/verify` runs
+// mcpAuth (UPDATE mcp_tokens SET last_used_at), rateLimit (read bucket,
+// 100/min) and audit (one mcp_audit_logs row, action `auth.read`, plus a
+// connection-sync bump and an `mcp_call` stream event). It is chosen because it
+// is semantically a verification endpoint that returns `scopes` in one round
+// trip and mints no KV session — not because it is free.
+
+import { USER_AGENT } from './version.mjs';
+import { classifyNetworkError } from './mcp-client.mjs';
+import { normalizeApiRoot } from './config.mjs';
+
+export const TOKEN_MCP_RE = /^as_mcp_[0-9a-f]{48}$/;
+export const TOKEN_OAUTH_RE = /^as_oauth_[0-9a-f]{64}$/;
+
+export const REQUIRED_SCOPE = 'memory:write';
+
+/**
+ * Token format contract, verbatim from the bridge (mcp-package/src/index.ts:32-38).
+ *
+ * The two lengths genuinely differ — 24 random bytes for `as_mcp_`
+ * (routes/mcp-tokens.ts:18-25) vs 32 for `as_oauth_`
+ * (mcp-service/src/routes/oauth.ts:914-919). A single length rule
+ * false-positives on one of them.
+ *
+ * @param {unknown} token
+ * @returns {boolean}
+ */
+export function isValidTokenFormat(token) {
+  if (typeof token !== 'string') return false;
+  return TOKEN_MCP_RE.test(token) || TOKEN_OAUTH_RE.test(token);
+}
+
+/** A short, safe preview of a rejected token for the error message. */
+export function tokenPreview(token) {
+  const s = String(token ?? '');
+  return s.length <= 8 ? s : `${s.slice(0, 8)}…`;
+}
+
+/**
+ * Does this token carry the scope `activity_submit` requires?
+ * `hasAnyScope` on the server also honours a literal `'*'`.
+ *
+ * @param {unknown} scopes
+ * @returns {boolean}
+ */
+export function hasWriteScope(scopes) {
+  if (!Array.isArray(scopes)) return false;
+  return scopes.includes(REQUIRED_SCOPE) || scopes.includes('*');
+}
+
+/**
+ * Validate the shape of `--api-url` before anything is trusted about a token.
+ *
+ * @param {string} value
+ * @returns {{ok: true, root: string, host: string, normalized: boolean, original: string}
+ *          | {ok: false, code: string, message: string}}
+ */
+export function checkUrlShape(value) {
+  const original = String(value ?? '').trim();
+  if (!original) {
+    return {
+      ok: false,
+      code: 'url_empty',
+      message: 'anyslate: --api-url is empty. Pass the service root, e.g. --api-url https://mcp.anyslate.io',
+    };
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(original);
+  } catch {
+    return {
+      ok: false,
+      code: 'url_unparseable',
+      message: `anyslate: "${original}" is not a valid URL. Pass the service root, e.g. --api-url https://mcp.anyslate.io`,
+    };
+  }
+
+  const isLocal =
+    parsed.hostname === 'localhost' ||
+    parsed.hostname === '127.0.0.1' ||
+    parsed.hostname === '::1' ||
+    parsed.hostname === '0.0.0.0';
+  if (parsed.protocol !== 'https:' && !(parsed.protocol === 'http:' && isLocal)) {
+    return {
+      ok: false,
+      code: 'url_scheme',
+      message: `anyslate: --api-url must use https (http is allowed only for localhost). Got "${original}".`,
+    };
+  }
+
+  const root = normalizeApiRoot(original);
+  return {
+    ok: true,
+    root,
+    host: parsed.host,
+    original,
+    normalized: root !== original.replace(/\/+$/, ''),
+  };
+}
+
+/**
+ * One live request that proves reachability, URL shape, token existence,
+ * revocation, expiry — and returns `scopes`.
+ *
+ * @param {object} opts
+ * @param {string} opts.root      normalized service root
+ * @param {string} opts.token
+ * @param {typeof fetch} [opts.fetchImpl]
+ * @param {number} [opts.timeoutMs]
+ * @returns {Promise<{ok: boolean, code: string, message: string, status?: number,
+ *   userId?: string|null, scopes?: string[], defaultHandleId?: string|null, raw?: unknown}>}
+ */
+export async function probeVerify({ root, token, fetchImpl = fetch, timeoutMs = 10_000 }) {
+  const url = `${root}/mcp/auth/verify`;
+  let host = root;
+  try {
+    host = new URL(root).host;
+  } catch {
+    /* keep root */
+  }
+
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method: 'GET',
+      headers: {
+        authorization: `Bearer ${token}`,
+        accept: 'application/json',
+        'user-agent': USER_AGENT,
+      },
+      signal: ac.signal,
+    });
+  } catch (e) {
+    const detail = classifyNetworkError(e, host, timeoutMs);
+    const short = /ENOTFOUND|EAI_AGAIN/.test(detail)
+      ? 'ENOTFOUND'
+      : /ECONNREFUSED/.test(detail)
+        ? 'ECONNREFUSED'
+        : /TLS/.test(detail)
+          ? 'TLS'
+          : /timed out/.test(detail)
+            ? 'timeout'
+            : detail;
+    return {
+      ok: false,
+      code: 'unreachable',
+      message: `anyslate: cannot reach ${host} — ${short}. Check --api-url and your network.`,
+      raw: detail,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+    body = null;
+  }
+
+  if (res.status === 404) {
+    return {
+      ok: false,
+      code: 'not_found',
+      status: 404,
+      message: `anyslate: ${root}/mcp/auth/verify returned 404 — this host isn't an AnySlate MCP service, or --api-url includes a path prefix.`,
+      raw: body,
+    };
+  }
+
+  if (res.status === 401 || res.status === 403) {
+    const err = typeof body?.error === 'string' ? body.error : '';
+    const desc = typeof body?.error_description === 'string' ? body.error_description : '';
+
+    if (err === 'authorization_required') {
+      return {
+        ok: false,
+        code: 'authorization_required',
+        status: res.status,
+        message: 'anyslate: server rejected the Authorization header. This is a CLI bug — please report it.',
+        raw: body,
+      };
+    }
+    if (/revok/i.test(desc)) {
+      return {
+        ok: false,
+        code: 'revoked',
+        status: res.status,
+        message: 'anyslate: that token was revoked. Mint a new one at Avatar → API Tokens, then re-run anyslate login.',
+        raw: body,
+      };
+    }
+    if (/expire/i.test(desc)) {
+      return {
+        ok: false,
+        code: 'expired',
+        status: res.status,
+        message: 'anyslate: that token has expired. Mint a new one at Avatar → API Tokens.',
+        raw: body,
+      };
+    }
+    return {
+      ok: false,
+      code: 'invalid_token',
+      status: res.status,
+      message: `anyslate: token not recognised by ${host}. Check for a typo, or that you minted it in the same environment (dev vs prod).`,
+      raw: body,
+    };
+  }
+
+  if (!res.ok) {
+    return {
+      ok: false,
+      code: 'http_error',
+      status: res.status,
+      message: `anyslate: ${host} returned HTTP ${res.status} from /mcp/auth/verify${
+        body?.error ? ` — ${body.error}` : ''
+      }.`,
+      raw: body,
+    };
+  }
+
+  const scopes = Array.isArray(body?.scopes) ? body.scopes : [];
+  const userId = body?.user_id ?? body?.userId ?? null;
+  const defaultHandleId = body?.default_handle_id ?? body?.defaultHandleId ?? null;
+
+  return {
+    ok: true,
+    code: 'verified',
+    status: res.status,
+    message: `anyslate: verified against ${host} — user ${userId ?? '(unknown)'}, scopes [${scopes.join(',')}]`,
+    userId,
+    scopes,
+    defaultHandleId,
+    raw: body,
+  };
+}
+
+/**
+ * Exact scope warning (warn, never block — the token may still be usable for
+ * reads, and blocking here would be a new class of false negative).
+ *
+ * @param {string[]} scopes
+ * @returns {string|null}
+ */
+export function scopeWarning(scopes) {
+  if (hasWriteScope(scopes)) return null;
+  return `anyslate: warning — token scopes are [${(scopes || []).join(',')}]; \`anyslate hook\` needs ${REQUIRED_SCOPE}. Mint a token with the Memory profile.`;
+}

package/src/version.mjs

@@ -0,0 +1,21 @@
+// Single source of truth for the CLI version.
+//
+// Read from package.json at runtime rather than duplicated as a literal in
+// index.mjs and mcp-client.mjs (the User-Agent). npm always ships
+// package.json inside the tarball, so this resolves in an installed package
+// exactly as it does in the repo.
+
+import { readFileSync } from 'node:fs';
+
+function read() {
+  try {
+    const raw = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed?.version === 'string' ? parsed.version : '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+export const VERSION = read();
+export const USER_AGENT = `anyslate-cli/${VERSION}`;

package/templates/git/post-commit

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# AnySlate — git post-commit hook (Phase 15.3)
+#
+# Drop this file at .git/hooks/post-commit (chmod +x). On every commit it
+# pipes a small JSON payload to `anyslate hook post-tool-use`, which submits
+# a `task_completed` activity to your AnySlate Activity feed via the
+# activity_submit MCP tool. 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 Activity panel.
+#
+# Requirements:
+#   - anyslate CLI installed (`npx @anyslate/cli` or `npm i -g @anyslate/cli`)
+#   - ANYSLATE_MCP_TOKEN configured (or `anyslate login --token <BEARER>`)
+#
+# Optional env:
+#   ANYSLATE_SESSION   AI session id to route the checkpoint into. If unset,
+#                      the activity classifier will mark this high-risk so
+#                      you can approve + assign in the desktop UI.
+#   ANYSLATE_HOST      host_hint advisory (default: git_post_commit)
+#   ANYSLATE_QUIET     if set, swallow CLI stderr (the hook itself never
+#                      blocks the commit either way)
+
+set -u
+
+if ! command -v anyslate >/dev/null 2>&1; then
+  if ! command -v npx >/dev/null 2>&1; then
+    exit 0
+  fi
+  ANYSLATE_BIN=("npx" "--yes" "@anyslate/cli")
+else
+  ANYSLATE_BIN=("anyslate")
+fi
+
+REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || echo unknown)"
+REPO_NAME="$(basename "${REPO_ROOT}")"
+SHA="$(git rev-parse HEAD 2>/dev/null || echo unknown)"
+SHORT_SHA="$(git rev-parse --short HEAD 2>/dev/null || echo unknown)"
+BRANCH="$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown)"
+SUBJECT="$(git log -1 --pretty=%s 2>/dev/null || echo)"
+AUTHOR="$(git log -1 --pretty='%an' 2>/dev/null || echo)"
+STATS="$(git show --stat --pretty='' HEAD 2>/dev/null | tail -1 | tr -d '\n')"
+
+read -r -d '' EVENT <<JSON || true
+{
+  "session_id": "${ANYSLATE_SESSION:-}",
+  "tool_name": "GitCommit",
+  "tool_response": {
+    "repo": "${REPO_NAME}",
+    "branch": "${BRANCH}",
+    "sha": "${SHA}",
+    "short_sha": "${SHORT_SHA}",
+    "subject": $(printf '%s' "${SUBJECT}" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))' 2>/dev/null || printf '"%s"' "${SUBJECT//\"/\\\"}"),
+    "author": $(printf '%s' "${AUTHOR}" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))' 2>/dev/null || printf '"%s"' "${AUTHOR//\"/\\\"}"),
+    "stats": $(printf '%s' "${STATS}" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))' 2>/dev/null || printf '"%s"' "${STATS//\"/\\\"}")
+  }
+}
+JSON
+
+cli_args=(hook post-tool-use --host "${ANYSLATE_HOST:-git_post_commit}")
+cli_args+=(--note "git commit on ${REPO_NAME}@${BRANCH}: ${SUBJECT}")
+if [ -n "${ANYSLATE_SESSION:-}" ]; then
+  cli_args+=(--session "${ANYSLATE_SESSION}")
+fi
+
+if [ -n "${ANYSLATE_QUIET:-}" ]; then
+  printf '%s\n' "${EVENT}" | "${ANYSLATE_BIN[@]}" "${cli_args[@]}" >/dev/null 2>&1 || true
+else
+  printf '%s\n' "${EVENT}" | "${ANYSLATE_BIN[@]}" "${cli_args[@]}" >/dev/null || true
+fi
+
+exit 0