@cryer/star-cli 0.3.8 → 0.3.9

package/dist/chunk-A5PXPWHB.js

@@ -0,0 +1,2014 @@
+#!/usr/bin/env node
+
+// src/agent/agent-tasks.ts
+import { EventEmitter } from "events";
+var MAX_FINISHED_RECORDS = 50;
+var AgentTaskManager = class extends EventEmitter {
+  records = /* @__PURE__ */ new Map();
+  counter = 0;
+  start(run, meta) {
+    const id = `agent-${++this.counter}`;
+    const rec = {
+      id,
+      prompt: meta.prompt,
+      description: meta.description,
+      status: "running",
+      startedAt: Date.now(),
+      result: "",
+      controller: new AbortController(),
+      notified: false
+    };
+    this.records.set(id, rec);
+    void run(rec.controller.signal).then((result) => this.finish(rec, "completed", result)).catch(
+      (error) => this.finish(rec, "failed", error instanceof Error ? error.message : String(error))
+    );
+    this.emitUpdate(rec);
+    return this.snapshot(rec);
+  }
+  get(id) {
+    const rec = this.records.get(id);
+    return rec ? this.snapshot(rec) : void 0;
+  }
+  list() {
+    return [...this.records.values()].map((rec) => this.snapshot(rec));
+  }
+  runningCount() {
+    let count = 0;
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") count += 1;
+    }
+    return count;
+  }
+  kill(id) {
+    const rec = this.records.get(id);
+    if (!rec || rec.status !== "running") return void 0;
+    rec.controller.abort();
+    this.finish(rec, "stopped", rec.result || "Stopped by user.");
+    return this.snapshot(rec);
+  }
+  cleanup() {
+    const killed = [];
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") {
+        rec.controller.abort();
+        this.finish(rec, "stopped", rec.result || "Stopped on shutdown.");
+        killed.push(this.snapshot(rec));
+      }
+    }
+    return killed;
+  }
+  // Finished tasks whose result has not yet been handed to the parent loop.
+  drainNotifications() {
+    const drained = [];
+    for (const rec of this.records.values()) {
+      if (rec.status !== "running" && !rec.notified) {
+        rec.notified = true;
+        drained.push(this.snapshot(rec));
+      }
+    }
+    this.pruneFinished();
+    return drained;
+  }
+  // Map iteration is insertion-ordered, so the first finished records met are
+  // the oldest. Never drop an un-notified record: the parent has not seen its
+  // result yet. Running records are untouched.
+  pruneFinished() {
+    let finished = 0;
+    for (const rec of this.records.values()) {
+      if (rec.status !== "running") finished += 1;
+    }
+    let excess = finished - MAX_FINISHED_RECORDS;
+    if (excess <= 0) return;
+    for (const rec of this.records.values()) {
+      if (excess <= 0) return;
+      if (rec.status !== "running" && rec.notified) {
+        this.records.delete(rec.id);
+        excess -= 1;
+      }
+    }
+  }
+  finish(rec, status, result) {
+    if (rec.status !== "running") return;
+    rec.status = status;
+    rec.result = result;
+    rec.endedAt = Date.now();
+    this.emitUpdate(rec);
+  }
+  emitUpdate(rec) {
+    this.emit("update", this.snapshot(rec));
+  }
+  snapshot(rec) {
+    return {
+      id: rec.id,
+      prompt: rec.prompt,
+      description: rec.description,
+      status: rec.status,
+      startedAt: rec.startedAt,
+      endedAt: rec.endedAt,
+      result: rec.result
+    };
+  }
+};
+var defaultAgentTasks = new AgentTaskManager();
+function formatAgentTaskUpdate(task) {
+  const label = task.description ? `: ${task.description}` : "";
+  if (task.status === "running") {
+    return `Background subagent ${task.id} started${label}`;
+  }
+  let text = `Background subagent ${task.id} ${task.status}${label}`;
+  if (task.status === "failed") {
+    const reason = (task.result.split("\n")[0] ?? "").replace(/^Subagent failed:\s*/, "");
+    if (reason) {
+      text += ` \u2014 ${reason.length > 140 ? `${reason.slice(0, 140)}\u2026` : reason}`;
+    }
+  }
+  return text;
+}
+
+// src/core/http-error.ts
+function responseBodyOf(error) {
+  const body = error.responseBody;
+  return typeof body === "string" && body.length > 0 ? body : void 0;
+}
+
+// src/core/image.ts
+var MAX_IMAGE_DIMENSION = 2e3;
+var OVERSIZED_IMAGE_FALLBACK_BYTES = 5 * 1024 * 1024;
+var IMAGE_REMOVED_PLACEHOLDER = "[image removed: too large for the model]";
+var IMAGE_UNSUPPORTED_PLACEHOLDER = "[image removed: the model cannot read images]";
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function probePng(buf) {
+  if (buf.length < 24) return null;
+  for (let i = 0; i < PNG_SIGNATURE.length; i++) {
+    if (buf[i] !== PNG_SIGNATURE[i]) return null;
+  }
+  if (buf.toString("ascii", 12, 16) !== "IHDR") return null;
+  return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+}
+var JPEG_SOF_MARKERS = /* @__PURE__ */ new Set([
+  192,
+  193,
+  194,
+  195,
+  197,
+  198,
+  199,
+  201,
+  202,
+  203,
+  205,
+  206,
+  207
+]);
+function probeJpeg(buf) {
+  if (buf.length < 4 || buf[0] !== 255 || buf[1] !== 216) return null;
+  let offset = 2;
+  while (offset + 3 < buf.length) {
+    if (buf[offset] !== 255) return null;
+    const marker = buf[offset + 1];
+    if (marker === void 0) return null;
+    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+      offset += 2;
+      continue;
+    }
+    const length = buf.readUInt16BE(offset + 2);
+    if (length < 2) return null;
+    if (JPEG_SOF_MARKERS.has(marker)) {
+      if (offset + 9 > buf.length) return null;
+      return { height: buf.readUInt16BE(offset + 5), width: buf.readUInt16BE(offset + 7) };
+    }
+    offset += 2 + length;
+  }
+  return null;
+}
+function probeGif(buf) {
+  if (buf.length < 10) return null;
+  const signature = buf.toString("ascii", 0, 6);
+  if (signature !== "GIF87a" && signature !== "GIF89a") return null;
+  return { width: buf.readUInt16LE(6), height: buf.readUInt16LE(8) };
+}
+function probeWebp(buf) {
+  if (buf.length < 30) return null;
+  if (buf.toString("ascii", 0, 4) !== "RIFF" || buf.toString("ascii", 8, 12) !== "WEBP") {
+    return null;
+  }
+  const chunk = buf.toString("ascii", 12, 16);
+  if (chunk === "VP8X") {
+    return { width: 1 + buf.readUIntLE(24, 3), height: 1 + buf.readUIntLE(27, 3) };
+  }
+  if (chunk === "VP8 ") {
+    return {
+      width: buf.readUInt16LE(26) & 16383,
+      height: buf.readUInt16LE(28) & 16383
+    };
+  }
+  if (chunk === "VP8L") {
+    if (buf[20] !== 47) return null;
+    const b1 = buf[21];
+    const b2 = buf[22];
+    const b3 = buf[23];
+    const b4 = buf[24];
+    return {
+      width: 1 + ((b2 & 63) << 8 | b1),
+      height: 1 + ((b4 & 15) << 10 | b3 << 2 | (b2 & 192) >> 6)
+    };
+  }
+  return null;
+}
+function probeImageDimensions(buf) {
+  return probePng(buf) ?? probeJpeg(buf) ?? probeGif(buf) ?? probeWebp(buf);
+}
+var IMAGE_SIZE_KEYWORDS = /too[\s-]*(large|big)|exceeds?|dimensions?|resolution|size\s*limit|max(?:imum)?[\s-]*size/i;
+function isOversizedImageError(error) {
+  const status = error.statusCode;
+  if (status === void 0 || status < 400 || status >= 500) return false;
+  const text = [error.message, responseBodyOf(error)].filter((part) => typeof part === "string").join("\n");
+  return /image/i.test(text) && IMAGE_SIZE_KEYWORDS.test(text);
+}
+var VISION_UNSUPPORTED_KEYWORDS = /vision\s*encoder|can(?:not|'t) (?:read|process|handle|accept) images?|does(?:\s*not|n't) support (?:image|vision|multimodal)|images?(?:\s*input)? (?:are|is) not supported|not a vision|no vision (?:capability|support|encoder)|multimodal(?:\s*input)? (?:is )?not supported/i;
+function isVisionUnsupportedError(error) {
+  const status = error.statusCode;
+  if (status === void 0 || status < 400 || status >= 500) return false;
+  const text = [error.message, responseBodyOf(error)].filter((part) => typeof part === "string").join("\n");
+  return /image|vision|multimodal/i.test(text) && VISION_UNSUPPORTED_KEYWORDS.test(text);
+}
+function imagePartBytes(image) {
+  if (typeof image === "string") {
+    const base64 = image.startsWith("data:") ? image.slice(image.indexOf(",") + 1) : image;
+    try {
+      return Buffer.from(base64, "base64");
+    } catch {
+      return null;
+    }
+  }
+  if (image instanceof Uint8Array) return Buffer.from(image);
+  return null;
+}
+function isOversizedImageData(buf) {
+  const dims = probeImageDimensions(buf);
+  if (dims) return Math.max(dims.width, dims.height) > MAX_IMAGE_DIMENSION;
+  return buf.length > OVERSIZED_IMAGE_FALLBACK_BYTES;
+}
+function stripOversizedImages(messages) {
+  let removed = 0;
+  const result = messages.map((message) => {
+    if (!Array.isArray(message.content)) return message;
+    let changed = false;
+    const content = message.content.map((part) => {
+      if (part.type !== "image") return part;
+      const bytes = imagePartBytes(part.image);
+      if (!bytes || !isOversizedImageData(bytes)) return part;
+      changed = true;
+      removed++;
+      return { type: "text", text: IMAGE_REMOVED_PLACEHOLDER };
+    });
+    return changed ? { ...message, content } : message;
+  });
+  return { messages: removed > 0 ? result : messages, removed };
+}
+function stripAllImages(messages) {
+  let removed = 0;
+  const result = messages.map((message) => {
+    if (!Array.isArray(message.content)) return message;
+    let changed = false;
+    const content = message.content.map((part) => {
+      if (part.type !== "image") return part;
+      changed = true;
+      removed++;
+      return { type: "text", text: IMAGE_UNSUPPORTED_PLACEHOLDER };
+    });
+    return changed ? { ...message, content } : message;
+  });
+  return { messages: removed > 0 ? result : messages, removed };
+}
+
+// src/config/paths.ts
+import os from "os";
+import path from "path";
+function starHome() {
+  return process.env.STAR_HOME ?? path.join(os.homedir(), ".star-cli");
+}
+function globalConfigPath() {
+  return path.join(starHome(), "config.toml");
+}
+function sessionsDir() {
+  return path.join(starHome(), "sessions");
+}
+function userMemoryPath() {
+  return path.join(starHome(), "MEMORY.md");
+}
+function gitTreesDir() {
+  return path.join(starHome(), "git-trees");
+}
+function envFilePath() {
+  return path.join(starHome(), ".env");
+}
+function projectConfigPath(cwd) {
+  return path.join(cwd, ".star", "config.toml");
+}
+
+// src/tasks/manager.ts
+import { spawn as spawn2 } from "child_process";
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/tools/bash.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import path2 from "path";
+import { z } from "zod";
+
+// src/config/env.ts
+import fs from "fs";
+var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseEnvContent(content) {
+  const vars = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!ENV_KEY_PATTERN.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+var envFileKeySet = /* @__PURE__ */ new Set();
+function getEnvFileKeys() {
+  return envFileKeySet;
+}
+function loadEnvFile(filePath = envFilePath()) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return;
+  }
+  for (const [key, value] of Object.entries(parseEnvContent(content))) {
+    envFileKeySet.add(key);
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+function upsertEnvContent(content, key, value) {
+  const entry = `${key}=${value.replace(/[\r\n]/g, "")}`;
+  const pattern = new RegExp(`^\\s*${key}\\s*=`);
+  const lines = content.split("\n");
+  while (lines.length > 0 && (lines[lines.length - 1] ?? "").trim() === "") lines.pop();
+  for (let i = 0; i < lines.length; i++) {
+    if (pattern.test(lines[i] ?? "")) {
+      lines[i] = entry;
+      return `${lines.join("\n")}
+`;
+    }
+  }
+  lines.push(entry);
+  return `${lines.join("\n")}
+`;
+}
+
+// src/tools/bash.ts
+var MAX_OUTPUT = 3e4;
+var HALF_OUTPUT = MAX_OUTPUT / 2;
+var DEFAULT_TIMEOUT = 120;
+var MAX_TIMEOUT = 600;
+function findOnPath(exe, exclude) {
+  for (const dir of (process.env.PATH ?? "").split(path2.delimiter)) {
+    if (!dir || exclude?.(dir)) {
+      continue;
+    }
+    const full = path2.join(dir, exe);
+    if (existsSync(full)) {
+      return full;
+    }
+  }
+  return null;
+}
+function resolveShellUncached() {
+  if (process.platform !== "win32") {
+    return { shell: "sh", wrap: (c) => ["-c", c], label: "sh" };
+  }
+  const isWslStub = (dir) => /\\(system32|windowsapps)\\?$/i.test(dir.trim());
+  const fromPath = findOnPath("bash.exe", isWslStub);
+  if (fromPath) {
+    return { shell: fromPath, wrap: (c) => ["-c", c], label: "bash" };
+  }
+  const gitExe = findOnPath("git.exe");
+  if (gitExe) {
+    const sibling = path2.join(path2.dirname(path2.dirname(gitExe)), "bin", "bash.exe");
+    if (existsSync(sibling)) {
+      return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of [
+    process.env.ProgramFiles,
+    process.env["ProgramFiles(x86)"],
+    process.env.ProgramW6432
+  ]) {
+    if (!root) continue;
+    const candidate = path2.join(root, "Git", "bin", "bash.exe");
+    const key = candidate.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (existsSync(candidate)) {
+      return { shell: candidate, wrap: (c) => ["-c", c], label: "bash" };
+    }
+  }
+  const comspec = process.env.ComSpec ?? "cmd.exe";
+  return { shell: comspec, wrap: (c) => ["/d", "/s", "/c", c], label: "cmd" };
+}
+var cachedSpec = null;
+function resolveShell() {
+  if (!cachedSpec) {
+    cachedSpec = resolveShellUncached();
+  }
+  return cachedSpec;
+}
+var schema = z.object({
+  command: z.string().describe("Shell command to execute"),
+  timeout: z.number().positive().max(MAX_TIMEOUT).optional().describe("Timeout in seconds (default 120, max 600)"),
+  description: z.string().optional().describe("Short description of what the command does"),
+  run_in_background: z.boolean().optional().describe(
+    "Run the command in the background and return a task id immediately (default false). Use task_output/task_kill to inspect or stop it."
+  )
+});
+function killTree(child) {
+  if (process.platform === "win32") {
+    if (child.pid) {
+      spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+        windowsHide: true,
+        stdio: "ignore"
+      }).unref();
+    }
+    return;
+  }
+  if (child.pid) {
+    try {
+      process.kill(-child.pid, "SIGKILL");
+      return;
+    } catch {
+    }
+  }
+  child.kill("SIGKILL");
+}
+var BoundedOutput = class {
+  head = Buffer.alloc(0);
+  tail = Buffer.alloc(0);
+  dropped = 0;
+  overflow = false;
+  append(chunk) {
+    if (!this.overflow) {
+      this.head = this.head.length === 0 ? chunk : Buffer.concat([this.head, chunk]);
+      if (this.head.length <= MAX_OUTPUT) {
+        return;
+      }
+      this.overflow = true;
+      this.tail = this.head.subarray(HALF_OUTPUT);
+      this.head = this.head.subarray(0, HALF_OUTPUT);
+      if (this.tail.length > HALF_OUTPUT) {
+        this.dropped = this.tail.length - HALF_OUTPUT;
+        this.tail = this.tail.subarray(this.tail.length - HALF_OUTPUT);
+      }
+      return;
+    }
+    this.tail = this.tail.length === 0 ? chunk : Buffer.concat([this.tail, chunk]);
+    if (this.tail.length > HALF_OUTPUT) {
+      this.dropped += this.tail.length - HALF_OUTPUT;
+      this.tail = this.tail.subarray(this.tail.length - HALF_OUTPUT);
+    }
+  }
+  toString() {
+    if (!this.overflow) {
+      return decodeOutput(this.head);
+    }
+    const head = decodeOutput(trimUtf8End(this.head));
+    const tail = decodeOutput(trimUtf8Start(this.tail));
+    return `${head}
+... [${this.dropped} bytes truncated] ...
+${tail}`;
+  }
+};
+function trimUtf8End(buf) {
+  let cont = 0;
+  let i = buf.length;
+  while (i > 0 && cont < 3 && ((buf[i - 1] ?? 0) & 192) === 128) {
+    i--;
+    cont++;
+  }
+  if (i === 0) return buf;
+  const lead = buf[i - 1] ?? 0;
+  if (lead < 128 || (lead & 192) === 128) return buf;
+  const needed = lead < 224 ? 1 : lead < 240 ? 2 : 3;
+  return cont < needed ? buf.subarray(0, i - 1) : buf;
+}
+function trimUtf8Start(buf) {
+  let i = 0;
+  while (i < buf.length && i < 3 && ((buf[i] ?? 0) & 192) === 128) i++;
+  return i === 0 ? buf : buf.subarray(i);
+}
+function decodeOutput(buf, platform = process.platform) {
+  const text = buf.toString("utf8");
+  if (platform === "win32" && text.includes("\uFFFD")) {
+    try {
+      return new TextDecoder("gbk").decode(buf);
+    } catch {
+      return text;
+    }
+  }
+  return text;
+}
+function childEnv() {
+  const env = { ...process.env };
+  for (const key of getEnvFileKeys()) {
+    delete env[key];
+  }
+  return env;
+}
+var bashTool = {
+  name: "bash",
+  description: "Execute a shell command (Git Bash on Windows when available, otherwise cmd; sh elsewhere). Stdout and stderr are merged. Output is truncated to 30000 bytes. Set run_in_background for long-running commands; it returns a task id for task_list/task_output/task_kill.",
+  permission: "exec",
+  parameters: schema,
+  execute(args, ctx) {
+    if (args.run_in_background) {
+      const task = defaultTaskManager.start({
+        command: args.command,
+        description: args.description,
+        cwd: ctx.cwd,
+        timeoutSeconds: args.timeout,
+        ownerId: ctx.agentId ?? "root",
+        env: childEnv()
+      });
+      return Promise.resolve({
+        content: `Background task started: ${task.id}
+command: ${args.command}
+description: ${args.description ?? "(none)"}`
+      });
+    }
+    const timeoutSeconds = Math.min(args.timeout ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
+    const spec = resolveShell();
+    return new Promise((resolve) => {
+      const child = spawn(spec.shell, spec.wrap(args.command), {
+        cwd: ctx.cwd,
+        env: childEnv(),
+        windowsHide: true,
+        detached: process.platform !== "win32",
+        // No stdin: a command that reads it (cat, read, input()) must get
+        // EOF immediately instead of hanging until the timeout.
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const output = new BoundedOutput();
+      let settled = false;
+      const finish = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        ctx.abortSignal?.removeEventListener("abort", onAbort);
+        resolve(result);
+      };
+      const onAbort = () => {
+        killTree(child);
+        finish({ content: `${output}
+Command aborted`, isError: true });
+      };
+      const timer = setTimeout(() => {
+        killTree(child);
+        finish({
+          content: `${output}
+Command timed out after ${timeoutSeconds}s`,
+          isError: true
+        });
+      }, timeoutSeconds * 1e3);
+      timer.unref();
+      child.stdout.on("data", (d) => output.append(d));
+      child.stderr.on("data", (d) => output.append(d));
+      child.on("error", (err) => {
+        finish({ content: `Failed to start shell '${spec.label}': ${err.message}`, isError: true });
+      });
+      ctx.abortSignal?.addEventListener("abort", onAbort);
+      child.on("close", (code) => {
+        const trimmed = output.toString().replace(/\s+$/, "");
+        if (code === 0) {
+          finish({ content: trimmed || "(no output)" });
+          return;
+        }
+        finish({
+          content: `${trimmed}${trimmed ? "\n" : ""}Exit code: ${code ?? "unknown"}`,
+          isError: true
+        });
+      });
+    });
+  }
+};
+
+// src/tasks/manager.ts
+var MAX_TASK_OUTPUT = 1e5;
+var DEFAULT_TASK_TIMEOUT = 3600;
+var MAX_FINISHED_RECORDS2 = 50;
+var TRUNCATED_PREFIX = "[... earlier output truncated ...]\n";
+var TaskManager = class extends EventEmitter2 {
+  records = /* @__PURE__ */ new Map();
+  seq = 0;
+  start(opts) {
+    const id = `task-${++this.seq}`;
+    const spec = resolveShell();
+    const child = spawn2(spec.shell, spec.wrap(opts.command), {
+      cwd: opts.cwd,
+      env: opts.env ?? childEnv(),
+      windowsHide: true,
+      // No stdin: background commands that read it would hang until the
+      // (much longer) task timeout; give them EOF immediately.
+      stdio: ["ignore", "pipe", "pipe"],
+      // POSIX: the child leads its own process group so killTree can SIGKILL
+      // the whole tree with a negative pid (Windows uses taskkill /t).
+      detached: process.platform !== "win32"
+    });
+    const rec = {
+      id,
+      ownerId: opts.ownerId ?? "root",
+      command: opts.command,
+      description: opts.description,
+      status: "running",
+      startedAt: Date.now(),
+      outputChunks: [],
+      outputBytes: 0,
+      truncated: false,
+      child
+    };
+    this.records.set(id, rec);
+    const append = (d) => {
+      rec.outputChunks.push(d);
+      rec.outputBytes += d.length;
+      if (rec.outputBytes > MAX_TASK_OUTPUT) {
+        const merged = Buffer.concat(rec.outputChunks, rec.outputBytes);
+        const kept = trimUtf8Start(merged.subarray(merged.length - MAX_TASK_OUTPUT));
+        rec.outputChunks = [kept];
+        rec.outputBytes = kept.length;
+        rec.truncated = true;
+      }
+    };
+    child.stdout.on("data", append);
+    child.stderr.on("data", append);
+    child.on("error", (err) => {
+      append(Buffer.from(`Failed to start shell '${spec.label}': ${err.message}
+`));
+      if (rec.status === "running") {
+        this.finish(rec, "failed", null);
+      }
+    });
+    child.on("close", (code) => {
+      if (rec.status !== "running") return;
+      this.finish(rec, code === 0 ? "completed" : "failed", code);
+    });
+    const timeoutSeconds = opts.timeoutSeconds ?? DEFAULT_TASK_TIMEOUT;
+    rec.timer = setTimeout(() => this.terminate(rec, "timed_out"), timeoutSeconds * 1e3);
+    rec.timer.unref();
+    this.emitUpdate(rec);
+    return this.snapshot(rec);
+  }
+  get(id) {
+    const rec = this.records.get(id);
+    return rec ? this.snapshot(rec) : void 0;
+  }
+  list() {
+    return [...this.records.values()].map((rec) => this.snapshot(rec));
+  }
+  runningCount() {
+    let count = 0;
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") count += 1;
+    }
+    return count;
+  }
+  kill(id) {
+    const rec = this.records.get(id);
+    if (!rec || rec.status !== "running") return void 0;
+    this.terminate(rec, "stopped");
+    return this.snapshot(rec);
+  }
+  cleanup() {
+    const killed = [];
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") {
+        this.terminate(rec, "stopped");
+        killed.push(this.snapshot(rec));
+      }
+    }
+    return killed;
+  }
+  terminate(rec, status) {
+    killTree(rec.child);
+    this.finish(rec, status, null);
+  }
+  finish(rec, status, exitCode) {
+    if (rec.timer) clearTimeout(rec.timer);
+    rec.status = status;
+    rec.exitCode = exitCode;
+    rec.endedAt = Date.now();
+    this.pruneFinished();
+    this.emitUpdate(rec);
+  }
+  pruneFinished() {
+    const finished = [...this.records.values()].filter((rec) => rec.status !== "running");
+    if (finished.length <= MAX_FINISHED_RECORDS2) return;
+    finished.sort((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0));
+    for (const rec of finished.slice(0, finished.length - MAX_FINISHED_RECORDS2)) {
+      this.records.delete(rec.id);
+    }
+  }
+  emitUpdate(rec) {
+    this.emit("update", this.snapshot(rec));
+  }
+  snapshot(rec) {
+    const output = decodeOutput(Buffer.concat(rec.outputChunks, rec.outputBytes));
+    return {
+      id: rec.id,
+      ownerId: rec.ownerId,
+      command: rec.command,
+      description: rec.description,
+      status: rec.status,
+      startedAt: rec.startedAt,
+      endedAt: rec.endedAt,
+      exitCode: rec.exitCode,
+      output: rec.truncated ? TRUNCATED_PREFIX + output : output
+    };
+  }
+};
+var defaultTaskManager = new TaskManager();
+
+// src/tools/fs/snapshots.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rm, stat, writeFile } from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+var MAX_SNAPSHOTS = 50;
+var MAX_SNAPSHOT_CONTENT_BYTES = 5 * 1024 * 1024;
+var stack = [];
+var activeTurn = 0;
+var activeTurnMessageIndex = -1;
+var checkpointSeq = 0;
+var hooks = null;
+var spillDir = path3.join(
+  os2.tmpdir(),
+  `star-cli-snapshots-${process.pid}-${randomUUID().slice(0, 8)}`
+);
+function isSpillPath(p) {
+  return p.startsWith(spillDir + path3.sep);
+}
+async function spillContent(snapshot) {
+  if (snapshot.content === null || snapshot.contentFile) return;
+  try {
+    const file = path3.join(spillDir, `${snapshot.id}.snap`);
+    await mkdir(spillDir, { recursive: true, mode: 448 });
+    await writeFile(file, snapshot.content, { mode: 384 });
+    snapshot.contentFile = file;
+    snapshot.content = null;
+  } catch {
+  }
+}
+async function discardSpill(snapshot) {
+  if (snapshot.contentFile && isSpillPath(snapshot.contentFile)) {
+    await rm(snapshot.contentFile, { force: true }).catch(() => {
+    });
+  }
+}
+function setSnapshotHooks(next) {
+  hooks = next;
+}
+function nextSnapshotId() {
+  return ++checkpointSeq;
+}
+function beginTurn(messageIndex = -1) {
+  activeTurnMessageIndex = messageIndex;
+  return ++activeTurn;
+}
+function currentTurnSeq() {
+  return activeTurn;
+}
+function currentTurnMessageIndex() {
+  return activeTurnMessageIndex;
+}
+function ownerOf(snapshot) {
+  return snapshot.owner ?? "root";
+}
+async function captureSnapshot(filePath, toolName, snapshotContext) {
+  let content = null;
+  let existed = false;
+  let contentTooLarge = false;
+  const st = await stat(filePath).catch(() => null);
+  if (st?.isFile()) {
+    existed = true;
+    if (st.size > MAX_SNAPSHOT_CONTENT_BYTES) {
+      contentTooLarge = true;
+    } else {
+      try {
+        content = await readFile(filePath);
+      } catch {
+        existed = false;
+      }
+    }
+  }
+  return {
+    id: nextSnapshotId(),
+    path: filePath,
+    existed,
+    content,
+    contentTooLarge: contentTooLarge || void 0,
+    toolName,
+    timestamp: Date.now(),
+    turn: snapshotContext?.turn ?? activeTurn,
+    messageIndex: snapshotContext?.messageIndex ?? activeTurnMessageIndex,
+    owner: snapshotContext?.owner ?? "root"
+  };
+}
+async function pushSnapshot(snapshot) {
+  stack.push(snapshot);
+  try {
+    await hooks?.onPush?.(snapshot);
+  } catch (err) {
+    if (process.env.STAR_DEBUG) {
+      console.error("[star] failed to persist snapshot checkpoint:", err);
+    }
+  }
+  await spillContent(snapshot);
+  if (stack.length > MAX_SNAPSHOTS) {
+    const evicted = stack.splice(0, stack.length - MAX_SNAPSHOTS);
+    for (const old of evicted) await discardSpill(old);
+    await removeFromStore(evicted.map((s) => s.id));
+  }
+}
+async function removeFromStore(ids) {
+  if (ids.length > 0) await hooks?.onRemove?.(ids);
+}
+function listSnapshots() {
+  return [...stack];
+}
+function clearSnapshots() {
+  for (const snapshot of stack) void discardSpill(snapshot);
+  stack.length = 0;
+}
+function hydrateSnapshots(snapshots) {
+  for (const snapshot of stack) void discardSpill(snapshot);
+  stack.length = 0;
+  stack.push(...snapshots.slice(-MAX_SNAPSHOTS));
+  for (const snapshot of stack) {
+    if (snapshot.id > checkpointSeq) checkpointSeq = snapshot.id;
+  }
+}
+async function resolveContent(snapshot) {
+  if (snapshot.content !== null) return snapshot.content;
+  if (!snapshot.contentFile) return null;
+  try {
+    return await readFile(snapshot.contentFile);
+  } catch {
+    return null;
+  }
+}
+async function revert(snapshot) {
+  if (snapshot.existed) {
+    if (snapshot.contentTooLarge) {
+      return `Skipped ${snapshot.path}: content too large, not restored.`;
+    }
+    const content = await resolveContent(snapshot);
+    if (content === null) {
+      return `Skipped ${snapshot.path}: the snapshot content is no longer available.`;
+    }
+    await mkdir(path3.dirname(snapshot.path), { recursive: true });
+    await writeFile(snapshot.path, content);
+    return `Restored ${snapshot.path} to its state before ${snapshot.toolName}.`;
+  }
+  await rm(snapshot.path, { force: true });
+  return `Deleted ${snapshot.path} (it did not exist before ${snapshot.toolName}).`;
+}
+function listTurnSnapshots(turn, includeSubagent = false) {
+  return stack.filter(
+    (snapshot) => snapshot.turn === turn && (includeSubagent || ownerOf(snapshot) === "root")
+  ).reverse();
+}
+async function resolveSnapshotContent(snapshot) {
+  const content = await resolveContent(snapshot);
+  if (content === null) return null;
+  return typeof content === "string" ? content : content.toString("utf8");
+}
+async function undoTurnSnapshots(turn, includeSubagent = false) {
+  const matches = [];
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const snapshot = stack[i];
+    if (snapshot && snapshot.turn === turn && (includeSubagent || ownerOf(snapshot) === "root")) {
+      matches.push(snapshot);
+    }
+  }
+  const messages = [];
+  const revertedIds = [];
+  for (const snapshot of matches) {
+    try {
+      messages.push(await revert(snapshot));
+      const idx = stack.indexOf(snapshot);
+      if (idx >= 0) stack.splice(idx, 1);
+      revertedIds.push(snapshot.id);
+      await discardSpill(snapshot);
+    } catch (err) {
+      messages.push(
+        `Failed to revert ${snapshot.path}: ${err.message} (checkpoint kept)`
+      );
+    }
+  }
+  await removeFromStore(revertedIds);
+  return messages;
+}
+async function dropTurnSnapshots(turn, includeSubagent = false) {
+  const dropped = [];
+  const droppedSnapshots = [];
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const snapshot = stack[i];
+    if (snapshot && snapshot.turn === turn && (includeSubagent || ownerOf(snapshot) === "root")) {
+      dropped.push(snapshot.id);
+      droppedSnapshots.push(snapshot);
+      stack.splice(i, 1);
+    }
+  }
+  for (const snapshot of droppedSnapshots) await discardSpill(snapshot);
+  await removeFromStore(dropped);
+  return dropped.length;
+}
+async function rewindToSnapshot(id, includeSubagent = false) {
+  if (!stack.some((snapshot) => snapshot.id === id)) return null;
+  const matches = [];
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const snapshot = stack[i];
+    if (snapshot && snapshot.id >= id && (includeSubagent || ownerOf(snapshot) === "root")) {
+      matches.push(snapshot);
+    }
+  }
+  const reverted = [];
+  const revertedIds = [];
+  let messageIndex = null;
+  for (const snapshot of matches) {
+    try {
+      reverted.push(await revert(snapshot));
+      const idx = stack.indexOf(snapshot);
+      if (idx >= 0) stack.splice(idx, 1);
+      revertedIds.push(snapshot.id);
+      await discardSpill(snapshot);
+      if (snapshot.messageIndex >= 0) {
+        messageIndex = messageIndex === null ? snapshot.messageIndex : Math.min(messageIndex, snapshot.messageIndex);
+      }
+    } catch (err) {
+      reverted.push(
+        `Failed to revert ${snapshot.path}: ${err.message} (checkpoint kept)`
+      );
+    }
+  }
+  await removeFromStore(revertedIds);
+  return { reverted, messageIndex };
+}
+
+// src/tools/todo.ts
+import { mkdir as mkdir2, readFile as readFile2, rename, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
+import { z as z2 } from "zod";
+var todoItemSchema = z2.object({
+  id: z2.number().int(),
+  title: z2.string(),
+  status: z2.enum(["pending", "in_progress", "done"])
+});
+var fileSchema = z2.object({
+  sessionId: z2.string().nullable(),
+  items: z2.array(todoItemSchema)
+});
+var writeSchema = z2.object({
+  todos: z2.array(todoItemSchema).describe("The full todo list, replacing the current one")
+});
+var readSchema = z2.object({});
+function fileFor(cwd) {
+  return path4.join(cwd, ".star", "todos.json");
+}
+var persistGuard = () => true;
+function setTodoPersistGuard(guard) {
+  persistGuard = guard;
+}
+var boundSessionId = null;
+function setTodoSession(id) {
+  boundSessionId = id;
+}
+var TodoStore = class {
+  items = /* @__PURE__ */ new Map();
+  list() {
+    return [...this.items.values()];
+  }
+  replace(items) {
+    this.items.clear();
+    for (const item of items) {
+      this.items.set(item.id, item);
+    }
+  }
+  async load(cwd, sessionId) {
+    let raw;
+    try {
+      raw = await readFile2(fileFor(cwd), "utf8");
+    } catch {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        this.replace(parsed.filter((it) => todoItemSchema.safeParse(it).success));
+        return;
+      }
+      const file = fileSchema.safeParse(parsed);
+      if (!file.success) {
+        return;
+      }
+      if (file.data.sessionId !== (sessionId ?? null)) {
+        this.replace([]);
+        return;
+      }
+      this.replace(file.data.items);
+    } catch {
+    }
+  }
+  // Atomic write (tmp + rename): a crash or failed save can never leave a
+  // truncated todos.json behind. An empty or fully completed list has no
+  // resume value — rehydrating it would only restore finished work — so the
+  // file is deleted instead of persisted.
+  async save(cwd) {
+    if (!persistGuard()) {
+      return;
+    }
+    const items = this.list();
+    const file = fileFor(cwd);
+    if (items.length === 0 || items.every((it) => it.status === "done")) {
+      await rm2(file, { force: true });
+      return;
+    }
+    await mkdir2(path4.join(cwd, ".star"), { recursive: true });
+    const tmp = `${file}.tmp`;
+    await writeFile2(tmp, `${JSON.stringify({ sessionId: boundSessionId, items }, null, 2)}
+`);
+    await rename(tmp, file);
+  }
+};
+var SYMBOLS = {
+  pending: "[ ]",
+  in_progress: "[~]",
+  done: "[x]"
+};
+function formatTodos(items) {
+  if (items.length === 0) {
+    return "No todos.";
+  }
+  const lines = items.map((it) => `${SYMBOLS[it.status]} ${it.id}. ${it.title}`);
+  const width = Math.max(...lines.map((l) => l.length));
+  return lines.map((line, i) => {
+    const status = items[i]?.status;
+    return status === "pending" ? line : `${line.padEnd(width + 4)}(${status})`;
+  }).join("\n");
+}
+var defaultStore = new TodoStore();
+function parseTodoArgs(args) {
+  const parsed = writeSchema.safeParse(args);
+  return parsed.success ? parsed.data.todos : null;
+}
+function pendingTodoTitles(args) {
+  return (parseTodoArgs(args) ?? []).filter((t) => t.status !== "done").map((t) => t.title);
+}
+async function loadTodos(cwd, sessionId) {
+  await defaultStore.load(cwd, sessionId);
+  return defaultStore.list();
+}
+function resetTodos() {
+  defaultStore.replace([]);
+}
+function createTodoTools(store = defaultStore) {
+  const todoWrite = {
+    name: "todo_write",
+    description: "Replace the current todo list with the given items. Each item has an id, title, and status (pending, in_progress, done).",
+    permission: "read",
+    parameters: writeSchema,
+    async execute(args, ctx) {
+      const parsed = writeSchema.safeParse(args);
+      if (!parsed.success) {
+        return { content: `Invalid todos: ${parsed.error.message}`, isError: true };
+      }
+      const previous = store.list();
+      store.replace(parsed.data.todos);
+      try {
+        await store.save(ctx.cwd);
+      } catch (err) {
+        store.replace(previous);
+        return { content: `Failed to save todos: ${err.message}`, isError: true };
+      }
+      const items = store.list();
+      const done = items.filter((it) => it.status === "done").length;
+      return { content: `Todo list updated (${done}/${items.length} done).` };
+    }
+  };
+  const todoRead = {
+    name: "todo_read",
+    description: "Read the current todo list.",
+    permission: "read",
+    parameters: readSchema,
+    async execute() {
+      return { content: formatTodos(store.list()) };
+    }
+  };
+  return [todoWrite, todoRead];
+}
+
+// src/core/image-resize.ts
+import { execFile } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile3, unlink, writeFile as writeFile3 } from "fs/promises";
+import os3 from "os";
+import path5 from "path";
+import { promisify } from "util";
+var RESIZE_TIMEOUT_MS = 1e4;
+var execFileAsync = promisify(execFile);
+function windowsResizeScript(inputFile, outputFile, maxDimension) {
+  const input = inputFile.replace(/'/g, "''");
+  const output = outputFile.replace(/'/g, "''");
+  return [
+    "Add-Type -AssemblyName System.Drawing",
+    `$img = [System.Drawing.Image]::FromFile('${input}')`,
+    `$scale = [Math]::Min(1.0, ${maxDimension} / [Math]::Max($img.Width, $img.Height))`,
+    "$w = [int][Math]::Max(1, [Math]::Round($img.Width * $scale))",
+    "$h = [int][Math]::Max(1, [Math]::Round($img.Height * $scale))",
+    "$bmp = New-Object System.Drawing.Bitmap($w, $h)",
+    "$g = [System.Drawing.Graphics]::FromImage($bmp)",
+    "$g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic",
+    "$g.DrawImage($img, 0, 0, $w, $h)",
+    `$bmp.Save('${output}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+    "$g.Dispose(); $bmp.Dispose(); $img.Dispose()"
+  ].join("; ");
+}
+function resizeImagePlan(platform, inputFile, outputFile, maxDimension, tools = {}) {
+  if (platform === "win32") {
+    return {
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        windowsResizeScript(inputFile, outputFile, maxDimension)
+      ]
+    };
+  }
+  if (platform === "darwin") {
+    return {
+      command: "sips",
+      args: ["-Z", String(maxDimension), inputFile, "--out", outputFile]
+    };
+  }
+  if (platform === "linux") {
+    if (tools.hasConvert) {
+      return {
+        command: "convert",
+        // -auto-orient keeps EXIF-rotated photos upright after the resize
+        // strips their orientation metadata.
+        args: [
+          inputFile,
+          "-auto-orient",
+          "-resize",
+          `${maxDimension}x${maxDimension}>`,
+          outputFile
+        ]
+      };
+    }
+    if (tools.hasFfmpeg) {
+      return {
+        command: "ffmpeg",
+        args: [
+          "-y",
+          "-i",
+          inputFile,
+          "-vf",
+          `scale='if(gt(iw,ih),min(iw,${maxDimension}),-1)':'if(gt(iw,ih),-1,min(ih,${maxDimension}))'`,
+          outputFile
+        ]
+      };
+    }
+    return null;
+  }
+  return null;
+}
+async function commandExists(command) {
+  const checker = process.platform === "win32" ? "where" : "which";
+  try {
+    await execFileAsync(checker, [command], { timeout: RESIZE_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function downsampleImageIfNeeded(image) {
+  const buf = Buffer.from(image.data, "base64");
+  const dims = probeImageDimensions(buf);
+  if (!dims || Math.max(dims.width, dims.height) <= MAX_IMAGE_DIMENSION) {
+    return { image, oversized: false, resized: false };
+  }
+  const inputFile = path5.join(os3.tmpdir(), `star-image-${randomUUID2()}.src`);
+  const outputFile = path5.join(os3.tmpdir(), `star-image-${randomUUID2()}.png`);
+  try {
+    const [hasConvert, hasFfmpeg] = process.platform === "linux" ? await Promise.all([commandExists("convert"), commandExists("ffmpeg")]) : [false, false];
+    const plan = resizeImagePlan(process.platform, inputFile, outputFile, MAX_IMAGE_DIMENSION, {
+      hasConvert,
+      hasFfmpeg
+    });
+    if (!plan) return { image, oversized: true, resized: false };
+    await writeFile3(inputFile, buf);
+    await execFileAsync(plan.command, plan.args, { timeout: RESIZE_TIMEOUT_MS });
+    const out = await readFile3(outputFile).catch(() => null);
+    if (!out || out.length === 0) return { image, oversized: true, resized: false };
+    return {
+      image: { path: image.path, mimeType: "image/png", data: out.toString("base64") },
+      oversized: true,
+      resized: true
+    };
+  } catch {
+    return { image, oversized: true, resized: false };
+  } finally {
+    await unlink(inputFile).catch(() => {
+    });
+    await unlink(outputFile).catch(() => {
+    });
+  }
+}
+
+// src/core/sensitive.ts
+var SENSITIVE_BASENAMES = /* @__PURE__ */ new Set([
+  ".env",
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519",
+  ".npmrc",
+  ".netrc",
+  ".pgpass"
+]);
+var SENSITIVE_SUFFIXES = [".pem", ".key", ".p12", ".pfx"];
+var SENSITIVE_ENV_EXEMPTIONS = /* @__PURE__ */ new Set([".env.example", ".env.sample", ".env.template"]);
+var extraPatterns = [];
+function registerSensitivePatterns(patterns) {
+  extraPatterns.length = 0;
+  extraPatterns.push(...patterns.map((p) => p.trim()).filter((p) => p.length > 0));
+}
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function pathSegments(p) {
+  return p.replace(/\\/g, "/").split("/").filter(Boolean).map((s) => s.toLowerCase());
+}
+function isSensitivePath(p) {
+  const segments = pathSegments(p);
+  const base = segments[segments.length - 1] ?? "";
+  const normalized = p.replace(/\\/g, "/").replace(/\/+$/, "");
+  for (const pattern of extraPatterns) {
+    const re = globToRegExp(pattern);
+    if (re.test(normalized) || re.test(base)) {
+      return true;
+    }
+  }
+  if (SENSITIVE_ENV_EXEMPTIONS.has(base)) {
+    return false;
+  }
+  if (base === ".env" || base.startsWith(".env.")) {
+    return true;
+  }
+  if (SENSITIVE_BASENAMES.has(base)) {
+    return true;
+  }
+  if (SENSITIVE_SUFFIXES.some((suffix) => base.endsWith(suffix))) {
+    return true;
+  }
+  const dir = segments[segments.length - 2] ?? "";
+  if (dir === ".aws" && base === "credentials") {
+    return true;
+  }
+  if (dir === ".kube" && base === "config") {
+    return true;
+  }
+  return false;
+}
+
+// src/tools/fs/util.ts
+import { readFileSync, statSync } from "fs";
+import { readdir, realpath, stat as stat2 } from "fs/promises";
+import path6 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+var WALK_CONCURRENCY = 16;
+function createLimiter(concurrency) {
+  let active = 0;
+  const waiting = [];
+  return async function limit(fn) {
+    while (active >= concurrency) {
+      await new Promise((resolve) => waiting.push(resolve));
+    }
+    active += 1;
+    try {
+      return await fn();
+    } finally {
+      active -= 1;
+      waiting.shift()?.();
+    }
+  };
+}
+function layerIgnores(layers, rel, isDir) {
+  for (const layer of layers) {
+    const local = layer.relBase === "" ? rel : rel.startsWith(`${layer.relBase}/`) ? rel.slice(layer.relBase.length + 1) : null;
+    if (local === null) {
+      continue;
+    }
+    for (const { pattern, dirOnly } of layer.patterns) {
+      if (dirOnly && !isDir) {
+        continue;
+      }
+      if (matchesGlob(pattern, local)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function walkFiles(root, skipDirs = SKIP_DIRS, options = {}) {
+  const out = [];
+  const limit = createLimiter(WALK_CONCURRENCY);
+  const signal = options.signal;
+  const caseKey = (p) => process.platform === "win32" ? p.toLowerCase() : p;
+  const visited = /* @__PURE__ */ new Set();
+  const rootReal = await realpath(root).catch(() => null);
+  if (rootReal !== null) {
+    visited.add(caseKey(rootReal));
+  }
+  let boundaryReal;
+  async function resolveLink(abs) {
+    const real = await limit(() => realpath(abs)).catch(() => null);
+    if (real === null) {
+      return null;
+    }
+    const boundary = options.symlinkBoundary;
+    if (boundary === void 0) {
+      return real;
+    }
+    if (boundaryReal === void 0) {
+      boundaryReal = await limit(() => realpath(boundary)).catch(() => null);
+    }
+    if (boundaryReal === null) {
+      return null;
+    }
+    const realKey = caseKey(real);
+    const boundaryKey = caseKey(boundaryReal);
+    return realKey === boundaryKey || realKey.startsWith(`${boundaryKey}${path6.sep}`) ? real : null;
+  }
+  async function walkDir(dir, relBase, parentLayers) {
+    if (signal?.aborted) {
+      return;
+    }
+    const entries = await limit(() => readdir(dir, { withFileTypes: true })).catch(() => null);
+    if (!entries) {
+      return;
+    }
+    let layers = parentLayers;
+    if (options.nestedIgnore && entries.some((e) => e.name === IGNORE_FILE)) {
+      const patterns = loadIgnorePatterns(dir);
+      if (patterns.length > 0) {
+        layers = [...parentLayers, { relBase, patterns }];
+      }
+    }
+    const subs = [];
+    for (const entry of entries) {
+      if (signal?.aborted) {
+        break;
+      }
+      const abs = path6.join(dir, entry.name);
+      const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
+      let targetStat = null;
+      let resolved;
+      if (entry.isSymbolicLink()) {
+        targetStat = await limit(() => stat2(abs)).catch(() => null);
+        if (!targetStat || !targetStat.isDirectory() && !targetStat.isFile()) {
+          continue;
+        }
+        const real = await resolveLink(abs);
+        if (real === null) {
+          continue;
+        }
+        resolved = real;
+        if (targetStat.isDirectory()) {
+          const key = caseKey(real);
+          if (visited.has(key)) {
+            continue;
+          }
+          visited.add(key);
+        }
+      }
+      const isDir = entry.isDirectory() || (targetStat?.isDirectory() ?? false);
+      const isFile = entry.isFile() || (targetStat?.isFile() ?? false);
+      if (isDir) {
+        if (skipDirs.has(entry.name) || options.ignore?.(abs, true)) {
+          continue;
+        }
+        if (layers.length > 0 && layerIgnores(layers, rel, true)) {
+          continue;
+        }
+        subs.push(walkDir(abs, rel, layers));
+      } else if (isFile) {
+        if (options.ignore?.(abs, false)) {
+          continue;
+        }
+        if (layers.length > 0 && layerIgnores(layers, rel, false)) {
+          continue;
+        }
+        if (options.withMtime === false) {
+          out.push(
+            resolved === void 0 ? { abs, rel, mtimeMs: 0 } : { abs, rel, mtimeMs: 0, resolved }
+          );
+          continue;
+        }
+        const st = targetStat ?? await limit(() => stat2(abs)).catch(() => null);
+        if (st) {
+          out.push(
+            resolved === void 0 ? { abs, rel, mtimeMs: st.mtimeMs } : { abs, rel, mtimeMs: st.mtimeMs, resolved }
+          );
+        }
+      }
+    }
+    await Promise.all(subs);
+  }
+  await walkDir(root, "", []);
+  out.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+  return { files: out, aborted: signal?.aborted ?? false };
+}
+var REGEX_SPECIALS = /[.+^${}()|[\]\\]/g;
+function escapeRe(c) {
+  return c.replace(REGEX_SPECIALS, "\\$&");
+}
+function globToRegExp2(pattern) {
+  let i = 0;
+  function parseClass() {
+    let j = i + 1;
+    let negate = false;
+    if (pattern.charAt(j) === "!") {
+      negate = true;
+      j += 1;
+    }
+    let body = "";
+    if (pattern.charAt(j) === "]") {
+      body += "\\]";
+      j += 1;
+    }
+    while (j < pattern.length && pattern.charAt(j) !== "]") {
+      const ch = pattern.charAt(j);
+      body += ch === "\\" ? "\\\\" : ch;
+      j += 1;
+    }
+    if (j < pattern.length) {
+      i = j + 1;
+      if (body.startsWith("^")) body = `\\${body}`;
+      return `[${negate ? "^" : ""}${body}]`;
+    }
+    i += 1;
+    return "\\[";
+  }
+  function parseSegment(depth) {
+    let re2 = "";
+    while (i < pattern.length) {
+      const c = pattern.charAt(i);
+      if (depth > 0 && (c === "," || c === "}")) {
+        return { re: re2, end: c };
+      }
+      if (c === "*") {
+        if (pattern.charAt(i + 1) === "*") {
+          i += 2;
+          if (pattern.charAt(i) === "/") {
+            i += 1;
+            re2 += "(?:[^/]+/)*";
+            while (pattern.startsWith("**/", i)) {
+              i += 3;
+            }
+          } else {
+            re2 += ".*";
+          }
+        } else {
+          re2 += "[^/]*";
+          i += 1;
+        }
+        continue;
+      }
+      if (c === "?") {
+        re2 += "[^/]";
+        i += 1;
+        continue;
+      }
+      if (c === "[") {
+        re2 += parseClass();
+        continue;
+      }
+      if (c === "{" && depth < 2) {
+        const close = braceEnd(i);
+        if (close === -1) {
+          re2 += "\\{";
+          i += 1;
+          continue;
+        }
+        i += 1;
+        const alts = [];
+        for (; ; ) {
+          const part = parseSegment(depth + 1);
+          alts.push(part.re);
+          if (part.end !== ",") break;
+          i += 1;
+        }
+        i += 1;
+        re2 += `(?:${alts.join("|")})`;
+        continue;
+      }
+      re2 += escapeRe(c);
+      i += 1;
+    }
+    return { re: re2, end: "" };
+  }
+  function braceEnd(from) {
+    let depth = 0;
+    for (let j = from; j < pattern.length; j++) {
+      const ch = pattern.charAt(j);
+      if (ch === "{") depth += 1;
+      else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) return j;
+      }
+    }
+    return -1;
+  }
+  const { re } = parseSegment(0);
+  return new RegExp(`^${re}$`);
+}
+function matchesGlob(pattern, relPath) {
+  const normalized = pattern.replace(/\\/g, "/");
+  if (!normalized.includes("/")) {
+    const base = relPath.split("/").pop() ?? relPath;
+    return globToRegExp2(normalized).test(base);
+  }
+  return globToRegExp2(normalized).test(relPath);
+}
+var IGNORE_FILE = ".starignore";
+var ignoreCache = /* @__PURE__ */ new Map();
+function parseIgnorePatterns(body) {
+  const out = [];
+  for (const raw of body.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    if (line.endsWith("/")) {
+      const pattern = line.slice(0, -1);
+      if (pattern) {
+        out.push({ pattern, dirOnly: true });
+      }
+    } else {
+      out.push({ pattern: line, dirOnly: false });
+    }
+  }
+  return out;
+}
+function loadIgnorePatterns(dir) {
+  const file = path6.join(dir, IGNORE_FILE);
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(file).mtimeMs;
+  } catch {
+    return [];
+  }
+  const hit = ignoreCache.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) {
+    return hit.patterns;
+  }
+  let patterns = [];
+  try {
+    patterns = parseIgnorePatterns(readFileSync(file, "utf8"));
+  } catch {
+    patterns = [];
+  }
+  ignoreCache.set(file, { mtimeMs, patterns });
+  return patterns;
+}
+function createIgnorePredicate(cwd) {
+  const patterns = loadIgnorePatterns(cwd);
+  if (patterns.length === 0) {
+    return void 0;
+  }
+  const root = path6.resolve(cwd);
+  return (absPath, isDir) => {
+    const rel = path6.relative(root, absPath).split(path6.sep).join("/");
+    if (!rel || rel.startsWith("..")) {
+      return false;
+    }
+    for (const { pattern, dirOnly } of patterns) {
+      if (dirOnly && !isDir) {
+        continue;
+      }
+      if (matchesGlob(pattern, rel)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+
+// src/tools/web/fetch.ts
+import dns from "dns";
+import { z as z3 } from "zod";
+var DEFAULT_MAX_CHARS = 2e4;
+var MAX_BYTES = 2 * 1024 * 1024;
+var TIMEOUT_MS = 3e4;
+var MAX_REDIRECTS = 5;
+var MAX_ANNOTATED_LINKS = 50;
+var PDF_MAGIC = [37, 80, 68, 70];
+var schema2 = z3.object({
+  url: z3.string().describe("The http(s) URL to fetch"),
+  maxChars: z3.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
+});
+var defaultResolver = async (hostname) => {
+  const results = await dns.promises.lookup(hostname, { all: true });
+  return results.map((result) => result.address);
+};
+var configuredAllowPrivateHosts = false;
+function setWebFetchAllowPrivateHosts(allow) {
+  configuredAllowPrivateHosts = allow;
+}
+function isPrivateIpv4(ip) {
+  const parts = ip.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
+    return false;
+  }
+  const [a = 0, b = 0] = parts;
+  return a === 0 || a === 10 || a === 127 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+}
+function isPrivateAddress(address) {
+  let ip = address.toLowerCase();
+  if (ip.startsWith("::ffff:")) ip = ip.slice("::ffff:".length);
+  if (ip.includes(".")) return isPrivateIpv4(ip);
+  if (ip === "::1" || ip === "::") return true;
+  if (ip.startsWith("fc") || ip.startsWith("fd")) return true;
+  if (/^fe[89ab]/.test(ip)) return true;
+  return false;
+}
+function isLocalHostname(hostname) {
+  const h = hostname.toLowerCase().replace(/\.$/, "");
+  return h === "localhost" || h.endsWith(".localhost") || h.endsWith(".local") || h.endsWith(".internal");
+}
+async function privateHostRefusal(url, resolve) {
+  const hostname = url.hostname.replace(/^\[|\]$/g, "");
+  if (isLocalHostname(hostname)) {
+    return `"${hostname}" is a local/internal hostname`;
+  }
+  let addresses;
+  try {
+    addresses = await resolve(hostname);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return `could not resolve "${hostname}" (${message})`;
+  }
+  const blocked = addresses.find(isPrivateAddress);
+  if (blocked !== void 0) {
+    return `"${hostname}" resolves to a private/reserved address (${blocked})`;
+  }
+  if (addresses.length === 0) {
+    return `could not resolve "${hostname}"`;
+  }
+  return null;
+}
+function safeCodePoint(n, raw) {
+  if (!Number.isInteger(n) || n < 0 || n > 1114111) {
+    return raw;
+  }
+  return String.fromCodePoint(n);
+}
+function decodeEntities(s) {
+  return s.replace(/&#(\d+);/g, (m, n) => safeCodePoint(Number(n), m)).replace(/&#x([0-9a-fA-F]+);/gi, (m, n) => safeCodePoint(Number.parseInt(n, 16), m)).replace(/&(quot|lt|gt|nbsp);/g, (m) => {
+    switch (m) {
+      case "&quot;":
+        return '"';
+      case "&lt;":
+        return "<";
+      case "&gt;":
+        return ">";
+      case "&nbsp;":
+        return " ";
+      default:
+        return m;
+    }
+  }).replace(/&amp;/g, "&");
+}
+function annotateLinks(html, base) {
+  let annotated = 0;
+  return html.replace(
+    /<a\b[^>]*?\shref\s*=\s*(?:"([^"]*)"|'([^']*)')[^>]*>([\s\S]*?)<\/a\s*>/gi,
+    (_match, doubleQuoted, singleQuoted, inner) => {
+      const rawText = String(inner).replace(/<[^>]+>/g, " ");
+      const href = decodeEntities(String(doubleQuoted ?? singleQuoted ?? "")).trim();
+      if (annotated >= MAX_ANNOTATED_LINKS || href === "" || href.startsWith("#")) {
+        return rawText;
+      }
+      let resolved;
+      try {
+        resolved = new URL(href, base);
+      } catch {
+        return rawText;
+      }
+      if (resolved.protocol !== "http:" && resolved.protocol !== "https:") {
+        return rawText;
+      }
+      const text = decodeEntities(rawText).replace(/\s+/g, " ").trim();
+      if (text === "") {
+        annotated += 1;
+        return resolved.href;
+      }
+      if (text === resolved.href || text === href) {
+        return rawText;
+      }
+      annotated += 1;
+      return `${rawText} (${resolved.href})`;
+    }
+  );
+}
+function htmlToText(html, base) {
+  const noBlocks = html.replace(/<(script|style|noscript|template)\b[^>]*>[\s\S]*?<\/\1>/gi, " ");
+  const withLinks = annotateLinks(noBlocks, base);
+  const withBreaks = withLinks.replace(
+    /<br\s*\/?>|<\/(p|div|li|tr|h[1-6]|section|article|header|footer|blockquote|pre)>/gi,
+    "\n"
+  );
+  const stripped = decodeEntities(withBreaks.replace(/<[^>]+>/g, " "));
+  return stripped.split("\n").map((line) => line.replace(/\s+/g, " ").trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function charsetDecoder(contentTypeHeader) {
+  const match = contentTypeHeader.match(/charset\s*=\s*"?([^\s";]+)"?/i);
+  const label = match?.[1]?.toLowerCase() ?? "utf-8";
+  if (label === "utf-8" || label === "utf8") {
+    return new TextDecoder("utf-8");
+  }
+  try {
+    return new TextDecoder(label);
+  } catch {
+    return new TextDecoder("utf-8");
+  }
+}
+async function readBody(res, maxChars, decoder) {
+  if (!res.body) {
+    return "";
+  }
+  const reader = res.body.getReader();
+  let bytes = 0;
+  let text = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      bytes += value.byteLength;
+      text += decoder.decode(value, { stream: true });
+      if (bytes >= MAX_BYTES || text.length >= maxChars * 2) {
+        break;
+      }
+    }
+    text += decoder.decode();
+  } finally {
+    reader.cancel().catch(() => {
+    });
+  }
+  return text;
+}
+async function readPrefix(res, n) {
+  if (!res.body) {
+    return new Uint8Array(0);
+  }
+  const reader = res.body.getReader();
+  const out = new Uint8Array(n);
+  let total = 0;
+  try {
+    while (total < n) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      const take = Math.min(value.byteLength, n - total);
+      out.set(value.subarray(0, take), total);
+      total += take;
+    }
+  } finally {
+    reader.cancel().catch(() => {
+    });
+  }
+  return out.subarray(0, total);
+}
+function isPdfPrefix(bytes) {
+  return PDF_MAGIC.every((b, i) => bytes[i] === b);
+}
+function pdfError(url) {
+  return {
+    content: `ERROR: PDF is not supported by web_fetch: ${url.href} is a PDF document. Do not retry this URL \u2014 use an HTML alternative (landing page, abstract, or HTML version) or a different source instead.`,
+    isError: true
+  };
+}
+function truncate(s, maxChars) {
+  if (s.length <= maxChars) {
+    return s;
+  }
+  return `${s.slice(0, maxChars)}
+[truncated, showing first ${maxChars} of ${s.length} chars]`;
+}
+function createWebFetchTool(options = {}) {
+  const resolve = options.resolver ?? defaultResolver;
+  const fetchImpl = options.fetchImpl ?? ((...args) => fetch(...args));
+  const allowPrivate = () => options.allowPrivateHosts ?? configuredAllowPrivateHosts;
+  return {
+    name: "web_fetch",
+    description: "Fetch a URL over http(s) and return its contents as readable text. HTML pages are converted to plain text (tags, scripts and styles removed; links kept inline as `anchor text (absolute-url)`). The charset declared in the response content-type is honored (GBK, Shift_JIS, Big5, etc.). PDF documents are not supported and return a clear error \u2014 do not retry them with this tool. Output is truncated to maxChars (default 20000). Private/reserved addresses (loopback, RFC1918, link-local incl. 169.254.169.254, localhost/.local/.internal names) are refused by default, on redirect hops too \u2014 the global config key webFetchAllowPrivateHosts lifts that for trusted intranet use.",
+    permission: "read",
+    parameters: schema2,
+    async execute(args, ctx) {
+      let url;
+      try {
+        url = new URL(args.url);
+      } catch {
+        return { content: `ERROR: invalid URL: ${args.url}`, isError: true };
+      }
+      if (url.protocol !== "http:" && url.protocol !== "https:") {
+        return {
+          content: `ERROR: only http(s) URLs are supported, got: ${url.protocol}`,
+          isError: true
+        };
+      }
+      if (!allowPrivate()) {
+        const refusal = await privateHostRefusal(url, resolve);
+        if (refusal !== null) {
+          return { content: `ERROR: refused to fetch ${args.url}: ${refusal}`, isError: true };
+        }
+      }
+      const maxChars = args.maxChars ?? DEFAULT_MAX_CHARS;
+      const timeoutSignal = AbortSignal.timeout(TIMEOUT_MS);
+      const signal = ctx.abortSignal ? AbortSignal.any([timeoutSignal, ctx.abortSignal]) : timeoutSignal;
+      let res;
+      let current = url;
+      for (let hops = 0; ; hops += 1) {
+        try {
+          res = await fetchImpl(current, { signal, redirect: "manual" });
+        } catch (err) {
+          if (ctx.abortSignal?.aborted) {
+            return { content: "ERROR: request aborted", isError: true };
+          }
+          if (timeoutSignal.aborted) {
+            return {
+              content: `ERROR: request timed out after ${TIMEOUT_MS / 1e3}s`,
+              isError: true
+            };
+          }
+          const message = err instanceof Error ? err.message : String(err);
+          return { content: `ERROR: failed to fetch ${current.href}: ${message}`, isError: true };
+        }
+        const location = res.headers.get("location");
+        if (res.status >= 300 && res.status < 400 && location && hops < MAX_REDIRECTS) {
+          await res.body?.cancel().catch(() => {
+          });
+          let next;
+          try {
+            next = new URL(location, current);
+          } catch {
+            return { content: `ERROR: invalid redirect Location: ${location}`, isError: true };
+          }
+          if (next.protocol !== "http:" && next.protocol !== "https:") {
+            return {
+              content: `ERROR: redirect to non-http(s) URL refused: ${next.protocol}`,
+              isError: true
+            };
+          }
+          if (!allowPrivate()) {
+            const refusal = await privateHostRefusal(next, resolve);
+            if (refusal !== null) {
+              return {
+                content: `ERROR: refused redirect to ${next.href}: ${refusal}`,
+                isError: true
+              };
+            }
+          }
+          current = next;
+          continue;
+        }
+        break;
+      }
+      if (!res.ok) {
+        await res.body?.cancel().catch(() => {
+        });
+        return {
+          content: `ERROR: HTTP ${res.status} ${res.statusText} for ${current.href}`,
+          isError: true
+        };
+      }
+      const contentTypeHeader = res.headers.get("content-type") ?? "text/plain";
+      const [rawType = ""] = contentTypeHeader.split(";");
+      const contentType = rawType.trim().toLowerCase();
+      const isHtml = contentType === "text/html" || contentType === "application/xhtml+xml";
+      const isText = contentType.startsWith("text/") || contentType === "application/json" || contentType === "application/xml" || contentType.endsWith("+json") || contentType.endsWith("+xml");
+      if (contentType === "application/pdf") {
+        await res.body?.cancel().catch(() => {
+        });
+        return pdfError(current);
+      }
+      if (!isHtml && !isText) {
+        const prefix = await readPrefix(res, PDF_MAGIC.length);
+        if (isPdfPrefix(prefix)) {
+          return pdfError(current);
+        }
+        return {
+          content: `ERROR: unsupported content type: ${contentType} (${current.href})`,
+          isError: true
+        };
+      }
+      let body;
+      try {
+        body = await readBody(res, maxChars, charsetDecoder(contentTypeHeader));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `ERROR: failed to read response body: ${message}`, isError: true };
+      }
+      if (body.startsWith("%PDF")) {
+        return pdfError(current);
+      }
+      const text = isHtml ? htmlToText(body, current.href) : body;
+      return { content: truncate(text, maxChars) };
+    }
+  };
+}
+var webFetchTool = createWebFetchTool();
+
+export {
+  defaultAgentTasks,
+  formatAgentTaskUpdate,
+  responseBodyOf,
+  MAX_IMAGE_DIMENSION,
+  probeImageDimensions,
+  isOversizedImageError,
+  isVisionUnsupportedError,
+  stripOversizedImages,
+  stripAllImages,
+  downsampleImageIfNeeded,
+  registerSensitivePatterns,
+  isSensitivePath,
+  SKIP_DIRS,
+  WALK_CONCURRENCY,
+  walkFiles,
+  matchesGlob,
+  createIgnorePredicate,
+  starHome,
+  globalConfigPath,
+  sessionsDir,
+  userMemoryPath,
+  gitTreesDir,
+  envFilePath,
+  projectConfigPath,
+  setWebFetchAllowPrivateHosts,
+  decodeEntities,
+  webFetchTool,
+  loadEnvFile,
+  upsertEnvContent,
+  MAX_OUTPUT,
+  resolveShell,
+  bashTool,
+  defaultTaskManager,
+  MAX_SNAPSHOT_CONTENT_BYTES,
+  setSnapshotHooks,
+  nextSnapshotId,
+  beginTurn,
+  currentTurnSeq,
+  currentTurnMessageIndex,
+  captureSnapshot,
+  pushSnapshot,
+  listSnapshots,
+  clearSnapshots,
+  hydrateSnapshots,
+  listTurnSnapshots,
+  resolveSnapshotContent,
+  undoTurnSnapshots,
+  dropTurnSnapshots,
+  rewindToSnapshot,
+  setTodoPersistGuard,
+  setTodoSession,
+  TodoStore,
+  formatTodos,
+  parseTodoArgs,
+  pendingTodoTitles,
+  loadTodos,
+  resetTodos,
+  createTodoTools
+};
+//# sourceMappingURL=chunk-A5PXPWHB.js.map