@instaclaw/dispatch 0.5.0 → 0.6.0

package/dist/executor.js

@@ -34,6 +34,8 @@ export async function executeCommand(command) {
                 return await listWindows();
             case "batch":
                 return await executeBatch(params);
+            case "exec":
+                return await doExec(params);
             default:
                 return { success: false, error: `Unknown command type: ${type}` };
         }
@@ -210,4 +212,37 @@ async function listWindows() {
     const windows = await usecomputer.windowList();
     return { success: true, data: { windows } };
 }
+/**
+ * Execute a shell command directly on the user's machine.
+ * Bypasses the GUI entirely — no Terminal window needed.
+ * Returns stdout, stderr, and exit code.
+ */
+async function doExec(params) {
+    const command = String(params.command || "");
+    if (!command) {
+        return { success: false, error: "exec requires a 'command' parameter" };
+    }
+    // Timeout: default 30s, max 120s
+    const timeoutMs = Math.min(Number(params.timeout) || 30000, 120000);
+    return new Promise((resolve) => {
+        const { exec } = require("child_process");
+        exec(command, { timeout: timeoutMs, maxBuffer: 1024 * 1024, shell: "/bin/bash" }, (err, stdout, stderr) => {
+            const exitCode = err ? err.code ?? 1 : 0;
+            // Cap output to prevent context flooding (max 4KB each)
+            const cappedStdout = stdout.length > 4096 ? stdout.substring(0, 4096) + "\n[...truncated]" : stdout;
+            const cappedStderr = stderr.length > 4096 ? stderr.substring(0, 4096) + "\n[...truncated]" : stderr;
+            resolve({
+                success: exitCode === 0,
+                data: {
+                    action: "exec",
+                    command,
+                    exitCode,
+                    stdout: cappedStdout,
+                    stderr: cappedStderr,
+                },
+                error: exitCode !== 0 ? `Command exited with code ${exitCode}` : undefined,
+            });
+        });
+    });
+}
 //# sourceMappingURL=executor.js.map

package/dist/index.js

@@ -8,27 +8,105 @@
  *   npx @instaclaw/dispatch --token XXX --vm HOST    # Direct connect (advanced)
  */
 import { loadConfig, saveConfig, getConfigPath } from "./config.js";
-import { checkPermissions, printPermissionGuide, runPermissionTest } from "./permissions.js";
+import { checkPermissions, runPermissionTest } from "./permissions.js";
 import { connect, disconnect } from "./connection.js";
 import { closeSupervisor, setMode } from "./supervisor.js";
 import chalk from "chalk";
 import readline from "readline";
 import os from "os";
+import fs from "fs";
+import path from "path";
 const API_BASE = "https://instaclaw.io";
+// Temp file to persist pairing code + args across Terminal restarts
+const RETRY_FILE = path.join(os.tmpdir(), "instaclaw-dispatch-retry.json");
+const RETRY_MAX_AGE_MS = 10 * 60 * 1000; // 10 minutes
 async function main() {
     console.log(`
   ${chalk.bold("InstaClaw Dispatch")} ${chalk.dim("— Remote Computer Control")}
   ${chalk.dim("─────────────────────────────────────────────")}
   `);
-    // 1. Check permissions (macOS only)
+    const args = parseArgs();
+    // ── Auto-retry: check if we're resuming after a Terminal restart ──
+    const retry = loadRetryState();
+    if (!args.pair && !args.token && retry) {
+        console.log(`  ${chalk.cyan("↻")} Resuming after Terminal restart...`);
+        console.log(`  ${chalk.dim("Pairing code:")} ${chalk.bold(retry.pair)}\n`);
+        args.pair = retry.pair;
+        if (retry.autonomous)
+            args.autonomous = true;
+        clearRetryState();
+    }
+    // ── 1. Check permissions FIRST (before consuming pairing code) ──
     if (os.platform() === "darwin") {
         console.log("  Checking permissions...");
         const perms = checkPermissions();
-        printPermissionGuide(perms);
-        if (perms.screenRecording === false || perms.accessibility === false) {
-            await waitForEnter();
+        if (perms.accessibility === false || perms.screenRecording === false) {
+            const terminal = getTerminalName();
+            // Save state so we can auto-resume after Terminal restart
+            if (args.pair) {
+                saveRetryState({ pair: args.pair, autonomous: args.autonomous });
+            }
+            console.log("");
+            if (perms.accessibility === false) {
+                console.log(`  ${chalk.red("✗")} Accessibility: ${chalk.bold("NOT GRANTED")}`);
+                console.log(`    → System Settings → Privacy & Security → Accessibility`);
+                console.log(`    → Enable "${terminal}"`);
+                console.log("");
+                console.log(chalk.yellow(`  ⚠  Enabling Accessibility will close ${terminal}.`));
+                console.log(chalk.yellow(`     Don't worry — just reopen ${terminal} and run the same command.`));
+                if (args.pair) {
+                    console.log(chalk.green(`     Your pairing code ${chalk.bold(args.pair)} will still work.`));
+                }
+                console.log("");
+            }
+            if (perms.screenRecording === false) {
+                console.log(`  ${chalk.red("✗")} Screen Recording: ${chalk.bold("NOT GRANTED")}`);
+                console.log(`    → System Settings → Privacy & Security → Screen Recording`);
+                console.log(`    → Enable "${terminal}"`);
+                console.log("");
+            }
+            if (perms.accessibility === true && perms.screenRecording === false) {
+                // Only Screen Recording is missing — Terminal won't be killed
+                console.log(`  Grant Screen Recording, then press ${chalk.bold("Enter")} to continue...`);
+                await waitForEnter();
+                // Re-check
+                const recheck = checkPermissions();
+                if (recheck.screenRecording === false) {
+                    console.log(`  ${chalk.yellow("⚠")} Screen Recording still not granted. Screenshots may not work.\n`);
+                }
+                else {
+                    console.log(`  ${chalk.green("✓")} Screen Recording: OK\n`);
+                }
+            }
+            else if (perms.accessibility === false) {
+                // Accessibility is missing — Terminal WILL be killed
+                console.log(`  After granting permissions and reopening ${terminal}, run:`);
+                console.log("");
+                if (args.pair) {
+                    console.log(`  ${chalk.cyan(`npx @instaclaw/dispatch@0.5.0 --pair ${args.pair}`)}`);
+                }
+                else {
+                    console.log(`  ${chalk.cyan("npx @instaclaw/dispatch")}`);
+                }
+                console.log("");
+                console.log(`  ${chalk.dim("Or just reopen Terminal — we'll auto-resume if possible.")}`);
+                console.log("");
+                console.log(`  Press ${chalk.bold("Enter")} when ready (or grant Accessibility and Terminal will restart)...`);
+                await waitForEnter();
+                // If we get here, user pressed Enter without Terminal being killed
+                const recheck = checkPermissions();
+                if (recheck.accessibility === false) {
+                    console.log(`\n  ${chalk.yellow("⚠")} Accessibility still not granted. Click/type commands will fail.`);
+                    console.log(`  ${chalk.dim("Continuing anyway — screenshots may still work.\n")}`);
+                }
+                else {
+                    console.log(`\n  ${chalk.green("✓")} Permissions: all OK\n`);
+                    clearRetryState();
+                }
+            }
         }
         else {
+            // All permissions OK — run functional test
             console.log("  Running permission test...");
             const test = await runPermissionTest();
             if (test.ok) {
@@ -38,11 +116,11 @@ async function main() {
                 console.log(`  ${chalk.yellow("⚠")} ${test.error}`);
                 console.log("  Continuing anyway — some commands may fail.\n");
             }
+            clearRetryState();
         }
     }
-    // 2. Resolve config: --pair, --token+--vm, saved config, or interactive
+    // ── 2. Resolve config: --pair, --token+--vm, saved config, or interactive ──
     let config = loadConfig();
-    const args = parseArgs();
     // Path A: Pairing code (simplest)
     if (args.pair) {
         console.log(`  Redeeming pairing code ${chalk.bold(args.pair)}...`);
@@ -51,6 +129,7 @@ async function main() {
             config = { gatewayToken: result.token, vmAddress: result.vmAddress, port: 8765, mode: "supervised" };
             saveConfig(config);
             console.log(`  ${chalk.green("✓")} Paired successfully\n`);
+            clearRetryState();
         }
         else {
             process.exit(1);
@@ -80,7 +159,7 @@ async function main() {
     console.log(`  ${chalk.dim("VM:")}   ${config.vmAddress}:${config.port}`);
     console.log(`  ${chalk.dim("Mode:")} ${config.mode}`);
     console.log(`  ${chalk.dim("Token:")} ${config.gatewayToken.substring(0, 8)}...\n`);
-    // 3. Connect to VM
+    // ── 3. Connect to VM ──
     connect({
         vmAddress: config.vmAddress,
         port: config.port,
@@ -119,7 +198,7 @@ async function main() {
             }
         },
     });
-    // 4. Ctrl+C
+    // ── 4. Ctrl+C ──
     process.on("SIGINT", () => {
         console.log(`\n  ${chalk.dim("Disconnecting...")}`);
         disconnect();
@@ -127,6 +206,46 @@ async function main() {
         process.exit(0);
     });
 }
+// ── Retry State (persists across Terminal restarts) ──
+function saveRetryState(state) {
+    try {
+        fs.writeFileSync(RETRY_FILE, JSON.stringify({ ...state, ts: Date.now() }));
+    }
+    catch { }
+}
+function loadRetryState() {
+    try {
+        if (!fs.existsSync(RETRY_FILE))
+            return null;
+        const data = JSON.parse(fs.readFileSync(RETRY_FILE, "utf-8"));
+        // Only use if recent (within 10 min)
+        if (Date.now() - data.ts > RETRY_MAX_AGE_MS) {
+            clearRetryState();
+            return null;
+        }
+        if (!data.pair)
+            return null;
+        return { pair: data.pair, autonomous: data.autonomous };
+    }
+    catch {
+        return null;
+    }
+}
+function clearRetryState() {
+    try {
+        fs.unlinkSync(RETRY_FILE);
+    }
+    catch { }
+}
+function getTerminalName() {
+    const terminal = process.env.TERM_PROGRAM || "your terminal app";
+    return {
+        "Apple_Terminal": "Terminal",
+        "iTerm.app": "iTerm2",
+        "vscode": "Visual Studio Code",
+        "WarpTerminal": "Warp",
+    }[terminal] || terminal;
+}
 // ── Pairing Code ──
 async function redeemPairingCode(code) {
     try {

package/dist/supervisor.js

@@ -85,6 +85,23 @@ function isDangerous(cmd) {
         const key = String(p.key || "").toLowerCase();
         return DANGEROUS_KEY_COMBOS.has(key);
     }
+    // Check exec commands for dangerous patterns
+    if (cmd.type === "exec") {
+        const command = String(p.command || "");
+        // Check against text patterns (reuses the same dangerous detection)
+        if (DANGEROUS_TEXT_PATTERNS.some((pat) => pat.test(command)))
+            return true;
+        // Additional exec-specific dangerous patterns
+        if (/\brm\s+-rf\b/.test(command))
+            return true;
+        if (/\bsudo\b/.test(command))
+            return true;
+        if (/\bchmod\s+777\b/.test(command))
+            return true;
+        if (/\bcurl\b.*\|\s*(bash|sh)\b/.test(command))
+            return true;
+        return false;
+    }
     // Check all sub-actions in a batch
     if (cmd.type === "batch") {
         const actions = p.actions;
@@ -107,6 +124,8 @@ function formatCommand(cmd) {
             return `Scroll ${p.direction} by ${p.amount || 3}`;
         case "drag":
             return `Drag from (${p.fromX}, ${p.fromY}) to (${p.toX}, ${p.toY})`;
+        case "exec":
+            return `Run command: ${String(p.command || "").substring(0, 100)}${String(p.command || "").length > 100 ? "..." : ""}`;
         case "batch": {
             const actions = p.actions;
             if (!Array.isArray(actions))

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 /** Command sent from VM agent → dispatch server → local relay */
 export interface DispatchCommand {
     id: string;
-    type: "screenshot" | "click" | "type" | "press" | "scroll" | "drag" | "windows" | "status" | "batch";
+    type: "screenshot" | "click" | "type" | "press" | "scroll" | "drag" | "windows" | "status" | "batch" | "exec";
     params: Record<string, unknown>;
     description?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instaclaw/dispatch",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Let your InstaClaw AI agent control your computer — screenshots, clicks, typing, and more via a secure WebSocket relay",
   "bin": {
     "instaclaw-dispatch": "./dist/index.js"