singleton-pipeline 0.4.0-beta.13 → 0.4.0-beta.14

package/dist/packages/cli/src/runners/copilot.js

@@ -0,0 +1,209 @@
+import spawn from 'cross-spawn';
+import path from 'node:path';
+import { extractText, safeJsonParse } from './_shared.js';
+const DEFAULT_TIMEOUT_MS = Number(process.env.SINGLETON_RUNNER_TIMEOUT_MS) || 10 * 60 * 1000;
+function buildPrompt(systemPrompt, userPrompt) {
+    return [
+        '<system>',
+        systemPrompt,
+        '</system>',
+        '',
+        '<user>',
+        userPrompt,
+        '</user>',
+        '',
+    ].join('\n');
+}
+function normalizeToolPath(value) {
+    return String(value || '').replaceAll('\\', '/').replace(/^\/+/, '').replace(/\/+$/, '');
+}
+function hasGlob(value) {
+    return /[*?[\]{}]/.test(value);
+}
+function looksLikeFile(value) {
+    const base = path.posix.basename(value);
+    return Boolean(path.posix.extname(value)) || base === '.env';
+}
+function toWritePattern(entry) {
+    const normalized = normalizeToolPath(entry);
+    if (!normalized)
+        return null;
+    if (hasGlob(normalized) || looksLikeFile(normalized))
+        return normalized;
+    return `${normalized}/**`;
+}
+export function buildCopilotPermissionArgs(securityPolicy = {}) {
+    const profile = securityPolicy.profile || 'workspace-write';
+    const args = [];
+    if (profile === 'dangerous') {
+        args.push('--allow-all-tools');
+    }
+    else {
+        args.push('--allow-tool=read');
+    }
+    if (profile === 'restricted-write') {
+        for (const entry of securityPolicy.allowedPaths || []) {
+            const pattern = toWritePattern(entry);
+            if (pattern)
+                args.push(`--allow-tool=write(${pattern})`);
+        }
+    }
+    else if (profile === 'workspace-write') {
+        args.push('--allow-tool=write');
+    }
+    // Copilot CLI runs in deny-by-default mode as soon as any --allow-tool is
+    // present. Agents need shell access to list/grep the codebase even when their
+    // write surface is restricted - otherwise the scout can't discover anything.
+    // read-only stays shell-less; dangerous is already covered by --allow-all-tools.
+    if (profile === 'read-only') {
+        args.push('--deny-tool=write');
+        args.push('--deny-tool=shell');
+    }
+    else {
+        if (profile !== 'dangerous')
+            args.push('--allow-tool=shell');
+        args.push('--deny-tool=shell(git push)');
+    }
+    if (profile !== 'dangerous') {
+        args.push('--deny-tool=url');
+    }
+    for (const entry of securityPolicy.blockedPaths || []) {
+        const pattern = toWritePattern(entry);
+        if (pattern)
+            args.push(`--deny-tool=write(${pattern})`);
+    }
+    args.push('--deny-tool=memory');
+    return args;
+}
+export function buildCopilotArgs({ prompt, model, runnerAgent, securityPolicy = {} } = {}) {
+    // Copilot CLI expects the user prompt as `-p <text>` arg. Passing `-p -` is
+    // interpreted as the literal string "-", not as a stdin marker, so we always
+    // inline the prompt as an argument here. Callers must keep the prompt under
+    // ~32KB on Windows; large blobs should be referenced as files on disk rather
+    // than injected inline.
+    const args = [
+        '-p',
+        prompt ?? '',
+        '--output-format',
+        'json',
+        ...buildCopilotPermissionArgs(securityPolicy),
+    ];
+    if (runnerAgent)
+        args.push('--agent', runnerAgent);
+    if (model)
+        args.push('--model', model);
+    return args;
+}
+export function summarizeCopilotEvents(events) {
+    // Copilot emits intermediate `assistant.message` events between tool calls
+    // (the model's "thinking out loud"). The final deliverable is the LAST
+    // assistant.message - concatenating them all would prepend narration noise
+    // to whatever the agent is supposed to produce as its output.
+    const assistantMessages = events.filter((event) => event.type === 'assistant.message');
+    const finalMessage = assistantMessages.at(-1);
+    const finalText = finalMessage ? extractText(finalMessage.data) : '';
+    const deltaText = events
+        .filter((event) => event.type === 'assistant.message_delta')
+        .map((event) => event.data?.deltaContent || event.data?.delta || '')
+        .filter(Boolean)
+        .join('');
+    const result = [...events].reverse().find((event) => event.type === 'result') || null;
+    const outputTokens = events.reduce((total, event) => {
+        if (event.type !== 'assistant.message')
+            return total;
+        return total + (Number(event.data?.outputTokens || 0) || 0);
+    }, 0);
+    return {
+        text: (finalText || deltaText).trim(),
+        turns: assistantMessages.length || null,
+        outputTokens: outputTokens || null,
+        premiumRequests: Number(result?.usage?.premiumRequests || 0) || null,
+        result,
+    };
+}
+export function extractCopilotErrorMessage(event) {
+    if (!event || typeof event !== 'object')
+        return '';
+    const item = event;
+    if (typeof item.error === 'string')
+        return item.error;
+    if (typeof item.message === 'string')
+        return item.message;
+    if (typeof item.error?.message === 'string')
+        return item.error.message;
+    if (typeof item.error?.data?.message === 'string')
+        return item.error.data.message;
+    if (typeof item.data?.message === 'string')
+        return item.data.message;
+    return extractText(item);
+}
+export const copilotRunner = {
+    id: 'copilot',
+    command: 'copilot',
+    async run({ cwd, systemPrompt, userPrompt, model, runnerAgent, securityPolicy, timeoutMs = DEFAULT_TIMEOUT_MS, }) {
+        // When --agent is used, Copilot loads the system prompt from .github/agents/<name>.md.
+        // We pass only the user prompt as `-p <text>`. Without --agent we inline the
+        // system prompt wrapped in <system>/<user> tags as the user prompt.
+        const prompt = runnerAgent ? userPrompt : buildPrompt(systemPrompt, userPrompt);
+        const args = buildCopilotArgs({ prompt, model, runnerAgent, securityPolicy });
+        const { events, stderr } = await new Promise((resolve, reject) => {
+            const child = spawn('copilot', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+            const stdoutChunks = [];
+            let stderrText = '';
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+                setTimeout(() => child.kill('SIGKILL'), 5000).unref();
+            }, timeoutMs);
+            child.stdout.on('data', (chunk) => stdoutChunks.push(chunk.toString()));
+            child.stderr.on('data', (chunk) => (stderrText += chunk.toString()));
+            child.on('error', (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                const stdout = stdoutChunks.join('');
+                const events = stdout
+                    .split('\n')
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .map(safeJsonParse)
+                    .filter(Boolean);
+                if (timedOut) {
+                    reject(new Error(`copilot timed out after ${Math.round(timeoutMs / 1000)}s`));
+                    return;
+                }
+                if (code !== 0) {
+                    const result = [...events].reverse().find((event) => event.type === 'result');
+                    const message = extractCopilotErrorMessage(result) || stderrText.trim() || stdout.trim() || 'unknown error';
+                    reject(new Error(`copilot exited ${code}: ${message}`));
+                    return;
+                }
+                resolve({ events, stderr: stderrText });
+            });
+        });
+        const summary = summarizeCopilotEvents(events);
+        return {
+            text: summary.text,
+            metadata: {
+                provider: 'copilot',
+                model: model || null,
+                runnerAgent: runnerAgent || null,
+                turns: summary.turns,
+                costUsd: null,
+                tokens: {
+                    input: null,
+                    output: summary.outputTokens,
+                },
+                premiumRequests: summary.premiumRequests,
+                raw: {
+                    events,
+                    stderr,
+                    result: summary.result,
+                },
+            },
+        };
+    },
+};

package/dist/packages/cli/src/runners/index.js

@@ -0,0 +1,18 @@
+import { claudeRunner } from './claude.js';
+import { codexRunner } from './codex.js';
+import { copilotRunner } from './copilot.js';
+import { opencodeRunner } from './opencode.js';
+const RUNNERS = {
+    claude: claudeRunner,
+    codex: codexRunner,
+    copilot: copilotRunner,
+    opencode: opencodeRunner,
+};
+export function getRunner(provider = 'claude') {
+    const key = String(provider || 'claude').trim().toLowerCase();
+    const runner = RUNNERS[key];
+    if (!runner) {
+        throw new Error(`Unknown provider: ${provider}`);
+    }
+    return runner;
+}

package/dist/packages/cli/src/runners/opencode.js

@@ -0,0 +1,240 @@
+import spawn from 'cross-spawn';
+import path from 'node:path';
+import { extractText, findCostUsd, findUsage, safeJsonParse } from './_shared.js';
+const DEFAULT_TIMEOUT_MS = Number(process.env.SINGLETON_RUNNER_TIMEOUT_MS) || 10 * 60 * 1000;
+function buildPrompt(systemPrompt, userPrompt) {
+    return [
+        '<system>',
+        systemPrompt,
+        '</system>',
+        '',
+        '<user>',
+        userPrompt,
+        '</user>',
+        '',
+    ].join('\n');
+}
+function isAssistantEvent(event) {
+    const type = String(event?.type || '').toLowerCase();
+    const role = String(event?.role || event?.data?.role || event?.message?.role || '').toLowerCase();
+    return role === 'assistant' || type === 'text' || type.includes('assistant') || type.includes('message');
+}
+export function extractOpenCodeErrorMessage(event) {
+    if (!event || typeof event !== 'object')
+        return '';
+    const item = event;
+    if (typeof item.error === 'string')
+        return item.error;
+    if (typeof item.message === 'string')
+        return item.message;
+    if (typeof item.error?.message === 'string')
+        return item.error.message;
+    if (typeof item.error?.data?.message === 'string')
+        return item.error.data.message;
+    if (typeof item.data?.message === 'string')
+        return item.data.message;
+    return extractText(item);
+}
+function normalizePermissionPath(value) {
+    return String(value || '').replaceAll('\\', '/').replace(/^\/+/, '').replace(/\/+$/, '');
+}
+function hasGlob(value) {
+    return /[*?[\]{}]/.test(value);
+}
+function looksLikeFile(value) {
+    const base = path.posix.basename(value);
+    return Boolean(path.posix.extname(value)) || base === '.env';
+}
+function toOpenCodePathPattern(entry) {
+    const normalized = normalizePermissionPath(entry);
+    if (!normalized)
+        return null;
+    if (hasGlob(normalized) || looksLikeFile(normalized))
+        return normalized;
+    return `${normalized}/**`;
+}
+function buildEditPermission(securityPolicy) {
+    const profile = securityPolicy?.profile || 'workspace-write';
+    const blocked = (securityPolicy?.blockedPaths || [])
+        .map(toOpenCodePathPattern)
+        .filter((pattern) => typeof pattern === 'string');
+    if (profile === 'read-only')
+        return 'deny';
+    if (profile === 'dangerous')
+        return 'allow';
+    if (profile === 'restricted-write') {
+        const edit = { '*': 'deny' };
+        for (const entry of securityPolicy?.allowedPaths || []) {
+            const pattern = toOpenCodePathPattern(entry);
+            if (pattern)
+                edit[pattern] = 'allow';
+        }
+        for (const pattern of blocked)
+            edit[pattern] = 'deny';
+        return edit;
+    }
+    if (blocked.length) {
+        const edit = { '*': 'allow' };
+        for (const pattern of blocked)
+            edit[pattern] = 'deny';
+        return edit;
+    }
+    return 'allow';
+}
+export function buildOpenCodePermissionConfig(securityPolicy = {}) {
+    const profile = securityPolicy.profile || 'workspace-write';
+    if (profile === 'dangerous') {
+        return { permission: 'allow' };
+    }
+    const permission = {
+        read: 'allow',
+        glob: 'allow',
+        grep: 'allow',
+        edit: buildEditPermission(securityPolicy),
+        bash: profile === 'read-only' ? 'deny' : 'ask',
+        task: 'deny',
+        webfetch: 'deny',
+        websearch: 'deny',
+        external_directory: 'deny',
+        doom_loop: 'ask',
+    };
+    return { permission };
+}
+export function buildOpenCodeConfigContent({ securityPolicy = {}, runnerAgent = '', existingContent = '', } = {}) {
+    let config = {};
+    if (existingContent) {
+        try {
+            config = JSON.parse(existingContent);
+        }
+        catch {
+            config = {};
+        }
+    }
+    const permissionConfig = buildOpenCodePermissionConfig(securityPolicy);
+    config = {
+        ...config,
+        ...permissionConfig,
+    };
+    if (runnerAgent && permissionConfig.permission && typeof permissionConfig.permission === 'object') {
+        config.agent = {
+            ...(config.agent || {}),
+            [runnerAgent]: {
+                ...(config.agent?.[runnerAgent] || {}),
+                permission: permissionConfig.permission,
+            },
+        };
+    }
+    return JSON.stringify(config);
+}
+export function buildOpenCodeEnv({ securityPolicy = {}, runnerAgent = '', baseEnv = process.env, } = {}) {
+    // Note: we deliberately do NOT redirect XDG_DATA_HOME here. OpenCode stores
+    // provider auth under XDG_DATA_HOME, so isolating it strips API credentials
+    // from the spawned process. Security is enforced via OPENCODE_CONFIG_CONTENT
+    // and Singleton's post-run snapshot diff.
+    return {
+        ...baseEnv,
+        OPENCODE_CONFIG_CONTENT: buildOpenCodeConfigContent({
+            securityPolicy,
+            runnerAgent: runnerAgent || '',
+            existingContent: baseEnv.OPENCODE_CONFIG_CONTENT || '',
+        }),
+    };
+}
+export function buildOpenCodeArgs({ prompt, model, runnerAgent, securityPolicy = {} }) {
+    const args = ['run', '--format', 'json'];
+    if (model)
+        args.push('--model', model);
+    if (runnerAgent)
+        args.push('--agent', runnerAgent);
+    if (securityPolicy.profile === 'dangerous')
+        args.push('--dangerously-skip-permissions');
+    args.push(prompt);
+    return args;
+}
+export function summarizeOpenCodeEvents(events, stdout = '') {
+    const assistantText = events
+        .filter(isAssistantEvent)
+        .map((event) => extractText(event))
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+    const usage = [...events].reverse().map(findUsage).find(Boolean) || null;
+    const costUsd = [...events].reverse().map(findCostUsd).find((value) => value !== null) ?? null;
+    const turns = events.filter(isAssistantEvent).length || null;
+    return {
+        text: assistantText || stdout.trim(),
+        turns,
+        costUsd,
+        tokens: usage,
+    };
+}
+export const opencodeRunner = {
+    id: 'opencode',
+    command: 'opencode',
+    async run({ cwd, systemPrompt, userPrompt, model, runnerAgent, securityPolicy, timeoutMs = DEFAULT_TIMEOUT_MS, }) {
+        const prompt = buildPrompt(systemPrompt, userPrompt);
+        const args = buildOpenCodeArgs({ prompt, model, runnerAgent, securityPolicy });
+        const env = buildOpenCodeEnv({
+            securityPolicy,
+            runnerAgent,
+        });
+        const runResult = await new Promise((resolve, reject) => {
+            const child = spawn('opencode', args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+            const stdoutChunks = [];
+            let stderrText = '';
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+                setTimeout(() => child.kill('SIGKILL'), 5000).unref();
+            }, timeoutMs);
+            child.stdout.on('data', (chunk) => stdoutChunks.push(chunk.toString()));
+            child.stderr.on('data', (chunk) => (stderrText += chunk.toString()));
+            child.on('error', (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                const stdout = stdoutChunks.join('');
+                const events = stdout
+                    .split('\n')
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .map(safeJsonParse)
+                    .filter(Boolean);
+                if (timedOut) {
+                    reject(new Error(`opencode timed out after ${Math.round(timeoutMs / 1000)}s`));
+                    return;
+                }
+                const errorEvent = [...events].reverse().find((event) => event.type === 'error' || event.error);
+                if (errorEvent) {
+                    const message = extractOpenCodeErrorMessage(errorEvent) || stderrText.trim() || stdout.trim() || 'unknown error';
+                    reject(new Error(`opencode error: ${message}`));
+                    return;
+                }
+                if (code !== 0) {
+                    const result = [...events].reverse().find((event) => event.type === 'result' || event.error || event.message);
+                    const message = extractOpenCodeErrorMessage(result) || stderrText.trim() || stdout.trim() || 'unknown error';
+                    reject(new Error(`opencode exited ${code}: ${message}`));
+                    return;
+                }
+                resolve({ events, stdout, stderr: stderrText });
+            });
+        });
+        const { events, stdout, stderr } = runResult;
+        const summary = summarizeOpenCodeEvents(events, stdout);
+        return {
+            text: summary.text,
+            metadata: {
+                provider: 'opencode',
+                model: model || null,
+                runnerAgent: runnerAgent || null,
+                turns: summary.turns,
+                costUsd: summary.costUsd,
+                tokens: summary.tokens,
+                raw: { events, stdout, stderr },
+            },
+        };
+    },
+};

package/dist/packages/cli/src/scanner.js

@@ -0,0 +1,43 @@
+import fg from 'fast-glob';
+import fs from 'node:fs/promises';
+import { parseAgentFile } from './parser.js';
+const SOURCES = [
+    { kind: 'singleton', pattern: '.singleton/agents/*.md', priority: 3 },
+    { kind: 'claude', pattern: '.claude/agents/*.md', priority: 2 },
+    { kind: 'copilot', pattern: '.github/agents/*.md', priority: 2 },
+    { kind: 'opencode', pattern: '.opencode/agents/*.md', priority: 2 },
+];
+function normalizeAgent(agent, source) {
+    const sourceProvider = ['claude', 'copilot', 'opencode'].includes(source)
+        ? source
+        : undefined;
+    return {
+        ...agent,
+        source,
+        provider: agent.provider || sourceProvider,
+    };
+}
+export async function scanAgents(root) {
+    const selected = new Map();
+    for (const source of SOURCES) {
+        const files = await fg([source.pattern], {
+            cwd: root,
+            absolute: true,
+            ignore: source.ignore || [],
+        });
+        for (const file of files) {
+            const content = await fs.readFile(file, 'utf8');
+            const parsed = parseAgentFile(content, file);
+            if (!parsed)
+                continue;
+            const agent = normalizeAgent(parsed, source.kind);
+            const existing = selected.get(agent.id);
+            if (!existing || source.priority > existing.priority) {
+                selected.set(agent.id, { ...agent, priority: source.priority });
+            }
+        }
+    }
+    return [...selected.values()]
+        .map(({ priority: _priority, ...agent }) => agent)
+        .sort((a, b) => a.id.localeCompare(b.id));
+}

package/dist/packages/cli/src/security/policy.js

@@ -0,0 +1,115 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+const VALID_PROFILES = new Set(['read-only', 'workspace-write', 'restricted-write', 'dangerous']);
+const DEFAULT_PROFILE = 'workspace-write';
+const DEFAULT_BLOCKED_PATHS = ['.git', 'node_modules', '.env', '.env.*', '.ssh'];
+const DEFAULT_COMMIT_EXCLUDE_PATHS = ['.singleton'];
+function asList(value) {
+    return Array.isArray(value) ? value.filter(Boolean).map(String) : [];
+}
+function isInside(parent, child) {
+    const rel = path.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+function normalizeRel(value) {
+    return String(value || '').replaceAll('\\', '/').replace(/^\/+/, '').replace(/\/+$/, '');
+}
+function matchesPattern(relPath, pattern) {
+    const rel = normalizeRel(relPath);
+    const pat = normalizeRel(pattern);
+    if (!pat)
+        return false;
+    if (pat.endsWith('.*')) {
+        const prefix = pat.slice(0, -1);
+        return rel === pat.slice(0, -2) || rel.startsWith(prefix);
+    }
+    return rel === pat || rel.startsWith(`${pat}/`);
+}
+function resolvePath(root, value) {
+    return path.isAbsolute(value) ? path.resolve(value) : path.resolve(root, value);
+}
+export function resolveSecurityPolicy(step = {}, agent = {}) {
+    return resolveSecurityPolicyWithConfig(step, agent);
+}
+export async function loadProjectSecurityConfig(root) {
+    const file = path.join(root, '.singleton', 'security.json');
+    try {
+        const raw = await fs.readFile(file, 'utf8');
+        const config = JSON.parse(raw);
+        return {
+            file,
+            defaultProfile: config.default_profile || DEFAULT_PROFILE,
+            allowedPaths: asList(config.allowed_paths),
+            blockedPaths: asList(config.blocked_paths),
+            commit: {
+                excludePaths: [
+                    ...DEFAULT_COMMIT_EXCLUDE_PATHS,
+                    ...asList(config.commit?.exclude_paths),
+                ],
+                requireConfirmation: config.commit?.require_confirmation !== false,
+            },
+        };
+    }
+    catch (err) {
+        const code = err && typeof err === 'object' && 'code' in err ? err.code : null;
+        const message = err instanceof Error ? err.message : String(err);
+        if (code !== 'ENOENT') {
+            throw new Error(`Invalid project security config: ${file} (${message})`);
+        }
+        return {
+            file,
+            defaultProfile: DEFAULT_PROFILE,
+            allowedPaths: [],
+            blockedPaths: [],
+            commit: {
+                excludePaths: DEFAULT_COMMIT_EXCLUDE_PATHS,
+                requireConfirmation: true,
+            },
+        };
+    }
+}
+export function resolveSecurityPolicyWithConfig(step = {}, agent = {}, projectConfig = {}) {
+    const profile = (step.security_profile || agent.security_profile || projectConfig.defaultProfile || DEFAULT_PROFILE);
+    return {
+        profile,
+        allowedPaths: asList(step.allowed_paths ?? agent.allowed_paths ?? projectConfig.allowedPaths),
+        blockedPaths: [
+            ...DEFAULT_BLOCKED_PATHS,
+            ...asList(projectConfig.blockedPaths),
+            ...asList(step.blocked_paths ?? agent.blocked_paths),
+        ],
+    };
+}
+export function validateSecurityPolicy(policy) {
+    const errors = [];
+    if (!VALID_PROFILES.has(policy.profile)) {
+        errors.push(`unknown security_profile "${policy.profile}"`);
+    }
+    if (policy.profile === 'restricted-write' && policy.allowedPaths.length === 0) {
+        errors.push('restricted-write requires at least one allowed_paths entry');
+    }
+    return errors;
+}
+export function assertWriteAllowed(absTarget, { root, agentName, outputName, policy }) {
+    const absRoot = path.resolve(root);
+    const absPath = path.resolve(absTarget);
+    const rel = path.relative(absRoot, absPath);
+    if (!isInside(absRoot, absPath)) {
+        throw new Error(`Step "${agentName}" output "${outputName}" resolves outside the project root: ${absPath}`);
+    }
+    if (policy.profile === 'read-only') {
+        throw new Error(`Step "${agentName}" output "${outputName}" is blocked by read-only security_profile: ${rel}`);
+    }
+    if (policy.profile !== 'dangerous') {
+        const blocked = policy.blockedPaths.find((pattern) => matchesPattern(rel, pattern));
+        if (blocked) {
+            throw new Error(`Step "${agentName}" output "${outputName}" is blocked by security policy "${blocked}": ${rel}`);
+        }
+    }
+    if (policy.profile === 'restricted-write') {
+        const allowed = policy.allowedPaths.some((entry) => isInside(resolvePath(absRoot, entry), absPath));
+        if (!allowed) {
+            throw new Error(`Step "${agentName}" output "${outputName}" is outside allowed_paths: ${rel}`);
+        }
+    }
+}

package/dist/packages/cli/src/sentinels.js

@@ -0,0 +1 @@
+export const ESC_SENTINEL = '__SINGLETON_ESC__';