scalix 0.0.1 → 1.1.0

package/dist/tools.js

@@ -0,0 +1,380 @@
+import { tool } from './tool-helper.js';
+import { z } from 'zod';
+import { exec, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { safeEvaluate } from './safe-math.js';
+import { sandboxPath, isBlockedCommand, detectInjection, sanitizeEnvForCommand, getShellInfo } from './sandbox.js';
+import { DEFAULT_LIMITS } from './settings.js';
+import { TOOL_DEFAULTS, BINARY_DETECT_BUFFER_SIZE } from './constants.js';
+import { computeDiff, formatDiff } from './diff.js';
+let _limits = DEFAULT_LIMITS;
+export function setToolLimits(limits) { _limits = limits; }
+const execAsync = promisify(exec);
+let persistentCwd = process.cwd();
+export function getPersistentCwd() { return persistentCwd; }
+export function setPersistentCwd(dir) { persistentCwd = dir; }
+export function resetPersistentCwd() { persistentCwd = process.cwd(); }
+export const backgroundProcesses = new Map();
+export const timeTool = tool({
+    name: 'get_current_time',
+    description: 'Get the current date and time',
+    inputSchema: z.object({
+        timezone: z.string().max(100).optional().describe('Timezone (e.g., "UTC", "America/New_York")')
+    }),
+    execute: async ({ timezone }) => {
+        const tz = timezone || 'UTC';
+        try {
+            return {
+                time: new Date().toLocaleString('en-US', { timeZone: tz }),
+                timezone: tz,
+            };
+        }
+        catch {
+            return { error: `Invalid timezone: "${tz}". Use IANA names like "America/New_York" or "UTC".` };
+        }
+    }
+});
+export const calculatorTool = tool({
+    name: 'calculate',
+    description: 'Perform mathematical calculations. Supports +, -, *, /, %, ^, parentheses, and functions (sqrt, abs, sin, cos, tan, log, floor, ceil, round, min, max, pow, pi, e)',
+    inputSchema: z.object({
+        expression: z.string().max(1000).describe('Math expression (e.g., "2 + 2", "sqrt(16)")')
+    }),
+    execute: async ({ expression }) => {
+        try {
+            const result = safeEvaluate(expression);
+            return { expression, result };
+        }
+        catch (err) {
+            return { expression, error: err.message };
+        }
+    }
+});
+// Extract cd target from a command to persist working directory
+function extractCdTarget(command) {
+    const match = command.match(/^\s*cd\s+("([^"]+)"|'([^']+)'|(\S+))\s*(&&|;|$)/);
+    if (match)
+        return match[2] || match[3] || match[4] || null;
+    return null;
+}
+export const runCommandTool = tool({
+    name: 'run_command',
+    description: 'Run a shell command using the system shell (bash/zsh on Unix, PowerShell/cmd on Windows). Working directory persists between calls. Supports background execution and configurable timeout.',
+    inputSchema: z.object({
+        command: z.string().max(10000).describe('The command to run'),
+        description: z.string().max(500).optional().describe('Short description of what the command does'),
+        timeout: z.number().max(TOOL_DEFAULTS.maxCommandTimeoutMs).optional().describe(`Timeout in ms (default ${TOOL_DEFAULTS.commandTimeoutMs}, max ${TOOL_DEFAULTS.maxCommandTimeoutMs})`),
+        cwd: z.string().max(500).optional().describe('Working directory override (relative to workspace root)'),
+        run_in_background: z.boolean().optional().describe('Run command in background and return PID immediately'),
+    }),
+    execute: async ({ command, timeout, cwd, run_in_background: runInBg }) => {
+        if (isBlockedCommand(command)) {
+            return { error: 'Command blocked: matches a destructive pattern', exitCode: -1 };
+        }
+        const injection = detectInjection(command);
+        if (injection) {
+            return { error: `Command blocked: ${injection}`, exitCode: -1, requiresReview: true };
+        }
+        // Resolve working directory: explicit cwd > persistent cwd > process cwd
+        let workingDir;
+        if (cwd) {
+            try {
+                workingDir = sandboxPath(cwd);
+            }
+            catch (err) {
+                return { error: `Invalid working directory: ${err.message}`, exitCode: -1 };
+            }
+        }
+        else {
+            workingDir = persistentCwd;
+        }
+        const shell = getShellInfo();
+        if (runInBg) {
+            const child = spawn(shell.path, [...shell.args, command], {
+                detached: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: sanitizeEnvForCommand(),
+                cwd: workingDir,
+            });
+            if (!child.pid) {
+                return { error: 'Failed to spawn background process: no PID assigned', exitCode: -1 };
+            }
+            const pid = child.pid;
+            const entry = {
+                pid,
+                command,
+                stdout: '',
+                stderr: '',
+                exitCode: null,
+                startedAt: Date.now(),
+                lastRead: 0,
+            };
+            child.stdout?.on('data', (data) => {
+                const chunk = data.toString();
+                if (entry.stdout.length + chunk.length <= _limits.bgBufferMax) {
+                    entry.stdout += chunk;
+                }
+                else if (entry.stdout.length < _limits.bgBufferMax) {
+                    entry.stdout += chunk.slice(0, _limits.bgBufferMax - entry.stdout.length);
+                }
+            });
+            child.stdout?.on('error', () => { });
+            child.stderr?.on('data', (data) => {
+                const chunk = data.toString();
+                if (entry.stderr.length + chunk.length <= _limits.bgBufferMax) {
+                    entry.stderr += chunk;
+                }
+                else if (entry.stderr.length < _limits.bgBufferMax) {
+                    entry.stderr += chunk.slice(0, _limits.bgBufferMax - entry.stderr.length);
+                }
+            });
+            child.stderr?.on('error', () => { });
+            child.on('error', (err) => {
+                entry.exitCode = -1;
+                const errMsg = `\nProcess error: ${err.message}`;
+                if (entry.stderr.length + errMsg.length <= _limits.bgBufferMax) {
+                    entry.stderr += errMsg;
+                }
+                else if (entry.stderr.length < _limits.bgBufferMax) {
+                    entry.stderr += errMsg.slice(0, _limits.bgBufferMax - entry.stderr.length);
+                }
+            });
+            child.on('close', (code) => {
+                entry.exitCode = code ?? 1;
+                setTimeout(() => { backgroundProcesses.delete(pid); }, _limits.bgCleanupMs).unref();
+            });
+            backgroundProcesses.set(pid, entry);
+            child.unref();
+            return { pid, message: `Command started in background (PID: ${pid}). Use the monitor tool to check output.` };
+        }
+        // For cd-only commands, update persistent cwd directly
+        const cdTarget = extractCdTarget(command);
+        if (cdTarget && command.trim().match(/^cd\s/)) {
+            try {
+                const resolved = path.resolve(workingDir, cdTarget);
+                await fs.stat(resolved);
+                persistentCwd = resolved;
+                return { stdout: '', stderr: '', exitCode: 0, cwd: persistentCwd };
+            }
+            catch (err) {
+                return { error: `cd: ${cdTarget}: ${err.code === 'ENOENT' ? 'No such file or directory' : err.message}`, exitCode: 1 };
+            }
+        }
+        let fullCommand = command;
+        const CWD_MARKER = '__SCALIX_CWD_PROBE__';
+        if (cdTarget && !command.trim().match(/^cd\s+\S+\s*$/)) {
+            const cwdProbe = shell.type === 'cmd'
+                ? `${command} && echo ${CWD_MARKER} && cd`
+                : shell.type === 'pwsh'
+                    ? `${command}; Write-Host '${CWD_MARKER}'; Get-Location | Select-Object -ExpandProperty Path`
+                    : `${command} && echo '${CWD_MARKER}' && pwd`;
+            fullCommand = cwdProbe;
+        }
+        try {
+            const { stdout, stderr } = await execAsync(fullCommand, {
+                timeout: timeout ?? _limits.commandTimeoutMs,
+                maxBuffer: TOOL_DEFAULTS.maxExecBufferDefault,
+                env: sanitizeEnvForCommand(),
+                cwd: workingDir,
+                shell: shell.path,
+            });
+            if (cdTarget && fullCommand !== command) {
+                const markerIdx = stdout.indexOf(CWD_MARKER);
+                if (markerIdx !== -1) {
+                    const beforeMarker = stdout.slice(0, markerIdx).trimEnd();
+                    const afterMarker = stdout.slice(markerIdx + CWD_MARKER.length).trim();
+                    const newCwd = afterMarker.split('\n')[0]?.trim();
+                    if (newCwd && path.isAbsolute(newCwd)) {
+                        persistentCwd = newCwd;
+                        return { stdout: beforeMarker, stderr, exitCode: 0, cwd: persistentCwd };
+                    }
+                }
+            }
+            return { stdout, stderr, exitCode: 0, cwd: workingDir };
+        }
+        catch (error) {
+            const result = { stdout: error.stdout, stderr: error.stderr, exitCode: error.code || 1, error: error.message };
+            result.autoFixHint = 'The command failed. Analyze the error output above and suggest how to fix it. If it is a build/test/lint error, read the relevant file and fix the issue.';
+            return result;
+        }
+    }
+});
+export const readFileTool = tool({
+    name: 'read_file',
+    description: 'Read a local file with line numbers (lineN<tab>content). Returns the full file contents. Use read_file_lines if you only need a specific range.',
+    inputSchema: z.object({
+        filePath: z.string().max(500).describe('Relative path to the file'),
+        maxLines: z.number().min(1).optional().describe('Optional: limit output to first N lines'),
+    }),
+    execute: async ({ filePath, maxLines }) => {
+        try {
+            const safePath = sandboxPath(filePath);
+            const stat = await fs.stat(safePath);
+            if (stat.size > _limits.readFileMaxSize)
+                return { error: `File too large (${Math.round(stat.size / 1024)}KB, max ${Math.round(_limits.readFileMaxSize / 1024)}KB). Use read_file_lines to read specific sections.` };
+            const fd = await fs.open(safePath, 'r');
+            const header = Buffer.alloc(BINARY_DETECT_BUFFER_SIZE);
+            try {
+                await fd.read(header, 0, Math.min(BINARY_DETECT_BUFFER_SIZE, stat.size), 0);
+            }
+            finally {
+                await fd.close();
+            }
+            if (header.slice(0, Math.min(BINARY_DETECT_BUFFER_SIZE, stat.size)).includes(0x00)) {
+                return { error: 'File appears to be binary. Use a specialized tool to inspect binary files.' };
+            }
+            const content = await fs.readFile(safePath, 'utf-8');
+            const lines = content.split('\n');
+            if (maxLines && lines.length > maxLines) {
+                const numbered = lines.slice(0, maxLines).map((line, i) => `${i + 1}\t${line}`).join('\n');
+                return {
+                    content: numbered,
+                    totalLines: lines.length,
+                    truncatedAt: maxLines,
+                    hint: `Showing first ${maxLines} of ${lines.length} lines.`,
+                };
+            }
+            const numbered = lines.map((line, i) => `${i + 1}\t${line}`).join('\n');
+            return { content: numbered, totalLines: lines.length };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    }
+});
+export const writeFileTool = tool({
+    name: 'write_file',
+    description: 'Write text content to a local file (sandboxed to working directory). Requires user confirmation.',
+    inputSchema: z.object({
+        filePath: z.string().max(500).describe('Relative path to the file'),
+        content: z.string().max(1024 * 1024).describe('The entire text content to write')
+    }),
+    execute: async ({ filePath, content }) => {
+        try {
+            const safePath = sandboxPath(filePath);
+            let existed = false;
+            let oldContent = '';
+            try {
+                oldContent = await fs.readFile(safePath, 'utf-8');
+                existed = true;
+            }
+            catch { }
+            await fs.mkdir(path.dirname(safePath), { recursive: true });
+            await fs.writeFile(safePath, content, 'utf-8');
+            let diff;
+            if (existed) {
+                const diffResult = computeDiff(oldContent, content);
+                diff = formatDiff(diffResult, filePath);
+            }
+            return {
+                success: true,
+                message: `Wrote ${content.length} bytes to ${filePath}`,
+                ...(existed ? { warning: 'File already existed and was overwritten' } : {}),
+                ...(diff ? { diff } : {}),
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+});
+export const listFilesTool = tool({
+    name: 'list_files',
+    description: 'List files and directories in a given path (sandboxed to working directory). Supports recursive listing with glob patterns.',
+    inputSchema: z.object({
+        dirPath: z.string().max(500).optional().describe('Relative path (defaults to current directory)'),
+        recursive: z.boolean().optional().describe('Recursively list files (default: false)'),
+        pattern: z.string().max(200).optional().describe('Glob pattern filter when recursive (e.g., "**/*.ts")'),
+        maxResults: z.number().max(1000).optional().describe('Max results for recursive listing (default: 200)'),
+    }),
+    execute: async ({ dirPath, recursive, pattern, maxResults }) => {
+        try {
+            const safePath = sandboxPath(dirPath || '.');
+            if (recursive) {
+                const fg = (await import('fast-glob')).default;
+                const globPattern = pattern || '**/*';
+                const files = await fg(globPattern, {
+                    cwd: safePath,
+                    ignore: ['node_modules/**', '.git/**', 'dist/**', 'coverage/**'],
+                    onlyFiles: true,
+                    stats: true,
+                    followSymbolicLinks: false,
+                });
+                const limit = maxResults ?? 200;
+                const sorted = files
+                    .sort((a, b) => (b.stats?.mtimeMs ?? 0) - (a.stats?.mtimeMs ?? 0))
+                    .slice(0, limit)
+                    .map((f) => ({
+                    name: f.path,
+                    size: f.stats?.size ?? 0,
+                    isDirectory: false,
+                }));
+                return { path: safePath, count: sorted.length, total: files.length, files: sorted };
+            }
+            const entries = await fs.readdir(safePath, { withFileTypes: true });
+            const results = await Promise.all(entries.map(async (e) => {
+                let size;
+                if (!e.isDirectory()) {
+                    try {
+                        const stat = await fs.stat(path.join(safePath, e.name));
+                        size = stat.size;
+                    }
+                    catch { }
+                }
+                return { name: e.name, isDirectory: e.isDirectory(), ...(size !== undefined ? { size } : {}) };
+            }));
+            const sorted = results.sort((a, b) => {
+                if (a.isDirectory !== b.isDirectory)
+                    return a.isDirectory ? -1 : 1;
+                return a.name.localeCompare(b.name);
+            });
+            return { path: safePath, count: sorted.length, files: sorted };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    }
+});
+export const addMcpServerTool = tool({
+    name: 'add_mcp_server',
+    description: 'Add an HTTP MCP server persistently. Requires user confirmation.',
+    inputSchema: z.object({
+        label: z.string().min(1).max(100).describe('A logical name for the MCP server'),
+        url: z.string().url().describe('The HTTP SSE URL of the MCP server')
+    }),
+    execute: async ({ label, url }) => {
+        try {
+            const mcpConfigPath = path.resolve(process.cwd(), 'mcp-services.json');
+            let config = { mcpServers: [] };
+            try {
+                if (fsSync.existsSync(mcpConfigPath)) {
+                    const parsed = JSON.parse(fsSync.readFileSync(mcpConfigPath, 'utf-8'));
+                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                        config = parsed;
+                        if (!Array.isArray(config.mcpServers))
+                            config.mcpServers = [];
+                    }
+                }
+            }
+            catch { }
+            config.mcpServers.push({ serverLabel: label, serverUrl: url });
+            await fs.writeFile(mcpConfigPath, JSON.stringify(config, null, 2), 'utf-8');
+            return { success: true, message: `Added MCP server ${label} at ${url}` };
+        }
+        catch (e) {
+            return { success: false, error: e.message };
+        }
+    }
+});
+export const defaultTools = [
+    timeTool,
+    calculatorTool,
+    runCommandTool,
+    readFileTool,
+    writeFileTool,
+    listFilesTool,
+    addMcpServerTool,
+];

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/update-checker.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { VERSION, UPDATE_DEFAULTS, USER_CONFIG_DIR } from './constants.js';
+function semverGt(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map(Number);
+    const pb = b.replace(/^v/, '').split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return true;
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+function isValidSemver(v) {
+    return /^\d+\.\d+\.\d+/.test(v.replace(/^v/, ''));
+}
+function getCacheFile() {
+    return path.join(process.env.HOME || process.env.USERPROFILE || '.', USER_CONFIG_DIR, 'update-check.json');
+}
+function readCacheSync() {
+    try {
+        const raw = readFileSync(getCacheFile(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.lastCheck === 'number' && typeof parsed.latestVersion === 'string') {
+            return parsed;
+        }
+    }
+    catch { }
+    return null;
+}
+async function writeCache(cache) {
+    const dir = path.dirname(getCacheFile());
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getCacheFile(), JSON.stringify(cache), { encoding: 'utf-8', mode: 0o600 });
+}
+export async function checkForUpdate() {
+    if (process.env.NO_UPDATE_NOTIFIER)
+        return null;
+    const cached = readCacheSync();
+    const now = Date.now();
+    if (cached && (now - cached.lastCheck) < UPDATE_DEFAULTS.checkIntervalMs) {
+        return {
+            current: VERSION,
+            latest: cached.latestVersion,
+            updateAvailable: semverGt(cached.latestVersion, VERSION),
+        };
+    }
+    try {
+        const res = await fetch(UPDATE_DEFAULTS.registryUrl, {
+            signal: AbortSignal.timeout(UPDATE_DEFAULTS.fetchTimeoutMs),
+            headers: { 'Accept': 'application/json' },
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const latest = data.version;
+        if (!latest || !isValidSemver(latest))
+            return null;
+        await writeCache({ lastCheck: now, latestVersion: latest }).catch(() => { });
+        return {
+            current: VERSION,
+            latest,
+            updateAvailable: semverGt(latest, VERSION),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function getUpdateBanner() {
+    if (process.env.NO_UPDATE_NOTIFIER)
+        return null;
+    const cached = readCacheSync();
+    if (!cached)
+        return null;
+    if (!semverGt(cached.latestVersion, VERSION))
+        return null;
+    const current = VERSION;
+    const latest = cached.latestVersion;
+    const line1 = `  Update available: ${current} → ${latest}`;
+    const line2 = `  Run /update or:`;
+    const line3 = `  npm install -g ${UPDATE_DEFAULTS.npmPackageName}@latest`;
+    const maxLen = Math.max(line1.length, line2.length, line3.length) + 2;
+    const pad = (s) => s + ' '.repeat(Math.max(0, maxLen - s.length));
+    return [
+        `╭${'─'.repeat(maxLen)}╮`,
+        `│${pad(line1)}│`,
+        `│${pad(line2)}│`,
+        `│${pad(line3)}│`,
+        `╰${'─'.repeat(maxLen)}╯`,
+    ].join('\n');
+}
+export function performUpdate() {
+    return new Promise((resolve) => {
+        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        execFile(npmCmd, ['install', '-g', `${UPDATE_DEFAULTS.npmPackageName}@latest`], {
+            timeout: 120_000,
+            env: { ...process.env },
+        }, (error, stdout, stderr) => {
+            if (error) {
+                resolve({ success: false, output: stderr || error.message });
+            }
+            else {
+                resolve({ success: true, output: stdout.trim() });
+            }
+        });
+    });
+}

package/dist/worktree.js

@@ -0,0 +1,172 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { logger } from './logger.js';
+const execFileAsync = promisify(execFile);
+const WORKTREE_DIR = '.scalix/worktrees';
+const BRANCH_PREFIX = 'scalix-agent/';
+async function isGitRepo(dir) {
+    try {
+        await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: dir });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getCurrentBranch(dir) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir });
+        return stdout.trim();
+    }
+    catch {
+        return 'HEAD';
+    }
+}
+export async function createWorktree(agentId, basePath) {
+    if (!await isGitRepo(basePath)) {
+        throw new Error('Not a git repository — worktree isolation requires git');
+    }
+    const safeName = agentId.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 40);
+    const worktreePath = path.join(basePath, WORKTREE_DIR, safeName);
+    const branch = `${BRANCH_PREFIX}${safeName}`;
+    await fs.mkdir(path.dirname(worktreePath), { recursive: true });
+    try {
+        await execFileAsync('git', ['worktree', 'add', worktreePath, '-b', branch], {
+            cwd: basePath,
+            timeout: 30_000,
+        });
+    }
+    catch (err) {
+        await fs.rm(worktreePath, { recursive: true, force: true }).catch(() => { });
+        await execFileAsync('git', ['branch', '-D', branch], { cwd: basePath }).catch(() => { });
+        throw new Error(`Failed to create worktree: ${err.message}`);
+    }
+    logger.info('Created worktree for agent', { agentId, path: worktreePath, branch });
+    return {
+        path: worktreePath,
+        branch,
+        agentId,
+        createdAt: Date.now(),
+    };
+}
+export async function removeWorktree(info, basePath) {
+    try {
+        await execFileAsync('git', ['worktree', 'remove', info.path, '--force'], {
+            cwd: basePath,
+            timeout: 30_000,
+        });
+    }
+    catch (err) {
+        logger.warn('Failed to remove worktree via git, cleaning up manually', { error: err.message });
+        try {
+            await fs.rm(info.path, { recursive: true, force: true });
+            await execFileAsync('git', ['worktree', 'prune'], { cwd: basePath, timeout: 10_000 });
+        }
+        catch {
+            // best effort
+        }
+    }
+    try {
+        await execFileAsync('git', ['branch', '-D', info.branch], {
+            cwd: basePath,
+            timeout: 10_000,
+        });
+    }
+    catch {
+        // branch may already be deleted
+    }
+    logger.info('Removed worktree', { agentId: info.agentId, path: info.path });
+}
+export async function mergeWorktree(info, basePath, targetBranch) {
+    const target = targetBranch || await getCurrentBranch(basePath);
+    // Check if worktree has any commits beyond the branch point
+    try {
+        const { stdout: logOutput } = await execFileAsync('git', ['log', `${target}..${info.branch}`, '--oneline'], { cwd: basePath, timeout: 10_000 });
+        const commits = logOutput.trim().split('\n').filter(l => l.length > 0);
+        if (commits.length === 0) {
+            return { merged: true, commitCount: 0 };
+        }
+        try {
+            await execFileAsync('git', ['merge', info.branch, '--no-edit'], {
+                cwd: basePath,
+                timeout: 30_000,
+            });
+            return { merged: true, commitCount: commits.length };
+        }
+        catch (mergeErr) {
+            // Merge conflict — abort and report
+            try {
+                await execFileAsync('git', ['merge', '--abort'], { cwd: basePath, timeout: 10_000 });
+            }
+            catch {
+                // best effort abort
+            }
+            // Get list of conflicting files
+            const { stdout: diffOutput } = await execFileAsync('git', ['diff', '--name-only', target, info.branch], { cwd: basePath, timeout: 10_000 });
+            const conflicts = diffOutput.trim().split('\n').filter(l => l.length > 0);
+            return { merged: false, conflicts, commitCount: commits.length };
+        }
+    }
+    catch {
+        return { merged: true, commitCount: 0 };
+    }
+}
+export async function listWorktrees(basePath) {
+    try {
+        const { stdout } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], {
+            cwd: basePath,
+            timeout: 10_000,
+        });
+        const worktrees = [];
+        const entries = stdout.split('\n\n');
+        for (const entry of entries) {
+            const lines = entry.trim().split('\n');
+            const worktreeLine = lines.find(l => l.startsWith('worktree '));
+            const branchLine = lines.find(l => l.startsWith('branch '));
+            if (!worktreeLine || !branchLine)
+                continue;
+            const wtPath = worktreeLine.slice('worktree '.length);
+            const fullBranch = branchLine.slice('branch '.length);
+            const branch = fullBranch.replace('refs/heads/', '');
+            if (!branch.startsWith(BRANCH_PREFIX))
+                continue;
+            const agentId = branch.slice(BRANCH_PREFIX.length);
+            worktrees.push({
+                path: wtPath,
+                branch,
+                agentId,
+                createdAt: 0, // unknown from git porcelain
+            });
+        }
+        return worktrees;
+    }
+    catch {
+        return [];
+    }
+}
+export async function cleanupStaleWorktrees(basePath, maxAgeMs = 3600_000) {
+    const worktrees = await listWorktrees(basePath);
+    let cleaned = 0;
+    for (const wt of worktrees) {
+        try {
+            const stat = await fs.stat(wt.path);
+            if (Date.now() - stat.mtimeMs > maxAgeMs) {
+                await removeWorktree(wt, basePath);
+                cleaned++;
+            }
+        }
+        catch {
+            // worktree path doesn't exist, remove reference
+            try {
+                await execFileAsync('git', ['worktree', 'prune'], { cwd: basePath, timeout: 10_000 });
+                cleaned++;
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    return cleaned;
+}