| |
| |
| |
| import fs from 'node:fs/promises'; |
| import os from 'node:os'; |
| import crypto from 'node:crypto'; |
| import { execFileSync } from 'node:child_process'; |
| import path from 'node:path'; |
| import http from 'node:http'; |
| import { spawn } from 'node:child_process'; |
| import { OpencodeProvider } from '../apps/server/dist/providers/opencode-provider.js'; |
| import { AgentExecutor } from '../apps/server/dist/services/agent-executor.js'; |
| import { OpenCodeRoleRunner } from '../apps/server/dist/services/argus/opencode-role-runner.js'; |
| import { configureOpenCode } from '../apps/server/dist/services/argus/opencode-config.js'; |
| const root = await fs.mkdtemp(path.join(os.tmpdir(), 'automaker-opencode-probe-')); |
| const originalEnv = { ...process.env }; |
| const cli = process.env.OPENCODE_BIN || 'opencode'; |
| const env = { |
| ...process.env, |
| PATH: (cli.includes('/') ? path.dirname(path.resolve(cli)) + ':' : '') + process.env.PATH, |
| XDG_DATA_HOME: root + '/data', |
| XDG_CONFIG_HOME: root + '/config', |
| XDG_CACHE_HOME: root + '/cache', |
| XDG_STATE_HOME: root + '/state', |
| COMPATIBLE_MODEL: 'MiniMax-M2.7', |
| COMPATIBLE_API_KEY: crypto.randomUUID(), |
| }; |
| const requests = []; |
| const server = http.createServer(async (req, res) => { |
| let raw = ''; |
| for await (const chunk of req) raw += chunk; |
| let body = {}; |
| try { |
| body = JSON.parse(raw); |
| } catch {} |
| requests.push({ |
| path: req.url, |
| model: body.model, |
| authenticated: req.headers.authorization === 'Bearer ' + env.COMPATIBLE_API_KEY, |
| }); |
| if (req.url?.endsWith('/chat/completions')) { |
| res.writeHead(200, { 'Content-Type': 'text/event-stream' }); |
| const prompt = JSON.stringify(body.messages); |
| const reply = prompt.includes('diagnostic probe') |
| ? JSON.stringify({ |
| rootCause: 'routing', |
| recommendedFix: 'canonical identity', |
| juniorCanRepair: true, |
| evidence: [], |
| filesLikelyAffected: [], |
| }) |
| : prompt.includes('review probe') |
| ? JSON.stringify({ |
| verdict: 'approve', |
| reviewedHeadSha: 'abc', |
| findings: [], |
| requiredChanges: [], |
| evidence: [], |
| }) |
| : 'LOCAL_PROBE_OK'; |
| const base = { |
| id: 'chatcmpl-local', |
| object: 'chat.completion.chunk', |
| created: 1, |
| model: 'MiniMax-M2.7', |
| }; |
| res.write( |
| 'data: ' + |
| JSON.stringify({ |
| ...base, |
| choices: [ |
| { index: 0, delta: { role: 'assistant', content: reply }, finish_reason: null }, |
| ], |
| }) + |
| '\n\n' |
| ); |
| res.write( |
| 'data: ' + |
| JSON.stringify({ |
| ...base, |
| choices: [{ index: 0, delta: {}, finish_reason: 'stop' }], |
| usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }, |
| }) + |
| '\n\n' |
| ); |
| res.end('data: [DONE]\n\n'); |
| } else { |
| res.writeHead(404); |
| res.end('{}'); |
| } |
| }); |
| await new Promise((r) => server.listen(0, '127.0.0.1', r)); |
| env.COMPATIBLE_URL = `http://127.0.0.1:${server.address().port}/v1`; |
| process.env.PATH = env.PATH; |
| Object.assign(process.env, { |
| XDG_DATA_HOME: env.XDG_DATA_HOME, |
| XDG_CONFIG_HOME: env.XDG_CONFIG_HOME, |
| XDG_CACHE_HOME: env.XDG_CACHE_HOME, |
| XDG_STATE_HOME: env.XDG_STATE_HOME, |
| }); |
| const cfg = root + '/config/opencode'; |
| await fs.mkdir(cfg, { recursive: true }); |
| await fs.writeFile(cfg + '/opencode.json', JSON.stringify({ permission: { '*': 'deny' } })); |
| let outcome; |
| try { |
| const cliVersion = execFileSync(cli, ['--version'], { |
| env, |
| encoding: 'utf8', |
| timeout: 15000, |
| stdio: ['ignore', 'pipe', 'pipe'], |
| }).trim(); |
| const model = await configureOpenCode(env, cfg); |
| env.OPENCODE_CONFIG = cfg + '/opencode.json'; |
| const runProbe = (selector) => |
| new Promise((resolve) => { |
| const child = spawn(cli, ['run', '--format', 'json', '--model', selector], { |
| cwd: root, |
| env, |
| stdio: ['pipe', 'pipe', 'pipe'], |
| }); |
| let stdout = '', |
| stderr = ''; |
| child.stdout.on('data', (b) => (stdout += b)); |
| child.stderr.on('data', (b) => (stderr += b)); |
| child.stdin.end( |
| 'Return LOCAL_PROBE_OK. Do not use any tools, read files or modify anything.' |
| ); |
| const timer = setTimeout(() => child.kill('SIGKILL'), 45000); |
| child.on('exit', (exit) => { |
| clearTimeout(timer); |
| resolve({ |
| exit, |
| textReceived: stdout.includes('LOCAL_PROBE_OK'), |
| events: stdout |
| .split('\n') |
| .filter(Boolean) |
| .map((l) => { |
| try { |
| return JSON.parse(l).type; |
| } catch { |
| return 'non-json'; |
| } |
| }), |
| stderrPresent: !!stderr, |
| genericServerError: (stdout + stderr).includes('Unexpected server error'), |
| }); |
| }); |
| }); |
| const beforeRequestCount = requests.length; |
| const before = await runProbe('opencode/MiniMax-M2.7'); |
| const wrongProviderReachedEndpoint = requests.length !== beforeRequestCount; |
| outcome = await runProbe(model); |
| Object.assign(process.env, env); |
| const provider = new OpencodeProvider(); |
| const invocations = []; |
| const build = provider.buildCliArgs.bind(provider); |
| provider.buildCliArgs = (options) => { |
| const args = build(options); |
| invocations.push(args); |
| return args; |
| }; |
| const noop = async () => {}; |
| const executor = new AgentExecutor( |
| { emitAutoModeEvent: () => {} }, |
| { saveFeatureSummary: noop, updateFeaturePlanSpec: noop }, |
| { waitForApproval: noop } |
| ); |
| const normal = await executor.execute( |
| { |
| workDir: root, |
| projectPath: root, |
| featureId: 'bounded-cli-probe', |
| prompt: 'Return LOCAL_PROBE_OK without tools.', |
| abortController: new AbortController(), |
| provider, |
| effectiveBareModel: 'MiniMax-M2.7', |
| model: 'MiniMax-M2.7', |
| sdkOptions: { model, maxTurns: 1 }, |
| planningMode: 'skip', |
| }, |
| { |
| waitForApproval: noop, |
| saveFeatureSummary: noop, |
| updateFeatureSummary: noop, |
| buildTaskPrompt: () => '', |
| } |
| ); |
| const runner = new OpenCodeRoleRunner(); |
| const diagnosis = await runner.diagnose({ fixture: 'diagnostic probe' }); |
| const review = await runner.review({ fixture: 'review probe' }); |
| const engineer = await runner.execute('Return LOCAL_PROBE_OK without tools.', root); |
| console.log( |
| JSON.stringify({ |
| cliVersion, |
| identity: model, |
| before: { ...before, wrongProviderReachedEndpoint }, |
| outcome, |
| normalFeature: { textReceived: normal.responseText.includes('LOCAL_PROBE_OK'), invocations }, |
| roles: { |
| diagnosisValid: diagnosis.result.rootCause === 'routing', |
| reviewValid: review.result.verdict === 'approve', |
| engineerValid: engineer.output.includes('LOCAL_PROBE_OK'), |
| }, |
| requests, |
| }) |
| ); |
| if ( |
| !normal.responseText.includes('LOCAL_PROBE_OK') || |
| !invocations.some((a) => a.includes(model)) || |
| diagnosis.result.rootCause !== 'routing' || |
| review.result.verdict !== 'approve' || |
| !engineer.output.includes('LOCAL_PROBE_OK') || |
| requests.some((r) => r.model !== 'MiniMax-M2.7' || !r.authenticated) |
| ) |
| process.exitCode = 1; |
| if ( |
| before.exit === 0 || |
| before.textReceived || |
| wrongProviderReachedEndpoint || |
| outcome.exit !== 0 || |
| !outcome.textReceived || |
| !requests.some((r) => r.model === 'MiniMax-M2.7' && r.authenticated) |
| ) |
| process.exitCode = 1; |
| } catch { |
| console.error('OpenCode compatible smoke test failed; inspect sanitized diagnostics above.'); |
| process.exitCode = 1; |
| } finally { |
| await new Promise((resolve) => server.close(resolve)); |
| for (const key of Object.keys(process.env)) if (!(key in originalEnv)) delete process.env[key]; |
| Object.assign(process.env, originalEnv); |
| await fs.rm(root, { recursive: true, force: true }); |
| } |
|
|
