codymaster 5.2.0 → 7.0.1

package/dist/agent/opencode.js

@@ -0,0 +1,205 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenCodeBackend = void 0;
+const child_process_1 = require("child_process");
+class AsyncIterableEmitter {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.done = false;
+    }
+    emit(value) {
+        if (this.done)
+            return;
+        const resolver = this.resolvers.shift();
+        if (resolver) {
+            resolver({ value, done: false });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    close() {
+        this.done = true;
+        while (this.resolvers.length > 0) {
+            this.resolvers.shift()({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                }
+                if (this.done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}
+function spawnTextProcess(opts) {
+    const mergedEnv = Object.assign(Object.assign({}, process.env), opts.env);
+    const child = (0, child_process_1.spawn)(opts.command, opts.args, {
+        cwd: opts.cwd,
+        env: mergedEnv,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const emitter = new AsyncIterableEmitter();
+    let timeoutTimer;
+    if (opts.timeoutMs) {
+        timeoutTimer = setTimeout(() => {
+            child.kill('SIGKILL');
+        }, opts.timeoutMs);
+    }
+    let stdoutBuffer = '';
+    child.stdout.on('data', (chunk) => {
+        stdoutBuffer += chunk.toString('utf8');
+        const lines = stdoutBuffer.split('\n');
+        stdoutBuffer = lines.pop();
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed) {
+                emitter.emit({ type: 'text', content: trimmed });
+            }
+        }
+    });
+    child.on('exit', () => {
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
+        if (stdoutBuffer.trim()) {
+            emitter.emit({ type: 'text', content: stdoutBuffer.trim() });
+        }
+        emitter.close();
+    });
+    child.on('error', () => {
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
+        emitter.close();
+    });
+    return {
+        messages: emitter,
+        cancel: () => __awaiter(this, void 0, void 0, function* () {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            try {
+                child.kill('SIGTERM');
+                yield new Promise((resolve) => {
+                    const grace = setTimeout(() => {
+                        child.kill('SIGKILL');
+                        resolve();
+                    }, 5000);
+                    child.on('exit', () => {
+                        clearTimeout(grace);
+                        resolve();
+                    });
+                });
+            }
+            catch (_a) {
+                // already dead
+            }
+        }),
+    };
+}
+function collectResult(proc) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        let output = '';
+        let lastError;
+        let status = 'completed';
+        (() => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            try {
+                try {
+                    for (var _d = true, _e = __asyncValues(proc.messages), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const msg = _c;
+                        if (msg.type === 'text') {
+                            output += msg.content + '\n';
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (err) {
+                status = 'failed';
+                lastError = err instanceof Error ? err.message : String(err);
+            }
+            resolve({
+                status,
+                output: output.trim(),
+                error: lastError,
+                durationMs: Date.now() - start,
+            });
+        }))();
+    });
+}
+class OpenCodeBackend {
+    constructor() {
+        this.name = 'opencode';
+    }
+    detectVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (0, child_process_1.execFileSync)('opencode', ['--version'], {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                }).trim();
+            }
+            catch (_a) {
+                return 'unknown';
+            }
+        });
+    }
+    execute(prompt, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = ['run'];
+            if (opts.model)
+                args.push('--model', opts.model);
+            if (opts.customArgs)
+                args.push(...opts.customArgs);
+            args.push(prompt);
+            const proc = spawnTextProcess({
+                command: 'opencode',
+                args,
+                cwd: opts.cwd,
+                env: opts.customEnv,
+                timeoutMs: opts.timeoutMs,
+            });
+            const messages = proc.messages;
+            const result = collectResult(proc);
+            return {
+                messages,
+                result,
+                cancel: () => proc.cancel(),
+            };
+        });
+    }
+}
+exports.OpenCodeBackend = OpenCodeBackend;

package/dist/agent/spawn-helper.js

@@ -0,0 +1,237 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnProcess = spawnProcess;
+exports.getStderr = getStderr;
+const child_process_1 = require("child_process");
+const events_1 = require("events");
+const STDERR_RING_BUFFER_SIZE = 64 * 1024; // 64KB
+const CANCEL_SIGTERM_GRACE_MS = 5000;
+class RingBuffer {
+    constructor() {
+        this.buf = Buffer.alloc(STDERR_RING_BUFFER_SIZE);
+        this.writePos = 0;
+        this.full = false;
+    }
+    append(chunk) {
+        const data = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        for (let i = 0; i < data.length; i++) {
+            this.buf[this.writePos] = data[i];
+            this.writePos = (this.writePos + 1) % STDERR_RING_BUFFER_SIZE;
+            if (this.writePos === 0)
+                this.full = true;
+        }
+    }
+    toString() {
+        if (!this.full) {
+            return this.buf.subarray(0, this.writePos).toString('utf8');
+        }
+        const tail = this.buf.subarray(this.writePos).toString('utf8');
+        const head = this.buf.subarray(0, this.writePos).toString('utf8');
+        return tail + head;
+    }
+}
+class AsyncIterableEmitter {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.done = false;
+    }
+    emit(value) {
+        if (this.done)
+            return;
+        const resolver = this.resolvers.shift();
+        if (resolver) {
+            resolver({ value, done: false });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    close() {
+        this.done = true;
+        while (this.resolvers.length > 0) {
+            this.resolvers.shift()({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                }
+                if (this.done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}
+function spawnProcess(opts) {
+    var _a;
+    const mergedEnv = Object.assign(Object.assign({}, process.env), opts.env);
+    const child = (0, child_process_1.spawn)(opts.command, opts.args, {
+        cwd: opts.cwd,
+        env: mergedEnv,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: true,
+    });
+    const pgid = (_a = child.pid) !== null && _a !== void 0 ? _a : 0;
+    const emitter = new events_1.EventEmitter();
+    const messageIterable = new AsyncIterableEmitter();
+    const stderrRing = new RingBuffer();
+    let lastMessageTime = Date.now();
+    let inactivityTimer;
+    let timeoutTimer;
+    // Line parsing from stdout
+    const isTextMode = opts.outputFormat === 'text';
+    let stdoutBuffer = '';
+    child.stdout.on('data', (chunk) => {
+        stdoutBuffer += chunk.toString('utf8');
+        const lines = stdoutBuffer.split('\n');
+        stdoutBuffer = lines.pop();
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            if (isTextMode) {
+                const msg = { type: 'text', content: trimmed };
+                lastMessageTime = Date.now();
+                emitter.emit('message', msg);
+                messageIterable.emit(msg);
+            }
+            else {
+                try {
+                    const msg = JSON.parse(trimmed);
+                    lastMessageTime = Date.now();
+                    emitter.emit('message', msg);
+                    messageIterable.emit(msg);
+                }
+                catch (_a) {
+                    // skip non-JSON lines
+                }
+            }
+        }
+    });
+    // stderr ring buffer
+    child.stderr.on('data', (chunk) => {
+        stderrRing.append(chunk);
+    });
+    // Inactivity watchdog
+    function resetInactivityWatchdog() {
+        if (inactivityTimer)
+            clearTimeout(inactivityTimer);
+        if (!opts.semanticInactivityMs)
+            return;
+        inactivityTimer = setTimeout(() => {
+            const elapsed = Date.now() - lastMessageTime;
+            if (elapsed >= opts.semanticInactivityMs) {
+                killProcess();
+            }
+        }, opts.semanticInactivityMs);
+    }
+    // Process timeout
+    if (opts.timeoutMs) {
+        timeoutTimer = setTimeout(() => {
+            killProcess();
+        }, opts.timeoutMs);
+    }
+    function clearTimers() {
+        if (inactivityTimer)
+            clearTimeout(inactivityTimer);
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
+    }
+    function killProcess() {
+        clearTimers();
+        return new Promise((resolve) => {
+            try {
+                if (pgid > 0) {
+                    process.kill(-pgid, 'SIGKILL');
+                }
+                else if (child.pid) {
+                    child.kill('SIGKILL');
+                }
+            }
+            catch (_a) {
+                // process may already be dead
+            }
+            resolve();
+        });
+    }
+    child.on('exit', () => {
+        clearTimers();
+        messageIterable.close();
+    });
+    child.on('error', () => {
+        clearTimers();
+        messageIterable.close();
+    });
+    // Start inactivity watchdog
+    resetInactivityWatchdog();
+    // Listen for messages to reset watchdog
+    emitter.on('message', () => {
+        resetInactivityWatchdog();
+    });
+    function cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            clearTimers();
+            // Graceful cancel: SIGTERM -> wait 5s -> SIGKILL
+            try {
+                if (pgid > 0) {
+                    process.kill(-pgid, 'SIGTERM');
+                }
+                else if (child.pid) {
+                    child.kill('SIGTERM');
+                }
+            }
+            catch (_a) {
+                // process may already be dead
+                return;
+            }
+            yield new Promise((resolve) => {
+                const graceTimer = setTimeout(() => {
+                    try {
+                        if (pgid > 0) {
+                            process.kill(-pgid, 'SIGKILL');
+                        }
+                        else if (child.pid) {
+                            child.kill('SIGKILL');
+                        }
+                    }
+                    catch (_a) {
+                        // ignore
+                    }
+                    resolve();
+                }, CANCEL_SIGTERM_GRACE_MS);
+                child.on('exit', () => {
+                    clearTimeout(graceTimer);
+                    resolve();
+                });
+            });
+        });
+    }
+    return {
+        child,
+        pgid,
+        messages: messageIterable,
+        cancel,
+        kill: killProcess,
+    };
+}
+function getStderr(child) {
+    // This is a helper to retrieve stderr from a ring buffer if attached
+    // In practice, users should capture stderr via the ring buffer instance
+    return '';
+}

package/dist/agent/version.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectVersion = detectVersion;
+exports.checkMinVersion = checkMinVersion;
+const child_process_1 = require("child_process");
+function detectVersion(command) {
+    try {
+        return (0, child_process_1.execFileSync)(command, ['--version'], { encoding: 'utf8', timeout: 5000 }).trim();
+    }
+    catch (_a) {
+        return 'unknown';
+    }
+}
+function checkMinVersion(version, minVersion) {
+    const parse = (v) => v.split('.').map(Number);
+    const a = parse(version);
+    const b = parse(minVersion);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] || 0) > (b[i] || 0))
+            return true;
+        if ((a[i] || 0) < (b[i] || 0))
+            return false;
+    }
+    return true;
+}

package/dist/browse/adapter-factory.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * AdapterFactory — Auto-detect and select the best available browser adapter.
+ * Priority: agent-browser → Playwright (fallback).
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdapter = createAdapter;
+exports.checkEngines = checkEngines;
+const agent_browser_adapter_1 = require("./adapters/agent-browser-adapter");
+const playwright_adapter_1 = require("./adapters/playwright-adapter");
+/**
+ * Create the best available adapter.
+ * @param preferred - 'auto' (default), 'agent-browser', or 'playwright'
+ */
+function createAdapter() {
+    return __awaiter(this, arguments, void 0, function* (preferred = 'auto') {
+        // Explicit choice
+        if (preferred === 'playwright') {
+            const pw = new playwright_adapter_1.PlaywrightAdapter();
+            if (!(yield pw.isAvailable())) {
+                throw new Error('Playwright is not available. Run: npx playwright install chromium');
+            }
+            return { adapter: pw, engine: 'playwright', fallback: false };
+        }
+        if (preferred === 'agent-browser') {
+            const ab = new agent_browser_adapter_1.AgentBrowserAdapter();
+            if (!(yield ab.isAvailable())) {
+                throw new Error('agent-browser is not available. Run: npm i -g agent-browser && agent-browser install');
+            }
+            return { adapter: ab, engine: 'agent-browser', fallback: false };
+        }
+        // Auto: try agent-browser first, fallback to playwright
+        const ab = new agent_browser_adapter_1.AgentBrowserAdapter();
+        if (yield ab.isAvailable()) {
+            return { adapter: ab, engine: 'agent-browser', fallback: false };
+        }
+        const pw = new playwright_adapter_1.PlaywrightAdapter();
+        if (yield pw.isAvailable()) {
+            console.log('[cm-browse] agent-browser not found, falling back to Playwright');
+            return { adapter: pw, engine: 'playwright', fallback: true };
+        }
+        throw new Error('No browser engine available. Install one:\n' +
+            '  npm i -g agent-browser && agent-browser install\n' +
+            '  npx playwright install chromium');
+    });
+}
+/**
+ * Check which engines are available without creating adapters.
+ */
+function checkEngines() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ab = new agent_browser_adapter_1.AgentBrowserAdapter();
+        const pw = new playwright_adapter_1.PlaywrightAdapter();
+        const [abAvail, pwAvail] = yield Promise.all([ab.isAvailable(), pw.isAvailable()]);
+        return {
+            'agent-browser': abAvail,
+            playwright: pwAvail,
+        };
+    });
+}