@skillful-agents/agent-computer 0.0.3 → 0.0.5

package/dist-cjs/src/daemon.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonManager = void 0;
+const child_process_1 = require("child_process");
+const net_1 = require("net");
+const fs_1 = require("fs");
+const index_js_1 = require("./platform/index.js");
+const resolve_js_1 = require("./platform/resolve.js");
+class DaemonManager {
+    binaryPath;
+    constructor(binaryPath) {
+        this.binaryPath = binaryPath ?? (0, resolve_js_1.resolveBinary)();
+    }
+    async start() {
+        // Check if already running
+        const current = this.readDaemonInfo();
+        if (current && this.isProcessAlive(current.pid)) {
+            return this.buildStatus(current, true);
+        }
+        // Clean up stale files
+        this.cleanupStale();
+        // Spawn daemon
+        (0, fs_1.mkdirSync)(index_js_1.AC_DIR, { recursive: true });
+        const proc = (0, child_process_1.spawn)(this.binaryPath, ['--daemon'], {
+            detached: true,
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        proc.unref();
+        // Wait for daemon to be ready
+        const start = Date.now();
+        if (index_js_1.IS_NAMED_PIPE) {
+            // Named pipes: wait for daemon.json to appear (pipe has no file)
+            while (Date.now() - start < 5000) {
+                if ((0, fs_1.existsSync)(index_js_1.DAEMON_JSON_PATH)) {
+                    await sleep(50);
+                    break;
+                }
+                await sleep(50);
+            }
+            if (!(0, fs_1.existsSync)(index_js_1.DAEMON_JSON_PATH)) {
+                throw new Error('Daemon failed to start: daemon.json not created within 5s');
+            }
+        }
+        else {
+            // Unix socket: wait for socket file to appear
+            while (Date.now() - start < 5000) {
+                if ((0, fs_1.existsSync)(index_js_1.SOCKET_PATH)) {
+                    await sleep(50);
+                    break;
+                }
+                await sleep(50);
+            }
+            if (!(0, fs_1.existsSync)(index_js_1.SOCKET_PATH)) {
+                throw new Error('Daemon failed to start: socket not created within 5s');
+            }
+        }
+        const info = this.readDaemonInfo();
+        if (!info) {
+            throw new Error('Daemon started but daemon.json not found');
+        }
+        return this.buildStatus(info, true);
+    }
+    async stop() {
+        const info = this.readDaemonInfo();
+        if (!info)
+            return;
+        if (this.isProcessAlive(info.pid)) {
+            // On Windows, SIGTERM is a hard kill — try graceful RPC shutdown first
+            if (index_js_1.IS_NAMED_PIPE) {
+                try {
+                    await this.sendShutdownRPC(info.socket);
+                }
+                catch { /* fall through to SIGTERM */ }
+            }
+            // Wait for process to exit (may already be gone from RPC shutdown)
+            let start = Date.now();
+            while (Date.now() - start < 3000) {
+                if (!this.isProcessAlive(info.pid))
+                    break;
+                await sleep(50);
+            }
+            // Send SIGTERM if still alive
+            if (this.isProcessAlive(info.pid)) {
+                try {
+                    process.kill(info.pid, 'SIGTERM');
+                }
+                catch { /* ok */ }
+                start = Date.now();
+                while (Date.now() - start < 3000) {
+                    if (!this.isProcessAlive(info.pid))
+                        break;
+                    await sleep(50);
+                }
+            }
+            // Force kill if still alive
+            if (this.isProcessAlive(info.pid)) {
+                try {
+                    process.kill(info.pid, 'SIGKILL');
+                }
+                catch { /* ok */ }
+            }
+        }
+        this.cleanupStale();
+    }
+    sendShutdownRPC(socketPath) {
+        return new Promise((resolve, reject) => {
+            const sock = (0, net_1.connect)({ path: socketPath });
+            const timeout = setTimeout(() => { sock.destroy(); reject(new Error('shutdown timeout')); }, 2000);
+            sock.on('connect', () => {
+                const req = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'shutdown', params: {} }) + '\n';
+                sock.write(req, () => {
+                    clearTimeout(timeout);
+                    // Give daemon a moment to process before closing
+                    setTimeout(() => { sock.destroy(); resolve(); }, 100);
+                });
+            });
+            sock.on('error', (err) => { clearTimeout(timeout); reject(err); });
+        });
+    }
+    async status() {
+        const info = this.readDaemonInfo();
+        if (!info) {
+            return { running: false };
+        }
+        const alive = this.isProcessAlive(info.pid);
+        if (!alive) {
+            this.cleanupStale();
+            return { running: false };
+        }
+        return this.buildStatus(info, true);
+    }
+    async restart() {
+        await this.stop();
+        return this.start();
+    }
+    readDaemonInfo() {
+        try {
+            if (!(0, fs_1.existsSync)(index_js_1.DAEMON_JSON_PATH))
+                return null;
+            const raw = (0, fs_1.readFileSync)(index_js_1.DAEMON_JSON_PATH, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    isProcessAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    cleanupStale() {
+        if (!index_js_1.IS_NAMED_PIPE) {
+            try {
+                (0, fs_1.unlinkSync)(index_js_1.SOCKET_PATH);
+            }
+            catch { /* ok */ }
+        }
+        try {
+            (0, fs_1.unlinkSync)(index_js_1.DAEMON_JSON_PATH);
+        }
+        catch { /* ok */ }
+    }
+    buildStatus(info, running) {
+        const startedAt = new Date(info.started_at);
+        const uptime = Date.now() - startedAt.getTime();
+        return {
+            running,
+            pid: info.pid,
+            socket: info.socket,
+            started_at: info.started_at,
+            uptime_ms: Math.max(0, uptime),
+        };
+    }
+}
+exports.DaemonManager = DaemonManager;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist-cjs/src/errors.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidParamsError = exports.MethodNotFoundError = exports.InvalidRequestError = exports.OCRFallbackFailedError = exports.InvalidRefError = exports.WindowNotFoundError = exports.AppNotFoundError = exports.TimeoutError = exports.PermissionDeniedError = exports.ElementNotFoundError = exports.ACError = void 0;
+exports.errorFromCode = errorFromCode;
+exports.exitCodeFromErrorCode = exitCodeFromErrorCode;
+class ACError extends Error {
+    code;
+    exitCode;
+    data;
+    constructor(message, code, exitCode, data) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.data = data;
+        this.name = 'ACError';
+    }
+}
+exports.ACError = ACError;
+class ElementNotFoundError extends ACError {
+    constructor(message, data) {
+        super(message, -32001, 1, data);
+        this.name = 'ELEMENT_NOT_FOUND';
+    }
+}
+exports.ElementNotFoundError = ElementNotFoundError;
+class PermissionDeniedError extends ACError {
+    constructor(message, data) {
+        super(message, -32002, 2, data);
+        this.name = 'PERMISSION_DENIED';
+    }
+}
+exports.PermissionDeniedError = PermissionDeniedError;
+class TimeoutError extends ACError {
+    constructor(message, data) {
+        super(message, -32003, 3, data);
+        this.name = 'TIMEOUT';
+    }
+}
+exports.TimeoutError = TimeoutError;
+class AppNotFoundError extends ACError {
+    constructor(message, data) {
+        super(message, -32004, 4, data);
+        this.name = 'APP_NOT_FOUND';
+    }
+}
+exports.AppNotFoundError = AppNotFoundError;
+class WindowNotFoundError extends ACError {
+    constructor(message, data) {
+        super(message, -32005, 5, data);
+        this.name = 'WINDOW_NOT_FOUND';
+    }
+}
+exports.WindowNotFoundError = WindowNotFoundError;
+class InvalidRefError extends ACError {
+    constructor(message, data) {
+        super(message, -32006, 6, data);
+        this.name = 'INVALID_REF';
+    }
+}
+exports.InvalidRefError = InvalidRefError;
+class OCRFallbackFailedError extends ACError {
+    constructor(message, data) {
+        super(message, -32007, 7, data);
+        this.name = 'OCR_FALLBACK_FAILED';
+    }
+}
+exports.OCRFallbackFailedError = OCRFallbackFailedError;
+// JSON-RPC standard errors
+class InvalidRequestError extends ACError {
+    constructor(message, data) {
+        super(message, -32600, 126, data);
+        this.name = 'INVALID_REQUEST';
+    }
+}
+exports.InvalidRequestError = InvalidRequestError;
+class MethodNotFoundError extends ACError {
+    constructor(message, data) {
+        super(message, -32601, 126, data);
+        this.name = 'METHOD_NOT_FOUND';
+    }
+}
+exports.MethodNotFoundError = MethodNotFoundError;
+class InvalidParamsError extends ACError {
+    constructor(message, data) {
+        super(message, -32602, 126, data);
+        this.name = 'INVALID_PARAMS';
+    }
+}
+exports.InvalidParamsError = InvalidParamsError;
+// Error code → error class mapping
+const ERROR_MAP = {
+    [-32001]: ElementNotFoundError,
+    [-32002]: PermissionDeniedError,
+    [-32003]: TimeoutError,
+    [-32004]: AppNotFoundError,
+    [-32005]: WindowNotFoundError,
+    [-32006]: InvalidRefError,
+    [-32007]: OCRFallbackFailedError,
+    [-32600]: InvalidRequestError,
+    [-32601]: MethodNotFoundError,
+    [-32602]: InvalidParamsError,
+};
+function errorFromCode(code, message, data) {
+    const ErrorClass = ERROR_MAP[code];
+    if (ErrorClass) {
+        return new ErrorClass(message, data);
+    }
+    return new ACError(message, code, 126, data);
+}
+function exitCodeFromErrorCode(code) {
+    const instance = ERROR_MAP[code];
+    if (instance) {
+        // Create a temporary instance to get the exit code
+        const temp = new instance('');
+        return temp.exitCode;
+    }
+    return 126;
+}

package/dist-cjs/src/index.js

@@ -0,0 +1,24 @@
+"use strict";
+// @skillful-agents/ac — TypeScript SDK for macOS desktop automation
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPInteractions = exports.CDPAXTree = exports.CDPConnection = exports.CDPClient = exports.AC = exports.Bridge = exports.TimeoutError = exports.PermissionDeniedError = exports.ElementNotFoundError = exports.ACError = exports.REF_PREFIXES = exports.refToRole = exports.isValidRef = exports.parseRef = void 0;
+var refs_js_1 = require("./refs.js");
+Object.defineProperty(exports, "parseRef", { enumerable: true, get: function () { return refs_js_1.parseRef; } });
+Object.defineProperty(exports, "isValidRef", { enumerable: true, get: function () { return refs_js_1.isValidRef; } });
+Object.defineProperty(exports, "refToRole", { enumerable: true, get: function () { return refs_js_1.refToRole; } });
+Object.defineProperty(exports, "REF_PREFIXES", { enumerable: true, get: function () { return refs_js_1.REF_PREFIXES; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "ACError", { enumerable: true, get: function () { return errors_js_1.ACError; } });
+Object.defineProperty(exports, "ElementNotFoundError", { enumerable: true, get: function () { return errors_js_1.ElementNotFoundError; } });
+Object.defineProperty(exports, "PermissionDeniedError", { enumerable: true, get: function () { return errors_js_1.PermissionDeniedError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_js_1.TimeoutError; } });
+var bridge_js_1 = require("./bridge.js");
+Object.defineProperty(exports, "Bridge", { enumerable: true, get: function () { return bridge_js_1.Bridge; } });
+var sdk_js_1 = require("./sdk.js");
+Object.defineProperty(exports, "AC", { enumerable: true, get: function () { return sdk_js_1.AC; } });
+// CDP support
+var index_js_1 = require("./cdp/index.js");
+Object.defineProperty(exports, "CDPClient", { enumerable: true, get: function () { return index_js_1.CDPClient; } });
+Object.defineProperty(exports, "CDPConnection", { enumerable: true, get: function () { return index_js_1.CDPConnection; } });
+Object.defineProperty(exports, "CDPAXTree", { enumerable: true, get: function () { return index_js_1.CDPAXTree; } });
+Object.defineProperty(exports, "CDPInteractions", { enumerable: true, get: function () { return index_js_1.CDPInteractions; } });

package/dist-cjs/src/platform/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_NAMED_PIPE = exports.SOCKET_PATH = exports.SNAPSHOTS_DIR = exports.DAEMON_JSON_PATH = exports.AC_DIR = void 0;
+const path_1 = require("path");
+const os_1 = require("os");
+const os = (0, os_1.platform)();
+exports.AC_DIR = (0, path_1.join)((0, os_1.homedir)(), '.ac');
+exports.DAEMON_JSON_PATH = (0, path_1.join)(exports.AC_DIR, 'daemon.json');
+exports.SNAPSHOTS_DIR = (0, path_1.join)(exports.AC_DIR, 'snapshots');
+// macOS: Unix domain socket file on disk
+// Windows: Named pipe (kernel object, no file on disk)
+exports.SOCKET_PATH = os === 'win32'
+    ? '\\\\.\\pipe\\ac-daemon'
+    : (0, path_1.join)(exports.AC_DIR, 'daemon.sock');
+// Named pipes don't exist as files — connection-based detection needed
+exports.IS_NAMED_PIPE = os === 'win32';

package/dist-cjs/src/platform/resolve.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBinary = resolveBinary;
+const os_1 = require("os");
+const path_1 = require("path");
+const fs_1 = require("fs");
+/**
+ * Get directory of this file. Works in both ESM and CJS:
+ * - CJS: __dirname is a global provided by Node
+ * - ESM: use import.meta.url (wrapped in eval to avoid CJS parse error)
+ */
+function getModuleDir() {
+    if (typeof __dirname !== 'undefined')
+        return __dirname;
+    // ESM fallback — eval hides import.meta from the CJS parser
+    // eslint-disable-next-line no-eval
+    const url = eval('import.meta.url');
+    const { fileURLToPath } = require('url');
+    return (0, path_1.dirname)(fileURLToPath(url));
+}
+const _dirname = getModuleDir();
+/**
+ * Find the package root by walking up from __dirname until we find package.json.
+ * Works whether running from source (src/platform/) or compiled (dist/src/platform/).
+ */
+function findProjectRoot() {
+    let dir = _dirname;
+    for (let i = 0; i < 5; i++) {
+        if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'package.json')))
+            return dir;
+        dir = (0, path_1.dirname)(dir);
+    }
+    return (0, path_1.join)(_dirname, '..', '..');
+}
+function resolveBinary() {
+    const os = (0, os_1.platform)();
+    const cpu = (0, os_1.arch)();
+    if (os !== 'darwin' && os !== 'win32') {
+        throw new Error(`Unsupported platform: ${os}. agent-computer supports macOS and Windows.`);
+    }
+    const ext = os === 'win32' ? '.exe' : '';
+    const key = `${os}-${cpu === 'arm64' ? 'arm64' : 'x64'}`;
+    const projectRoot = findProjectRoot();
+    // Bundled platform-specific binary (npm package)
+    const bundledPath = (0, path_1.join)(projectRoot, 'bin', `ac-core-${key}${ext}`);
+    if ((0, fs_1.existsSync)(bundledPath)) {
+        return bundledPath;
+    }
+    if (os === 'darwin') {
+        // Development: locally-built Swift binary (release)
+        const devBinaryPath = (0, path_1.join)(projectRoot, 'native', 'macos', '.build', 'release', 'ac-core');
+        if ((0, fs_1.existsSync)(devBinaryPath))
+            return devBinaryPath;
+        // Development: Swift debug build
+        const debugBinaryPath = (0, path_1.join)(projectRoot, 'native', 'macos', '.build', 'debug', 'ac-core');
+        if ((0, fs_1.existsSync)(debugBinaryPath))
+            return debugBinaryPath;
+    }
+    if (os === 'win32') {
+        const rid = cpu === 'arm64' ? 'win-arm64' : 'win-x64';
+        const tfms = ['net9.0-windows', 'net9.0'];
+        const base = (0, path_1.join)(projectRoot, 'native', 'windows', 'ACCore', 'bin');
+        for (const tfm of tfms) {
+            // Development: self-contained release publish
+            const publishPath = (0, path_1.join)(base, 'Release', tfm, rid, 'publish', 'ac-core.exe');
+            if ((0, fs_1.existsSync)(publishPath))
+                return publishPath;
+            // Development: release build (framework-dependent)
+            const releasePath = (0, path_1.join)(base, 'Release', tfm, 'ac-core.exe');
+            if ((0, fs_1.existsSync)(releasePath))
+                return releasePath;
+            // Development: debug build (framework-dependent)
+            const debugPath = (0, path_1.join)(base, 'Debug', tfm, 'ac-core.exe');
+            if ((0, fs_1.existsSync)(debugPath))
+                return debugPath;
+        }
+    }
+    const buildHint = os === 'win32'
+        ? 'cd native/windows && dotnet build'
+        : 'cd native/macos && swift build -c release';
+    throw new Error(`Native binary not found for ${key}. ` +
+        `Build from source: ${buildHint}`);
+}

package/dist-cjs/src/refs.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REF_PREFIXES = void 0;
+exports.roleToPrefix = roleToPrefix;
+exports.parseRef = parseRef;
+exports.isValidRef = isValidRef;
+exports.refToRole = refToRole;
+// Single-letter prefix → role mapping
+const SINGLE_LETTER_PREFIXES = {
+    b: 'button',
+    t: 'textfield',
+    l: 'link',
+    m: 'menuitem',
+    c: 'checkbox',
+    r: 'radio',
+    s: 'slider',
+    d: 'dropdown',
+    i: 'image',
+    g: 'group',
+    w: 'window',
+    x: 'table',
+    o: 'row',
+    a: 'tab',
+    e: 'generic',
+};
+// Two-letter prefix → role mapping (for less common roles)
+const TWO_LETTER_PREFIXES = {
+    cb: 'combobox',
+    sa: 'scrollarea',
+    st: 'stepper',
+    sp: 'splitgroup',
+    tl: 'timeline',
+    pg: 'progress',
+    tv: 'treeview',
+    wb: 'webarea',
+};
+exports.REF_PREFIXES = {
+    ...SINGLE_LETTER_PREFIXES,
+    ...TWO_LETTER_PREFIXES,
+};
+// Reverse mapping: role → prefix
+const ROLE_TO_PREFIX = {};
+for (const [prefix, role] of Object.entries(exports.REF_PREFIXES)) {
+    // Prefer shorter prefix if role already mapped
+    if (!ROLE_TO_PREFIX[role] || prefix.length < ROLE_TO_PREFIX[role].length) {
+        ROLE_TO_PREFIX[role] = prefix;
+    }
+}
+// textfield and textarea both map to 't' — textarea gets 't' by convention
+ROLE_TO_PREFIX['textarea'] = 't';
+function roleToPrefix(role) {
+    return ROLE_TO_PREFIX[role] ?? 'e';
+}
+const ALL_PREFIXES = new Set(Object.keys(exports.REF_PREFIXES));
+// Ref pattern: @<prefix><positive integer>
+// Try two-letter prefix first, then single-letter
+const REF_REGEX = /^@([a-z]{1,2})([1-9]\d*)$/;
+function parseRef(input) {
+    const match = REF_REGEX.exec(input);
+    if (!match) {
+        throw new Error(`Invalid ref format: "${input}". Expected @<prefix><number> (e.g., @b1, @cb3)`);
+    }
+    const rawPrefix = match[1];
+    const id = parseInt(match[2], 10);
+    // Try two-letter prefix first (e.g., "@cb1" → prefix "cb", not "c" with "b1")
+    if (rawPrefix.length === 2 && ALL_PREFIXES.has(rawPrefix)) {
+        return { prefix: rawPrefix, role: exports.REF_PREFIXES[rawPrefix], id };
+    }
+    // Try single-letter prefix
+    if (rawPrefix.length === 1 && ALL_PREFIXES.has(rawPrefix)) {
+        return { prefix: rawPrefix, role: exports.REF_PREFIXES[rawPrefix], id };
+    }
+    // Two-letter prefix but only first letter is valid (e.g., "@bx1" is not valid)
+    if (rawPrefix.length === 2) {
+        // Check if first letter alone is a valid prefix — if so, reject because the second char is part of the number parsing issue
+        throw new Error(`Invalid ref prefix: "${rawPrefix}" in "${input}". Valid prefixes: ${[...ALL_PREFIXES].sort().join(', ')}`);
+    }
+    throw new Error(`Unknown ref prefix: "${rawPrefix}" in "${input}". Valid prefixes: ${[...ALL_PREFIXES].sort().join(', ')}`);
+}
+function isValidRef(input) {
+    try {
+        parseRef(input);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function refToRole(prefix) {
+    return exports.REF_PREFIXES[prefix];
+}