@tiens.nguyen/gonext-local-worker 1.0.228 → 1.0.230

package/gonext-local-worker.mjs

@@ -1853,6 +1853,10 @@ async function runAgentChatJob(job) {
       // REPL's "I can show a picker" signal (else python keeps hard-blocking, as on web).
       jobId,
       interactiveApproval: payload?.interactiveApproval === true,
+      // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
+      autoTest: payload?.autoTest === true,
+      // Deploy target chosen via the terminal /server picker (task #69). Host/user only.
+      deployServer: payload?.deployServer ?? null,
       // Max web_search + fetch_url calls the agent may make per task (user-configurable
       // in web Settings → Agent). Default 10; past it the retrieval tools refuse.
       researchBudget: payload?.researchBudget ?? 10,

package/gonext-repl.mjs

@@ -163,6 +163,8 @@ if (!workerKey || !apiBase) {
 // unknown-command guard, and /help, so they can never drift.
 const COMMANDS = [
   { name: "/model", desc: "switch the coding model for this session" },
+  { name: "/test-auto", desc: "toggle auto-test (verify & fix until it passes) for this folder" },
+  { name: "/server", desc: "pick a deployment server (host/user) for this session" },
   { name: "/revert", usage: "/revert [runId]", desc: "undo the agent's file edits (latest run)" },
   { name: "/reset", aliases: ["/new"], desc: "forget this folder's saved conversation and start fresh" },
   { name: "/help", desc: "list these commands" },
@@ -503,6 +505,17 @@ async function loadSession(cwd) {
   }
 }
 
+// The /test-auto choice is remembered per folder (stored alongside history in the same
+// session file). Read it once at startup so the banner and agent-ask reflect it.
+async function loadSessionTestAuto(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    return raw?.testAuto === true;
+  } catch {
+    return false;
+  }
+}
+
 async function saveSession(cwd, history) {
   try {
     await mkdir(SESSIONS_DIR, { recursive: true });
@@ -510,7 +523,7 @@ async function saveSession(cwd, history) {
     await writeFile(
       sessionFilePath(cwd),
       JSON.stringify(
-        { cwd, updatedAt: new Date().toISOString(), history: trimmed },
+        { cwd, updatedAt: new Date().toISOString(), testAuto: sessionTestAuto, history: trimmed },
         null,
         2
       ) + "\n"
@@ -580,6 +593,89 @@ async function chooseModel() {
   console.log(green(`  ✓ coding model → ${chosen}${chosen === def ? " (default)" : ""}\n`));
 }
 
+// Probe whether SSH KEY auth already works for a server (so we can tell the user to run
+// ssh-copy-id if not). BatchMode=yes = never prompt for a password → exit!=0 if no key.
+async function checkServerKeyAuth(s) {
+  try {
+    const ok = await new Promise((resolve) => {
+      const p = spawn(
+        "ssh",
+        [
+          "-o", "BatchMode=yes",
+          "-o", "ConnectTimeout=6",
+          "-o", "StrictHostKeyChecking=accept-new",
+          `${s.user}@${s.host}`,
+          "true",
+        ],
+        { stdio: "ignore" }
+      );
+      p.on("exit", (code) => resolve(code === 0));
+      p.on("error", () => resolve(false));
+    });
+    if (ok) console.log(dim("    ✓ key auth works — deploys will connect without a password."));
+    else
+      console.log(
+        yellow("    key auth not set up yet.") +
+          dim(` Run once in your terminal:  `) +
+          `ssh-copy-id ${s.user}@${s.host}`
+      );
+  } catch {
+    /* best-effort check — never block the picker */
+  }
+}
+
+// /server — pick a deployment target (from the web app's Servers registry) for this
+// session. Host/user only, never a secret; the agent deploys here with KEY auth (#69).
+async function chooseServer() {
+  let servers;
+  try {
+    const res = await fetch(`${apiBase}/api/worker/deploy-servers`, {
+      headers: { "X-Worker-Key": workerKey },
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      console.log(red(`  couldn't load servers: ${data?.error || `HTTP ${res.status}`}\n`));
+      return;
+    }
+    servers = Array.isArray(data?.servers) ? data.servers : [];
+  } catch (err) {
+    console.log(red(`  couldn't load servers: ${err.message}\n`));
+    return;
+  }
+  if (servers.length === 0) {
+    console.log(dim("  No deployment servers yet — add them in the web app → Servers.\n"));
+    return;
+  }
+  const activeHost = selectedServer?.host || "";
+  console.log(dim("  Choose a deployment server for this session:"));
+  servers.forEach((s, i) => {
+    const mark = s.host === activeHost ? green(" ●") : "  ";
+    console.log(`   ${mark} ${i + 1}. ${s.name} ${dim(`(${s.user}@${s.host})`)}`);
+  });
+  console.log(`      0. ${dim("none (clear selection)")}`);
+  const pick = (await ask(dim("  number (or Enter to keep current): "))).trim();
+  if (!pick) {
+    console.log("");
+    return;
+  }
+  const n = Number.parseInt(pick, 10);
+  if (n === 0) {
+    selectedServer = null;
+    console.log(dim("  ✓ deployment server cleared.\n"));
+    return;
+  }
+  const idx = n - 1;
+  if (!Number.isInteger(idx) || idx < 0 || idx >= servers.length) {
+    console.log(red("  invalid choice.\n"));
+    return;
+  }
+  const s = servers[idx];
+  selectedServer = { name: s.name, host: s.host, user: s.user };
+  console.log(green(`  ✓ deploy target → ${s.name} (${s.user}@${s.host})`));
+  await checkServerKeyAuth(selectedServer);
+  console.log("");
+}
+
 async function fetchAgentPayload(messages) {
   const res = await fetch(`${apiBase}/api/worker/agent-payload`, {
     method: "POST",
@@ -672,6 +768,13 @@ function approvalPrompt(command) {
 // Per-session coding-model override chosen via /model (empty = use the account default).
 // Sent to /agent-ask as codingModelOverride; the API validates it against the whitelist.
 let sessionCodingModel = "";
+// Auto-test mode (/test-auto): when on, the agent verifies its work (build/run/curl/…)
+// and fixes → re-tests until it passes before finishing. Default off; remembered per
+// folder in the session file; sent to /agent-ask as autoTest so python drives the loop.
+let sessionTestAuto = false;
+// Deploy target chosen via /server (task #69): {name, host, user} or null. Session-scoped;
+// sent to /agent-ask as deployServer so the agent deploys to this host with KEY auth.
+let selectedServer = null;
 
 // While a turn runs, mute readline's own echo/redraws so keystrokes can't corrupt the
 // live status display and there's no way to type a new question — only Ctrl+C works.
@@ -703,6 +806,65 @@ const answerFrom = (s) =>
     .replace(/<think>[\s\S]*$/i, "")
     .trim();
 
+// --- Live-thought normalization (task "agent thought normalizing issue") ---------------
+// The blinking status line names the model's current Thought. But the model often emits
+// <code> with NO "Thought:" prose (or degenerates into a runaway), so the raw stream is
+// a create_file(...) blob / escaped CSS — which used to render verbatim on the line
+// ("◐ , #94a3b8);\n -webkit-background-clip…"). Fix: show a genuine thought ONLY when the
+// model actually wrote prose; otherwise name the TOOL it's calling ("Writing App.js");
+// otherwise show nothing (the line falls back to "Thinking…"). Never raw code/CSS.
+const _baseName = (p) => (String(p || "").split(/[\\/]/).pop() || "").trim();
+const THOUGHT_TOOL_LABELS = {
+  create_file: (a) => `Writing ${_baseName(a) || "a file"}`,
+  create_folder: (a) => `Creating ${_baseName(a) || "a folder"}`,
+  edit_lines: (a) => `Editing ${_baseName(a) || "a file"}`,
+  edit_file: (a) => `Editing ${_baseName(a) || "a file"}`,
+  read_file_lines: (a) => `Reading ${_baseName(a) || "a file"}`,
+  read_text_file: (a) => `Reading ${_baseName(a) || "a file"}`,
+  list_dir: (a) => `Listing ${_baseName(a) || "files"}`,
+  grep_repo: () => "Searching the code",
+  run_command: (a) => `Running ${a || "a command"}`,
+  stop_server: () => "Stopping the server",
+  deploy_web: () => "Deploying",
+  fetch_url: (a) => `Fetching ${_baseName(a) || "a page"}`,
+  web_search: () => "Searching the web",
+  http_request: () => "Calling an API",
+  create_pdf: () => "Building a PDF",
+  rag_search: () => "Searching the knowledge base",
+  rag_index: () => "Indexing the knowledge base",
+  download_file: () => "Downloading a file",
+  unzip_file: () => "Unzipping",
+  send_email: () => "Preparing an email",
+  open_url: (a) => `Opening ${a || "a link"}`,
+  final_answer: () => "Composing the answer",
+};
+// Does this candidate look like CODE / a data blob rather than a human thought? (Escaped
+// newlines, braces, hex colors, -webkit-, a leading function call, or too few spaces.)
+const _thoughtLooksCodey = (s) =>
+  /\\n|[{}]|=>|="|#[0-9a-fA-F]{3,6}\b|-webkit-|;\s*$|^\s*[<([]/.test(s) ||
+  /^\s*[a-z_]\w*\s*\(/i.test(s) ||
+  (s.length > 24 && (s.split(" ").length - 1) / s.length < 0.06);
+// Raw in-fence stream → a short, meaningful status: a real Thought clause if the model
+// wrote one, else a friendly label from the tool it's calling, else "" (→ "Thinking…").
+const normalizeThought = (buf) => {
+  const t = String(buf || "");
+  const ci = t.search(/<code[\s>]/i);
+  const head = ci >= 0 ? t.slice(0, ci) : t;
+  // 1) a genuine Thought prose line (before the code) — only if it isn't itself code.
+  const prose = head
+    .replace(/^\s*Thought:\s*/i, "")
+    .split(/\n/)
+    .map((x) => x.trim())
+    .find(Boolean);
+  if (prose && !_thoughtLooksCodey(prose)) return prose.slice(0, 100);
+  // 2) otherwise name the tool being called (from the code part).
+  const codePart = ci >= 0 ? t.slice(ci) : t;
+  const m = /(?:<code>\s*)?\b([a-z_]\w*)\s*\(\s*(?:path\s*=\s*)?["']?([^"'\n,)]*)/i.exec(codePart);
+  if (m && THOUGHT_TOOL_LABELS[m[1]]) return THOUGHT_TOOL_LABELS[m[1]](m[2].trim()).slice(0, 100);
+  // 3) nothing human to show.
+  return "";
+};
+
 async function runAgentTurn(history) {
   const res = await fetch(`${apiBase}/api/worker/agent-ask`, {
     method: "POST",
@@ -715,6 +877,10 @@ async function runAgentTurn(history) {
       // The terminal can show a Yes/No picker → the agent PAUSES on a risky command and
       // asks instead of hard-blocking it (interactive command-approval gate).
       interactiveApproval: true,
+      // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
+      ...(sessionTestAuto ? { autoTest: true } : {}),
+      // Deploy target chosen via /server — host/user only (no secret), for key-auth deploys.
+      ...(selectedServer ? { deployServer: selectedServer } : {}),
       ...(sessionCodingModel ? { codingModelOverride: sessionCodingModel } : {}),
     }),
   });
@@ -774,15 +940,6 @@ async function runAgentTurn(history) {
   // random word. `fenceThought` accumulates the raw in-fence text for the current step.
   let liveThought = "";
   let fenceThought = "";
-  // First non-empty Thought clause: drop the "Thought:" prefix, stop at the <code> block
-  // (we never show code), take the first line, and cap length so it never wraps.
-  const extractThought = (buf) => {
-    let t = String(buf || "");
-    const ci = t.search(/<code[\s>]/i);
-    if (ci >= 0) t = t.slice(0, ci);
-    t = t.replace(/^\s*Thought:\s*/i, "").split(/\n/)[0].trim();
-    return t;
-  };
   const thinkSecs = () => Math.max(1, Math.round((Date.now() - thinkingSince) / 1000));
 
   // The status is TWO in-place lines — the in-progress action, then the playful word
@@ -887,9 +1044,12 @@ async function runAgentTurn(history) {
       // Thought clause for the blinking line (task #64) — up to the <code> block, which is
       // where the prose ends and the tool call begins (we never surface code here).
       if (inStreamFence) {
-        if (!/<code[\s>]/i.test(fenceThought)) {
+        // Accumulate a bounded head of the stream (enough to see the Thought prose OR the
+        // tool call), capped so a 16k-char runaway can't grow the buffer. normalizeThought
+        // yields a clean label — never raw code/CSS.
+        if (fenceThought.length < 400) {
           fenceThought += line + "\n";
-          const th = extractThought(fenceThought);
+          const th = normalizeThought(fenceThought);
           if (th) liveThought = th;
         }
         continue;
@@ -1025,8 +1185,8 @@ async function runAgentTurn(history) {
     // no newline yet (a long reasoning sentence streams token-by-token) — recompute the
     // live clause from the partial too, so the blinking line updates mid-sentence instead
     // of only once the line finally breaks (task #64).
-    if (inStreamFence && !/<code[\s>]/i.test(fenceThought)) {
-      const th = extractThought(fenceThought + carry);
+    if (inStreamFence && fenceThought.length < 400) {
+      const th = normalizeThought(fenceThought + carry);
       if (th) liveThought = th;
     }
     // A non-empty remainder is a partial CONTENT line (heartbeats always arrive whole with
@@ -1161,6 +1321,8 @@ async function runAgentTurn(history) {
 async function main() {
   console.log(cyan("GoNext agent REPL") + dim(` · API ${apiBase} · key ${workerKey.slice(0, 8)}…`));
   await ensureWorkspace();
+  // Restore this folder's remembered auto-test choice so the banner + agent-ask reflect it.
+  sessionTestAuto = await loadSessionTestAuto(resolve(process.cwd()));
   // Show which models will answer, straight from user settings (also validates auth).
   try {
     const probe = await fetchAgentPayload([{ role: "user", content: "ping" }]);
@@ -1169,8 +1331,9 @@ async function main() {
       dim(
         `agent model: ${p.agentModelId || probe?.modelKey || "?"}` +
           (p.codingModelId ? ` · coder: ${p.codingModelId}` : "") +
-          (p.ragEnabled ? " · RAG on" : "")
-      )
+          (p.ragEnabled ? " · RAG on" : "") +
+          ` · auto-test: ${sessionTestAuto ? "on" : "off"}`
+      ) + (sessionTestAuto ? "" : dim(" (/test-auto to enable)"))
     );
   } catch (err) {
     console.error(red(`gonext: ${err.message}`));
@@ -1250,6 +1413,23 @@ async function main() {
       await chooseModel();
       continue;
     }
+    if (line === "/server") {
+      await chooseServer();
+      continue;
+    }
+    if (line === "/test-auto") {
+      sessionTestAuto = !sessionTestAuto;
+      await saveSession(cwd, history); // persist the choice for this folder
+      console.log(
+        (sessionTestAuto ? green("auto-test: ON") : dim("auto-test: OFF")) +
+          dim(
+            sessionTestAuto
+              ? " — the agent will verify its work and fix until it passes, for this folder.\n"
+              : " for this folder.\n"
+          )
+      );
+      continue;
+    }
     if (line === "/reset" || line === "/new") {
       history.length = 0;
       await clearSession(cwd);

package/gonext_agent_chat.py

@@ -2498,6 +2498,13 @@ def run_agent_chat(cfg):
     # risky command and asks the user via the API instead of hard-blocking it.
     _job_id = (cfg.get("jobId") or "").strip()
     _interactive_approval = bool(cfg.get("interactiveApproval"))
+    # Auto-test mode (/test-auto): after making changes the agent must VERIFY them and
+    # fix → re-test until they pass before finishing. Drives a prompt directive + a
+    # slightly higher step budget (the verify loop needs room). Terminal-only.
+    _auto_test = bool(cfg.get("autoTest"))
+    # Deploy target chosen via the terminal /server picker (task #69): {name, host, user}
+    # or None. Host/user only — never a secret; deploys use SSH KEY auth to this host.
+    _deploy_server = cfg.get("deployServer") if isinstance(cfg.get("deployServer"), dict) else None
     # Optional dedicated coding/reasoning model for the CodeAgent's tool-use loop.
     # Routing, plain replies and summarization stay on the chat model (better at
     # natural language); the code model only drives http_request reasoning.
@@ -2731,6 +2738,12 @@ def run_agent_chat(cfg):
         if not cfg.get("maxSteps") and max_steps < 12:
             max_steps = 12
             _log("workspace registered → step budget raised to 12 (no explicit maxSteps)")
+        # Auto-test adds a verify → fix → re-test cycle on top of the work itself, so give
+        # it more room (unless the user pinned a budget). Kept modest so a stuck test loop
+        # still terminates rather than burning a huge budget.
+        if _auto_test and not cfg.get("maxSteps") and max_steps < 16:
+            max_steps = 16
+            _log("auto-test on → step budget raised to 16 (no explicit maxSteps)")
 
     def _rag_s3_and_loc():
         client = _rag_s3_client(rag_region, rag_akid, rag_secret)
@@ -3098,8 +3111,52 @@ def run_agent_chat(cfg):
         "- 'email …' / 'send an email to …' -> send_email(to, subject, body) "
         "(previews first, then sends on confirm).\n"
     ) if _EMAIL_AVAILABLE else ""
+    # Auto-test mode (/test-auto): a directive that makes the agent VERIFY its changes
+    # and fix → re-test until they pass. Only meaningful for workspace code work; empty
+    # otherwise so it costs no prompt-eval when off. Climbs the cheapest-sufficient
+    # verification ladder and bakes in the guardrails (freeze the pass criterion, ignore
+    # flakes, prove the test ran, cap retries) so it converges instead of chasing green.
+    _auto_test_block = (
+        "\nAUTO-TEST MODE (ON): after you CHANGE code you MUST verify it before "
+        "final_answer — never finish on an untested change. Use the CHEAPEST check that "
+        "proves the change, climbing only as needed:\n"
+        "  1. grep_repo the edited file to confirm the change landed (and the old code is gone).\n"
+        "  2. build / typecheck (e.g. run_command('npm run build') / 'tsc --noEmit' / 'go build').\n"
+        "  3. run the project's tests (npm test / pytest / …) if they exist.\n"
+        "  4. if it's a running app, start it and curl/fetch_url it, then check the response "
+        "contains what the change should produce.\n"
+        "DECIDE what 'passes' BEFORE you fix — do NOT weaken the check to make it green. If a "
+        "check FAILS: read the error, make ONE fix, then RE-TEST the SAME way. If it passes only "
+        "after re-running with no change, it was flaky — stop, don't keep editing. Give up after "
+        "3 fix attempts on the same failure and final_answer honestly what still fails. Confirm a "
+        "test actually exercised the change (e.g. the asserted text was really present), not an "
+        "empty/no-op pass.\n"
+        if (_auto_test and _WS_AVAILABLE) else ""
+    )
+    # Deploy target (/server): when the user picked one, tell the agent to deploy THERE
+    # with key auth. Host/user only — the block never contains a password.
+    _deploy_block = ""
+    if _deploy_server and _deploy_server.get("host") and _deploy_server.get("user"):
+        _dh = str(_deploy_server.get("host")).strip()
+        _du = str(_deploy_server.get("user")).strip()
+        _dn = str(_deploy_server.get("name") or _dh).strip()
+        # Diagnostic: prove the picked server reached python (visible in the worker log).
+        _log(f"deploy target: {_du}@{_dh} (server '{_dn}') — injecting into the prompt")
+        _deploy_block = (
+            f"\n*** DEPLOY TARGET — the user already chose a server: '{_dn}' → host={_dh}, "
+            f"user={_du}. Do NOT search the project for host/user/credentials and do NOT ask "
+            f"for them; you already have them. When the task is to DEPLOY, go straight to "
+            f"deploy_web(local_dir, host='{_dh}', user='{_du}', remote_path='/var/www/<domain>', "
+            f"domain='<domain>') — or ssh/scp/rsync to {_du}@{_dh}. KEY auth ONLY "
+            f"(-o BatchMode=yes); NEVER ask for or type a password. If key auth isn't set up "
+            f"(Permission denied publickey,password), STOP and tell the user to run "
+            f"'ssh-copy-id {_du}@{_dh}' once, then retry. ***\n"
+        )
     tool_hint = (
-        f"Solve the TASK step by step (up to {max_steps} steps). At EACH step write a "
+        # Deploy target FIRST (when a server is picked) — a small model buries context deep
+        # in a 20k-char hint, so the chosen server must lead, not trail (task #69 retest fix).
+        _deploy_block
+        + f"Solve the TASK step by step (up to {max_steps} steps). At EACH step write a "
         "brief Thought, then ONE code block that calls a SINGLE tool. You will SEE that "
         "tool's result (Observation) before the next step — use it to decide what to do "
         "next (e.g. web_search to find a URL, THEN fetch_url to read it). When you have "
@@ -3108,7 +3165,7 @@ def run_agent_chat(cfg):
         "{{TOOL_LIST}}\n"  # filled in below, once from the REAL registered tool objects
         f"(Current date/time: {now_str} — pass a timezone to get_current_datetime() only "
         "if the task needs a DIFFERENT one.)\n"
-        + _rag_tool_block + _ws_tool_block +
+        + _rag_tool_block + _ws_tool_block + _auto_test_block +
         "\n"
         "http_request RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
         "\n"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.228",
+  "version": "1.0.230",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",