@skillful-agents/agent-computer 0.0.4 → 0.0.6

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

@@ -0,0 +1,215 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommand = registerCommand;
+exports.getCommand = getCommand;
+exports.getCommandAsync = getCommandAsync;
+exports.getAllCommands = getAllCommands;
+const daemon_js_1 = require("../daemon.js");
+const config_js_1 = require("../config.js");
+const commands = {};
+let commandModulesLoaded = false;
+function registerCommand(name, handler) {
+    commands[name] = handler;
+}
+async function ensureCommandModulesLoaded() {
+    if (commandModulesLoaded)
+        return;
+    commandModulesLoaded = true;
+    await Promise.resolve().then(() => __importStar(require('./commands/apps.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/windows.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/session.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/snapshot.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/click.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/type.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/clipboard.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/windowmgmt.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/screenshot.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/scroll.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/find.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/menu.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/dialog.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/drag.js')));
+    await Promise.resolve().then(() => __importStar(require('./commands/batch.js')));
+}
+function getCommand(name) {
+    return commands[name];
+}
+async function getCommandAsync(name) {
+    await ensureCommandModulesLoaded();
+    return commands[name];
+}
+function getAllCommands() {
+    return Object.keys(commands).sort();
+}
+// Register built-in commands
+registerCommand('version', async () => {
+    return { data: { version: '0.1.0' }, exitCode: 0 };
+});
+registerCommand('help', async () => {
+    const help = `agent-computer — Agent Computer CLI for macOS
+
+Usage: agent-computer <command> [options]
+
+Commands:
+  snapshot              Snapshot the accessibility tree
+  screenshot [path]     Take a screenshot
+  click <sel>           Click an element
+  type <text>           Type text
+  fill <sel> <text>     Focus, clear, and type into an element
+  key <combo>           Press a key combination
+  find <text>           Find elements by text
+  read <sel>            Read element value
+  scroll <dir> [amount] Scroll in a direction
+  menu <path>           Click a menu item by path
+
+  apps                  List applications
+  launch <name>         Launch an application
+  quit <name>           Quit an application
+  windows               List windows
+  grab <sel>            Set active window context
+  ungrab                Clear active window context
+  status                Show session state
+
+  wait <sel|ms>         Wait for condition
+  clipboard [set <text>] Clipboard operations
+  alert                 Handle alerts
+  dialog                Handle dialogs
+
+  daemon <start|stop|status|restart>  Manage daemon
+  config [set <key> <val> | reset]    Configuration
+  permissions [grant]                 Permission status
+  doctor                              Run diagnostics
+  version                             Print version
+
+Global options:
+  --json                JSON output (default: human-readable text)
+  --timeout <ms>        Override timeout (default: 10000)
+  --verbose             Debug logging to stderr
+  --content-boundary    Wrap output in delimiters
+  --max-output <n>      Truncate output to N characters
+
+See: https://github.com/datawizz/agent-computer`;
+    return { data: help, exitCode: 0 };
+});
+registerCommand('daemon', async (args) => {
+    const manager = new daemon_js_1.DaemonManager();
+    const sub = args.subcommand;
+    switch (sub) {
+        case 'start': {
+            const status = await manager.start();
+            return { data: status, exitCode: 0 };
+        }
+        case 'stop': {
+            await manager.stop();
+            return { data: { ok: true }, exitCode: 0 };
+        }
+        case 'status': {
+            const status = await manager.status();
+            return { data: status, exitCode: 0 };
+        }
+        case 'restart': {
+            const status = await manager.restart();
+            return { data: status, exitCode: 0 };
+        }
+        default:
+            return { data: { error: `Unknown daemon subcommand: ${sub}. Use: start, stop, status, restart` }, exitCode: 1 };
+    }
+});
+registerCommand('config', async (args) => {
+    const sub = args.subcommand;
+    switch (sub) {
+        case 'set': {
+            const key = args.positional[0];
+            const value = args.positional[1];
+            if (!key || value === undefined) {
+                return { data: { error: 'Usage: agent-computer config set <key> <value>' }, exitCode: 1 };
+            }
+            const defaults = (0, config_js_1.getDefaults)();
+            if (!(key in defaults)) {
+                return { data: { error: `Unknown config key: ${key}` }, exitCode: 1 };
+            }
+            // Coerce value to correct type
+            const defaultVal = defaults[key];
+            let coerced = value;
+            if (typeof defaultVal === 'number')
+                coerced = parseInt(value, 10);
+            if (typeof defaultVal === 'boolean')
+                coerced = value === 'true' || value === '1';
+            (0, config_js_1.setConfigValue)(key, coerced);
+            return { data: { ok: true, key, value: coerced }, exitCode: 0 };
+        }
+        case 'reset': {
+            (0, config_js_1.resetConfig)();
+            return { data: { ok: true }, exitCode: 0 };
+        }
+        default: {
+            // Show current config
+            const config = (0, config_js_1.resolveConfig)();
+            return { data: config, exitCode: 0 };
+        }
+    }
+});
+registerCommand('ping', async (_args, bridge) => {
+    const result = await bridge.send('ping');
+    return { data: result, exitCode: 0 };
+});
+registerCommand('status', async (_args, bridge) => {
+    const result = await bridge.send('status');
+    return { data: result, exitCode: 0 };
+});
+registerCommand('permissions', async (args, bridge) => {
+    if (args.subcommand === 'grant') {
+        const result = await bridge.send('permissions_grant');
+        return { data: result, exitCode: 0 };
+    }
+    const result = await bridge.send('permissions');
+    return { data: result, exitCode: 0 };
+});
+registerCommand('doctor', async (_args, bridge) => {
+    const [permissions, version, daemonStatus] = await Promise.all([
+        bridge.send('permissions'),
+        bridge.send('version'),
+        new daemon_js_1.DaemonManager().status(),
+    ]);
+    const result = {
+        version: version.version,
+        permissions,
+        daemon: daemonStatus,
+        platform: process.platform,
+        arch: process.arch,
+    };
+    return { data: result, exitCode: 0 };
+});

package/dist-cjs/src/cli/output.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOutput = formatOutput;
+exports.wrapBoundary = wrapBoundary;
+exports.truncateOutput = truncateOutput;
+const crypto_1 = require("crypto");
+// Format output — text mode is default, --json for JSON
+function formatOutput(data, textMode) {
+    if (textMode) {
+        return formatText(data);
+    }
+    return JSON.stringify(data, null, 2);
+}
+// Human-readable text formatting
+function formatText(data) {
+    if (data === null || data === undefined) {
+        return '';
+    }
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (typeof data === 'boolean' || typeof data === 'number') {
+        return String(data);
+    }
+    if (Array.isArray(data)) {
+        return data.map(item => formatText(item)).join('\n');
+    }
+    if (typeof data === 'object') {
+        const obj = data;
+        // Snapshot result — format as tree
+        if ('snapshot_id' in obj && 'elements' in obj) {
+            return formatSnapshotText(obj);
+        }
+        // Windows list
+        if ('windows' in obj && Array.isArray(obj.windows)) {
+            return formatWindowsList(obj.windows);
+        }
+        // Apps list
+        if ('apps' in obj && Array.isArray(obj.apps)) {
+            return formatAppsList(obj.apps);
+        }
+        // Find results
+        if ('elements' in obj && Array.isArray(obj.elements) && !('snapshot_id' in obj)) {
+            return formatFindResults(obj.elements);
+        }
+        // Dialog detection
+        if ('found' in obj && 'dialog' in obj) {
+            return formatDialogResult(obj);
+        }
+        // Batch results
+        if ('results' in obj && Array.isArray(obj.results) && 'total' in obj) {
+            return formatBatchResults(obj);
+        }
+        // Diff/changed
+        if ('changed' in obj && typeof obj.changed === 'boolean') {
+            return formatDiffResult(obj);
+        }
+        // Menu list
+        if ('items' in obj && Array.isArray(obj.items)) {
+            return formatMenuItems(obj.items, obj.menu);
+        }
+        // Screenshot
+        if ('path' in obj && typeof obj.path === 'string' && ('width' in obj || 'ok' in obj)) {
+            return formatScreenshot(obj);
+        }
+        // Displays
+        if ('displays' in obj && Array.isArray(obj.displays)) {
+            return formatDisplays(obj.displays);
+        }
+        // Permissions
+        if ('accessibility' in obj && 'screen_recording' in obj) {
+            return formatPermissions(obj);
+        }
+        // Simple ok result
+        if ('ok' in obj && Object.keys(obj).length <= 3) {
+            const extra = Object.entries(obj)
+                .filter(([k]) => k !== 'ok')
+                .map(([k, v]) => {
+                if (typeof v !== 'object' || v === null)
+                    return `${k}: ${v}`;
+                // Format nested objects as key=value pairs
+                const inner = Object.entries(v)
+                    .map(([ik, iv]) => `${ik}=${Array.isArray(iv) ? iv.join(',') : iv}`)
+                    .join(', ');
+                return `${k}: ${inner}`;
+            })
+                .join(', ');
+            return extra ? `OK (${extra})` : 'OK';
+        }
+        // Clipboard
+        if ('text' in obj && typeof obj.text === 'string' && Object.keys(obj).length <= 2) {
+            return obj.text;
+        }
+        // Generic key-value
+        return Object.entries(obj)
+            .map(([key, val]) => `${key}: ${typeof val === 'object' ? JSON.stringify(val) : val}`)
+            .join('\n');
+    }
+    return JSON.stringify(data);
+}
+// Format snapshot as hierarchical tree
+function formatSnapshotText(snap) {
+    const elements = snap.elements;
+    const lines = [];
+    for (const el of elements) {
+        formatElementTree(el, 0, lines);
+    }
+    return lines.join('\n');
+}
+function formatElementTree(el, indent, lines) {
+    const prefix = '  '.repeat(indent);
+    const focusMarker = el.focused ? '*' : '';
+    const parts = [];
+    parts.push(`${focusMarker}[${el.ref}] ${capitalize(el.role)}`);
+    if (el.label)
+        parts.push(`"${el.label}"`);
+    if (el.value !== null && el.value !== undefined)
+        parts.push(`value="${truncate(String(el.value), 50)}"`);
+    const attrs = [];
+    if (el.enabled)
+        attrs.push('enabled');
+    if (!el.enabled)
+        attrs.push('disabled');
+    if (el.focused)
+        attrs.push('focused');
+    if (el.bounds) {
+        const [x, y, w, h] = el.bounds;
+        attrs.push(`${x},${y} ${w}x${h}`);
+    }
+    lines.push(`${prefix}${parts.join(' ')} (${attrs.join(', ')})`);
+    if (el.children) {
+        for (const child of el.children) {
+            formatElementTree(child, indent + 1, lines);
+        }
+    }
+}
+function formatWindowsList(windows) {
+    if (windows.length === 0)
+        return 'No windows';
+    return windows.map(w => `${w.ref || '-'} ${w.app}: "${w.title}"${w.minimized ? ' (minimized)' : ''}${w.hidden ? ' (hidden)' : ''}`).join('\n');
+}
+function formatAppsList(apps) {
+    if (apps.length === 0)
+        return 'No running apps';
+    return apps.map(a => `${a.name}${a.is_active ? ' *' : ''}${a.is_hidden ? ' (hidden)' : ''}${a.bundle_id ? ` [${a.bundle_id}]` : ''}`).join('\n');
+}
+function formatFindResults(elements) {
+    if (elements.length === 0)
+        return 'No elements found';
+    return elements.map(e => {
+        const parts = [`[${e.ref}] ${e.role}`];
+        if (e.label)
+            parts.push(`"${e.label}"`);
+        if (e.value)
+            parts.push(`value="${truncate(String(e.value), 40)}"`);
+        return parts.join(' ');
+    }).join('\n');
+}
+function formatDialogResult(obj) {
+    if (!obj.found)
+        return 'No dialog found';
+    const dialog = obj.dialog;
+    const lines = [`Dialog: ${dialog.type}`];
+    if (dialog.title)
+        lines.push(`  Title: ${dialog.title}`);
+    if (dialog.message)
+        lines.push(`  Message: ${dialog.message}`);
+    if (dialog.buttons && Array.isArray(dialog.buttons)) {
+        const btns = dialog.buttons.map(b => b.title).join(', ');
+        lines.push(`  Buttons: ${btns}`);
+    }
+    return lines.join('\n');
+}
+function formatBatchResults(obj) {
+    const results = obj.results;
+    const lines = [`Batch: ${obj.count}/${obj.total} completed${obj.ok ? '' : ' (stopped on error)'}`];
+    for (const r of results) {
+        if (r.error) {
+            lines.push(`  [${r.index}] ${r.method}: ERROR - ${r.error}`);
+        }
+        else {
+            lines.push(`  [${r.index}] ${r.method}: OK`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatDiffResult(obj) {
+    if (!obj.changed)
+        return 'No changes detected';
+    const lines = ['Changes detected'];
+    if (obj.added_count)
+        lines.push(`  Added: ${obj.added_count}`);
+    if (obj.removed_count)
+        lines.push(`  Removed: ${obj.removed_count}`);
+    if (Array.isArray(obj.added) && obj.added.length > 0) {
+        lines.push(`  Added elements: ${obj.added.length}`);
+    }
+    if (Array.isArray(obj.removed) && obj.removed.length > 0) {
+        lines.push(`  Removed elements: ${obj.removed.length}`);
+    }
+    return lines.join('\n');
+}
+function formatMenuItems(items, menuName) {
+    if (items.length === 0)
+        return menuName ? `No items in menu "${menuName}"` : 'No menus';
+    const header = menuName ? `Menu: ${menuName}` : 'Menus';
+    const lines = [header];
+    for (const item of items) {
+        const enabled = item.enabled !== false ? '' : ' (disabled)';
+        lines.push(`  ${item.title}${enabled}`);
+        if (Array.isArray(item.children)) {
+            for (const child of item.children) {
+                const cEnabled = child.enabled !== false ? '' : ' (disabled)';
+                lines.push(`    ${child.title}${cEnabled}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+function formatScreenshot(obj) {
+    const parts = [`Screenshot: ${obj.path}`];
+    if (obj.width && obj.height)
+        parts.push(`(${obj.width}x${obj.height})`);
+    return parts.join(' ');
+}
+function formatDisplays(displays) {
+    return displays.map(d => `Display ${d.id}${d.is_main ? ' (main)' : ''}: ${d.width}x${d.height} @ ${d.x},${d.y} scale=${d.scale_factor}`).join('\n');
+}
+function formatPermissions(obj) {
+    const lines = ['Permissions:'];
+    lines.push(`  Accessibility: ${obj.accessibility ? 'granted' : 'NOT GRANTED'}`);
+    lines.push(`  Screen Recording: ${obj.screen_recording ? 'granted' : 'NOT GRANTED'}`);
+    return lines.join('\n');
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function truncate(s, maxLen) {
+    if (s.length <= maxLen)
+        return s;
+    return s.slice(0, maxLen - 3) + '...';
+}
+// Content boundary wrapping
+function wrapBoundary(content) {
+    const boundary = `AC_BOUNDARY_${(0, crypto_1.randomBytes)(4).toString('hex')}`;
+    return `<<<${boundary}\n${content}\n${boundary}>>>`;
+}
+// Max-output truncation
+function truncateOutput(content, maxChars) {
+    if (content.length <= maxChars)
+        return content;
+    return content.slice(0, maxChars) + `\n... (truncated at ${maxChars} chars)`;
+}

package/dist-cjs/src/cli/parser.js

@@ -0,0 +1,128 @@
+"use strict";
+// CLI argument parser — verb-first pattern
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.parseSelector = parseSelector;
+// Commands that have subcommands
+const SUBCOMMAND_COMMANDS = new Set([
+    'daemon', 'menu', 'menubar', 'clipboard', 'mouse',
+    'record', 'config', 'permissions', 'dock', 'diff',
+    'dialog', 'alert', 'is',
+]);
+// Commands where the first positional arg looks like a subcommand
+const DIRECTION_COMMANDS = new Set(['scroll']);
+// Flag aliases
+const FLAG_ALIASES = {
+    '-i': '--interactive',
+    '-c': '--compact',
+    '-d': '--depth',
+    '-o': '--output',
+    '-t': '--threshold',
+};
+// Flags that take a value (next arg)
+const VALUE_FLAGS = new Set([
+    '--timeout', '--depth', '--app', '--pid', '--window', '--subtree',
+    '--on', '--modifiers', '--count', '--delay', '--repeat',
+    '--format', '--quality', '--output', '--threshold',
+    '--preset', '--text-match', '--role', '--attr',
+    '--max-output', '--duration', '--steps', '--to-coords',
+    '--from-coords', '--to-app', '--pixels', '--open',
+]);
+function parseArgs(argv) {
+    // Strip node and script path if present
+    const args = argv[0]?.includes('node') || argv[0]?.includes('tsx')
+        ? argv.slice(2)
+        : argv;
+    const result = {
+        command: '',
+        subcommand: null,
+        positional: [],
+        flags: {},
+    };
+    if (args.length === 0) {
+        result.command = 'help';
+        return result;
+    }
+    let i = 0;
+    // Check for global flags before command
+    while (i < args.length && args[i].startsWith('-')) {
+        const flag = args[i];
+        if (flag === '--version') {
+            result.command = 'version';
+            return result;
+        }
+        if (flag === '--help' || flag === '-h') {
+            result.command = 'help';
+            return result;
+        }
+        // Global flags
+        const resolved = FLAG_ALIASES[flag] || flag;
+        const flagName = resolved.replace(/^--/, '');
+        if (VALUE_FLAGS.has(resolved) && i + 1 < args.length) {
+            result.flags[flagName] = args[i + 1];
+            i += 2;
+        }
+        else {
+            result.flags[flagName] = true;
+            i += 1;
+        }
+    }
+    // Command
+    if (i >= args.length) {
+        result.command = 'help';
+        return result;
+    }
+    result.command = args[i];
+    i++;
+    // Subcommand (for commands that have them)
+    if (SUBCOMMAND_COMMANDS.has(result.command) && i < args.length && !args[i].startsWith('-') && !args[i].startsWith('@')) {
+        result.subcommand = args[i];
+        i++;
+    }
+    // Direction for scroll
+    if (DIRECTION_COMMANDS.has(result.command) && i < args.length && !args[i].startsWith('-') && !args[i].startsWith('@')) {
+        result.subcommand = args[i];
+        i++;
+    }
+    // Remaining args
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg.startsWith('-')) {
+            const resolved = FLAG_ALIASES[arg] || arg;
+            const flagName = resolved.replace(/^--/, '');
+            if (VALUE_FLAGS.has(resolved) && i + 1 < args.length) {
+                result.flags[flagName] = args[i + 1];
+                i += 2;
+            }
+            else if (resolved === '--interactive' || resolved === '-i') {
+                result.flags['interactive'] = true;
+                i++;
+            }
+            else if (resolved === '--compact' || resolved === '-c') {
+                result.flags['compact'] = true;
+                i++;
+            }
+            else {
+                // Boolean flag
+                result.flags[flagName] = true;
+                i++;
+            }
+        }
+        else {
+            result.positional.push(arg);
+            i++;
+        }
+    }
+    return result;
+}
+// Parse a selector: could be a ref (@b1), coordinates (100,200), or a label string
+function parseSelector(sel) {
+    if (sel.startsWith('@')) {
+        return { type: 'ref', ref: sel };
+    }
+    const coordMatch = /^(\d+),(\d+)$/.exec(sel);
+    if (coordMatch) {
+        return { type: 'coords', x: parseInt(coordMatch[1], 10), y: parseInt(coordMatch[2], 10) };
+    }
+    return { type: 'label', label: sel };
+}

package/dist-cjs/src/config.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+exports.getConfigValue = getConfigValue;
+exports.setConfigValue = setConfigValue;
+exports.resetConfig = resetConfig;
+exports.getDefaults = getDefaults;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const DEFAULTS = {
+    'default-timeout': 10000,
+    'screenshot-dir': '/tmp/agent-computer',
+    'screenshot-format': 'png',
+    retina: false,
+    'content-boundary': false,
+    'daemon-idle-timeout': 300000,
+};
+const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.config', 'agent-computer');
+const CONFIG_FILE = (0, path_1.join)(CONFIG_DIR, 'config.json');
+// Environment variable overrides
+const ENV_MAP = {
+    AC_TIMEOUT: 'default-timeout',
+    AC_SCREENSHOT_DIR: 'screenshot-dir',
+};
+function loadConfigFile() {
+    try {
+        const raw = (0, fs_1.readFileSync)(CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function loadEnvOverrides() {
+    const overrides = {};
+    for (const [envVar, configKey] of Object.entries(ENV_MAP)) {
+        const val = process.env[envVar];
+        if (val !== undefined) {
+            if (configKey) {
+                if (configKey === 'default-timeout' || configKey === 'daemon-idle-timeout') {
+                    overrides[configKey] = parseInt(val, 10);
+                }
+                else {
+                    overrides[configKey] = val;
+                }
+            }
+        }
+    }
+    // Boolean env vars
+    if (process.env.AC_JSON === '1') {
+        // This is handled at the CLI level, not config
+    }
+    if (process.env.AC_VERBOSE === '1') {
+        // This is handled at the CLI level, not config
+    }
+    return overrides;
+}
+function resolveConfig() {
+    const fileConfig = loadConfigFile();
+    const envConfig = loadEnvOverrides();
+    return { ...DEFAULTS, ...fileConfig, ...envConfig };
+}
+function getConfigValue(key) {
+    return resolveConfig()[key];
+}
+function setConfigValue(key, value) {
+    const existing = loadConfigFile();
+    existing[key] = value;
+    (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    (0, fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(existing, null, 2) + '\n');
+}
+function resetConfig() {
+    (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    (0, fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify({}, null, 2) + '\n');
+}
+function getDefaults() {
+    return { ...DEFAULTS };
+}