kimiflare 0.1.0

package/dist/index.js

@@ -0,0 +1,2511 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+import { readFile, mkdir, writeFile, chmod } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+function configPath() {
+  const xdg = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(xdg, "kimiflare", "config.json");
+}
+async function loadConfig() {
+  const envAccount = process.env.CLOUDFLARE_ACCOUNT_ID ?? process.env.CF_ACCOUNT_ID;
+  const envToken = process.env.CLOUDFLARE_API_TOKEN ?? process.env.CF_API_TOKEN;
+  const envModel = process.env.KIMI_MODEL ?? DEFAULT_MODEL;
+  if (envAccount && envToken) {
+    return { accountId: envAccount, apiToken: envToken, model: envModel };
+  }
+  try {
+    const raw = await readFile(configPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.accountId && parsed.apiToken) {
+      return {
+        accountId: envAccount ?? parsed.accountId,
+        apiToken: envToken ?? parsed.apiToken,
+        model: envModel ?? parsed.model ?? DEFAULT_MODEL
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function saveConfig(cfg) {
+  const p = configPath();
+  await mkdir(join(p, ".."), { recursive: true });
+  await writeFile(p, JSON.stringify(cfg, null, 2), "utf8");
+  await chmod(p, 384);
+  return p;
+}
+var DEFAULT_MODEL;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    DEFAULT_MODEL = "@cf/moonshotai/kimi-k2.6";
+  }
+});
+
+// src/util/sse.ts
+async function* readSSE(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) throw new DOMException("aborted", "AbortError");
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      buffer = buffer.replace(/\r\n/g, "\n");
+      let sep;
+      while ((sep = buffer.indexOf("\n\n")) !== -1) {
+        const event = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        const data = extractData(event);
+        if (data !== null) yield data;
+      }
+    }
+    buffer += decoder.decode();
+    const tail = extractData(buffer.trim());
+    if (tail !== null) yield tail;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function extractData(event) {
+  if (!event) return null;
+  const parts = [];
+  for (const raw of event.split("\n")) {
+    if (!raw.startsWith("data:")) continue;
+    parts.push(raw.slice(5).replace(/^ /, ""));
+  }
+  return parts.length ? parts.join("\n") : null;
+}
+var init_sse = __esm({
+  "src/util/sse.ts"() {
+    "use strict";
+  }
+});
+
+// src/util/errors.ts
+var KimiApiError;
+var init_errors = __esm({
+  "src/util/errors.ts"() {
+    "use strict";
+    KimiApiError = class extends Error {
+      constructor(message, code, httpStatus) {
+        super(message);
+        this.code = code;
+        this.httpStatus = httpStatus;
+        this.name = "KimiApiError";
+      }
+      code;
+      httpStatus;
+    };
+  }
+});
+
+// src/agent/client.ts
+async function* runKimi(opts2) {
+  const url = `https://api.cloudflare.com/client/v4/accounts/${opts2.accountId}/ai/run/${opts2.model}`;
+  const body = {
+    messages: opts2.messages,
+    ...opts2.tools && opts2.tools.length ? { tools: opts2.tools, tool_choice: "auto", parallel_tool_calls: true } : {},
+    stream: true,
+    temperature: opts2.temperature ?? 0.2,
+    max_completion_tokens: opts2.maxCompletionTokens ?? 16384
+  };
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${opts2.apiToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: opts2.signal
+    });
+    const contentType = res.headers.get("content-type") ?? "";
+    if (!contentType.includes("text/event-stream")) {
+      const text = await res.text();
+      let parsed = null;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+      }
+      const err = extractCloudflareError(parsed);
+      if (err?.code === RETRYABLE_CODE && attempt < MAX_ATTEMPTS - 1) {
+        const delay = 500 * 2 ** attempt + Math.random() * 250;
+        await sleep(delay, opts2.signal);
+        continue;
+      }
+      const msg = err?.message ?? `HTTP ${res.status}: ${text.slice(0, 300)}`;
+      throw new KimiApiError(`kimiflare: ${msg}`, err?.code, res.status);
+    }
+    if (!res.body) throw new KimiApiError("kimiflare: empty response body", void 0, res.status);
+    yield* parseStream(res.body, opts2.signal);
+    return;
+  }
+}
+async function* parseStream(body, signal) {
+  const toolCalls = /* @__PURE__ */ new Map();
+  let lastUsage = null;
+  let finishReason = null;
+  for await (const dataStr of readSSE(body, signal)) {
+    if (dataStr === "[DONE]") break;
+    let chunk = null;
+    try {
+      chunk = JSON.parse(dataStr);
+    } catch {
+      continue;
+    }
+    if (!chunk) continue;
+    if (chunk.usage) {
+      lastUsage = chunk.usage;
+      yield { type: "usage", usage: chunk.usage };
+    }
+    const choice = chunk.choices?.[0];
+    if (!choice) continue;
+    const d = choice.delta;
+    if (d) {
+      if (typeof d.reasoning_content === "string" && d.reasoning_content.length) {
+        yield { type: "reasoning", delta: d.reasoning_content };
+      }
+      if (typeof d.content === "string" && d.content.length) {
+        yield { type: "text", delta: d.content };
+      }
+      if (Array.isArray(d.tool_calls)) {
+        for (const tc of d.tool_calls) {
+          const idx = typeof tc.index === "number" ? tc.index : 0;
+          let buf = toolCalls.get(idx);
+          const incomingName = tc.function?.name ?? null;
+          const incomingId = tc.id ?? null;
+          if (!buf) {
+            buf = { id: incomingId ?? `tc_${idx}`, name: incomingName ?? "", args: "" };
+            toolCalls.set(idx, buf);
+            if (buf.name) {
+              yield { type: "tool_call_start", index: idx, id: buf.id, name: buf.name };
+            }
+          } else {
+            if (!buf.name && incomingName) {
+              buf.name = incomingName;
+              yield { type: "tool_call_start", index: idx, id: buf.id, name: buf.name };
+            }
+            if (buf.id.startsWith("tc_") && incomingId) buf.id = incomingId;
+          }
+          const argDelta = tc.function?.arguments;
+          if (typeof argDelta === "string" && argDelta.length) {
+            buf.args += argDelta;
+            yield { type: "tool_call_args", index: idx, argsDelta: argDelta };
+          }
+        }
+      }
+    }
+    if (choice.finish_reason) finishReason = choice.finish_reason;
+  }
+  for (const [idx, buf] of [...toolCalls.entries()].sort((a, b) => a[0] - b[0])) {
+    if (!buf.name) continue;
+    yield {
+      type: "tool_call_complete",
+      index: idx,
+      id: buf.id,
+      name: buf.name,
+      arguments: buf.args
+    };
+  }
+  yield { type: "done", finishReason, usage: lastUsage };
+}
+function extractCloudflareError(parsed) {
+  if (!parsed || typeof parsed !== "object") return null;
+  const p = parsed;
+  if (p.success === false && Array.isArray(p.errors) && p.errors.length > 0) {
+    return { code: p.errors[0]?.code, message: p.errors[0]?.message };
+  }
+  return null;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) return reject(new DOMException("aborted", "AbortError"));
+    const t = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      reject(new DOMException("aborted", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var RETRYABLE_CODE, MAX_ATTEMPTS;
+var init_client = __esm({
+  "src/agent/client.ts"() {
+    "use strict";
+    init_sse();
+    init_errors();
+    RETRYABLE_CODE = 3040;
+    MAX_ATTEMPTS = 5;
+  }
+});
+
+// src/tools/registry.ts
+function toOpenAIToolDefs(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+var init_registry = __esm({
+  "src/tools/registry.ts"() {
+    "use strict";
+  }
+});
+
+// src/agent/loop.ts
+async function runAgentTurn(opts2) {
+  const max = opts2.maxToolIterations ?? 50;
+  const toolDefs = toOpenAIToolDefs(opts2.tools);
+  for (let iter = 0; iter < max; iter++) {
+    const toolCalls = [];
+    let content = "";
+    let reasoning = "";
+    opts2.callbacks.onAssistantStart?.();
+    const events = runKimi({
+      accountId: opts2.accountId,
+      apiToken: opts2.apiToken,
+      model: opts2.model,
+      messages: opts2.messages,
+      tools: toolDefs,
+      signal: opts2.signal,
+      temperature: opts2.temperature,
+      maxCompletionTokens: opts2.maxCompletionTokens
+    });
+    for await (const ev of events) {
+      switch (ev.type) {
+        case "reasoning":
+          reasoning += ev.delta;
+          opts2.callbacks.onReasoningDelta?.(ev.delta);
+          break;
+        case "text":
+          content += ev.delta;
+          opts2.callbacks.onTextDelta?.(ev.delta);
+          break;
+        case "tool_call_start":
+          opts2.callbacks.onToolCallStart?.(ev.index, ev.id, ev.name);
+          break;
+        case "tool_call_args":
+          opts2.callbacks.onToolCallArgs?.(ev.index, ev.argsDelta);
+          break;
+        case "tool_call_complete": {
+          const call = {
+            id: ev.id,
+            type: "function",
+            function: { name: ev.name, arguments: ev.arguments }
+          };
+          toolCalls.push(call);
+          opts2.callbacks.onToolCallFinalized?.(call);
+          break;
+        }
+        case "usage":
+          opts2.callbacks.onUsage?.(ev.usage);
+          break;
+        case "done":
+          break;
+      }
+    }
+    const assistantMsg = {
+      role: "assistant",
+      content: content || null,
+      ...reasoning ? { reasoning_content: reasoning } : {},
+      ...toolCalls.length ? { tool_calls: toolCalls } : {}
+    };
+    opts2.messages.push(assistantMsg);
+    opts2.callbacks.onAssistantFinal?.(assistantMsg);
+    if (toolCalls.length === 0) return;
+    for (const tc of toolCalls) {
+      if (opts2.signal.aborted) throw new DOMException("aborted", "AbortError");
+      const result = await opts2.executor.run(
+        { id: tc.id, name: tc.function.name, arguments: tc.function.arguments },
+        opts2.callbacks.askPermission,
+        { cwd: opts2.cwd, signal: opts2.signal }
+      );
+      opts2.messages.push({
+        role: "tool",
+        tool_call_id: result.tool_call_id,
+        content: result.content,
+        name: result.name
+      });
+      opts2.callbacks.onToolResult?.(result);
+    }
+  }
+  throw new Error(`kimiflare: tool iteration limit reached (${opts2.maxToolIterations ?? 50})`);
+}
+var init_loop = __esm({
+  "src/agent/loop.ts"() {
+    "use strict";
+    init_client();
+    init_registry();
+  }
+});
+
+// src/agent/system-prompt.ts
+import { platform, release, homedir as homedir2 } from "os";
+import { basename } from "path";
+function buildSystemPrompt(opts2) {
+  const now = opts2.now ?? /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const shell = process.env.SHELL ? basename(process.env.SHELL) : "sh";
+  const toolsBlock = opts2.tools.map((t) => {
+    const perm = t.needsPermission ? " [needs user permission]" : "";
+    return `- \`${t.name}\`${perm}: ${t.description.split("\n")[0]}`;
+  }).join("\n");
+  return `You are kimiflare, an interactive coding assistant running in the user's terminal. You act on the user's local filesystem through the tools listed below. You are powered by the ${opts2.model} model on Cloudflare Workers AI.
+
+Environment:
+- Working directory: ${opts2.cwd}
+- Platform: ${platform()} ${release()}
+- Shell: ${shell}
+- Home: ${homedir2()}
+- Today: ${date}
+
+Tools available:
+${toolsBlock}
+
+How to work:
+- Prefer calling tools over guessing. Read files before editing them. Use \`glob\` and \`grep\` to explore code before assuming structure.
+- Before any mutating tool call (write, edit, bash), state in one short sentence what you're about to do, then call the tool. The user will be asked to approve each mutating call.
+- When the user asks for a change, make the change. Do not paste code in chat that you could apply with \`edit\` or \`write\`.
+- Keep responses terse. The user sees tool calls and their results inline \u2014 do not re-summarize them unless asked.
+- If a tool returns an error, read it carefully and adjust; do not retry the same call blindly.
+- You have a 262k-token context window. Read as much of a file as needed rather than guessing.
+- If a request is ambiguous, ask one focused question instead of making large assumptions.
+- When you finish a task, stop. Do not add a closing summary.`;
+}
+var init_system_prompt = __esm({
+  "src/agent/system-prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/util/paths.ts
+import { resolve, isAbsolute } from "path";
+import { homedir as homedir3 } from "os";
+function resolvePath(cwd, input) {
+  if (input.startsWith("~/") || input === "~") {
+    return resolve(homedir3(), input === "~" ? "." : input.slice(2));
+  }
+  return isAbsolute(input) ? input : resolve(cwd, input);
+}
+function truncate(s, n) {
+  if (s.length <= n) return s;
+  return s.slice(0, n) + `
+... [truncated, ${s.length - n} chars omitted]`;
+}
+var init_paths = __esm({
+  "src/util/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/read.ts
+import { readFile as readFile2, stat } from "fs/promises";
+var MAX_BYTES, readTool;
+var init_read = __esm({
+  "src/tools/read.ts"() {
+    "use strict";
+    init_paths();
+    MAX_BYTES = 2 * 1024 * 1024;
+    readTool = {
+      name: "read",
+      description: "Read a text file from the local filesystem. Supports optional line offset/limit. Refuses files larger than 2MB. Returns contents with 1-indexed line numbers prefixed, cat -n style.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path to the file. Absolute or relative to cwd." },
+          offset: { type: "integer", description: "1-indexed line number to start reading from.", minimum: 1 },
+          limit: { type: "integer", description: "Maximum number of lines to return.", minimum: 1 }
+        },
+        required: ["path"],
+        additionalProperties: false
+      },
+      needsPermission: false,
+      render: ({ path }) => ({ title: `read ${path}` }),
+      async run(args, ctx) {
+        const abs = resolvePath(ctx.cwd, args.path);
+        const st = await stat(abs);
+        if (st.size > MAX_BYTES) throw new Error(`file too large: ${st.size} bytes (max ${MAX_BYTES})`);
+        const text = await readFile2(abs, "utf8");
+        const lines = text.split("\n");
+        const start = Math.max(0, (args.offset ?? 1) - 1);
+        const end = args.limit ? Math.min(lines.length, start + args.limit) : lines.length;
+        const width = String(end).length;
+        return lines.slice(start, end).map((l, i) => `${String(start + i + 1).padStart(width, " ")}	${l}`).join("\n");
+      }
+    };
+  }
+});
+
+// src/tools/write.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { dirname } from "path";
+var writeTool;
+var init_write = __esm({
+  "src/tools/write.ts"() {
+    "use strict";
+    init_paths();
+    writeTool = {
+      name: "write",
+      description: "Create a file or overwrite an existing one with the given contents. Prompts the user for permission first and shows a diff preview.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          content: { type: "string" }
+        },
+        required: ["path", "content"],
+        additionalProperties: false
+      },
+      needsPermission: true,
+      render: (args) => ({
+        title: `write ${args.path} (${args.content.length} chars)`,
+        diff: { path: args.path, before: "", after: args.content }
+      }),
+      async run(args, ctx) {
+        const abs = resolvePath(ctx.cwd, args.path);
+        let before = "";
+        try {
+          before = await readFile3(abs, "utf8");
+        } catch {
+        }
+        await mkdir2(dirname(abs), { recursive: true });
+        await writeFile2(abs, args.content, "utf8");
+        const verb = before ? "Overwrote" : "Created";
+        return `${verb} ${args.path} (${args.content.length} chars).`;
+      }
+    };
+  }
+});
+
+// src/tools/edit.ts
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+function countOccurrences(haystack, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let from = 0;
+  while (true) {
+    const i = haystack.indexOf(needle, from);
+    if (i === -1) return count;
+    count++;
+    from = i + needle.length;
+  }
+}
+var editTool;
+var init_edit = __esm({
+  "src/tools/edit.ts"() {
+    "use strict";
+    init_paths();
+    editTool = {
+      name: "edit",
+      description: "Replace an exact string in a file. If replace_all is false (default), the old_string must appear exactly once or the call fails. Prompts the user for permission first and shows a diff preview.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          old_string: { type: "string", description: "Exact text to replace." },
+          new_string: { type: "string", description: "Replacement text." },
+          replace_all: { type: "boolean", default: false }
+        },
+        required: ["path", "old_string", "new_string"],
+        additionalProperties: false
+      },
+      needsPermission: true,
+      render: (args) => ({
+        title: `edit ${args.path}${args.replace_all ? " (replace_all)" : ""}`,
+        diff: { path: args.path, before: args.old_string, after: args.new_string }
+      }),
+      async run(args, ctx) {
+        const abs = resolvePath(ctx.cwd, args.path);
+        const orig = await readFile4(abs, "utf8");
+        const occurrences = countOccurrences(orig, args.old_string);
+        if (occurrences === 0) throw new Error(`old_string not found in ${args.path}`);
+        if (occurrences > 1 && !args.replace_all) {
+          throw new Error(
+            `old_string appears ${occurrences} times in ${args.path}; pass replace_all=true or include more surrounding context`
+          );
+        }
+        const next = args.replace_all ? orig.split(args.old_string).join(args.new_string) : orig.replace(args.old_string, args.new_string);
+        await writeFile3(abs, next, "utf8");
+        return `Replaced ${occurrences} occurrence(s) in ${args.path}.`;
+      }
+    };
+  }
+});
+
+// src/tools/bash.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT, MAX_TIMEOUT, OUTPUT_CAP, bashTool;
+var init_bash = __esm({
+  "src/tools/bash.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULT_TIMEOUT = 12e4;
+    MAX_TIMEOUT = 6e5;
+    OUTPUT_CAP = 3e4;
+    bashTool = {
+      name: "bash",
+      description: "Run a shell command via `bash -lc`. Prompts the user for permission before executing. stdout and stderr are captured, combined, and capped at 30KB.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: { type: "string" },
+          timeout_ms: {
+            type: "integer",
+            description: "Milliseconds. Default 120000, max 600000.",
+            minimum: 1e3,
+            maximum: MAX_TIMEOUT
+          }
+        },
+        required: ["command"],
+        additionalProperties: false
+      },
+      needsPermission: true,
+      render: (args) => ({ title: `bash: ${args.command}`.slice(0, 120) }),
+      run(args, ctx) {
+        const timeout = Math.min(Math.max(1e3, args.timeout_ms ?? DEFAULT_TIMEOUT), MAX_TIMEOUT);
+        return new Promise((resolve2, reject) => {
+          const child = spawn("bash", ["-lc", args.command], {
+            cwd: ctx.cwd,
+            signal: ctx.signal
+          });
+          let stdout = "";
+          let stderr = "";
+          let killedByTimeout = false;
+          const timer = setTimeout(() => {
+            killedByTimeout = true;
+            child.kill("SIGKILL");
+          }, timeout);
+          child.stdout.on("data", (d) => {
+            stdout += d.toString("utf8");
+          });
+          child.stderr.on("data", (d) => {
+            stderr += d.toString("utf8");
+          });
+          child.on("error", (e) => {
+            clearTimeout(timer);
+            reject(e);
+          });
+          child.on("close", (code, signal) => {
+            clearTimeout(timer);
+            const header = killedByTimeout ? `(timed out after ${timeout}ms)` : `exit=${code ?? "?"}${signal ? ` signal=${signal}` : ""}`;
+            const parts = [header];
+            if (stdout) parts.push(`--- stdout ---
+${stdout.trimEnd()}`);
+            if (stderr) parts.push(`--- stderr ---
+${stderr.trimEnd()}`);
+            if (!stdout && !stderr) parts.push("(no output)");
+            resolve2(truncate(parts.join("\n"), OUTPUT_CAP));
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/tools/glob.ts
+import fg from "fast-glob";
+var globTool;
+var init_glob = __esm({
+  "src/tools/glob.ts"() {
+    "use strict";
+    init_paths();
+    globTool = {
+      name: "glob",
+      description: "Find files matching a glob pattern (e.g. `**/*.ts`). Returns up to 200 absolute paths, sorted by mtime descending.",
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "Glob pattern, e.g. `src/**/*.ts`." },
+          path: { type: "string", description: "Root directory. Defaults to cwd." }
+        },
+        required: ["pattern"],
+        additionalProperties: false
+      },
+      needsPermission: false,
+      render: (args) => ({ title: `glob ${args.pattern}${args.path ? ` in ${args.path}` : ""}` }),
+      async run(args, ctx) {
+        const root = args.path ? resolvePath(ctx.cwd, args.path) : ctx.cwd;
+        const entries = await fg(args.pattern, {
+          cwd: root,
+          absolute: true,
+          dot: false,
+          onlyFiles: false,
+          stats: true
+        });
+        entries.sort((a, b) => (b.stats?.mtimeMs ?? 0) - (a.stats?.mtimeMs ?? 0));
+        const paths = entries.slice(0, 200).map((e) => e.path);
+        return paths.length ? paths.join("\n") : "(no matches)";
+      }
+    };
+  }
+});
+
+// src/tools/grep.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { readFile as readFile5 } from "fs/promises";
+import fg2 from "fast-glob";
+async function hasRipgrep() {
+  if (cachedHasRg !== null) return cachedHasRg;
+  try {
+    await pExecFile("rg", ["--version"]);
+    cachedHasRg = true;
+  } catch {
+    cachedHasRg = false;
+  }
+  return cachedHasRg;
+}
+async function runRipgrep(args, root, mode) {
+  const rgArgs = ["--no-heading", "--color=never", "--line-number"];
+  if (args.case_insensitive) rgArgs.push("-i");
+  if (args.glob) rgArgs.push("--glob", args.glob);
+  if (mode === "files") rgArgs.push("-l");
+  rgArgs.push("--", args.pattern, root);
+  try {
+    const { stdout } = await pExecFile("rg", rgArgs, { maxBuffer: 10 * 1024 * 1024 });
+    const trimmed = stdout.trim();
+    return trimmed ? truncate(trimmed, 3e4) : "(no matches)";
+  } catch (e) {
+    const err = e;
+    if (err.code === 1) return "(no matches)";
+    throw new Error(err.stderr || String(e));
+  }
+}
+async function runJsFallback(args, root, mode) {
+  const re = new RegExp(args.pattern, args.case_insensitive ? "i" : "");
+  const globPattern = args.glob ? `**/${args.glob}` : "**/*";
+  const files = await fg2(globPattern, {
+    cwd: root,
+    absolute: true,
+    dot: false,
+    onlyFiles: true,
+    ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**"]
+  });
+  const out = [];
+  for (const file of files.slice(0, 5e3)) {
+    try {
+      const content = await readFile5(file, "utf8");
+      if (mode === "files") {
+        if (re.test(content)) out.push(file);
+      } else {
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (re.test(lines[i])) {
+            out.push(`${file}:${i + 1}:${lines[i]}`);
+            if (out.length > 500) break;
+          }
+        }
+      }
+    } catch {
+    }
+    if (out.length > 500) break;
+  }
+  return out.length ? truncate(out.join("\n"), 3e4) : "(no matches)";
+}
+var pExecFile, cachedHasRg, grepTool;
+var init_grep = __esm({
+  "src/tools/grep.ts"() {
+    "use strict";
+    init_paths();
+    pExecFile = promisify(execFile);
+    cachedHasRg = null;
+    grepTool = {
+      name: "grep",
+      description: "Search file contents for a regular expression. Shells out to ripgrep if available, otherwise uses a JavaScript fallback. Output is capped at 30KB.",
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "Regex pattern." },
+          path: { type: "string", description: "Root directory. Defaults to cwd." },
+          glob: { type: "string", description: "Filter files by glob, e.g. `*.ts`." },
+          case_insensitive: { type: "boolean" },
+          output_mode: {
+            type: "string",
+            enum: ["content", "files"],
+            description: "`content` returns matching lines; `files` returns matching file paths only."
+          }
+        },
+        required: ["pattern"],
+        additionalProperties: false
+      },
+      needsPermission: false,
+      render: (args) => ({ title: `grep ${args.pattern}${args.glob ? ` (${args.glob})` : ""}` }),
+      async run(args, ctx) {
+        const root = args.path ? resolvePath(ctx.cwd, args.path) : ctx.cwd;
+        const mode = args.output_mode ?? "content";
+        if (await hasRipgrep()) return runRipgrep(args, root, mode);
+        return runJsFallback(args, root, mode);
+      }
+    };
+  }
+});
+
+// src/tools/web-fetch.ts
+import TurndownService from "turndown";
+var MAX_BYTES2, MAX_OUTPUT, TIMEOUT_MS, webFetchTool;
+var init_web_fetch = __esm({
+  "src/tools/web-fetch.ts"() {
+    "use strict";
+    init_paths();
+    MAX_BYTES2 = 1 * 1024 * 1024;
+    MAX_OUTPUT = 1e5;
+    TIMEOUT_MS = 2e4;
+    webFetchTool = {
+      name: "web_fetch",
+      description: "Fetch a URL over HTTPS and return its content. HTML pages are converted to markdown. Output is capped at ~100KB.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "Full URL, http(s)." }
+        },
+        required: ["url"],
+        additionalProperties: false
+      },
+      needsPermission: false,
+      render: (args) => ({ title: `GET ${args.url}` }),
+      async run(args) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+        try {
+          const res = await fetch(args.url, {
+            redirect: "follow",
+            signal: controller.signal,
+            headers: { "user-agent": "kimiflare/0.1 (+https://github.com/sinameraji/kimiflare)" }
+          });
+          const ct = res.headers.get("content-type") ?? "";
+          const body = await res.text();
+          const bounded = body.length > MAX_BYTES2 ? body.slice(0, MAX_BYTES2) : body;
+          if (ct.toLowerCase().includes("html")) {
+            const td = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+            return truncate(`# ${args.url}
+
+${td.turndown(bounded)}`, MAX_OUTPUT);
+          }
+          return truncate(`# ${args.url}
+
+${bounded}`, MAX_OUTPUT);
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+    };
+  }
+});
+
+// src/tools/executor.ts
+function truncateForError(s) {
+  return s.length <= 200 ? s : `${s.slice(0, 200)}... [${s.length - 200} more chars]`;
+}
+var ALL_TOOLS, ToolExecutor;
+var init_executor = __esm({
+  "src/tools/executor.ts"() {
+    "use strict";
+    init_read();
+    init_write();
+    init_edit();
+    init_bash();
+    init_glob();
+    init_grep();
+    init_web_fetch();
+    ALL_TOOLS = [
+      readTool,
+      writeTool,
+      editTool,
+      bashTool,
+      globTool,
+      grepTool,
+      webFetchTool
+    ];
+    ToolExecutor = class {
+      sessionAllowed = /* @__PURE__ */ new Set();
+      tools;
+      constructor(tools = ALL_TOOLS) {
+        this.tools = new Map(tools.map((t) => [t.name, t]));
+      }
+      list() {
+        return [...this.tools.values()];
+      }
+      async run(call, askPermission, ctx) {
+        const tool = this.tools.get(call.name);
+        if (!tool) {
+          return {
+            tool_call_id: call.id,
+            name: call.name,
+            content: `Error: unknown tool "${call.name}". Valid tools: ${[...this.tools.keys()].join(", ")}.`,
+            ok: false
+          };
+        }
+        let args;
+        try {
+          args = call.arguments.trim() ? JSON.parse(call.arguments) : {};
+        } catch (e) {
+          return {
+            tool_call_id: call.id,
+            name: call.name,
+            content: `Error: invalid JSON arguments for ${call.name}: ${e.message}. Arguments received: ${truncateForError(call.arguments)}`,
+            ok: false
+          };
+        }
+        if (tool.needsPermission) {
+          const sessionKey = this.permissionKey(tool, args);
+          if (!this.sessionAllowed.has(sessionKey)) {
+            const decision = await askPermission({ tool, args, sessionKey });
+            if (decision === "deny") {
+              return {
+                tool_call_id: call.id,
+                name: call.name,
+                content: `Permission denied by user. Do not retry this exact call; ask the user what they want to do differently.`,
+                ok: false
+              };
+            }
+            if (decision === "allow_session") this.sessionAllowed.add(sessionKey);
+          }
+        }
+        try {
+          const content = await tool.run(args, ctx);
+          return { tool_call_id: call.id, name: call.name, content, ok: true };
+        } catch (e) {
+          return {
+            tool_call_id: call.id,
+            name: call.name,
+            content: `Error running ${call.name}: ${e.message ?? String(e)}`,
+            ok: false
+          };
+        }
+      }
+      permissionKey(tool, args) {
+        if (tool.name === "bash" && typeof args.command === "string") {
+          const firstToken = args.command.trim().split(/\s+/)[0] ?? "";
+          return `bash:${firstToken}`;
+        }
+        return tool.name;
+      }
+    };
+  }
+});
+
+// src/ui/diff-view.tsx
+import { Box, Text } from "ink";
+import { createTwoFilesPatch } from "diff";
+import { jsx, jsxs } from "react/jsx-runtime";
+function DiffView({ path, before, after, maxLines = 40 }) {
+  const patch = createTwoFilesPatch(path, path, before, after, "", "", { context: 2 });
+  const lines = patch.split("\n").slice(4);
+  const truncated = lines.length > maxLines ? lines.slice(0, maxLines) : lines;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    truncated.map((line, i) => /* @__PURE__ */ jsx(DiffLine, { line }, i)),
+    lines.length > maxLines && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      "... (",
+      lines.length - maxLines,
+      " more lines)"
+    ] })
+  ] });
+}
+function DiffLine({ line }) {
+  if (line.startsWith("+") && !line.startsWith("+++")) {
+    return /* @__PURE__ */ jsx(Text, { color: "green", children: line });
+  }
+  if (line.startsWith("-") && !line.startsWith("---")) {
+    return /* @__PURE__ */ jsx(Text, { color: "red", children: line });
+  }
+  if (line.startsWith("@@")) {
+    return /* @__PURE__ */ jsx(Text, { color: "cyan", children: line });
+  }
+  return /* @__PURE__ */ jsx(Text, { color: "gray", children: line });
+}
+var init_diff_view = __esm({
+  "src/ui/diff-view.tsx"() {
+    "use strict";
+  }
+});
+
+// src/ui/tool-view.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import Spinner from "ink-spinner";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ToolView({ evt }) {
+  const statusIcon = evt.status === "running" ? /* @__PURE__ */ jsx2(Spinner, { type: "dots" }) : evt.status === "error" ? /* @__PURE__ */ jsx2(Text2, { color: "red", children: "\u2717" }) : /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2713" });
+  const title = evt.render?.title ?? `${evt.name}(${compactArgs(evt.args)})`;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      statusIcon,
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { color: "magenta", children: title })
+    ] }),
+    evt.render?.diff ? /* @__PURE__ */ jsx2(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx2(DiffView, { ...evt.render.diff }) }) : null,
+    evt.result && evt.expanded ? /* @__PURE__ */ jsxs2(Box2, { marginLeft: 2, flexDirection: "column", children: [
+      evt.result.split("\n").slice(0, 20).map((l, i) => /* @__PURE__ */ jsx2(Text2, { color: "gray", children: l }, i)),
+      evt.result.split("\n").length > 20 && /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+        "... (",
+        evt.result.split("\n").length - 20,
+        " more lines)"
+      ] })
+    ] }) : null,
+    evt.result && !evt.expanded && evt.status !== "running" ? /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+      "  ",
+      firstLine(evt.result)
+    ] }) : null
+  ] });
+}
+function compactArgs(raw) {
+  const s = raw.replace(/\s+/g, " ");
+  return s.length <= 80 ? s : s.slice(0, 80) + "\u2026";
+}
+function firstLine(s) {
+  const line = s.split("\n").find((l) => l.trim().length > 0) ?? "";
+  return line.length <= 120 ? line : line.slice(0, 120) + "\u2026";
+}
+var init_tool_view = __esm({
+  "src/ui/tool-view.tsx"() {
+    "use strict";
+    init_diff_view();
+  }
+});
+
+// src/ui/chat.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ChatView({ events, showReasoning }) {
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: events.map((e) => /* @__PURE__ */ jsx3(EventView, { evt: e, showReasoning }, e.key)) });
+}
+function EventView({ evt, showReasoning }) {
+  if (evt.kind === "user") {
+    return /* @__PURE__ */ jsxs3(Box3, { marginY: 0, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "\u203A " }),
+      /* @__PURE__ */ jsx3(Text3, { children: evt.text })
+    ] });
+  }
+  if (evt.kind === "assistant") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginY: 0, children: [
+      showReasoning && evt.reasoning ? /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", marginLeft: 2, children: /* @__PURE__ */ jsxs3(Text3, { color: "gray", dimColor: true, children: [
+        "\u2727 thinking: ",
+        evt.reasoning.length > 400 ? evt.reasoning.slice(0, 400) + "\u2026" : evt.reasoning
+      ] }) }) : null,
+      evt.text ? /* @__PURE__ */ jsx3(Text3, { children: evt.text }) : null
+    ] });
+  }
+  if (evt.kind === "tool") {
+    return /* @__PURE__ */ jsx3(ToolView, { evt });
+  }
+  if (evt.kind === "info") {
+    return /* @__PURE__ */ jsx3(Text3, { color: "gray", dimColor: true, children: evt.text });
+  }
+  return /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+    "! ",
+    evt.text
+  ] });
+}
+var init_chat = __esm({
+  "src/ui/chat.tsx"() {
+    "use strict";
+    init_tool_view();
+  }
+});
+
+// src/ui/status.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function StatusBar({ model, usage, thinking, hint }) {
+  const parts = [`model: ${shortModel(model)}`];
+  if (usage) {
+    const cached = usage.prompt_tokens_details?.cached_tokens ?? 0;
+    const uncachedIn = usage.prompt_tokens - cached;
+    const cost = uncachedIn * PRICE_IN_PER_M / 1e6 + cached * PRICE_IN_CACHED_PER_M / 1e6 + usage.completion_tokens * PRICE_OUT_PER_M / 1e6;
+    parts.push(
+      `in: ${usage.prompt_tokens}${cached ? ` (${cached} cached)` : ""}`,
+      `out: ${usage.completion_tokens}`,
+      `$${cost.toFixed(5)}`
+    );
+  }
+  if (thinking) parts.push("thinking\u2026");
+  if (hint) parts.push(hint);
+  return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { color: "gray", dimColor: true, children: parts.join("  \xB7  ") }) });
+}
+function shortModel(m) {
+  const last = m.split("/").at(-1) ?? m;
+  return last;
+}
+var PRICE_IN_PER_M, PRICE_IN_CACHED_PER_M, PRICE_OUT_PER_M;
+var init_status = __esm({
+  "src/ui/status.tsx"() {
+    "use strict";
+    PRICE_IN_PER_M = 0.95;
+    PRICE_IN_CACHED_PER_M = 0.16;
+    PRICE_OUT_PER_M = 4;
+  }
+});
+
+// src/ui/permission.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import SelectInput from "ink-select-input";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function PermissionModal({ tool, args, onDecide }) {
+  const render2 = tool.render?.(args);
+  const items = [
+    { label: "Allow once", value: "allow" },
+    { label: "Allow for this session", value: "allow_session" },
+    { label: "Deny", value: "deny" }
+  ];
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "yellow", bold: true, children: "Permission requested" }),
+    /* @__PURE__ */ jsxs4(Text5, { children: [
+      "tool: ",
+      /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: tool.name })
+    ] }),
+    render2?.title ? /* @__PURE__ */ jsxs4(Text5, { children: [
+      "action: ",
+      render2.title
+    ] }) : null,
+    render2?.diff ? /* @__PURE__ */ jsx5(Box5, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx5(DiffView, { ...render2.diff }) }) : /* @__PURE__ */ jsxs4(Text5, { color: "gray", children: [
+      "args: ",
+      JSON.stringify(args)
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(SelectInput, { items, onSelect: (item) => onDecide(item.value) }) })
+  ] });
+}
+var init_permission = __esm({
+  "src/ui/permission.tsx"() {
+    "use strict";
+    init_diff_view();
+  }
+});
+
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm({
+  "node_modules/chalk/source/vendor/ansi-styles/index.js"() {
+    "use strict";
+    ANSI_BACKGROUND_OFFSET = 10;
+    wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+    wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+    styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39],
+        // Alias of `blackBright`
+        grey: [90, 39],
+        // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49],
+        // Alias of `bgBlackBright`
+        bgGrey: [100, 49],
+        // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    modifierNames = Object.keys(styles.modifier);
+    foregroundColorNames = Object.keys(styles.color);
+    backgroundColorNames = Object.keys(styles.bgColor);
+    colorNames = [...foregroundColorNames, ...backgroundColorNames];
+    ansiStyles = assembleStyles();
+    ansi_styles_default = ansiStyles;
+  }
+});
+
+// node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "node_modules/chalk/source/vendor/supports-color/index.js"() {
+    "use strict";
+    ({ env } = process2);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+    };
+    supports_color_default = supportsColor;
+  }
+});
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+var init_utilities = __esm({
+  "node_modules/chalk/source/utilities.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/chalk/source/index.js
+function createChalk(options) {
+  return chalkFactory(options);
+}
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr, source_default;
+var init_source = __esm({
+  "node_modules/chalk/source/index.js"() {
+    "use strict";
+    init_ansi_styles();
+    init_supports_color();
+    init_utilities();
+    ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
+    GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+    STYLER = /* @__PURE__ */ Symbol("STYLER");
+    IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+    levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    styles2 = /* @__PURE__ */ Object.create(null);
+    applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    chalkFactory = (options) => {
+      const chalk2 = (...strings) => strings.join(" ");
+      applyOptions(chalk2, options);
+      Object.setPrototypeOf(chalk2, createChalk.prototype);
+      return chalk2;
+    };
+    Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+    for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+      styles2[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
+    }
+    styles2.visible = {
+      get() {
+        const builder = createBuilder(this, this[STYLER], true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    getModelAnsi = (model, level, type, ...arguments_) => {
+      if (model === "rgb") {
+        if (level === "ansi16m") {
+          return ansi_styles_default[type].ansi16m(...arguments_);
+        }
+        if (level === "ansi256") {
+          return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+        }
+        return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+      }
+      if (model === "hex") {
+        return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+      }
+      return ansi_styles_default[type][model](...arguments_);
+    };
+    usedModels = ["rgb", "hex", "ansi256"];
+    for (const model of usedModels) {
+      styles2[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+    }
+    proto = Object.defineProperties(() => {
+    }, {
+      ...styles2,
+      level: {
+        enumerable: true,
+        get() {
+          return this[GENERATOR].level;
+        },
+        set(level) {
+          this[GENERATOR].level = level;
+        }
+      }
+    });
+    createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      Object.setPrototypeOf(builder, proto);
+      builder[GENERATOR] = self;
+      builder[STYLER] = _styler;
+      builder[IS_EMPTY] = _isEmpty;
+      return builder;
+    };
+    applyStyle = (self, string) => {
+      if (self.level <= 0 || !string) {
+        return self[IS_EMPTY] ? "" : string;
+      }
+      let styler = self[STYLER];
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.includes("\x1B")) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    Object.defineProperties(createChalk.prototype, styles2);
+    chalk = createChalk();
+    chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+    source_default = chalk;
+  }
+});
+
+// src/ui/text-input.tsx
+import { useState, useEffect } from "react";
+import { Text as Text6, useInput } from "ink";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function findWordBoundaryForward(text, pos) {
+  while (pos < text.length && /\w/.test(text[pos])) pos++;
+  while (pos < text.length && !/\w/.test(text[pos])) pos++;
+  return pos;
+}
+function findWordBoundaryBackward(text, pos) {
+  while (pos > 0 && !/\w/.test(text[pos - 1])) pos--;
+  while (pos > 0 && /\w/.test(text[pos - 1])) pos--;
+  return pos;
+}
+function CustomTextInput({
+  value,
+  onChange,
+  onSubmit,
+  onHistoryUp,
+  onHistoryDown,
+  onClearQueueItem,
+  focus = true,
+  mask
+}) {
+  const [cursorOffset, setCursorOffset] = useState(value.length);
+  useEffect(() => {
+    if (!focus) return;
+    setCursorOffset((prev) => prev > value.length ? value.length : prev);
+  }, [value, focus]);
+  useInput(
+    (input, key) => {
+      if (!focus) return;
+      if (key.ctrl && input === "c") return;
+      if (key.ctrl && input === "r") return;
+      if (key.tab) return;
+      if (key.return) {
+        onSubmit(value);
+        setCursorOffset(0);
+        return;
+      }
+      if (key.upArrow) {
+        onHistoryUp?.();
+        return;
+      }
+      if (key.downArrow) {
+        onHistoryDown?.();
+        return;
+      }
+      let nextCursor = cursorOffset;
+      let nextValue = value;
+      let didDelete = false;
+      if (key.leftArrow) {
+        if (key.meta) {
+          nextCursor = findWordBoundaryBackward(value, cursorOffset);
+        } else {
+          nextCursor = cursorOffset - 1;
+        }
+      } else if (key.rightArrow) {
+        if (key.meta) {
+          nextCursor = findWordBoundaryForward(value, cursorOffset);
+        } else {
+          nextCursor = cursorOffset + 1;
+        }
+      } else if (key.home || key.ctrl && input === "a") {
+        nextCursor = 0;
+      } else if (key.end || key.ctrl && input === "e") {
+        nextCursor = value.length;
+      } else if (key.backspace) {
+        didDelete = true;
+        if (key.meta || key.ctrl && input === "w") {
+          const boundary = findWordBoundaryBackward(value, cursorOffset);
+          nextValue = value.slice(0, boundary) + value.slice(cursorOffset);
+          nextCursor = boundary;
+        } else if (key.ctrl) {
+          const boundary = findWordBoundaryBackward(value, cursorOffset);
+          nextValue = value.slice(0, boundary) + value.slice(cursorOffset);
+          nextCursor = boundary;
+        } else {
+          if (cursorOffset > 0) {
+            nextValue = value.slice(0, cursorOffset - 1) + value.slice(cursorOffset);
+            nextCursor = cursorOffset - 1;
+          }
+        }
+      } else if (key.delete) {
+        didDelete = true;
+        if (key.meta || key.ctrl) {
+          const boundary = findWordBoundaryForward(value, cursorOffset);
+          nextValue = value.slice(0, cursorOffset) + value.slice(boundary);
+        } else {
+          nextValue = value.slice(0, cursorOffset) + value.slice(cursorOffset + 1);
+        }
+      } else if (key.ctrl && input === "w") {
+        didDelete = true;
+        const boundary = findWordBoundaryBackward(value, cursorOffset);
+        nextValue = value.slice(0, boundary) + value.slice(cursorOffset);
+        nextCursor = boundary;
+      } else if (key.ctrl && input === "u") {
+        didDelete = true;
+        nextValue = value.slice(cursorOffset);
+        nextCursor = 0;
+      } else if (key.ctrl && input === "k") {
+        didDelete = true;
+        nextValue = value.slice(0, cursorOffset);
+      } else if (input.length > 0 && !key.ctrl && !key.meta) {
+        nextValue = value.slice(0, cursorOffset) + input + value.slice(cursorOffset);
+        nextCursor = cursorOffset + input.length;
+      }
+      if (nextCursor < 0) nextCursor = 0;
+      if (nextCursor > nextValue.length) nextCursor = nextValue.length;
+      if (didDelete && nextValue === "" && value !== "") {
+        onClearQueueItem?.(value);
+      }
+      if (nextCursor !== cursorOffset) {
+        setCursorOffset(nextCursor);
+      }
+      if (nextValue !== value) {
+        onChange(nextValue);
+      }
+    },
+    { isActive: focus }
+  );
+  const displayValue = mask ? mask.repeat(value.length) : value;
+  let renderedValue = "";
+  let i = 0;
+  for (const char of displayValue) {
+    renderedValue += i === cursorOffset ? source_default.inverse(char) : char;
+    i++;
+  }
+  if (displayValue.length === 0) {
+    renderedValue = source_default.inverse(" ");
+  } else if (cursorOffset === displayValue.length) {
+    renderedValue += source_default.inverse(" ");
+  }
+  return /* @__PURE__ */ jsx6(Text6, { children: renderedValue });
+}
+var init_text_input = __esm({
+  "src/ui/text-input.tsx"() {
+    "use strict";
+    init_source();
+  }
+});
+
+// src/util/update-check.ts
+import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir3, access } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+function cachePath() {
+  const xdg = process.env.XDG_CONFIG_HOME || join2(homedir4(), ".config");
+  return join2(xdg, "kimiflare", "update-check.json");
+}
+function localPackageJsonPath() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  return join2(here, "..", "..", "package.json");
+}
+async function readLocalVersion() {
+  try {
+    const raw = await readFile6(localPackageJsonPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function readCache() {
+  try {
+    const raw = await readFile6(cachePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (Date.now() - parsed.checkedAt < CACHE_TTL_MS) {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+async function writeCache(entry) {
+  const p = cachePath();
+  await mkdir3(dirname2(p), { recursive: true });
+  await writeFile4(p, JSON.stringify(entry), "utf8");
+}
+async function fetchLatestVersion() {
+  try {
+    const res = await fetch(GITHUB_API, {
+      headers: { "User-Agent": "kimiflare-update-checker" }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.tag_name ?? null;
+  } catch {
+    return null;
+  }
+}
+function stripV(v) {
+  return v.startsWith("v") ? v.slice(1) : v;
+}
+function isNewer(local, remote) {
+  const a = stripV(local).split(".").map(Number);
+  const b = stripV(remote).split(".").map(Number);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av < bv) return true;
+    if (av > bv) return false;
+  }
+  return false;
+}
+async function checkForUpdate() {
+  const localVersion = await readLocalVersion();
+  if (!localVersion) return { hasUpdate: false, localVersion: null, latestVersion: null };
+  const cached = await readCache();
+  if (cached) {
+    return { hasUpdate: cached.hasUpdate, localVersion, latestVersion: cached.latestVersion };
+  }
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    return { hasUpdate: false, localVersion, latestVersion: null };
+  }
+  const hasUpdate = isNewer(localVersion, latestVersion);
+  await writeCache({ checkedAt: Date.now(), latestVersion, hasUpdate });
+  return { hasUpdate, localVersion, latestVersion };
+}
+async function isGitRepo() {
+  try {
+    const here = dirname2(fileURLToPath(import.meta.url));
+    await access(join2(here, "..", "..", ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var CACHE_TTL_MS, GITHUB_API;
+var init_update_check = __esm({
+  "src/util/update-check.ts"() {
+    "use strict";
+    CACHE_TTL_MS = 60 * 60 * 1e3;
+    GITHUB_API = "https://api.github.com/repos/sinameraji/kimiflare/releases/latest";
+  }
+});
+
+// src/ui/onboarding.tsx
+import { useState as useState2 } from "react";
+import { Box as Box6, Text as Text7 } from "ink";
+import { Fragment, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function Onboarding({ onDone }) {
+  const [step, setStep] = useState2("accountId");
+  const [accountId, setAccountId] = useState2("");
+  const [apiToken, setApiToken] = useState2("");
+  const [model, setModel] = useState2(DEFAULT_MODEL);
+  const [savedPath, setSavedPath] = useState2(null);
+  const handleAccountIdSubmit = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    setAccountId(trimmed);
+    setStep("apiToken");
+  };
+  const handleApiTokenSubmit = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    setApiToken(trimmed);
+    setStep("model");
+  };
+  const handleModelSubmit = (value) => {
+    const trimmed = value.trim() || DEFAULT_MODEL;
+    setModel(trimmed);
+    setStep("confirm");
+  };
+  const handleConfirm = async () => {
+    const cfg = { accountId, apiToken, model };
+    try {
+      const path = await saveConfig(cfg);
+      setSavedPath(path);
+      onDone(cfg);
+    } catch (e) {
+      setSavedPath(`error: ${e.message}`);
+    }
+  };
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: "Welcome to kimiflare!" }),
+    /* @__PURE__ */ jsx7(Text7, { color: "gray", dimColor: true, children: "Terminal coding agent powered by Kimi-K2.6 on Cloudflare Workers AI." }),
+    /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+      step === "accountId" && /* @__PURE__ */ jsxs5(Fragment, { children: [
+        /* @__PURE__ */ jsx7(Text7, { children: "Enter your Cloudflare Account ID:" }),
+        /* @__PURE__ */ jsxs5(Box6, { children: [
+          /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "\u203A " }),
+          /* @__PURE__ */ jsx7(
+            CustomTextInput,
+            {
+              value: accountId,
+              onChange: setAccountId,
+              onSubmit: handleAccountIdSubmit
+            }
+          )
+        ] })
+      ] }),
+      step === "apiToken" && /* @__PURE__ */ jsxs5(Fragment, { children: [
+        /* @__PURE__ */ jsx7(Text7, { children: "Enter your Cloudflare API Token:" }),
+        /* @__PURE__ */ jsx7(Text7, { color: "gray", dimColor: true, children: "Create one at https://dash.cloudflare.com/profile/api-tokens" }),
+        /* @__PURE__ */ jsxs5(Box6, { children: [
+          /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "\u203A " }),
+          /* @__PURE__ */ jsx7(
+            CustomTextInput,
+            {
+              value: apiToken,
+              onChange: setApiToken,
+              onSubmit: handleApiTokenSubmit,
+              mask: "\u2022"
+            }
+          )
+        ] })
+      ] }),
+      step === "model" && /* @__PURE__ */ jsxs5(Fragment, { children: [
+        /* @__PURE__ */ jsx7(Text7, { children: "Model ID (press Enter for default):" }),
+        /* @__PURE__ */ jsxs5(Text7, { color: "gray", dimColor: true, children: [
+          "default: ",
+          DEFAULT_MODEL
+        ] }),
+        /* @__PURE__ */ jsxs5(Box6, { children: [
+          /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "\u203A " }),
+          /* @__PURE__ */ jsx7(
+            CustomTextInput,
+            {
+              value: model,
+              onChange: setModel,
+              onSubmit: handleModelSubmit
+            }
+          )
+        ] })
+      ] }),
+      step === "confirm" && /* @__PURE__ */ jsxs5(Fragment, { children: [
+        /* @__PURE__ */ jsx7(Text7, { children: "Ready to save configuration:" }),
+        /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginLeft: 2, children: [
+          /* @__PURE__ */ jsxs5(Text7, { color: "gray", children: [
+            "Account ID: ",
+            accountId
+          ] }),
+          /* @__PURE__ */ jsxs5(Text7, { color: "gray", children: [
+            "API Token: ",
+            "\u2022".repeat(apiToken.length)
+          ] }),
+          /* @__PURE__ */ jsxs5(Text7, { color: "gray", children: [
+            "Model: ",
+            model
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx7(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { children: "Press Enter to confirm, or Ctrl+C to cancel" }) }),
+        /* @__PURE__ */ jsxs5(Box6, { children: [
+          /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "\u203A " }),
+          /* @__PURE__ */ jsx7(
+            CustomTextInput,
+            {
+              value: "",
+              onChange: () => {
+              },
+              onSubmit: handleConfirm
+            }
+          )
+        ] })
+      ] }),
+      savedPath && /* @__PURE__ */ jsxs5(Text7, { color: "green", children: [
+        "Config saved to ",
+        savedPath
+      ] })
+    ] })
+  ] });
+}
+var init_onboarding = __esm({
+  "src/ui/onboarding.tsx"() {
+    "use strict";
+    init_text_input();
+    init_config();
+  }
+});
+
+// src/app.tsx
+var app_exports = {};
+__export(app_exports, {
+  renderApp: () => renderApp
+});
+import { useState as useState3, useRef, useEffect as useEffect2, useCallback } from "react";
+import { Box as Box7, Text as Text8, useApp, useInput as useInput2, render } from "ink";
+import Spinner2 from "ink-spinner";
+import { unlink } from "fs/promises";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function App({ initialCfg }) {
+  const { exit } = useApp();
+  const [cfg, setCfg] = useState3(initialCfg);
+  const [events, setEvents] = useState3([
+    { kind: "info", key: mkKey(), text: "kimiflare \xB7 /help for commands \xB7 ctrl-c to exit" }
+  ]);
+  const [input, setInput] = useState3("");
+  const [busy, setBusy] = useState3(false);
+  const [usage, setUsage] = useState3(null);
+  const [showReasoning, setShowReasoning] = useState3(false);
+  const [perm, setPerm] = useState3(null);
+  const [queue, setQueue] = useState3([]);
+  const [history, setHistory] = useState3([]);
+  const [historyIndex, setHistoryIndex] = useState3(-1);
+  const [draftInput, setDraftInput] = useState3("");
+  const [updateInfo, setUpdateInfo] = useState3(null);
+  const messagesRef = useRef([
+    {
+      role: "system",
+      content: buildSystemPrompt({ cwd: process.cwd(), tools: ALL_TOOLS, model: cfg?.model ?? DEFAULT_MODEL })
+    }
+  ]);
+  const executorRef = useRef(new ToolExecutor(ALL_TOOLS));
+  const activeAsstIdRef = useRef(null);
+  const activeControllerRef = useRef(null);
+  useInput2((inputChar, key) => {
+    if (key.ctrl && inputChar === "c") {
+      if (busy && activeControllerRef.current) {
+        activeControllerRef.current.abort();
+        setEvents((e) => [...e, { kind: "info", key: mkKey(), text: "(interrupted)" }]);
+      } else {
+        exit();
+      }
+    }
+    if (key.ctrl && inputChar === "r") setShowReasoning((s) => !s);
+  });
+  const updateAssistant = useCallback(
+    (id, patch) => {
+      setEvents(
+        (evts) => evts.map(
+          (e) => e.kind === "assistant" && e.id === id ? { ...e, ...patch(e) } : e
+        )
+      );
+    },
+    []
+  );
+  const updateTool = useCallback(
+    (id, patch) => {
+      setEvents(
+        (evts) => evts.map(
+          (e) => e.kind === "tool" && e.id === id ? { ...e, ...patch } : e
+        )
+      );
+    },
+    []
+  );
+  const handleSlash = useCallback(
+    (cmd) => {
+      const c = cmd.trim().toLowerCase();
+      if (c === "/exit" || c === "/quit") {
+        exit();
+        return true;
+      }
+      if (c === "/clear") {
+        messagesRef.current = [messagesRef.current[0]];
+        setEvents([{ kind: "info", key: mkKey(), text: "conversation cleared" }]);
+        setUsage(null);
+        return true;
+      }
+      if (c === "/reasoning") {
+        setShowReasoning((s) => {
+          const next = !s;
+          setEvents((e) => [
+            ...e,
+            { kind: "info", key: mkKey(), text: `reasoning: ${next ? "shown" : "hidden"}` }
+          ]);
+          return next;
+        });
+        return true;
+      }
+      if (c === "/cost") {
+        setEvents((e) => [
+          ...e,
+          {
+            kind: "info",
+            key: mkKey(),
+            text: usage ? `prompt ${usage.prompt_tokens} / completion ${usage.completion_tokens}` : "no usage yet"
+          }
+        ]);
+        return true;
+      }
+      if (c === "/model") {
+        setEvents((e) => [
+          ...e,
+          { kind: "info", key: mkKey(), text: `current model: ${cfg?.model ?? "unknown"}` }
+        ]);
+        return true;
+      }
+      if (c === "/update") {
+        if (updateInfo?.hasUpdate) {
+          setEvents((e) => [
+            ...e,
+            {
+              kind: "info",
+              key: mkKey(),
+              text: `updating from ${updateInfo.localVersion} \u2192 ${updateInfo.latestVersion}\u2026`
+            }
+          ]);
+          isGitRepo().then((git) => {
+            if (git) {
+              setEvents((e) => [
+                ...e,
+                {
+                  kind: "info",
+                  key: mkKey(),
+                  text: "run:  git pull && npm install && npm run build  then restart kimiflare"
+                }
+              ]);
+            } else {
+              setEvents((e) => [
+                ...e,
+                {
+                  kind: "info",
+                  key: mkKey(),
+                  text: "run:  npm update -g kimiflare  then restart"
+                }
+              ]);
+            }
+          });
+        } else {
+          setEvents((e) => [
+            ...e,
+            { kind: "info", key: mkKey(), text: "no update available" }
+          ]);
+        }
+        return true;
+      }
+      if (c === "/logout") {
+        unlink(configPath()).catch(() => {
+        });
+        setEvents((e) => [
+          ...e,
+          { kind: "info", key: mkKey(), text: `credentials cleared from ${configPath()}` }
+        ]);
+        setCfg(null);
+        return true;
+      }
+      if (c === "/help") {
+        setEvents((e) => [
+          ...e,
+          {
+            kind: "info",
+            key: mkKey(),
+            text: "commands: /clear /reasoning /cost /model /update /logout /help /exit  \xB7  keys: ctrl-r toggle reasoning, ctrl-c interrupt/exit"
+          }
+        ]);
+        return true;
+      }
+      return false;
+    },
+    [cfg, exit, usage, updateInfo]
+  );
+  const processMessage = useCallback(
+    async (text) => {
+      if (!cfg) return;
+      const trimmed = text.trim();
+      if (!trimmed) return;
+      if (trimmed.startsWith("/") && handleSlash(trimmed)) return;
+      setEvents((e) => [...e, { kind: "user", key: mkKey(), text: trimmed }]);
+      messagesRef.current.push({ role: "user", content: trimmed });
+      setBusy(true);
+      const controller = new AbortController();
+      activeControllerRef.current = controller;
+      try {
+        await runAgentTurn({
+          accountId: cfg.accountId,
+          apiToken: cfg.apiToken,
+          model: cfg.model,
+          messages: messagesRef.current,
+          tools: ALL_TOOLS,
+          executor: executorRef.current,
+          cwd: process.cwd(),
+          signal: controller.signal,
+          callbacks: {
+            onAssistantStart: () => {
+              const id = nextAssistantId++;
+              activeAsstIdRef.current = id;
+              setEvents((e) => [
+                ...e,
+                { kind: "assistant", key: `asst_${id}`, id, text: "", reasoning: "", streaming: true }
+              ]);
+            },
+            onReasoningDelta: (d) => {
+              const id = activeAsstIdRef.current;
+              if (id !== null) updateAssistant(id, (e) => ({ reasoning: e.reasoning + d }));
+            },
+            onTextDelta: (d) => {
+              const id = activeAsstIdRef.current;
+              if (id !== null) updateAssistant(id, (e) => ({ text: e.text + d }));
+            },
+            onAssistantFinal: () => {
+              const id = activeAsstIdRef.current;
+              if (id !== null) updateAssistant(id, () => ({ streaming: false }));
+            },
+            onToolCallFinalized: (call) => {
+              const spec = executorRef.current.list().find((t) => t.name === call.function.name);
+              let renderMeta;
+              try {
+                const args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+                renderMeta = spec?.render?.(args);
+              } catch {
+              }
+              setEvents((e) => [
+                ...e,
+                {
+                  kind: "tool",
+                  key: `tool_${call.id}`,
+                  id: call.id,
+                  name: call.function.name,
+                  args: call.function.arguments,
+                  status: "running",
+                  render: renderMeta,
+                  expanded: false
+                }
+              ]);
+            },
+            onToolResult: (r) => {
+              updateTool(r.tool_call_id, {
+                status: r.ok ? "done" : "error",
+                result: r.content
+              });
+            },
+            onUsage: (u) => setUsage(u),
+            askPermission: (req) => new Promise((resolve2) => {
+              setPerm({ tool: req.tool, args: req.args, resolve: resolve2 });
+            })
+          }
+        });
+      } catch (e) {
+        if (e.name === "AbortError") {
+          setEvents((es) => [...es, { kind: "info", key: mkKey(), text: "(aborted)" }]);
+        } else {
+          setEvents((es) => [
+            ...es,
+            { kind: "error", key: mkKey(), text: e.message ?? String(e) }
+          ]);
+        }
+      } finally {
+        setBusy(false);
+        activeAsstIdRef.current = null;
+        activeControllerRef.current = null;
+      }
+    },
+    [cfg, handleSlash, updateAssistant, updateTool]
+  );
+  useEffect2(() => {
+    if (!busy && queue.length > 0) {
+      const next = queue[0];
+      setQueue((q) => q.slice(1));
+      processMessage(next);
+    }
+  }, [busy, queue, processMessage]);
+  const submit = useCallback(
+    (text) => {
+      const trimmed = text.trim();
+      if (!trimmed) return;
+      if (busy) {
+        setQueue((q) => [...q, trimmed]);
+        setHistory((h) => h.length > 0 && h[h.length - 1] === trimmed ? h : [...h, trimmed]);
+        setInput("");
+        setHistoryIndex(-1);
+        return;
+      }
+      setHistory((h) => h.length > 0 && h[h.length - 1] === trimmed ? h : [...h, trimmed]);
+      setInput("");
+      setHistoryIndex(-1);
+      processMessage(trimmed);
+    },
+    [busy, processMessage]
+  );
+  useEffect2(() => {
+  }, [events]);
+  useEffect2(() => {
+    checkForUpdate().then((result) => {
+      if (result.hasUpdate) {
+        setUpdateInfo(result);
+        setEvents((e) => [
+          ...e,
+          {
+            kind: "info",
+            key: mkKey(),
+            text: `update available: ${result.localVersion} \u2192 ${result.latestVersion}  \xB7  run /update to upgrade`
+          }
+        ]);
+      }
+    });
+  }, []);
+  if (!cfg) {
+    return /* @__PURE__ */ jsx8(
+      Onboarding,
+      {
+        onDone: (newCfg) => {
+          setCfg(newCfg);
+          setEvents((e) => [
+            ...e,
+            { kind: "info", key: mkKey(), text: "configuration saved \u2014 welcome to kimiflare!" }
+          ]);
+        }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(ChatView, { events, showReasoning }),
+    perm ? /* @__PURE__ */ jsx8(
+      PermissionModal,
+      {
+        tool: perm.tool,
+        args: perm.args,
+        onDecide: (d) => {
+          perm.resolve(d);
+          setPerm(null);
+        }
+      }
+    ) : /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", marginTop: 1, children: [
+      queue.length > 0 && /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", marginBottom: 1, children: queue.map((q, i) => /* @__PURE__ */ jsxs6(Text8, { color: "gray", dimColor: true, children: [
+        "\u23F3 ",
+        q
+      ] }, `queue_${i}`)) }),
+      /* @__PURE__ */ jsx8(
+        StatusBar,
+        {
+          model: cfg.model,
+          usage,
+          thinking: busy,
+          hint: busy ? "ctrl-c to interrupt" : "enter to send \xB7 /help"
+        }
+      ),
+      /* @__PURE__ */ jsx8(Box7, { children: busy ? /* @__PURE__ */ jsxs6(Box7, { children: [
+        /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: /* @__PURE__ */ jsx8(Spinner2, { type: "dots" }) }),
+        /* @__PURE__ */ jsx8(Text8, { color: "gray", children: " working\u2026" })
+      ] }) : /* @__PURE__ */ jsxs6(Box7, { children: [
+        /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: "\u203A " }),
+        /* @__PURE__ */ jsx8(
+          CustomTextInput,
+          {
+            value: input,
+            onChange: setInput,
+            onSubmit: submit,
+            onHistoryUp: () => {
+              if (history.length === 0) return;
+              if (historyIndex === -1) {
+                setDraftInput(input);
+                const nextIndex = history.length - 1;
+                setHistoryIndex(nextIndex);
+                setInput(history[nextIndex]);
+              } else {
+                const nextIndex = Math.max(0, historyIndex - 1);
+                setHistoryIndex(nextIndex);
+                setInput(history[nextIndex]);
+              }
+            },
+            onHistoryDown: () => {
+              if (historyIndex === -1) return;
+              const nextIndex = historyIndex + 1;
+              if (nextIndex >= history.length) {
+                setHistoryIndex(-1);
+                setInput(draftInput);
+              } else {
+                setHistoryIndex(nextIndex);
+                setInput(history[nextIndex]);
+              }
+            },
+            onClearQueueItem: (text) => {
+              setQueue((q) => {
+                const idx = q.indexOf(text);
+                if (idx >= 0) {
+                  const next = [...q];
+                  next.splice(idx, 1);
+                  return next;
+                }
+                return q;
+              });
+            }
+          }
+        )
+      ] }) })
+    ] })
+  ] });
+}
+async function renderApp(cfg) {
+  const instance = render(/* @__PURE__ */ jsx8(App, { initialCfg: cfg }));
+  await instance.waitUntilExit();
+}
+var nextAssistantId, nextKey, mkKey;
+var init_app = __esm({
+  "src/app.tsx"() {
+    "use strict";
+    init_loop();
+    init_system_prompt();
+    init_executor();
+    init_chat();
+    init_status();
+    init_permission();
+    init_text_input();
+    init_update_check();
+    init_onboarding();
+    init_config();
+    nextAssistantId = 1;
+    nextKey = 1;
+    mkKey = () => `evt_${nextKey++}`;
+  }
+});
+
+// src/index.tsx
+init_config();
+init_loop();
+init_system_prompt();
+init_executor();
+import { Command } from "commander";
+var program = new Command();
+program.name("kimiflare").description("Terminal coding agent powered by Kimi-K2.6 on Cloudflare Workers AI.").version("0.1.0").option("-p, --print <prompt>", "one-shot mode: send prompt, stream reply to stdout, exit").option("-m, --model <id>", "model id (defaults to @cf/moonshotai/kimi-k2.6)").option("--dangerously-allow-all", "auto-approve every permission prompt (print mode only)").option("--reasoning", "include reasoning in stdout (print mode only)").parse();
+var opts = program.opts();
+async function main() {
+  const cfg = await loadConfig();
+  if (opts.print !== void 0) {
+    if (!cfg) {
+      console.error(
+        'kimiflare: missing credentials.\nSet CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN, or write them to\n  ~/.config/kimiflare/config.json  (chmod 600)\n  { "accountId": "...", "apiToken": "...", "model": "@cf/moonshotai/kimi-k2.6" }'
+      );
+      process.exit(2);
+    }
+    const model = opts.model ?? cfg.model ?? DEFAULT_MODEL;
+    await runPrintMode({
+      ...cfg,
+      model,
+      prompt: opts.print,
+      allowAll: !!opts.dangerouslyAllowAll,
+      showReasoning: !!opts.reasoning
+    });
+    return;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.error(
+      'kimiflare: interactive mode requires a TTY. Use `kimiflare -p "..."` for non-TTY / piped usage.'
+    );
+    process.exit(2);
+  }
+  const { renderApp: renderApp2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+  if (cfg) {
+    const model = opts.model ?? cfg.model ?? DEFAULT_MODEL;
+    await renderApp2({ ...cfg, model });
+  } else {
+    await renderApp2(null);
+  }
+}
+async function runPrintMode(opts2) {
+  const cwd = process.cwd();
+  const executor = new ToolExecutor(ALL_TOOLS);
+  const messages = [
+    { role: "system", content: buildSystemPrompt({ cwd, tools: ALL_TOOLS, model: opts2.model }) },
+    { role: "user", content: opts2.prompt }
+  ];
+  const controller = new AbortController();
+  process.on("SIGINT", () => controller.abort());
+  let printedReasoningHeader = false;
+  let printedAnswerHeader = false;
+  await runAgentTurn({
+    accountId: opts2.accountId,
+    apiToken: opts2.apiToken,
+    model: opts2.model,
+    messages,
+    tools: ALL_TOOLS,
+    executor,
+    cwd,
+    signal: controller.signal,
+    callbacks: {
+      onReasoningDelta: opts2.showReasoning ? (delta) => {
+        if (!printedReasoningHeader) {
+          process.stderr.write("\x1B[2m--- reasoning ---\n");
+          printedReasoningHeader = true;
+        }
+        process.stderr.write(delta);
+      } : void 0,
+      onTextDelta: (delta) => {
+        if (opts2.showReasoning && printedReasoningHeader && !printedAnswerHeader) {
+          process.stderr.write("\n--- answer ---\x1B[0m\n");
+          printedAnswerHeader = true;
+        }
+        process.stdout.write(delta);
+      },
+      onToolCallFinalized: (call) => {
+        process.stderr.write(`\x1B[2m[tool ${call.function.name}(${call.function.arguments})]\x1B[0m
+`);
+      },
+      onToolResult: (result) => {
+        const snippet = result.content.length > 400 ? result.content.slice(0, 400) + "..." : result.content;
+        process.stderr.write(`\x1B[2m[result: ${snippet.replace(/\n/g, " \u23CE ")}]\x1B[0m
+`);
+      },
+      askPermission: async ({ tool, args }) => {
+        if (opts2.allowAll) return "allow";
+        process.stderr.write(
+          `\x1B[31m[permission denied: ${tool.name}(${JSON.stringify(args)}) \u2014 pass --dangerously-allow-all to approve in print mode]\x1B[0m
+`
+        );
+        return "deny";
+      }
+    }
+  });
+  process.stdout.write("\n");
+}
+main().catch((e) => {
+  console.error(`kimiflare: ${e instanceof Error ? e.message : String(e)}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map