@q-agent/agent 0.1.18 → 0.1.20

package/dist/src/runner.js

@@ -1041,9 +1041,12 @@ async function processAuthoringJob(cfg, job) {
             }
             catch { /* best-effort on Windows */ }
         }
+        // Prompt goes as the -p ARGUMENT (not stdin — headless `claude -p` reads the
+        // prompt from argv). stream-json + verbose lets us surface every step live.
         const claudeArgs = [
-            "-p",
-            "--output-format", "json",
+            "-p", job.taskPrompt,
+            "--output-format", "stream-json",
+            "--verbose",
             "--model", job.model,
             "--append-system-prompt-file", systemFile,
             "--allowedTools", "Bash", "Read", "Write", "Glob", "Grep",
@@ -1065,21 +1068,59 @@ async function processAuthoringJob(cfg, job) {
         claude = (0, child_process_1.spawn)((0, paths_1.claudeCli)(), claudeArgs, {
             cwd: workDir,
             env: claudeEnv,
-            stdio: ["pipe", "pipe", "pipe"],
+            stdio: ["ignore", "pipe", "pipe"],
         });
         activeChild = claude;
-        let cout = "";
+        // Surface each step to the agent console + the run WebSocket so the operator
+        // can watch Claude drive browser-harness live.
+        const emitStep = (line) => {
+            const trimmed = line.length > 300 ? line.slice(0, 300) + "…" : line;
+            console.log(`[authoring ${job.caseId}] ${trimmed}`);
+            (0, bus_1.emit)("authoring-step", { caseId: job.caseId, line: trimmed });
+            void api
+                .postAuthoringEvent(cfg, job.sessionId, "authoring.progress", {
+                case: job.caseId, phase: "step", message: trimmed,
+            })
+                .catch(() => { });
+        };
         let cerr = "";
-        claude.stdout?.on("data", (d) => { cout += String(d); });
+        let finalResult = "";
+        let buf = "";
+        const handleEvent = (ev) => {
+            if (ev.type === "assistant" && ev.message?.content) {
+                for (const c of ev.message.content) {
+                    if (c.type === "text" && typeof c.text === "string" && c.text.trim()) {
+                        emitStep(`Claude: ${c.text.trim()}`);
+                    }
+                    else if (c.type === "tool_use") {
+                        const inp = c.input || {};
+                        const detail = inp.command ?? inp.file_path ?? inp.path ?? inp.pattern ?? JSON.stringify(inp).slice(0, 200);
+                        emitStep(`▷ ${String(c.name)}: ${String(detail).replace(/\s+/g, " ").trim()}`);
+                    }
+                }
+            }
+            else if (ev.type === "result" && typeof ev.result === "string") {
+                finalResult = ev.result;
+            }
+        };
+        claude.stdout?.on("data", (d) => {
+            buf += String(d);
+            let nl;
+            while ((nl = buf.indexOf("\n")) >= 0) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line)
+                    continue;
+                try {
+                    handleEvent(JSON.parse(line));
+                }
+                catch { /* ignore non-JSON noise */ }
+            }
+        });
         claude.stderr?.on("data", (d) => { cerr += String(d); });
-        try {
-            claude.stdin?.write(job.taskPrompt);
-            claude.stdin?.end();
-        }
-        catch { }
-        await new Promise((resolve) => {
-            claude.on("close", () => resolve());
-            claude.on("error", (e) => { cerr += `\nclaude spawn error: ${e.message}`; resolve(); });
+        const exitCode = await new Promise((resolve) => {
+            claude.on("close", (c) => resolve(c ?? 0));
+            claude.on("error", (e) => { cerr += `\nclaude spawn error: ${e.message}`; resolve(-1); });
         });
         // 3) Read emitted artifacts.
         const specPath = path.join(workDir, job.specFilename);
@@ -1092,19 +1133,19 @@ async function processAuthoringJob(cfg, job) {
             }
             catch { /* keep default */ }
         }
-        let summary = "";
-        try {
-            summary = JSON.parse(cout).result || "";
-        }
-        catch {
-            summary = (cout || cerr).slice(0, 800);
-        }
-        if (!code.trim() && !summary)
-            summary = "Live authoring produced no spec.";
         const ok = code.trim().length > 0;
+        let summary = finalResult || "";
+        if (!ok) {
+            // Make failures diagnosable: include claude's exit + stderr tail.
+            const errTail = cerr.trim().slice(-500);
+            summary = `${summary || "Live authoring produced no spec."} (claude exit ${exitCode})` +
+                (errTail ? `\n[claude stderr] ${errTail}` : "");
+        }
+        emitStep(ok ? "✓ spec authored" : `✗ no spec (claude exit ${exitCode})`);
+        // Terminal event so the UI can close the live authoring trail.
         await api
             .postAuthoringEvent(cfg, job.sessionId, "authoring.progress", {
-            case: job.caseId, phase: ok ? "done" : "failed", message: summary.slice(0, 400),
+            case: job.caseId, phase: ok ? "done" : "failed", message: (summary || "").slice(0, 300),
         })
             .catch(() => { });
         await finalize(code, discovered, summary, ok);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@q-agent/agent",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Q-Agent Local Agent — claims execution jobs from the Q-Agent server and runs Playwright locally, so manual login/MFA happens on the user's own machine and session credentials never leave it.",
   "license": "UNLICENSED",
   "bin": {

package/vendor/authoring_browser.cjs

@@ -75,36 +75,44 @@ async function waitForCDP(port, timeoutMs) {
   return false;
 }
 
-// Replay saved sessionStorage into the running Chrome so MSAL/SPA apps that keep
-// their token in sessionStorage are authenticated. Playwright is OPTIONAL: if it
-// can't be required (the API container ships none) or no path was given, this is
-// a no-op. Returns the connected Playwright browser (kept alive so the init-script
-// registration survives) or null.
-async function replaySessionStorage(port) {
+// Load the saved sessionStorage map ({origin: {k:v}}), or null if unusable.
+function loadSessionStorage() {
   if (!sessionStoragePath) return null;
-  let byOrigin;
-  try { byOrigin = JSON.parse(fs.readFileSync(sessionStoragePath, 'utf-8')); }
-  catch { return null; }
-  if (!byOrigin || typeof byOrigin !== 'object' || !Object.keys(byOrigin).length) return null;
-  let chromium;
-  try { ({ chromium } = require('playwright')); } catch { return null; }
   try {
-    const browser = await chromium.connectOverCDP(`http://127.0.0.1:${port}`);
-    const ctx = browser.contexts()[0];
-    if (ctx) {
-      await ctx.addInitScript((data) => {
-        try {
-          const o = data && data[location.origin];
-          if (o) for (const k of Object.keys(o)) window.sessionStorage.setItem(k, o[k]);
-        } catch (e) {}
-      }, byOrigin);
-      console.error('authoring_browser: sessionStorage replay armed for', Object.keys(byOrigin).join(','));
-    }
-    return browser;
+    const m = JSON.parse(fs.readFileSync(sessionStoragePath, 'utf-8'));
+    return m && typeof m === 'object' && Object.keys(m).length ? m : null;
+  } catch { return null; }
+}
+
+// Require Playwright if available (agent side); null in the API container.
+function tryPlaywright() {
+  try { return require('playwright').chromium; } catch { return null; }
+}
+
+// Arm sessionStorage replay and navigate the VISIBLE tab to baseUrl WITH the
+// token restored, so MSAL/SPA apps load authenticated. Critical ordering: the
+// init script must be registered BEFORE the first navigation to the app (that's
+// why Chrome is launched at about:blank, not baseUrl). Returns the connected
+// Playwright browser (kept alive so the init-script registration + tab survive).
+async function armAuthAndNavigate(chromium, port, byOrigin) {
+  const browser = await chromium.connectOverCDP(`http://127.0.0.1:${port}`);
+  const ctx = browser.contexts()[0];
+  if (!ctx) return browser;
+  await ctx.addInitScript((data) => {
+    try {
+      const o = data && data[location.origin];
+      if (o) for (const k of Object.keys(o)) window.sessionStorage.setItem(k, o[k]);
+    } catch (e) {}
+  }, byOrigin);
+  const page = ctx.pages()[0] || (await ctx.newPage());
+  try {
+    await page.goto(baseUrl, { waitUntil: 'domcontentloaded', timeout: 45000 });
+    await page.waitForLoadState('networkidle', { timeout: 15000 }).catch(() => {});
   } catch (e) {
-    console.error('authoring_browser: sessionStorage replay failed:', e && e.message);
-    return null;
+    console.error('authoring_browser: navigate after replay failed:', e && e.message);
   }
+  console.error('authoring_browser: sessionStorage replay armed for', Object.keys(byOrigin).join(','));
+  return browser;
 }
 
 (async () => {
@@ -127,14 +135,22 @@ async function replaySessionStorage(port) {
     }
   } catch (e) { console.error('pref seed failed:', e && e.message); }
 
+  // If we can replay sessionStorage (agent side: Playwright resolvable + a saved
+  // map), launch to about:blank and let Playwright navigate AFTER arming the init
+  // script — so the app never loads before the token is restored. Otherwise launch
+  // straight to baseUrl (profile-only / API container).
+  const byOrigin = loadSessionStorage();
+  const chromium = byOrigin ? tryPlaywright() : null;
+  const launchUrl = chromium ? 'about:blank' : baseUrl;
+
   const child = spawn(exe, [
     `--remote-debugging-port=${PORT}`,
     `--user-data-dir=${profileDir}`,
     '--no-first-run', '--no-default-browser-check', '--new-window',
     ...containerFlags(),
-    baseUrl,
+    launchUrl,
   ], { detached: false, stdio: 'ignore' });
-  console.error('authoring_browser launched:', exe, 'port', PORT);
+  console.error('authoring_browser launched:', exe, 'port', PORT, 'replay:', Boolean(chromium));
 
   if (!(await waitForCDP(PORT, 20000))) {
     console.error('authoring_browser: CDP endpoint never came up on port', PORT);
@@ -142,9 +158,13 @@ async function replaySessionStorage(port) {
     process.exit(1);
   }
 
-  // Arm sessionStorage replay (best-effort) BEFORE signalling readiness, so the
-  // token is restored before browser-harness navigates.
-  const pw = await replaySessionStorage(PORT);
+  // Arm sessionStorage replay + navigate the visible tab authenticated, BEFORE
+  // signalling readiness so browser-harness attaches to a logged-in tab.
+  let pw = null;
+  if (chromium) {
+    try { pw = await armAuthAndNavigate(chromium, PORT, byOrigin); }
+    catch (e) { console.error('authoring_browser: replay failed:', e && e.message); }
+  }
 
   // Signal readiness on stdout so the parent proceeds. The daemon resolves
   // BU_CDP_URL to the WS.