screenhand 0.1.1 → 0.3.0

package/dist/scripts/codex-monitor-daemon.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env npx tsx
+/**
+ * Codex Monitor Daemon — runs as a standalone background process.
+ *
+ * Survives Claude Code restarts. Writes state to ~/.screenhand/monitor/
+ * so MCP tools can read status and enqueue tasks via the filesystem.
+ *
+ * Usage:
+ *   npx tsx scripts/codex-monitor-daemon.ts --pid 56966
+ *   npx tsx scripts/codex-monitor-daemon.ts --pid 56966 --window 5015 --poll 5000
+ *
+ * State files:
+ *   ~/.screenhand/monitor/state.json    — terminal states + status
+ *   ~/.screenhand/monitor/tasks.json    — task queue
+ *   ~/.screenhand/monitor/daemon.pid    — PID of this process
+ *   ~/.screenhand/monitor/daemon.log    — log output
+ */
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { BridgeClient } from "../src/native/bridge-client.js";
+// ── Config from CLI args ──
+const args = process.argv.slice(2);
+function getArg(name, fallback) {
+    const idx = args.indexOf("--" + name);
+    if (idx === -1)
+        return fallback;
+    return args[idx + 1] ?? fallback;
+}
+const VSCODE_PID = Number(getArg("pid", "0"));
+const WINDOW_ID = getArg("window") ? Number(getArg("window")) : undefined;
+const POLL_MS = Number(getArg("poll", "3000"));
+const LABEL = getArg("label", "Terminal") ?? "Terminal";
+const AUTO_ASSIGN = getArg("no-auto-assign") === undefined;
+if (!VSCODE_PID) {
+    console.error("Usage: codex-monitor-daemon.ts --pid <vscode_pid> [--window <id>] [--poll <ms>]");
+    process.exit(1);
+}
+// ── State directory ──
+const STATE_DIR = path.join(os.homedir(), ".screenhand", "monitor");
+const STATE_FILE = path.join(STATE_DIR, "state.json");
+const TASKS_FILE = path.join(STATE_DIR, "tasks.json");
+const PID_FILE = path.join(STATE_DIR, "daemon.pid");
+const LOG_FILE = path.join(STATE_DIR, "daemon.log");
+fs.mkdirSync(STATE_DIR, { recursive: true });
+// ── Logging ──
+const logStream = fs.createWriteStream(LOG_FILE, { flags: "a" });
+function log(msg) {
+    const line = `[${new Date().toISOString()}] ${msg}`;
+    logStream.write(line + "\n");
+    // Also write to stderr for initial debugging
+    if (!daemonized)
+        process.stderr.write(line + "\n");
+}
+let daemonized = false;
+// ── Status detection patterns ──
+const RUNNING_PATTERNS = [
+    "thinking", "working", "generating", "analyzing", "reading",
+    "writing", "searching", "running", "executing", "...",
+    "in progress",
+];
+const IDLE_PATTERNS = [
+    "codex>", "> ", "$ ", "done", "complete", "finished",
+    "task completed", "all done", "ready", "waiting for input",
+    "what would you like", "how can i help",
+];
+const ERROR_PATTERNS = [
+    "error:", "failed", "exception", "traceback", "panic:",
+    "fatal", "cannot", "could not",
+];
+// ── Bridge setup ──
+const scriptDir = import.meta.dirname ?? path.dirname(new URL(import.meta.url).pathname);
+const projectRoot = path.resolve(scriptDir, "..");
+const bridgePath = process.platform === "win32"
+    ? path.resolve(projectRoot, "native/windows-bridge/bin/Release/net8.0-windows/windows-bridge.exe")
+    : path.resolve(projectRoot, "native/macos-bridge/.build/release/macos-bridge");
+const bridge = new BridgeClient(bridgePath);
+// ── State ──
+let resolvedWindowId = WINDOW_ID;
+const terminal = {
+    id: `term_${VSCODE_PID}_${Date.now().toString(36)}`,
+    vscodePid: VSCODE_PID,
+    ...(WINDOW_ID != null ? { windowId: WINDOW_ID } : {}),
+    label: LABEL,
+    status: "unknown",
+    lastOutput: "",
+    lastTask: null,
+    lastPollAt: new Date().toISOString(),
+    tasksCompleted: 0,
+    taskHistory: [],
+};
+let stopped = false;
+// ── Filesystem I/O ──
+function writeState() {
+    const state = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        terminals: [terminal],
+        running: !stopped,
+    };
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function readTasks() {
+    try {
+        if (!fs.existsSync(TASKS_FILE))
+            return [];
+        return JSON.parse(fs.readFileSync(TASKS_FILE, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function writeTasks(tasks) {
+    fs.writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2));
+}
+// ── Detection logic ──
+function detectStatus(text) {
+    const lower = text.toLowerCase();
+    const lines = text.split("\n").filter((l) => l.trim().length > 0);
+    const lastLine = (lines[lines.length - 1] ?? "").trim().toLowerCase();
+    // Check errors in last 5 lines
+    const lastFew = lines.slice(-5).join("\n").toLowerCase();
+    for (const p of ERROR_PATTERNS) {
+        if (lastFew.includes(p))
+            return "error";
+    }
+    // Check idle (prompt on last line)
+    for (const p of IDLE_PATTERNS) {
+        if (lastLine.includes(p) || lastLine.endsWith(p.trim()))
+            return "idle";
+    }
+    // Check running
+    for (const p of RUNNING_PATTERNS) {
+        if (lower.includes(p))
+            return "running";
+    }
+    return "unknown";
+}
+// ── Terminal reading ──
+async function readTerminalContent() {
+    try {
+        // Find window if not set
+        if (!resolvedWindowId) {
+            const wins = await bridge.call("app.windows");
+            // Find VS Code windows, pick the largest one (skip title bar / small panels)
+            const vscodeWins = wins.filter((w) => w.pid === VSCODE_PID || w.bundleId === "com.microsoft.VSCode");
+            if (vscodeWins.length === 0) {
+                log("VS Code window not found");
+                return null;
+            }
+            const largest = vscodeWins.reduce((a, b) => {
+                const areaA = (a.bounds?.width ?? 0) * (a.bounds?.height ?? 0);
+                const areaB = (b.bounds?.width ?? 0) * (b.bounds?.height ?? 0);
+                return areaA >= areaB ? a : b;
+            });
+            resolvedWindowId = largest.windowId;
+            if (resolvedWindowId !== undefined) {
+                terminal.windowId = resolvedWindowId;
+            }
+            log(`Auto-detected window ${resolvedWindowId} (${largest.bounds?.width}x${largest.bounds?.height})`);
+        }
+        // Screenshot + OCR
+        const shot = await bridge.call("cg.captureWindow", {
+            windowId: resolvedWindowId,
+        });
+        const ocr = await bridge.call("vision.ocr", {
+            imagePath: shot.path,
+        });
+        return ocr.text;
+    }
+    catch (err) {
+        log(`OCR failed: ${err instanceof Error ? err.message : String(err)}`);
+        // Fallback: AX tree
+        try {
+            const tree = await bridge.call("ax.getElementTree", {
+                pid: VSCODE_PID,
+                maxDepth: 6,
+            });
+            return extractTerminalText(tree);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function extractTerminalText(node, depth = 0) {
+    if (depth > 8)
+        return null;
+    const role = (node.role || "").toLowerCase();
+    const title = (node.title || "").toLowerCase();
+    if ((role.includes("terminal") || title.includes("terminal")) &&
+        node.value) {
+        return node.value;
+    }
+    if (node.children) {
+        for (const child of node.children) {
+            const found = extractTerminalText(child, depth + 1);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+// ── Task assignment ──
+async function typeIntoTerminal(text) {
+    try {
+        await bridge.call("app.focus", { bundleId: "com.microsoft.VSCode" });
+        await sleep(300);
+        await bridge.call("cg.typeText", { text });
+        await sleep(100);
+        await bridge.call("cg.keyCombo", { keys: ["enter"] });
+        return true;
+    }
+    catch (err) {
+        log(`Failed to type: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
+async function tryAssignTask() {
+    if (!AUTO_ASSIGN || terminal.status !== "idle")
+        return;
+    const tasks = readTasks();
+    const next = tasks.find((t) => t.status === "queued" && (t.terminalId === null || t.terminalId === terminal.id));
+    if (!next)
+        return;
+    log(`Assigning task: "${next.prompt.slice(0, 60)}"`);
+    next.status = "assigned";
+    next.terminalId = terminal.id;
+    next.assignedAt = new Date().toISOString();
+    writeTasks(tasks);
+    terminal.lastTask = next.prompt;
+    const success = await typeIntoTerminal(next.prompt);
+    if (success) {
+        next.status = "running";
+        terminal.status = "running";
+        log(`Task running: ${next.id}`);
+    }
+    else {
+        next.status = "failed";
+        next.result = "Failed to type into terminal";
+        log(`Task failed to assign: ${next.id}`);
+    }
+    writeTasks(tasks);
+}
+function handleIdleTransition() {
+    // Complete current task
+    if (terminal.lastTask) {
+        terminal.taskHistory.push({
+            task: terminal.lastTask,
+            completedAt: new Date().toISOString(),
+        });
+        terminal.tasksCompleted++;
+        // Update task in queue
+        const tasks = readTasks();
+        const running = tasks.find((t) => t.status === "running" && t.terminalId === terminal.id);
+        if (running) {
+            running.status = "completed";
+            running.completedAt = new Date().toISOString();
+            running.result = terminal.lastOutput.split("\n").slice(-20).join("\n");
+            writeTasks(tasks);
+        }
+        terminal.lastTask = null;
+        log(`Task completed (${terminal.tasksCompleted} total)`);
+    }
+    // Delay then try assign
+    setTimeout(() => tryAssignTask(), 2000);
+}
+// ── Main loop ──
+async function poll() {
+    const output = await readTerminalContent();
+    if (output === null)
+        return;
+    const oldStatus = terminal.status;
+    terminal.lastOutput = output;
+    terminal.lastPollAt = new Date().toISOString();
+    const lastLines = output.split("\n").slice(-15).join("\n");
+    terminal.status = detectStatus(lastLines);
+    if (oldStatus !== terminal.status) {
+        log(`Status: ${oldStatus} -> ${terminal.status}`);
+        if (terminal.status === "idle" && (oldStatus === "running" || oldStatus === "unknown")) {
+            handleIdleTransition();
+        }
+    }
+    writeState();
+}
+async function main() {
+    // Write PID file
+    fs.writeFileSync(PID_FILE, String(process.pid));
+    // Initialize tasks file if missing
+    if (!fs.existsSync(TASKS_FILE)) {
+        writeTasks([]);
+    }
+    log(`Daemon started (pid=${process.pid})`);
+    log(`Watching VS Code pid=${VSCODE_PID} window=${WINDOW_ID ?? "auto"} poll=${POLL_MS}ms`);
+    await bridge.start();
+    log("Bridge started");
+    writeState();
+    // Poll loop
+    while (!stopped) {
+        try {
+            await poll();
+        }
+        catch (err) {
+            log(`Poll error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await sleep(POLL_MS);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ── Graceful shutdown ──
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+async function shutdown() {
+    if (stopped)
+        return;
+    stopped = true;
+    log("Shutting down...");
+    writeState();
+    try {
+        fs.unlinkSync(PID_FILE);
+    }
+    catch { /* ignore */ }
+    try {
+        await bridge.stop();
+    }
+    catch { /* ignore */ }
+    logStream.end();
+    process.exit(0);
+}
+main().catch((err) => {
+    log(`Fatal: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

package/dist/scripts/export-help-center.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env npx tsx
+import { exportHelpCenterToMarkdown } from "../src/platform/help-center-markdown.js";
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.help || !options.url) {
+        printUsage();
+        process.exit(options.help ? 0 : 1);
+    }
+    const result = await exportHelpCenterToMarkdown({
+        startUrl: options.url,
+        outputPath: options.output,
+        maxPages: options.maxPages,
+        headless: options.headless,
+        waitAfterLoadMs: options.waitMs,
+        onProgress: (message) => console.log(message),
+        ...(options.scope ? { scopePrefix: options.scope } : {}),
+    });
+    console.log("");
+    console.log(`Wrote ${result.pageCount} page(s) to ${result.outputPath}`);
+    console.log(`Scope prefix: ${result.scopePrefix}`);
+}
+function parseArgs(args) {
+    const options = {
+        output: "help-center-export.md",
+        maxPages: 25,
+        headless: false,
+        waitMs: 1200,
+        help: false,
+    };
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        const next = args[index + 1];
+        if (arg === "--help" || arg === "-h") {
+            options.help = true;
+            continue;
+        }
+        if (arg === "--headless") {
+            options.headless = true;
+            continue;
+        }
+        if (arg === "--headed") {
+            options.headless = false;
+            continue;
+        }
+        if (arg === "--url" && next) {
+            options.url = next;
+            index++;
+            continue;
+        }
+        if (arg.startsWith("--url=")) {
+            options.url = arg.slice("--url=".length);
+            continue;
+        }
+        if (arg === "--output" && next) {
+            options.output = next;
+            index++;
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            options.output = arg.slice("--output=".length);
+            continue;
+        }
+        if (arg === "--scope" && next) {
+            options.scope = next;
+            index++;
+            continue;
+        }
+        if (arg.startsWith("--scope=")) {
+            options.scope = arg.slice("--scope=".length);
+            continue;
+        }
+        if (arg === "--max-pages" && next) {
+            options.maxPages = parsePositiveInt(next, "--max-pages");
+            index++;
+            continue;
+        }
+        if (arg.startsWith("--max-pages=")) {
+            options.maxPages = parsePositiveInt(arg.slice("--max-pages=".length), "--max-pages");
+            continue;
+        }
+        if (arg === "--wait-ms" && next) {
+            options.waitMs = parsePositiveInt(next, "--wait-ms");
+            index++;
+            continue;
+        }
+        if (arg.startsWith("--wait-ms=")) {
+            options.waitMs = parsePositiveInt(arg.slice("--wait-ms=".length), "--wait-ms");
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return options;
+}
+function parsePositiveInt(value, flagName) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`${flagName} must be a positive integer`);
+    }
+    return parsed;
+}
+function printUsage() {
+    console.log("Usage:");
+    console.log("  npm run export:help-md -- --url <help-root-url> [--output file.md] [--scope /path/] [--max-pages 25] [--headless]");
+    console.log("");
+    console.log("Examples:");
+    console.log("  npm run export:help-md -- --url https://www.canva.com/en_in/help/topics/ --output docs/canva-help.md --max-pages 40");
+    console.log("  npm run export:help-md -- --url https://www.canva.com/en_in/help/topics/ --scope /en_in/help/ --headless");
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/scripts/marketing-loop.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env npx tsx
+/**
+ * ScreenHand Marketing Automation Loop
+ *
+ * Architecture:
+ *   Claude Code (this script via /loop)
+ *     → ScreenHand CDP → Codex (content generation)
+ *     → ScreenHand browser → Social platforms (execution)
+ *
+ * Platforms: X/Twitter, Threads, LinkedIn, Reddit
+ * Goal: Increase GitHub stars for ScreenHand (github.com/manushi4/Screenhand)
+ */
+// Marketing task types with weights for rotation
+const TASK_TYPES = [
+    { type: 'search_engage', weight: 30, platforms: ['x', 'threads', 'linkedin'] },
+    { type: 'create_post', weight: 20, platforms: ['x', 'threads', 'linkedin'] },
+    { type: 'reply_contextual', weight: 25, platforms: ['x', 'threads', 'reddit'] },
+    { type: 'like_repost', weight: 15, platforms: ['x', 'threads'] },
+    { type: 'dm_outreach', weight: 10, platforms: ['x', 'linkedin'] },
+];
+// Search queries to find relevant conversations
+const SEARCH_QUERIES = [
+    'claude code',
+    'desktop automation AI',
+    'MCP server',
+    'browser automation agent',
+    'AI agent desktop control',
+    'anthropic claude tools',
+    'cursor automation',
+    'computer use API',
+    'accessibility automation mac',
+    'screenhand',
+    'AI coding assistant',
+    'claude MCP',
+    'openai codex desktop',
+    'AI agent framework',
+    'playwright alternative AI',
+];
+// Content angles for posts
+const CONTENT_ANGLES = [
+    'Show how ScreenHand gives AI agents native desktop control — 82 MCP tools',
+    'Demo: Claude Code using ScreenHand to automate a real workflow',
+    'ScreenHand vs browser-only automation — why desktop control matters',
+    'Open source AI desktop automation — ScreenHand on npm',
+    'How ScreenHand handles the focus-stealing problem in Electron apps',
+    'Building multi-agent systems with ScreenHand supervisor + job system',
+    'ScreenHand memory system — AI agents that learn from mistakes',
+    'Cross-platform desktop automation: macOS Swift + Windows C# native bridges',
+    'The playbook system — reusable automation recipes for any platform',
+    'Why we built ScreenHand: the gap between AI coding and AI doing',
+];
+// Rate limits per platform (actions per hour)
+const RATE_LIMITS = {
+    x: 8,
+    threads: 10,
+    linkedin: 6,
+    reddit: 4,
+};
+const state = {
+    startTime: Date.now(),
+    actionsPerformed: { x: 0, threads: 0, linkedin: 0, reddit: 0 },
+    lastActionTime: { x: 0, threads: 0, linkedin: 0, reddit: 0 },
+    postsCreated: [],
+    repliesSent: [],
+    searchesPerformed: [],
+    errors: [],
+    currentCycle: 0,
+};
+function pickWeightedRandom(items) {
+    const total = items.reduce((s, i) => s + i.weight, 0);
+    let r = Math.random() * total;
+    for (const item of items) {
+        r -= item.weight;
+        if (r <= 0)
+            return item;
+    }
+    return items[0];
+}
+function pickRandom(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+function canActOnPlatform(platform) {
+    const hourMs = 60 * 60 * 1000;
+    const now = Date.now();
+    const limit = RATE_LIMITS[platform] ?? 5;
+    const count = state.actionsPerformed[platform] ?? 0;
+    const elapsed = now - state.startTime;
+    const hoursElapsed = Math.max(1, elapsed / hourMs);
+    return count / hoursElapsed < limit;
+}
+function getNextTask() {
+    state.currentCycle++;
+    // Pick task type
+    const task = pickWeightedRandom(TASK_TYPES);
+    // Pick platform that hasn't hit rate limit
+    const availablePlatforms = task.platforms.filter(p => canActOnPlatform(p));
+    if (availablePlatforms.length === 0) {
+        return { type: 'wait', platform: 'none' };
+    }
+    const platform = pickRandom(availablePlatforms);
+    return {
+        type: task.type,
+        platform,
+        query: pickRandom(SEARCH_QUERIES),
+        angle: pickRandom(CONTENT_ANGLES),
+    };
+}
+function formatStatus() {
+    const elapsed = Math.round((Date.now() - state.startTime) / 60000);
+    const total = Object.values(state.actionsPerformed).reduce((s, n) => s + n, 0);
+    return `[Cycle ${state.currentCycle} | ${elapsed}m elapsed | ${total} actions | ` +
+        `X:${state.actionsPerformed.x} T:${state.actionsPerformed.threads} ` +
+        `L:${state.actionsPerformed.linkedin} R:${state.actionsPerformed.reddit} | ` +
+        `${state.errors.length} errors]`;
+}
+// Export for use by the loop controller
+export { getNextTask, formatStatus, state, SEARCH_QUERIES, CONTENT_ANGLES, canActOnPlatform };