@foxden-app/foxclaw 0.11.1 → 0.13.0

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import type { LogLevel } from './logger.js';
 import type { ApprovalPolicyValue, SandboxModeValue } from './types.js';
+import type { DshClientOptions } from './dsh/client.js';
 export declare const APP_HOME: string;
 export declare const DEFAULT_STORE_PATH: string;
 export declare const DEFAULT_STATUS_PATH: string;
@@ -19,6 +20,8 @@ export declare function resolveEnvPath(): string;
 export declare function getLoadedEnvPath(): string | null;
 export declare function loadEnv(): void;
 export interface AppConfig {
+    dsh?: DshClientOptions;
+    dshBotToken?: string | null;
     codexBotTokens: string[];
     antigravityBotTokens: string[];
     tgBotToken: string;
@@ -112,6 +115,7 @@ export interface CodexApiProviderConfig {
 export declare function loadConfig(): AppConfig;
 export declare function buildCodexApiProviderOverrides(providers: readonly CodexApiProviderConfig[], defaultProviderId?: string | null): string[];
 export declare function validateCodexBotTokens(tokens: readonly string[]): void;
+export declare function parseDshPatches(value?: string): string[];
 export declare function validateOpencodeBotToken(token: string | null, codexTokens: readonly string[]): void;
 export declare function validateAntigravityBotTokens(tokens: readonly string[], codexTokens: readonly string[], opencodeToken: string | null): void;
 export declare function validateAntigravityBotToken(token: string | null, codexTokens: readonly string[], opencodeToken: string | null): void;

package/dist/config.js

@@ -50,8 +50,12 @@ export function loadConfig() {
     const codexBotTokens = parseCommaSeparatedIds(process.env.CODEX_BOT_TOKENS || process.env.CODEX_BOT_TOKEN);
     const antigravityBotTokens = parseCommaSeparatedIds(process.env.ANTIGRAVITY_BOT_TOKENS || process.env.ANTIGRAVITY_BOT_TOKEN);
     const opencodeBotToken = optional('OPENCODE_BOT_TOKEN');
-    if (codexBotTokens.length === 0 && antigravityBotTokens.length === 0) {
-        throw new Error('At least one Telegram bot token must be configured via CODEX_BOT_TOKENS or ANTIGRAVITY_BOT_TOKENS');
+    const dshBotToken = optional('DSH_BOT_TOKEN');
+    if (dshBotToken && [...codexBotTokens, ...antigravityBotTokens, opencodeBotToken].includes(dshBotToken)) {
+        throw new Error('DSH_BOT_TOKEN must use a different bot from Codex, Antigravity, and OpenCode');
+    }
+    if (codexBotTokens.length === 0 && antigravityBotTokens.length === 0 && !dshBotToken) {
+        throw new Error('At least one Telegram bot token must be configured via CODEX_BOT_TOKENS, ANTIGRAVITY_BOT_TOKENS, or DSH_BOT_TOKEN');
     }
     validateCodexBotTokens(codexBotTokens);
     validateAntigravityBotTokens(antigravityBotTokens, codexBotTokens, opencodeBotToken);
@@ -60,11 +64,23 @@ export function loadConfig() {
     const antigravityDefaultRuntimeBotToken = selectDefaultRuntimeBotToken(antigravityBotTokens, optional('ANTIGRAVITY_DEFAULT_RUNTIME_BOT_TOKEN')) ||
         antigravityBotTokens[0] ||
         null;
-    const totalBots = codexBotTokens.length + antigravityBotTokens.length;
-    const tgBotTokens = codexBotTokens.length > 0 ? codexBotTokens : antigravityBotTokens;
-    const tgBotToken = (codexBotTokens[0] || antigravityBotTokens[0]);
+    const totalBots = codexBotTokens.length + antigravityBotTokens.length + (dshBotToken ? 1 : 0);
+    const tgBotTokens = codexBotTokens.length > 0 ? codexBotTokens : antigravityBotTokens.length > 0 ? antigravityBotTokens : dshBotToken ? [dshBotToken] : [];
+    const tgBotToken = (codexBotTokens[0] || antigravityBotTokens[0] || dshBotToken);
     const antigravityBotToken = antigravityBotTokens[0] || null;
     const config = {
+        dshBotToken,
+        ...(boolEnv('DSH_ENABLED', Boolean(dshBotToken || optional('DSH_SOURCE_DIR') || optional('DSH_CLI_BIN'))) ? {
+            dsh: {
+                cliBin: optional('DSH_CLI_BIN') || resolveCommand('dsh') || 'dsh',
+                sourceDir: optional('DSH_SOURCE_DIR'),
+                home: optional('DSH_HOME'),
+                profile: optional('DSH_PROFILE') || 'acp',
+                patches: parseDshPatches(process.env.DSH_PATCHES),
+                runtimeDir: path.join(APP_HOME, 'runtime', 'dsh'),
+                startupTimeoutMs: Number(optional('DSH_STARTUP_TIMEOUT_MS') || 60000),
+            },
+        } : {}),
         codexBotTokens,
         antigravityBotTokens,
         tgBotToken,
@@ -142,6 +158,12 @@ export function loadConfig() {
         voiceTextLimit: intEnv('VOICE_TEXT_LIMIT', 2800),
         voiceTtsTimeoutMs: intEnv('VOICE_TTS_TIMEOUT_MS', 300_000),
     };
+    if (dshBotToken && !config.dsh)
+        throw new Error('DSH_BOT_TOKEN requires DSH_ENABLED=true');
+    if (config.dsh && (!Number.isSafeInteger(config.dsh.startupTimeoutMs) || config.dsh.startupTimeoutMs <= 0))
+        throw new Error('DSH_STARTUP_TIMEOUT_MS must be a positive integer');
+    if (config.wxEnabled && codexBotTokens.length === 0 && antigravityBotTokens.length === 0)
+        throw new Error('WX_ENABLED currently requires a Codex or Antigravity runtime alongside DSH');
     ensureAppDirs(config);
     return config;
 }
@@ -176,6 +198,20 @@ export function validateCodexBotTokens(tokens) {
         seen.add(token);
     }
 }
+export function parseDshPatches(value) {
+    if (!value?.trim())
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error('DSH_PATCHES must be a JSON array of patch paths');
+    }
+    if (!Array.isArray(parsed) || !parsed.every(item => typeof item === 'string' && item.trim().length > 0))
+        throw new Error('DSH_PATCHES must be a JSON array of patch paths');
+    return parsed.map(item => path.resolve(item));
+}
 export function validateOpencodeBotToken(token, codexTokens) {
     if (!token)
         return;

package/dist/controller/access.d.ts

@@ -1,11 +1 @@
-import type { AppConfig } from '../config.js';
-import type { AccessPresetValue, ApprovalPolicyValue, ChatSessionSettings, SandboxModeValue } from '../types.js';
-export interface ResolvedAccessMode {
-    preset: AccessPresetValue;
-    approvalPolicy: ApprovalPolicyValue;
-    sandboxMode: SandboxModeValue;
-}
-export declare const ACCESS_PRESETS: AccessPresetValue[];
-export declare function normalizeAccessPreset(value: string | null | undefined): AccessPresetValue | null;
-export declare function resolveConfiguredAccessPreset(settings: Pick<ChatSessionSettings, 'accessPreset'> | null | undefined): AccessPresetValue;
-export declare function resolveAccessMode(config: Pick<AppConfig, 'defaultApprovalPolicy' | 'defaultSandboxMode'>, settings: Pick<ChatSessionSettings, 'accessPreset'> | null | undefined): ResolvedAccessMode;
+export * from '../core/access.js';

package/dist/controller/access.js

@@ -1,33 +1 @@
-export const ACCESS_PRESETS = ['read-only', 'default', 'full-access'];
-export function normalizeAccessPreset(value) {
-    if (value === 'read-only' || value === 'default' || value === 'full-access') {
-        return value;
-    }
-    return null;
-}
-export function resolveConfiguredAccessPreset(settings) {
-    return settings?.accessPreset ?? 'default';
-}
-export function resolveAccessMode(config, settings) {
-    const preset = resolveConfiguredAccessPreset(settings);
-    switch (preset) {
-        case 'read-only':
-            return {
-                preset,
-                approvalPolicy: 'on-request',
-                sandboxMode: 'read-only',
-            };
-        case 'full-access':
-            return {
-                preset,
-                approvalPolicy: 'never',
-                sandboxMode: 'danger-full-access',
-            };
-        default:
-            return {
-                preset: 'default',
-                approvalPolicy: config.defaultApprovalPolicy,
-                sandboxMode: config.defaultSandboxMode,
-            };
-    }
-}
+export * from '../core/access.js';

package/dist/controller/activity.d.ts

@@ -1,62 +1 @@
-import type { JsonRpcNotification } from '../codex_app/client.js';
-export interface RawExecCommandEvent {
-    callId: string;
-    turnId: string;
-    command: string[];
-    cwd: string | null;
-    parsedCmd: any[];
-}
-export type TurnActivityState = 'thinking' | 'reading' | 'searching' | 'editing' | 'running_command' | 'approval_waiting' | 'completed' | 'interrupted';
-export type TurnOutputKind = 'commentary' | 'final_answer' | 'tool_summary' | 'error';
-export type TurnActivityEvent = {
-    kind: 'user_message';
-    turnId: string;
-    text: string;
-} | {
-    kind: 'agent_message_started';
-    turnId: string;
-    itemId: string;
-    phase: string | null;
-    outputKind: TurnOutputKind;
-    isPlan?: boolean;
-} | {
-    kind: 'agent_message_delta';
-    turnId: string;
-    itemId: string;
-    delta: string;
-    outputKind: TurnOutputKind;
-    isPlan?: boolean;
-} | {
-    kind: 'agent_message_completed';
-    turnId: string;
-    itemId: string;
-    phase: string | null;
-    text: string | null;
-    outputKind: TurnOutputKind;
-    isPlan?: boolean;
-} | {
-    kind: 'reasoning_started';
-    turnId: string;
-    state: 'thinking';
-} | {
-    kind: 'reasoning_completed';
-    turnId: string;
-    state: 'thinking';
-} | {
-    kind: 'tool_started';
-    turnId: string;
-    exec: RawExecCommandEvent;
-    state: TurnActivityState;
-} | {
-    kind: 'tool_completed';
-    turnId: string;
-    exec: RawExecCommandEvent;
-    state: TurnActivityState;
-} | {
-    kind: 'turn_completed';
-    turnId: string;
-    state: 'completed' | 'interrupted';
-};
-export declare function normalizeTurnActivityEvent(notification: JsonRpcNotification): TurnActivityEvent | null;
-export declare function classifyAgentOutput(phase: string | null, completed: boolean): TurnOutputKind;
-export declare function inferToolActivityState(event: RawExecCommandEvent): TurnActivityState;
+export * from '../codex_app/activity.js';

package/dist/controller/activity.js

@@ -1,418 +1,2 @@
-export function normalizeTurnActivityEvent(notification) {
-    switch (notification.method) {
-        case 'item/started':
-            return normalizeStartedEvent(notification.params);
-        case 'item/agentMessage/delta':
-            return normalizeAgentDeltaEvent(notification.params);
-        case 'item/plan/delta':
-            return normalizePlanDeltaEvent(notification.params);
-        case 'item/completed':
-            return normalizeCompletedEvent(notification.params);
-        case 'turn/plan/updated':
-            return normalizePlanUpdatedEvent(notification.params);
-        case 'codex/event/exec_command_begin':
-            return normalizeToolEvent(notification.params, 'tool_started');
-        case 'codex/event/exec_command_end':
-            return normalizeToolEvent(notification.params, 'tool_completed');
-        case 'turn/completed': {
-            const turnId = extractTurnId(notification.params);
-            if (!turnId)
-                return null;
-            return {
-                kind: 'turn_completed',
-                turnId,
-                state: 'completed',
-            };
-        }
-        case 'turn/interrupted':
-        case 'turn/aborted': {
-            const turnId = extractTurnId(notification.params);
-            if (!turnId)
-                return null;
-            return {
-                kind: 'turn_completed',
-                turnId,
-                state: 'interrupted',
-            };
-        }
-        default:
-            return null;
-    }
-}
-function normalizeStartedEvent(params) {
-    const turnId = extractTurnId(params);
-    if (!turnId)
-        return null;
-    const item = params?.item;
-    const itemType = normalizeEventItemType(item);
-    if (itemType === 'reasoning') {
-        return {
-            kind: 'reasoning_started',
-            turnId,
-            state: 'thinking',
-        };
-    }
-    const toolEvent = normalizeThreadItemToolEvent(params, 'tool_started');
-    if (toolEvent) {
-        return toolEvent;
-    }
-    if (!isRelayableTextItemType(itemType)) {
-        return null;
-    }
-    const itemId = extractItemId(item);
-    if (!itemId)
-        return null;
-    const phase = itemType === 'plan' ? 'commentary' : extractAgentPhase(item);
-    return {
-        kind: 'agent_message_started',
-        turnId,
-        itemId,
-        phase,
-        outputKind: outputKindForItemType(itemType, phase, false),
-        isPlan: itemType === 'plan',
-    };
-}
-function normalizeAgentDeltaEvent(params) {
-    const turnId = extractTurnId(params);
-    const delta = extractAgentDeltaText(params);
-    const itemId = extractItemId(params);
-    if (!turnId || !delta || !itemId) {
-        return null;
-    }
-    const phase = extractAgentPhase(params);
-    return {
-        kind: 'agent_message_delta',
-        turnId,
-        itemId,
-        delta,
-        outputKind: classifyAgentOutput(phase, false),
-    };
-}
-function normalizePlanDeltaEvent(params) {
-    const turnId = extractTurnId(params);
-    const delta = extractAgentDeltaText(params);
-    const itemId = extractItemId(params);
-    if (!turnId || !delta || !itemId) {
-        return null;
-    }
-    return {
-        kind: 'agent_message_delta',
-        turnId,
-        itemId,
-        delta,
-        outputKind: 'commentary',
-        isPlan: true,
-    };
-}
-function normalizeCompletedEvent(params) {
-    const turnId = extractTurnId(params);
-    if (!turnId)
-        return null;
-    const item = params?.item;
-    const itemType = normalizeEventItemType(item);
-    if (itemType === 'reasoning') {
-        return {
-            kind: 'reasoning_completed',
-            turnId,
-            state: 'thinking',
-        };
-    }
-    const toolEvent = normalizeThreadItemToolEvent(params, 'tool_completed');
-    if (toolEvent) {
-        return toolEvent;
-    }
-    if (!isRelayableTextItemType(itemType)) {
-        return null;
-    }
-    const itemId = extractItemId(item);
-    if (!itemId)
-        return null;
-    const phase = itemType === 'plan' ? 'commentary' : extractAgentPhase(item);
-    return {
-        kind: 'agent_message_completed',
-        turnId,
-        itemId,
-        phase,
-        text: extractCompletedAgentText(params),
-        outputKind: outputKindForItemType(itemType, phase, true),
-        isPlan: itemType === 'plan',
-    };
-}
-function normalizePlanUpdatedEvent(params) {
-    const turnId = extractTurnId(params);
-    if (!turnId) {
-        return null;
-    }
-    const text = formatPlanUpdateText(params);
-    if (!text) {
-        return null;
-    }
-    return {
-        kind: 'agent_message_completed',
-        turnId,
-        itemId: `${turnId}:plan`,
-        phase: 'commentary',
-        text,
-        outputKind: 'commentary',
-        isPlan: true,
-    };
-}
-function normalizeToolEvent(params, kind) {
-    const exec = extractRawExecCommandEvent(params);
-    if (!exec) {
-        return null;
-    }
-    return {
-        kind,
-        turnId: exec.turnId,
-        exec,
-        state: inferToolActivityState(exec),
-    };
-}
-function normalizeThreadItemToolEvent(params, kind) {
-    const turnId = extractTurnId(params);
-    const item = params?.item;
-    const itemId = extractItemId(item);
-    const itemType = normalizeEventItemType(item);
-    if (!turnId || !itemId || !itemType) {
-        return null;
-    }
-    let command = [];
-    let cwd = null;
-    let parsedCmd = [];
-    switch (itemType) {
-        case 'commandexecution':
-            command = typeof item.command === 'string' ? [item.command] : [];
-            cwd = typeof item.cwd === 'string' ? item.cwd : null;
-            parsedCmd = normalizeCommandActions(item.commandActions);
-            break;
-        case 'filechange':
-            parsedCmd = normalizeFileChanges(item.changes);
-            break;
-        case 'websearch':
-            parsedCmd = [{
-                    type: 'search',
-                    query: typeof item.query === 'string' ? item.query : '',
-                    path: null,
-                }];
-            break;
-        case 'imageview':
-            parsedCmd = [{ type: 'read', path: typeof item.path === 'string' ? item.path : null }];
-            break;
-        case 'mcptoolcall':
-            command = [`MCP ${String(item.server ?? 'server')}/${String(item.tool ?? 'tool')}`];
-            break;
-        case 'dynamictoolcall':
-            command = [`Tool ${item.namespace ? `${String(item.namespace)}/` : ''}${String(item.tool ?? 'tool')}`];
-            break;
-        case 'collabagenttoolcall':
-            command = [`Agent ${String(item.tool ?? 'operation')}`];
-            break;
-        case 'imagegeneration':
-            command = ['Image generation'];
-            break;
-        default:
-            return null;
-    }
-    const exec = {
-        callId: itemId,
-        turnId,
-        command,
-        cwd,
-        parsedCmd,
-    };
-    return {
-        kind,
-        turnId,
-        exec,
-        state: inferToolActivityState(exec),
-    };
-}
-function normalizeCommandActions(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.map((entry) => {
-        const type = typeof entry?.type === 'string' ? entry.type : '';
-        if (type === 'listFiles') {
-            return { ...entry, type: 'list_files' };
-        }
-        return entry;
-    });
-}
-function normalizeFileChanges(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.map((entry) => ({
-        type: 'apply_patch',
-        path: typeof entry?.path === 'string' ? entry.path : null,
-    }));
-}
-export function classifyAgentOutput(phase, completed) {
-    if (!phase) {
-        return completed ? 'final_answer' : 'commentary';
-    }
-    const normalized = phase.replace(/[^a-z]/gi, '').toLowerCase();
-    if (normalized === 'final' || normalized === 'finalanswer' || normalized === 'answer' || normalized === 'response') {
-        return 'final_answer';
-    }
-    return 'commentary';
-}
-export function inferToolActivityState(event) {
-    const parsedTypes = (event.parsedCmd ?? [])
-        .map((entry) => (typeof entry?.type === 'string' ? entry.type : ''))
-        .filter(Boolean);
-    if (parsedTypes.includes('search')) {
-        return 'searching';
-    }
-    if (parsedTypes.includes('read') || parsedTypes.includes('list_files')) {
-        return 'reading';
-    }
-    if (parsedTypes.some(type => ['write', 'edit', 'apply_patch', 'move', 'copy', 'delete', 'mkdir'].includes(type))) {
-        return 'editing';
-    }
-    return 'running_command';
-}
-function extractRawExecCommandEvent(params) {
-    const msg = params?.msg;
-    if (!msg || typeof msg !== 'object') {
-        return null;
-    }
-    const callId = typeof msg.call_id === 'string' ? msg.call_id : null;
-    const turnId = typeof msg.turn_id === 'string' ? msg.turn_id : null;
-    if (!callId || !turnId) {
-        return null;
-    }
-    return {
-        callId,
-        turnId,
-        command: Array.isArray(msg.command) ? msg.command.map((entry) => String(entry)) : [],
-        cwd: msg.cwd ? String(msg.cwd) : null,
-        parsedCmd: Array.isArray(msg.parsed_cmd) ? msg.parsed_cmd : [],
-    };
-}
-function extractTurnId(params) {
-    const candidates = [
-        params?.turnId,
-        params?.turn_id,
-        params?.turn?.id,
-        params?.turn?.turnId,
-        params?.item?.turnId,
-        params?.item?.turn_id,
-    ];
-    for (const candidate of candidates) {
-        if (candidate !== null && candidate !== undefined && String(candidate).trim()) {
-            return String(candidate);
-        }
-    }
-    return null;
-}
-function extractItemId(value) {
-    const candidates = [
-        value?.itemId,
-        value?.item_id,
-        value?.id,
-        value?.item?.id,
-    ];
-    for (const candidate of candidates) {
-        if (candidate !== null && candidate !== undefined && String(candidate).trim()) {
-            return String(candidate);
-        }
-    }
-    return null;
-}
-function extractAgentPhase(value) {
-    const phase = value?.phase ?? value?.item?.phase ?? null;
-    return typeof phase === 'string' && phase.trim() ? phase : null;
-}
-function extractAgentDeltaText(params) {
-    const candidates = [
-        params?.delta,
-        params?.textDelta,
-        params?.contentDelta,
-        params?.text,
-    ];
-    for (const candidate of candidates) {
-        const text = extractTextCandidate(candidate);
-        if (text) {
-            return text;
-        }
-    }
-    return null;
-}
-function extractCompletedAgentText(params) {
-    const itemType = normalizeEventItemType(params?.item ?? params);
-    if (!isRelayableTextItemType(itemType)) {
-        return null;
-    }
-    const item = params?.item ?? params;
-    const directText = extractTextCandidate(item?.text)
-        ?? extractTextCandidate(item?.content)
-        ?? extractTextCandidate(item?.value);
-    if (directText !== null) {
-        return directText;
-    }
-    return '';
-}
-function isRelayableTextItemType(itemType) {
-    return itemType === 'agentmessage' || itemType === 'assistantmessage' || itemType === 'plan';
-}
-function outputKindForItemType(itemType, phase, completed) {
-    if (itemType === 'plan') {
-        return 'commentary';
-    }
-    return classifyAgentOutput(phase, completed);
-}
-function formatPlanUpdateText(params) {
-    const lines = [];
-    const explanation = extractTextCandidate(params?.explanation);
-    if (explanation) {
-        lines.push(explanation);
-    }
-    const plan = Array.isArray(params?.plan) ? params.plan : [];
-    for (const entry of plan) {
-        const step = extractTextCandidate(entry?.step);
-        if (!step) {
-            continue;
-        }
-        const status = typeof entry?.status === 'string' && entry.status ? ` [${entry.status}]` : '';
-        lines.push(`- ${step}${status}`);
-    }
-    return lines.join('\n').trim() || null;
-}
-function normalizeEventItemType(value) {
-    const raw = value?.type ?? value?.itemType ?? value?.item_type ?? value?.kind;
-    if (typeof raw !== 'string') {
-        return null;
-    }
-    return raw.replace(/[^a-z]/gi, '').toLowerCase();
-}
-function extractTextCandidate(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (!value || typeof value !== 'object') {
-        return null;
-    }
-    for (const key of ['text', 'delta', 'content', 'value']) {
-        const candidate = value[key];
-        if (typeof candidate === 'string') {
-            return candidate;
-        }
-    }
-    for (const key of ['parts', 'segments', 'content']) {
-        const candidate = value[key];
-        if (!Array.isArray(candidate)) {
-            continue;
-        }
-        const text = candidate
-            .map((entry) => extractTextCandidate(entry))
-            .filter((entry) => entry !== null)
-            .join('');
-        if (text) {
-            return text;
-        }
-    }
-    return null;
-}
+// Compatibility export for existing control-plane consumers.
+export * from '../codex_app/activity.js';

package/dist/controller/auth_errors.d.ts

@@ -0,0 +1,11 @@
+import { CodexAuthRotationReason } from './state_types.js';
+export declare function classifyCodexAuthRotationError(params: any): CodexAuthRotationReason | null;
+export declare function isCodexAuthInvalidError(text: string): boolean;
+export declare function isCodexQuotaLimitError(text: string): boolean;
+export declare function formatCodexNotificationError(params: any): string;
+export declare function isRetryableCodexTransportError(params: any): boolean;
+export declare function collectCodexErrorText(params: any): string;
+export declare function formatKnownCodexAccessError(raw: string): string | null;
+export declare function isChatGptBackendAccessBlocked(raw: string): boolean;
+export declare function cleanUserFacingError(raw: string): string;
+export declare function clipUserFacingError(raw: string, limit?: number): string;