@skillful-agents/agent-computer 0.0.4 → 0.0.6

package/dist-cjs/src/cli/commands/dialog.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+(0, commands_js_1.registerCommand)('dialog', async (args, bridge) => {
+    const sub = args.subcommand;
+    if (sub === 'accept' || sub === 'ok' || sub === 'yes') {
+        const params = {};
+        if (args.flags['app'])
+            params.app = args.flags['app'];
+        const result = await bridge.send('dialog_accept', params);
+        return { data: result, exitCode: 0 };
+    }
+    if (sub === 'cancel' || sub === 'dismiss' || sub === 'no') {
+        const params = {};
+        if (args.flags['app'])
+            params.app = args.flags['app'];
+        const result = await bridge.send('dialog_cancel', params);
+        return { data: result, exitCode: 0 };
+    }
+    if (sub === 'file') {
+        const path = args.positional[0];
+        if (!path) {
+            return { data: { error: 'Usage: agent-computer dialog file <path>' }, exitCode: 1 };
+        }
+        const params = { path };
+        if (args.flags['app'])
+            params.app = args.flags['app'];
+        const result = await bridge.send('dialog_file', params);
+        return { data: result, exitCode: 0 };
+    }
+    // Default: detect dialog
+    const params = {};
+    if (args.flags['app'])
+        params.app = args.flags['app'];
+    const result = await bridge.send('dialog', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('alert', async (args, bridge) => {
+    // Alias for dialog
+    const params = {};
+    if (args.flags['app'])
+        params.app = args.flags['app'];
+    const result = await bridge.send('dialog', params);
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/drag.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+(0, commands_js_1.registerCommand)('drag', async (args, bridge) => {
+    const params = {};
+    // Support ref-based: ac drag @b1 @b2
+    // Or coordinate-based: ac drag --from-x 100 --from-y 200 --to-x 300 --to-y 400
+    if (args.positional[0])
+        params.from_ref = args.positional[0];
+    if (args.positional[1])
+        params.to_ref = args.positional[1];
+    if (args.flags['from-x'])
+        params.from_x = parseFloat(args.flags['from-x']);
+    if (args.flags['from-y'])
+        params.from_y = parseFloat(args.flags['from-y']);
+    if (args.flags['to-x'])
+        params.to_x = parseFloat(args.flags['to-x']);
+    if (args.flags['to-y'])
+        params.to_y = parseFloat(args.flags['to-y']);
+    if (args.flags['duration'])
+        params.duration = parseFloat(args.flags['duration']);
+    if (args.flags['steps'])
+        params.steps = parseInt(args.flags['steps'], 10);
+    const result = await bridge.send('drag', params);
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/find.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+const parser_js_1 = require("../parser.js");
+(0, commands_js_1.registerCommand)('find', async (args, bridge) => {
+    const params = {};
+    if (args.positional[0])
+        params.text = args.positional[0];
+    if (args.flags['role'])
+        params.role = args.flags['role'];
+    if (args.flags['first'])
+        params.first = true;
+    if (args.flags['app'])
+        params.app = args.flags['app'];
+    const result = await bridge.send('find', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('read', async (args, bridge) => {
+    const sel = args.positional[0];
+    if (!sel) {
+        return { data: { error: 'Usage: agent-computer read <ref> [--attr <name>]' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const ref = parsed.type === 'ref' ? parsed.ref : sel;
+    const params = { ref };
+    if (args.flags['attr'])
+        params.attr = args.flags['attr'];
+    const result = await bridge.send('read', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('title', async (args, bridge) => {
+    const params = {};
+    if (args.flags['app'])
+        params.app = true;
+    const result = await bridge.send('title', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('is', async (args, bridge) => {
+    const state = args.subcommand;
+    const sel = args.positional[0];
+    if (!state || !sel) {
+        return { data: { error: 'Usage: agent-computer is <visible|enabled|focused|checked> <ref>' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const ref = parsed.type === 'ref' ? parsed.ref : sel;
+    const result = await bridge.send('is', { state, ref });
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('box', async (args, bridge) => {
+    const sel = args.positional[0];
+    if (!sel) {
+        return { data: { error: 'Usage: agent-computer box <ref>' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const ref = parsed.type === 'ref' ? parsed.ref : sel;
+    const result = await bridge.send('box', { ref });
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('children', async (args, bridge) => {
+    const sel = args.positional[0];
+    if (!sel) {
+        return { data: { error: 'Usage: agent-computer children <ref>' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const ref = parsed.type === 'ref' ? parsed.ref : sel;
+    const result = await bridge.send('children', { ref });
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('wait', async (args, bridge) => {
+    const params = {};
+    // Wait for fixed duration
+    if (args.positional[0] && /^\d+$/.test(args.positional[0])) {
+        params.ms = parseInt(args.positional[0], 10);
+    }
+    else if (args.positional[0]) {
+        // Wait for element
+        const parsed = (0, parser_js_1.parseSelector)(args.positional[0]);
+        if (parsed.type === 'ref')
+            params.ref = parsed.ref;
+        else
+            params.ref = args.positional[0];
+    }
+    if (args.flags['app'])
+        params.app = args.flags['app'];
+    if (args.flags['window'])
+        params.window = args.flags['window'];
+    if (args.flags['text'])
+        params.text = args.flags['text'];
+    if (args.flags['hidden'])
+        params.hidden = true;
+    if (args.flags['enabled'])
+        params.enabled = true;
+    if (args.flags['gone'])
+        params.gone = true;
+    if (args.flags['timeout'])
+        params.timeout = parseInt(args.flags['timeout'], 10);
+    const result = await bridge.send('wait', params);
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/menu.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+(0, commands_js_1.registerCommand)('menu', async (args, bridge) => {
+    const sub = args.subcommand;
+    if (sub === 'list') {
+        // ac menu list [name] [--all] [--app name]
+        const params = {};
+        if (args.positional[0])
+            params.menu = args.positional[0];
+        if (args.flags['all'])
+            params.all = true;
+        if (args.flags['app'])
+            params.app = args.flags['app'];
+        const result = await bridge.send('menu_list', params);
+        return { data: result, exitCode: 0 };
+    }
+    if (sub) {
+        // ac menu "File > Save" — click by path
+        const params = { path: sub };
+        if (args.flags['app'])
+            params.app = args.flags['app'];
+        const result = await bridge.send('menu_click', params);
+        return { data: result, exitCode: 0 };
+    }
+    return { data: { error: 'Usage: agent-computer menu <path> | agent-computer menu list [name]' }, exitCode: 1 };
+});
+(0, commands_js_1.registerCommand)('menubar', async (args, bridge) => {
+    const sub = args.subcommand;
+    if (sub === 'click' && args.positional[0]) {
+        // Click a menubar extra — not fully implemented yet
+        return { data: { error: 'menubar click not yet implemented' }, exitCode: 1 };
+    }
+    const result = await bridge.send('menubar');
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/screenshot.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+(0, commands_js_1.registerCommand)('screenshot', async (args, bridge) => {
+    const params = {};
+    // Optional output path as first positional arg
+    if (args.positional[0])
+        params.path = args.positional[0];
+    if (args.flags['screen'])
+        params.screen = true;
+    if (args.flags['retina'])
+        params.retina = true;
+    if (args.flags['format'])
+        params.format = args.flags['format'];
+    if (args.flags['quality'])
+        params.quality = parseInt(args.flags['quality'], 10);
+    if (args.flags['window'])
+        params.ref = args.flags['window'];
+    if (args.flags['annotate'])
+        params.annotate = true;
+    const result = await bridge.send('screenshot', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('displays', async (_args, bridge) => {
+    const result = await bridge.send('displays');
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/scroll.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+const parser_js_1 = require("../parser.js");
+(0, commands_js_1.registerCommand)('scroll', async (args, bridge) => {
+    const direction = args.subcommand;
+    if (!direction || !['up', 'down', 'left', 'right'].includes(direction)) {
+        return { data: { error: 'Usage: agent-computer scroll <up|down|left|right> [amount] [--on <sel>] [--smooth] [--pixels <n>]' }, exitCode: 1 };
+    }
+    const params = { direction };
+    if (args.positional[0])
+        params.amount = parseInt(args.positional[0], 10);
+    if (args.flags['on'])
+        params.on = args.flags['on'];
+    if (args.flags['smooth'])
+        params.smooth = true;
+    if (args.flags['pixels'])
+        params.pixels = parseInt(args.flags['pixels'], 10);
+    const result = await bridge.send('scroll', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('focus', async (args, bridge) => {
+    const sel = args.positional[0];
+    if (!sel) {
+        return { data: { error: 'Usage: agent-computer focus <ref>' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const params = {};
+    if (parsed.type === 'ref')
+        params.ref = parsed.ref;
+    else
+        params.ref = sel;
+    const result = await bridge.send('focus', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('select', async (args, bridge) => {
+    const sel = args.positional[0];
+    const value = args.positional[1];
+    if (!sel || !value) {
+        return { data: { error: 'Usage: agent-computer select <ref> <value>' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const ref = parsed.type === 'ref' ? parsed.ref : sel;
+    const result = await bridge.send('select', { ref, value });
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('check', async (args, bridge) => {
+    const sel = args.positional[0];
+    if (!sel) {
+        return { data: { error: 'Usage: agent-computer check <ref>' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const ref = parsed.type === 'ref' ? parsed.ref : sel;
+    const result = await bridge.send('check', { ref });
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('uncheck', async (args, bridge) => {
+    const sel = args.positional[0];
+    if (!sel) {
+        return { data: { error: 'Usage: agent-computer uncheck <ref>' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const ref = parsed.type === 'ref' ? parsed.ref : sel;
+    const result = await bridge.send('uncheck', { ref });
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('set', async (args, bridge) => {
+    const sel = args.positional[0];
+    const value = args.positional[1];
+    if (!sel || value === undefined) {
+        return { data: { error: 'Usage: agent-computer set <ref> <value>' }, exitCode: 1 };
+    }
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    const ref = parsed.type === 'ref' ? parsed.ref : sel;
+    const result = await bridge.send('set', { ref, value });
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/session.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+(0, commands_js_1.registerCommand)('grab', async (args, bridge) => {
+    const params = {};
+    if (args.flags['app']) {
+        params.app = args.flags['app'];
+    }
+    else if (args.positional[0]) {
+        const val = args.positional[0];
+        if (val.startsWith('@')) {
+            params.ref = val;
+        }
+        else {
+            params.app = val;
+        }
+    }
+    else {
+        return { data: { error: 'Usage: agent-computer grab <@w1> or agent-computer grab --app <name>' }, exitCode: 1 };
+    }
+    const result = await bridge.send('grab', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('ungrab', async (_args, bridge) => {
+    const result = await bridge.send('ungrab');
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/snapshot.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+(0, commands_js_1.registerCommand)('snapshot', async (args, bridge) => {
+    const params = {};
+    if (args.flags['interactive'])
+        params.interactive = true;
+    if (args.flags['compact'])
+        params.compact = true;
+    if (args.flags['depth'])
+        params.depth = parseInt(args.flags['depth'], 10);
+    if (args.flags['subtree'])
+        params.subtree = args.flags['subtree'];
+    if (args.flags['app'])
+        params.app = args.flags['app'];
+    if (args.flags['pid'])
+        params.pid = parseInt(args.flags['pid'], 10);
+    if (args.flags['screen'])
+        params.screen = true;
+    if (args.flags['window'])
+        params.window = args.flags['window'];
+    const result = await bridge.send('snapshot', params);
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/type.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+const parser_js_1 = require("../parser.js");
+(0, commands_js_1.registerCommand)('type', async (args, bridge) => {
+    const text = args.positional[0];
+    if (!text) {
+        return { data: { error: 'Usage: agent-computer type <text> [--delay ms]' }, exitCode: 1 };
+    }
+    const params = { text };
+    if (args.flags['delay'])
+        params.delay = parseInt(args.flags['delay'], 10);
+    const result = await bridge.send('type', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('fill', async (args, bridge) => {
+    const sel = args.positional[0];
+    const text = args.positional[1];
+    if (!sel || !text) {
+        return { data: { error: 'Usage: agent-computer fill <ref> <text>' }, exitCode: 1 };
+    }
+    const params = { text };
+    const parsed = (0, parser_js_1.parseSelector)(sel);
+    if (parsed.type === 'ref') {
+        params.ref = parsed.ref;
+    }
+    else {
+        params.ref = sel;
+    }
+    const result = await bridge.send('fill', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('key', async (args, bridge) => {
+    const combo = args.positional[0];
+    if (!combo) {
+        return { data: { error: 'Usage: agent-computer key <combo> [--repeat n]' }, exitCode: 1 };
+    }
+    const params = { combo };
+    if (args.flags['repeat'])
+        params.repeat = parseInt(args.flags['repeat'], 10);
+    if (args.flags['delay'])
+        params.delay = parseInt(args.flags['delay'], 10);
+    const result = await bridge.send('key', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('keydown', async (args, bridge) => {
+    const key = args.positional[0];
+    if (!key) {
+        return { data: { error: 'Usage: agent-computer keydown <key>' }, exitCode: 1 };
+    }
+    const result = await bridge.send('keydown', { key });
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('keyup', async (args, bridge) => {
+    const key = args.positional[0];
+    if (!key) {
+        return { data: { error: 'Usage: agent-computer keyup <key>' }, exitCode: 1 };
+    }
+    const result = await bridge.send('keyup', { key });
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('paste', async (args, bridge) => {
+    const text = args.positional[0];
+    if (!text) {
+        return { data: { error: 'Usage: agent-computer paste <text>' }, exitCode: 1 };
+    }
+    const result = await bridge.send('paste', { text });
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/windowmgmt.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+// Simple window actions: minimize, maximize, fullscreen, close, raise
+for (const cmd of ['minimize', 'maximize', 'fullscreen', 'close', 'raise']) {
+    (0, commands_js_1.registerCommand)(cmd, async (args, bridge) => {
+        const ref = args.positional[0] || args.flags['ref'];
+        const params = {};
+        if (ref)
+            params.ref = ref;
+        const result = await bridge.send(cmd, params);
+        return { data: result, exitCode: 0 };
+    });
+}
+(0, commands_js_1.registerCommand)('move', async (args, bridge) => {
+    const ref = args.positional[0];
+    const x = args.positional[1];
+    const y = args.positional[2];
+    if (!ref) {
+        return { data: { error: 'Usage: agent-computer move <@w> <x> <y>' }, exitCode: 1 };
+    }
+    const params = { ref };
+    if (x !== undefined && y !== undefined) {
+        params.x = parseFloat(x);
+        params.y = parseFloat(y);
+    }
+    const result = await bridge.send('move', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('resize', async (args, bridge) => {
+    const ref = args.positional[0];
+    const w = args.positional[1];
+    const h = args.positional[2];
+    if (!ref) {
+        return { data: { error: 'Usage: agent-computer resize <@w> <w> <h>' }, exitCode: 1 };
+    }
+    const params = { ref };
+    if (w !== undefined && h !== undefined) {
+        params.width = parseFloat(w);
+        params.height = parseFloat(h);
+    }
+    const result = await bridge.send('resize', params);
+    return { data: result, exitCode: 0 };
+});
+(0, commands_js_1.registerCommand)('bounds', async (args, bridge) => {
+    const ref = args.positional[0];
+    if (!ref) {
+        return { data: { error: 'Usage: agent-computer bounds <@w> <x> <y> <w> <h> | agent-computer bounds <@w> --preset <name>' }, exitCode: 1 };
+    }
+    const params = { ref };
+    if (args.flags['preset']) {
+        params.preset = args.flags['preset'];
+    }
+    else if (args.positional.length >= 5) {
+        params.x = parseFloat(args.positional[1]);
+        params.y = parseFloat(args.positional[2]);
+        params.width = parseFloat(args.positional[3]);
+        params.height = parseFloat(args.positional[4]);
+    }
+    const result = await bridge.send('bounds', params);
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/commands/windows.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_js_1 = require("../commands.js");
+(0, commands_js_1.registerCommand)('windows', async (args, bridge) => {
+    const params = {};
+    if (args.flags['app'])
+        params.app = args.flags['app'];
+    const result = await bridge.send('windows', params);
+    return { data: result, exitCode: 0 };
+});