@instaclaw/dispatch 0.1.0 → 0.2.0

package/dist/index.js

@@ -7,21 +7,44 @@
  *   npx @instaclaw/dispatch --token XXX --vm HOST  # Direct connect
  */
 import { loadConfig, saveConfig, getConfigPath } from "./config.js";
-import { checkPermissions, printPermissionGuide } from "./permissions.js";
+import { checkPermissions, printPermissionGuide, runPermissionTest } from "./permissions.js";
 import { connect, disconnect } from "./connection.js";
-import { closeSupervisor } from "./supervisor.js";
+import { closeSupervisor, setMode } from "./supervisor.js";
 import readline from "readline";
+import os from "os";
 async function main() {
     console.log(`
   InstaClaw Dispatch — Remote Computer Control
   ─────────────────────────────────────────────
   `);
-    // 1. Check/request permissions
-    const perms = checkPermissions();
-    if (!perms.accessibility || !perms.screenRecording) {
+    // 1. Check permissions (macOS only)
+    if (os.platform() === "darwin") {
         console.log("  Checking permissions...");
-        printPermissionGuide();
-        await waitForEnter();
+        const perms = checkPermissions();
+        printPermissionGuide(perms);
+        if (perms.screenRecording === false || perms.accessibility === false) {
+            await waitForEnter();
+            // Re-check after user grants
+            const recheck = checkPermissions();
+            if (recheck.screenRecording === false) {
+                console.log("  Warning: Screen Recording still not granted. Screenshots may fail.\n");
+            }
+            if (recheck.accessibility === false) {
+                console.log("  Warning: Accessibility still not granted. Click/type may fail.\n");
+            }
+        }
+        else {
+            // Run a functional test to be sure
+            console.log("  Running permission test...");
+            const test = await runPermissionTest();
+            if (test.ok) {
+                console.log("  Permissions: all OK\n");
+            }
+            else {
+                console.log(`  Warning: ${test.error}`);
+                console.log("  Continuing anyway — some commands may fail.\n");
+            }
+        }
     }
     // 2. Load or create config
     let config = loadConfig();
@@ -32,7 +55,7 @@ async function main() {
             gatewayToken: args.token,
             vmAddress: args.vm,
             port: args.port || 8765,
-            mode: "supervised",
+            mode: args.autonomous ? "autonomous" : "supervised",
         };
         saveConfig(config);
     }
@@ -42,6 +65,10 @@ async function main() {
         saveConfig(config);
         console.log(`  Config saved to ${getConfigPath()}\n`);
     }
+    // Set supervisor mode
+    if (config.mode === "autonomous") {
+        setMode("autonomous");
+    }
     console.log(`  VM:   ${config.vmAddress}:${config.port}`);
     console.log(`  Mode: ${config.mode}`);
     console.log(`  Token: ${config.gatewayToken.substring(0, 8)}...\n`);
@@ -54,8 +81,14 @@ async function main() {
         rejectUnauthorized: false, // Accept self-signed (TOFU)
         certFingerprint: config.certFingerprint,
         onConnect: () => {
-            console.log(`\n  Dispatch mode: SUPERVISED`);
-            console.log(`  Screenshots auto-approved. Actions require [Enter] to confirm.`);
+            if (config.mode === "autonomous") {
+                console.log(`\n  Dispatch mode: AUTONOMOUS`);
+                console.log(`  All actions auto-approved (dangerous actions still require confirmation).`);
+            }
+            else {
+                console.log(`\n  Dispatch mode: SUPERVISED`);
+                console.log(`  Screenshots auto-approved. Actions require [Enter] to confirm.`);
+            }
             console.log(`  Press Ctrl+C to disconnect.\n`);
         },
         onDisconnect: () => {
@@ -110,6 +143,9 @@ function parseArgs() {
         else if ((args[i] === "--port" || args[i] === "-p") && args[i + 1]) {
             result.port = parseInt(args[++i], 10);
         }
+        else if (args[i] === "--autonomous" || args[i] === "--auto") {
+            result.autonomous = true;
+        }
     }
     return result;
 }

package/dist/permissions.d.ts

@@ -1,8 +1,16 @@
 interface PermissionStatus {
-    accessibility: boolean;
-    screenRecording: boolean;
+    accessibility: boolean | "unknown";
+    screenRecording: boolean | "unknown";
     platform: string;
 }
 export declare function checkPermissions(): PermissionStatus;
-export declare function printPermissionGuide(): void;
+/**
+ * Run a quick functional test: take a screenshot via usecomputer.
+ * If it fails, permissions are likely missing.
+ */
+export declare function runPermissionTest(): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+export declare function printPermissionGuide(status: PermissionStatus): void;
 export {};

package/dist/permissions.js

@@ -1,44 +1,118 @@
+import { execSync } from "child_process";
 import os from "os";
+import fs from "fs";
+import path from "path";
 export function checkPermissions() {
     const platform = os.platform();
     if (platform === "darwin") {
         return checkMacPermissions();
     }
-    // Linux/Windows — no special permissions needed for X11
+    // Linux/Windows — no special permissions needed
     return { accessibility: true, screenRecording: true, platform };
 }
 function checkMacPermissions() {
-    let accessibility = false;
-    let screenRecording = false;
-    // Check accessibility: try to create a CGEvent (will fail without permission)
-    // We can't check directly from Node — usecomputer will fail at runtime if missing
-    // For now, assume true and catch errors at execution time
-    accessibility = true; // Will validate on first command
-    // Screen recording: same — can't check from Node without native module
-    screenRecording = true;
+    let accessibility = "unknown";
+    let screenRecording = "unknown";
+    // Check Accessibility via TCC database
+    // macOS stores permission grants in ~/Library/Application Support/com.apple.TCC/TCC.db
+    // and /Library/Application Support/com.apple.TCC/TCC.db (system)
+    // We can try a quick test: usecomputer mouse position (fails without accessibility)
+    try {
+        const result = execSync('osascript -e \'tell application "System Events" to get name of first process\'', { timeout: 3000, stdio: ["pipe", "pipe", "pipe"] });
+        accessibility = true;
+    }
+    catch {
+        // AppleScript fails without Accessibility permission
+        accessibility = false;
+    }
+    // Check Screen Recording by attempting a tiny screenshot
+    // CGWindowListCreateImage returns a null/empty image without Screen Recording permission
+    try {
+        const tmpFile = path.join(os.tmpdir(), `dispatch-perm-check-${Date.now()}.png`);
+        execSync(`screencapture -x -t png "${tmpFile}" 2>/dev/null`, { timeout: 5000 });
+        if (fs.existsSync(tmpFile)) {
+            const size = fs.statSync(tmpFile).size;
+            fs.unlinkSync(tmpFile);
+            // A valid screenshot is at least a few KB. A blocked capture may produce a tiny or empty file.
+            screenRecording = size > 500;
+        }
+        else {
+            screenRecording = false;
+        }
+    }
+    catch {
+        screenRecording = false;
+    }
     return { accessibility, screenRecording, platform: "darwin" };
 }
-export function printPermissionGuide() {
-    const platform = os.platform();
+/**
+ * Run a quick functional test: take a screenshot via usecomputer.
+ * If it fails, permissions are likely missing.
+ */
+export async function runPermissionTest() {
+    try {
+        const uc = await import("usecomputer");
+        const tmpPath = path.join(os.tmpdir(), `dispatch-test-${Date.now()}.png`);
+        await uc.screenshot({ path: tmpPath, display: null, window: null, region: null, annotate: null });
+        if (fs.existsSync(tmpPath)) {
+            const size = fs.statSync(tmpPath).size;
+            fs.unlinkSync(tmpPath);
+            if (size > 500)
+                return { ok: true };
+            return { ok: false, error: "Screenshot captured but empty — Screen Recording permission may be missing" };
+        }
+        return { ok: false, error: "Screenshot file not created" };
+    }
+    catch (err) {
+        const msg = String(err);
+        if (msg.includes("EVENT_POST_FAILED") || msg.includes("CGEvent")) {
+            return { ok: false, error: "Accessibility permission not granted" };
+        }
+        if (msg.includes("CAPTURE_FAILED")) {
+            return { ok: false, error: "Screen Recording permission not granted" };
+        }
+        return { ok: false, error: msg.slice(0, 100) };
+    }
+}
+export function printPermissionGuide(status) {
+    const platform = status.platform;
     if (platform === "darwin") {
-        console.log(`
-  To grant permissions (macOS):
-    1. System Settings → Privacy & Security → Accessibility
-       → Add your terminal app (Terminal, iTerm, Warp, etc.)
-    2. System Settings → Privacy & Security → Screen Recording
-       → Add your terminal app
-
-  Press Enter after granting permissions...`);
+        const terminal = process.env.TERM_PROGRAM || "your terminal app";
+        const terminalName = {
+            "Apple_Terminal": "Terminal",
+            "iTerm.app": "iTerm2",
+            "vscode": "Visual Studio Code",
+            "WarpTerminal": "Warp",
+        }[terminal] || terminal;
+        console.log("");
+        if (status.screenRecording === false) {
+            console.log(`  Screen Recording: NOT GRANTED`);
+            console.log(`    → System Settings → Privacy & Security → Screen Recording`);
+            console.log(`    → Enable "${terminalName}"`);
+            console.log(`    → You may need to restart ${terminalName} after granting`);
+            console.log("");
+        }
+        else {
+            console.log(`  Screen Recording: OK`);
+        }
+        if (status.accessibility === false) {
+            console.log(`  Accessibility: NOT GRANTED`);
+            console.log(`    → System Settings → Privacy & Security → Accessibility`);
+            console.log(`    → Enable "${terminalName}"`);
+            console.log("");
+        }
+        else {
+            console.log(`  Accessibility: OK`);
+        }
+        if (status.screenRecording === false || status.accessibility === false) {
+            console.log(`  After granting permissions, press Enter to continue...`);
+        }
     }
     else if (platform === "linux") {
-        console.log(`
-  Linux: No special permissions needed.
-  Ensure DISPLAY is set if using X11.`);
+        console.log(`  Linux: No special permissions needed.`);
     }
     else {
-        console.log(`
-  Windows: No special permissions needed.
-  Run as administrator if controlling elevated apps.`);
+        console.log(`  Windows: No special permissions needed.`);
     }
 }
 //# sourceMappingURL=permissions.js.map

package/dist/supervisor.d.ts

@@ -1,3 +1,4 @@
 import type { DispatchCommand } from "./types.js";
+export declare function setMode(m: "supervised" | "autonomous"): void;
 export declare function requestApproval(command: DispatchCommand): Promise<boolean>;
 export declare function closeSupervisor(): void;

package/dist/supervisor.js

@@ -1,9 +1,25 @@
 /**
- * Supervisor — prompts user for approval before executing commands.
- * Screenshots are auto-approved. All other actions require Enter to proceed.
+ * Supervisor — controls whether commands need user approval.
+ *
+ * Modes:
+ *   supervised (default) — all non-passive commands require Enter to approve
+ *   autonomous — auto-approves most commands, but ALWAYS prompts for dangerous ones
  */
 import readline from "readline";
 const AUTO_APPROVE_TYPES = new Set(["screenshot", "windows", "status"]);
+// Patterns that indicate dangerous actions — always require confirmation even in autonomous mode
+const DANGEROUS_TEXT_PATTERNS = [
+    /password/i, /passwd/i, /secret/i, /credential/i,
+    /delete/i, /remove/i, /destroy/i, /format/i, /erase/i,
+    /purchase/i, /submit.*order/i, /confirm.*payment/i, /buy\s/i,
+    /transfer.*fund/i, /send.*money/i, /withdraw/i,
+    /sudo\s/i, /rm\s+-rf/i, /shutdown/i, /reboot/i,
+];
+const DANGEROUS_KEY_COMBOS = new Set([
+    "cmd+delete", "cmd+shift+delete", "ctrl+delete",
+    "cmd+q", "alt+f4",
+]);
+let mode = "supervised";
 const isTTY = process.stdin.isTTY ?? false;
 let rl = null;
 if (isTTY) {
@@ -12,18 +28,36 @@ if (isTTY) {
         output: process.stdout,
     });
 }
+export function setMode(m) {
+    mode = m;
+}
 export async function requestApproval(command) {
-    // Auto-approve passive commands
+    // Always auto-approve passive commands
     if (AUTO_APPROVE_TYPES.has(command.type)) {
         return true;
     }
     const desc = formatCommand(command);
-    console.log(`\n  Agent wants to: ${desc}`);
-    // Non-interactive mode (no TTY) — auto-approve with log
+    const dangerous = isDangerous(command);
+    // Non-interactive (no TTY) — auto-approve everything (can't prompt)
     if (!rl) {
+        if (dangerous) {
+            console.log(`\n  BLOCKED (dangerous, no TTY): ${desc}`);
+            return false;
+        }
+        console.log(`\n  Agent wants to: ${desc}`);
         console.log("  Auto-approved (non-interactive mode)");
         return true;
     }
+    // Autonomous mode — auto-approve non-dangerous actions
+    if (mode === "autonomous" && !dangerous) {
+        console.log(`\n  Agent: ${desc}`);
+        return true;
+    }
+    // Supervised mode OR dangerous action in autonomous mode — prompt user
+    console.log(`\n  Agent wants to: ${desc}`);
+    if (dangerous) {
+        console.log("  ⚠️  DANGEROUS ACTION — requires confirmation");
+    }
     return new Promise((resolve) => {
         rl.question("  [Enter] to approve, [n] to deny: ", (answer) => {
             const denied = answer.trim().toLowerCase() === "n";
@@ -34,6 +68,18 @@ export async function requestApproval(command) {
         });
     });
 }
+function isDangerous(cmd) {
+    const p = cmd.params;
+    if (cmd.type === "type") {
+        const text = String(p.text || "");
+        return DANGEROUS_TEXT_PATTERNS.some((pat) => pat.test(text));
+    }
+    if (cmd.type === "press") {
+        const key = String(p.key || "").toLowerCase();
+        return DANGEROUS_KEY_COMBOS.has(key);
+    }
+    return false;
+}
 function formatCommand(cmd) {
     const p = cmd.params;
     switch (cmd.type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instaclaw/dispatch",
-  "version": "0.1.0",
+  "version": "0.2.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"