portal-agent-cli 3.0.1 → 3.0.2

package/lib/tools/index.mjs

@@ -1,2 +1,53 @@
 import { read_file } from "./read.mjs";
-import { write_file, append_file }
+import { write_file, append_file } from "./write.mjs";
+import { edit_file, undo_file } from "./edit.mjs";
+import { list_files } from "./list.mjs";
+import { find_files } from "./find.mjs";
+import { grep_search } from "./grep.mjs";
+import { delete_file, move_file } from "./delete.mjs";
+import { shell } from "./shell.mjs";
+import { git_status, git_diff, git_log } from "./git.mjs";
+
+export const TOOLS = {
+  read_file: read_file,
+  write_file: write_file,
+  edit_file: edit_file,
+  append_file: append_file,
+  undo_file: undo_file,
+  list_files: list_files,
+  find_files: find_files,
+  grep_search: grep_search,
+  delete_file: delete_file,
+  move_file: move_file,
+  shell: shell,
+  git_status: git_status,
+  git_diff: git_diff,
+  git_log: git_log
+};
+
+export const SAFE_TOOLS = new Set([
+  "read_file",
+  "list_files",
+  "find_files",
+  "grep_search",
+  "git_status",
+  "git_diff",
+  "git_log"
+]);
+
+export const CATALOG = [
+  "read_file(path, start_line?, end_line?)",
+  "write_file(path, content)",
+  "edit_file(path, old_string, new_string, replace_all?)",
+  "append_file(path, content)",
+  "undo_file(path)",
+  "list_files(path?)",
+  "find_files(pattern)",
+  "grep_search(pattern, path?, case_sensitive?)",
+  "delete_file(path)",
+  "move_file(from, to)",
+  "shell(command)",
+  "git_status()",
+  "git_diff(path?, staged?)",
+  "git_log(count?)"
+].join("\n");

package/lib/tools/list.mjs

@@ -1 +1,35 @@
-import { readdir, stat } from "node:fs/prom
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { safePath } from "./path.mjs";
+
+export async function list_files(args) {
+  const abs = safePath(args.path || ".");
+  const entries = await readdir(abs, { withFileTypes: true });
+
+  if (!entries.length) {
+    return "EMPTY. Do not call list_files again on this path.";
+  }
+
+  const rows = [];
+  for (const e of entries) {
+    const full = join(abs, e.name);
+    let size = "";
+    if (e.isFile()) {
+      try {
+        const st = await stat(full);
+        size = formatSize(st.size);
+      } catch (err) {}
+    }
+    const tag = e.isDirectory() ? "[dir] " : "      ";
+    rows.push(tag + e.name.padEnd(40) + " " + size);
+  }
+
+  rows.sort();
+  return rows.join("\n");
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return Math.round(bytes / 1024) + " KB";
+  return (bytes / 1024 / 1024).toFixed(1) + " MB";
+}

package/lib/tools/path.mjs

@@ -1 +1,22 @@
-import
+import { resolve, relative, sep } from "node:path";
+
+let ws = process.cwd();
+
+export function setWorkspace(p) { ws = resolve(p); }
+export function getWorkspace() { return ws; }
+
+export function safePath(p) {
+  if (!p || typeof p !== "string") {
+    throw new Error("path must be a non-empty string");
+  }
+  const abs = resolve(ws, p);
+  const rel = relative(ws, abs);
+  if (rel === ".." || rel.slice(0, 3) === "..\\" || rel.slice(0, 3) === "../") {
+    throw new Error("path escapes workspace: " + p);
+  }
+  return abs;
+}
+
+export function toPosix(p) {
+  return p.split(sep).join("/");
+}

package/lib/tools/read.mjs

@@ -1,4 +1,31 @@
 import { readFile } from "node:fs/promises";
 import { safePath } from "./path.mjs";
 
-const MAX_BYTES = 
+const MAX_BYTES = 500000;
+
+export async function read_file(args) {
+  const abs = safePath(args.path);
+  const text = await readFile(abs, "utf8");
+
+  if (text.length > MAX_BYTES) {
+    return text.slice(0, MAX_BYTES) + "\n[truncated]";
+  }
+
+  const lines = text.split("\n");
+  const start = Math.max(1, Number(args.start_line) || 1);
+  const end = Math.min(lines.length, Number(args.end_line) || lines.length);
+
+  if (start > end) return "invalid range";
+
+  const width = String(end).length;
+  const out = [];
+  for (let i = start - 1; i < end; i++) {
+    out.push(String(i + 1).padStart(width) + "| " + lines[i]);
+  }
+
+  const header = start === 1 && end === lines.length
+    ? lines.length + " lines"
+    : "lines " + start + "-" + end + " of " + lines.length;
+
+  return "[" + header + "]\n" + out.join("\n");
+}

package/lib/tools/shell.mjs

@@ -2,4 +2,62 @@ import { spawn } from "node:child_process";
 import { getWorkspace } from "./path.mjs";
 
 const MAX_OUTPUT = 65000;
-const TIMEOUT_MS = 60000
+const TIMEOUT_MS = 60000;
+
+function normalizeWinCommand(cmd) {
+  if (process.platform !== "win32") return cmd;
+  return cmd.replace(/(\S+)/g, function (token) {
+    if (token.indexOf("://") >= 0) return token;
+    if (/^\/[a-zA-Z](\s|$)/.test(token)) return token;
+    if (/^[A-Za-z]:\//.test(token) || (token.indexOf("/") > 0 && token.indexOf("://") < 0)) {
+      const leading = token.startsWith('"') ? '"' : "";
+      const trailing = token.endsWith('"') ? '"' : "";
+      const body = token.slice(leading.length, token.length - trailing.length);
+      return leading + body.split("/").join("\\") + trailing;
+    }
+    return token;
+  });
+}
+
+export function shell(args) {
+  const raw = String(args.command || "");
+  if (!raw) return Promise.resolve("shell requires a command");
+
+  const cmd = normalizeWinCommand(raw);
+
+  return new Promise(function (done) {
+    const ws = getWorkspace();
+    const isWin = process.platform === "win32";
+
+    const child = spawn(cmd, {
+      cwd: ws,
+      shell: isWin ? true : "/bin/sh",
+      windowsHide: true
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    if (child.stdout) child.stdout.on("data", function (d) { stdout += String(d); });
+    if (child.stderr) child.stderr.on("data", function (d) { stderr += String(d); });
+
+    const timer = setTimeout(function () {
+      child.kill();
+      done("timed out\n" + stderr);
+    }, TIMEOUT_MS);
+
+    child.on("error", function (err) {
+      clearTimeout(timer);
+      done("spawn error: " + err.message);
+    });
+
+    child.on("close", function (code) {
+      clearTimeout(timer);
+      const both = [stdout.trimEnd(), stderr.trimEnd()].filter(Boolean).join("\n");
+      let s = "exit " + (code === null ? "null" : code) + "\n" + (both || "(no output)");
+      if (cmd !== raw) s += "\n[normalized: " + cmd + "]";
+      if (s.length > MAX_OUTPUT) s = s.slice(0, MAX_OUTPUT) + "\n[truncated]";
+      done(s);
+    });
+  });
+}

package/lib/tools/walk.mjs

@@ -1 +1,30 @@
-import { readdir } from "node
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+const DEFAULT_IGNORE = new Set([
+  "node_modules", ".git", ".hg", ".svn", "dist", "build", "out",
+  ".next", ".nuxt", ".turbo", ".cache", "target", "__pycache__",
+  ".venv", "venv", "env", "coverage", ".idea", ".vscode", ".DS_Store"
+]);
+
+let ignore = DEFAULT_IGNORE;
+
+export function setIgnore(names) {
+  ignore = new Set(names || []);
+}
+
+export async function* walk(dir) {
+  let items;
+  try {
+    items = await readdir(dir, { withFileTypes: true });
+  } catch (e) {
+    return;
+  }
+  for (const it of items) {
+    if (ignore.has(it.name)) continue;
+    if (it.name.startsWith(".") && it.name !== ".env.example") continue;
+    const full = join(dir, it.name);
+    if (it.isDirectory()) yield* walk(full);
+    else if (it.isFile()) yield full;
+  }
+}

package/lib/tools/write.mjs

@@ -2,4 +2,34 @@ import { writeFile, mkdir, readFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { safePath } from "./path.mjs";
 
-export async function write_file
+export async function write_file(args) {
+  const abs = safePath(args.path);
+  const content = args.content || "";
+  await mkdir(dirname(abs), { recursive: true });
+
+  try {
+    const existing = await readFile(abs, "utf8");
+    if (existing !== content) {
+      await writeFile(abs + ".portal-bak", existing, "utf8");
+    }
+  } catch (e) {}
+
+  await writeFile(abs, content, "utf8");
+  const lines = content.length === 0 ? 0 : content.split("\n").length;
+  return "wrote " + content.length + " bytes (" + lines + " lines) to " + args.path;
+}
+
+export async function append_file(args) {
+  const abs = safePath(args.path);
+  await mkdir(dirname(abs), { recursive: true });
+
+  let existing = "";
+  try { existing = await readFile(abs, "utf8"); } catch (e) { existing = ""; }
+
+  const content = args.content || "";
+  const sep = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  const add = content.endsWith("\n") ? content : content + "\n";
+
+  await writeFile(abs, existing + sep + add, "utf8");
+  return "appended " + content.length + " bytes to " + args.path;
+}

package/lib/turn.mjs

@@ -1,2 +1,99 @@
 import { send } from "./send.mjs";
-import { parse
+import { parseCalls, stripCalls } from "./parse.mjs";
+import { TOOLS, SAFE_TOOLS } from "./tools/index.mjs";
+import { getWorkspace } from "./tools/path.mjs";
+import { buildSystem } from "./system.mjs";
+import { askApproval } from "./safety.mjs";
+import { reply, tool as logTool, toolResult, status } from "./log.mjs";
+import { theme } from "./theme.mjs";
+
+const REPEAT_WARN = 2;
+const REPEAT_STOP = 3;
+
+export async function runTurn(page, provider, prompt, config, session) {
+  const instructions = config.instructionsText || null;
+  const sys = buildSystem(getWorkspace(), instructions);
+
+  const seen = new Map();
+  let next = sys + "\n\nTask: " + prompt;
+  const approvedAlways = new Set(session.approvedAlways || []);
+
+  for (let step = 0; step < config.maxSteps; step++) {
+    status("waiting for " + provider.label + "...");
+    const r = await send(page, provider, next, config.timeout);
+    const calls = parseCalls(r);
+
+    if (!calls.length) {
+      const prose = stripCalls(r);
+      reply(prose);
+      session.turns.push({ role: "user", text: prompt });
+      session.turns.push({ role: "assistant", text: prose });
+      session.approvedAlways = Array.from(approvedAlways);
+      session.updatedAt = Date.now();
+      return;
+    }
+
+    const results = [];
+    let stopped = false;
+
+    for (const c of calls) {
+      const sig = c.tool + ":" + JSON.stringify(c.args || {});
+      const n = (seen.get(sig) || 0) + 1;
+      seen.set(sig, n);
+
+      if (n >= REPEAT_STOP) {
+        process.stdout.write(theme.error("x loop detected: " + c.tool +
+          " repeated. stopping.") + "\n");
+        stopped = true;
+        break;
+      }
+
+      if (n === REPEAT_WARN) {
+        process.stdout.write(theme.warn("! " + c.tool + " repeated.") + "\n");
+      }
+
+      logTool(c.tool, c.args);
+
+      const needs = !config.yolo &&
+        !SAFE_TOOLS.has(c.tool) &&
+        !approvedAlways.has(c.tool);
+
+      if (needs) {
+        const d = await askApproval(c.tool, c.args);
+        if (d === "no") {
+          const msg = "user denied " + c.tool;
+          toolResult(msg, true);
+          results.push("Tool: " + c.tool + "\nStatus: denied\n" + msg);
+          continue;
+        }
+        if (d === "always") approvedAlways.add(c.tool);
+      }
+
+      let out;
+      let isErr = false;
+      try {
+        const fn = TOOLS[c.tool];
+        if (!fn) { out = "unknown tool: " + c.tool; isErr = true; }
+        else out = await fn(c.args || {});
+      } catch (e) {
+        out = "error: " + (e.message || e);
+        isErr = true;
+      }
+
+      toolResult(out, isErr);
+      results.push("Tool: " + c.tool + "\nResult:\n" + out);
+    }
+
+    if (stopped) {
+      session.turns.push({ role: "user", text: prompt });
+      session.turns.push({ role: "assistant", text: "(stopped: loop)" });
+      session.updatedAt = Date.now();
+      return;
+    }
+
+    next = "Tool results:\n\n" + results.join("\n\n") +
+      "\n\nContinue. Do not repeat any call.";
+  }
+
+  process.stdout.write(theme.warn("max steps reached.") + "\n");
+}

package/lib/wait.mjs

@@ -13,9 +13,7 @@ export async function findFirstVisible(page, selectors, ms) {
       const loc = page.locator(sel).last();
       try {
         if (await loc.isVisible({ timeout: 200 })) return loc;
-      } catch (e) {
-        // try next selector
-      }
+      } catch (e) {}
     }
     await sleep(200);
   }
@@ -24,29 +22,26 @@ export async function findFirstVisible(page, selectors, ms) {
 
 export async function waitForComposer(page, provider, ms) {
   const end = Date.now() + ms;
-  let lastHint = Date.now();
+  let hint = Date.now();
   while (Date.now() < end) {
     for (const sel of provider.input) {
       const loc = page.locator(sel).last();
       let ok = false;
       try {
         ok = await loc.isVisible({ timeout: 200 });
-      } catch (e) {
-        ok = false;
-      }
+      } catch (e) {}
       if (ok) return loc;
     }
-    if (Date.now() - lastHint > 15000) {
+    if (Date.now() - hint > 15000) {
       const left = Math.round((end - Date.now()) / 1000);
       process.stdout.write("  waiting for login (" + left + "s left)\n");
-      lastHint = Date.now();
+      hint = Date.now();
     }
     await sleep(1000);
   }
   throw new Error(
-    "Timed out waiting for the composer.\n" +
-    "Log in to the provider in the Chrome window and try again, " +
-    "or raise --login-timeout."
+    "Timed out waiting for the composer. Log in to the provider " +
+    "and try again, or raise --login-timeout."
   );
 }
 
@@ -55,9 +50,7 @@ export async function countMatching(page, selectors) {
     try {
       const n = await page.locator(sel).count();
       if (n > 0) return n;
-    } catch (e) {
-      // try next
-    }
+    } catch (e) {}
   }
   return 0;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "portal-agent-cli",
-  "version": "3.0.1",
-  "description": "Drive web AI products from the terminal with local tools. Multi-provider, approval gate, session persistence, undo.",
+  "version": "3.0.2",
+  "description": "Drive web AI products from the terminal with local tools.",
   "type": "module",
   "bin": {
     "portal-agent": "portal.mjs"
@@ -29,10 +29,7 @@
     "ai",
     "agent",
     "deepseek",
-    "chatgpt",
-    "gemini",
-    "grok",
-    "playwright"
+    "chatgpt"
   ],
   "license": "MIT"
 }

package/portal.mjs

@@ -1,9 +1,4 @@
 #!/usr/bin/env node
-//
-// portal-agent -- drive web AI products from the terminal with local tools.
-//
-// Entry point. Loads config, parses arguments, dispatches to REPL or exec.
-//
 import { parseArgs } from "./lib/args.mjs";
 import { loadConfig } from "./lib/config.mjs";
 import { runRepl } from "./lib/repl.mjs";
@@ -13,23 +8,16 @@ import { theme } from "./lib/theme.mjs";
 async function main() {
   const opts = parseArgs();
   const config = await loadConfig(opts);
-
   if (config.verbose) {
     process.stdout.write(theme.dim("config: " + JSON.stringify(config, null, 2)) + "\n");
   }
-
-  if (opts.exec) {
-    await runExec(config);
-  } else {
-    await runRepl(config);
-  }
+  if (opts.exec) await runExec(config);
+  else await runRepl(config);
 }
 
 main().catch(function (e) {
   const msg = e && e.message ? e.message : String(e);
   process.stderr.write(theme.error("fatal: " + msg) + "\n");
-  if (process.env.PORTAL_DEBUG) {
-    process.stderr.write(e.stack + "\n");
-  }
+  if (process.env.PORTAL_DEBUG) process.stderr.write(e.stack + "\n");
   process.exit(1);
 });