aether-code 0.28.0 → 0.30.0

package/bin/aether-code.js

@@ -28,7 +28,7 @@ import {
 import readline from "node:readline";
 import { c, errorLine, divider, setTerminalTitle } from "../src/render.js";
 
-const VERSION = "0.28.0";
+const VERSION = "0.30.0";
 
 /**
  * Try to start MCP servers from ~/.aether/mcp.json. Returns a started

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-code",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "Uncensored AI coding agent for your terminal — Claude Code alternative with MCP support. Reads code, writes files, runs commands. Drives IDA Pro, Roblox Studio, Wireshark, Blender, and any MCP server. No refusal layer.",
   "homepage": "https://trynoguard.com",
   "repository": {

package/src/agent.js

@@ -18,6 +18,17 @@ function envContext(cwd) {
   const home = os.homedir();
   const desktop = path.join(home, "Desktop");
   const documents = path.join(home, "Documents");
+  const win = process.platform === "win32";
+  // OS-specific shell guidance: gemma tends to emit Unix commands (mkdir -p,
+  // touch, &&-chains) which FAIL in Windows cmd.exe ("The syntax of the command
+  // is incorrect"). Steer it to the file tools (which are cross-platform and
+  // auto-create parent dirs) and OS-appropriate shell usage.
+  const shellNote = win
+    ? `shell: Windows cmd.exe. To create files OR directories, use the write_file tool — ` +
+      `it creates any missing parent folders automatically. Do NOT use shell "mkdir -p", ` +
+      `"touch", "ls", "rm", "cp", "mv", or "&&"-chained Unix commands; they FAIL in cmd.exe. ` +
+      `Run programs/tests with their interpreter (python, node, java, etc.).`
+    : `shell: POSIX sh. Standard Unix commands are available. write_file still auto-creates parent dirs.`;
   return (
     `[environment]\n` +
     `os: ${process.platform}\n` +
@@ -25,6 +36,7 @@ function envContext(cwd) {
     `home: ${home}\n` +
     `desktop: ${desktop}\n` +
     `documents: ${documents}\n` +
+    `${shellNote}\n` +
     `When the user names a location ("my desktop", "home", "documents"), write to ` +
     `the matching ABSOLUTE path above (e.g. desktop -> ${desktop}). Otherwise ` +
     `work under the cwd. Use absolute paths when a specific location is named.\n` +

package/src/api.js

@@ -33,6 +33,9 @@ export async function fetchWithRetry(url, options, { retries = 2, baseDelay = 50
     try {
       const res = await fetch(url, options);
       if (res.status >= 500 && attempt < retries) {
+        // Release the connection back to the pool before retrying — an
+        // unconsumed body keeps the socket open (undici won't reuse it).
+        res.body?.cancel().catch(() => {});
         attempt++;
         if (onRetry) onRetry(attempt, `HTTP ${res.status}`);
         await sleep(baseDelay * 2 ** (attempt - 1));
@@ -175,39 +178,69 @@ export async function agentTurnStream({
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() ?? "";
-    for (const line of lines) {
-      if (!line.startsWith("data:")) continue;
-      const json = line.slice(5).trim();
-      if (!json) continue;
-      let evt;
-      try { evt = JSON.parse(json); } catch { continue; }
-      if (evt.kind === "delta") {
-        textBuf += evt.content;
-        if (onDelta) onDelta(evt.content);
-      } else if (evt.kind === "tool_call_delta") {
-        const slot = toolBuf.get(evt.index) || { id: undefined, name: undefined, args: "" };
-        if (evt.id) slot.id = evt.id;
-        if (evt.name) slot.name = evt.name;
-        if (evt.args_delta) slot.args += evt.args_delta;
-        toolBuf.set(evt.index, slot);
-        if (onToolCallDelta) onToolCallDelta(evt);
-      } else if (evt.kind === "finish") {
-        finishReason = evt.reason;
-        if (onFinish) onFinish(evt.reason);
-      } else if (evt.kind === "done") {
-        creditsCharged = evt.creditsCharged ?? 0;
-        balanceAfter = evt.balanceAfter ?? null;
-        usage = evt.usage ?? usage;
-      } else if (evt.kind === "error") {
-        streamError = evt.error;
-      }
+
+  // Dispatch a single parsed SSE "data:" line.
+  const handleLine = (line) => {
+    if (!line.startsWith("data:")) return;
+    const json = line.slice(5).trim(); // .trim() also drops a CRLF trailing \r
+    if (!json) return;
+    let evt;
+    try { evt = JSON.parse(json); } catch { return; }
+    if (evt.kind === "delta") {
+      textBuf += evt.content;
+      if (onDelta) onDelta(evt.content);
+    } else if (evt.kind === "tool_call_delta") {
+      const slot = toolBuf.get(evt.index) || { id: undefined, name: undefined, args: "" };
+      if (evt.id) slot.id = evt.id;
+      if (evt.name) slot.name = evt.name;
+      if (evt.args_delta) slot.args += evt.args_delta;
+      toolBuf.set(evt.index, slot);
+      if (onToolCallDelta) onToolCallDelta(evt);
+    } else if (evt.kind === "finish") {
+      finishReason = evt.reason;
+      if (onFinish) onFinish(evt.reason);
+    } else if (evt.kind === "done") {
+      creditsCharged = evt.creditsCharged ?? 0;
+      balanceAfter = evt.balanceAfter ?? null;
+      usage = evt.usage ?? usage;
+    } else if (evt.kind === "error") {
+      streamError = evt.error;
+    }
+  };
+
+  // Watchdog: if the open stream stalls (no bytes) for too long, abort instead
+  // of hanging the CLI forever.
+  const READ_TIMEOUT_MS = 120_000;
+  const readOnce = () => {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new AetherError("Stream stalled — no data for 120s", "STREAM_TIMEOUT", 0)),
+        READ_TIMEOUT_MS,
+      );
+    });
+    return Promise.race([reader.read(), timeout]).finally(() => clearTimeout(timer));
+  };
+
+  try {
+    while (true) {
+      const { value, done } = await readOnce();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) handleLine(line);
     }
+    // Flush any multibyte bytes the decoder is holding, then process a final
+    // line that arrived without a trailing newline (else the "done" event with
+    // credits/usage is silently dropped).
+    buffer += decoder.decode();
+    if (buffer.trim()) handleLine(buffer);
+  } catch (e) {
+    reader.cancel().catch(() => {});
+    throw e;
+  } finally {
+    try { reader.releaseLock(); } catch { /* already released / pending — ignore */ }
   }
 
   if (streamError) {

package/src/repl.js

@@ -16,7 +16,7 @@ import { c, errorLine, boxLines, sideBySide } from "./render.js";
 import { checkForUpdate } from "./update-check.js";
 import { promptBox, EXIT_SIGNAL } from "./box-input.js";
 
-const VERSION = "0.28.0";
+const VERSION = "0.30.0";
 const MODEL_NAME = "Aether Core";
 
 const SHORTCUTS = `

package/src/skills.js

@@ -134,6 +134,12 @@ export function loadSkillsFromDir(dir) {
     if (!name.endsWith(".md")) continue;
     const filePath = path.join(dir, name);
     const raw = fs.readFileSync(filePath, "utf8");
+    // Cap skill size: the body is injected into the prompt every turn it
+    // triggers, so a huge file would blow the context window / inflate cost.
+    if (raw.length > 50_000) {
+      process.stderr.write(`  (skipping oversized skill ${name}: ${raw.length} bytes > 50KB)\n`);
+      continue;
+    }
     skills.push(parseSkill(raw, filePath));
   }
   return skills;

package/src/tools.js

@@ -279,6 +279,7 @@ const MAX_GLOB_RESULTS = 300;
 // relative path. ** spans directory separators; * does not.
 export function globToRegExp(glob) {
   let re = "";
+  let braceDepth = 0;
   for (let i = 0; i < glob.length; i++) {
     const ch = glob[i];
     if (ch === "*") {
@@ -291,6 +292,16 @@ export function globToRegExp(glob) {
       }
     } else if (ch === "?") {
       re += "[^/]";
+    } else if (ch === "{") {
+      // Brace expansion: {js,ts} -> (js|ts). Common in .gitignore (*.{js,ts});
+      // treating it literally silently failed to ignore those files.
+      re += "(";
+      braceDepth++;
+    } else if (ch === "}" && braceDepth > 0) {
+      re += ")";
+      braceDepth--;
+    } else if (ch === "," && braceDepth > 0) {
+      re += "|";
     } else if ("\\^$+.()|{}[]".includes(ch)) {
       re += "\\" + ch;
     } else {
@@ -430,13 +441,22 @@ async function askUser(args, _opts) {
 function readFile(args, opts) {
   if (typeof args.path !== "string") return { ok: false, output: "path is required" };
   const abs = resolveSafe(args.path, opts);
-  const stat = fs.statSync(abs);
+  let stat;
+  try { stat = fs.statSync(abs); } catch (e) {
+    return { ok: false, output: `Cannot access ${args.path}: ${e.code || e.message}` };
+  }
   if (stat.isDirectory()) return { ok: false, output: `${args.path} is a directory, not a file` };
+  // Block non-regular files (named pipes, sockets, devices) — reading them can
+  // hang forever (no timeout on readFileSync).
+  if (!stat.isFile()) return { ok: false, output: `${args.path} is not a regular file.` };
   if (stat.size > 1_000_000) {
     return { ok: false, output: `File too large (${stat.size} bytes). Aether refuses to read >1MB at once.` };
   }
-  const text = fs.readFileSync(abs, "utf8");
-  return { ok: true, output: text };
+  try {
+    return { ok: true, output: fs.readFileSync(abs, "utf8") };
+  } catch (e) {
+    return { ok: false, output: `Cannot read ${args.path}: ${e.code || e.message}` };
+  }
 }
 
 function listDir(args, opts) {
@@ -497,6 +517,10 @@ function searchFiles(args, opts) {
         } catch { continue; }
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
+          // Skip very long lines: the pattern is model-supplied and a
+          // pathological regex on a long line can backtrack catastrophically
+          // (ReDoS) and freeze the single-threaded process.
+          if (lines[i].length > 2000) continue;
           if (regex.test(lines[i])) {
             matches.push({ file: rel, line: i + 1, text: lines[i].slice(0, 300) });
             if (matches.length >= MAX_SEARCH_MATCHES) { truncated = true; return; }
@@ -648,12 +672,33 @@ async function webSearch(args, opts) {
 // Bounded fetch with a fixed timeout + size cap. Strips scripts/styles, removes
 // tags, decodes common HTML entities. Not a full HTML parser; good enough for
 // reading docs pages, GitHub READMEs, MDN, Stack Overflow answers, etc.
+// SSRF guard: refuse loopback / link-local / private hosts so web_fetch can't
+// be steered (directly or via a redirect) at localhost or cloud-metadata
+// (169.254.169.254) or an internal service.
+function isBlockedHost(hostname) {
+  const h = (hostname || "").toLowerCase().replace(/^\[|\]$/g, "");
+  if (!h || h === "localhost" || h === "0.0.0.0" || h === "::1" || h === "::") return true;
+  if (h.endsWith(".localhost") || h.endsWith(".internal") || h.endsWith(".local")) return true;
+  if (/^127\./.test(h)) return true;                       // loopback
+  if (/^10\./.test(h)) return true;                        // private A
+  if (/^192\.168\./.test(h)) return true;                  // private C
+  if (/^172\.(1[6-9]|2\d|3[01])\./.test(h)) return true;   // private B
+  if (/^169\.254\./.test(h)) return true;                  // link-local incl. cloud metadata
+  if (/^(fe80:|fc|fd|::ffff:)/.test(h)) return true;       // IPv6 link-local / ULA / mapped
+  return false;
+}
+
 async function webFetch(args, opts) {
   void opts;
   if (typeof args.url !== "string") return { ok: false, output: "url is required" };
   if (!/^https?:\/\//i.test(args.url)) {
     return { ok: false, output: "Only http:// and https:// URLs are allowed." };
   }
+  let initialHost;
+  try { initialHost = new URL(args.url).hostname; } catch { return { ok: false, output: "Invalid URL." }; }
+  if (isBlockedHost(initialHost)) {
+    return { ok: false, output: "web_fetch blocked: refusing to fetch a private/internal/loopback address." };
+  }
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 15_000);
   let res;
@@ -674,6 +719,14 @@ async function webFetch(args, opts) {
     return { ok: false, output: `web_fetch error: ${e.name === "AbortError" ? "timed out after 15s" : e.message}` };
   }
   clearTimeout(timeout);
+  // Re-check the FINAL url after any redirects — a public URL can 302 to an
+  // internal target, which the initial-URL check wouldn't catch.
+  try {
+    if (isBlockedHost(new URL(res.url).hostname)) {
+      res.body?.cancel().catch(() => {});
+      return { ok: false, output: "web_fetch blocked: redirect to a private/internal address." };
+    }
+  } catch { /* res.url unparseable — fall through */ }
   if (!res.ok) {
     return { ok: false, output: `web_fetch HTTP ${res.status} ${res.statusText}` };
   }