clixad 0.0.1-beta.13 → 0.0.1-beta.15

package/dist/clixad.mjs

@@ -604,7 +604,12 @@ var init_client = __esm({
         const calls = /* @__PURE__ */ new Map();
         for await (const evt of parseSSE(res.body)) {
           if (evt === "[DONE]") break;
-          const json = JSON.parse(evt);
+          let json;
+          try {
+            json = JSON.parse(evt);
+          } catch {
+            continue;
+          }
           const choice = json.choices?.[0];
           const delta = choice?.delta?.content;
           if (delta) {
@@ -1239,12 +1244,13 @@ function installExitHook(registry) {
     });
   }
 }
-var MAX_SHELL_BUFFER, MAX_SHELLS, ShellError, ShellRegistry, shells, hookInstalled;
+var MAX_SHELL_BUFFER, MAX_SHELLS, MAX_FINISHED_SHELLS, ShellError, ShellRegistry, shells, hookInstalled;
 var init_shells = __esm({
   "src/shells.ts"() {
     "use strict";
     MAX_SHELL_BUFFER = 2e5;
     MAX_SHELLS = 8;
+    MAX_FINISHED_SHELLS = 8;
     ShellError = class extends Error {
     };
     ShellRegistry = class {
@@ -1252,21 +1258,27 @@ var init_shells = __esm({
       seq = 0;
       /** Start a command in the background and return it before it has finished. */
       start(root, command, now = Date.now()) {
+        this.pruneFinished();
         const live = [...this.entries.values()].filter((e) => e.status === "running");
         if (live.length >= MAX_SHELLS) {
           throw new ShellError(
             `${MAX_SHELLS} background commands are already running (${live.map((e) => e.id).join(", ")}) \u2014 stop one with kill_shell before starting another`
           );
         }
-        const child = spawn2(command, {
-          cwd: root,
-          shell: true,
-          windowsHide: true,
-          detached: process.platform !== "win32",
-          // Nothing types at a background command, and leaving stdin inherited lets
-          // it steal the keystrokes meant for the REPL.
-          stdio: ["ignore", "pipe", "pipe"]
-        });
+        let child;
+        try {
+          child = spawn2(command, {
+            cwd: root,
+            shell: true,
+            windowsHide: true,
+            detached: process.platform !== "win32",
+            // Nothing types at a background command, and leaving stdin inherited
+            // lets it steal the keystrokes meant for the REPL.
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+        } catch (err) {
+          throw new ShellError(`could not start that command: ${err.message}`);
+        }
         const entry = {
           id: `bash_${++this.seq}`,
           command,
@@ -1339,10 +1351,23 @@ var init_shells = __esm({
       list(now = Date.now()) {
         return [...this.entries.values()].map((e) => snapshot(e, now));
       }
-      /** Forget a finished shell. Running ones are kept — see `killAll`. */
-      forget(id) {
-        const entry = this.entries.get(id);
-        if (entry && entry.status !== "running") this.entries.delete(id);
+      /**
+       * Forget all but the most recent `MAX_FINISHED_SHELLS` finished commands.
+       *
+       * Run when a new one starts, which is the only moment the registry grows.
+       * Running commands are never touched — those are `killAll`'s and
+       * `kill`'s — and the Map's insertion order is the start order, so "oldest"
+       * needs no timestamp.
+       *
+       * This replaces a `forget(id)` that nothing ever called: an explicit
+       * single-entry drop is only useful to a caller who knows a shell is finished
+       * with, and neither the tools nor the REPL is in a position to know that.
+       */
+      pruneFinished() {
+        const finished = [...this.entries.values()].filter((e) => e.status !== "running");
+        for (const entry of finished.slice(0, Math.max(0, finished.length - MAX_FINISHED_SHELLS))) {
+          this.entries.delete(entry.id);
+        }
       }
       /** Stop everything. Called on exit; safe to call more than once. */
       killAll() {
@@ -2189,6 +2214,64 @@ function passesThrough(err) {
   if (err instanceof PaywallError) return true;
   return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
 }
+function fsCall(what, run) {
+  try {
+    return run();
+  } catch (err) {
+    if (passesThrough(err)) throw err;
+    const code = err.code ?? "";
+    throw new ToolError(`${what}: ${FS_REASON[code] ?? err.message}`);
+  }
+}
+function countArg(raw, fallback) {
+  const n = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : Number.NaN;
+  return Number.isFinite(n) ? Math.max(1, Math.floor(n)) : fallback;
+}
+function requireString(value, tool, field) {
+  const text = readString(value);
+  if (text === void 0) {
+    throw new ToolError(`${tool}: ${field} must be a string, got ${describeValue(value)}`);
+  }
+  return text;
+}
+function optionalString(value, tool, field) {
+  if (value === void 0 || value === null) return void 0;
+  return requireString(value, tool, field);
+}
+function readString(value) {
+  if (typeof value === "string") return value;
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : void 0;
+}
+function describeValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "nothing";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "number") return "an unusable number";
+  return typeof value === "object" ? "an object" : `a ${typeof value}`;
+}
+function entryKind(entry, abs) {
+  if (entry.isDirectory()) return "dir";
+  if (entry.isFile()) return "file";
+  if (!entry.isSymbolicLink()) return "other";
+  try {
+    const stat = statSync(abs);
+    return stat.isDirectory() ? "dir" : stat.isFile() ? "file" : "other";
+  } catch {
+    return "other";
+  }
+}
+function isFilePath(abs) {
+  try {
+    return statSync(abs).isFile();
+  } catch {
+    return false;
+  }
+}
+function searchBase(ctx, path) {
+  const abs = safeResolve(ctx.root, path ?? ".");
+  if (!existsSync2(abs)) throw new ToolError(`not found: ${path ?? "."}`);
+  return abs;
+}
 function commandSignature(command) {
   return `run:${command.replace(/\s+/g, " ").trim()}`;
 }
@@ -2299,13 +2382,19 @@ async function runMcpTool(ctx, name, args) {
 }
 function execute(ctx, command, timeout) {
   return new Promise((resolvePromise) => {
-    const child = spawn4(command, {
-      cwd: ctx.root,
-      shell: true,
-      windowsHide: true,
-      // Own process group on POSIX so killTree can take the children with it.
-      detached: process.platform !== "win32"
-    });
+    let child;
+    try {
+      child = spawn4(command, {
+        cwd: ctx.root,
+        shell: true,
+        windowsHide: true,
+        // Own process group on POSIX so killTree can take the children with it.
+        detached: process.platform !== "win32"
+      });
+    } catch (err) {
+      return resolvePromise(`command failed to start: ${err.message}
+(no output)`);
+    }
     let out = "";
     let total = 0;
     let timedOut = false;
@@ -2352,6 +2441,10 @@ function listWorkspaceFiles(root, limit = 5e3) {
   return files.sort();
 }
 function walk(dir, root, visit) {
+  if (isFilePath(dir)) {
+    visit(dir);
+    return;
+  }
   let seen = 0;
   const stack = [dir];
   while (stack.length > 0) {
@@ -2364,12 +2457,13 @@ function walk(dir, root, visit) {
     }
     for (const entry of entries) {
       const abs = join3(current, entry.name);
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      const kind = entryKind(entry, abs);
+      if (kind === "dir") {
+        if (entry.isSymbolicLink() || SKIP_DIRS.has(entry.name)) continue;
         stack.push(abs);
         continue;
       }
-      if (!entry.isFile()) continue;
+      if (kind !== "file") continue;
       if (++seen > MAX_WALK_FILES) return;
       if (!visit(abs)) return;
     }
@@ -2377,8 +2471,9 @@ function walk(dir, root, visit) {
   void root;
 }
 function globToRegExp(pattern) {
-  const p = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+  const p = requireString(pattern, "glob", "pattern").replace(/\\/g, "/").replace(/^\.\//, "");
   let re = "";
+  let depth = 0;
   for (let i = 0; i < p.length; i++) {
     const ch = p[i];
     if (ch === "*") {
@@ -2394,14 +2489,23 @@ function globToRegExp(pattern) {
         re += "[^/]*";
       }
     } else if (ch === "?") re += "[^/]";
-    else if (ch === "{") re += "(?:";
-    else if (ch === "}") re += ")";
-    else if (ch === ",") re += "|";
-    else if (".+^$()[]|\\".includes(ch)) re += "\\" + ch;
+    else if (ch === "{") {
+      re += "(?:";
+      depth++;
+    } else if (ch === "}" && depth > 0) {
+      re += ")";
+      depth--;
+    } else if (ch === "," && depth > 0) re += "|";
+    else if (".+^$()[]|\\{}".includes(ch)) re += "\\" + ch;
     else re += ch;
   }
+  re += ")".repeat(depth);
   const anchored = p.includes("/") ? `^${re}$` : `^(?:.*/)?${re}$`;
-  return new RegExp(anchored);
+  try {
+    return new RegExp(anchored);
+  } catch (err) {
+    throw new ToolError(`not a usable glob pattern: ${pattern} \u2014 ${err.message}`);
+  }
 }
 function toolSchemaFor(mode, mcpSchemas = [], available = {}) {
   const usable = (t) => t.function.name !== "web_search" || available.webSearch === true;
@@ -2416,7 +2520,7 @@ function subagentToolSchema(available = {}) {
     (t) => SUBAGENT_TOOLS.includes(t.function.name) && (t.function.name !== "web_search" || available.webSearch === true)
   );
 }
-var ToolError, PermissionDeniedError, MAX_FILE_BYTES, MAX_READ_LINES, MAX_READ_LINE_CHARS, MAX_OUTPUT_CHARS, MAX_GLOB_RESULTS, MAX_GREP_MATCHES, MAX_WALK_FILES, DEFAULT_COMMAND_TIMEOUT, MAX_IMAGE_BYTES, DEFAULT_SEARCH_RESULTS, MAX_SEARCH_RESULTS, MAX_ASK_OPTIONS, BACKGROUND_SETTLE_MS, SKIP_DIRS, TOOLS, READ_ONLY_TOOLS, EXIT_PLAN_MODE_SCHEMA, SUBAGENT_TOOLS, TOOL_SCHEMA;
+var ToolError, PermissionDeniedError, FS_REASON, MAX_FILE_BYTES, MAX_READ_LINES, MAX_READ_LINE_CHARS, MAX_OUTPUT_CHARS, MAX_GLOB_RESULTS, MAX_GREP_MATCHES, MAX_WALK_FILES, DEFAULT_COMMAND_TIMEOUT, MAX_IMAGE_BYTES, DEFAULT_SEARCH_RESULTS, MAX_SEARCH_RESULTS, MAX_ASK_OPTIONS, BACKGROUND_SETTLE_MS, SKIP_DIRS, TOOLS, READ_ONLY_TOOLS, EXIT_PLAN_MODE_SCHEMA, SUBAGENT_TOOLS, TOOL_SCHEMA;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
@@ -2436,6 +2540,19 @@ var init_tools = __esm({
         this.notice = notice;
       }
     };
+    FS_REASON = {
+      ENOTDIR: "it is a file, not a directory \u2014 use read_file",
+      EISDIR: "it is a directory, not a file \u2014 use list_dir, or edit a file inside it",
+      ENOENT: "it does not exist (a symlink pointing at nothing looks like this too)",
+      EACCES: "permission denied",
+      EPERM: "permission denied",
+      ELOOP: "the path goes through a symlink loop",
+      ENAMETOOLONG: "the path is too long",
+      EMFILE: "this process has too many files open \u2014 try again",
+      ENFILE: "the system has too many files open \u2014 try again",
+      ENOSPC: "the disk is full",
+      EROFS: "the filesystem is read-only"
+    };
     MAX_FILE_BYTES = 4e5;
     MAX_READ_LINES = 2e3;
     MAX_READ_LINE_CHARS = 2e3;
@@ -2450,16 +2567,37 @@ var init_tools = __esm({
     MAX_ASK_OPTIONS = 6;
     BACKGROUND_SETTLE_MS = 500;
     SKIP_DIRS = /* @__PURE__ */ new Set([
+      // Version control.
       ".git",
+      ".hg",
+      ".svn",
+      // Dependencies and their caches.
       "node_modules",
+      ".yarn",
+      ".pnpm-store",
+      ".venv",
+      ".tox",
+      // Build output.
       "dist",
       "build",
       "coverage",
       ".next",
+      ".nuxt",
+      ".svelte-kit",
+      ".output",
+      ".angular",
+      ".dart_tool",
+      // Tool caches.
       ".turbo",
+      ".nx",
       ".cache",
+      ".parcel-cache",
+      ".gradle",
       "__pycache__",
-      ".venv"
+      ".mypy_cache",
+      ".pytest_cache",
+      ".ruff_cache",
+      ".terraform"
     ]);
     TOOLS = {
       /**
@@ -2478,11 +2616,14 @@ var init_tools = __esm({
        * is told precisely what went wrong instead of guessing.
        */
       read_file(ctx, args) {
-        const abs = safeResolve(ctx.root, args.path);
-        if (!existsSync2(abs)) throw new ToolError(`not found: ${args.path}`);
-        if (statSync(abs).isDirectory()) throw new ToolError(`${args.path} is a directory \u2014 use list_dir`);
-        const bytes = readFileSync3(abs);
+        const path = requireString(args.path, "read_file", "path");
+        const abs = safeResolve(ctx.root, path);
+        if (!existsSync2(abs)) throw new ToolError(`not found: ${path}`);
         const name = rel(ctx.root, abs);
+        if (fsCall(`cannot read ${name}`, () => statSync(abs)).isDirectory()) {
+          throw new ToolError(`${path} is a directory \u2014 use list_dir`);
+        }
+        const bytes = fsCall(`cannot read ${name}`, () => readFileSync3(abs));
         const image = imageType(bytes);
         if (image) return readImage(ctx, bytes, name, image);
         if (looksLikePdf(bytes)) {
@@ -2503,11 +2644,11 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
         const raw = bytes.toString("utf8");
         const all = raw.split("\n");
         const total = all.length > 1 && all[all.length - 1] === "" ? all.length - 1 : all.length;
-        const first = Math.max(1, Math.floor(args.offset ?? 1));
-        const want = Math.max(1, Math.floor(args.limit ?? MAX_READ_LINES));
+        const first = countArg(args.offset, 1);
+        const want = countArg(args.limit, MAX_READ_LINES);
         const last = Math.min(total, first + want - 1);
         if (first > total) {
-          return `${args.path} has ${total} lines; offset ${first} is past the end`;
+          return `${path} has ${total} lines; offset ${first} is past the end`;
         }
         const body = all.slice(first - 1, last).map((line2, i) => {
           const n = String(first + i).padStart(5, " ");
@@ -2523,27 +2664,35 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
         return body + note;
       },
       list_dir(ctx, args) {
-        const abs = safeResolve(ctx.root, args.path ?? ".");
-        if (!existsSync2(abs)) throw new ToolError(`not found: ${args.path ?? "."}`);
-        const entries = readdirSync(abs).map((name) => {
-          const isDir = statSync(resolve(abs, name)).isDirectory();
-          return { name: isDir ? `${name}/` : name, isDir };
-        });
+        const path = optionalString(args.path, "list_dir", "path") ?? ".";
+        const abs = safeResolve(ctx.root, path);
+        if (!existsSync2(abs)) throw new ToolError(`not found: ${path}`);
+        const name = rel(ctx.root, abs);
+        if (!fsCall(`cannot list ${name}`, () => statSync(abs)).isDirectory()) {
+          throw new ToolError(`${path} is a file \u2014 use read_file`);
+        }
+        const entries = fsCall(`cannot list ${name}`, () => readdirSync(abs, { withFileTypes: true })).map(
+          (entry) => {
+            const isDir = entryKind(entry, resolve(abs, entry.name)) === "dir";
+            return { name: isDir ? `${entry.name}/` : entry.name, isDir };
+          }
+        );
         entries.sort((a, b) => Number(b.isDir) - Number(a.isDir) || a.name.localeCompare(b.name));
         return entries.map((e) => e.name).join("\n") || "(empty)";
       },
       /** Find files by glob, e.g. `src/**\/*.ts`. Cheap orientation before reading. */
       glob(ctx, args) {
-        if (!args.pattern) throw new ToolError("glob needs a pattern");
-        const base = safeResolve(ctx.root, args.path ?? ".");
-        const re = globToRegExp(args.pattern);
+        const pattern = optionalString(args.pattern, "glob", "pattern");
+        if (!pattern) throw new ToolError("glob needs a pattern");
+        const base = searchBase(ctx, optionalString(args.path, "glob", "path"));
+        const re = globToRegExp(pattern);
         const hits = [];
         walk(base, ctx.root, (abs) => {
           const r = rel(ctx.root, abs);
           if (re.test(r)) hits.push(r);
           return hits.length < MAX_GLOB_RESULTS;
         });
-        if (hits.length === 0) return `no files match ${args.pattern}`;
+        if (hits.length === 0) return `no files match ${pattern}`;
         hits.sort();
         const more = hits.length >= MAX_GLOB_RESULTS ? `
 \u2026 [capped at ${MAX_GLOB_RESULTS}]` : "";
@@ -2551,15 +2700,17 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
       },
       /** Search file contents with a regular expression; returns path:line: text. */
       grep(ctx, args) {
-        if (!args.pattern) throw new ToolError("grep needs a pattern");
+        const pattern = optionalString(args.pattern, "grep", "pattern");
+        if (!pattern) throw new ToolError("grep needs a pattern");
         let re;
         try {
-          re = new RegExp(args.pattern);
+          re = new RegExp(pattern);
         } catch (err) {
           throw new ToolError(`invalid regular expression: ${err.message}`);
         }
-        const base = safeResolve(ctx.root, args.path ?? ".");
-        const filter = args.glob ? globToRegExp(args.glob) : void 0;
+        const base = searchBase(ctx, optionalString(args.path, "grep", "path"));
+        const globArg = optionalString(args.glob, "grep", "glob");
+        const filter = globArg ? globToRegExp(globArg) : void 0;
         const out = [];
         walk(base, ctx.root, (abs) => {
           const r = rel(ctx.root, abs);
@@ -2580,24 +2731,28 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
           }
           return true;
         });
-        if (out.length === 0) return `no matches for ${args.pattern}`;
+        if (out.length === 0) return `no matches for ${pattern}`;
         const more = out.length >= MAX_GREP_MATCHES ? `
 \u2026 [capped at ${MAX_GREP_MATCHES} matches]` : "";
         return out.join("\n") + more;
       },
       async write_file(ctx, args) {
-        const abs = safeResolve(ctx.root, args.path);
-        const before = existsSync2(abs) ? readFileSync3(abs, "utf8") : "";
-        const preview = renderDiff(before, args.content) || "(no change)";
+        const abs = safeResolve(ctx.root, requireString(args.path, "write_file", "path"));
+        const content = requireString(args.content, "write_file", "content");
+        const name = rel(ctx.root, abs);
+        const before = existsSync2(abs) ? fsCall(`cannot write ${name}`, () => readFileSync3(abs, "utf8")) : "";
+        const preview = renderDiff(before, content) || "(no change)";
         await gate(ctx, {
           tool: "write_file",
-          signature: `write:${rel(ctx.root, abs)}`,
-          summary: `${before ? "overwrite" : "create"} ${rel(ctx.root, abs)}`,
+          signature: `write:${name}`,
+          summary: `${before ? "overwrite" : "create"} ${name}`,
           preview
         });
-        mkdirSync2(dirname2(abs), { recursive: true });
-        writeFileSync2(abs, args.content, "utf8");
-        return `wrote ${args.content.length} bytes to ${rel(ctx.root, abs)}`;
+        fsCall(`cannot write ${name}`, () => {
+          mkdirSync2(dirname2(abs), { recursive: true });
+          writeFileSync2(abs, content, "utf8");
+        });
+        return `wrote ${content.length} bytes to ${name}`;
       },
       /**
        * Replace an exact snippet in a file. Preferred over write_file: it keeps the
@@ -2605,41 +2760,42 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
        * An ambiguous match is an error rather than a guess.
        */
       async edit_file(ctx, args) {
-        const abs = safeResolve(ctx.root, args.path);
-        if (!existsSync2(abs)) throw new ToolError(`not found: ${args.path}`);
-        if (typeof args.old_string !== "string" || typeof args.new_string !== "string") {
-          throw new ToolError("edit_file needs old_string and new_string");
-        }
-        if (args.old_string === args.new_string) throw new ToolError("old_string and new_string are identical");
-        const before = readFileSync3(abs, "utf8");
-        const count = occurrences(before, args.old_string);
+        const path = requireString(args.path, "edit_file", "path");
+        const abs = safeResolve(ctx.root, path);
+        if (!existsSync2(abs)) throw new ToolError(`not found: ${path}`);
+        const oldString = requireString(args.old_string, "edit_file", "old_string");
+        const newString = requireString(args.new_string, "edit_file", "new_string");
+        if (oldString === newString) throw new ToolError("old_string and new_string are identical");
+        const name = rel(ctx.root, abs);
+        const before = fsCall(`cannot edit ${name}`, () => readFileSync3(abs, "utf8"));
+        const count = occurrences(before, oldString);
         if (count === 0) {
           throw new ToolError(
-            `old_string not found in ${args.path} \u2014 read the file and copy the exact text, without the line numbers read_file puts in front of each line`
+            `old_string not found in ${path} \u2014 read the file and copy the exact text, without the line numbers read_file puts in front of each line`
           );
         }
         if (count > 1 && !args.replace_all) {
           throw new ToolError(
-            `old_string appears ${count} times in ${args.path} \u2014 add more surrounding context, or pass replace_all: true`
+            `old_string appears ${count} times in ${path} \u2014 add more surrounding context, or pass replace_all: true`
           );
         }
-        const after = before.split(args.old_string).join(args.new_string);
+        const after = before.split(oldString).join(newString);
         const preview = renderDiff(before, after) || "(no change)";
         await gate(ctx, {
           tool: "edit_file",
-          signature: `write:${rel(ctx.root, abs)}`,
-          summary: `edit ${rel(ctx.root, abs)}`,
+          signature: `write:${name}`,
+          summary: `edit ${name}`,
           preview
         });
-        writeFileSync2(abs, after, "utf8");
-        return `edited ${rel(ctx.root, abs)} (${count > 1 ? `${count} occurrences` : "1 occurrence"})`;
+        fsCall(`cannot edit ${name}`, () => writeFileSync2(abs, after, "utf8"));
+        return `edited ${name} (${count > 1 ? `${count} occurrences` : "1 occurrence"})`;
       },
       /**
        * Run a shell command in the workspace. Streams output to `ctx.onOutput` as it
        * arrives and dies with `ctx.signal`, so a runaway build can be interrupted.
        */
       async run_command(ctx, args) {
-        const command = (args.command ?? "").trim();
+        const command = (optionalString(args.command, "run_command", "command") ?? "").trim();
         if (!command) throw new ToolError("run_command needs a command");
         const background = args.background === true;
         await gate(ctx, {
@@ -2651,7 +2807,7 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
           summary: `${background ? "run in the background" : "run"} ${command.length > 60 ? command.slice(0, 59) + "\u2026" : command}`,
           preview: command
         });
-        if (!background) return execute(ctx, command, args.timeout ?? DEFAULT_COMMAND_TIMEOUT);
+        if (!background) return execute(ctx, command, countArg(args.timeout, DEFAULT_COMMAND_TIMEOUT));
         const registry = ctx.shells ?? shells;
         let started;
         try {
@@ -2671,7 +2827,7 @@ ${first.output.trim().slice(0, 4e3)}` : "");
       /** Whatever a background command has printed since it was last read. */
       read_output(ctx, args) {
         const registry = ctx.shells ?? shells;
-        const id = (args.shell_id ?? "").trim();
+        const id = (optionalString(args.shell_id, "read_output", "shell_id") ?? "").trim();
         if (!id) {
           const running = registry.list();
           throw new ToolError(
@@ -2680,7 +2836,8 @@ ${first.output.trim().slice(0, 4e3)}` : "");
         }
         let read;
         try {
-          read = registry.read(id, args.filter ? { filter: args.filter } : {});
+          const filter = optionalString(args.filter, "read_output", "filter");
+          read = registry.read(id, filter ? { filter } : {});
         } catch (err) {
           asToolError(err);
         }
@@ -2696,7 +2853,7 @@ ${body || "(nothing new since the last read)"}`;
       },
       async kill_shell(ctx, args) {
         const registry = ctx.shells ?? shells;
-        const id = (args.shell_id ?? "").trim();
+        const id = (optionalString(args.shell_id, "kill_shell", "shell_id") ?? "").trim();
         if (!id) throw new ToolError("kill_shell needs a shell_id");
         await gate(ctx, {
           tool: "kill_shell",
@@ -2719,14 +2876,14 @@ ${body || "(nothing new since the last read)"}`;
        * a context that is billed by the token.
        */
       async web_search(ctx, args) {
-        const query = (args.query ?? "").trim();
+        const query = (optionalString(args.query, "web_search", "query") ?? "").trim();
         if (!query) throw new ToolError("web_search needs a query");
         if (!ctx.webSearch) {
           throw new ToolError(
             "web search is not available in this run \u2014 use web_fetch on a URL you already know instead"
           );
         }
-        const count = Math.max(1, Math.min(MAX_SEARCH_RESULTS, Math.floor(args.count ?? DEFAULT_SEARCH_RESULTS)));
+        const count = Math.min(MAX_SEARCH_RESULTS, countArg(args.count, DEFAULT_SEARCH_RESULTS));
         let results;
         try {
           results = await ctx.webSearch(query, { count, ...ctx.signal ? { signal: ctx.signal } : {} });
@@ -2754,9 +2911,9 @@ ${body || "(nothing new since the last read)"}`;
       async web_fetch(ctx, args) {
         let page;
         try {
-          page = await fetchPage(args.url ?? "", {
+          page = await fetchPage(optionalString(args.url, "web_fetch", "url") ?? "", {
             ...ctx.signal ? { signal: ctx.signal } : {},
-            ...typeof args.max_chars === "number" ? { maxChars: Math.max(1e3, Math.floor(args.max_chars)) } : {}
+            ...args.max_chars === void 0 ? {} : { maxChars: Math.max(1e3, countArg(args.max_chars, MAX_FILE_BYTES)) }
           });
         } catch (err) {
           networkToolError(err);
@@ -2783,8 +2940,8 @@ ${page.text}`;
        * the credits it saves do not pay for that.
        */
       async task(ctx, args) {
-        const prompt = (args.prompt ?? "").trim();
-        const description = (args.description ?? "").trim() || "subagent";
+        const prompt = (optionalString(args.prompt, "task", "prompt") ?? "").trim();
+        const description = (optionalString(args.description, "task", "description") ?? "").trim() || "subagent";
         if (!prompt) throw new ToolError("task needs a prompt describing what to find out");
         if (!ctx.spawn) {
           throw new ToolError(
@@ -2821,7 +2978,7 @@ ${page.text}`;
        * be told something that was not on the list.
        */
       async ask_user(ctx, args) {
-        const question = (args.question ?? "").trim();
+        const question = (optionalString(args.question, "ask_user", "question") ?? "").trim();
         if (!question) throw new ToolError("ask_user needs a question");
         if (!ctx.askUser) {
           throw new ToolError(
@@ -2846,7 +3003,7 @@ ${page.text}`;
        * able to grant itself write access.
        */
       async exit_plan_mode(ctx, args) {
-        const plan = (args.plan ?? "").trim();
+        const plan = (optionalString(args.plan, "exit_plan_mode", "plan") ?? "").trim();
         if (!plan) throw new ToolError("exit_plan_mode needs a plan");
         if (!ctx.approvePlan) {
           throw new ToolError(
@@ -3337,8 +3494,6 @@ var init_agent = __esm({
     "use strict";
     init_tools();
     init_mcp();
-    init_shells();
-    init_web();
     init_client();
     SUBAGENT_MAX_STEPS = 12;
     SYSTEM_PROMPT = "You are Clixad, a terminal coding agent. You can read, search, write and edit files and run shell commands, all confined to the user's workspace. Find your way around with glob and grep before reading whole files. Prefer edit_file over write_file for existing files. Make minimal correct edits, verify them when a test or build command is available, and stop when the task is complete. Keep your final message short: say what you did and why.\n\nNot every message is a task. If the user asks a question, or asks you to say something, answer in plain text and call no tools at all. Reach for a file or a command only when the request is actually about one, and when a message is ambiguous, prefer the reading of it that changes nothing.\n\nA tool call that was refused did not happen. Never describe it as done, and do not repeat it on a later message unless the user asks for it again.\n\nReach outside the workspace when the answer is outside it: web_search for current documentation, releases and error messages, then web_fetch to read the page. Do not guess at an API you could look up.\n\nStart anything that does not exit on its own \u2014 dev servers, watchers, tailed logs \u2014 with run_command background: true, and read it with read_output. A foreground command is killed after its timeout.\n\nWhen finding something out means opening many files, give it to task instead: the sub-agent reads them in its own context and reports back, which keeps this conversation short. Use todo_write for work with several distinct steps, and keep it current as you go.";
@@ -4831,7 +4986,9 @@ function App({ client, config, wallet, session, initialTask, sponsorServe }) {
   const busyAbortRef = useRef(null);
   const filesRef = useRef(null);
   const ctrlCRef = useRef(0);
-  const sessionRef = useRef(session ?? { id: newSessionId(), started: (/* @__PURE__ */ new Date()).toISOString() });
+  const sessionRef = useRef(
+    session ?? { id: newSessionId(), started: (/* @__PURE__ */ new Date()).toISOString() }
+  );
   const runStartedAtRef = useRef(Date.now());
   const contextRef = useRef(collectContext(root));
   const catalogRef = useRef([]);
@@ -5185,16 +5342,14 @@ ${NO_SEARCH_INSTRUCTION}`),
         });
         const next = result.messages.slice(1);
         setMessages(next);
+        sessionRef.current.title ??= (task.split("\n")[0] || task).slice(0, 80);
         saveSession({
           id: sessionRef.current.id,
           started: sessionRef.current.started,
           updated: (/* @__PURE__ */ new Date()).toISOString(),
           cwd: root,
           model,
-          // The first line only: an `@path` message carries the whole file after
-          // a blank line, and a session titled with a file's contents is not a
-          // title. What the user typed is always the first line.
-          title: (session?.title || task.split("\n")[0] || task).slice(0, 80),
+          title: sessionRef.current.title,
           messages: next
         });
         if (result.stopped === "aborted") {
@@ -5248,8 +5403,7 @@ ${NO_SEARCH_INSTRUCTION}`),
       nextSponsor,
       permit,
       push,
-      root,
-      session?.title
+      root
     ]
   );
   const stopCurrent = useCallback(() => {
@@ -5515,7 +5669,7 @@ ${NO_SEARCH_INSTRUCTION}`),
               return;
             }
             setMessages(found.messages);
-            sessionRef.current = { id: found.id, started: found.started };
+            sessionRef.current = { id: found.id, started: found.started, title: found.title };
             push({
               kind: "notice",
               tone: "good",
@@ -5722,9 +5876,27 @@ ${output}` }
     setEditor((state) => insert(state, text2));
     setHistIdx(-1);
   });
+  const dismissModals = useCallback(() => {
+    if (plan) {
+      setPlan(null);
+      plan.resolve("keepPlanning");
+    }
+    if (ask2) {
+      setAsk(null);
+      ask2.resolve("deny");
+    }
+    if (picker) {
+      const cancel = picker.onCancel;
+      setPicker(null);
+      cancel?.();
+    }
+  }, [ask2, picker, plan]);
   useInput((ch, key) => {
     if (key.ctrl && ch === "c") {
-      if (busy) return stopCurrent();
+      if (busy) {
+        dismissModals();
+        return stopCurrent();
+      }
       if (!isEmpty(editor)) return setEditor(EMPTY);
       if (Date.now() - ctrlCRef.current < 2e3) return exit();
       ctrlCRef.current = Date.now();
@@ -6419,6 +6591,7 @@ function logout(config) {
   delete config.token;
   delete config.userId;
   delete config.email;
+  delete config.login;
   saveConfig(config);
   console.log(c.green("\u2713 logged out"));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clixad",
-  "version": "0.0.1-beta.13",
+  "version": "0.0.1-beta.15",
   "description": "Free AI coding agent in your terminal, funded by rewarded ads.",
   "license": "UNLICENSED",
   "type": "module",