@ornexus/neocortex 4.60.68 → 4.60.70

package/packages/client/dist/runner/headless/adapters.js

@@ -1,49 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- *
- * P190.04 -- allowlisted headless adapter registry.
- */
-import { HEADLESS_ADAPTER_IDS, HEADLESS_REASON_CODES, isHeadlessAdapterId, redaction, } from './types.js';
-import { createClaudeCodeHeadlessAdapter } from './claude-code-adapter.js';
-import { createFakeHeadlessAdapter } from './fake-adapter.js';
-import { createOpenCodeHeadlessAdapter } from './opencode-adapter.js';
-export class HeadlessAdapterRegistry {
-    adapters;
-    constructor(adapters) {
-        const map = new Map();
-        for (const adapter of adapters) {
-            if (!isHeadlessAdapterId(adapter.id))
-                continue;
-            map.set(adapter.id, adapter);
-        }
-        this.adapters = map;
-    }
-    listAdapterIds() {
-        return HEADLESS_ADAPTER_IDS.filter((id) => this.adapters.has(id));
-    }
-    hasAdapter(id) {
-        return isHeadlessAdapterId(id) && this.adapters.has(id);
-    }
-    getAdapter(id) {
-        if (!isHeadlessAdapterId(id) || !this.adapters.has(id)) {
-            return {
-                ok: false,
-                reasonCode: HEADLESS_REASON_CODES.RUNTIME_UNTRUSTED,
-                reasonCodes: [HEADLESS_REASON_CODES.RUNTIME_UNTRUSTED],
-                publicSummary: 'Headless adapter id is not allowlisted.',
-                redactionSummary: [redaction('runtimeId', 'unsafe_key', 'value-denied')],
-                publicSafe: true,
-            };
-        }
-        return { ok: true, adapter: this.adapters.get(id), publicSafe: true };
-    }
-}
-export function createDefaultHeadlessAdapterRegistry() {
-    return new HeadlessAdapterRegistry([
-        createFakeHeadlessAdapter('fake'),
-        createFakeHeadlessAdapter('test'),
-        createOpenCodeHeadlessAdapter(),
-        createClaudeCodeHeadlessAdapter(),
-    ]);
-}
+import{HEADLESS_ADAPTER_IDS as o,HEADLESS_REASON_CODES as s,isHeadlessAdapterId as a,redaction as p}from"./types.js";import{createClaudeCodeHeadlessAdapter as i}from"./claude-code-adapter.js";import{createFakeHeadlessAdapter as d}from"./fake-adapter.js";import{createOpenCodeHeadlessAdapter as n}from"./opencode-adapter.js";class u{adapters;constructor(e){const r=new Map;for(const t of e)a(t.id)&&r.set(t.id,t);this.adapters=r}listAdapterIds(){return o.filter(e=>this.adapters.has(e))}hasAdapter(e){return a(e)&&this.adapters.has(e)}getAdapter(e){return!a(e)||!this.adapters.has(e)?{ok:!1,reasonCode:s.RUNTIME_UNTRUSTED,reasonCodes:[s.RUNTIME_UNTRUSTED],publicSummary:"Headless adapter id is not allowlisted.",redactionSummary:[p("runtimeId","unsafe_key","value-denied")],publicSafe:!0}:{ok:!0,adapter:this.adapters.get(e),publicSafe:!0}}}function S(){return new u([d("fake"),d("test"),n(),i()])}export{u as HeadlessAdapterRegistry,S as createDefaultHeadlessAdapterRegistry};

package/packages/client/dist/runner/headless/claude-code-adapter.js

@@ -1,79 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- *
- * P190.04 -- trusted Claude Code headless adapter interface.
- */
-import { createRejectedExecutionResult, createUnavailableExecutionResult, normalizeHeadlessCommandResult, runHeadlessCommand, validateHeadlessAdapterExecutionInput, } from './types.js';
-import { checkRuntimeAvailability } from './opencode-adapter.js';
-import { governedPreflightFailureResult, preflightManagedHeadlessProfile, withGovernedHeadlessEvidence, } from './managed-profile.js';
-const CLAUDE_CODE_ADAPTER_ID = 'claude-code';
-const CLAUDE_CODE_COMMAND = 'claude';
-const CLAUDE_CODE_AGENT_PROFILE = 'neocortex';
-export function createClaudeCodeHeadlessAdapter() {
-    return {
-        id: CLAUDE_CODE_ADAPTER_ID,
-        displayName: 'Claude Code Headless Adapter',
-        async checkAvailability(options = {}) {
-            return checkRuntimeAvailability(CLAUDE_CODE_ADAPTER_ID, CLAUDE_CODE_COMMAND, options, {
-                realpathBasenamePolicy: 'claude-code-versioned',
-                versionEvidence: 'claude-code',
-            });
-        },
-        buildInvocation(input) {
-            const validation = validateHeadlessAdapterExecutionInput(input, CLAUDE_CODE_ADAPTER_ID);
-            if (!validation.ok)
-                return validation;
-            return {
-                ok: true,
-                invocation: {
-                    adapterId: CLAUDE_CODE_ADAPTER_ID,
-                    commandName: CLAUDE_CODE_COMMAND,
-                    args: buildClaudeCodeArgs(validation.prompt, validation.input.modelId),
-                    promptHash: validation.promptHash,
-                    ...(validation.input.modelId ? { modelId: validation.input.modelId } : {}),
-                    timeoutMs: validation.input.timeoutMs ?? 10 * 60 * 1000,
-                    publicSafe: true,
-                },
-                publicSafe: true,
-            };
-        },
-        async execute(input, options = {}) {
-            const validation = validateHeadlessAdapterExecutionInput(input, CLAUDE_CODE_ADAPTER_ID);
-            if (!validation.ok)
-                return createRejectedExecutionResult(CLAUDE_CODE_ADAPTER_ID, CLAUDE_CODE_ADAPTER_ID, validation);
-            const preflight = preflightManagedHeadlessProfile(CLAUDE_CODE_ADAPTER_ID, options);
-            if (!preflight.ok)
-                return governedPreflightFailureResult(CLAUDE_CODE_ADAPTER_ID, validation.input, preflight);
-            if (options.signal?.aborted) {
-                return withGovernedHeadlessEvidence(normalizeHeadlessCommandResult(CLAUDE_CODE_ADAPTER_ID, validation.input, {
-                    exitCode: null, signal: 'SIGTERM', timedOut: false, cancelled: true, durationMs: 0,
-                    stdout: '', stderr: '', stdoutBytes: 0, stderrBytes: 0,
-                }));
-            }
-            const availability = await this.checkAvailability(options);
-            if (!availability.ok)
-                return withGovernedHeadlessEvidence(createUnavailableExecutionResult(CLAUDE_CODE_ADAPTER_ID, validation.input, availability));
-            const invocation = this.buildInvocation(validation.input);
-            if (!invocation.ok)
-                return createRejectedExecutionResult(CLAUDE_CODE_ADAPTER_ID, CLAUDE_CODE_ADAPTER_ID, invocation);
-            const runner = options.commandRunner ?? runHeadlessCommand;
-            const result = await runner(availability.executablePath ?? CLAUDE_CODE_COMMAND, invocation.invocation.args, {
-                cwd: options.cwd,
-                env: options.env,
-                timeoutMs: invocation.invocation.timeoutMs,
-                maxOutputBytes: options.maxOutputBytes,
-                signal: options.signal,
-                ...(validation.input.receipt?.jobId ? { localConsole: { projectRoot: options.cwd, jobId: validation.input.receipt.jobId, attemptId: validation.input.receipt.attemptId, executionId: validation.input.receipt.executionId, publicSafe: true } } : {}),
-            });
-            return withGovernedHeadlessEvidence(normalizeHeadlessCommandResult(CLAUDE_CODE_ADAPTER_ID, validation.input, result));
-        },
-    };
-}
-function buildClaudeCodeArgs(prompt, modelId) {
-    const args = ['--agent', CLAUDE_CODE_AGENT_PROFILE];
-    if (modelId)
-        args.push('--model', modelId);
-    args.push('-p', prompt);
-    return args;
-}
+import{createRejectedExecutionResult as c,createUnavailableExecutionResult as m,normalizeHeadlessCommandResult as l,runHeadlessCommand as v,validateHeadlessAdapterExecutionInput as s}from"./types.js";import{checkRuntimeAvailability as f}from"./opencode-adapter.js";import{governedPreflightFailureResult as C,preflightManagedHeadlessProfile as I,withGovernedHeadlessEvidence as u}from"./managed-profile.js";const a="claude-code",o="claude",b="neocortex";function y(){return{id:a,displayName:"Claude Code Headless Adapter",async checkAvailability(i={}){return f(a,o,i,{realpathBasenamePolicy:"claude-code-versioned",versionEvidence:"claude-code"})},buildInvocation(i){const e=s(i,a);return e.ok?{ok:!0,invocation:{adapterId:a,commandName:o,args:h(e.prompt,e.input.modelId),promptHash:e.promptHash,...e.input.modelId?{modelId:e.input.modelId}:{},timeoutMs:e.input.timeoutMs??600*1e3,publicSafe:!0},publicSafe:!0}:e},async execute(i,e={}){const t=s(i,a);if(!t.ok)return c(a,a,t);const d=I(a,e);if(!d.ok)return C(a,t.input,d);if(e.signal?.aborted)return u(l(a,t.input,{exitCode:null,signal:"SIGTERM",timedOut:!1,cancelled:!0,durationMs:0,stdout:"",stderr:"",stdoutBytes:0,stderrBytes:0}));const r=await this.checkAvailability(e);if(!r.ok)return u(m(a,t.input,r));const n=this.buildInvocation(t.input);if(!n.ok)return c(a,a,n);const p=await(e.commandRunner??v)(r.executablePath??o,n.invocation.args,{cwd:e.cwd,env:e.env,timeoutMs:n.invocation.timeoutMs,maxOutputBytes:e.maxOutputBytes,signal:e.signal,...t.input.receipt?.jobId?{localConsole:{projectRoot:e.cwd,jobId:t.input.receipt.jobId,attemptId:t.input.receipt.attemptId,executionId:t.input.receipt.executionId,publicSafe:!0}}:{}});return u(l(a,t.input,p))}}}function h(i,e){const t=["--agent",b];return e&&t.push("--model",e),t.push("-p",i),t}export{y as createClaudeCodeHeadlessAdapter};