kronk-cli 0.1.0

package/src/mcp.js

@@ -0,0 +1,268 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { c } from './ui.js';
+
+const PROTOCOL = '2025-06-18';
+const CLIENT = { name: 'kronk-cli', version: '0.1.0' };
+const CALL_TIMEOUT = 120_000;
+const START_TIMEOUT = 20_000;
+
+/* ------------------------------------------------------------------ config */
+
+/**
+ * Read MCP servers from the places a developer already keeps them:
+ * Claude Code's global and per-project config, a project `.mcp.json`, and
+ * kronk-cli's own rc file. Later sources win on name collision.
+ */
+export async function loadServers(cwd = process.cwd()) {
+  const out = {};
+  const merge = (obj) => { for (const [k, v] of Object.entries(obj ?? {})) out[k] = v; };
+
+  const readJson = async (p) => {
+    try { return JSON.parse(await readFile(p, 'utf8')); } catch { return null; }
+  };
+
+  const claude = await readJson(join(homedir(), '.claude.json'));
+  if (claude) {
+    merge(claude.mcpServers);
+    merge(claude.projects?.[cwd]?.mcpServers);
+  }
+  merge((await readJson(join(cwd, '.mcp.json')))?.mcpServers);
+  merge((await readJson(join(homedir(), '.kronk-cli.json')))?.mcpServers);
+  merge((await readJson(join(cwd, '.kronk-cli.json')))?.mcpServers);
+
+  // `"disabled": true` keeps an entry in the file but out of this session.
+  for (const [k, v] of Object.entries(out)) if (v?.disabled) delete out[k];
+  return out;
+}
+
+/* --------------------------------------------------------------- transports */
+
+/** Newline-delimited JSON-RPC over a child process's stdio. */
+function stdioTransport(spec, name) {
+  const child = spawn(spec.command, spec.args ?? [], {
+    env: { ...process.env, ...(spec.env ?? {}) },
+    cwd: spec.cwd ?? process.cwd(),
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  const pending = new Map();
+  let buf = '';
+  let stderrTail = '';
+
+  child.stdout.on('data', (d) => {
+    buf += d.toString();
+    const lines = buf.split('\n');
+    buf = lines.pop() ?? '';
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let msg;
+      try { msg = JSON.parse(line); } catch { continue; }   // servers log to stdout sometimes
+      const p = pending.get(msg.id);
+      if (!p) continue;
+      pending.delete(msg.id);
+      msg.error ? p.reject(new Error(msg.error.message ?? 'mcp error')) : p.resolve(msg.result);
+    }
+  });
+
+  // Keep the last of stderr so a crash can be explained.
+  child.stderr.on('data', (d) => { stderrTail = (stderrTail + d.toString()).slice(-2000); });
+
+  const fail = (e) => {
+    for (const p of pending.values()) p.reject(e);
+    pending.clear();
+  };
+  child.on('error', (e) => fail(new Error(`${name}: ${e.message}`)));
+  child.on('exit', (code) => fail(new Error(`${name}: exited (${code}) ${stderrTail.trim()}`)));
+
+  // A live child with piped stdio holds the event loop open, so the CLI would
+  // print its answer and then hang instead of exiting. Unref everything; we
+  // kill the child explicitly on close.
+  child.unref();
+  child.stdout.unref?.();
+  child.stderr.unref?.();
+  child.stdin.unref?.();
+
+  return {
+    kind: 'stdio',
+    async send(msg, timeout) {
+      if (msg.id === undefined) {                            // notification
+        child.stdin.write(`${JSON.stringify(msg)}\n`);
+        return undefined;
+      }
+      return new Promise((resolve, reject) => {
+        const t = setTimeout(() => {
+          pending.delete(msg.id);
+          reject(new Error(`${name}: timed out after ${timeout}ms`));
+        }, timeout);
+        pending.set(msg.id, {
+          resolve: (v) => { clearTimeout(t); resolve(v); },
+          reject: (e) => { clearTimeout(t); reject(e); },
+        });
+        child.stdin.write(`${JSON.stringify(msg)}\n`);
+      });
+    },
+    close() { child.kill(); },
+  };
+}
+
+/** Streamable HTTP: POST JSON-RPC, accept either JSON or an SSE stream back. */
+function httpTransport(spec, name) {
+  let sessionId = null;
+
+  return {
+    kind: 'http',
+    async send(msg, timeout) {
+      const ac = new AbortController();
+      const t = setTimeout(() => ac.abort(), timeout);
+      try {
+        const res = await fetch(spec.url, {
+          method: 'POST',
+          signal: ac.signal,
+          headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json, text/event-stream',
+            ...(sessionId ? { 'Mcp-Session-Id': sessionId } : {}),
+            ...(spec.headers ?? {}),
+          },
+          body: JSON.stringify(msg),
+        });
+        const sid = res.headers.get('mcp-session-id');
+        if (sid) sessionId = sid;
+        if (msg.id === undefined) return undefined;
+        if (!res.ok) throw new Error(`${name}: HTTP ${res.status} ${(await res.text()).slice(0, 200)}`);
+
+        const body = await res.text();
+        // SSE framing when the server streams; plain JSON otherwise.
+        const payload = body.startsWith('event:') || body.startsWith('data:')
+          ? body.split('\n').filter((l) => l.startsWith('data:')).map((l) => l.slice(5).trim()).join('')
+          : body;
+        const parsed = JSON.parse(payload);
+        if (parsed.error) throw new Error(parsed.error.message ?? 'mcp error');
+        return parsed.result;
+      } finally { clearTimeout(t); }
+    },
+    close() {},
+  };
+}
+
+/* ------------------------------------------------------------------ client */
+
+class Server {
+  constructor(name, spec) {
+    this.name = name;
+    this.spec = spec;
+    this.tools = [];
+    this.nextId = 1;
+  }
+
+  async start() {
+    const isHttp = this.spec.url || this.spec.type === 'http' || this.spec.type === 'sse';
+    if (!isHttp && !this.spec.command) throw new Error('needs a command or a url');
+    this.transport = isHttp
+      ? httpTransport(this.spec, this.name)
+      : stdioTransport(this.spec, this.name);
+
+    await this.rpc('initialize', {
+      protocolVersion: PROTOCOL,
+      capabilities: { tools: {} },
+      clientInfo: CLIENT,
+    }, START_TIMEOUT);
+
+    await this.transport.send({ jsonrpc: '2.0', method: 'notifications/initialized' }, START_TIMEOUT);
+
+    const { tools } = await this.rpc('tools/list', {}, START_TIMEOUT);
+    this.tools = tools ?? [];
+    return this.tools;
+  }
+
+  rpc(method, params, timeout = CALL_TIMEOUT) {
+    return this.transport.send(
+      { jsonrpc: '2.0', id: this.nextId++, method, params },
+      timeout,
+    );
+  }
+
+  close() { this.transport?.close(); }
+}
+
+/** Function names must match ^[a-zA-Z0-9_-]{1,64}$ for the chat API. */
+export const qualify = (server, tool) =>
+  `${server}__${tool}`.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+
+export class McpHub {
+  constructor() {
+    this.servers = new Map();
+    this.routes = new Map();   // qualified name -> { server, tool }
+    this.failures = [];
+  }
+
+  /** Start every configured server. One failing never blocks the others. */
+  async connect(specs) {
+    const entries = Object.entries(specs);
+    await Promise.all(entries.map(async ([name, spec]) => {
+      const server = new Server(name, spec);
+      try {
+        const tools = await server.start();
+        this.servers.set(name, server);
+        for (const t of tools) this.routes.set(qualify(name, t.name), { server, tool: t.name });
+      } catch (e) {
+        this.failures.push({ name, error: e.message });
+        server.close();
+      }
+    }));
+    return this;
+  }
+
+  /** MCP tool definitions in OpenAI function-calling shape. */
+  toolDefs() {
+    const defs = [];
+    for (const [qualified, { server, tool }] of this.routes) {
+      const def = server.tools.find((t) => t.name === tool);
+      defs.push({
+        type: 'function',
+        function: {
+          name: qualified,
+          description: `[${server.name}] ${def?.description ?? tool}`.slice(0, 1024),
+          parameters: def?.inputSchema ?? { type: 'object', properties: {} },
+        },
+      });
+    }
+    return defs;
+  }
+
+  has(name) { return this.routes.has(name); }
+
+  async call(name, args) {
+    const route = this.routes.get(name);
+    if (!route) return `error: unknown MCP tool ${name}`;
+    try {
+      const res = await route.server.rpc('tools/call', { name: route.tool, arguments: args ?? {} });
+      const text = (res?.content ?? [])
+        .map((part) => {
+          if (part.type === 'text') return part.text;
+          if (part.type === 'resource') return part.resource?.text ?? `[resource ${part.resource?.uri}]`;
+          return `[${part.type}]`;
+        })
+        .join('\n')
+        .trim();
+      const body = text || JSON.stringify(res?.structuredContent ?? res ?? {}).slice(0, 4000);
+      return res?.isError ? `error: ${body}` : body;
+    } catch (e) {
+      return `error: ${e.message}`;
+    }
+  }
+
+  summary() {
+    const parts = [...this.servers.values()].map((s) => `${s.name}(${s.tools.length})`);
+    return parts.join(' · ');
+  }
+
+  close() { for (const s of this.servers.values()) s.close(); }
+}
+
+export function reportFailures(failures) {
+  for (const f of failures) console.log(c.yellow(`  mcp ${f.name}: ${f.error.slice(0, 160)}`));
+}

package/src/sse.js

@@ -0,0 +1,45 @@
+/**
+ * Incremental Server-Sent Events parser.
+ *
+ * Kept separate from the HTTP call so the protocol logic can be tested without
+ * a server: chunk boundaries fall in arbitrary places, and a parser that only
+ * works when each read lands on a line boundary will fail in production and
+ * pass every naive test.
+ */
+export function createSseParser() {
+  let buf = '';
+  return {
+    /** Feed a chunk; get back the complete `data:` payloads it completed. */
+    push(chunk) {
+      buf += chunk;
+      const lines = buf.split('\n');
+      buf = lines.pop() ?? '';
+      const out = [];
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const payload = line.slice(6).trim();
+        if (payload) out.push(payload);
+      }
+      return out;
+    },
+    /** Anything left in the buffer that never saw a newline. */
+    flush() {
+      const rest = buf;
+      buf = '';
+      return rest.startsWith('data: ') ? [rest.slice(6).trim()].filter(Boolean) : [];
+    },
+  };
+}
+
+/** Merge streamed tool-call deltas, accumulating arguments by index. */
+export function accumulateToolCalls(calls, deltas) {
+  for (const tc of deltas ?? []) {
+    const idx = tc.index ?? 0;
+    const cur = calls.get(idx) ?? { id: '', name: '', args: '' };
+    if (tc.id) cur.id = tc.id;
+    if (tc.function?.name) cur.name = tc.function.name;
+    if (tc.function?.arguments) cur.args += tc.function.arguments;
+    calls.set(idx, cur);
+  }
+  return calls;
+}

package/src/tools.js

@@ -0,0 +1,270 @@
+import { readFile, writeFile, readdir, stat } from 'node:fs/promises';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { resolve, relative } from 'node:path';
+import { realpathSync } from 'node:fs';
+import { c } from './ui.js';
+
+const exec = promisify(execFile);
+export const MAX_OUT = 30_000;
+const MAX_CAPTURE = 400_000;                     // keep the tail of chatty builds
+const TOOL_TIMEOUT = Number(process.env.KRONK_TOOL_TIMEOUT ?? 900) * 1000;   // 15 min
+
+/**
+ * One shell session for the whole run.
+ *
+ * Each bash call is a fresh `bash -c`, so a bare `cd` would evaporate and the
+ * next command would silently run somewhere else — the model then flails,
+ * re-running `pwd` and `cd` trying to work out where it is. We keep the cwd
+ * here and hand it back to every subsequent call.
+ */
+export const session = { root: real(process.cwd()), cwd: real(process.cwd()) };
+
+/**
+ * Resolve symlinks before comparing paths.
+ *
+ * macOS maps /tmp and /var onto /private/*, so a shell reporting its own `pwd`
+ * hands back a path that no longer looks like a child of the launch root. The
+ * containment check then fails and `cd` silently stops persisting.
+ */
+function real(p) {
+  try { return realpathSync(p); } catch { return p; }
+}
+
+/**
+ * Trim from the MIDDLE, never the end.
+ *
+ * Build output puts its errors last, so head-only truncation silently dropped
+ * exactly the lines that mattered and left 30k characters of progress chatter.
+ */
+export const clip = (s) => {
+  if (s.length <= MAX_OUT) return s;
+  const head = Math.floor(MAX_OUT * 0.3);
+  const tail = MAX_OUT - head;
+  const dropped = s.length - head - tail;
+  return `${s.slice(0, head)}\n…[${dropped.toLocaleString()} chars elided from the middle]…\n${s.slice(-tail)}`;
+};
+
+/** Resolve against the session cwd, and keep the agent inside the launch root. */
+export function safe(p) {
+  const abs = resolve(real(session.cwd), p);
+  const rel = relative(real(session.root), abs);
+  if (rel.startsWith('..')) throw new Error(`refusing to touch path outside ${session.root}: ${p}`);
+  return abs;
+}
+
+const def = (name, description, properties, required) => ({
+  type: 'function',
+  function: { name, description, parameters: { type: 'object', properties, required } },
+});
+
+export const TOOLS = [
+  def('read_file', 'Read a UTF-8 text file relative to the working directory.',
+    { path: { type: 'string' } }, ['path']),
+
+  def('write_file', 'Create or overwrite a text file. Requires user approval.',
+    { path: { type: 'string' }, content: { type: 'string' } }, ['path', 'content']),
+
+  def('list_dir', 'List entries in a directory. Defaults to the working directory.',
+    { path: { type: 'string' } }, []),
+
+  def('search', 'Search file contents with a regular expression (ripgrep-style). Returns matching lines with file:line prefixes.',
+    { pattern: { type: 'string' }, path: { type: 'string' } }, ['pattern']),
+
+  def('bash', 'Run a shell command in the working directory. Requires user approval.',
+    { cmd: { type: 'string' } }, ['cmd']),
+];
+
+/** Tools that mutate state or run arbitrary code must be confirmed. */
+export const NEEDS_APPROVAL = new Set(['write_file', 'bash']);
+
+/**
+ * MCP tools are arbitrary third-party code, so anything that looks like it
+ * writes gets gated. Read-only lookups stay frictionless — prompting for
+ * `nx__nx_docs` would train you to hit `y` without reading.
+ */
+const MUTATING = /(^|_)(create|update|delete|remove|write|edit|apply|sync|run|exec|deploy|restart|scale|patch|set|add|move|rename|push|merge|close|assign)(_|$)/i;
+
+export function mcpNeedsApproval(qualifiedName) {
+  return MUTATING.test(qualifiedName.split('__').slice(1).join('__'));
+}
+
+export function preview(name, args) {
+  if (name === 'write_file') {
+    const lines = (args.content ?? '').split('\n');
+    const head = lines.slice(0, 12).map((l) => c.green(`+ ${l}`)).join('\n');
+    const more = lines.length > 12 ? c.grey(`\n  …${lines.length - 12} more lines`) : '';
+    return `${c.bold(args.path)}\n${head}${more}`;
+  }
+  if (name === 'bash') return c.yellow(`$ ${args.cmd}`);
+  return '';
+}
+
+export function describe(name, args) {
+  switch (name) {
+    case 'read_file':  return `read ${args.path}`;
+    case 'write_file': return `write ${args.path}`;
+    case 'list_dir':   return `ls ${args.path ?? '.'}`;
+    case 'search':     return `search /${args.pattern}/ in ${args.path ?? '.'}`;
+    case 'bash':       return `bash: ${args.cmd}`;
+    default:           return `${name}(${JSON.stringify(args)})`;
+  }
+}
+
+/** Strip the cwd marker off command output and record where we ended up. */
+function applyCwd(out, mark) {
+  const i = out.lastIndexOf(mark);
+  if (i === -1) return out;
+  const next = real(out.slice(i + mark.length).trim());
+  const rel = relative(real(session.root), next);
+  if (next && !rel.startsWith('..')) session.cwd = next;
+  return out.slice(0, i).replace(/\n$/, '');
+}
+
+const MARK = '__KRONK_CWD__';
+
+/**
+ * Run a shell command, streaming progress to `onProgress` as it goes.
+ *
+ * `execFile` buffers silently, so a ten-minute build looked identical to a
+ * hang, and when it was killed the rejection carried `code: undefined` — the
+ * infamous `exit code ?`. Spawning directly gives us live output, the real
+ * signal, and whatever the command managed to print before it died.
+ */
+export function runBash(cmd, { onProgress, timeoutMs = TOOL_TIMEOUT } = {}) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    // Own process group: killing bash alone leaves its children running and
+    // holding the stdout pipe open, so `close` would not fire until they
+    // finished anyway — a 5s timeout that returned after 30s.
+    // Capture the real status BEFORE the marker runs, then exit with it.
+    // Appending `printf` naively made every command look successful, so
+    // failures never reached the agent at all.
+    const script = `${cmd}\n__kronk_st=$?\nprintf '\\n${MARK}%s' "$(pwd)"\nexit $__kronk_st`;
+    const child = spawn('bash', ['-c', script], {
+      cwd: session.cwd,
+      env: { ...process.env, TERM: 'dumb', CI: process.env.CI ?? '1' },
+      detached: true,
+    });
+
+    const killTree = (sig) => {
+      try { process.kill(-child.pid, sig); }
+      catch { try { child.kill(sig); } catch { /* already gone */ } }
+    };
+
+    let out = '';
+    let err = '';
+    let truncated = false;
+    let lines = 0;
+    let produced = 0;          // total bytes the command has emitted
+
+    const take = (chunk, into) => {
+      const text = chunk.toString();
+      produced += text.length;
+      lines += (text.match(/\n/g) ?? []).length;
+      if (into === 'out') out += text; else err += text;
+      if (out.length + err.length > MAX_CAPTURE) {
+        truncated = true;
+        if (out.length > MAX_CAPTURE) out = out.slice(-MAX_CAPTURE);
+        if (err.length > MAX_CAPTURE) err = err.slice(-MAX_CAPTURE);
+      }
+      const lastLine = text.trimEnd().split('\n').pop() ?? '';
+      onProgress?.({
+        seconds: (Date.now() - started) / 1000,
+        lines,
+        bytes: produced,
+        kept: Math.min(produced, MAX_OUT),
+        capped: produced > MAX_OUT,
+        lastLine: lastLine.slice(0, 90),
+      });
+    };
+
+    child.stdout.on('data', (d) => take(d, 'out'));
+    child.stderr.on('data', (d) => take(d, 'err'));
+
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; killTree('SIGKILL'); }, timeoutMs);
+
+    child.on('error', (e) => {
+      clearTimeout(timer);
+      resolve(`error: could not start command — ${e.message}\ncwd: ${session.cwd}`);
+    });
+
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+      const secs = ((Date.now() - started) / 1000).toFixed(1);
+      const body = applyCwd(out, MARK);
+      const tail = [
+        body.trim() && `stdout:\n${body.trim()}`,
+        err.trim() && `stderr:\n${err.trim()}`,
+      ].filter(Boolean).join('\n\n');
+
+      if (timedOut) {
+        return resolve(clip([
+          `error: killed after ${secs}s (timeout ${Math.round(timeoutMs / 1000)}s).`,
+          'The command may simply be slow — re-run a narrower scope, or raise KRONK_TOOL_TIMEOUT.',
+          `cwd: ${session.cwd}`,
+          tail || '(no output before it was killed)',
+        ].join('\n')));
+      }
+      if (code === 0) {
+        const okBody = clip(body + err);
+        return resolve(`${okBody.trim() || '(no output)'}${truncated ? '\n[earlier output dropped]' : ''}`);
+      }
+      return resolve(clip([
+        signal
+          ? `error: killed by ${signal} after ${secs}s`
+          : `error: exit code ${code} after ${secs}s`,
+        `cwd: ${session.cwd}`,
+        tail || '(no output)',
+        truncated ? '[earlier output dropped]' : '',
+      ].filter(Boolean).join('\n')));
+    });
+  });
+}
+
+export async function runTool(name, args, opts = {}) {
+  try {
+    switch (name) {
+      case 'read_file':
+        return clip(await readFile(safe(args.path), 'utf8'));
+
+      case 'write_file':
+        await writeFile(safe(args.path), args.content ?? '');
+        return `wrote ${args.path} (${(args.content ?? '').length} bytes)`;
+
+      case 'list_dir': {
+        const dir = safe(args.path ?? '.');
+        const names = await readdir(dir);
+        const rows = await Promise.all(names.map(async (n) => {
+          try {
+            const s = await stat(resolve(dir, n));
+            return s.isDirectory() ? `${n}/` : `${n}  ${s.size}b`;
+          } catch { return n; }
+        }));
+        return clip(rows.join('\n')) || '(empty)';
+      }
+
+      case 'search': {
+        const where = args.path ?? '.';
+        try {
+          const { stdout } = await exec('rg', ['-n', '--no-heading', '-m', '200', args.pattern, where]);
+          return clip(stdout) || '(no matches)';
+        } catch (e) {
+          if (e.code === 1) return '(no matches)';
+          const { stdout } = await exec('grep', ['-rn', '-m', '200', args.pattern, where]);
+          return clip(stdout) || '(no matches)';
+        }
+      }
+
+      case 'bash':
+        return runBash(args.cmd, opts);
+
+      default:
+        return `error: unknown tool ${name}`;
+    }
+  } catch (e) {
+    // Errors are data, not crashes — hand them back so the model can recover.
+    return `error: ${e.message}${e.stdout ? `\n${e.stdout}` : ''}${e.stderr ? `\n${e.stderr}` : ''}`;
+  }
+}