form-tester 0.6.0 → 0.7.1

package/.claude/skills/form-tester/SKILL.md

@@ -20,7 +20,10 @@ form-tester install --global   # or install to ~/.claude/skills/
 form-tester test <url> --auto
 form-tester test <url> --auto --pnr 12345 --persona ung-mann --scenario "test validation"
 
-# Interactive CLI:
+# Interactive mode (prompts for persona, scenario, etc.):
+form-tester test <url> --human
+
+# Full interactive CLI:
 form-tester
 ```
 
@@ -28,8 +31,17 @@ Persona IDs: `ung-mann`, `gravid-kvinne`, `eldre-kvinne`, `kronisk-syk-mann`. De
 
 ## Recording & Replay
 
-Every test run records all playwright-cli commands to `recording.json` in the output folder. Replay a previous run:
+Every test run records all commands to `recording.json` in the output folder. To ensure ALL commands are recorded (including form filling, clicking, etc.), always use `form-tester exec` instead of `playwright-cli` directly:
+
+```bash
+# ALWAYS use this instead of playwright-cli directly:
+form-tester exec fill e1 "value"
+form-tester exec click e3
+form-tester exec screenshot --filename "path.png" --full-page
+form-tester exec close    # finalizes and saves the recording
+```
 
+Replay a previous run:
 ```bash
 form-tester replay output/form-id/timestamp/recording.json
 ```
@@ -57,4 +69,12 @@ Use `/people` to rescan the visible person list and get a numbered selection pro
 
 ## Playwright CLI
 
-You can also run `playwright-cli` commands directly when needed.
+IMPORTANT: Always use `form-tester exec` instead of `playwright-cli` directly. This ensures all commands are recorded for replay. The syntax is the same — just prefix with `form-tester exec`:
+
+```bash
+form-tester exec snapshot
+form-tester exec fill e1 "value"
+form-tester exec click e3
+form-tester exec screenshot --filename "page.png" --full-page
+form-tester exec close
+```

package/form-tester.js

@@ -6,39 +6,78 @@ const { spawn, execSync } = require("child_process");
 
 const CONFIG_PATH = path.join(process.cwd(), "form-tester.config.json");
 const OUTPUT_BASE = path.resolve(process.cwd(), "output");
-const LOCAL_VERSION = "0.6.0";
+const LOCAL_VERSION = "0.7.1";
 const RECOMMENDED_PERSON = "Uromantisk Direktør";
 
-// Recording state — when active, all playwright-cli commands are logged
-let activeRecording = null;
+// Recording — persisted to disk so `form-tester exec` can append across processes
+let activeRecordingPath = null;
 
 function startRecording(outputDir) {
-  activeRecording = { commands: [], outputDir, startedAt: new Date().toISOString() };
+  const filePath = path.join(outputDir, "recording.json");
+  const data = {
+    version: LOCAL_VERSION,
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+    commandCount: 0,
+    commands: [],
+  };
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  activeRecordingPath = filePath;
+  return filePath;
 }
 
 function recordCommand(args) {
-  if (activeRecording) {
-    activeRecording.commands.push({ args, timestamp: new Date().toISOString() });
+  // In-process recording
+  if (activeRecordingPath && fs.existsSync(activeRecordingPath)) {
+    appendToRecording(activeRecordingPath, args);
+    return;
+  }
+  // Check config for active recording (cross-process via exec)
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+    if (config.activeRecording && fs.existsSync(config.activeRecording)) {
+      appendToRecording(config.activeRecording, args);
+    }
+  } catch (e) {
+    // no config or no active recording, skip
   }
 }
 
-function saveRecording() {
-  if (!activeRecording || !activeRecording.commands.length) return null;
-  const filePath = path.join(activeRecording.outputDir, "recording.json");
-  const data = {
-    version: LOCAL_VERSION,
-    startedAt: activeRecording.startedAt,
-    completedAt: new Date().toISOString(),
-    commandCount: activeRecording.commands.length,
-    commands: activeRecording.commands,
-  };
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-  activeRecording = null;
-  return filePath;
+function appendToRecording(filePath, args) {
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    data.commands.push({ args, timestamp: new Date().toISOString() });
+    data.commandCount = data.commands.length;
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  } catch (e) {
+    // recording file corrupted or gone, skip
+  }
 }
 
-function stopRecording() {
-  activeRecording = null;
+function finalizeRecording(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    data.completedAt = new Date().toISOString();
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    return filePath;
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveRecording() {
+  const result = finalizeRecording(activeRecordingPath);
+  activeRecordingPath = null;
+  // Clear active recording from config
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+    delete config.activeRecording;
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  } catch (e) {
+    // config not found, skip
+  }
+  return result;
 }
 
 const PERSONAS = [
@@ -854,8 +893,10 @@ async function handleTest(url, config) {
   config.lastRunDir = outputDir;
   saveConfig(config);
 
-  // Start recording
-  startRecording(outputDir);
+  // Start recording and persist path to config for `exec`
+  const recordingFile = startRecording(outputDir);
+  config.activeRecording = recordingFile;
+  saveConfig(config);
 
   if (personaChoice.type === "preset") {
     fs.writeFileSync(
@@ -971,8 +1012,10 @@ async function handleTestAuto(url, config, flags) {
   config.lastRunDir = outputDir;
   saveConfig(config);
 
-  // Start recording
-  startRecording(outputDir);
+  // Start recording and persist path to config for `exec`
+  const recordingFile = startRecording(outputDir);
+  config.activeRecording = recordingFile;
+  saveConfig(config);
 
   // Save persona and scenario
   if (personaChoice.type === "preset") {
@@ -1213,6 +1256,40 @@ async function main() {
     process.exit(0);
   }
 
+  if (args[0] === "exec") {
+    const pwArgs = args.slice(1);
+    if (!pwArgs.length) {
+      console.error("Usage: form-tester exec <playwright-cli command and args>");
+      process.exit(1);
+    }
+    // Record (reads config.activeRecording) and run playwright-cli directly
+    recordCommand(pwArgs);
+    // Run without going through runPlaywrightCli to avoid double-recording
+    const spec = getPlaywrightCommandSpec();
+    const spawnOpts = { stdio: "inherit" };
+    if (spec.shell) spawnOpts.shell = true;
+    const code = await new Promise((resolve) => {
+      const child = spawn(spec.command, [...spec.args, ...pwArgs], spawnOpts);
+      child.on("error", (err) => { console.error(err.message); resolve(1); });
+      child.on("exit", (c) => resolve(c ?? 0));
+    });
+    // If the command was "close", finalize the recording
+    if (pwArgs[0] === "close") {
+      try {
+        const config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+        if (config.activeRecording) {
+          const rPath = finalizeRecording(config.activeRecording);
+          delete config.activeRecording;
+          fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+          if (rPath) console.log(`Recording saved: ${rPath}`);
+        }
+      } catch (e) {
+        // no config, skip
+      }
+    }
+    process.exit(code);
+  }
+
   if (args[0] === "replay") {
     const filePath = args[1];
     if (!filePath) {
@@ -1223,6 +1300,17 @@ async function main() {
     process.exit(0);
   }
 
+  if (args[0] === "test" && args.includes("--human")) {
+    const config = loadConfig();
+    const url = args.find((a) => a.startsWith("http"));
+    if (!url) {
+      console.error("Usage: form-tester test <url> --human");
+      process.exit(1);
+    }
+    await handleTest(url, config);
+    process.exit(0);
+  }
+
   if (args[0] === "test" && args.includes("--auto")) {
     const config = loadConfig();
     const url = args.find((a) => a.startsWith("http"));
@@ -1285,5 +1373,8 @@ module.exports = {
   getPersonaById,
   formatPersonaList,
   promptScenario,
+  startRecording,
+  appendToRecording,
+  finalizeRecording,
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "form-tester",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "AI-powered form testing skill for /skjemautfyller forms using Playwright CLI. Works with Claude Code and GitHub Copilot.",
   "main": "form-tester.js",
   "bin": {

package/tests/form-tester.test.js

@@ -1,6 +1,10 @@
 const test = require("node:test");
 const assert = require("node:assert/strict");
 
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
 const {
   extractFormId,
   extractPnrFromUrl,
@@ -14,6 +18,9 @@ const {
   getPersonaById,
   formatPersonaList,
   promptScenario,
+  startRecording,
+  appendToRecording,
+  finalizeRecording,
 } = require("../form-tester");
 
 test("extractFormId returns form id from skjemautfyller URL", () => {
@@ -118,3 +125,58 @@ test("each persona has a unique id", () => {
 test("promptScenario is exported as a function", () => {
   assert.equal(typeof promptScenario, "function");
 });
+
+// --- Recording tests ---
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "form-tester-test-"));
+}
+
+test("startRecording creates recording.json with empty commands", () => {
+  const dir = makeTmpDir();
+  const filePath = startRecording(dir);
+  assert.equal(filePath, path.join(dir, "recording.json"));
+  const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  assert.equal(data.commandCount, 0);
+  assert.deepEqual(data.commands, []);
+  assert.ok(data.startedAt);
+  assert.equal(data.completedAt, null);
+  fs.rmSync(dir, { recursive: true });
+});
+
+test("appendToRecording adds commands to recording file", () => {
+  const dir = makeTmpDir();
+  const filePath = startRecording(dir);
+  appendToRecording(filePath, ["open", "https://example.com"]);
+  appendToRecording(filePath, ["fill", "e1", "hello"]);
+  appendToRecording(filePath, ["click", "e3"]);
+  const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  assert.equal(data.commandCount, 3);
+  assert.deepEqual(data.commands[0].args, ["open", "https://example.com"]);
+  assert.deepEqual(data.commands[1].args, ["fill", "e1", "hello"]);
+  assert.deepEqual(data.commands[2].args, ["click", "e3"]);
+  assert.ok(data.commands[0].timestamp);
+  fs.rmSync(dir, { recursive: true });
+});
+
+test("finalizeRecording sets completedAt timestamp", () => {
+  const dir = makeTmpDir();
+  const filePath = startRecording(dir);
+  appendToRecording(filePath, ["snapshot"]);
+  const result = finalizeRecording(filePath);
+  assert.equal(result, filePath);
+  const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  assert.ok(data.completedAt);
+  assert.equal(data.commandCount, 1);
+  fs.rmSync(dir, { recursive: true });
+});
+
+test("finalizeRecording returns null for missing file", () => {
+  assert.equal(finalizeRecording("/nonexistent/recording.json"), null);
+  assert.equal(finalizeRecording(null), null);
+});
+
+test("appendToRecording is resilient to missing file", () => {
+  // Should not throw
+  appendToRecording("/nonexistent/recording.json", ["click", "e1"]);
+});