@minionry/minion 0.7.36

package/dist/server/engines/codex/codex-invoker.js

@@ -0,0 +1,205 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { hlog } from '../../cli/headless/headless-logger.js';
+function asRecord(value) {
+    return typeof value === 'object' && value !== null
+        ? value
+        : undefined;
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function asResultString(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined || value === null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export class CodexEventMapper {
+    _threadId;
+    syntheticToolCounter = 0;
+    now;
+    usage;
+    constructor(options = {}) {
+        this._threadId = options.resumeThreadId;
+        this.now = options.now ?? Date.now;
+        this.usage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            lastUpdatedAt: this.now(),
+        };
+    }
+    get threadId() {
+        return this._threadId;
+    }
+    forgetThread() {
+        this._threadId = undefined;
+    }
+    getUsage() {
+        return { ...this.usage };
+    }
+    sessionId() {
+        return this._threadId ?? 'pending';
+    }
+    ingest(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            hlog(`[codex] skipping malformed JSONL line: ${line.slice(0, 120)}`);
+            return [];
+        }
+        const event = asRecord(parsed);
+        if (!event) {
+            hlog('[codex] skipping non-object JSONL line');
+            return [];
+        }
+        switch (asString(event.type)) {
+            case 'thread.started': {
+                const id = asString(event.thread_id) ?? asString(asRecord(event.thread)?.id);
+                if (id)
+                    this._threadId = id;
+                return [];
+            }
+            case 'turn.started':
+                return [];
+            case 'item.completed':
+                return this.mapItem(asRecord(event.item));
+            case 'turn.completed':
+                return this.mapTurnCompleted(asRecord(event.usage));
+            case 'error':
+                return [
+                    {
+                        kind: 'engine.error',
+                        sessionId: this.sessionId(),
+                        timestamp: this.now(),
+                        code: 'CODEX_STREAM_ERROR',
+                        message: asString(event.message) ?? 'Codex reported an error',
+                        fatal: false,
+                        raw: event,
+                    },
+                ];
+            default:
+                hlog(`[codex] dropping unmapped event type: ${asString(event.type) ?? '(none)'}`);
+                return [];
+        }
+    }
+    mapItem(item) {
+        if (!item)
+            return [];
+        const itemType = asString(item.type) ?? asString(item.item_type);
+        switch (itemType) {
+            case 'agent_message':
+                return this.textEvent('message.delta', asString(item.text) ?? asString(item.message));
+            case 'reasoning':
+                return this.textEvent('message.thinking', asString(item.text) ?? asString(item.summary));
+            case 'command_execution':
+            case 'file_change':
+            case 'mcp_tool_call':
+                return this.mapToolItem(itemType, item);
+            default:
+                hlog(`[codex] dropping unmapped item type: ${itemType ?? '(none)'}`);
+                return [];
+        }
+    }
+    textEvent(kind, text) {
+        if (!text)
+            return [];
+        return [{ kind, sessionId: this.sessionId(), timestamp: this.now(), text }];
+    }
+    mapToolItem(itemType, item) {
+        if (itemType === 'command_execution') {
+            return this.toolPair(item, 'command_execution', {
+                input: { command: item.command },
+                result: asString(item.aggregated_output) ?? asString(item.output) ?? '',
+                isError: (asNumber(item.exit_code) ?? 0) !== 0,
+            });
+        }
+        if (itemType === 'file_change') {
+            return this.toolPair(item, 'file_change', {
+                input: { changes: item.changes },
+                result: asResultString(item.changes),
+                isError: asString(item.status) === 'failed',
+            });
+        }
+        const server = asString(item.server);
+        const tool = asString(item.tool);
+        const toolName = server && tool ? `${server}.${tool}` : (tool ?? 'mcp_tool_call');
+        return this.toolPair(item, toolName, {
+            input: asRecord(item.arguments) ?? {},
+            result: asResultString(item.result),
+            isError: asString(item.status) === 'failed',
+        });
+    }
+    toolPair(item, toolName, parts) {
+        const toolCallId = asString(item.id) ?? `codex-tool-${++this.syntheticToolCounter}`;
+        const sessionId = this.sessionId();
+        const timestamp = this.now();
+        return [
+            { kind: 'tool.start', sessionId, timestamp, toolCallId, toolName, input: parts.input },
+            {
+                kind: 'tool.end',
+                sessionId,
+                timestamp,
+                toolCallId,
+                toolName,
+                input: parts.input,
+                result: parts.result,
+                isError: parts.isError,
+                durationMs: 0,
+            },
+        ];
+    }
+    mapTurnCompleted(usage) {
+        const events = [];
+        if (this.foldUsage(usage)) {
+            events.push({
+                kind: 'usage.update',
+                sessionId: this.sessionId(),
+                timestamp: this.now(),
+                inputTokens: this.usage.inputTokens,
+                outputTokens: this.usage.outputTokens,
+                cacheCreationTokens: this.usage.cacheCreationTokens,
+                cacheReadTokens: this.usage.cacheReadTokens,
+            });
+        }
+        events.push({
+            kind: 'session.idle',
+            sessionId: this.sessionId(),
+            timestamp: this.now(),
+            stopReason: 'end_turn',
+        });
+        return events;
+    }
+    foldUsage(usage) {
+        if (!usage)
+            return false;
+        const input = asNumber(usage.input_tokens) ?? asNumber(usage.inputTokens);
+        const output = asNumber(usage.output_tokens) ?? asNumber(usage.outputTokens);
+        const cacheRead = asNumber(usage.cached_input_tokens) ?? asNumber(usage.cacheReadTokens);
+        if (input === undefined && output === undefined && cacheRead === undefined) {
+            return false;
+        }
+        const cur = this.usage;
+        this.usage = {
+            inputTokens: Math.max(input ?? 0, cur.inputTokens),
+            outputTokens: Math.max(output ?? 0, cur.outputTokens),
+            cacheCreationTokens: cur.cacheCreationTokens,
+            cacheReadTokens: Math.max(cacheRead ?? 0, cur.cacheReadTokens ?? 0),
+            lastUpdatedAt: this.now(),
+        };
+        return true;
+    }
+}

package/dist/server/engines/codex/codex-provision.js

@@ -0,0 +1,215 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { MINIONRY_ROOT } from '../../utils/paths.js';
+export const CODEX_PACKAGE = '@openai/codex';
+export const PUBLIC_NPM_REGISTRY = 'https://registry.npmjs.org/';
+export const DEFAULT_CODEX_VERSION = '^0.145.0';
+const DEFAULT_PACKAGE_ROOT = MINIONRY_ROOT;
+function defaultResolveCodexBinary() {
+    try {
+        const require_ = createRequire(import.meta.url);
+        const manifestPath = require_.resolve(`${CODEX_PACKAGE}/package.json`);
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        const binRel = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.codex;
+        if (!binRel)
+            return null;
+        const binPath = join(dirname(manifestPath), binRel);
+        return existsSync(binPath) ? binPath : null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildInstallEnv(base) {
+    const env = { ...base };
+    for (const key of Object.keys(env)) {
+        const k = key.toLowerCase();
+        if (k === 'npm_config__auth' ||
+            k === 'npm_config__authtoken' ||
+            k === 'npm_config_always_auth') {
+            delete env[key];
+        }
+    }
+    env.npm_config_always_auth = 'false';
+    return env;
+}
+function defaultReadCodexVersion(packageRoot) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+        return (pkg.optionalDependencies?.[CODEX_PACKAGE] ??
+            pkg.dependencies?.[CODEX_PACKAGE] ??
+            DEFAULT_CODEX_VERSION);
+    }
+    catch {
+        return DEFAULT_CODEX_VERSION;
+    }
+}
+const defaultSpawn = (cmd, args, opts) => new Promise((resolveExit) => {
+    const child = spawn(cmd, args, {
+        cwd: opts.cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: opts.env ?? process.env,
+        windowsHide: true,
+    });
+    let tail = '';
+    const TAIL_CAP = 4_000;
+    const append = (chunk) => {
+        const text = chunk.toString('utf8');
+        tail = (tail + text).slice(-TAIL_CAP);
+        if (opts.onLine) {
+            for (const line of text.split('\n')) {
+                if (line.trim().length > 0)
+                    opts.onLine(line);
+            }
+        }
+    };
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', (err) => {
+        tail = `${tail}\nspawn error: ${err.message}`.slice(-TAIL_CAP);
+        resolveExit({ ok: false, code: null, tail });
+    });
+    child.on('exit', (code) => resolveExit({ ok: code === 0, code, tail }));
+});
+export class CodexRuntimeProvisioner {
+    packageRoot;
+    resolveCodexBinary;
+    pathExists;
+    readCodexVersion;
+    spawnFn;
+    installEnv;
+    constructor(deps = {}) {
+        this.packageRoot = deps.packageRoot ?? DEFAULT_PACKAGE_ROOT;
+        this.resolveCodexBinary =
+            deps.resolveCodexBinary ?? defaultResolveCodexBinary;
+        this.pathExists = deps.pathExists ?? existsSync;
+        this.readCodexVersion =
+            deps.readCodexVersion ??
+                (() => defaultReadCodexVersion(this.packageRoot));
+        this.spawnFn = deps.spawn ?? defaultSpawn;
+        this.installEnv = buildInstallEnv(deps.env ?? process.env);
+    }
+    get root() {
+        return this.packageRoot;
+    }
+    status() {
+        const resolved = this.resolveCodexBinary();
+        if (resolved && this.pathExists(resolved)) {
+            return { provisioned: true, binaryPath: resolved, state: 'ok' };
+        }
+        const pkgManifest = join(this.packageRoot, 'node_modules', CODEX_PACKAGE, 'package.json');
+        if (this.pathExists(pkgManifest)) {
+            return { provisioned: false, binaryPath: resolved, state: 'binary-missing' };
+        }
+        return { provisioned: false, binaryPath: null, state: 'package-missing' };
+    }
+    async provision(onLine) {
+        const log = onLine ?? (() => { });
+        const before = this.status();
+        if (before.provisioned) {
+            return { ok: true, status: before, action: 'noop' };
+        }
+        await this.runNpmInstall(log, before.state === 'binary-missing');
+        const after = this.status();
+        if (after.provisioned) {
+            return { ok: true, status: after, action: 'npm-install' };
+        }
+        return {
+            ok: false,
+            status: after,
+            action: 'failed',
+            error: this.describeFailure(after),
+        };
+    }
+    async runNpmInstall(log, force) {
+        const version = this.readCodexVersion();
+        const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        log(`Installing ${CODEX_PACKAGE}@${version} into ${this.packageRoot} from ${PUBLIC_NPM_REGISTRY}…`);
+        const args = [
+            'install',
+            `${CODEX_PACKAGE}@${version}`,
+            '--no-save',
+            '--no-audit',
+            '--no-fund',
+            '--no-package-lock',
+            `--registry=${PUBLIC_NPM_REGISTRY}`,
+        ];
+        if (force)
+            args.push('--force');
+        const r = await this.spawnFn(npm, args, {
+            cwd: this.packageRoot,
+            onLine: log,
+            env: this.installEnv,
+        });
+        if (!r.ok) {
+            log(`npm install exited with code ${r.code ?? 'null'}.`);
+        }
+        return r;
+    }
+    describeFailure(status) {
+        const note = status.state === 'package-missing'
+            ? `Could not install ${CODEX_PACKAGE} into ${this.packageRoot}.`
+            : `${CODEX_PACKAGE} is installed at ${this.packageRoot} but its platform binary is still missing.`;
+        return (`${note} If the cli lives in a root-owned location, re-run with elevated ` +
+            `permissions or reinstall the cli. You can also install the Codex CLI ` +
+            `manually: \`npm i -g ${CODEX_PACKAGE}\` (or add it to the monorepo and ` +
+            `run \`npm install\` at the repo ROOT), then set \`CODEX_COMMAND\` to its path.`);
+    }
+}
+let inFlight = null;
+let lastFailureAt = 0;
+let lastFailureResult = null;
+export const PROVISION_FAILURE_COOLDOWN_MS = 60_000;
+export function ensureCodexProvisioned(onLine, deps) {
+    if (inFlight)
+        return inFlight;
+    if (lastFailureResult && now() - lastFailureAt < PROVISION_FAILURE_COOLDOWN_MS) {
+        return Promise.resolve(lastFailureResult);
+    }
+    const run = new CodexRuntimeProvisioner(deps)
+        .provision(onLine)
+        .then((result) => {
+        if (result.ok) {
+            lastFailureResult = null;
+        }
+        else {
+            lastFailureResult = result;
+            lastFailureAt = now();
+        }
+        return result;
+    })
+        .finally(() => {
+        inFlight = null;
+    });
+    inFlight = run;
+    return run;
+}
+export async function resolveCodexCommand(onLine, deps) {
+    const override = process.env.CODEX_COMMAND;
+    if (override && override.trim().length > 0) {
+        return override;
+    }
+    const result = await ensureCodexProvisioned(onLine, deps);
+    if (result.ok && result.status.binaryPath) {
+        return result.status.binaryPath;
+    }
+    throw new Error(result.error ??
+        `The Codex CLI (${CODEX_PACKAGE}) is not installed and could not be ` +
+            `provisioned. Install it with \`npm i -g ${CODEX_PACKAGE}\`, or set ` +
+            `\`CODEX_COMMAND\` to an existing codex binary.`);
+}
+export function isCodexProvisioning() {
+    return inFlight !== null;
+}
+function now() {
+    return Date.now();
+}
+export function resetCodexProvisionStateForTests() {
+    inFlight = null;
+    lastFailureAt = 0;
+    lastFailureResult = null;
+}

package/dist/server/engines/credentials/credential-probe.js

@@ -0,0 +1,88 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const CREDENTIAL_PROBE_TIMEOUT_MS = 10_000;
+const ANTHROPIC_DIALECT = {
+    defaultBaseUrl: 'https://api.anthropic.com',
+    modelsPath: '/v1/models',
+    headers: (apiKey) => ({
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+    }),
+};
+const OPENAI_DIALECT = {
+    defaultBaseUrl: 'https://api.openai.com/v1',
+    modelsPath: '/models',
+    headers: (apiKey) => ({ Authorization: `Bearer ${apiKey}` }),
+};
+const DIALECT_BY_ENGINE = {
+    'claude-code': ANTHROPIC_DIALECT,
+    codex: OPENAI_DIALECT,
+    hermes: OPENAI_DIALECT,
+};
+function joinUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/+$/, '')}${path}`;
+}
+export function credentialProbeUrl(target) {
+    const dialect = DIALECT_BY_ENGINE[target.engine];
+    return joinUrl(target.baseUrl?.trim() || dialect.defaultBaseUrl, dialect.modelsPath);
+}
+export async function probeCredential(target, deps = {}) {
+    const key = target.apiKey.trim();
+    if (!key)
+        return { ok: false, failure: 'invalid_key', message: 'No API key is stored for this provider.' };
+    const doFetch = deps.fetch ?? globalThis.fetch;
+    if (typeof doFetch !== 'function') {
+        return { ok: false, failure: 'unreachable', message: 'This machine has no HTTP client available to verify the key.' };
+    }
+    const url = credentialProbeUrl(target);
+    const dialect = DIALECT_BY_ENGINE[target.engine];
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), deps.timeoutMs ?? CREDENTIAL_PROBE_TIMEOUT_MS);
+    try {
+        const response = await doFetch(url, {
+            method: 'GET',
+            headers: dialect.headers(key),
+            signal: controller.signal,
+        });
+        return classifyResponse(response.status, url);
+    }
+    catch (err) {
+        const aborted = err instanceof Error && err.name === 'AbortError';
+        return {
+            ok: false,
+            failure: 'unreachable',
+            message: aborted
+                ? `Timed out contacting ${url}. Your key was saved — try again in a moment.`
+                : `Couldn't reach ${url}. Check the base URL and this machine's network access.`,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function classifyResponse(status, url) {
+    if (status >= 200 && status < 300)
+        return { ok: true };
+    if (status === 401 || status === 403) {
+        return {
+            ok: false,
+            failure: 'invalid_key',
+            status,
+            message: `The provider rejected this key (${status}). Check you copied the whole key, then try again.`,
+        };
+    }
+    if (status === 404) {
+        return {
+            ok: false,
+            failure: 'bad_endpoint',
+            status,
+            message: `No model list at ${url} (404). Check the base URL — most providers expect it to end at the API root.`,
+        };
+    }
+    return {
+        ok: false,
+        failure: 'bad_endpoint',
+        status,
+        message: `The provider answered ${status} when asked for its model list. The key may be fine; the endpoint is not answering normally.`,
+    };
+}