@cryer/star-cli 0.3.7 → 0.3.9

package/dist/chunk-OIJYNQFZ.js

@@ -0,0 +1,1163 @@
+#!/usr/bin/env node
+import {
+  MAX_OUTPUT,
+  MAX_SNAPSHOT_CONTENT_BYTES,
+  WALK_CONCURRENCY,
+  bashTool,
+  captureSnapshot,
+  createIgnorePredicate,
+  createTodoTools,
+  currentTurnMessageIndex,
+  currentTurnSeq,
+  decodeEntities,
+  defaultAgentTasks,
+  defaultTaskManager,
+  downsampleImageIfNeeded,
+  isSensitivePath,
+  matchesGlob,
+  nextSnapshotId,
+  probeImageDimensions,
+  pushSnapshot,
+  starHome,
+  walkFiles,
+  webFetchTool
+} from "./chunk-A5PXPWHB.js";
+
+// src/tools/fs/edit.ts
+import { readFile, stat, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var BINARY_PROBE_BYTES = 8192;
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  let idx = haystack.indexOf(needle);
+  while (idx !== -1) {
+    count += 1;
+    idx = haystack.indexOf(needle, idx + needle.length);
+  }
+  return count;
+}
+function normalizeEol(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+var schema = z.object({
+  path: z.string().describe("File path, absolute or relative to the working directory"),
+  old_string: z.string().min(1).describe("Exact text to replace"),
+  new_string: z.string().describe("Replacement text"),
+  replace_all: z.boolean().optional().describe("Replace every occurrence instead of requiring a unique match")
+});
+var editFileTool = {
+  name: "edit_file",
+  description: "Replace an exact string in a file. Fails if old_string is not found or matches multiple locations unless replace_all is set. Refuses binary files and files over 5MB.",
+  permission: "write",
+  parameters: schema,
+  async execute(args, ctx) {
+    const filePath = path.resolve(ctx.cwd, args.path);
+    let content;
+    let readMtimeMs;
+    try {
+      const st = await stat(filePath);
+      if (st.size > MAX_SNAPSHOT_CONTENT_BYTES) {
+        return {
+          content: `Refused to edit ${args.path}: file is ${st.size} bytes, over the 5MB limit (edits past it could not be restored by /undo)`,
+          isError: true
+        };
+      }
+      readMtimeMs = st.mtimeMs;
+      const buf = await readFile(filePath);
+      if (buf.subarray(0, BINARY_PROBE_BYTES).includes(0)) {
+        return { content: `Refused to edit binary file: ${args.path}`, isError: true };
+      }
+      content = buf.toString("utf8");
+    } catch (err) {
+      return { content: `Failed to read ${args.path}: ${err.message}`, isError: true };
+    }
+    let working = content;
+    let oldString = args.old_string;
+    let newString = args.new_string;
+    let restoreEol = null;
+    let count = countOccurrences(working, oldString);
+    if (count === 0) {
+      const normalizedContent = normalizeEol(content);
+      const normalizedOld = normalizeEol(oldString);
+      const normalizedCount = countOccurrences(normalizedContent, normalizedOld);
+      if (normalizedCount > 0) {
+        const crlfCount = countOccurrences(content, "\r\n");
+        const loneLfCount = countOccurrences(content.replace(/\r\n/g, ""), "\n");
+        restoreEol = crlfCount > 0 && crlfCount >= loneLfCount ? (text) => text.replace(/\n/g, "\r\n") : null;
+        working = normalizedContent;
+        oldString = normalizedOld;
+        newString = normalizeEol(newString);
+        count = normalizedCount;
+      }
+    }
+    if (count === 0) {
+      return { content: `old_string not found in ${args.path}`, isError: true };
+    }
+    if (count > 1 && !args.replace_all) {
+      return {
+        content: `old_string matches ${count} locations in ${args.path}; provide more surrounding context or set replace_all`,
+        isError: true
+      };
+    }
+    let updated = args.replace_all ? working.split(oldString).join(newString) : working.replace(oldString, () => newString);
+    if (restoreEol) {
+      updated = restoreEol(updated);
+    }
+    try {
+      const now = await stat(filePath).catch(() => null);
+      if (!now || now.mtimeMs !== readMtimeMs) {
+        return {
+          content: `Failed to edit ${args.path}: file changed since it was read; re-read and retry`,
+          isError: true
+        };
+      }
+      await writeFile(filePath, updated, "utf8");
+    } catch (err) {
+      return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
+    }
+    const contentTooLarge = Buffer.byteLength(content, "utf8") > MAX_SNAPSHOT_CONTENT_BYTES;
+    await pushSnapshot({
+      id: nextSnapshotId(),
+      path: filePath,
+      existed: true,
+      content: contentTooLarge ? null : content,
+      contentTooLarge: contentTooLarge || void 0,
+      toolName: "edit_file",
+      timestamp: Date.now(),
+      turn: ctx.snapshotContext?.turn ?? currentTurnSeq(),
+      messageIndex: ctx.snapshotContext?.messageIndex ?? currentTurnMessageIndex(),
+      owner: ctx.snapshotContext?.owner ?? "root"
+    });
+    return { content: `Edited ${args.path}: ${count} replacement${count > 1 ? "s" : ""}` };
+  }
+};
+
+// src/tools/fs/glob.ts
+import path2 from "path";
+import { z as z2 } from "zod";
+var MAX_RESULTS = 100;
+var GLOB_MAGIC = /[*?[{]/;
+function literalDirPrefix(pattern) {
+  const segments = pattern.replace(/\\/g, "/").split("/").slice(0, -1);
+  const out = [];
+  for (const segment of segments) {
+    if (segment === "" || GLOB_MAGIC.test(segment)) {
+      break;
+    }
+    out.push(segment);
+  }
+  return out;
+}
+var schema2 = z2.object({
+  pattern: z2.string().describe(
+    "Glob pattern, e.g. 'src/**/*.ts'. Supports **, *, ?, {a,b} braces and [abc] character classes. A bare pattern like '*.ts' matches basenames recursively."
+  ),
+  path: z2.string().optional().describe("Directory to search, defaults to the working directory")
+});
+function hasParentSegment(pattern) {
+  return pattern.replace(/\\/g, "/").split("/").some((segment) => segment === "..");
+}
+var globTool = {
+  name: "glob",
+  description: "Find files by glob pattern. Skips node_modules, .git and dist. Follows symlinks that stay inside the working directory. Returns paths sorted by modification time, newest first, up to 100 results.",
+  permission: "read",
+  parameters: schema2,
+  async execute(args, ctx) {
+    if (hasParentSegment(args.pattern)) {
+      return {
+        content: `Refused glob pattern with '..' segment: ${args.pattern}`,
+        isError: true
+      };
+    }
+    const root = path2.resolve(ctx.cwd, args.path ?? ".");
+    const prefixSegments = literalDirPrefix(args.pattern);
+    const walkRoot = prefixSegments.length > 0 ? path2.join(root, ...prefixSegments) : root;
+    const prefix = prefixSegments.length > 0 ? `${prefixSegments.join("/")}/` : "";
+    const { files, aborted } = await walkFiles(walkRoot, void 0, {
+      ignore: createIgnorePredicate(ctx.cwd),
+      signal: ctx.abortSignal,
+      symlinkBoundary: ctx.cwd,
+      nestedIgnore: true
+    });
+    const matched = files.filter((f) => matchesGlob(args.pattern, `${prefix}${f.rel}`)).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_RESULTS);
+    if (matched.length === 0) {
+      return {
+        content: aborted ? `Search interrupted before any files matched pattern: ${args.pattern}` : `No files matched pattern: ${args.pattern}`
+      };
+    }
+    const lines = matched.map((f) => `${prefix}${f.rel}`);
+    if (aborted) {
+      lines.push("... (interrupted: partial results)");
+    }
+    return { content: lines.join("\n") };
+  }
+};
+
+// src/tools/fs/grep.ts
+import { readFile as readFile2, realpath, stat as stat2 } from "fs/promises";
+import path3 from "path";
+import { z as z3 } from "zod";
+var MAX_MATCHES = 250;
+var MAX_LINE_CHARS = 500;
+var MAX_PATTERN_CHARS = 200;
+var MAX_FILE_BYTES = 5 * 1024 * 1024;
+function isTooComplexPattern(pattern) {
+  return pattern.length > MAX_PATTERN_CHARS || /\)[+*]/.test(pattern) || /\)\{\d+(,\d*)?\}/.test(pattern);
+}
+var schema3 = z3.object({
+  pattern: z3.string().describe("Regular expression to search for"),
+  path: z3.string().optional().describe("File or directory to search, defaults to the working directory"),
+  glob: z3.string().optional().describe("Glob pattern to filter which files are searched, e.g. '*.ts'"),
+  ignoreCase: z3.boolean().optional().describe("Case-insensitive matching")
+});
+var grepTool = {
+  name: "grep",
+  description: "Search file contents with a regular expression. Outputs 'file:line:content', up to 250 matches. Skips binary files, files over 5MB, sensitive files, node_modules and .git. Follows symlinks that stay inside the working directory.",
+  permission: "read",
+  parameters: schema3,
+  async execute(args, ctx) {
+    if (isTooComplexPattern(args.pattern)) {
+      return {
+        content: `pattern too complex: keep it under ${MAX_PATTERN_CHARS} characters and avoid quantified groups like (a+)+`,
+        isError: true
+      };
+    }
+    let re;
+    try {
+      re = new RegExp(args.pattern, args.ignoreCase ? "i" : "");
+    } catch (err) {
+      return { content: `Invalid regular expression: ${err.message}`, isError: true };
+    }
+    const root = path3.resolve(ctx.cwd, args.path ?? ".");
+    let files;
+    let interrupted = false;
+    try {
+      const st = await stat2(root);
+      if (st.isFile()) {
+        const resolved = await realpath(root).catch(() => null);
+        if (isSensitivePath(root) || resolved !== null && isSensitivePath(resolved)) {
+          return {
+            content: `Refused to grep sensitive file: ${args.path ?? "."}`,
+            isError: true
+          };
+        }
+        files = [{ abs: root, rel: path3.basename(root), mtimeMs: st.mtimeMs }];
+      } else {
+        const walked = await walkFiles(root, void 0, {
+          ignore: createIgnorePredicate(ctx.cwd),
+          withMtime: false,
+          signal: ctx.abortSignal,
+          symlinkBoundary: ctx.cwd,
+          nestedIgnore: true
+        });
+        interrupted = walked.aborted;
+        files = walked.files.filter(
+          (f) => !isSensitivePath(f.abs) && (f.resolved === void 0 || !isSensitivePath(f.resolved))
+        );
+      }
+    } catch {
+      return { content: `Path not found: ${args.path ?? "."}`, isError: true };
+    }
+    if (args.glob) {
+      const glob = args.glob;
+      files = files.filter((f) => matchesGlob(glob, f.rel));
+    }
+    const scanFile = async (file) => {
+      const st = await stat2(file.abs).catch(() => null);
+      if (!st) {
+        return null;
+      }
+      if (st.size > MAX_FILE_BYTES) {
+        skippedLarge += 1;
+        return null;
+      }
+      let buf;
+      try {
+        buf = await readFile2(file.abs);
+      } catch {
+        return null;
+      }
+      if (buf.includes(0)) {
+        return null;
+      }
+      const hits = [];
+      const lines = buf.toString("utf8").split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (re.test(line)) {
+          const shown = line.length > MAX_LINE_CHARS ? `${line.slice(0, MAX_LINE_CHARS)}\u2026` : line;
+          hits.push(`${file.rel}:${i + 1}:${shown}`);
+        }
+      }
+      return hits;
+    };
+    const out = [];
+    let truncated = false;
+    let skippedLarge = 0;
+    outer: for (let i = 0; i < files.length; i += WALK_CONCURRENCY) {
+      if (ctx.abortSignal?.aborted) {
+        interrupted = true;
+        break;
+      }
+      const chunk = await Promise.all(
+        files.slice(i, i + WALK_CONCURRENCY).map((file) => scanFile(file))
+      );
+      for (const hits of chunk) {
+        if (!hits) {
+          continue;
+        }
+        for (const hit of hits) {
+          out.push(hit);
+          if (out.length >= MAX_MATCHES) {
+            truncated = true;
+            break outer;
+          }
+        }
+      }
+    }
+    const skippedNote = skippedLarge > 0 ? `(skipped ${skippedLarge} file(s) larger than 5MB)` : null;
+    if (out.length === 0) {
+      return {
+        content: `No matches for pattern: ${args.pattern}${skippedNote ? ` ${skippedNote}` : ""}${interrupted ? " (search interrupted)" : ""}`
+      };
+    }
+    if (truncated) {
+      out.push(`... (truncated: more than ${MAX_MATCHES} matches)`);
+    } else if (interrupted) {
+      out.push("... (interrupted: partial results)");
+    }
+    if (skippedNote) {
+      out.push(`... ${skippedNote}`);
+    }
+    return { content: out.join("\n") };
+  }
+};
+
+// src/tools/fs/read.ts
+import { open, realpath as realpath2, stat as stat3 } from "fs/promises";
+import path4 from "path";
+import { z as z4 } from "zod";
+var DEFAULT_LIMIT = 2e3;
+var MAX_CHARS = 100 * 1024;
+var MAX_READ_BYTES = 1024 * 1024;
+var BINARY_PROBE_BYTES2 = 8192;
+function decodeUtf16be(buf) {
+  const len = buf.length - buf.length % 2;
+  const swapped = Buffer.allocUnsafe(len);
+  for (let k = 0; k < len; k += 2) {
+    swapped[k] = buf[k + 1] ?? 0;
+    swapped[k + 1] = buf[k] ?? 0;
+  }
+  return swapped.toString("utf16le");
+}
+function decodeTextBuffer(buf) {
+  if (buf.length >= 2 && buf[0] === 255 && buf[1] === 254) {
+    return { text: buf.subarray(2).toString("utf16le") };
+  }
+  if (buf.length >= 2 && buf[0] === 254 && buf[1] === 255) {
+    return { text: decodeUtf16be(buf.subarray(2)) };
+  }
+  if (buf.subarray(0, BINARY_PROBE_BYTES2).includes(0)) {
+    return { binary: true };
+  }
+  return { text: buf.toString("utf8") };
+}
+var schema4 = z4.object({
+  path: z4.string().describe("File path, absolute or relative to the working directory"),
+  offset: z4.number().int().positive().optional().describe("1-based line number to start reading from"),
+  limit: z4.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
+});
+var READ_CACHE_MAX_ENTRIES = 200;
+function createReadFileTool() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    name: "read_file",
+    description: "Read a text file and return its contents with line numbers. Output is truncated to 2000 lines or 100KB by default. Re-reading an unchanged file range returns a short note instead of the content.",
+    permission: "read",
+    parameters: schema4,
+    reset: () => cache.clear(),
+    async execute(args, ctx) {
+      const filePath = path4.resolve(ctx.cwd, args.path);
+      const resolvedPath = await realpath2(filePath).catch(() => null);
+      if (isSensitivePath(filePath) || resolvedPath !== null && isSensitivePath(resolvedPath)) {
+        return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
+      }
+      const st = await stat3(filePath).catch(() => null);
+      if (!st) {
+        return { content: `File not found: ${args.path}`, isError: true };
+      }
+      if (st.isDirectory()) {
+        return { content: `Path is a directory, not a file: ${args.path}`, isError: true };
+      }
+      const start = args.offset ?? 1;
+      const limit = args.limit ?? DEFAULT_LIMIT;
+      const cacheKey = resolvedPath ?? filePath;
+      const hit = cache.get(cacheKey);
+      if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
+        const requestedEnd = Math.min(hit.totalLines, start - 1 + limit);
+        if (start >= hit.start && requestedEnd <= hit.end && start <= hit.totalLines) {
+          return {
+            content: `[unchanged since last read: ${args.path} \u2014 lines ${start}-${requestedEnd} of ${hit.totalLines} are already in context and the file has not changed]`
+          };
+        }
+      }
+      const bytesToRead = Math.min(st.size, MAX_READ_BYTES);
+      const fileCapped = st.size > MAX_READ_BYTES;
+      const handle = await open(filePath, "r").catch(() => null);
+      if (!handle) {
+        return { content: `Failed to read ${args.path}`, isError: true };
+      }
+      let buf;
+      try {
+        const { bytesRead, buffer } = await handle.read(
+          Buffer.alloc(bytesToRead),
+          0,
+          bytesToRead,
+          0
+        );
+        buf = buffer.subarray(0, bytesRead);
+      } finally {
+        await handle.close().catch(() => {
+        });
+      }
+      const decoded = decodeTextBuffer(buf);
+      if ("binary" in decoded) {
+        return { content: `Cannot read binary file: ${args.path}`, isError: true };
+      }
+      const lines = decoded.text.split("\n");
+      const totalDesc = fileCapped ? `at least ${lines.length}` : `${lines.length}`;
+      if (start > lines.length) {
+        return { content: `(offset ${start} beyond end of file; file has ${totalDesc} lines)` };
+      }
+      const end = Math.min(lines.length, start - 1 + limit);
+      const out = [];
+      let size = 0;
+      let truncatedBySize = false;
+      for (let i = start - 1; i < end; i++) {
+        const line = (lines[i] ?? "").replace(/\r$/, "");
+        const numbered = `${i + 1}	${line}`;
+        if (size + numbered.length > MAX_CHARS) {
+          truncatedBySize = true;
+          break;
+        }
+        out.push(numbered);
+        size += numbered.length;
+      }
+      const lastShown = start - 1 + out.length;
+      if (truncatedBySize) {
+        out.push(
+          `... (truncated: output exceeds 100KB, showing lines ${start}-${lastShown} of ${totalDesc})`
+        );
+      } else if (end < lines.length || fileCapped) {
+        out.push(`... (truncated: showing lines ${start}-${end} of ${totalDesc})`);
+      }
+      if (out.length > 0) {
+        if (cache.size >= READ_CACHE_MAX_ENTRIES) cache.clear();
+        const prev = hit?.mtimeMs === st.mtimeMs && hit.size === st.size ? hit : void 0;
+        cache.set(cacheKey, {
+          mtimeMs: st.mtimeMs,
+          size: st.size,
+          totalLines: lines.length,
+          // Extend the remembered range when the new read overlaps or abuts
+          // the previous one; disjoint ranges replace it.
+          start: prev && start <= prev.end + 1 ? Math.min(prev.start, start) : start,
+          end: prev && lastShown >= prev.start - 1 ? Math.max(prev.end, lastShown) : lastShown
+        });
+      }
+      return { content: out.join("\n") };
+    }
+  };
+}
+var readFileTool = createReadFileTool();
+
+// src/tools/fs/read-image.ts
+import { readFile as readFile3, realpath as realpath3, stat as stat4 } from "fs/promises";
+import path5 from "path";
+import { z as z5 } from "zod";
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var IMAGE_MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+var schema5 = z5.object({
+  path: z5.string().describe(
+    "Image file path (png/jpg/jpeg/gif/webp), absolute or relative to the working directory"
+  )
+});
+var readImageTool = {
+  name: "read_image",
+  description: "Read an image file (png, jpg, gif, webp) and show it to the model. Use this whenever the user references a screenshot, diagram, or picture file you need to see. Images larger than 2000px are downsampled automatically.",
+  permission: "read",
+  parameters: schema5,
+  async execute(args, ctx) {
+    if (ctx.visionEnabled === false) {
+      return {
+        content: "The active model does not support image input (vision = false), so the image was not read. Work from text instead, or ask the user to describe the image.",
+        isError: true
+      };
+    }
+    const filePath = path5.resolve(ctx.cwd, args.path);
+    const resolvedPath = await realpath3(filePath).catch(() => null);
+    if (isSensitivePath(filePath) || resolvedPath !== null && isSensitivePath(resolvedPath)) {
+      return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
+    }
+    const mimeType = IMAGE_MIME_TYPES[path5.extname(filePath).toLowerCase()];
+    if (!mimeType) {
+      return {
+        content: `Not a supported image (png/jpg/jpeg/gif/webp): ${args.path}`,
+        isError: true
+      };
+    }
+    const st = await stat4(filePath).catch(() => null);
+    if (!st || !st.isFile()) {
+      return { content: `File not found: ${args.path}`, isError: true };
+    }
+    if (st.size > MAX_IMAGE_BYTES) {
+      return {
+        content: `Image too large (${Math.round(st.size / 1024)}KB > ${MAX_IMAGE_BYTES / 1024}KB): ${args.path}`,
+        isError: true
+      };
+    }
+    const buf = await readFile3(filePath).catch(() => null);
+    if (!buf || buf.length === 0) {
+      return { content: `Failed to read ${args.path}`, isError: true };
+    }
+    if (!probeImageDimensions(buf)) {
+      return {
+        content: `File is not a valid image (unrecognized header): ${args.path}`,
+        isError: true
+      };
+    }
+    const downsampled = await downsampleImageIfNeeded({
+      path: args.path,
+      mimeType,
+      data: buf.toString("base64")
+    });
+    if (downsampled.oversized && !downsampled.resized) {
+      return {
+        content: `Image exceeds 2000px and could not be downsampled on this platform: ${args.path}`,
+        isError: true
+      };
+    }
+    const image = downsampled.image;
+    const dims = probeImageDimensions(Buffer.from(image.data, "base64"));
+    const sizeKB = Math.round(image.data.length / 1024);
+    const desc = dims ? `${dims.width}x${dims.height}` : "unknown dimensions";
+    const resizedNote = downsampled.resized ? " (downsampled to fit 2000px)" : "";
+    return {
+      content: `Image loaded: ${args.path} (${desc}, ~${sizeKB}KB)${resizedNote}. The image is attached below \u2014 look at it now.`,
+      images: [image]
+    };
+  }
+};
+
+// src/tools/fs/write.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import path6 from "path";
+import { z as z6 } from "zod";
+var schema6 = z6.object({
+  path: z6.string().describe("File path, absolute or relative to the working directory"),
+  content: z6.string().describe("Full content to write to the file")
+});
+var writeFileTool = {
+  name: "write_file",
+  description: "Write content to a file, creating parent directories as needed. Overwrites existing files. Refuses content with NUL bytes (binary) or over 5MB.",
+  permission: "write",
+  parameters: schema6,
+  async execute(args, ctx) {
+    const filePath = path6.resolve(ctx.cwd, args.path);
+    if (args.content.includes("\0")) {
+      return {
+        content: `Refused to write ${args.path}: content contains NUL bytes (write_file is text-only)`,
+        isError: true
+      };
+    }
+    const bytes = Buffer.byteLength(args.content, "utf8");
+    if (bytes > MAX_SNAPSHOT_CONTENT_BYTES) {
+      return {
+        content: `Refused to write ${args.path}: content is ${bytes} bytes, over the 5MB limit (writes past it could not be restored by /undo)`,
+        isError: true
+      };
+    }
+    const snapshot = await captureSnapshot(filePath, "write_file", ctx.snapshotContext);
+    try {
+      await mkdir(path6.dirname(filePath), { recursive: true });
+      await writeFile2(filePath, args.content, "utf8");
+    } catch (err) {
+      return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
+    }
+    await pushSnapshot(snapshot);
+    return { content: `Wrote ${bytes} bytes to ${args.path}` };
+  }
+};
+
+// src/tools/screenshot.ts
+import { z as z7 } from "zod";
+
+// src/core/screenshot.ts
+import { execFile } from "child_process";
+import { randomUUID } from "crypto";
+import { readFile as readFile4, unlink } from "fs/promises";
+import os from "os";
+import path7 from "path";
+import { promisify } from "util";
+var SCREENSHOT_TIMEOUT_MS = 2e4;
+var execFileAsync = promisify(execFile);
+function windowsScreenshotScript(outputFile) {
+  const output = outputFile.replace(/'/g, "''");
+  return [
+    `try { Add-Type -MemberDefinition '[DllImport("user32.dll")] public static extern bool SetProcessDpiAwarenessContext(int v);' -Name Dpi -Namespace StarShot -ErrorAction Stop; [void][StarShot.Dpi]::SetProcessDpiAwarenessContext(-4) } catch { }`,
+    "Add-Type -AssemblyName System.Windows.Forms,System.Drawing",
+    "$b = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds",
+    "$bmp = New-Object System.Drawing.Bitmap($b.Width, $b.Height)",
+    "$g = [System.Drawing.Graphics]::FromImage($bmp)",
+    "$g.CopyFromScreen($b.Left, $b.Top, 0, 0, $bmp.Size)",
+    `$bmp.Save('${output}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+    "$g.Dispose(); $bmp.Dispose()"
+  ].join("; ");
+}
+function screenshotPlan(platform, outputFile, env = process.env, tools = {}) {
+  if (platform === "win32") {
+    return {
+      command: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-Command", windowsScreenshotScript(outputFile)]
+    };
+  }
+  if (platform === "darwin") {
+    return { command: "screencapture", args: ["-x", "-D", "1", outputFile] };
+  }
+  if (platform === "linux") {
+    if (env.WAYLAND_DISPLAY) {
+      if (tools.grim) return { command: "grim", args: [outputFile] };
+      if (tools["gnome-screenshot"]) {
+        return { command: "gnome-screenshot", args: ["-f", outputFile] };
+      }
+      if (tools.spectacle) {
+        return { command: "spectacle", args: ["-b", "-n", "-o", outputFile] };
+      }
+      return null;
+    }
+    if (env.DISPLAY) {
+      if (tools.import) return { command: "import", args: ["-window", "root", outputFile] };
+      if (tools.scrot) return { command: "scrot", args: ["--overwrite", outputFile] };
+      if (tools["gnome-screenshot"]) {
+        return { command: "gnome-screenshot", args: ["-f", outputFile] };
+      }
+      if (tools.spectacle) {
+        return { command: "spectacle", args: ["-b", "-n", "-o", outputFile] };
+      }
+      return null;
+    }
+    return null;
+  }
+  return null;
+}
+function noScreenshotToolMessage(platform, env = process.env) {
+  if (platform === "linux") {
+    if (!env.WAYLAND_DISPLAY && !env.DISPLAY) {
+      return "no display server (neither DISPLAY nor WAYLAND_DISPLAY is set) \u2014 this session is headless (e.g. SSH), there is no screen to capture";
+    }
+    return "no screenshot tool found \u2014 install one of: grim or spectacle (Wayland), scrot or ImageMagick's import (X11), or gnome-screenshot";
+  }
+  return `screenshots are not supported on this platform (${platform})`;
+}
+async function commandExists(command) {
+  const checker = process.platform === "win32" ? "where" : "which";
+  try {
+    await execFileAsync(checker, [command], { timeout: SCREENSHOT_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var LINUX_TOOL_NAMES = ["grim", "gnome-screenshot", "spectacle", "import", "scrot"];
+async function captureScreenshot() {
+  const outputFile = path7.join(os.tmpdir(), `star-screenshot-${randomUUID()}.png`);
+  try {
+    const tools = {};
+    if (process.platform === "linux") {
+      const found = await Promise.all(LINUX_TOOL_NAMES.map(commandExists));
+      for (const [i, name] of LINUX_TOOL_NAMES.entries()) {
+        tools[name] = found[i] ?? false;
+      }
+    }
+    const plan = screenshotPlan(process.platform, outputFile, process.env, tools);
+    if (!plan) {
+      return { ok: false, error: noScreenshotToolMessage(process.platform) };
+    }
+    try {
+      await execFileAsync(plan.command, plan.args, { timeout: SCREENSHOT_TIMEOUT_MS });
+    } catch (err) {
+      const detail = err instanceof Error && err.message ? ` (${err.message})` : "";
+      return { ok: false, error: `${plan.command} failed to capture the screen${detail}` };
+    }
+    const buf = await readFile4(outputFile).catch(() => null);
+    if (!buf || buf.length === 0) {
+      return { ok: false, error: `${plan.command} produced no image file` };
+    }
+    if (!probeImageDimensions(buf)) {
+      return { ok: false, error: `${plan.command} produced an unrecognized image file` };
+    }
+    const downsampled = await downsampleImageIfNeeded({
+      path: "screen",
+      mimeType: "image/png",
+      data: buf.toString("base64")
+    });
+    if (downsampled.oversized && !downsampled.resized) {
+      return {
+        ok: false,
+        error: "screenshot exceeds 2000px and could not be downsampled on this platform"
+      };
+    }
+    return { ok: true, image: downsampled.image };
+  } finally {
+    await unlink(outputFile).catch(() => {
+    });
+  }
+}
+
+// src/tools/screenshot.ts
+var schema7 = z7.object({});
+function createScreenshotTool(capture = captureScreenshot) {
+  return {
+    name: "screenshot",
+    description: "Capture a screenshot of the primary display and see it. Use this to check the actual visual result of a running program (web page, GUI) \u2014 e.g. after starting a dev server \u2014 instead of inferring from code. The capture shows exactly what is visible on screen, including overlapping windows: content hidden behind other windows cannot be seen, so if a specific window matters ask the user to bring it to the front first. Note the capture may include anything else currently on screen.",
+    permission: "read",
+    parameters: schema7,
+    async execute(_args, ctx) {
+      if (ctx.visionEnabled === false) {
+        return {
+          content: "The active model does not support image input (vision = false), so no screenshot was taken. Work from text instead, or ask the user to describe what is on screen.",
+          isError: true
+        };
+      }
+      const result = await capture();
+      if (!result.ok) {
+        return { content: `Screenshot failed: ${result.error}`, isError: true };
+      }
+      const image = result.image;
+      const dims = probeImageDimensions(Buffer.from(image.data, "base64"));
+      const sizeKB = Math.round(image.data.length / 1024);
+      const desc = dims ? `${dims.width}x${dims.height}` : "unknown dimensions";
+      return {
+        content: `Screenshot captured (${desc}, ~${sizeKB}KB). The image is attached below \u2014 look at it now.`,
+        images: [image]
+      };
+    }
+  };
+}
+var screenshotTool = createScreenshotTool();
+
+// src/tools/tasks.ts
+import { z as z8 } from "zod";
+
+// src/tasks/format.ts
+function formatDuration(startedAt, endedAt) {
+  const seconds = Math.max(0, Math.round(((endedAt ?? Date.now()) - startedAt) / 1e3));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m${seconds % 60}s`;
+  return `${Math.floor(minutes / 60)}h${minutes % 60}m`;
+}
+function formatStatus(task) {
+  const duration = formatDuration(task.startedAt, task.endedAt);
+  if (task.status === "running") return `running ${duration}`;
+  const exit = task.exitCode === null || task.exitCode === void 0 ? "" : `, exit ${task.exitCode}`;
+  return `${task.status}${exit} after ${duration}`;
+}
+function formatTaskLine(task) {
+  const label = task.description ? `${task.description} (${task.command})` : task.command;
+  return `${task.id} [${formatStatus(task)}] ${label}`;
+}
+function formatTaskList(tasks) {
+  if (tasks.length === 0) return "No background tasks.";
+  return `Background tasks:
+${tasks.map(formatTaskLine).join("\n")}`;
+}
+function formatTaskStarted(task) {
+  const label = task.description ? `${task.description} (${task.command})` : task.command;
+  return `Background task ${task.id} started: ${label}`;
+}
+function formatTaskFinished(task) {
+  const exit = task.exitCode === null || task.exitCode === void 0 ? "" : ` (exit ${task.exitCode})`;
+  switch (task.status) {
+    case "completed":
+      return `Background task ${task.id} finished${exit}: ${task.command}`;
+    case "failed":
+      return `Background task ${task.id} failed${exit}: ${task.command}`;
+    case "timed_out":
+      return `Background task ${task.id} timed out: ${task.command}`;
+    case "stopped":
+      return `Background task ${task.id} stopped: ${task.command}`;
+    default:
+      return `Background task ${task.id}: ${task.command}`;
+  }
+}
+
+// src/tools/tasks.ts
+var idSchema = z8.object({
+  id: z8.string().describe("Task id, e.g. task-1 or agent-1")
+});
+function truncateOutput(s) {
+  if (s.length <= MAX_OUTPUT) return s;
+  return `[... earlier output truncated; showing the last ${MAX_OUTPUT} characters ...]
+${s.slice(-MAX_OUTPUT)}`;
+}
+function callerId(ctx) {
+  return ctx.agentId ?? "root";
+}
+function accessibleShellTask(ctx, id) {
+  const task = defaultTaskManager.get(id);
+  if (!task) return void 0;
+  const caller = callerId(ctx);
+  return caller === "root" || task.ownerId === caller ? task : void 0;
+}
+function formatAgentTaskLine(task) {
+  const duration = formatDuration(task.startedAt, task.endedAt);
+  const label = task.description ?? task.prompt.slice(0, 60);
+  const status = task.status === "running" ? `running ${duration}` : `${task.status} after ${duration}`;
+  return `${task.id} [${status}] ${label}`;
+}
+var taskListTool = {
+  name: "task_list",
+  description: "List background tasks (shell commands and subagents) with status and runtime.",
+  permission: "read",
+  parameters: z8.object({}),
+  execute(_args, ctx) {
+    const caller = callerId(ctx);
+    const shell = formatTaskList(
+      defaultTaskManager.list().filter((t) => caller === "root" || t.ownerId === caller)
+    );
+    const agents = caller === "root" ? defaultAgentTasks.list() : [];
+    const agentLines = agents.length === 0 ? "No background subagents." : `Background subagents:
+${agents.map(formatAgentTaskLine).join("\n")}`;
+    return Promise.resolve({ content: `${shell}
+${agentLines}` });
+  }
+};
+var taskOutputTool = {
+  name: "task_output",
+  description: "Read the current output of a background task (shell command or subagent; works while still running).",
+  permission: "read",
+  parameters: idSchema,
+  execute(args, ctx) {
+    const shell = accessibleShellTask(ctx, args.id);
+    if (shell) {
+      const body = truncateOutput(shell.output.replace(/\s+$/, "") || "(no output yet)");
+      return Promise.resolve({ content: `${formatTaskLine(shell)}
+${body}` });
+    }
+    const agent = callerId(ctx) === "root" ? defaultAgentTasks.get(args.id) : void 0;
+    if (agent) {
+      const body = agent.status === "running" ? "(still running)" : truncateOutput(agent.result.replace(/\s+$/, "") || "(no report)");
+      return Promise.resolve({ content: `${formatAgentTaskLine(agent)}
+${body}` });
+    }
+    return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
+  }
+};
+var taskKillTool = {
+  name: "task_kill",
+  description: "Stop a running background task (shell command process tree or subagent).",
+  permission: "exec",
+  parameters: idSchema,
+  execute(args, ctx) {
+    const shell = accessibleShellTask(ctx, args.id);
+    const agent = shell || callerId(ctx) !== "root" ? void 0 : defaultAgentTasks.get(args.id);
+    const task = shell ?? agent;
+    if (!task) {
+      return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
+    }
+    if (task.status !== "running") {
+      return Promise.resolve({
+        content: `Task ${args.id} is not running (status: ${task.status}).`,
+        isError: true
+      });
+    }
+    if (shell) {
+      defaultTaskManager.kill(args.id);
+    } else {
+      defaultAgentTasks.kill(args.id);
+    }
+    return Promise.resolve({ content: `Task ${args.id} stopped.` });
+  }
+};
+
+// src/tools/web/search.ts
+import { z as z9 } from "zod";
+
+// src/llm/debug.ts
+import { appendFileSync } from "fs";
+import path8 from "path";
+function debugStreamLog(event, data) {
+  if (!process.env.STAR_DEBUG) return;
+  try {
+    const line = `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), event, ...data })}
+`;
+    appendFileSync(path8.join(starHome(), "debug.log"), line);
+  } catch {
+  }
+}
+
+// src/tools/web/search.ts
+var TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_RESULTS = 5;
+var MAX_RESULTS_LIMIT = 10;
+var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+var schema8 = z9.object({
+  query: z9.string().min(1).describe("The search query"),
+  maxResults: z9.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
+    `Maximum number of results to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS_LIMIT})`
+  )
+});
+function stripTags(s) {
+  return decodeEntities(s.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
+}
+function normalizeUrl(href) {
+  const decoded = decodeEntities(href);
+  const uddg = decoded.match(/[?&]uddg=([^&]+)/);
+  if (uddg?.[1]) {
+    try {
+      return decodeURIComponent(uddg[1]);
+    } catch {
+      return decoded;
+    }
+  }
+  if (decoded.startsWith("//")) {
+    return `https:${decoded}`;
+  }
+  return decoded;
+}
+function hrefOf(tag) {
+  const match = tag.match(/href\s*=\s*"([^"]*)"/i) ?? tag.match(/href\s*=\s*'([^']*)'/i);
+  return match?.[1];
+}
+function parseResults(html) {
+  const results = [];
+  const anchorRe = /<a\b[^>]*\bclass\s*=\s*"[^"]*\bresult__a\b[^"]*"[^>]*>[\s\S]*?<\/a>/gi;
+  const anchors = [...html.matchAll(anchorRe)];
+  for (const [i, anchor] of anchors.entries()) {
+    const full = anchor[0];
+    const href = hrefOf(full);
+    if (!href) {
+      continue;
+    }
+    const url = normalizeUrl(href);
+    const title = stripTags(full.replace(/^<a\b[^>]*>/i, "").replace(/<\/a>\s*$/i, ""));
+    const blockStart = (anchor.index ?? 0) + full.length;
+    const blockEnd = i + 1 < anchors.length ? anchors[i + 1]?.index ?? html.length : html.length;
+    const block = html.slice(blockStart, blockEnd);
+    const snippetMatch = block.match(
+      /<(?:a|div)\b[^>]*\bclass\s*=\s*"[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/(?:a|div)>/i
+    );
+    const snippet = snippetMatch?.[1] ? stripTags(snippetMatch[1]) : "";
+    if (title && url) {
+      results.push({ title, url, snippet });
+    }
+  }
+  return results;
+}
+function parseDdgLiteResults(html) {
+  const results = [];
+  const anchorRe = /<a\b[^>]*\bclass\s*=\s*["'][^"']*\bresult-link\b[^"']*["'][^>]*>[\s\S]*?<\/a>/gi;
+  const anchors = [...html.matchAll(anchorRe)];
+  for (const [i, anchor] of anchors.entries()) {
+    const full = anchor[0];
+    const href = hrefOf(full);
+    if (!href) {
+      continue;
+    }
+    const url = normalizeUrl(href);
+    const title = stripTags(full.replace(/^<a\b[^>]*>/i, "").replace(/<\/a>\s*$/i, ""));
+    const blockStart = (anchor.index ?? 0) + full.length;
+    const blockEnd = i + 1 < anchors.length ? anchors[i + 1]?.index ?? html.length : html.length;
+    const block = html.slice(blockStart, blockEnd);
+    const snippetMatch = block.match(
+      /<td\b[^>]*\bclass\s*=\s*["'][^"']*\bresult-snippet\b[^"']*["'][^>]*>([\s\S]*?)<\/td>/i
+    );
+    const snippet = snippetMatch?.[1] ? stripTags(snippetMatch[1]) : "";
+    if (title && url) {
+      results.push({ title, url, snippet });
+    }
+  }
+  return results;
+}
+function parseBingResults(html) {
+  const results = [];
+  const blockRe = /<li\b[^>]*\bclass\s*=\s*"[^"]*\bb_algo\b[^"]*"[^>]*>/gi;
+  const blocks = [...html.matchAll(blockRe)];
+  for (const [i, block] of blocks.entries()) {
+    const start = block.index ?? 0;
+    const end = i + 1 < blocks.length ? blocks[i + 1]?.index ?? html.length : html.length;
+    const slice = html.slice(start, end);
+    const headMatch = slice.match(
+      /<h2\b[^>]*>[\s\S]*?<a\b[^>]*?\shref\s*=\s*"([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<\/h2>/i
+    );
+    if (!headMatch) {
+      continue;
+    }
+    const url = decodeEntities(headMatch[1] ?? "").trim();
+    const title = stripTags(headMatch[2] ?? "");
+    const snippetMatch = slice.match(/<p\b[^>]*>([\s\S]*?)<\/p>/i);
+    const snippet = snippetMatch?.[1] ? stripTags(snippetMatch[1]) : "";
+    if (title && /^https?:\/\//.test(url)) {
+      results.push({ title, url, snippet });
+    }
+  }
+  return results;
+}
+var SEARCH_SOURCES = [
+  {
+    name: "duckduckgo-html",
+    buildUrl: (query) => `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+    parse: parseResults
+  },
+  {
+    name: "duckduckgo-lite",
+    buildUrl: (query) => `https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`,
+    parse: parseDdgLiteResults
+  },
+  {
+    name: "bing",
+    buildUrl: (query) => `https://www.bing.com/search?q=${encodeURIComponent(query)}`,
+    parse: parseBingResults
+  }
+];
+var webSearchTool = {
+  name: "web_search",
+  description: "Search the web and return a numbered list of results with title, URL and snippet. Uses DuckDuckGo with automatic fallback to DuckDuckGo Lite and Bing when a source fails or returns nothing. No API key required. Use web_fetch to read a result's full page.",
+  permission: "read",
+  parameters: schema8,
+  async execute(args, ctx) {
+    const maxResults = Math.min(args.maxResults ?? DEFAULT_MAX_RESULTS, MAX_RESULTS_LIMIT);
+    const failures = [];
+    for (const source of SEARCH_SOURCES) {
+      const timeoutSignal = AbortSignal.timeout(TIMEOUT_MS);
+      const signal = ctx.abortSignal ? AbortSignal.any([timeoutSignal, ctx.abortSignal]) : timeoutSignal;
+      let res;
+      try {
+        res = await fetch(source.buildUrl(args.query), {
+          signal,
+          redirect: "follow",
+          headers: { "user-agent": USER_AGENT, accept: "text/html" }
+        });
+      } catch (err) {
+        if (ctx.abortSignal?.aborted) {
+          return { content: "ERROR: request aborted", isError: true };
+        }
+        const name = err instanceof Error ? err.name : "";
+        if (timeoutSignal.aborted || name === "TimeoutError") {
+          failures.push(`${source.name}: search timed out after ${TIMEOUT_MS / 1e3}s`);
+        } else {
+          const message = err instanceof Error ? err.message : String(err);
+          failures.push(`${source.name}: search request failed: ${message}`);
+        }
+        continue;
+      }
+      if (!res.ok) {
+        await res.body?.cancel().catch(() => {
+        });
+        failures.push(`${source.name}: HTTP ${res.status} ${res.statusText}`);
+        continue;
+      }
+      let html;
+      try {
+        html = await res.text();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        failures.push(`${source.name}: failed to read search response: ${message}`);
+        continue;
+      }
+      const results = source.parse(html).slice(0, maxResults);
+      if (results.length === 0) {
+        failures.push(
+          `${source.name}: no results found (the response may have been blocked or the page layout changed)`
+        );
+        continue;
+      }
+      debugStreamLog("web_search", {
+        source: source.name,
+        query: args.query,
+        results: results.length,
+        failures
+      });
+      const lines = results.map(
+        (r, i) => `${i + 1}. ${r.title}
+   ${r.url}${r.snippet ? `
+   ${r.snippet}` : ""}`
+      );
+      return { content: lines.join("\n") };
+    }
+    debugStreamLog("web_search_failed", { query: args.query, failures });
+    return {
+      content: `ERROR: web search failed for "${args.query}" \u2014 ${failures.join("; ")}`,
+      isError: true
+    };
+  }
+};
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  // todoStore defaults to the module-level shared store; subagent loops pass
+  // their own instance so a child's todo_write cannot clobber the parent list.
+  constructor(todoStore) {
+    for (const tool of [
+      // Fresh per registry (i.e. per agent loop): the unchanged-since-last-
+      // read cache must not leak across loops, whose contexts differ.
+      createReadFileTool(),
+      readImageTool,
+      screenshotTool,
+      writeFileTool,
+      editFileTool,
+      globTool,
+      grepTool,
+      bashTool,
+      webFetchTool,
+      webSearchTool,
+      taskListTool,
+      taskOutputTool,
+      taskKillTool,
+      ...createTodoTools(todoStore)
+    ]) {
+      this.register(tool);
+    }
+  }
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  // Drops per-session volatile tool state after a wholesale history rewrite
+  // (compaction, /undo, resume): anything a tool remembers as "already sent
+  // to the model" may no longer be in the context.
+  resetVolatileState() {
+    for (const tool of this.tools.values()) tool.reset?.();
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  names() {
+    return [...this.tools.keys()];
+  }
+};
+
+// src/tools/index.ts
+function createDefaultRegistry(todoStore) {
+  return new ToolRegistry(todoStore);
+}
+
+export {
+  debugStreamLog,
+  formatTaskList,
+  formatTaskStarted,
+  formatTaskFinished,
+  ToolRegistry,
+  createDefaultRegistry
+};
+//# sourceMappingURL=chunk-OIJYNQFZ.js.map