screenhand 0.1.1 → 0.2.0

package/dist/npm-publish-helper.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env tsx
+/**
+ * Helper script: Uses ScreenHand to navigate npm tokens page in Safari.
+ * Spawns the MCP server, starts a session, and automates Safari.
+ */
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, "..");
+const tsxBin = path.join(projectRoot, "node_modules", ".bin", "tsx");
+const TIMEOUT_MS = 15_000;
+const proc = spawn(tsxBin, [path.join(projectRoot, "src/mcp-entry.ts")], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env, SCREENHAND_ADAPTER: "accessibility" },
+    cwd: projectRoot,
+});
+let stderrBuf = "";
+proc.stderr.on("data", (d) => {
+    stderrBuf += d.toString();
+    process.stderr.write(d);
+});
+let msgId = 0;
+function send(msg) {
+    proc.stdin.write(JSON.stringify(msg) + "\n");
+}
+const rl = createInterface({ input: proc.stdout });
+const lineQueue = [];
+let lineWaiter = null;
+rl.on("line", (line) => {
+    if (lineWaiter) {
+        const w = lineWaiter;
+        lineWaiter = null;
+        w(line);
+    }
+    else {
+        lineQueue.push(line);
+    }
+});
+function readResponse() {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            lineWaiter = null;
+            reject(new Error(`Timeout. stderr: ${stderrBuf.slice(-500)}`));
+        }, TIMEOUT_MS);
+        const handle = (line) => {
+            clearTimeout(timer);
+            resolve(JSON.parse(line));
+        };
+        const queued = lineQueue.shift();
+        if (queued) {
+            clearTimeout(timer);
+            resolve(JSON.parse(queued));
+        }
+        else {
+            lineWaiter = handle;
+        }
+    });
+}
+async function callTool(name, args) {
+    const id = ++msgId;
+    send({ jsonrpc: "2.0", id, method: "tools/call", params: { name, arguments: args } });
+    const resp = await readResponse();
+    const result = resp.result;
+    const content = result?.content;
+    const data = content?.[0]?.text ? JSON.parse(content[0].text) : null;
+    if (result?.isError) {
+        console.error(`  ERROR: ${content?.[0]?.text}`);
+    }
+    return data;
+}
+try {
+    // Wait for server to start
+    await new Promise((r) => setTimeout(r, 2000));
+    // Initialize MCP
+    send({
+        jsonrpc: "2.0", id: ++msgId, method: "initialize",
+        params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "npm-helper", version: "1.0" } },
+    });
+    await readResponse();
+    send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    await new Promise((r) => setTimeout(r, 300));
+    // Start session
+    console.log("Starting session...");
+    const session = await callTool("session_start", {});
+    const sid = session.sessionId;
+    console.log(`  Session: ${sid}`);
+    // Launch Safari
+    console.log("\nLaunching Safari...");
+    await callTool("app_launch", { sessionId: sid, bundleId: "com.apple.Safari" });
+    await new Promise((r) => setTimeout(r, 1500));
+    // Focus Safari
+    console.log("Focusing Safari...");
+    await callTool("app_focus", { sessionId: sid, bundleId: "com.apple.Safari" });
+    await new Promise((r) => setTimeout(r, 500));
+    // Navigate to npm tokens page
+    console.log("Navigating to npm tokens page...");
+    await callTool("navigate", { sessionId: sid, url: "https://www.npmjs.com/settings/ai2hum/tokens" });
+    await new Promise((r) => setTimeout(r, 3000));
+    // Take screenshot to see the page
+    console.log("\nTaking screenshot...");
+    const screenshot = await callTool("screenshot", { sessionId: sid });
+    console.log("  Screenshot:", JSON.stringify(screenshot));
+    // Get element tree to see what's on the page
+    console.log("\nGetting element tree...");
+    const tree = await callTool("element_tree", { sessionId: sid, maxDepth: 4 });
+    console.log("  Tree:", JSON.stringify(tree, null, 2).slice(0, 3000));
+    console.log("\n--- Page loaded. Inspect the output above to determine next steps. ---");
+    proc.kill();
+    process.exit(0);
+}
+catch (e) {
+    console.error("Error:", e instanceof Error ? e.message : String(e));
+    proc.kill();
+    process.exit(1);
+}

package/dist/npm-token-cdp.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env tsx
+/**
+ * Uses ScreenHand with CDP adapter to create npm token in Chrome.
+ */
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, "..");
+const tsxBin = path.join(projectRoot, "node_modules", ".bin", "tsx");
+const proc = spawn(tsxBin, [path.join(projectRoot, "src/mcp-entry.ts")], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env, SCREENHAND_ADAPTER: "cdp" },
+    cwd: projectRoot,
+});
+proc.stderr.on("data", (d) => process.stderr.write(d));
+let msgId = 0;
+function send(msg) {
+    proc.stdin.write(JSON.stringify(msg) + "\n");
+}
+const rl = createInterface({ input: proc.stdout });
+const lineQueue = [];
+let lineWaiter = null;
+rl.on("line", (line) => {
+    if (lineWaiter) {
+        const w = lineWaiter;
+        lineWaiter = null;
+        w(line);
+    }
+    else
+        lineQueue.push(line);
+});
+function readResponse() {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { lineWaiter = null; reject(new Error("Timeout")); }, 30000);
+        const handle = (line) => { clearTimeout(timer); resolve(JSON.parse(line)); };
+        const queued = lineQueue.shift();
+        if (queued) {
+            clearTimeout(timer);
+            resolve(JSON.parse(queued));
+        }
+        else
+            lineWaiter = handle;
+    });
+}
+async function callTool(name, args) {
+    send({ jsonrpc: "2.0", id: ++msgId, method: "tools/call", params: { name, arguments: args } });
+    const resp = await readResponse();
+    const result = resp.result;
+    const content = result?.content;
+    const text = content?.[0]?.text ?? "{}";
+    if (result?.isError) {
+        console.error(`  ERROR: ${text}`);
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function sleep(ms) { await new Promise(r => setTimeout(r, ms)); }
+try {
+    await sleep(3000);
+    send({ jsonrpc: "2.0", id: ++msgId, method: "initialize",
+        params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "npm-cdp", version: "1.0" } } });
+    await readResponse();
+    send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    await sleep(300);
+    const session = await callTool("session_start", {});
+    if (!session) {
+        console.error("Failed to start session");
+        process.exit(1);
+    }
+    const sid = session.sessionId;
+    console.log(`Session: ${sid}`);
+    // Navigate to npm tokens page
+    console.log("\nNavigating to npm tokens page...");
+    await callTool("navigate", { sessionId: sid, url: "https://www.npmjs.com/settings/ai2hum/tokens/new" });
+    await sleep(3000);
+    // Take screenshot
+    const ss1 = await callTool("screenshot", { sessionId: sid });
+    console.log("Screenshot:", JSON.stringify(ss1).slice(0, 200));
+    // Type token name
+    console.log("\nTyping token name...");
+    await callTool("type_into", { sessionId: sid, target: "css=#token-name", text: "screenhand-publish" });
+    await sleep(500);
+    // Check bypass 2FA
+    console.log("\nChecking bypass 2FA...");
+    await callTool("press", { sessionId: sid, target: "css=#bypass-2fa" });
+    await sleep(500);
+    // Set packages permission to "Read and write"
+    console.log("\nSetting packages permission...");
+    // Find the packages permissions select and change it
+    await callTool("press", { sessionId: sid, target: "css=select[name='packages-permission']" });
+    await sleep(300);
+    // Screenshot to see current state
+    const ss2 = await callTool("screenshot", { sessionId: sid });
+    console.log("Screenshot:", JSON.stringify(ss2).slice(0, 200));
+    // Try to get page HTML to understand the form structure
+    console.log("\nGetting page structure...");
+    const html = await callTool("extract", { sessionId: sid, target: "css=form", format: "text" });
+    console.log("Form text:", JSON.stringify(html).slice(0, 2000));
+    proc.kill();
+    process.exit(0);
+}
+catch (e) {
+    console.error("Error:", e instanceof Error ? e.message : String(e));
+    proc.kill();
+    process.exit(1);
+}

package/dist/npm-token-create.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env tsx
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, "..");
+const tsxBin = path.join(projectRoot, "node_modules", ".bin", "tsx");
+const proc = spawn(tsxBin, [path.join(projectRoot, "src/mcp-entry.ts")], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env, SCREENHAND_ADAPTER: "accessibility" },
+    cwd: projectRoot,
+});
+proc.stderr.on("data", (d) => process.stderr.write(d));
+let msgId = 0;
+function send(msg) {
+    proc.stdin.write(JSON.stringify(msg) + "\n");
+}
+const rl = createInterface({ input: proc.stdout });
+const lineQueue = [];
+let lineWaiter = null;
+rl.on("line", (line) => {
+    if (lineWaiter) {
+        const w = lineWaiter;
+        lineWaiter = null;
+        w(line);
+    }
+    else
+        lineQueue.push(line);
+});
+function readResponse() {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { lineWaiter = null; reject(new Error("Timeout")); }, 15000);
+        const handle = (line) => { clearTimeout(timer); resolve(JSON.parse(line)); };
+        const queued = lineQueue.shift();
+        if (queued) {
+            clearTimeout(timer);
+            resolve(JSON.parse(queued));
+        }
+        else
+            lineWaiter = handle;
+    });
+}
+async function callTool(name, args) {
+    send({ jsonrpc: "2.0", id: ++msgId, method: "tools/call", params: { name, arguments: args } });
+    const resp = await readResponse();
+    const result = resp.result;
+    const content = result?.content;
+    const text = content?.[0]?.text ?? "{}";
+    if (result?.isError)
+        console.error(`  ERROR: ${text}`);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function screenshot(sid) {
+    const result = await callTool("screenshot", { sessionId: sid });
+    const data = result.data;
+    return data?.path ?? "";
+}
+async function sleep(ms) { await new Promise(r => setTimeout(r, ms)); }
+try {
+    await sleep(2000);
+    // Init MCP
+    send({ jsonrpc: "2.0", id: ++msgId, method: "initialize",
+        params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "npm-helper", version: "1.0" } } });
+    await readResponse();
+    send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    await sleep(300);
+    // Start session
+    console.log("Starting session...");
+    const session = await callTool("session_start", {});
+    const sid = session.sessionId;
+    console.log(`  Session: ${sid}`);
+    // Focus Safari (should already be on the tokens page)
+    console.log("\nFocusing Safari...");
+    await callTool("app_focus", { sessionId: sid, bundleId: "com.apple.Safari" });
+    await sleep(500);
+    // Step 1: Type token name
+    console.log("\nTyping token name...");
+    await callTool("press", { sessionId: sid, target: "Token name" });
+    await sleep(300);
+    await callTool("type_into", { sessionId: sid, target: "Token name", text: "screenhand-publish" });
+    await sleep(500);
+    // Step 2: Check "Bypass two-factor authentication (2FA)"
+    console.log("\nChecking bypass 2FA...");
+    await callTool("press", { sessionId: sid, target: "Bypass two-factor authentication (2FA)" });
+    await sleep(500);
+    // Step 3: Scroll down to see more options
+    console.log("\nScrolling down...");
+    await callTool("scroll", { sessionId: sid, direction: "down", amount: 5 });
+    await sleep(1000);
+    // Screenshot to see current state
+    console.log("\nScreenshot after scroll...");
+    const path1 = await screenshot(sid);
+    console.log(`  Saved: ${path1}`);
+    // Step 4: Look for packages section - need to set permissions
+    console.log("\nScrolling down more...");
+    await callTool("scroll", { sessionId: sid, direction: "down", amount: 5 });
+    await sleep(1000);
+    const path2 = await screenshot(sid);
+    console.log(`  Screenshot: ${path2}`);
+    // Try to find and click "Read and write" for packages permission
+    console.log("\nLooking for package permissions...");
+    await callTool("press", { sessionId: sid, target: "Read and write" });
+    await sleep(500);
+    // Scroll down to find Generate Token button
+    console.log("\nScrolling to Generate Token...");
+    await callTool("scroll", { sessionId: sid, direction: "down", amount: 5 });
+    await sleep(1000);
+    const path3 = await screenshot(sid);
+    console.log(`  Screenshot: ${path3}`);
+    // Click Generate Token
+    console.log("\nClicking Generate Token...");
+    await callTool("press", { sessionId: sid, target: "Generate Token" });
+    await sleep(3000);
+    // Take final screenshot to see the token
+    console.log("\nFinal screenshot...");
+    const pathFinal = await screenshot(sid);
+    console.log(`  Screenshot: ${pathFinal}`);
+    // Try to extract the token text from the page
+    console.log("\nExtracting page content...");
+    const tree = await callTool("element_tree", { sessionId: sid, maxDepth: 6 });
+    console.log(JSON.stringify(tree, null, 2).slice(0, 5000));
+    proc.kill();
+    process.exit(0);
+}
+catch (e) {
+    console.error("Error:", e instanceof Error ? e.message : String(e));
+    proc.kill();
+    process.exit(1);
+}

package/dist/npm-token-finish.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env tsx
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, "..");
+const tsxBin = path.join(projectRoot, "node_modules", ".bin", "tsx");
+const proc = spawn(tsxBin, [path.join(projectRoot, "src/mcp-entry.ts")], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env, SCREENHAND_ADAPTER: "accessibility" },
+    cwd: projectRoot,
+});
+proc.stderr.on("data", (d) => process.stderr.write(d));
+let msgId = 0;
+function send(msg) {
+    proc.stdin.write(JSON.stringify(msg) + "\n");
+}
+const rl = createInterface({ input: proc.stdout });
+const lineQueue = [];
+let lineWaiter = null;
+rl.on("line", (line) => {
+    if (lineWaiter) {
+        const w = lineWaiter;
+        lineWaiter = null;
+        w(line);
+    }
+    else
+        lineQueue.push(line);
+});
+function readResponse() {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { lineWaiter = null; reject(new Error("Timeout")); }, 15000);
+        const handle = (line) => { clearTimeout(timer); resolve(JSON.parse(line)); };
+        const queued = lineQueue.shift();
+        if (queued) {
+            clearTimeout(timer);
+            resolve(JSON.parse(queued));
+        }
+        else
+            lineWaiter = handle;
+    });
+}
+async function callTool(name, args) {
+    send({ jsonrpc: "2.0", id: ++msgId, method: "tools/call", params: { name, arguments: args } });
+    const resp = await readResponse();
+    const result = resp.result;
+    const content = result?.content;
+    const text = content?.[0]?.text ?? "{}";
+    if (result?.isError)
+        console.error(`  ERROR: ${text}`);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function screenshot(sid, label) {
+    const result = await callTool("screenshot", { sessionId: sid });
+    const data = result.data;
+    const p = data?.path ?? "";
+    console.log(`  [${label}] ${p}`);
+    return p;
+}
+async function sleep(ms) { await new Promise(r => setTimeout(r, ms)); }
+try {
+    await sleep(2000);
+    send({ jsonrpc: "2.0", id: ++msgId, method: "initialize",
+        params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "npm-helper", version: "1.0" } } });
+    await readResponse();
+    send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    await sleep(300);
+    const session = await callTool("session_start", {});
+    const sid = session.sessionId;
+    console.log(`Session: ${sid}`);
+    // Focus Safari
+    await callTool("app_focus", { sessionId: sid, bundleId: "com.apple.Safari" });
+    await sleep(500);
+    // Click the Packages "No access" dropdown to change permissions
+    console.log("\n1. Clicking Packages permissions dropdown...");
+    // The dropdown shows "No access" under "Packages and scopes"
+    await callTool("press", { sessionId: sid, target: { x: 220, y: 280 } });
+    await sleep(500);
+    await screenshot(sid, "after clicking packages dropdown");
+    // Try selecting "Read and write" from the dropdown
+    console.log("\n2. Selecting Read and write...");
+    await callTool("press", { sessionId: sid, target: "Read and write" });
+    await sleep(500);
+    await screenshot(sid, "after selecting read and write");
+    // Now we need to select which package - type "screenhand"
+    console.log("\n3. Looking for package selector...");
+    await callTool("scroll", { sessionId: sid, direction: "down", amount: 3 });
+    await sleep(500);
+    await screenshot(sid, "after scroll");
+    // Try to find a package input or "select packages" area
+    console.log("\n4. Trying to add screenhand package...");
+    await callTool("press", { sessionId: sid, target: "select" });
+    await sleep(300);
+    // Type screenhand in whatever input appeared
+    await callTool("key_combo", { sessionId: sid, keys: ["s", "c", "r", "e", "e", "n", "h", "a", "n", "d"] });
+    await sleep(1000);
+    await screenshot(sid, "after typing screenhand");
+    // Try to select it from autocomplete
+    await callTool("press", { sessionId: sid, target: "screenhand" });
+    await sleep(500);
+    // Scroll down to Generate Token
+    console.log("\n5. Scrolling to Generate Token...");
+    await callTool("scroll", { sessionId: sid, direction: "down", amount: 10 });
+    await sleep(500);
+    await screenshot(sid, "before generate");
+    // Click Generate Token
+    console.log("\n6. Clicking Generate Token...");
+    await callTool("press", { sessionId: sid, target: "Generate Token" });
+    await sleep(3000);
+    // Final screenshot - should show the token
+    console.log("\n7. Final result...");
+    const finalPath = await screenshot(sid, "FINAL");
+    proc.kill();
+    process.exit(0);
+}
+catch (e) {
+    console.error("Error:", e instanceof Error ? e.message : String(e));
+    proc.kill();
+    process.exit(1);
+}

package/dist/playbook/engine.js

@@ -0,0 +1,193 @@
+/**
+ * Playbook Engine — executes playbooks step-by-step
+ *
+ * Known path → playbook (fast, deterministic, no AI)
+ * Unknown state → AI fallback (slow, adaptive, learns)
+ *
+ * After AI recovers, the recovery steps get saved back into the playbook.
+ */
+const DEFAULT_VERIFY_TIMEOUT = 5000;
+const STEP_DELAY_MS = 300;
+export class PlaybookEngine {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    /**
+     * Execute a playbook against a live session.
+     * Returns result with success/failure and which step broke.
+     */
+    async run(sessionId, playbook, options = {}) {
+        const start = Date.now();
+        let stepsCompleted = 0;
+        for (let i = 0; i < playbook.steps.length; i++) {
+            const step = playbook.steps[i];
+            try {
+                const result = await this.executeStep(sessionId, step);
+                stepsCompleted++;
+                if (options.onStep) {
+                    options.onStep(i, step, result);
+                }
+                // Verify step if needed
+                if (step.verify) {
+                    const verified = await this.verifyStep(sessionId, step);
+                    if (!verified && !step.optional) {
+                        return {
+                            playbook: playbook.id,
+                            success: false,
+                            stepsCompleted,
+                            totalSteps: playbook.steps.length,
+                            failedAtStep: i,
+                            error: `Verification failed at step ${i}: ${step.description ?? step.action}`,
+                            durationMs: Date.now() - start,
+                        };
+                    }
+                }
+                // Small delay between steps for UI to settle
+                await sleep(STEP_DELAY_MS);
+            }
+            catch (err) {
+                if (step.optional) {
+                    stepsCompleted++;
+                    if (options.onStep) {
+                        options.onStep(i, step, `Skipped (optional): ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    continue;
+                }
+                return {
+                    playbook: playbook.id,
+                    success: false,
+                    stepsCompleted,
+                    totalSteps: playbook.steps.length,
+                    failedAtStep: i,
+                    error: err instanceof Error ? err.message : String(err),
+                    durationMs: Date.now() - start,
+                };
+            }
+        }
+        return {
+            playbook: playbook.id,
+            success: true,
+            stepsCompleted,
+            totalSteps: playbook.steps.length,
+            failedAtStep: -1,
+            durationMs: Date.now() - start,
+        };
+    }
+    /**
+     * Execute a single playbook step.
+     */
+    async executeStep(sessionId, step) {
+        const target = this.resolveTarget(step.target);
+        switch (step.action) {
+            case "navigate": {
+                if (!step.url)
+                    throw new Error("navigate step missing url");
+                const r = await this.runtime.navigate({ sessionId, url: step.url });
+                if (!r.ok)
+                    throw new Error(r.error.message);
+                return `Navigated to ${step.url}`;
+            }
+            case "press": {
+                if (!target)
+                    throw new Error("press step missing target");
+                const r = await this.runtime.press({ sessionId, target });
+                if (!r.ok)
+                    throw new Error(r.error.message);
+                return `Pressed ${JSON.stringify(step.target)}`;
+            }
+            case "type_into": {
+                if (!target)
+                    throw new Error("type_into step missing target");
+                if (!step.text)
+                    throw new Error("type_into step missing text");
+                const r = await this.runtime.typeInto({ sessionId, target, text: step.text });
+                if (!r.ok)
+                    throw new Error(r.error.message);
+                return `Typed "${step.text}" into ${JSON.stringify(step.target)}`;
+            }
+            case "extract": {
+                if (!target)
+                    throw new Error("extract step missing target");
+                const r = await this.runtime.extract({
+                    sessionId,
+                    target,
+                    format: step.format ?? "text",
+                });
+                if (!r.ok)
+                    throw new Error(r.error.message);
+                return `Extracted: ${JSON.stringify(r.data).slice(0, 200)}`;
+            }
+            case "key_combo": {
+                if (!step.keys || step.keys.length === 0)
+                    throw new Error("key_combo step missing keys");
+                const r = await this.runtime.keyCombo({ sessionId, keys: step.keys });
+                if (!r.ok)
+                    throw new Error(r.error.message);
+                return `Key combo: ${step.keys.join("+")}`;
+            }
+            case "scroll": {
+                const input = {
+                    sessionId,
+                    direction: step.direction ?? "down",
+                };
+                if (step.amount != null)
+                    input.amount = step.amount;
+                const r = await this.runtime.scroll(input);
+                if (!r.ok)
+                    throw new Error(r.error.message);
+                return `Scrolled ${step.direction ?? "down"}`;
+            }
+            case "wait": {
+                await sleep(step.ms ?? 1000);
+                return `Waited ${step.ms ?? 1000}ms`;
+            }
+            case "screenshot": {
+                const r = await this.runtime.screenshot({ sessionId });
+                if (!r.ok)
+                    throw new Error(r.error.message);
+                return `Screenshot taken`;
+            }
+            default:
+                throw new Error(`Unknown action: ${step.action}`);
+        }
+    }
+    /**
+     * Verify a step's postcondition via CSS selector check.
+     */
+    async verifyStep(sessionId, step) {
+        if (!step.verify)
+            return true;
+        const timeout = step.verifyTimeoutMs ?? DEFAULT_VERIFY_TIMEOUT;
+        const r = await this.runtime.waitFor({
+            sessionId,
+            condition: { type: "selector_visible", selector: step.verify },
+            timeoutMs: timeout,
+        });
+        return r.ok && r.data.matched;
+    }
+    /**
+     * Convert playbook target format to runtime Target format.
+     */
+    resolveTarget(target) {
+        if (!target)
+            return undefined;
+        if (typeof target === "string") {
+            // CSS selector if starts with common patterns, else treat as text
+            if (target.startsWith("[") || target.startsWith("#") || target.startsWith(".") || target.startsWith("css=")) {
+                return { type: "selector", value: target.replace(/^css=/, "") };
+            }
+            return { type: "text", value: target };
+        }
+        if ("selector" in target) {
+            return { type: "selector", value: target.selector };
+        }
+        if ("x" in target && "y" in target) {
+            return { type: "coordinates", x: target.x, y: target.y };
+        }
+        return undefined;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/playbook/index.js

@@ -0,0 +1,4 @@
+export { PlaybookEngine } from "./engine.js";
+export { PlaybookStore } from "./store.js";
+export { PlaybookRunner } from "./runner.js";
+export { PlaybookRecorder } from "./recorder.js";