@ornexus/neocortex 4.60.66 → 4.60.68

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

@@ -1 +1,49 @@
-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};
+/**
+ * @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(),
+    ]);
+}

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

@@ -1 +1,79 @@
-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};
+/**
+ * @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;
+}