@zibby/core 0.1.21 → 0.1.22

package/templates/browser-test-automation/run-index.mjs

@@ -0,0 +1,418 @@
+/**
+ * Browser test automation — run-index.jsonl rows (execute_live / generate_script layout).
+ * Used by CLI runTest; generic JSONL I/O is in @zibby/core/utils/run-registry.js.
+ */
+
+import { existsSync, readdirSync, statSync } from 'fs';
+import { join, relative, sep, resolve as pathResolve } from 'path';
+import {
+  appendRunIndexRecord,
+  readRunIndexRecordsFromFile,
+  resolveRunIndexPath,
+} from '../../src/utils/run-registry.js';
+import { mergeSessionRunState, readSessionRunState } from '../../src/utils/run-state-session.js';
+import { partitionRunIndexBySession, runIndexSessionEntryIsLive } from '../../src/utils/run-index-merge.js';
+import { DEFAULT_OUTPUT_BASE, SESSIONS_DIR } from '../../src/framework/constants.js';
+import { BROWSER_TEST_PIPELINE_NODE_IDS } from './pipeline-ids.js';
+
+export { BROWSER_TEST_PIPELINE_NODE_IDS };
+
+/** Stable id for Studio + run-index: Studio env, else session folder id (CLI/chat). */
+function runIndexCorrelationId(sessionId) {
+  const env = process.env.ZIBBY_STUDIO_TEST_CASE_ID;
+  if (env != null && String(env).trim() !== '') return String(env).trim();
+  return sessionId != null ? String(sessionId) : '';
+}
+
+const SCRIPT_CANDIDATES = [
+  join('generate_script', 'generated-test.spec.js'),
+  join('generate_script', 'generated-test.spec.ts'),
+  join('generate_script', 'playwright.spec.ts'),
+  join('generate_script', 'test.spec.ts'),
+];
+
+function firstExistingVideo(sessionAbs) {
+  const dirs = [
+    join(sessionAbs, 'execute_live', 'videos'),
+    join(sessionAbs, 'execute_live'),
+    sessionAbs,
+  ];
+  for (const d of dirs) {
+    if (!existsSync(d)) continue;
+    let names;
+    try {
+      names = readdirSync(d);
+    } catch {
+      continue;
+    }
+    const webm = names.find((f) => f.endsWith('.webm'));
+    if (webm) return join(d, webm);
+  }
+  return null;
+}
+
+function firstExistingEvents(sessionAbs) {
+  const c = [join(sessionAbs, 'execute_live', 'events.json'), join(sessionAbs, 'events.json')];
+  for (const p of c) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+function firstExistingScript(sessionAbs) {
+  for (const rel of SCRIPT_CANDIDATES) {
+    const p = join(sessionAbs, rel);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+/**
+ * Discover absolute artifact paths for a browser-test session directory.
+ * @param {string} sessionPathAbs
+ */
+export function discoverBrowserTestSessionArtifacts(sessionPathAbs) {
+  if (!sessionPathAbs || !existsSync(sessionPathAbs)) {
+    return { videoPathAbs: null, eventsPathAbs: null, scriptPathAbs: null };
+  }
+  return {
+    videoPathAbs: firstExistingVideo(sessionPathAbs),
+    eventsPathAbs: firstExistingEvents(sessionPathAbs),
+    scriptPathAbs: firstExistingScript(sessionPathAbs),
+  };
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.cwd
+ * @param {object} opts.result - return value from agent.run / runSingleNode
+ * @param {boolean} opts.success
+ * @param {string} [opts.outputBase]
+ * @param {string} [opts.specPath]
+ * @param {string} [opts.errorMessage]
+ * @param {string} [opts.status] — override default completed/failed (e.g. `interrupted`)
+ */
+export function buildBrowserTestRunIndexRecord(opts) {
+  const cwd = opts.cwd || process.cwd();
+  const outputBase = opts.outputBase || DEFAULT_OUTPUT_BASE;
+  const result = opts.result || {};
+  const state = result.state || {};
+  const sessionPathAbs = state.sessionPath;
+  if (!sessionPathAbs || typeof sessionPathAbs !== 'string') {
+    return null;
+  }
+
+  const sessionId = sessionPathAbs.split(/[/\\]/).filter(Boolean).pop();
+  if (!sessionId) return null;
+
+  const { videoPathAbs, eventsPathAbs, scriptPathAbs } =
+    discoverBrowserTestSessionArtifacts(sessionPathAbs);
+
+  const toRel = (abs) => {
+    if (!abs) return null;
+    try {
+      return relative(cwd, abs).split(sep).join('/');
+    } catch {
+      return null;
+    }
+  };
+
+  let specRel = null;
+  if (opts.specPath) {
+    try {
+      const absSpec = pathResolve(cwd, opts.specPath);
+      specRel = relative(cwd, absSpec).split(sep).join('/');
+    } catch {
+      specRel = String(opts.specPath).split(sep).join('/');
+    }
+  }
+
+  return {
+    v: 1,
+    recordKind: 'summary',
+    ts: Date.now(),
+    sessionId,
+    status: opts.status ?? (opts.success ? 'completed' : 'failed'),
+    cwd,
+    outputBase,
+    sessionPathAbs,
+    sessionDirRel: toRel(sessionPathAbs),
+    videoPathAbs: videoPathAbs || null,
+    eventsPathAbs: eventsPathAbs || null,
+    scriptPathAbs: scriptPathAbs || null,
+    videoRel: toRel(videoPathAbs),
+    eventsRel: toRel(eventsPathAbs),
+    scriptRel: toRel(scriptPathAbs),
+    specRel,
+    source: process.env.ZIBBY_RUN_SOURCE || 'cli',
+    studioTestCaseId: runIndexCorrelationId(sessionId) || null,
+    errorMessage: opts.errorMessage || null,
+  };
+}
+
+export function tryAppendBrowserTestRunIndex({
+  cwd,
+  config,
+  result,
+  success,
+  specPath,
+  errorMessage,
+}) {
+  try {
+    const record = buildBrowserTestRunIndexRecord({
+      cwd: cwd || process.cwd(),
+      result,
+      success,
+      outputBase: config?.paths?.output || DEFAULT_OUTPUT_BASE,
+      specPath,
+      errorMessage,
+    });
+    if (record) {
+      appendRunIndexRecord(record);
+      if (record.sessionPathAbs) {
+        mergeSessionRunState(record.sessionPathAbs, {
+          sessionId: record.sessionId,
+          studioTestCaseId: record.studioTestCaseId || record.sessionId,
+          status: record.status,
+          activeNode: null,
+          activeStageIndex: null,
+          errorMessage: record.errorMessage || null,
+          runSource: record.source || 'cli',
+          cwd: record.cwd,
+          outputBase: record.outputBase,
+          sessionPathAbs: record.sessionPathAbs,
+        });
+      }
+    }
+  } catch (e) {
+    console.warn(`[zibby browser-test run-index] ${e.message}`);
+  }
+}
+
+/**
+ * Append one JSONL row when a pipeline node starts (live Mission Control).
+ * @param {object} payload
+ * @param {string} payload.currentNode — graph node id
+ * @param {string} payload.sessionPath — absolute session dir
+ * @param {string} [payload.sessionId]
+ * @param {string} [payload.cwd]
+ * @param {string} [payload.outputBase]
+ */
+/**
+ * Single absolute session directory for pipeline progress + zibby-run-state.json.
+ * Studio spawns the CLI with ZIBBY_SESSION_PATH; cwd may still be wrong (home, app bundle, etc.).
+ * Never merge under join(cwd, …/sessions/id) when studio env points elsewhere — that caused duplicate dirs.
+ */
+export function resolveBrowserTestPipelineSessionPathAbs({
+  sessionPath,
+  sessionId,
+  cwd,
+  outputBase = DEFAULT_OUTPUT_BASE,
+} = {}) {
+  const cwd0 = cwd || process.cwd();
+  const ob = outputBase || DEFAULT_OUTPUT_BASE;
+  const sid =
+    sessionId != null && String(sessionId).trim() !== ''
+      ? String(sessionId).trim()
+      : null;
+
+  const studio = process.env.ZIBBY_RUN_SOURCE === 'studio';
+  const envSession = process.env.ZIBBY_SESSION_PATH && String(process.env.ZIBBY_SESSION_PATH).trim();
+  if (studio && envSession) {
+    return pathResolve(envSession);
+  }
+
+  const trimmed = sessionPath && String(sessionPath).trim();
+  if (trimmed) {
+    return pathResolve(trimmed);
+  }
+
+  const sessionsRoot = process.env.ZIBBY_SESSIONS_ROOT && String(process.env.ZIBBY_SESSIONS_ROOT).trim();
+  if (sessionsRoot && sid) {
+    return pathResolve(join(sessionsRoot, sid));
+  }
+
+  if (process.env.ZIBBY_SESSION_PATH && String(process.env.ZIBBY_SESSION_PATH).trim()) {
+    return pathResolve(String(process.env.ZIBBY_SESSION_PATH).trim());
+  }
+
+  return pathResolve(join(cwd0, ob, SESSIONS_DIR, sid || 'invalid'));
+}
+
+export function tryAppendBrowserTestPipelineProgress(payload) {
+  try {
+    const currentNode = payload?.currentNode;
+    if (!currentNode || !BROWSER_TEST_PIPELINE_NODE_IDS.includes(currentNode)) return;
+
+    const sessionPath = payload.sessionPath;
+    const sessionId =
+      payload.sessionId ||
+      (sessionPath && String(sessionPath).split(/[/\\]/).filter(Boolean).pop()) ||
+      null;
+    if (!sessionId) return;
+
+    const cwd = payload.cwd || process.cwd();
+    const outputBase = payload.outputBase || DEFAULT_OUTPUT_BASE;
+    const activeStageIndex = BROWSER_TEST_PIPELINE_NODE_IDS.indexOf(currentNode);
+    const specPathRaw = payload?.specPath != null ? String(payload.specPath).trim() : '';
+    const taskDescription =
+      payload?.taskDescription != null ? String(payload.taskDescription) : '';
+    let specRel = null;
+    if (specPathRaw) {
+      try {
+        const absSpec = pathResolve(cwd, specPathRaw);
+        specRel = relative(cwd, absSpec).split(sep).join('/');
+      } catch {
+        specRel = specPathRaw.split(sep).join('/');
+      }
+    }
+
+    const sessionPathAbs = resolveBrowserTestPipelineSessionPathAbs({
+      sessionPath,
+      sessionId,
+      cwd,
+      outputBase,
+    });
+
+    appendRunIndexRecord({
+      v: 1,
+      recordKind: 'progress',
+      ts: Date.now(),
+      sessionId,
+      cwd,
+      outputBase,
+      sessionPathAbs,
+      activeNode: currentNode,
+      activeStageIndex,
+      specRel,
+      taskDescription: taskDescription || null,
+      studioTestCaseId: runIndexCorrelationId(sessionId) || null,
+      source: process.env.ZIBBY_RUN_SOURCE || 'cli',
+    });
+
+    mergeSessionRunState(sessionPathAbs, {
+      sessionId,
+      studioTestCaseId: runIndexCorrelationId(sessionId) || sessionId,
+      status: 'running',
+      activeNode: currentNode,
+      activeStageIndex,
+      sessionPathAbs,
+      cwd,
+      outputBase,
+      specPath: specRel || null,
+      task: taskDescription || null,
+      taskDescription: taskDescription || null,
+      runSource: process.env.ZIBBY_RUN_SOURCE || 'cli',
+      pid: typeof process.pid === 'number' ? process.pid : null,
+    });
+  } catch (e) {
+    console.warn(`[zibby browser-test run-index progress] ${e.message}`);
+  }
+}
+
+/** Factory for graph.run `initialState.onPipelineProgress`. */
+export function createBrowserTestPipelineProgressAppender({ cwd, config } = {}) {
+  const cwd0 = cwd || process.cwd();
+  const ob0 = config?.paths?.output || DEFAULT_OUTPUT_BASE;
+  return (payload) => {
+    tryAppendBrowserTestPipelineProgress({
+      cwd: payload?.cwd || cwd0,
+      outputBase: payload?.outputBase || ob0,
+      sessionPath: payload?.sessionPath,
+      sessionId: payload?.sessionId,
+      currentNode: payload?.currentNode,
+      specPath: payload?.specPath,
+      taskDescription: payload?.taskDescription,
+    });
+  };
+}
+
+/**
+ * Append a terminal `summary` row for every session that still looks “live” in run-index (progress newer than summary).
+ * Call from SIGINT/SIGTERM so Mission Control clears after Ctrl+C in the terminal.
+ * @param {object} [opts]
+ * @param {string} [opts.cwd]
+ * @param {object} [opts.config] — uses `config.paths.output`
+ */
+export function tryAppendBrowserTestInterruptedRunIndex(opts = {}) {
+  try {
+    const cwd0 = opts.cwd || process.cwd();
+    const outputBase = opts.config?.paths?.output || opts.outputBase || DEFAULT_OUTPUT_BASE;
+    const indexPath = resolveRunIndexPath(cwd0, outputBase);
+    const records = readRunIndexRecordsFromFile(indexPath);
+    const partitioned = partitionRunIndexBySession(records);
+    const handled = new Set();
+
+    const errMsg =
+      opts.errorMessage ||
+      'Run stopped (SIGINT/SIGTERM) before a normal summary was written.';
+
+    const flushInterrupted = (sessionId, sessionPathAbs) => {
+      if (!sessionId || !sessionPathAbs) return;
+      if (handled.has(sessionId)) return;
+      handled.add(sessionId);
+      const record = buildBrowserTestRunIndexRecord({
+        cwd: cwd0,
+        outputBase,
+        result: { state: { sessionPath: sessionPathAbs } },
+        success: false,
+        specPath: null,
+        status: 'interrupted',
+        errorMessage: errMsg,
+      });
+      if (record) {
+        appendRunIndexRecord(record);
+        mergeSessionRunState(sessionPathAbs, {
+          sessionId,
+          studioTestCaseId: record.studioTestCaseId || sessionId,
+          status: 'interrupted',
+          activeNode: null,
+          activeStageIndex: null,
+          errorMessage: record.errorMessage || null,
+          runSource: record.source || 'cli',
+          cwd: cwd0,
+          outputBase,
+          sessionPathAbs,
+        });
+      }
+    };
+
+    // 1) JSONL “live” sessions (progress newer than summary)
+    for (const [folderSessionId, entry] of partitioned) {
+      if (!runIndexSessionEntryIsLive(entry)) continue;
+      const prog = entry.progress;
+      if (!prog) continue;
+      const sessionId = String(folderSessionId);
+      const sessionPathAbs =
+        (prog.sessionPathAbs && String(prog.sessionPathAbs)) ||
+        join(cwd0, outputBase, SESSIONS_DIR, sessionId);
+      flushInterrupted(sessionId, sessionPathAbs);
+    }
+
+    // 2) Disk-only live: Studio (or early CLI) wrote zibby-run-state.json as running before any
+    //    run-index progress line — JSONL partition omits them, so Ctrl+C must clear by scanning sessions/.
+    const sessionsRoot = join(cwd0, outputBase, SESSIONS_DIR);
+    if (!existsSync(sessionsRoot)) return;
+    let names;
+    try {
+      names = readdirSync(sessionsRoot);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const sessionPathAbs = join(sessionsRoot, name);
+      let st;
+      try {
+        st = statSync(sessionPathAbs);
+      } catch {
+        continue;
+      }
+      if (!st.isDirectory()) continue;
+      const doc = readSessionRunState(sessionPathAbs);
+      if (!doc || doc.status !== 'running') continue;
+      flushInterrupted(String(name), sessionPathAbs);
+    }
+  } catch (e) {
+    console.warn(`[zibby browser-test run-index interrupt] ${e.message}`);
+  }
+}

package/scripts/export-default-workflows.js

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-/**
- * Export default workflows as JSON for the backend API
- * Run: node packages/core/scripts/export-default-workflows.js
- */
-
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { WorkflowGraph } from '../src/framework/graph.js';
-import { buildAnalysisGraph } from '../templates/graphs/analysisGraph.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const outputDir = join(__dirname, '../../../backend/src/data');
-
-// Ensure output directory exists
-if (!existsSync(outputDir)) {
-  mkdirSync(outputDir, { recursive: true });
-}
-
-// Build and serialize analysis workflow
-console.log('Building analysis workflow...');
-const analysisGraph = new WorkflowGraph();
-buildAnalysisGraph(analysisGraph);
-const serializedAnalysis = analysisGraph.serialize();
-
-// Add workflow metadata
-const analysisWorkflow = {
-  id: 'default_analysis',
-  name: 'Analysis Workflow',
-  description: 'Analyzes tickets and generates code implementation',
-  ...serializedAnalysis,
-  createdAt: new Date().toISOString(),
-  isDefault: true
-};
-
-// Write to JSON file
-const outputPath = join(outputDir, 'default-workflows.json');
-const workflows = {
-  analysis: analysisWorkflow
-};
-
-writeFileSync(outputPath, JSON.stringify(workflows, null, 2));
-console.log(`✅ Exported default workflows to ${outputPath}`);
-
-// Also export as individual files for clarity
-writeFileSync(
-  join(outputDir, 'default-analysis-workflow.json'),
-  JSON.stringify(analysisWorkflow, null, 2)
-);
-console.log('✅ Exported individual workflow files');

package/scripts/patch-cursor-mcp.js

@@ -1,174 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Patch cursor-agent CLI to auto-approve MCP tool calls for CI/CD use.
- *
- * This script modifies the cursor-agent source code to bypass the manual
- * approval prompt for MCP tool executions, making it suitable for automated
- * CI/CD pipelines.
- *
- * Usage:
- *   node patch-cursor-mcp.js
- */
-
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-function findLatestCursorAgent() {
-  const versionsDir = join(homedir(), '.local/share/cursor-agent/versions');
-  
-  if (!existsSync(versionsDir)) {
-    console.error(`❌ Cursor agent versions directory not found: ${versionsDir}`);
-    console.error('   Make sure cursor-agent is installed: curl https://cursor.com/install -fsS | bash');
-    process.exit(1);
-  }
-  
-  const versions = readdirSync(versionsDir)
-    .map(name => join(versionsDir, name))
-    .filter(path => statSync(path).isDirectory());
-  
-  if (versions.length === 0) {
-    console.error(`❌ No cursor-agent versions found in ${versionsDir}`);
-    process.exit(1);
-  }
-  
-  // Get the latest version by creation time
-  const latestVersion = versions
-    .map(path => ({ path, ctime: statSync(path).ctimeMs }))
-    .sort((a, b) => b.ctime - a.ctime)[0].path;
-  
-  return join(latestVersion, 'index.js');
-}
-
-function backupFile(filePath) {
-  const backupPath = `${filePath  }.backup`;
-  
-  if (existsSync(backupPath)) {
-    console.log(`ℹ️  Backup already exists: ${backupPath}`);
-    return backupPath;
-  }
-  
-  const content = readFileSync(filePath, 'utf8');
-  writeFileSync(backupPath, content, 'utf8');
-  
-  console.log(`✅ Backup created: ${backupPath}`);
-  return backupPath;
-}
-
-function patchMcpApproval(filePath) {
-  const content = readFileSync(filePath, 'utf8');
-  
-  // Check if already patched
-  if (content.includes('AUTO-APPROVE MCP TOOLS FOR CI/CD')) {
-    console.log('✅ File is already patched!');
-    return false;
-  }
-  
-  // Pattern to match the requestApproval call for MCP
-  const pattern = /(\s+const result = await this\.pendingDecisionProvider\.requestApproval\(\{\s+type: OperationType\.Mcp,\s+details: \{\s+name: approvalDetails\.name,\s+toolName: approvalDetails\.toolName,\s+providerIdentifier: approvalDetails\.providerIdentifier,\s+args: approvalDetails\.args,\s+\},\s+toolCallId: args\.toolCallId,\s+\}\);)/;
-  
-  const replacement = `                        // AUTO-APPROVE MCP TOOLS FOR CI/CD
-                        const result = { approved: true };
-                        /*
-                        const result = await this.pendingDecisionProvider.requestApproval({
-                            type: OperationType.Mcp,
-                            details: {
-                                name: approvalDetails.name,
-                                toolName: approvalDetails.toolName,
-                                providerIdentifier: approvalDetails.providerIdentifier,
-                                args: approvalDetails.args,
-                            },
-                            toolCallId: args.toolCallId,
-                        });
-                        */`;
-  
-  const newContent = content.replace(pattern, replacement);
-  
-  if (newContent === content) {
-    console.log('ℹ️  Pattern not found - cursor-agent code structure has changed.');
-    console.log('   This is OKAY! Newer versions might not need this patch.');
-    console.log('   If auto-approval doesn\'t work, cursor-agent team may have fixed it!');
-    return false;
-  }
-  
-  writeFileSync(filePath, newContent, 'utf8');
-  return true;
-}
-
-function addApprovalKeyLogging(filePath) {
-  const content = readFileSync(filePath, 'utf8');
-  const lines = content.split('\n');
-  
-  // Check if already added
-  if (lines.some(line => line.includes('🔑 APPROVAL KEY'))) {
-    console.log('✅ Approval key logging already enabled!');
-    return false;
-  }
-  
-  // Find the line with generateApprovalKey and add logging after it
-  let targetLineNum = -1;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].includes('const approvalKey = generateApprovalKey(serverName, server, this.cwd);')) {
-      targetLineNum = i;
-      break;
-    }
-  }
-  
-  if (targetLineNum === -1) {
-    console.log('⚠️  Could not find approval key generation line');
-    return false;
-  }
-  
-  // Insert the console.log after the generateApprovalKey line
-  const indent = '            ';
-  const logLine = `${indent}console.log("🔑 APPROVAL KEY:", serverName, "=>", approvalKey);`;
-  lines.splice(targetLineNum + 1, 0, logLine);
-  
-  writeFileSync(filePath, lines.join('\n'), 'utf8');
-  return true;
-}
-
-function main() {
-  console.log('🔧 Patching cursor-agent for CI/CD MCP usage...\n');
-  console.log('ℹ️  Note: This patch is temporary and may not be needed in future versions.\n');
-  
-  // Find cursor-agent
-  const indexFile = findLatestCursorAgent();
-  console.log(`📍 Found cursor-agent: ${indexFile}\n`);
-  
-  // Backup
-  backupFile(indexFile);
-  console.log();
-  
-  // Apply patches
-  const patchedApproval = patchMcpApproval(indexFile);
-  if (patchedApproval) {
-    console.log('✅ Patched MCP tool auto-approval');
-  }
-  console.log();
-  
-  const patchedLogging = addApprovalKeyLogging(indexFile);
-  if (patchedLogging) {
-    console.log('✅ Added approval key logging');
-  }
-  console.log();
-  
-  if (patchedApproval || patchedLogging) {
-    console.log('🎉 cursor-agent is now ready for CI/CD!');
-    console.log('\nNext steps:');
-    console.log('1. Run: cursor-agent mcp list');
-    console.log('2. Copy the approval key shown');
-    console.log('3. Add it to ~/.cursor/projects/YOUR_PROJECT/mcp-approvals.json');
-    console.log('\n⚠️  If cursor-agent updates break this patch, MCP may work without it.');
-  } else {
-    console.log('ℹ️  No changes needed - already configured or cursor-agent version doesn\'t need patching!');
-  }
-}
-
-main();
-