portal-agent-cli 1.0.1 → 3.0.0

package/lib/paste.mjs

@@ -1,5 +1,7 @@
 import { sleep } from "./wait.mjs";
 
+// DeepSeek shows a Cancel/Send confirmation bar when a large paste is
+// detected. Find the Cancel button, locate its Send sibling, click that.
 export async function dismissPaste(page) {
   const btns = page.locator("button, [role=button]");
   let total = 0;
@@ -33,7 +35,7 @@ export async function dismissPaste(page) {
         try {
           await sib.click({ timeout: 1500 });
           await sleep(200);
-          return;
+          return true;
         } catch (e) {
           // fall through
         }
@@ -46,10 +48,13 @@ export async function dismissPaste(page) {
     } catch (e) {
       // ignore
     }
-    return;
+    return true;
   }
+  return false;
 }
 
+// Poll the composer for emptiness. A thrown inputValue() means the composer
+// is a contenteditable with no inputValue method, so treat that as sent.
 export async function composerEmpty(input, ms) {
   const end = Date.now() + ms;
   while (Date.now() < end) {
@@ -57,7 +62,6 @@ export async function composerEmpty(input, ms) {
     try {
       v = await input.inputValue();
     } catch (e) {
-      // contenteditable composers have no inputValue. Treat as sent.
       return true;
     }
     if (!v || v.length === 0) return true;

package/lib/providers.mjs

@@ -3,19 +3,41 @@ export const PROVIDERS = {
     id: "deepseek",
     label: "DeepSeek",
     url: "https://chat.deepseek.com/",
-    input: "textarea",
-    submit: "button[aria-label=Send]",
-    response: "div.ds-markdown",
-    paste: true
+    input: ["textarea#chat-input", "textarea", "[contenteditable=true]"],
+    submit: ["button[aria-label=Send]", "button[data-testid=send-button]"],
+    response: ["div.ds-markdown", "div[class*=message]"],
+    paste: true,
+    notes: "DeepSeek renders the user prompt with the same class as the reply."
   },
   chatgpt: {
     id: "chatgpt",
     label: "ChatGPT",
     url: "https://chatgpt.com/",
-    input: "#prompt-textarea",
-    submit: "button[data-testid=send-button]",
-    response: "[data-message-author-role=assistant]",
-    paste: false
+    input: ["#prompt-textarea", "div[contenteditable=true][id=prompt-textarea]"],
+    submit: ["button[data-testid=send-button]", "button[aria-label*=Send]"],
+    response: ["[data-message-author-role=assistant]", "article[data-testid^=conversation-turn]"],
+    paste: false,
+    notes: "ChatGPT does not show a paste dialog."
+  },
+  gemini: {
+    id: "gemini",
+    label: "Gemini",
+    url: "https://gemini.google.com/app",
+    input: ["div[contenteditable=true][role=textbox]", "rich-textarea div[contenteditable=true]"],
+    submit: ["button[aria-label*=Send]", "button[aria-label=Send message]"],
+    response: ["message-content", "div[class*=model-response-text]"],
+    paste: false,
+    notes: "Gemini uses a rich-textarea web component."
+  },
+  grok: {
+    id: "grok",
+    label: "Grok",
+    url: "https://grok.com/",
+    input: ["textarea", "div[contenteditable=true]"],
+    submit: ["button[type=submit]", "button[aria-label*=Send]"],
+    response: ["div[class*=message]", "div[class*=response]"],
+    paste: false,
+    notes: "Grok selectors are best-effort and may need updating."
   }
 };
 
@@ -23,7 +45,11 @@ export function getProvider(id) {
   const p = PROVIDERS[id];
   if (!p) {
     const names = Object.keys(PROVIDERS).join(", ");
-    throw new Error("unknown provider: " + id + ". Available: " + names);
+    throw new Error("unknown provider: " + id + "\nAvailable: " + names);
   }
   return p;
 }
+
+export function listProviders() {
+  return Object.keys(PROVIDERS).map(function (k) { return PROVIDERS[k]; });
+}

package/lib/repl.mjs

@@ -2,118 +2,285 @@ import { createInterface } from "node:readline";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { launch } from "./browser.mjs";
-import { getProvider } from "./providers.mjs";
+import { getProvider, listProviders } from "./providers.mjs";
 import { waitForComposer } from "./wait.mjs";
 import { runTurn } from "./turn.mjs";
-import { setWs, getWs } from "./tools.mjs";
+import { setWorkspace, getWorkspace } from "./tools/path.mjs";
+import { setIgnore } from "./tools/walk.mjs";
+import { loadInstructions, activeInstructionFile } from "./instructions.mjs";
+import {
+  newSessionId,
+  saveSession,
+  loadSession,
+  listSessions
+} from "./sessions.mjs";
+import { theme } from "./theme.mjs";
+import { info, warn, error, ok } from "./log.mjs";
 
-export async function runRepl(opts) {
-  const provider = getProvider(opts.provider);
-  setWs(opts.ws);
+export async function runRepl(config) {
+  const provider = getProvider(config.provider);
+  setWorkspace(config.ws);
+  setIgnore(config.ignored);
 
-  console.log("");
-  console.log("Portal -- web AI in your terminal");
-  console.log("workspace: " + getWs());
-  console.log("provider:  " + provider.label);
-  console.log("");
+  const instructionsText = await loadInstructions(config.ws);
+  config.instructionsText = instructionsText;
+
+  // Session handling
+  let session;
+  if (config.resume) {
+    session = await loadSession(config.resume);
+    if (!session) {
+      warn("session not found: " + config.resume + ". starting fresh.");
+      session = newSession(config);
+    }
+  } else {
+    session = newSession(config);
+  }
+
+  // Banner
+  process.stdout.write("\n");
+  process.stdout.write(theme.bold(theme.cyan("Portal")) + theme.dim(" v2.0.0") + "\n");
+  process.stdout.write(theme.dim("workspace: ") + theme.accent(getWorkspace()) + "\n");
+  process.stdout.write(theme.dim("provider:  ") + theme.accent(provider.label) + "\n");
+  process.stdout.write(theme.dim("session:   ") + theme.accent(session.id) + "\n");
+  if (instructionsText) {
+    process.stdout.write(theme.dim("instructions: ") +
+      theme.accent(activeInstructionFile() || "?") + "\n");
+  }
+  if (config.yolo) {
+    process.stdout.write(theme.warn("yolo mode: all tool calls auto-approved") + "\n");
+  }
+  process.stdout.write("\n");
 
   const ctx = await launch();
   const page = await ctx.newPage();
   page.setDefaultTimeout(30000);
 
-  console.log("opening " + provider.label + "...");
+  info("opening " + provider.label + "...");
   await page.goto(provider.url);
-  console.log("");
-  console.log("Log in to " + provider.label + " in the Chrome window.");
-  console.log("Waiting up to " + Math.round(opts.loginTimeout / 1000) + "s.");
-  console.log("");
 
-  await waitForComposer(page, provider, opts.loginTimeout);
+  process.stdout.write("\n");
+  process.stdout.write(theme.yellow("Log in to " + provider.label +
+    " in the Chrome window.") + "\n");
+  process.stdout.write(theme.dim("Waiting up to " +
+    Math.round(config.loginTimeout / 1000) + "s.") + "\n");
+  process.stdout.write("\n");
+
+  await waitForComposer(page, provider, config.loginTimeout);
 
-  console.log("+ " + provider.label + " ready");
-  console.log("type /help for commands");
-  console.log("");
+  ok(provider.label + " ready");
+  process.stdout.write(theme.dim("type /help for commands") + "\n");
+  process.stdout.write("\n");
 
+  // REPL
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: "> "
+    prompt: theme.user("> ")
   });
   rl.prompt();
 
   let busy = false;
+  const queue = [];
+
+  async function drain() {
+    if (busy) return;
+    const next = queue.shift();
+    if (!next) return;
+    busy = true;
+    try {
+      await runTurn(page, provider, next, config, session);
+      await saveSession(session.id, session);
+    } catch (e) {
+      error(e.message || String(e));
+    }
+    busy = false;
+    process.stdout.write("\n");
+    rl.prompt();
+    if (queue.length > 0) drain();
+  }
 
   rl.on("line", async function (line) {
     const t = line.trim();
+    if (!t) { rl.prompt(); return; }
 
-    if (busy) {
-      rl.prompt();
-      return;
-    }
-    if (!t) {
+    // Slash commands
+    if (t === "/quit" || t === "/exit") { rl.close(); return; }
+    if (t === "/help" || t === "/?") { showHelp(); rl.prompt(); return; }
+    if (t === "/pwd") { process.stdout.write(getWorkspace() + "\n"); rl.prompt(); return; }
+    if (t === "/queue") { showQueue(queue); rl.prompt(); return; }
+    if (t === "/status") { showStatus(config, session, queue, busy); rl.prompt(); return; }
+    if (t === "/history") { showHistory(session); rl.prompt(); return; }
+    if (t === "/clear") { clearScreen(); rl.prompt(); return; }
+    if (t === "/sessions") { await showSessions(); rl.prompt(); return; }
+    if (t === "/providers") { showProviders(); rl.prompt(); return; }
+    if (t.slice(0, 4) === "/cd ") { changeDir(t.slice(4).trim()); rl.prompt(); return; }
+    if (t.slice(0, 10) === "/provider ") {
+      await changeProvider(t.slice(10).trim(), page, config, provider);
       rl.prompt();
       return;
     }
-    if (t === "/quit" || t === "/exit") {
-      rl.close();
-      return;
-    }
-    if (t === "/help") {
-      help();
-      rl.prompt();
-      return;
-    }
-    if (t === "/pwd") {
-      console.log(getWs());
+
+    // Queue or execute
+    if (busy) {
+      queue.push(t);
+      process.stdout.write(theme.dim("queued (" + queue.length + " waiting)") + "\n");
       rl.prompt();
       return;
     }
-    if (t.slice(0, 4) === "/cd ") {
-      changeDir(t.slice(4).trim(), rl);
-      return;
-    }
-
-    busy = true;
-    try {
-      await runTurn(page, provider, t, opts);
-    } catch (e) {
-      console.log("x " + (e.message || e));
-    }
-    busy = false;
-    console.log("");
-    rl.prompt();
+    queue.push(t);
+    drain();
   });
 
   rl.on("close", async function () {
-    console.log("");
-    console.log("closing browser...");
+    process.stdout.write("\n");
+    process.stdout.write(theme.dim("saving session...") + "\n");
+    await saveSession(session.id, session).catch(function () {});
+    process.stdout.write(theme.dim("closing browser...") + "\n");
     await ctx.close().catch(function () {});
+    process.stdout.write(theme.ok("+ done") + "\n");
     process.exit(0);
   });
 }
 
-function help() {
-  console.log("  /cd <folder>   change workspace");
-  console.log("  /pwd           show current workspace");
-  console.log("  /help          show this help");
-  console.log("  /quit          exit");
+function newSession(config) {
+  return {
+    id: newSessionId(),
+    ws: config.ws,
+    provider: config.provider,
+    turns: [],
+    approvedAlways: [],
+    startedAt: Date.now(),
+    updatedAt: Date.now()
+  };
 }
 
-function changeDir(target, rl) {
+function showHelp() {
+  const lines = [
+    "COMMANDS",
+    "  /help              show this",
+    "  /cd <folder>       change workspace",
+    "  /pwd               show current workspace",
+    "  /provider <name>   switch provider",
+    "  /providers         list providers",
+    "  /sessions          list saved sessions",
+    "  /history           show recent turns",
+    "  /queue             list tasks waiting to run",
+    "  /status            show session status",
+    "  /clear             clear the screen",
+    "  /quit              exit",
+    "",
+    "Anything else is sent to the model as a task.",
+    "Tasks typed while the model is busy are queued."
+  ];
+  for (const l of lines) {
+    process.stdout.write((l.startsWith("  ") ? theme.dim(l) : theme.bold(l)) + "\n");
+  }
+}
+
+function showQueue(queue) {
+  if (!queue.length) {
+    process.stdout.write(theme.dim("(queue empty)") + "\n");
+    return;
+  }
+  process.stdout.write(theme.bold(queue.length + " task(s) waiting:") + "\n");
+  queue.forEach(function (x, i) {
+    process.stdout.write(theme.dim("  " + (i + 1) + ". ") + x + "\n");
+  });
+}
+
+function showStatus(config, session, queue, busy) {
+  process.stdout.write(theme.bold("session status") + "\n");
+  process.stdout.write(theme.dim("  id:        ") + session.id + "\n");
+  process.stdout.write(theme.dim("  workspace: ") + getWorkspace() + "\n");
+  process.stdout.write(theme.dim("  provider:  ") + session.provider + "\n");
+  process.stdout.write(theme.dim("  turns:     ") + session.turns.length + "\n");
+  process.stdout.write(theme.dim("  busy:      ") + (busy ? "yes" : "no") + "\n");
+  process.stdout.write(theme.dim("  queued:    ") + queue.length + "\n");
+  process.stdout.write(theme.dim("  yolo:      ") + (config.yolo ? "on" : "off") + "\n");
+}
+
+function showHistory(session) {
+  if (!session.turns.length) {
+    process.stdout.write(theme.dim("(no turns yet)") + "\n");
+    return;
+  }
+  const recent = session.turns.slice(-10);
+  for (const t of recent) {
+    const tag = t.role === "user" ? theme.user("you") : theme.cyan("ai");
+    const text = String(t.text || "").slice(0, 200);
+    process.stdout.write(tag + ": " + text + "\n");
+  }
+}
+
+async function showSessions() {
+  const list = await listSessions();
+  if (!list.length) {
+    process.stdout.write(theme.dim("(no saved sessions)") + "\n");
+    return;
+  }
+  process.stdout.write(theme.bold("saved sessions:") + "\n");
+  for (const s of list.slice(0, 15)) {
+    const when = timeAgo(s.updatedAt);
+    process.stdout.write(theme.dim("  " + s.id + "  " + when + "  " +
+      s.provider + "  " + s.turns + " turns") + "\n");
+  }
+}
+
+function showProviders() {
+  const list = listProviders();
+  process.stdout.write(theme.bold("providers:") + "\n");
+  for (const p of list) {
+    process.stdout.write(theme.dim("  " + p.id.padEnd(10)) + " " + p.label + "\n");
+  }
+}
+
+function changeDir(target) {
   if (!target) {
-    console.log("usage: /cd <folder>");
-    console.log("current: " + getWs());
-    rl.prompt();
+    process.stdout.write(theme.dim("usage: /cd <folder>") + "\n");
+    process.stdout.write(theme.dim("current: ") + getWorkspace() + "\n");
     return;
   }
   const clean = target.replace(/^"|"$/g, "");
   const abs = resolve(clean);
   if (!existsSync(abs)) {
-    console.log("not found: " + abs);
-    rl.prompt();
+    warn("not found: " + abs);
     return;
   }
-  setWs(abs);
-  console.log("workspace: " + getWs());
-  rl.prompt();
+  setWorkspace(abs);
+  ok("workspace: " + getWorkspace());
+}
+
+async function changeProvider(name, page, config, current) {
+  if (name === current.id) {
+    process.stdout.write(theme.dim("already on " + name) + "\n");
+    return;
+  }
+  let next;
+  try {
+    next = getProvider(name);
+  } catch (e) {
+    error(e.message);
+    return;
+  }
+  info("switching to " + next.label + "...");
+  await page.goto(next.url);
+  await waitForComposer(page, next, 60000);
+  config.provider = name;
+  ok("switched to " + next.label);
+}
+
+function clearScreen() {
+  process.stdout.write(String.fromCharCode(27) + "[2J");
+  process.stdout.write(String.fromCharCode(27) + "[H");
+}
+
+function timeAgo(ms) {
+  const s = Math.floor((Date.now() - ms) / 1000);
+  if (s < 60) return s + "s ago";
+  const m = Math.floor(s / 60);
+  if (m < 60) return m + "m ago";
+  const h = Math.floor(m / 60);
+  if (h < 24) return h + "h ago";
+  return Math.floor(h / 24) + "d ago";
 }

package/lib/safety.mjs

@@ -0,0 +1,64 @@
+import { createInterface } from "node:readline";
+import { theme } from "./theme.mjs";
+
+// Tools that touch the filesystem destructively or execute code. These
+// require explicit approval unless --yolo is set.
+export const SENSITIVE = new Set([
+  "shell",
+  "delete_file",
+  "move_file",
+  "write_file",
+  "edit_file"
+]);
+
+// Read-only tools. Never prompt.
+export const SAFE = new Set([
+  "read_file",
+  "list_files",
+  "find_files",
+  "grep_search",
+  "stat_file",
+  "git_status",
+  "git_diff"
+]);
+
+export function isSensitive(name) {
+  return SENSITIVE.has(name);
+}
+
+export function isSafe(name) {
+  return SAFE.has(name);
+}
+
+// Approval prompt. Reads a single key from stdin.
+export async function askApproval(toolName, args) {
+  const preview = JSON.stringify(args || {}, null, 2).slice(0, 500);
+  process.stdout.write("\n");
+  process.stdout.write(theme.warn("+ approval required") + "\n");
+  process.stdout.write(theme.dim("  tool: ") + theme.tool(toolName) + "\n");
+  const lines = preview.split("\n").slice(0, 12);
+  for (const l of lines) {
+    process.stdout.write(theme.dim("  " + l) + "\n");
+  }
+  if (preview.split("\n").length > 12) {
+    process.stdout.write(theme.dim("  ...") + "\n");
+  }
+
+  return new Promise(function (resolve) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(
+      theme.bold("  allow? ") + theme.ok("y") + "es / " +
+      theme.warn("a") + "lways / " + theme.error("n") + "o: ",
+      function (answer) {
+        rl.close();
+        const a = answer.trim().toLowerCase();
+        if (a === "y" || a === "yes") resolve("yes");
+        else if (a === "a" || a === "always") resolve("always");
+        else resolve("no");
+      }
+    );
+  });
+}

package/lib/send.mjs

@@ -1,88 +1,92 @@
-import { sleep, norm } from "./wait.mjs";
+import { sleep, norm, findFirstVisible, countMatching } from "./wait.mjs";
 import { dismissPaste, composerEmpty } from "./paste.mjs";
 
+const SETTLE_MS = 2000;
+
 export async function send(page, provider, prompt, timeoutMs) {
-  const input = page.locator(provider.input).last();
-  await input.waitFor({ state: "visible", timeout: 30000 });
-  const before = await page.locator(provider.response).count();
+  const input = await findFirstVisible(page, provider.input, 30000);
+  if (!input) throw new Error("composer not found");
+
+  const before = await countMatching(page, provider.response);
+  const want = norm(prompt);
 
   await input.focus();
   try {
     await page.keyboard.press("Control+A");
     await page.keyboard.press("Delete");
   } catch (e) {
-    // composer may be empty
+    // empty composer
   }
 
   await page.keyboard.insertText(prompt);
   await sleep(300);
-
   if (provider.paste) await dismissPaste(page);
 
   try {
     await input.press("Enter");
   } catch (e) {
-    // fall through to button
+    // fall through
   }
 
   let ok = await composerEmpty(input, 5000);
-
   if (!ok) {
-    const btn = page.locator(provider.submit).last();
-    try {
-      if (await btn.isVisible({ timeout: 1500 })) await btn.click();
-    } catch (e) {
-      // no button
+    const btn = await findFirstVisible(page, provider.submit, 1500);
+    if (btn) {
+      try { await btn.click({ timeout: 1500 }); } catch (e) {}
     }
     ok = await composerEmpty(input, 3000);
   }
 
   if (!ok) {
     throw new Error(
-      "Message stayed in composer. Look at the Chrome window: if a " +
-      "Cancel/Send bar is showing, click Send manually once, then resend."
+      "Message stayed in composer.\n" +
+      "Check the Chrome window. If a Cancel/Send bar is showing, click Send " +
+      "once manually, then resend."
     );
   }
 
-  const want = norm(prompt);
+  return waitForReply(page, provider, want, timeoutMs);
+}
+
+async function waitForReply(page, provider, want, timeoutMs) {
   const end = Date.now() + timeoutMs;
-  let appeared = false;
+  let last = "";
+  let stab = Date.now();
+  let sawAnything = false;
+  let lastCount = 0;
 
   while (Date.now() < end) {
-    const c = await page.locator(provider.response).count();
-    if (c > before) {
-      appeared = true;
-      break;
-    }
-    await sleep(300);
-  }
+    const count = await countMatching(page, provider.response);
+    if (count > lastCount) lastCount = count;
 
-  if (!appeared) throw new Error("No response appeared within the timeout.");
+    const node = await findFirstVisible(page, provider.response, 1000);
+    if (node) {
+      let tx = "";
+      try { tx = (await node.textContent()) || ""; } catch (e) { tx = ""; }
+      const n = norm(tx);
 
-  let last = "";
-  let stab = Date.now();
+      // Skip empty nodes and the echoed prompt.
+      if (!n || n === want) {
+        await sleep(300);
+        continue;
+      }
 
-  while (Date.now() < end) {
-    const node = page.locator(provider.response).last();
-    let tx = "";
-    try {
-      tx = (await node.textContent()) || "";
-    } catch (e) {
-      tx = "";
-    }
-    const n = norm(tx);
-    if (!n || n === want) {
-      await sleep(300);
-      continue;
-    }
-    if (tx !== last) {
-      last = tx;
-      stab = Date.now();
-    } else if (Date.now() - stab > 1500) {
-      return tx;
+      if (tx !== last) {
+        last = tx;
+        stab = Date.now();
+        sawAnything = true;
+      } else if (sawAnything && Date.now() - stab > SETTLE_MS) {
+        return tx;
+      }
     }
+
     await sleep(300);
   }
 
-  return last || "(timeout)";
+  if (last) return last;
+  throw new Error(
+    "Timed out waiting for a reply.\n" +
+    "Check the Chrome window. If the model answered but Portal missed it, " +
+    "send the task again."
+  );
 }