staklink 0.3.24 → 0.3.26

package/dist/proxy-server.cjs

@@ -34824,7 +34824,7 @@ var SSEManager = class {
 var sseManager = new SSEManager();
 
 // src/proxy/version.ts
-var VERSION = "0.3.24";
+var VERSION = "0.3.26";
 
 // node_modules/uuid/dist/esm/stringify.js
 var byteToHex = [];
@@ -80367,6 +80367,9 @@ function gitleaksProtect() {
 var import_child_process4 = require("child_process");
 var import_util10 = require("util");
 var execAsync = (0, import_util10.promisify)(import_child_process4.exec);
+function sanitizeGitHubText(text2) {
+  return text2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/`/g, "\\`").replace(/\$/g, "\\$");
+}
 var GitHubCLI = class {
   token;
   branch;
@@ -80474,10 +80477,10 @@ Stderr: ${error82.stderr}`
       "--head",
       this.branch,
       "--title",
-      `"${options.title}"`
+      `"${sanitizeGitHubText(options.title)}"`
     ];
     if (options.body) {
-      args.push("--body", `"${options.body}"`);
+      args.push("--body", `"${sanitizeGitHubText(options.body)}"`);
     }
     if (options.base) {
       args.push("--base", options.base);
@@ -80619,10 +80622,10 @@ Stderr: ${error82.stderr}`
       args.push("--delete-branch");
     }
     if (commitTitle) {
-      args.push("--subject", `"${commitTitle}"`);
+      args.push("--subject", `"${sanitizeGitHubText(commitTitle)}"`);
     }
     if (commitBody) {
-      args.push("--body", `"${commitBody}"`);
+      args.push("--body", `"${sanitizeGitHubText(commitBody)}"`);
     }
     try {
       const { stdout } = await this.execGH(args.join(" "));
@@ -80676,7 +80679,9 @@ Stderr: ${error82.stderr}`
    */
   async addComment(prNumber, comment) {
     try {
-      await this.execGH(`pr comment ${prNumber} --body "${comment}"`);
+      await this.execGH(
+        `pr comment ${prNumber} --body "${sanitizeGitHubText(comment)}"`
+      );
     } catch (error82) {
       throw new Error(`Failed to add comment to PR #${prNumber}: ${error82}`);
     }
@@ -80687,10 +80692,10 @@ Stderr: ${error82.stderr}`
   async updatePR(prNumber, updates) {
     const args = ["pr", "edit", prNumber.toString()];
     if (updates.title) {
-      args.push("--title", `"${updates.title}"`);
+      args.push("--title", `"${sanitizeGitHubText(updates.title)}"`);
     }
     if (updates.body) {
-      args.push("--body", `"${updates.body}"`);
+      args.push("--body", `"${sanitizeGitHubText(updates.body)}"`);
     }
     try {
       await this.execGH(args.join(" "));
@@ -80751,6 +80756,189 @@ Stderr: ${error82.stderr}`
 // src/proxy/playwright.ts
 var fs10 = __toESM(require("fs/promises"), 1);
 var path9 = __toESM(require("path"), 1);
+var DEFAULT_CONFIG = `import { defineConfig } from "@playwright/test";
+export default defineConfig({
+  timeout: 60000,
+  workers: 1,
+  fullyParallel: false,
+  reporter: [
+    ["list"],
+    ["./timestamp-reporter.ts"],
+  ],
+  use: {
+    video: "on",
+    headless: true,
+    browserName: "chromium",
+    trace: "on-first-retry",
+  },
+});
+`;
+var TIMESTAMP_REPORTER_CODE = `import {
+  Reporter,
+  TestCase,
+  TestResult,
+  TestStep,
+  FullConfig,
+  Suite,
+  FullResult,
+} from "@playwright/test/reporter";
+import * as fs from "fs";
+import * as path from "path";
+
+interface TimestampEntry {
+  title: string;
+  category: string;
+  timestamp: string;
+  relativeMs: number;
+  duration: number;
+  location: {
+    file: string;
+    line: number;
+    column: number;
+  };
+  stepPath: string[];
+  sourceCode?: string;
+  error?: {
+    message: string;
+    stack?: string;
+  };
+}
+
+class TimestampReporter implements Reporter {
+  private logs: TimestampEntry[] = [];
+  private testStartTime: number = 0;
+  private outputDir: string = "test-results";
+  private sourceCache: Map<string, string[]> = new Map();
+
+  onBegin(config: FullConfig, suite: Suite) {
+    this.outputDir = config.projects[0]?.outputDir || "test-results";
+    console.log("\\n\u{1F3AC} Timestamp Reporter: Recording action timestamps\\n");
+  }
+
+  private readSourceLine(filePath: string, lineNumber: number): string | undefined {
+    try {
+      // Check cache first
+      if (!this.sourceCache.has(filePath)) {
+        const content = fs.readFileSync(filePath, "utf-8");
+        this.sourceCache.set(filePath, content.split("\\n"));
+      }
+
+      const lines = this.sourceCache.get(filePath);
+      if (lines && lineNumber > 0 && lineNumber <= lines.length) {
+        return lines[lineNumber - 1].trim();
+      }
+    } catch (error) {
+      console.error(\`Error reading source file \${filePath}:\`, error);
+    }
+    return undefined;
+  }
+
+  onTestBegin(test: TestCase, result: TestResult) {
+    this.testStartTime = Date.now();
+    console.log(\`\\n\u{1F4DD} [\${new Date().toISOString()}] Test started: \${test.title}\`);
+  }
+
+  onStepBegin(test: TestCase, result: TestResult, step: TestStep) {
+    // Only log steps that have a location (actual test code)
+    if (!step.location) return;
+
+    const timestamp = new Date().toISOString();
+    const relativeMs = Date.now() - this.testStartTime;
+    const indent = "  ".repeat(step.titlePath().length - 1);
+    const sourceCode = this.readSourceLine(step.location.file, step.location.line);
+
+    console.log(
+      \`\${indent}\u23F1\uFE0F  [\${timestamp}] +\${relativeMs}ms - \${sourceCode || step.title}\`
+    );
+  }
+
+  onStepEnd(test: TestCase, result: TestResult, step: TestStep) {
+    // Only log steps that have a location (actual test code)
+    if (!step.location) return;
+
+    const timestamp = new Date().toISOString();
+    const relativeMs = Date.now() - this.testStartTime;
+
+    // Read the actual source code line
+    const sourceCode = this.readSourceLine(step.location.file, step.location.line);
+
+    const entry: TimestampEntry = {
+      title: step.title,
+      category: step.category,
+      timestamp: timestamp,
+      relativeMs: relativeMs,
+      duration: step.duration,
+      stepPath: step.titlePath(),
+      location: {
+        file: step.location.file,
+        line: step.location.line,
+        column: step.location.column,
+      },
+      sourceCode: sourceCode,
+    };
+
+    // Add error if present
+    if (step.error) {
+      entry.error = {
+        message: step.error.message || "Unknown error",
+        stack: step.error.stack,
+      };
+    }
+
+    this.logs.push(entry);
+
+    const indent = "  ".repeat(step.titlePath().length - 1);
+    const status = step.error ? "\u274C" : "\u2705";
+    console.log(
+      \`\${indent}\${status} [\${timestamp}] \${sourceCode || step.title} (\${step.duration}ms)\`
+    );
+  }
+
+  onTestEnd(test: TestCase, result: TestResult) {
+    const videoAttachment = result.attachments.find((a) => a.name === "video");
+    const videoPath = videoAttachment?.path;
+
+    const output = {
+      testTitle: test.title,
+      testId: test.id,
+      status: result.status,
+      duration: result.duration,
+      startTime: new Date(this.testStartTime).toISOString(),
+      videoPath: videoPath || null,
+      actions: this.logs,
+    };
+
+    // Write to test-results directory
+    const sanitizedTitle = test.title
+      .replace(/[^a-z0-9]/gi, "-")
+      .toLowerCase();
+    const outputPath = path.join(
+      this.outputDir,
+      \`timestamps-\${sanitizedTitle}.json\`
+    );
+
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, JSON.stringify(output, null, 2));
+
+    console.log(\`\\n\u{1F4BE} Timestamps saved to: \${outputPath}\`);
+    if (videoPath) {
+      console.log(\`\u{1F4F9} Video path: \${videoPath}\`);
+    }
+    console.log("");
+
+    // Reset logs for next test
+    this.logs = [];
+    // Clear source cache to free memory
+    this.sourceCache.clear();
+  }
+
+  onEnd(result: FullResult) {
+    console.log(\`\\n\u2705 Test run complete! Status: \${result.status}\\n\`);
+  }
+}
+
+export default TimestampReporter;
+`;
 async function findRepositoryLocation(repoName) {
   const repoLocation = await findRepoLocation(repoName);
   if (!repoLocation) {
@@ -80785,12 +80973,39 @@ async function findPlaywrightConfig(repoLocation) {
 }
 async function createPlaywrightConfig(repoLocation) {
   const configPath = path9.join(repoLocation, "playwright.config.ts");
-  const defaultConfig = `import { defineConfig } from "@playwright/test";
+  await fs10.writeFile(configPath, DEFAULT_CONFIG);
+  console.log(`Created playwright config at ${configPath}`);
+  return configPath;
+}
+async function createTimestampReporter(repoLocation) {
+  const reporterPath = path9.join(repoLocation, "timestamp-reporter.ts");
+  await fs10.writeFile(reporterPath, TIMESTAMP_REPORTER_CODE);
+  console.log(`Created timestamp reporter at ${reporterPath}`);
+  return reporterPath;
+}
+async function setupPlaywrightConfig(repoLocation) {
+  let configPath = await findPlaywrightConfig(repoLocation);
+  let wasCreated = false;
+  let originalContent = null;
+  let wasModified = false;
+  const reporterPath = await createTimestampReporter(repoLocation);
+  if (!configPath) {
+    configPath = await createPlaywrightConfig(repoLocation);
+    wasCreated = true;
+    console.log("Created new playwright config");
+  } else {
+    originalContent = await fs10.readFile(configPath, "utf-8");
+    wasModified = true;
+    const newConfig = `import { defineConfig } from "@playwright/test";
 
 export default defineConfig({
   timeout: 60000,
   workers: 1,
   fullyParallel: false,
+  reporter: [
+    ["list"],
+    ["./timestamp-reporter.ts"],
+  ],
   use: {
     video: "on",
     headless: true,
@@ -80799,63 +81014,18 @@ export default defineConfig({
   },
 });
 `;
-  await fs10.writeFile(configPath, defaultConfig);
-  console.log(`Created playwright config at ${configPath}`);
-  return configPath;
-}
-async function ensureVideoEnabled(configPath) {
-  const configContent = await fs10.readFile(configPath, "utf-8");
-  if (configContent.match(/video:\s*["']on["']/)) {
-    console.log("Video already enabled in config");
-    return null;
-  }
-  console.log("Updating config to enable video recording");
-  let updatedConfig = configContent;
-  const useBlockRegex = /use:\s*\{([^}]*)\}/s;
-  const match2 = configContent.match(useBlockRegex);
-  if (match2) {
-    const useBlockContent = match2[1];
-    if (useBlockContent.includes("video:")) {
-      updatedConfig = configContent.replace(
-        /video:\s*["'][^"']*["']/,
-        'video: "on"'
-      );
-    } else {
-      const updatedUseBlock = `use: {
-    video: "on",${useBlockContent}}`;
-      updatedConfig = configContent.replace(useBlockRegex, updatedUseBlock);
-    }
-  } else {
-    const configObjectRegex = /export\s+default\s+defineConfig\(\s*\{/;
-    updatedConfig = configContent.replace(
-      configObjectRegex,
-      `export default defineConfig({
-  use: {
-    video: "on",
-  },`
+    await fs10.writeFile(configPath, newConfig);
+    console.log(
+      `Overwrote existing config at ${configPath} (backed up for cleanup)`
     );
   }
-  await fs10.writeFile(configPath, updatedConfig);
-  console.log("Config updated to enable video recording");
-  return configContent;
-}
-async function setupPlaywrightConfig(repoLocation) {
-  let configPath = await findPlaywrightConfig(repoLocation);
-  let wasCreated = false;
-  let originalContent = null;
-  let wasModified = false;
-  if (!configPath) {
-    configPath = await createPlaywrightConfig(repoLocation);
-    wasCreated = true;
-  } else {
-    originalContent = await ensureVideoEnabled(configPath);
-    wasModified = originalContent !== null;
-  }
   return {
     configPath,
     wasCreated,
     originalContent,
-    wasModified
+    wasModified,
+    reporterPath,
+    reporterWasCreated: true
   };
 }
 async function ensureTestResultsInGitignore(repoLocation) {
@@ -80928,14 +81098,48 @@ async function findVideoFile(repoLocation) {
   console.log(`Found video at: ${videoPath}`);
   return videoPath;
 }
-async function uploadVideo(videoPath, responseUrl) {
+async function findTimestampJsonFile(repoLocation) {
+  const testResultsDir = path9.join(repoLocation, "test-results");
+  const walkDir = async (dir) => {
+    try {
+      const files = await fs10.readdir(dir);
+      for (const file3 of files) {
+        const fullPath = path9.join(dir, file3);
+        const stat4 = await fs10.stat(fullPath);
+        if (stat4.isDirectory()) {
+          const result = await walkDir(fullPath);
+          if (result) {
+            return result;
+          }
+        } else if (file3.startsWith("timestamps-") && file3.endsWith(".json")) {
+          return fullPath;
+        }
+      }
+    } catch (error82) {
+      console.error(`Error walking directory ${dir}:`, error82);
+    }
+    return null;
+  };
+  const jsonPath = await walkDir(testResultsDir);
+  if (!jsonPath) {
+    throw new Error("No timestamp JSON file found in test-results directory");
+  }
+  console.log(`Found timestamp JSON at: ${jsonPath}`);
+  return jsonPath;
+}
+async function uploadVideo(videoPath, timestampJsonPath, responseUrl) {
   const videoBuffer = await fs10.readFile(videoPath);
+  const jsonBuffer = await fs10.readFile(timestampJsonPath);
   const FormData2 = (await Promise.resolve().then(() => __toESM(require_form_data(), 1))).default;
   const formData = new FormData2();
   formData.append("video", videoBuffer, {
     filename: path9.basename(videoPath),
     contentType: "video/webm"
   });
+  formData.append("timestamps", jsonBuffer, {
+    filename: path9.basename(timestampJsonPath),
+    contentType: "application/json"
+  });
   const uploadResponse = await fetch(responseUrl, {
     method: "POST",
     body: formData,
@@ -80943,34 +81147,49 @@ async function uploadVideo(videoPath, responseUrl) {
   });
   if (!uploadResponse.ok) {
     throw new Error(
-      `Failed to upload video: ${uploadResponse.status} ${uploadResponse.statusText}`
+      `Failed to upload files: ${uploadResponse.status} ${uploadResponse.statusText}`
     );
   }
-  console.log(`Video uploaded successfully to ${responseUrl}`);
+  console.log(`Video and timestamps uploaded successfully to ${responseUrl}`);
   return uploadResponse.status;
 }
-async function deleteVideo(videoPath) {
+async function deleteTestFiles(videoPath, timestampJsonPath) {
   try {
     await fs10.unlink(videoPath);
     console.log(`Deleted video file: ${videoPath}`);
   } catch (error82) {
     console.error(`Error deleting video file ${videoPath}:`, error82);
   }
+  try {
+    await fs10.unlink(timestampJsonPath);
+    console.log(`Deleted timestamp JSON: ${timestampJsonPath}`);
+  } catch (error82) {
+    console.error(`Error deleting timestamp JSON ${timestampJsonPath}:`, error82);
+  }
 }
 async function cleanupConfig(configState) {
-  if (!configState.configPath) {
-    return;
+  if (configState.configPath) {
+    try {
+      if (configState.wasCreated) {
+        await fs10.unlink(configState.configPath);
+        console.log(
+          `Cleaned up created config file: ${configState.configPath}`
+        );
+      } else if (configState.wasModified && configState.originalContent) {
+        await fs10.writeFile(configState.configPath, configState.originalContent);
+        console.log(`Restored original config: ${configState.configPath}`);
+      }
+    } catch (error82) {
+      console.error("Error cleaning up config:", error82);
+    }
   }
-  try {
-    if (configState.wasCreated) {
-      await fs10.unlink(configState.configPath);
-      console.log(`Cleaned up created config file: ${configState.configPath}`);
-    } else if (configState.wasModified && configState.originalContent) {
-      await fs10.writeFile(configState.configPath, configState.originalContent);
-      console.log(`Restored original config: ${configState.configPath}`);
+  if (configState.reporterPath && configState.reporterWasCreated) {
+    try {
+      await fs10.unlink(configState.reporterPath);
+      console.log(`Cleaned up reporter file: ${configState.reporterPath}`);
+    } catch (error82) {
+      console.error("Error cleaning up reporter:", error82);
     }
-  } catch (error82) {
-    console.error("Error cleaning up config:", error82);
   }
 }
 async function runPlaywrightTestWithVideo(options) {
@@ -80983,12 +81202,13 @@ async function runPlaywrightTestWithVideo(options) {
     await ensureTestResultsInGitignore(repoLocation);
     const testResult = await runPlaywrightTest(repoLocation, testFilePath);
     const videoPath = await findVideoFile(repoLocation);
+    const timestampJsonPath = await findTimestampJsonFile(repoLocation);
     let uploadStatus;
     if (responseUrl) {
-      uploadStatus = await uploadVideo(videoPath, responseUrl);
-      await deleteVideo(videoPath);
+      uploadStatus = await uploadVideo(videoPath, timestampJsonPath, responseUrl);
+      await deleteTestFiles(videoPath, timestampJsonPath);
     } else {
-      console.log("No responseUrl provided, keeping video file locally");
+      console.log("No responseUrl provided, keeping files locally");
     }
     await cleanupConfig(configState);
     return {

package/dist/staklink-cli.cjs

@@ -10905,7 +10905,7 @@ var glob = Object.assign(glob_, {
 glob.glob = glob;
 
 // src/proxy/version.ts
-var VERSION = "0.3.24";
+var VERSION = "0.3.26";
 
 // src/cli.ts
 var STAKLINK_PROXY = "staklink-proxy";

package/package.json

@@ -2,7 +2,7 @@
   "name": "staklink",
   "displayName": "staklink",
   "description": "staklink process manager",
-  "version": "0.3.24",
+  "version": "0.3.26",
   "type": "module",
   "publisher": "stakwork",
   "engines": {

package/test-results/timestamps-yolo-page-should-display-yolo-text.json

@@ -0,0 +1,106 @@
+{
+  "testTitle": "YOLO page should display YOLO text",
+  "testId": "ea70bc1c4bc8cb3ef066-ef50a3f3fbda7cffd2c6",
+  "status": "passed",
+  "duration": 2661,
+  "startTime": "2025-11-20T05:03:47.154Z",
+  "videoPath": "/Users/evanfeenstra/code/sphinx2/staklink/test-results/scripts-demo-test-YOLO-page-should-display-YOLO-text/video.webm",
+  "actions": [
+    {
+      "title": "Navigate to \"/\"",
+      "category": "pw:api",
+      "timestamp": "2025-11-20T05:03:47.791Z",
+      "relativeMs": 637,
+      "duration": 505,
+      "stepPath": [
+        "Navigate to \"/\""
+      ],
+      "location": {
+        "file": "/Users/evanfeenstra/code/sphinx2/staklink/scripts/demo-test.spec.ts",
+        "line": 5,
+        "column": 14
+      },
+      "sourceCode": "await page.goto('http://localhost:8080', { waitUntil: 'networkidle' });"
+    },
+    {
+      "title": "Wait for load state \"domcontentloaded\"",
+      "category": "pw:api",
+      "timestamp": "2025-11-20T05:03:47.793Z",
+      "relativeMs": 639,
+      "duration": 1,
+      "stepPath": [
+        "Wait for load state \"domcontentloaded\""
+      ],
+      "location": {
+        "file": "/Users/evanfeenstra/code/sphinx2/staklink/scripts/demo-test.spec.ts",
+        "line": 8,
+        "column": 14
+      },
+      "sourceCode": "await page.waitForLoadState('domcontentloaded');"
+    },
+    {
+      "title": "Expect \"toHaveText\"",
+      "category": "expect",
+      "timestamp": "2025-11-20T05:03:47.815Z",
+      "relativeMs": 661,
+      "duration": 21,
+      "stepPath": [
+        "Expect \"toHaveText\""
+      ],
+      "location": {
+        "file": "/Users/evanfeenstra/code/sphinx2/staklink/scripts/demo-test.spec.ts",
+        "line": 11,
+        "column": 36
+      },
+      "sourceCode": "await expect(page.locator('h1')).toHaveText('YOLO');"
+    },
+    {
+      "title": "Expect \"toBeVisible\"",
+      "category": "expect",
+      "timestamp": "2025-11-20T05:03:47.817Z",
+      "relativeMs": 663,
+      "duration": 2,
+      "stepPath": [
+        "Expect \"toBeVisible\""
+      ],
+      "location": {
+        "file": "/Users/evanfeenstra/code/sphinx2/staklink/scripts/demo-test.spec.ts",
+        "line": 14,
+        "column": 40
+      },
+      "sourceCode": "await expect(page.locator('button')).toBeVisible();"
+    },
+    {
+      "title": "Expect \"toHaveText\"",
+      "category": "expect",
+      "timestamp": "2025-11-20T05:03:47.819Z",
+      "relativeMs": 665,
+      "duration": 2,
+      "stepPath": [
+        "Expect \"toHaveText\""
+      ],
+      "location": {
+        "file": "/Users/evanfeenstra/code/sphinx2/staklink/scripts/demo-test.spec.ts",
+        "line": 15,
+        "column": 40
+      },
+      "sourceCode": "await expect(page.locator('button')).toHaveText('Test');"
+    },
+    {
+      "title": "Wait for timeout",
+      "category": "pw:api",
+      "timestamp": "2025-11-20T05:03:49.821Z",
+      "relativeMs": 2667,
+      "duration": 2002,
+      "stepPath": [
+        "Wait for timeout"
+      ],
+      "location": {
+        "file": "/Users/evanfeenstra/code/sphinx2/staklink/scripts/demo-test.spec.ts",
+        "line": 18,
+        "column": 14
+      },
+      "sourceCode": "await page.waitForTimeout(2000);"
+    }
+  ]
+}