@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.1

package/lib/types/backends/codex/channels.js

@@ -0,0 +1,274 @@
+/** Codex Responses-API channels. Only token refs persist here; token I/O
+ * comes from BackendHost.tokenStore and the backend-neutral shared seam.
+ * Provider overrides stay in argv (§5.11): hosts are process-list-visible. */
+import { createHash } from 'node:crypto';
+import { readFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { channelProfileSlug } from '../../channel/channel-slug.js';
+import { t } from '../../i18n.js';
+import { DATA_DIR } from '../../utils/paths.js';
+import { writeFileAtomic } from '../shared/atomic-file.js';
+import { channelTokenRef } from '../shared/channel-tokens.js';
+import { rec, str } from './narrow.js';
+export const channelSlug = channelProfileSlug;
+export const CODEX_CHANNEL_TOKEN_ENV = 'DSH_TUI_CODEX_CHANNEL_TOKEN';
+const FILE = 'channels.json';
+const derivedRef = (id) => channelTokenRef('codex-' + id);
+const credentialEnv = /(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|AUTHORIZATION)/iu;
+/** Reject credential-bearing URLs before either persistence or spawn. */
+export function validateCodexBaseUrl(value) {
+    const fail = () => { throw new Error(t('codex-channel-url-invalid')); };
+    const input = value.trim();
+    if (input === '' || /[\s\\]/u.test(input) || input.includes('?') || input.includes('#'))
+        return fail();
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        return fail();
+    }
+    if ((url.protocol !== 'https:' && !(url.protocol === 'http:' && (url.hostname === 'localhost' || url.hostname === '127.0.0.1')))
+        || url.username !== '' || url.password !== '')
+        return fail();
+    for (const encoded of url.pathname.split('/')) {
+        let segment;
+        try {
+            segment = decodeURIComponent(encoded);
+        }
+        catch {
+            return fail();
+        }
+        if (/^(?:sk-|(?:api[_-]?key|key|token|secret)=)/iu.test(segment)
+            || /^[A-Za-z0-9_]{24,}$/u.test(segment)
+            || (/^[A-Za-z0-9_-]{24,}$/u.test(segment) && /[0-9A-Z_]/u.test(segment))
+            || /^[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}$/u.test(segment))
+            return fail();
+    }
+    return url.href;
+}
+function stringMap(value) {
+    const entries = rec(value);
+    if (entries === undefined)
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(entries))
+        if (key.trim() !== '' && typeof value === 'string' && value.trim() !== '')
+            out[key.trim()] = value.trim();
+    return Object.keys(out).length === 0 ? undefined : out;
+}
+/** Invalid endpoint rows remain selected so launch refuses, never silently
+ * switching a hand-edited active connection to ambient OAuth credentials. */
+export function parseCodexChannels(value) {
+    const data = rec(value);
+    const channels = [];
+    for (const raw of Array.isArray(data?.channels) ? data.channels : []) {
+        const row = rec(raw);
+        const id = str(row?.id)?.trim();
+        if (id === undefined || !/^[a-z0-9][a-z0-9_-]*$/iu.test(id) || channels.some(profile => profile.id === id))
+            continue;
+        channels.push({
+            id, name: str(row?.name)?.trim() || id,
+            ...(typeof row?.baseUrl === 'string' && row.baseUrl !== '' ? { baseUrl: row.baseUrl.trim() } : {}),
+            ...(typeof row?.tokenRef === 'string' && row.tokenRef !== '' ? { tokenRef: row.tokenRef } : {}),
+            wireApi: str(row?.wireApi) ?? 'responses',
+            ...(stringMap(row?.env) === undefined ? {} : { env: stringMap(row?.env) }),
+            ...(stringMap(row?.models) === undefined ? {} : { models: stringMap(row?.models) }),
+        });
+    }
+    const active = str(data?.active);
+    return { channels, ...(channels.some(profile => profile.id === active) ? { active } : {}) };
+}
+function checked(profile) {
+    if (!/^[a-z0-9][a-z0-9_-]*$/iu.test(profile.id))
+        throw new Error(t('codex-channel-id-invalid'));
+    if (profile.wireApi !== undefined && profile.wireApi !== 'responses')
+        throw new Error(t('codex-channel-wire-api-invalid'));
+    for (const key of Object.keys(profile.env ?? {})) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key) || credentialEnv.test(key))
+            throw new Error(t('codex-channel-env-invalid'));
+    }
+    return {
+        id: profile.id, name: profile.name.trim() || profile.id, wireApi: 'responses',
+        ...(profile.baseUrl === undefined ? {} : { baseUrl: validateCodexBaseUrl(profile.baseUrl) }),
+        ...(profile.tokenRef === undefined ? {} : { tokenRef: profile.tokenRef }),
+        ...(profile.env === undefined ? {} : { env: { ...profile.env } }),
+        ...(profile.models === undefined ? {} : { models: { ...profile.models } }),
+    };
+}
+const upsert = (data, profile) => ({
+    ...data, channels: data.channels.some(row => row.id === profile.id) ? data.channels.map(row => row.id === profile.id ? profile : row) : [...data.channels, profile],
+});
+const without = (data, id) => ({
+    channels: data.channels.filter(row => row.id !== id), ...(data.active === undefined || data.active === id ? {} : { active: data.active }),
+});
+export const activeProfileOf = (data) => data.channels.find(row => row.id === data.active);
+export const hasChannelConnection = (profile) => profile !== undefined && (profile.baseUrl !== undefined || profile.tokenRef !== undefined || Object.keys(profile.env ?? {}).length > 0);
+/** Same atomic/upsert/damaged-file semantics as the mature Claude store. */
+export function fileCodexChannels(dir = join(DATA_DIR, 'backends', 'codex'), debug = () => undefined) {
+    const path = join(dir, FILE);
+    const load = () => {
+        try {
+            return { data: parseCodexChannels(JSON.parse(readFileSync(path, 'utf8'))), damaged: false };
+        }
+        catch (error) {
+            return { data: { channels: [] }, damaged: !['ENOENT', 'ENOTDIR'].includes(error.code ?? '') };
+        }
+    };
+    const commit = (data) => {
+        try {
+            writeFileAtomic(dir, FILE, JSON.stringify(data, null, 2) + '\n');
+        }
+        catch {
+            debug('codex: channels write failed');
+        }
+    };
+    return {
+        read: () => load().data,
+        setActive: id => { const data = load().data; if (data.active !== id && data.channels.some(row => row.id === id))
+            commit({ ...data, active: id }); },
+        save: profile => {
+            const valid = checked(profile);
+            const current = load();
+            if (current.damaged) {
+                try {
+                    renameSync(path, path + '.damaged-' + Date.now());
+                }
+                catch {
+                    debug('codex: damaged channels file could not be moved aside; not saving');
+                    return;
+                }
+            }
+            commit(upsert(current.data, valid));
+        },
+        remove: id => { const data = load().data; if (data.channels.some(row => row.id === id))
+            commit(without(data, id)); },
+    };
+}
+export function memoryCodexChannels(initial = { channels: [] }) {
+    let data = parseCodexChannels(initial);
+    return {
+        read: () => data,
+        setActive: id => { if (data.channels.some(row => row.id === id))
+            data = { ...data, active: id }; },
+        save: profile => { data = upsert(data, checked(profile)); },
+        remove: id => { data = without(data, id); },
+    };
+}
+/** The token only goes into the child environment, never an argv override. */
+export function codexChannelLaunch(profile, tokens) {
+    if (!hasChannelConnection(profile) || profile === undefined)
+        return { args: [], env: {}, injectedEnvKeys: [] };
+    if (profile.baseUrl === undefined)
+        throw new Error(t('codex-channel-url-required'));
+    const valid = checked(profile);
+    const token = valid.tokenRef === undefined ? undefined : tokens?.read(valid.tokenRef);
+    if (token === undefined && new URL(valid.baseUrl).protocol !== 'http:')
+        throw new Error(t('codex-channel-token-missing', { name: valid.name }));
+    const provider = 'dshtui-' + valid.id;
+    const overrides = {
+        model_provider: provider,
+        ['model_providers.' + provider + '.name']: valid.name,
+        ['model_providers.' + provider + '.base_url']: valid.baseUrl,
+        ['model_providers.' + provider + '.wire_api']: 'responses',
+        ['model_providers.' + provider + '.requires_openai_auth']: false,
+        ...(token === undefined ? {} : { ['model_providers.' + provider + '.env_key']: CODEX_CHANNEL_TOKEN_ENV }),
+    };
+    const env = { ...valid.env, ...(token === undefined ? {} : { [CODEX_CHANNEL_TOKEN_ENV]: token }) };
+    return { args: Object.entries(overrides).flatMap(([key, value]) => ['-c', key + '=' + JSON.stringify(value)]), env, injectedEnvKeys: Object.keys(env), provider };
+}
+function settingsImport(config, env) {
+    const provider = str(config?.model_provider);
+    if (provider === undefined || provider === 'openai' || provider.startsWith('dshtui-'))
+        return undefined;
+    const row = rec(rec(config?.model_providers)?.[provider]);
+    if (typeof row?.base_url !== 'string' || (row.wire_api != null && row.wire_api !== 'responses'))
+        return undefined;
+    let baseUrl;
+    try {
+        baseUrl = validateCodexBaseUrl(row.base_url);
+    }
+    catch {
+        return undefined;
+    }
+    const name = new URL(baseUrl).host;
+    const key = str(row.env_key);
+    const token = key === undefined ? undefined : Object.entries(env).find(([name, value]) => name.toUpperCase() === key.toUpperCase() && value !== undefined && value !== '')?.[1];
+    return { profile: { id: channelSlug(name), name, baseUrl, wireApi: 'responses' }, ...(token === undefined ? {} : { token }) };
+}
+/** Synchronous channel capability over a config/read snapshot. The TUI's
+ * own dshtui-* provider is not re-imported as if it were user settings. */
+export function createCodexChannelsRuntime(deps) {
+    let config = deps.config;
+    const { store, tokens } = deps;
+    const view = (profile) => {
+        let baseUrl;
+        try {
+            if (profile.baseUrl !== undefined)
+                baseUrl = validateCodexBaseUrl(profile.baseUrl);
+        }
+        catch { /* unsafe URL never reaches a view */ }
+        const token = profile.tokenRef === undefined ? undefined : tokens?.read(profile.tokenRef);
+        const env = Object.entries(profile.env ?? {}).sort(([a], [b]) => a.localeCompare(b));
+        return {
+            id: profile.id, name: profile.name, models: Object.entries(profile.models ?? {}).map(([from, to]) => ({ from, to })), tiers: [],
+            ...(!hasChannelConnection(profile) ? {} : { connection: { ...(baseUrl === undefined ? {} : { baseUrl }), hasToken: profile.tokenRef !== undefined && (tokens?.declared(profile.tokenRef) ?? false), envKeys: Object.keys(profile.env ?? {}), fingerprint: createHash('sha256').update(JSON.stringify([profile.baseUrl, token, env])).digest('hex').slice(0, 16) } }),
+        };
+    };
+    const shared = (ref, except) => store.read().channels.some(row => row.id !== except && row.tokenRef === ref);
+    const capability = {
+        list: () => store.read().channels.map(view),
+        activeId: () => store.read().active,
+        setActive: id => store.setActive(id),
+        save: input => {
+            const current = store.read().channels.find(row => row.id === input.id);
+            const profile = checked({
+                id: input.id, name: input.name,
+                ...(input.baseUrl === undefined ? (current?.baseUrl === undefined ? {} : { baseUrl: current.baseUrl }) : input.baseUrl === '' ? {} : { baseUrl: input.baseUrl }),
+                ...(current?.tokenRef === undefined ? {} : { tokenRef: current.tokenRef }),
+                ...(input.env === undefined ? (current?.env === undefined ? {} : { env: current.env }) : { env: input.env }),
+                ...(input.models === undefined ? (current?.models === undefined ? {} : { models: current.models }) : { models: input.models }),
+            });
+            let tokenRef = profile.tokenRef;
+            if (input.token !== undefined) {
+                if (tokens === undefined)
+                    throw new Error(t('codex-channel-store-unavailable'));
+                if (input.token === '') {
+                    if (tokenRef !== undefined && !shared(tokenRef, input.id) && tokenRef === derivedRef(input.id))
+                        tokens.erase(tokenRef);
+                    tokenRef = undefined;
+                }
+                else {
+                    tokenRef ??= derivedRef(input.id);
+                    tokens.write(tokenRef, input.token);
+                    if (tokens.read(tokenRef) !== input.token)
+                        throw new Error(t('codex-channel-token-write-failed'));
+                }
+            }
+            const { tokenRef: _oldRef, ...rest } = profile;
+            const saved = { ...rest, ...(tokenRef === undefined ? {} : { tokenRef }) };
+            store.save(saved);
+            return view(saved);
+        },
+        remove: id => {
+            const current = store.read().channels.find(row => row.id === id);
+            if (current === undefined)
+                return false;
+            if (current.tokenRef === derivedRef(id) && !shared(current.tokenRef, id))
+                tokens?.erase(current.tokenRef);
+            store.remove(id);
+            return true;
+        },
+        importFromSettings: () => {
+            const draft = settingsImport(config, deps.env ?? {});
+            if (draft === undefined || draft.token === undefined || tokens === undefined)
+                return undefined;
+            return capability.save({ ...draft.profile, token: draft.token });
+        },
+        peekSettingsImport: () => {
+            const draft = settingsImport(config, deps.env ?? {});
+            return draft === undefined ? undefined : { baseUrl: draft.profile.baseUrl, tiers: {} };
+        },
+    };
+    return { capability, active: () => activeProfileOf(store.read()), refreshConfig: value => { config = value; }, launch: () => codexChannelLaunch(activeProfileOf(store.read()), tokens) };
+}

package/lib/types/backends/codex/contract.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Version contract of the Codex backend (docs/codex-backend-design.md D3).
+ * There is no npm dependency: the backend drives the user's own `codex`
+ * binary over `codex app-server`, and the protocol types under
+ * `protocol/generated/` are that binary's generator output, vendored by
+ * `scripts/codex-protocol-sync.mjs`. `verify:codex-contract` checks the
+ * digest below against the tree and every protocol name the backend handles
+ * against the generated unions.
+ *
+ * Version policy: a binary on the same minor line as a validated version and
+ * not older than it is compatible (`0.160.x` ≥ `0.160.1`); anything else on
+ * or above {@link MIN_CODEX_VERSION} runs with a drift notice; below it the
+ * backend reports itself not installed, with an upgrade hint.
+ */
+/** Backend id of the Codex backend (`AgentSessionRef.backendId`). */
+export declare const CODEX_BACKEND_ID = "codex";
+/** User-facing backend name. */
+export declare const CODEX_BACKEND_LABEL = "Codex";
+/** How a user re-enters a Codex thread from a shell. */
+export declare function codexResumeCommand(threadId: string): string;
+/** The `codex-cli` versions the backend is validated against. */
+export declare const VALIDATED_CODEX_VERSIONS: readonly string[];
+/**
+ * The oldest `codex-cli` the backend starts on (C0 V16): 0.144.0's generated
+ * protocol carries every method, notification, server request and item type
+ * this backend uses, and its handshake / thread start / model list were
+ * observed working. Anything below the validated line still runs with a
+ * drift notice.
+ */
+export declare const MIN_CODEX_VERSION = "0.144.0";
+/** The `codex-cli` version `protocol/generated/` was generated from. */
+export declare const PROTOCOL_VERSION = "0.160.1";
+/** Digest of `protocol/generated/` (scripts/lib/codex-protocol-digest.mjs). */
+export declare const PROTOCOL_DIGEST = "sha256:3843848c108242f7364b986c80fefd6cd37aec4ab2863b0e2b6fb7bc86feb6f7";
+/** `X.Y.Z` (with an optional pre-release tail) from `codex --version`
+ *  output (`codex-cli 0.160.1`), else undefined. */
+export declare function parseCodexVersion(text: string): string | undefined;
+/** Compare two versions by their numeric triple (pre-release tails ignored);
+ *  undefined when either does not parse. */
+export declare function compareCodexVersions(a: string, b: string): number | undefined;
+/** Whether a version is at least {@link MIN_CODEX_VERSION} (an unreadable
+ *  version is given the benefit of the doubt: drift, never a refusal). */
+export declare function codexVersionSupported(version: string | undefined): boolean;
+/** The version when it is outside the validated range, else undefined. */
+export declare function codexVersionDrift(version: string | undefined): string | undefined;
+//# sourceMappingURL=contract.d.ts.map

package/lib/types/backends/codex/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../src/backends/codex/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,UAAU,CAAA;AAEvC,gCAAgC;AAChC,eAAO,MAAM,mBAAmB,UAAU,CAAA;AAE1C,wDAAwD;AACxD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,iEAAiE;AACjE,eAAO,MAAM,wBAAwB,EAAE,SAAS,MAAM,EAAgB,CAAA;AAEtE;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,YAAY,CAAA;AAE1C,wEAAwE;AACxE,eAAO,MAAM,gBAAgB,YAAY,CAAA;AAEzC,+EAA+E;AAC/E,eAAO,MAAM,eAAe,4EAA4E,CAAA;AAExG;oDACoD;AACpD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAQD;4CAC4C;AAC5C,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQ7E;AAED;0EAC0E;AAC1E,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAI1E;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CASjF"}

package/lib/types/backends/codex/contract.js

@@ -0,0 +1,80 @@
+/**
+ * Version contract of the Codex backend (docs/codex-backend-design.md D3).
+ * There is no npm dependency: the backend drives the user's own `codex`
+ * binary over `codex app-server`, and the protocol types under
+ * `protocol/generated/` are that binary's generator output, vendored by
+ * `scripts/codex-protocol-sync.mjs`. `verify:codex-contract` checks the
+ * digest below against the tree and every protocol name the backend handles
+ * against the generated unions.
+ *
+ * Version policy: a binary on the same minor line as a validated version and
+ * not older than it is compatible (`0.160.x` ≥ `0.160.1`); anything else on
+ * or above {@link MIN_CODEX_VERSION} runs with a drift notice; below it the
+ * backend reports itself not installed, with an upgrade hint.
+ */
+/** Backend id of the Codex backend (`AgentSessionRef.backendId`). */
+export const CODEX_BACKEND_ID = 'codex';
+/** User-facing backend name. */
+export const CODEX_BACKEND_LABEL = 'Codex';
+/** How a user re-enters a Codex thread from a shell. */
+export function codexResumeCommand(threadId) {
+    return `dsh-tui --backend codex --resume ${threadId}`;
+}
+/** The `codex-cli` versions the backend is validated against. */
+export const VALIDATED_CODEX_VERSIONS = ['0.160.1'];
+/**
+ * The oldest `codex-cli` the backend starts on (C0 V16): 0.144.0's generated
+ * protocol carries every method, notification, server request and item type
+ * this backend uses, and its handshake / thread start / model list were
+ * observed working. Anything below the validated line still runs with a
+ * drift notice.
+ */
+export const MIN_CODEX_VERSION = '0.144.0';
+/** The `codex-cli` version `protocol/generated/` was generated from. */
+export const PROTOCOL_VERSION = '0.160.1';
+/** Digest of `protocol/generated/` (scripts/lib/codex-protocol-digest.mjs). */
+export const PROTOCOL_DIGEST = 'sha256:3843848c108242f7364b986c80fefd6cd37aec4ab2863b0e2b6fb7bc86feb6f7';
+/** `X.Y.Z` (with an optional pre-release tail) from `codex --version`
+ *  output (`codex-cli 0.160.1`), else undefined. */
+export function parseCodexVersion(text) {
+    return /(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/u.exec(text)?.[1];
+}
+/** Numeric `[major, minor, patch]` of a version, else undefined. */
+function triple(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/u.exec(version);
+    return match === null ? undefined : [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+/** Compare two versions by their numeric triple (pre-release tails ignored);
+ *  undefined when either does not parse. */
+export function compareCodexVersions(a, b) {
+    const left = triple(a);
+    const right = triple(b);
+    if (left === undefined || right === undefined)
+        return undefined;
+    for (let index = 0; index < 3; index++) {
+        if (left[index] !== right[index])
+            return left[index] - right[index];
+    }
+    return 0;
+}
+/** Whether a version is at least {@link MIN_CODEX_VERSION} (an unreadable
+ *  version is given the benefit of the doubt: drift, never a refusal). */
+export function codexVersionSupported(version) {
+    if (version === undefined)
+        return true;
+    const order = compareCodexVersions(version, MIN_CODEX_VERSION);
+    return order === undefined || order >= 0;
+}
+/** The version when it is outside the validated range, else undefined. */
+export function codexVersionDrift(version) {
+    if (version === undefined || version === '')
+        return undefined;
+    const own = triple(version);
+    if (own === undefined)
+        return version;
+    const compatible = VALIDATED_CODEX_VERSIONS.some(validated => {
+        const line = triple(validated);
+        return line !== undefined && line[0] === own[0] && line[1] === own[1] && own[2] >= line[2];
+    });
+    return compatible ? undefined : version;
+}

package/lib/types/backends/codex/detect.d.ts

@@ -0,0 +1,14 @@
+import type { BackendDetection, BackendHost } from '../../agent/backend.js';
+import { type CodexChannelProfile } from './channels.js';
+import type { ChannelTokenStore } from '../shared/channel-tokens.js';
+/** The Codex home the app-server will use (`CODEX_HOME`, else `~/.codex`). */
+export declare function codexHomeDir(env?: NodeJS.ProcessEnv): string;
+/** Whether a credential is visible without a network call. */
+export declare function detectCodexAuth(env?: NodeJS.ProcessEnv, options?: {
+    readonly channel?: CodexChannelProfile;
+    readonly tokens?: ChannelTokenStore;
+}): 'ok' | 'missing' | 'unknown';
+export declare function detectCodex(host: BackendHost & {
+    readonly tokenStore?: ChannelTokenStore;
+}, env?: NodeJS.ProcessEnv): Promise<BackendDetection>;
+//# sourceMappingURL=detect.d.ts.map

package/lib/types/backends/codex/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../../src/backends/codex/detect.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAG3E,OAAO,EAAgF,KAAK,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACtI,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAKpE,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAGzE;AAED,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,EAAE,OAAO,GAAE;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAA;CAAO,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,CAkBjM;AAED,wBAAsB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG;IAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,iBAAiB,CAAA;CAAE,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA2BlK"}

package/lib/types/backends/codex/detect.js

@@ -0,0 +1,90 @@
+/**
+ * Codex backend detection (docs/codex-backend-design.md §5.4): is a usable
+ * `codex` installed, is it a supported version, and is there a credential
+ * it could use — all without starting the app-server or touching the
+ * network. Never throws.
+ *
+ * The credential check is cheap and conservative: an API key in the
+ * environment, a `$CODEX_HOME/auth.json`, or a config that routes to a
+ * provider of its own count as present; a keychain store is `unknown`.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { t } from '../../i18n.js';
+import { CODEX_OAUTH_PROVIDER } from './auth/external-tokens.js';
+import { activeProfileOf, codexChannelLaunch, fileCodexChannels, hasChannelConnection } from './channels.js';
+import { codexVersionDrift, codexVersionSupported, MIN_CODEX_VERSION } from './contract.js';
+import { errorText } from './narrow.js';
+import { resolveCodexExecutable } from './rpc/binary.js';
+/** The Codex home the app-server will use (`CODEX_HOME`, else `~/.codex`). */
+export function codexHomeDir(env = process.env) {
+    const configured = env.CODEX_HOME;
+    return configured !== undefined && configured !== '' ? configured : join(homedir(), '.codex');
+}
+/** Whether a credential is visible without a network call. */
+export function detectCodexAuth(env = process.env, options = {}) {
+    if (hasChannelConnection(options.channel)) {
+        try {
+            codexChannelLaunch(options.channel, options.tokens);
+            return 'ok';
+        }
+        catch {
+            return 'missing';
+        }
+    }
+    if ((env.OPENAI_API_KEY ?? '') !== '' || (env.CODEX_API_KEY ?? '') !== '')
+        return 'ok';
+    const home = codexHomeDir(env);
+    if (existsSync(join(home, 'auth.json')))
+        return 'ok';
+    let config = '';
+    try {
+        config = readFileSync(join(home, 'config.toml'), 'utf8');
+    }
+    catch {
+        config = '';
+    }
+    // A provider of its own (a relay, a local model) needs no OpenAI login.
+    const provider = /^\s*model_provider\s*=\s*["']([^"']+)["']/mu.exec(config)?.[1];
+    if (provider !== undefined && provider !== 'openai')
+        return 'ok';
+    if (/^\s*cli_auth_credentials_store\s*=\s*["'](?:keyring|auto)["']/mu.test(config))
+        return 'unknown';
+    return 'missing';
+}
+export async function detectCodex(host, env = process.env) {
+    try {
+        const executable = await resolveCodexExecutable(env);
+        if (executable === undefined)
+            return { installed: false, hint: t('codex-not-installed') };
+        const version = executable.version;
+        if (!codexVersionSupported(version)) {
+            return { installed: false, ...(version === undefined ? {} : { version }), hint: t('codex-too-old', { version: version ?? '', min: MIN_CODEX_VERSION }) };
+        }
+        const channel = activeProfileOf(fileCodexChannels(undefined, host.debug).read());
+        let auth = detectCodexAuth(env, { channel, tokens: host.tokenStore });
+        if (!hasChannelConnection(channel)) {
+            try {
+                if (await host.oauthCredential?.(CODEX_OAUTH_PROVIDER)?.stored() === true)
+                    auth = 'ok';
+            }
+            catch {
+                host.debug('codex: stored OAuth detection failed');
+            }
+        }
+        const drift = codexVersionDrift(version);
+        return {
+            installed: true,
+            loginInSession: true,
+            auth,
+            ...(version === undefined ? {} : { version }),
+            ...(drift === undefined ? {} : { drift }),
+            ...(auth === 'missing' ? { hint: t('codex-auth-missing-hint') } : {}),
+        };
+    }
+    catch (error) {
+        host.debug(`codex: detection failed (${errorText(error)})`);
+        return { installed: false };
+    }
+}

package/lib/types/backends/codex/index.d.ts

@@ -0,0 +1,6 @@
+/** The Codex backend (docs/codex-backend-design.md): its one entry point. */
+export { codexBackend } from './backend.js';
+export { CODEX_BACKEND_ID, CODEX_BACKEND_LABEL, codexResumeCommand, MIN_CODEX_VERSION, VALIDATED_CODEX_VERSIONS } from './contract.js';
+export { fileCodexPrefs } from './prefs.js';
+export { closeAllCodexHubs } from './rpc/hub.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/backends/codex/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/backends/codex/index.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AACtI,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA"}

package/lib/types/backends/codex/index.js

@@ -0,0 +1,5 @@
+/** The Codex backend (docs/codex-backend-design.md): its one entry point. */
+export { codexBackend } from './backend.js';
+export { CODEX_BACKEND_ID, CODEX_BACKEND_LABEL, codexResumeCommand, MIN_CODEX_VERSION, VALIDATED_CODEX_VERSIONS } from './contract.js';
+export { fileCodexPrefs } from './prefs.js';
+export { closeAllCodexHubs } from './rpc/hub.js';

package/lib/types/backends/codex/modes.d.ts

@@ -0,0 +1,16 @@
+/** The permission modes (Plan mode is C2). */
+export declare const CODEX_MODE_IDS: readonly ["read-only", "auto", "full-access"];
+export type CodexModeId = typeof CODEX_MODE_IDS[number];
+/** The mode a session starts in when nothing is remembered. */
+export declare const DEFAULT_CODEX_MODE: CodexModeId;
+/** What each mode sends: `thread/start`/`thread/resume` take a sandbox
+ *  mode; `turn/start` and `thread/settings/update` a sandbox policy. */
+export declare const CODEX_MODE_PARAMS: Readonly<Record<CodexModeId, {
+    readonly approvalPolicy: 'on-request' | 'never';
+    readonly sandbox: 'read-only' | 'workspace-write' | 'danger-full-access';
+}>>;
+export declare function isCodexModeId(value: unknown): value is CodexModeId;
+/** The mode a thread's reported settings correspond to; `custom` when they
+ *  match no preset (a user config the presets do not cover). */
+export declare function modeIdOf(approvalPolicy: unknown, sandbox: unknown): CodexModeId | 'custom';
+//# sourceMappingURL=modes.d.ts.map

package/lib/types/backends/codex/modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../../../src/backends/codex/modes.ts"],"names":[],"mappings":"AAYA,8CAA8C;AAC9C,eAAO,MAAM,cAAc,+CAAgD,CAAA;AAC3E,MAAM,MAAM,WAAW,GAAG,OAAO,cAAc,CAAC,MAAM,CAAC,CAAA;AAEvD,+DAA+D;AAC/D,eAAO,MAAM,kBAAkB,EAAE,WAAoB,CAAA;AAErD;wEACwE;AACxE,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE;IAAE,QAAQ,CAAC,cAAc,EAAE,YAAY,GAAG,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,iBAAiB,GAAG,oBAAoB,CAAA;CAAE,CAAC,CAI1L,CAAA;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE;AAcD;gEACgE;AAChE,wBAAgB,QAAQ,CAAC,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,WAAW,GAAG,QAAQ,CAQ1F"}

package/lib/types/backends/codex/modes.js

@@ -0,0 +1,49 @@
+/**
+ * The Codex permission presets as the backend's modes
+ * (docs/codex-backend-design.md §5.9; C0 V8: the official `/permissions`
+ * presets `read-only` "Read Only", `auto` "Default", `full-access` "Full
+ * Access", plus Plan mode, which C2 adds as a collaboration mode).
+ *
+ * `auto` is the base mode a session starts in unless the user picked
+ * another: on-request approvals inside a workspace-write sandbox, so every
+ * command or edit outside the workspace asks first.
+ */
+import { rec, str } from './narrow.js';
+/** The permission modes (Plan mode is C2). */
+export const CODEX_MODE_IDS = ['read-only', 'auto', 'full-access'];
+/** The mode a session starts in when nothing is remembered. */
+export const DEFAULT_CODEX_MODE = 'auto';
+/** What each mode sends: `thread/start`/`thread/resume` take a sandbox
+ *  mode; `turn/start` and `thread/settings/update` a sandbox policy. */
+export const CODEX_MODE_PARAMS = {
+    'read-only': { approvalPolicy: 'on-request', sandbox: 'read-only' },
+    auto: { approvalPolicy: 'on-request', sandbox: 'workspace-write' },
+    'full-access': { approvalPolicy: 'never', sandbox: 'danger-full-access' },
+};
+export function isCodexModeId(value) {
+    return typeof value === 'string' && CODEX_MODE_IDS.includes(value);
+}
+/** The sandbox mode a `SandboxPolicy` object (or mode string) names. */
+function sandboxModeOf(sandbox) {
+    const text = str(sandbox);
+    if (text !== undefined)
+        return text;
+    switch (str(rec(sandbox)?.type)) {
+        case 'readOnly': return 'read-only';
+        case 'workspaceWrite': return 'workspace-write';
+        case 'dangerFullAccess': return 'danger-full-access';
+        default: return undefined;
+    }
+}
+/** The mode a thread's reported settings correspond to; `custom` when they
+ *  match no preset (a user config the presets do not cover). */
+export function modeIdOf(approvalPolicy, sandbox) {
+    const approval = str(approvalPolicy);
+    const mode = sandboxModeOf(sandbox);
+    for (const id of CODEX_MODE_IDS) {
+        const params = CODEX_MODE_PARAMS[id];
+        if (params.approvalPolicy === approval && params.sandbox === mode)
+            return id;
+    }
+    return 'custom';
+}

package/lib/types/backends/codex/narrow.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Narrowing helpers for the untyped app-server JSON (the counterpart of
+ * `claude/narrow.ts`). The generated protocol types only annotate call
+ * sites; every value read at run time goes through these (a `bigint` field
+ * of a generated type is a plain JSON number on the wire).
+ */
+export type Rec = Readonly<Record<string, unknown>>;
+/** A plain object (not an array), else undefined. */
+export declare const rec: (value: unknown) => Rec | undefined;
+export declare const str: (value: unknown) => string | undefined;
+/** A non-empty string, else undefined. */
+export declare const text: (value: unknown) => string | undefined;
+/** A finite number, else undefined. */
+export declare const num: (value: unknown) => number | undefined;
+export declare const bool: (value: unknown) => boolean | undefined;
+export declare const arr: (value: unknown) => readonly unknown[];
+/** The string members of an array value. */
+export declare const strings: (value: unknown) => readonly string[];
+export declare const errorText: (error: unknown) => string;
+//# sourceMappingURL=narrow.d.ts.map

package/lib/types/backends/codex/narrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrow.d.ts","sourceRoot":"","sources":["../../../../src/backends/codex/narrow.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAEnD,qDAAqD;AACrD,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,KAAG,GAAG,GAAG,SACsD,CAAA;AAEjG,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAA0D,CAAA;AAExG,0CAA0C;AAC1C,eAAO,MAAM,IAAI,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAA0E,CAAA;AAEzH,uCAAuC;AACvC,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAAoF,CAAA;AAElI,eAAO,MAAM,IAAI,GAAI,OAAO,OAAO,KAAG,OAAO,GAAG,SAA2D,CAAA;AAE3G,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,KAAG,SAAS,OAAO,EAAuC,CAAA;AAE5F,4CAA4C;AAC5C,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,SAAS,MAAM,EAA2E,CAAA;AAEnI,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,MAAgE,CAAA"}

package/lib/types/backends/codex/narrow.js

@@ -0,0 +1,18 @@
+/**
+ * Narrowing helpers for the untyped app-server JSON (the counterpart of
+ * `claude/narrow.ts`). The generated protocol types only annotate call
+ * sites; every value read at run time goes through these (a `bigint` field
+ * of a generated type is a plain JSON number on the wire).
+ */
+/** A plain object (not an array), else undefined. */
+export const rec = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) ? value : undefined;
+export const str = (value) => typeof value === 'string' ? value : undefined;
+/** A non-empty string, else undefined. */
+export const text = (value) => typeof value === 'string' && value !== '' ? value : undefined;
+/** A finite number, else undefined. */
+export const num = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+export const bool = (value) => typeof value === 'boolean' ? value : undefined;
+export const arr = (value) => Array.isArray(value) ? value : [];
+/** The string members of an array value. */
+export const strings = (value) => arr(value).filter((item) => typeof item === 'string');
+export const errorText = (error) => error instanceof Error ? error.message : String(error);