singleton-pipeline 0.4.0-beta.0

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

@@ -0,0 +1,208 @@
+import { spawn } from 'node:child_process';
+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');
+  }
+
+  if (profile === 'read-only') {
+    args.push('--deny-tool=write');
+    args.push('--deny-tool=shell');
+  } else {
+    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 = {} } = {}) {
+  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) {
+  const assistantMessages = events
+    .filter((event) => event.type === 'assistant.message')
+    .map((event) => extractText(event.data))
+    .filter(Boolean);
+  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: assistantMessages.join('\n').trim() || deltaText.trim(),
+    turns: events.filter((event) => event.type === 'assistant.message').length || null,
+    outputTokens: outputTokens || null,
+    premiumRequests: Number(result?.usage?.premiumRequests || 0) || null,
+    result,
+  };
+}
+
+export function extractCopilotErrorMessage(event) {
+  if (!event || typeof event !== 'object') return '';
+  if (typeof event.error === 'string') return event.error;
+  if (typeof event.message === 'string') return event.message;
+  if (typeof event.error?.message === 'string') return event.error.message;
+  if (typeof event.error?.data?.message === 'string') return event.error.data.message;
+  if (typeof event.data?.message === 'string') return event.data.message;
+  return extractText(event);
+}
+
+export const copilotRunner = {
+  id: 'copilot',
+  command: 'copilot',
+
+  async run({
+    cwd,
+    systemPrompt,
+    userPrompt,
+    model,
+    runnerAgent,
+    securityPolicy,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+  }) {
+    const prompt = 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', (d) => stdoutChunks.push(d.toString()));
+      child.stderr.on('data', (d) => (stderrText += d.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/packages/cli/src/runners/index.js

@@ -0,0 +1,20 @@
+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/packages/cli/src/runners/opencode.js

@@ -0,0 +1,265 @@
+import { spawn } from 'node:child_process';
+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 '';
+  if (typeof event.error === 'string') return event.error;
+  if (typeof event.message === 'string') return event.message;
+  if (typeof event.error?.message === 'string') return event.error.message;
+  if (typeof event.error?.data?.message === 'string') return event.error.data.message;
+  if (typeof event.data?.message === 'string') return event.data.message;
+  return extractText(event);
+}
+
+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(Boolean);
+
+  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 (anthropic, openai, …) under XDG_DATA_HOME, so isolating
+  // it would strip API credentials from the spawned process. Security is
+  // enforced via OPENCODE_CONFIG_CONTENT (native permissions injection) and
+  // Singleton's post-run snapshot diff — both of which work without isolating
+  // OpenCode's data dir.
+  return {
+    ...baseEnv,
+    OPENCODE_CONFIG_CONTENT: buildOpenCodeConfigContent({
+      securityPolicy,
+      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', (d) => stdoutChunks.push(d.toString()));
+      child.stderr.on('data', (d) => (stderrText += d.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/packages/cli/src/scanner.js

@@ -0,0 +1,47 @@
+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) {
+  return {
+    ...agent,
+    source,
+    provider: agent.provider || (['claude', 'copilot', 'opencode'].includes(source) ? source : undefined),
+  };
+}
+
+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, ...agent }) => agent)
+    .sort((a, b) => a.id.localeCompare(b.id));
+}

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

@@ -0,0 +1,126 @@
+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) : [];
+}
+
+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) {
+    if (err.code !== 'ENOENT') {
+      throw new Error(`Invalid project security config: ${file} (${err.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}`);
+    }
+  }
+}