skopix 2.0.97 → 2.0.98

package/cli/commands/agent.js

@@ -190,6 +190,7 @@ export async function agentCommand(options) {
       if (msg.type === 'ping') { ws.send(JSON.stringify({ type: 'pong' })); return; }
       if (msg.type === 'record') { await handleRecord(msg); return; }
       if (msg.type === 'replay') { await handleReplay(msg); return; }
+      if (msg.type === 'debug-record') { await handleDebugRecord(msg); return; }
     });
 
     ws.addEventListener('close', () => {
@@ -380,6 +381,103 @@ export async function agentCommand(options) {
     }
   }
 
+  // ── DEBUG-RECORD JOB ────────────────────────────────────────────────────────
+  // Replays steps to a debug point on this agent (which has a display),
+  // then opens the recorder so user can add new steps from that state.
+  async function handleDebugRecord(msg) {
+    const { runId, recordingId, replaySteps, startUrl, env: jobEnv } = msg;
+    console.log(chalk.cyan('  ⏸ Debug replay: ') + chalk.white(replaySteps.length + ' steps to debug point'));
+
+    const sendRun = (data) => {
+      try { ws.send(JSON.stringify({ type: 'runUpdate', runId, data })); } catch {}
+    };
+    const sendRec = (data) => {
+      try { ws.send(JSON.stringify({ type: 'recordingUpdate', recordingId, data })); } catch {}
+    };
+
+    sendRun({ type: 'stdout', text: '' });
+    sendRun({ type: 'stdout', text: '  Replaying ' + replaySteps.length + ' steps to reach debug point...' });
+    sendRun({ type: 'stdout', text: '━'.repeat(60) });
+
+    try {
+      const { chromium } = await import('playwright');
+      const browser = await chromium.launch({ headless: false, args: ['--no-sandbox', '--disable-blink-features=AutomationControlled', '--allow-insecure-localhost'] });
+      const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
+      const page = await ctx.newPage();
+
+      if (startUrl) {
+        await page.goto(startUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
+        await page.waitForTimeout(1000);
+      }
+
+      // Replay each step
+      let stepNum = 0;
+      for (const step of replaySteps) {
+        stepNum++;
+        sendRun({ type: 'stdout', text: '  [' + stepNum + '/' + replaySteps.length + '] ' + (step.action || '').toUpperCase() + ' — ' + (step.description || step.selector || '') });
+        try {
+          const sel = step.stableSelector || step.selector;
+          await executeStep(step, sel, page, { url: startUrl });
+          sendRun({ type: 'stdout', text: chalk.green ? '✓ Done' : '✓ Done' });
+        } catch (err) {
+          sendRun({ type: 'stdout', text: '✖ FAILED: ' + err.message });
+          sendRun({ type: 'done', exitCode: 1, status: 'failed' });
+          sendRun({ type: 'stdout', text: '✗ Replay failed — could not reach debug point' });
+          await browser.close().catch(() => {});
+          ws.send(JSON.stringify({ type: 'jobDone', runId }));
+          return;
+        }
+      }
+
+      sendRun({ type: 'stdout', text: '' });
+      sendRun({ type: 'stdout', text: '  ✔ Reached debug point — starting recorder' });
+
+      // Now start the recorder from this browser state
+      const screenshotDir = path.join(os.homedir(), '.skopix', 'recordings', recordingId);
+      await fs.ensureDir(screenshotDir);
+
+      const recorderPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..', 'core', 'recorder.js');
+      const { spawn } = await import('child_process');
+      const child = spawn('node', [recorderPath, startUrl || '', recordingId, screenshotDir], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+      child.stdout.on('data', (chunk) => {
+        chunk.toString().split('\n').filter(Boolean).forEach(line => {
+          try {
+            const parsed = JSON.parse(line);
+            sendRec(parsed);
+            if (parsed.type === 'step') process.stdout.write(chalk.cyan('    ⏺ ') + (parsed.step?.action || '') + '\n');
+            if (parsed.type === 'done') console.log(chalk.green('  ✔ Debug recording done'));
+          } catch {}
+        });
+      });
+
+      child.stderr.on('data', (chunk) => { sendRec({ type: 'error', message: chunk.toString().trim().slice(0, 200) }); });
+      child.on('close', () => {
+        sendRec({ type: 'stopped' });
+        browser.close().catch(() => {});
+        ws.send(JSON.stringify({ type: 'jobDone', runId }));
+        console.log(chalk.cyan('  ◆ Waiting for jobs\n'));
+      });
+
+      // Listen for stop signal
+      const stopHandler = (event) => {
+        let m; try { m = JSON.parse(event.data); } catch { return; }
+        if (m.type === 'stopRecord' && m.recordingId === recordingId) {
+          try { child.stdin.write('stop\n'); } catch {}
+          ws.removeEventListener('message', stopHandler);
+        }
+      };
+      ws.addEventListener('message', stopHandler);
+
+    } catch (err) {
+      console.error(chalk.red('  ✖ Debug error: ' + err.message));
+      sendRun({ type: 'stdout', text: '✖ Debug replay error: ' + err.message });
+      sendRun({ type: 'done', exitCode: 1, status: 'failed' });
+      sendRun({ type: 'stdout', text: '<span style="color:var(--red)">✗ Replay failed — could not reach debug point</span>' });
+      ws.send(JSON.stringify({ type: 'jobDone', runId }));
+    }
+  }
+
   // ── HELPERS ────────────────────────────────────────────────────────────────
   function sanitiseSelector(sel) {
     if (!sel) return sel;

package/cli/commands/dashboard.js

@@ -1249,17 +1249,33 @@ export async function dashboardCommand(options) {
         const broadcast = (line) => { run.output.push(line); run.listeners.forEach(l => l(line)); };
         const broadcastRec = (line) => { recording.output.push(line); recording.listeners.forEach(l => l(line)); };
 
-        // In team mode, check we have a headed agent available before starting
+        // In team mode, dispatch to a headed agent — never run locally on the server
         if (teamMode) {
           const headedAgent = getLeastBusyAgent(currentUser?.id, true);
           if (!headedAgent) {
-            sendJSON(res, 503, { error: 'No agent with a display connected. Run "skopix agent --server ' + (req.headers.host || 'localhost:9000') + '" on your local machine first to use debug mode.' });
+            sendJSON(res, 503, { error: 'No agent with a display connected. Run "skopix agent --server http://' + (req.headers.host || 'localhost:9000') + '" on your local machine first to use debug mode.' });
             activeRuns.delete(runId);
             activeRecordings.delete(recordingId);
             return;
           }
+          // Dispatch to the headed agent
+          headedAgent.status = 'recording';
+          headedAgent.currentJob = { type: 'debug-record', runId, recordingId };
+          broadcastAgentList();
+          sendToAgent(headedAgent, {
+            type: 'debug-record',
+            runId,
+            recordingId,
+            replaySteps,
+            startUrl: test.url,
+            env: { ...process.env, ...(await resolveUserSecretsEnv(currentUser?.id, teamMode) || {}) },
+          });
+          sendJSON(res, 200, { runId, recordingId, agent: { id: headedAgent.id, name: headedAgent.name } });
+          return;
         }
 
+        // Solo mode — run locally
+        sendJSON(res, 200, { runId, recordingId });
         // Start the debug session asynchronously
         (async () => {
           const sessionDir = path.join(reportsDir, runId);
@@ -2353,7 +2369,7 @@ export async function dashboardCommand(options) {
 
       if (msg.type === 'register') {
         const agentId = msg.agentId || crypto.randomUUID();
-        const agent = { id: agentId, name: msg.name || msg.machine, machine: msg.machine, userId: msg.userId || null, ws, status: 'idle', currentJob: null, connectedAt: Date.now(), hasDisplay: msg.hasDisplay !== false };
+        const agent = { id: agentId, name: msg.name || msg.machine, machine: msg.machine, userId: msg.userId || null, ws, status: 'idle', currentJob: null, connectedAt: Date.now(), hasDisplay: msg.hasDisplay === true };
         agents.set(agentId, agent);
         ws.agentId = agentId;
         ws.send(JSON.stringify({ type: 'registered', agentId }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skopix",
-  "version": "2.0.97",
+  "version": "2.0.98",
   "description": "Browser-based QA tool — record tests by using your app, replay them deterministically, generate Playwright code automatically",
   "main": "cli/index.js",
   "bin": {