accelr8 1.0.0 → 3.0.0

package/dist/chunks/chunk-3JNUWI22.js

@@ -0,0 +1,563 @@
+#!/usr/bin/env node
+
+// src/accounts.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var HANDLE_RE = /^[a-z0-9][a-z0-9-]{2,19}$/;
+var DEFAULT_MODEL = {
+  anthropic: "claude-opus-4-8",
+  openai: "gpt-4o"
+};
+var DEFAULT_MAX_CALLS_PER_HOUR = 30;
+var DEFAULT_MAX_CALLS_PER_REQUESTER_HOUR = 10;
+var DEFAULT_MAX_OUTPUT_TOKENS = 1024;
+var ACCOUNTS_FILE = "accounts.json";
+var TOKENS_FILE = "agent-tokens.json";
+function dirOf(baseDir) {
+  return baseDir ?? path.join(os.homedir(), ".accelr8");
+}
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+}
+function readJson(file) {
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    if ((fs.statSync(file).mode & 63) !== 0) {
+      try {
+        fs.chmodSync(file, 384);
+      } catch {
+      }
+      if ((fs.statSync(file).mode & 63) !== 0) {
+        process.stderr.write(`accelr8: refusing to load ${file}: it is readable by others and could not be locked to 600. run: chmod 600 ${file}
+`);
+        return void 0;
+      }
+    }
+  } catch {
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function writeJson(file, value) {
+  ensureDir(path.dirname(file));
+  const tmp = `${file}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
+  fs.chmodSync(tmp, 384);
+  fs.renameSync(tmp, file);
+  fs.chmodSync(file, 384);
+}
+function isAccount(v) {
+  if (!v || typeof v !== "object") return false;
+  const a = v;
+  const auth = a.auth;
+  return typeof a.id === "string" && (a.provider === "anthropic" || a.provider === "openai") && !!auth && typeof auth === "object" && (auth.kind === "api_key" ? typeof auth.apiKey === "string" : auth.kind === "claude_code_login") && typeof a.model === "string" && typeof a.handle === "string" && typeof a.maxCallsPerHour === "number" && typeof a.maxCallsPerRequesterHour === "number" && typeof a.maxOutputTokens === "number" && typeof a.createdAt === "number";
+}
+function loadAccounts(baseDir) {
+  const data = readJson(path.join(dirOf(baseDir), ACCOUNTS_FILE));
+  if (!Array.isArray(data)) return [];
+  return data.filter(isAccount).map((a) => ({ ...a, mode: a.mode ?? "approve" }));
+}
+function saveAccounts(list, baseDir) {
+  writeJson(path.join(dirOf(baseDir), ACCOUNTS_FILE), list);
+}
+function addAccount(partial, baseDir) {
+  if (!HANDLE_RE.test(partial.handle)) {
+    throw new Error(`invalid handle '${partial.handle}' (want 3-20 chars of a-z 0-9 -, starting alphanumeric)`);
+  }
+  if (partial.auth.kind === "api_key" && !partial.auth.apiKey) {
+    throw new Error("apiKey must not be empty");
+  }
+  const account = {
+    id: "acct_" + Math.random().toString(36).slice(2, 10) + Math.random().toString(36).slice(2, 6),
+    provider: partial.provider,
+    auth: partial.auth,
+    model: partial.model || DEFAULT_MODEL[partial.provider],
+    handle: partial.handle,
+    mode: partial.mode ?? "approve",
+    maxCallsPerHour: partial.maxCallsPerHour ?? DEFAULT_MAX_CALLS_PER_HOUR,
+    maxCallsPerRequesterHour: partial.maxCallsPerRequesterHour ?? DEFAULT_MAX_CALLS_PER_REQUESTER_HOUR,
+    maxOutputTokens: partial.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
+    createdAt: Date.now()
+  };
+  const list = loadAccounts(baseDir);
+  list.push(account);
+  saveAccounts(list, baseDir);
+  return account;
+}
+function removeAccount(id, baseDir) {
+  const list = loadAccounts(baseDir);
+  const next = list.filter((a) => a.id !== id);
+  if (next.length === list.length) return false;
+  saveAccounts(next, baseDir);
+  return true;
+}
+var tokenKey = (projectId, agentId) => `${projectId}:${agentId}`;
+function loadTokens(baseDir) {
+  const data = readJson(path.join(dirOf(baseDir), TOKENS_FILE));
+  if (!data || typeof data !== "object" || Array.isArray(data)) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(data)) if (typeof v === "string") out[k] = v;
+  return out;
+}
+function saveToken(projectId, agentId, token, baseDir) {
+  const tokens = loadTokens(baseDir);
+  tokens[tokenKey(projectId, agentId)] = token;
+  writeJson(path.join(dirOf(baseDir), TOKENS_FILE), tokens);
+}
+function detectClaudeCode() {
+  const dirs = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    const candidate = path.join(dir, "claude");
+    try {
+      if (!fs.existsSync(candidate)) continue;
+      fs.accessSync(candidate, fs.constants.X_OK);
+      if (fs.statSync(candidate).isFile()) return { available: true, path: candidate };
+    } catch {
+    }
+  }
+  return { available: false };
+}
+function detectEnvKeys() {
+  const out = {};
+  const a = process.env.ANTHROPIC_API_KEY?.trim();
+  const o = process.env.OPENAI_API_KEY?.trim();
+  if (a) out.anthropic = a;
+  if (o) out.openai = o;
+  return out;
+}
+function defaultHandle(userName, provider) {
+  const suffix = "s" + (provider === "anthropic" ? "claude" : "gpt");
+  let name = userName.toLowerCase().replace(/[^a-z0-9-]/g, "").replace(/^-+/, "");
+  if (!name) name = "my";
+  return name.slice(0, 20 - suffix.length) + suffix;
+}
+
+// src/executor.ts
+import { spawn } from "node:child_process";
+var ANTHROPIC_VERSION = "2023-06-01";
+var ANTHROPIC_BASE = "https://api.anthropic.com";
+var OPENAI_BASE = "https://api.openai.com";
+var DELTA_MS = 100;
+var DELTA_CHARS = 800;
+var RETRY_CAP_MS = 1e4;
+var STDERR_TAIL = 500;
+var Run = class {
+  constructor(cb, secret) {
+    this.cb = cb;
+    this.secret = secret;
+  }
+  cb;
+  secret;
+  ac = new AbortController();
+  aborted = false;
+  settled = false;
+  buf = "";
+  timer = null;
+  lastFlush = Date.now();
+  get isSettled() {
+    return this.settled;
+  }
+  push(text) {
+    if (this.settled || !text) return;
+    this.buf += text;
+    if (this.buf.length >= DELTA_CHARS) {
+      this.flush();
+      return;
+    }
+    if (!this.timer) {
+      const wait = Math.max(0, this.lastFlush + DELTA_MS - Date.now());
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        this.flush();
+      }, wait);
+    }
+  }
+  done(finish) {
+    if (this.settled) return;
+    if (finish !== "aborted") this.flush();
+    this.settle();
+    this.cb.onDone(finish);
+  }
+  error(code, message) {
+    if (this.settled) return;
+    this.flush();
+    this.settle();
+    this.cb.onError(code, this.scrub(message));
+  }
+  abort() {
+    if (this.settled) return;
+    this.aborted = true;
+    this.ac.abort();
+    this.done("aborted");
+  }
+  /** Key must never surface, even echoed back by a provider error body. */
+  scrub(message) {
+    return this.secret ? message.split(this.secret).join("***") : message;
+  }
+  flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.settled || !this.buf) return;
+    const text = this.buf;
+    this.buf = "";
+    this.lastFlush = Date.now();
+    this.cb.onDelta(text);
+  }
+  settle() {
+    this.settled = true;
+    this.buf = "";
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+function execute(account, ctx, cb, opts) {
+  if (account.auth.kind === "claude_code_login") return executeClaudeCli(ctx, cb);
+  const run = new Run(cb, account.auth.apiKey);
+  if (account.provider === "anthropic") void streamAnthropic(account, account.auth.apiKey, ctx, run, opts);
+  else void streamOpenai(account, account.auth.apiKey, ctx, run, opts);
+  return { abort: () => run.abort() };
+}
+async function verifyAccount(account, opts) {
+  if (account.auth.kind === "claude_code_login") {
+    const det = detectClaudeCode();
+    return det.available ? { ok: true, message: `claude CLI found at ${det.path ?? "PATH"}` } : { ok: false, message: "claude CLI not found on PATH" };
+  }
+  const apiKey = account.auth.apiKey;
+  const anthropic = account.provider === "anthropic";
+  const url = anthropic ? (opts?.anthropicBase ?? ANTHROPIC_BASE) + "/v1/messages" : (opts?.openaiBase ?? OPENAI_BASE) + "/v1/chat/completions";
+  const headers = anthropic ? { "content-type": "application/json", "x-api-key": apiKey, "anthropic-version": ANTHROPIC_VERSION } : { "content-type": "application/json", authorization: `Bearer ${apiKey}` };
+  const scrub = (m) => apiKey ? m.split(apiKey).join("***") : m;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ model: account.model, max_tokens: 1, messages: [{ role: "user", content: "ping" }] })
+    });
+    if (res.ok) {
+      void res.body?.cancel().catch(() => {
+      });
+      return { ok: true, message: `${account.provider} key ok (${account.model})` };
+    }
+    const msg = await providerMessage(res);
+    const label = res.status === 401 || res.status === 403 ? "invalid key" : res.status === 429 ? "rate limited" : `status ${res.status}`;
+    return { ok: false, message: scrub(`${label}${msg ? ": " + msg : ""}`) };
+  } catch (e) {
+    return { ok: false, message: scrub("network error: " + errMsg(e)) };
+  }
+}
+async function streamAnthropic(account, apiKey, ctx, run, opts) {
+  const res = await fetchWithRetry((opts?.anthropicBase ?? ANTHROPIC_BASE) + "/v1/messages", {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-api-key": apiKey, "anthropic-version": ANTHROPIC_VERSION },
+    body: JSON.stringify({
+      model: account.model,
+      system: ctx.system,
+      messages: ctx.messages,
+      max_tokens: ctx.maxOutputTokens,
+      stream: true
+    }),
+    signal: run.ac.signal
+  }, run);
+  if (!res) return;
+  if (!res.ok) {
+    await httpError(res, run);
+    return;
+  }
+  if (!res.body) {
+    run.error("internal", "provider sent no response body");
+    return;
+  }
+  let finish = "end";
+  try {
+    await readSse(res.body, (data) => {
+      let ev;
+      try {
+        ev = JSON.parse(data);
+      } catch {
+        return;
+      }
+      if (ev?.type === "content_block_delta" && ev.delta?.type === "text_delta" && typeof ev.delta.text === "string") {
+        run.push(ev.delta.text);
+      } else if (ev?.type === "message_delta" && ev.delta?.stop_reason === "max_tokens") {
+        finish = "length";
+      } else if (ev?.type === "message_stop") {
+        run.done(finish);
+      } else if (ev?.type === "error") {
+        run.error(mapAnthropicSseError(ev.error?.type), String(ev.error?.message ?? "provider stream error"));
+      }
+    });
+    run.done(finish);
+  } catch (e) {
+    if (!run.aborted) run.error("network", errMsg(e));
+  }
+}
+function mapAnthropicSseError(type) {
+  switch (type) {
+    case "overloaded_error":
+      return "overloaded";
+    case "rate_limit_error":
+      return "rate";
+    case "authentication_error":
+    case "permission_error":
+      return "auth";
+    case "invalid_request_error":
+      return "badRequest";
+    default:
+      return "internal";
+  }
+}
+async function streamOpenai(account, apiKey, ctx, run, opts) {
+  const res = await fetchWithRetry((opts?.openaiBase ?? OPENAI_BASE) + "/v1/chat/completions", {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: account.model,
+      messages: [{ role: "system", content: ctx.system }, ...ctx.messages],
+      max_tokens: ctx.maxOutputTokens,
+      stream: true
+    }),
+    signal: run.ac.signal
+  }, run);
+  if (!res) return;
+  if (!res.ok) {
+    await httpError(res, run);
+    return;
+  }
+  if (!res.body) {
+    run.error("internal", "provider sent no response body");
+    return;
+  }
+  let finish = "end";
+  try {
+    await readSse(res.body, (data) => {
+      if (data === "[DONE]") {
+        run.done(finish);
+        return;
+      }
+      let ev;
+      try {
+        ev = JSON.parse(data);
+      } catch {
+        return;
+      }
+      const choice = ev?.choices?.[0];
+      if (typeof choice?.delta?.content === "string") run.push(choice.delta.content);
+      if (choice?.finish_reason === "length") finish = "length";
+    });
+    run.done(finish);
+  } catch (e) {
+    if (!run.aborted) run.error("network", errMsg(e));
+  }
+}
+function executeClaudeCli(ctx, cb) {
+  const run = new Run(cb);
+  const transcript = ctx.messages.map((m) => m.role === "assistant" ? "[you]: " + m.content : m.content).join("\n");
+  const prompt = ctx.system + "\n\n" + transcript;
+  let child;
+  try {
+    const CHAT_ONLY_DISALLOW = "Bash Edit Write Read Glob Grep WebFetch WebSearch NotebookEdit Task MultiEdit";
+    const env = { ...process.env };
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_AUTH_TOKEN;
+    child = spawn("claude", ["-p", "--output-format", "stream-json", "--verbose", "--max-turns", "1", "--permission-mode", "plan", "--disallowedTools", CHAT_ONLY_DISALLOW], {
+      // prompt goes on stdin, never argv — argv is world-readable via `ps`, and
+      // the prompt carries the whole room transcript.
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    child.stdin?.on("error", () => {
+    });
+    child.stdin?.end(prompt);
+  } catch (e) {
+    queueMicrotask(() => run.error("internal", errMsg(e)));
+    return { abort: () => run.abort() };
+  }
+  let produced = false;
+  let stdoutBuf = "";
+  let stderrTail = "";
+  const handleLine = (line) => {
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (ev?.type === "assistant") {
+      const content = ev.message?.content;
+      if (typeof content === "string" && content) {
+        produced = true;
+        run.push(content);
+      } else if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block?.type === "text" && typeof block.text === "string" && block.text) {
+            produced = true;
+            run.push(block.text);
+          }
+        }
+      }
+    } else if (ev?.type === "result" && typeof ev.result === "string" && ev.result && !produced) {
+      produced = true;
+      run.push(ev.result);
+    }
+  };
+  child.stdout?.setEncoding("utf8");
+  child.stdout?.on("data", (chunk) => {
+    stdoutBuf += chunk;
+    let nl;
+    while ((nl = stdoutBuf.indexOf("\n")) >= 0) {
+      const line = stdoutBuf.slice(0, nl).trim();
+      stdoutBuf = stdoutBuf.slice(nl + 1);
+      if (line) handleLine(line);
+    }
+  });
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL);
+  });
+  child.on("error", (e) => {
+    if (e.code === "ENOENT") run.error("badRequest", "claude CLI not found");
+    else run.error("internal", errMsg(e));
+  });
+  child.on("close", (code) => {
+    if (run.aborted) return;
+    const rest = stdoutBuf.trim();
+    if (rest) handleLine(rest);
+    if (code !== 0 && !produced) run.error("internal", stderrTail.trim() || `claude exited with code ${code}`);
+    else run.done("end");
+  });
+  return {
+    abort: () => {
+      run.abort();
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  };
+}
+async function fetchWithRetry(url, init, run) {
+  for (let attempt = 0; ; attempt++) {
+    let res;
+    try {
+      res = await fetch(url, init);
+    } catch (e) {
+      if (!run.aborted && !run.isSettled) run.error("network", errMsg(e));
+      return null;
+    }
+    if (res.status !== 429) return res;
+    if (attempt >= 1) {
+      const msg = await providerMessage(res);
+      run.error("rate", msg || "rate limited (429)");
+      return null;
+    }
+    void res.body?.cancel().catch(() => {
+    });
+    await sleep(Math.min(retryAfterMs(res.headers.get("retry-after")), RETRY_CAP_MS), run.ac.signal);
+    if (run.aborted || run.isSettled) return null;
+  }
+}
+async function httpError(res, run) {
+  const msg = await providerMessage(res);
+  const st = res.status;
+  if (st === 401 || st === 403) run.error("auth", msg || `authentication failed (${st})`);
+  else if (st === 400) run.error("badRequest", msg || "bad request (400)");
+  else if (st >= 500) run.error("overloaded", msg || `provider overloaded (${st})`);
+  else run.error("badRequest", msg || `unexpected status ${st}`);
+}
+async function providerMessage(res) {
+  try {
+    const text = await res.text();
+    try {
+      const json = JSON.parse(text);
+      const m = json?.error?.message ?? json?.message;
+      if (typeof m === "string" && m) return m;
+    } catch {
+    }
+    return text.slice(0, 300);
+  } catch {
+    return "";
+  }
+}
+async function readSse(body, onData) {
+  const reader = body.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  const drainLines = () => {
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).replace(/\r$/, "");
+      buf = buf.slice(nl + 1);
+      if (line.startsWith("data:")) onData(line.slice(5).trim());
+    }
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) buf += dec.decode(value, { stream: true });
+    drainLines();
+  }
+  buf += dec.decode();
+  drainLines();
+  const last = buf.trim();
+  if (last.startsWith("data:")) onData(last.slice(5).trim());
+}
+function retryAfterMs(header) {
+  if (!header) return 1e3;
+  const secs = Number(header);
+  if (Number.isFinite(secs)) return Math.max(0, secs * 1e3);
+  const date = Date.parse(header);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return 1e3;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted || ms <= 0) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(t);
+      resolve();
+    };
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+export {
+  DEFAULT_MODEL,
+  loadAccounts,
+  saveAccounts,
+  addAccount,
+  removeAccount,
+  loadTokens,
+  saveToken,
+  detectClaudeCode,
+  detectEnvKeys,
+  defaultHandle,
+  execute,
+  verifyAccount
+};

package/dist/chunks/chunk-SF6NNSYZ.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+// src/protocol.ts
+var VERSION = "3.0.0";
+var PROTO = 3;
+var PORT = 8787;
+var DEFAULT_SERVER = "wss://accelr8-canvas.patonchain.workers.dev";
+var CANVAS_W = 100;
+var CANVAS_H = 30;
+var LIMITS = {
+  chatMaxCp: 4e3,
+  // code points per chat message
+  chatMaxJson: 8192,
+  // serialized bytes per chat message
+  chatPerWindow: 10,
+  // messages per 10s per session
+  chatTail: 50,
+  // messages delivered in `joined`
+  chatPage: 50,
+  // default history page (max 100)
+  chatSyncMaxGap: 200,
+  // bigger gap -> full resync
+  chatRetain: 2e3,
+  // messages kept per project
+  draftMinIntervalMs: 100,
+  // server drops faster arrivals
+  draftMaxCp: 4e3,
+  framesPerWindow: 200,
+  // frames per 10s per session -> disconnect
+  invokesPerProjectMin: 20,
+  triggersPerUserMin: 6,
+  joinGuessesPerMin: 5,
+  revealsPerMin: 10,
+  secretsPerProject: 50,
+  secretValueMax: 8192,
+  agentQueueCap: 5,
+  agentMaxDepth: 3,
+  agentBudgetPerTrigger: 5,
+  agentRepeatPerChain: 2
+};
+var DEFAULT_ACCESS = { mode: "owner", users: [] };
+function encode(msg) {
+  return JSON.stringify(msg);
+}
+function decode(data) {
+  return JSON.parse(data);
+}
+
+export {
+  VERSION,
+  PROTO,
+  PORT,
+  DEFAULT_SERVER,
+  CANVAS_W,
+  CANVAS_H,
+  LIMITS,
+  DEFAULT_ACCESS,
+  encode,
+  decode
+};