@hizliemre/horse-code 0.2.0 → 0.3.0

package/dist/chunk-G45RWL7S.js

@@ -0,0 +1,289 @@
+// src/agents/cli-auth.ts
+import { spawnSync } from "child_process";
+
+// src/agents/cli-agent.ts
+import { spawn } from "child_process";
+var CLI_KINDS = ["claude", "codex", "grok", "zai"];
+function cliBinary(kind) {
+  return kind === "zai" ? "claude" : kind;
+}
+var CLI_ERROR_UNSPOKEN = "the CLI reported an error";
+function cliArgs(kind, prompt, extra = []) {
+  if (kind === "claude" || kind === "zai") {
+    return ["--output-format", "stream-json", "--verbose", ...extra, "-p", "--", prompt];
+  }
+  if (kind === "codex") {
+    return ["exec", "--json", "--skip-git-repo-check", ...extra, "--", prompt];
+  }
+  return ["--output-format", "streaming-messages-json", ...extra, `--single=${prompt}`];
+}
+function decodeClaudeEvent(line) {
+  let e;
+  try {
+    e = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  const type = e.type;
+  if (type === "rate_limit_event") {
+    const info = e.rate_limit_info ?? {};
+    const status = String(info.status ?? "unknown");
+    const raw = info.unifiedWindows ?? {};
+    const windows = {};
+    for (const [name, w] of Object.entries(raw)) windows[name] = w?.utilization ?? 0;
+    const quota = {
+      status,
+      windows,
+      ...typeof info.resetsAt === "number" ? { resetsAt: info.resetsAt } : {}
+    };
+    return status.startsWith("allowed") ? { quota } : {
+      quota,
+      /**
+       * The reset time rides along, as an ISO instant rather than prose.
+       *
+       * A spent five-hour window reopens; without saying when, the only safe bench is "the rest of the
+       * run", which on a ten-hour board writes off a subscription for hours after it recovered. The
+       * gateway's wordings said "reset after 4h" and nothing ever parsed them — see `quotaResetAt`.
+       */
+      rateLimited: `${status} \u2014 ${describeWindows(windows)}` + (quota.resetsAt ? ` (resets ${new Date(quota.resetsAt * 1e3).toISOString()})` : "")
+    };
+  }
+  if (type === "assistant") {
+    const msg = e.message;
+    const parts = Array.isArray(msg?.content) ? msg.content : [];
+    const text = parts.filter((b) => typeof b === "object" && b !== null && b.type === "text").map((b) => b.text).join("");
+    const tool = parts.find((b) => typeof b === "object" && b !== null && b.type === "tool_use");
+    return {
+      ...text ? { text } : {},
+      ...msg?.model ? { served: msg.model } : {},
+      ...tool ? { tool: { name: tool.name, ...targetOf(tool.input) ? { target: targetOf(tool.input) } : {} } } : {}
+    };
+  }
+  if (type === "user") {
+    const parts = e.message?.content;
+    const failed = (Array.isArray(parts) ? parts : []).find(
+      (b) => typeof b === "object" && b !== null && b.type === "tool_result" && b.is_error === true
+    );
+    return failed ? { tool: { name: "tool", ok: false } } : void 0;
+  }
+  if (type === "result") {
+    const u = e.usage ?? {};
+    const cost = e.total_cost_usd;
+    return {
+      usage: {
+        freshTokens: u.input_tokens ?? 0,
+        cachedTokens: u.cache_read_input_tokens ?? 0,
+        cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0,
+        ...cost !== void 0 ? { costUsd: cost } : {}
+      },
+      ...e.subtype === "error_during_execution" ? { error: String(e.result ?? CLI_ERROR_UNSPOKEN) } : {}
+    };
+  }
+  return void 0;
+}
+function decodeCodexEvent(line) {
+  let e;
+  try {
+    e = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  const type = String(e.type ?? "");
+  if (/rate.?limit/i.test(type)) return { rateLimited: String(e.message ?? "rate limited by the CLI") };
+  if (type === "item.completed") {
+    const item = e.item;
+    if (item?.type === "agent_message" && item.text) return { text: item.text };
+    if (item?.type && item.type !== "agent_message") {
+      const changes = item.changes;
+      const first = Array.isArray(changes) ? changes.find((c) => typeof c?.path === "string")?.path : void 0;
+      const more = Array.isArray(changes) && changes.length > 1 ? ` +${changes.length - 1}` : "";
+      return {
+        tool: {
+          name: item.name ?? item.type,
+          ...first ? { target: `${first}${more}` } : {}
+        }
+      };
+    }
+    return void 0;
+  }
+  if (type === "turn.completed") {
+    const u = e.usage ?? {};
+    return {
+      usage: {
+        freshTokens: u.input_tokens ?? 0,
+        cachedTokens: u.cached_input_tokens ?? 0,
+        cacheWriteTokens: u.cache_write_input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0
+      }
+    };
+  }
+  if (type === "turn.failed" || type === "error") {
+    return { error: String(e.message ?? "codex reported an error") };
+  }
+  return void 0;
+}
+function describeWindows(windows) {
+  const parts = Object.entries(windows).map(([k, v]) => `${k} ${Math.round(v * 100)}%`);
+  return parts.length ? parts.join(", ") : "no window reported";
+}
+var SYNTHETIC = "<synthetic>";
+function targetOf(input) {
+  for (const k of ["file_path", "path", "filePath", "notebook_path"]) {
+    const v = input?.[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return void 0;
+}
+function makeStreamReader(decode, onEvent) {
+  let pending = "";
+  const drain = (upToNewline) => {
+    const lines = pending.split("\n");
+    pending = upToNewline ? lines.pop() ?? "" : "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const ev = decode(line);
+      if (ev) onEvent(ev);
+    }
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      drain(true);
+    },
+    end() {
+      if (pending.trim()) drain(false);
+    }
+  };
+}
+function reportedError(decoded, stderr, exitCode) {
+  if (decoded && decoded !== CLI_ERROR_UNSPOKEN) return decoded;
+  const spoken = exitCode !== 0 ? stderr.trim().slice(0, 500) : "";
+  return spoken || decoded || void 0;
+}
+async function runCliAgent(run) {
+  const decode = run.kind === "codex" ? decodeCodexEvent : decodeClaudeEvent;
+  const args = cliArgs(run.kind, run.prompt, run.args ?? []);
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cliBinary(run.kind), args, {
+        cwd: run.cwd,
+        signal: run.signal,
+        stdio: ["ignore", "pipe", "pipe"],
+        ...run.configDir ? { env: { ...process.env, ...profileEnv(run.kind, run.configDir) } } : {}
+      });
+    } catch (e) {
+      resolve({ text: "", error: e instanceof Error ? e.message : String(e), exitCode: -1 });
+      return;
+    }
+    let text = "";
+    let usage;
+    let rateLimited;
+    let served;
+    let quota;
+    let error;
+    let stderr = "";
+    const reader = makeStreamReader(decode, (ev) => {
+      if (ev.text) text += ev.text;
+      if (ev.usage) usage = ev.usage;
+      if (ev.rateLimited) rateLimited = ev.rateLimited;
+      if (ev.served) served = ev.served;
+      if (ev.quota) quota = ev.quota;
+      if (ev.error) error = ev.error;
+      run.onEvent?.(ev);
+    });
+    child.stdout?.on("data", (d) => reader.push(d.toString()));
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (e) => resolve({ text, ...usage ? { usage } : {}, error: e.message, exitCode: -1 }));
+    child.on("close", (code) => {
+      reader.end();
+      const reported = reportedError(error, stderr, code ?? -1);
+      resolve({
+        text,
+        ...usage ? { usage } : {},
+        ...rateLimited ? { rateLimited } : {},
+        ...quota ? { quota } : {},
+        ...served ? { served } : {},
+        ...reported ? { error: reported } : {},
+        exitCode: code ?? -1
+      });
+    });
+  });
+}
+
+// src/agents/cli-auth.ts
+function profileEnv(kind, configDir) {
+  if (!configDir) return {};
+  if (kind === "claude" || kind === "zai") return { CLAUDE_CONFIG_DIR: configDir };
+  if (kind === "codex") return { CODEX_HOME: configDir };
+  return { GROK_HOME: configDir };
+}
+function readAuthStatus(kind, out) {
+  if (kind === "grok") {
+    const m = /you are logged in with\s+(.+)/i.exec(out);
+    if (!m) return { loggedIn: false };
+    const plan = m[1].trim().replace(/\.$/, "");
+    return { loggedIn: true, ...plan ? { plan } : {} };
+  }
+  if (kind === "codex") {
+    const m = /logged in(?: using (.+))?/i.exec(out);
+    if (!m || /not logged in/i.test(out)) return { loggedIn: false };
+    const plan = m[1]?.trim();
+    return { loggedIn: true, ...plan ? { plan } : {} };
+  }
+  try {
+    const j = JSON.parse(out);
+    if (!j.loggedIn) return { loggedIn: false };
+    return {
+      loggedIn: true,
+      ...j.email ? { email: j.email } : {},
+      ...j.subscriptionType ? { plan: j.subscriptionType } : {}
+    };
+  } catch {
+    return { loggedIn: false };
+  }
+}
+function statusArgs(kind) {
+  if (kind === "claude" || kind === "zai") return ["auth", "status"];
+  if (kind === "codex") return ["login", "status"];
+  return ["models"];
+}
+function loginArgs(kind) {
+  return kind === "claude" ? ["auth", "login"] : ["login"];
+}
+function checkProfile(kind, configDir) {
+  if (kind === "zai" && !configDir) return { loggedIn: false };
+  const r = spawnSync(cliBinary(kind), statusArgs(kind), {
+    env: { ...process.env, ...profileEnv(kind, configDir) },
+    encoding: "utf8",
+    // A status check that hangs must not hang the startup summary with it.
+    timeout: 2e4
+  });
+  if (r.error) return { loggedIn: false };
+  return readAuthStatus(kind, `${r.stdout ?? ""}${r.stderr ?? ""}`);
+}
+function runLogin(kind, configDir) {
+  if (kind === "zai") {
+    return { ok: false, error: "z.ai has no sign-in \u2014 a profile is connected by writing its settings file" };
+  }
+  const r = spawnSync(cliBinary(kind), loginArgs(kind), {
+    env: { ...process.env, ...profileEnv(kind, configDir) },
+    stdio: "inherit"
+  });
+  if (r.error) {
+    const e = r.error;
+    return e.code === "ENOENT" ? { ok: false, error: `\`${kind}\` is not installed, or not on PATH` } : { ok: false, error: e.message };
+  }
+  return { ok: r.status === 0 };
+}
+
+export {
+  checkProfile,
+  runLogin,
+  CLI_KINDS,
+  SYNTHETIC,
+  runCliAgent
+};