@foxden-app/foxclaw 0.2.0

package/dist/controller/activity.js

@@ -0,0 +1,330 @@
+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',
+        };
+    }
+    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',
+        };
+    }
+    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),
+    };
+}
+export function classifyAgentOutput(phase, completed) {
+    if (!phase) {
+        return completed ? 'final_answer' : 'commentary';
+    }
+    const normalized = phase.replace(/[^a-z]/gi, '').toLowerCase();
+    if (normalized === 'final' || 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;
+}

package/dist/controller/commands.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedCommand {
+    name: string;
+    args: string[];
+    targetBot: string | null;
+}
+export declare function parseCommand(text: string): ParsedCommand | null;

package/dist/controller/commands.js

@@ -0,0 +1,17 @@
+export function parseCommand(text) {
+    if (!text.startsWith('/'))
+        return null;
+    const parts = text.trim().split(/\s+/);
+    const rawName = parts.shift();
+    if (!rawName)
+        return null;
+    const [namePart, targetPart] = rawName.slice(1).split('@', 2);
+    const name = (namePart ?? '').toLowerCase();
+    if (!name)
+        return null;
+    return {
+        name,
+        args: parts,
+        targetBot: targetPart ? targetPart.toLowerCase() : null,
+    };
+}

package/dist/controller/controller.d.ts

@@ -0,0 +1,326 @@
+import type { AppConfig } from '../config.js';
+import type { Logger } from '../logger.js';
+import type { BridgeStore } from '../store/database.js';
+import type { RuntimeStatus } from '../types.js';
+import type { TelegramGateway, TelegramTextEvent } from '../telegram/gateway.js';
+import { BridgeMessagingRouter } from '../channels/bridge_messaging_router.js';
+import type { CodexAppClient } from '../codex_app/client.js';
+export declare class BridgeSessionCore {
+    private readonly config;
+    private readonly store;
+    private readonly logger;
+    private readonly bot;
+    private readonly app;
+    private activeTurns;
+    private activeTurnsByTurnId;
+    private observedThreadWatchers;
+    private queuedPrompts;
+    private pendingTurnErrors;
+    private pendingUserInputs;
+    private pendingMcpElicitations;
+    private pendingPlanImplementations;
+    private pendingLoginsByScope;
+    private pendingLoginScopesById;
+    private pendingAuthAddsByLoginId;
+    private latestTurnDiffs;
+    private threadTokenUsageAlerts;
+    private pendingAuthChoiceLists;
+    private pendingApprovalMessages;
+    private pendingAuthRotation;
+    private authRotationInProgress;
+    private authRotationFailedTargets;
+    private localUsageCache;
+    private lastRemoteControlStatus;
+    private pendingThreadRenames;
+    private pendingThreadNewCwds;
+    private recentCommandUsageByScope;
+    private commandUsageSequence;
+    private locks;
+    private approvalTimers;
+    private submittedUserInputTimers;
+    private attachedThreads;
+    private botUsername;
+    private lastError;
+    /** Last threads-panel pagination state per scope (Telegram inline nav + /open index alignment). */
+    private threadListPresentationState;
+    private readonly messaging;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, bot: TelegramGateway, app: CodexAppClient, outbound: BridgeMessagingRouter);
+    /** Wire Telegram inbound events. Call before {@link startCodexApp}. */
+    registerTelegramInboundHandlers(): void;
+    /**
+     * Deliver an inbound user message through the same pipeline as Telegram `text` events
+     * (used by the Weixin adapter).
+     */
+    dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
+    /** Start Codex app-server transport and attach RPC listeners. */
+    startCodexApp(): Promise<void>;
+    /** Begin Telegram Bot API long-polling after handlers and Codex are ready. */
+    startTelegramPolling(): Promise<void>;
+    /** Telegram-only default startup (single channel). */
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getRuntimeStatus(): RuntimeStatus;
+    private handleText;
+    private handleCommand;
+    private buildHelpLines;
+    private rememberCommandUsage;
+    private sendNewThreadStartedMessage;
+    private handleWatchCommand;
+    private handleThreadArchiveIndexCommand;
+    private handleThreadRenameIndexCommand;
+    private handleCallback;
+    private handleApprovalTextCommand;
+    private handleNotification;
+    private handleServerRequest;
+    private sendApprovalRequestToThreadScopes;
+    private markApprovalResolvedForAllScopes;
+    private handleCodexErrorNotification;
+    private handleTurnStartedNotification;
+    private handleTurnDiffUpdated;
+    private handleThreadStatusChanged;
+    private handleThreadTokenUsageUpdated;
+    private handleThreadGoalNotification;
+    private handleMcpToolCallProgress;
+    private handleModelNotification;
+    private handleRemoteControlStatusChanged;
+    private shouldNotifyThreadTokenUsage;
+    private handleThreadLifecycleNotification;
+    private handleServerRequestResolved;
+    private handleAccountLoginCompleted;
+    private restorePendingAuthAdd;
+    private restoreAuthAfterAddFailure;
+    private handleAccountUpdated;
+    private handleRateLimitsUpdated;
+    private handleSkillsChangedNotification;
+    private handleAppListUpdated;
+    private handleMcpStartupStatusUpdated;
+    private handleMcpOauthLoginCompleted;
+    private handleBridgeWarningNotification;
+    private notifyBoundScopes;
+    private recordActiveTurnError;
+    private finishTerminalErroredActiveTurn;
+    private handleUserInputRequest;
+    private hasPendingUserInput;
+    private findPendingUserInputForScope;
+    private handleUserInputCallback;
+    private handleUserInputTextReply;
+    private handleUserInputAnswerCommand;
+    private refreshOrFinishUserInput;
+    private submitPendingUserInput;
+    private persistPendingUserInputAnswers;
+    private restorePendingUserInputs;
+    private restorePendingUserInputMessage;
+    private retireStalePendingUserInput;
+    private isPendingUserInputTurnLive;
+    private maybeSendPlanImplementationPrompt;
+    private findPendingPlanImplementation;
+    private clearPlanImplementationPromptsForScope;
+    private hasPendingUserInputForTurn;
+    private finalizeUserInputsForTurn;
+    private handlePlanImplementationCallback;
+    private handlePlanImplementationTextCommand;
+    private startPlanImplementationTurn;
+    private handleMcpElicitationRequest;
+    private hasPendingMcpElicitation;
+    private findPendingMcpElicitationForScope;
+    private handleMcpElicitationTextReply;
+    private handleMcpElicitationCallback;
+    private handleMcpElicitationTextCommand;
+    private createBinding;
+    private startTurnWithRecovery;
+    private buildTurnInput;
+    private resolveServiceTierForTurn;
+    private stageAttachments;
+    private registerActiveTurn;
+    private createActiveTurnState;
+    private setActiveTurn;
+    private getActiveTurn;
+    private getActiveTurnsForTurn;
+    private getPrimaryActiveTurnForTurn;
+    private hasAnyActiveTurnForTurn;
+    private deleteActiveTurn;
+    private deleteActiveTurnRecord;
+    private completeTurn;
+    private handleTurnActivityEvent;
+    private handleTurnActivityForActive;
+    private createApprovalRecord;
+    private createPermissionApprovalRecord;
+    private findChatByThread;
+    private findAllChatsByThread;
+    private scopeCanApproveThread;
+    private withLock;
+    private updateStatus;
+    private sendMessage;
+    private sendHtmlMessage;
+    private editMessage;
+    private editHtmlMessage;
+    private deleteMessage;
+    private sendTyping;
+    private sendObservedCliUserMessage;
+    private cleanupObservedTransientMessages;
+    private hasObservedPersistentReply;
+    private ensureThreadReady;
+    private handleAsyncError;
+    private armApprovalTimer;
+    private clearApprovalTimer;
+    private armSubmittedUserInputTimer;
+    private clearSubmittedUserInputTimer;
+    private notifySubmittedUserInputStillWaiting;
+    private expireApproval;
+    private tryRevealThread;
+    private bindCachedThread;
+    private resumeThreadForScope;
+    private setChatAccessPreset;
+    private clearAttachedThreadsForScope;
+    private storeThreadSession;
+    private resolveEffectiveAccess;
+    private localeForChat;
+    private findActiveTurn;
+    private clearObservedThreadWatchers;
+    private clearObservedTurnWatcher;
+    private stopWatchingScopeThread;
+    private forgetStaleActiveTurn;
+    private unwatchThread;
+    private watchThread;
+    private scheduleObservedThreadPoll;
+    private pollObservedThread;
+    private pollObservedSessionFile;
+    private ensureObservedActiveTurnState;
+    private applyObservedSessionEvents;
+    private applyObservedTurnSnapshot;
+    private handleTakeoverCommand;
+    private handleQueueCommand;
+    private handleActiveTurnInboundMessage;
+    private queuePromptAfterActiveTurn;
+    private steerActiveTurn;
+    private startQueuedPromptIfPresent;
+    private handleModeCommand;
+    private handleActiveTurnMessageModeCommand;
+    private handleGoalCommand;
+    private handleHistoryCommand;
+    private handleFilesCommand;
+    private handleRemoteCommand;
+    private handleFastCommand;
+    private setCollaborationMode;
+    private handleAuthReloadCommand;
+    private handleAuthCommand;
+    private handleAuthUseCommand;
+    private handleAuthToggleCommand;
+    private findLatestAuthChoiceList;
+    private handleAuthAddCommand;
+    private handleAccountCommand;
+    private handleQuotaCommand;
+    private handleQuotaNudgeCommand;
+    private handleLoginDeviceCommand;
+    private handleLoginCancelCommand;
+    private handleLogoutCommand;
+    private handleSteerCommand;
+    private handleForkCommand;
+    private handleRollbackCommand;
+    private handleRenameCommand;
+    private handleCompactCommand;
+    private handleArchiveCommand;
+    private handleUnarchiveCommand;
+    private handleReviewCommand;
+    private handleDiffCommand;
+    private handleLoadedCommand;
+    private handleSkillsCommand;
+    private handleSkillCommand;
+    private handleSkillConfigCommand;
+    private handleHooksCommand;
+    private handlePluginsCommand;
+    private handlePluginCommand;
+    private handlePluginSkillCommand;
+    private handleAppsCommand;
+    private handleFeaturesCommand;
+    private handleConfigCommand;
+    private handleRequirementsCommand;
+    private handleProviderCommand;
+    private handleMcpCommand;
+    private handleMcpReloadCommand;
+    private handleMcpLoginCommand;
+    private handleMcpResourceCommand;
+    private listSkillsForScope;
+    private requireReadyBinding;
+    private handleAuthPanelActionCallback;
+    private handleAuthToggleCallback;
+    private handleAuthSwitchCallback;
+    private maybeRunPendingAuthRotation;
+    private retryTurnAfterAuthRotation;
+    private selectNextCodexAuthCandidate;
+    private listCodexAuthState;
+    private switchCodexAuthAndRestart;
+    private buildNativeCollaborationMode;
+    private buildCodexUsageStatusLines;
+    private buildCodexLocalUsageStatusLines;
+    private resolveFastStatusLabel;
+    private readCachedCodexLocalUsageStats;
+    private handleModelCommand;
+    private handleEffortCommand;
+    private handleThreadOpenCallback;
+    private handleThreadActionCallback;
+    private handleThreadNewCallback;
+    private handleThreadNewCwdCallback;
+    private handleThreadNewCwdTextReply;
+    private startNewThreadForRequestedCwd;
+    private createAndBindNewThread;
+    private promptCreateMissingNewThreadCwd;
+    private createMissingCwdAndStartNewThread;
+    private finishThreadNewCwdConfirmation;
+    private inspectNewThreadCwd;
+    private handleThreadRenameTextReply;
+    private archiveThreadFromPanel;
+    private showThreadsPanelFromStoredState;
+    private handleTurnInterruptCallback;
+    private handleNavigationCallback;
+    private showWherePanel;
+    private handleThreadListNavigationCallback;
+    private showThreadsPanel;
+    private showModelSettingsPanel;
+    private showSetupPanel;
+    private showAccessSettingsPanel;
+    private handleSettingsCallback;
+    private handleSetupCallback;
+    private handleAccessSettingsCallback;
+    private refreshModelSettingsPanel;
+    private refreshSetupPanel;
+    private refreshAccessSettingsPanel;
+    private startBoundTurnFromEvent;
+    private requestInterrupt;
+    private queueTurnRender;
+    private syncTurnStatus;
+    private syncTurnStream;
+    private cleanupStaleTurnPreviews;
+    private recoverLiveTurnPreview;
+    private interruptOrphanWaitingUserInput;
+    private cleanupFinishedPreview;
+    private cleanupStaleInterruptButton;
+    private cleanupTransientPreview;
+    private abandonActiveTurns;
+    private releaseActiveTurnsForBridgeShutdown;
+    private retirePreviewMessage;
+    private forgetPreviewRecord;
+    private clearMessageButtons;
+    private sendDraft;
+    private renderActiveStatus;
+    private dismissTurnPreview;
+    private ensureStatusMessage;
+    private rebaseStatusMessage;
+    private archiveStatusMessage;
+    private noteToolCommandStart;
+    private noteToolCommandEnd;
+    private scheduleToolBatchArchive;
+    private promoteReadyToolBatch;
+    private clearToolBatchTimer;
+    private scheduleRenderRetry;
+    private clearRenderRetry;
+    private notePendingApprovalStatus;
+    private clearPendingApprovalStatus;
+    private syncDraftTurnStream;
+    private renderDraftStreamText;
+    private findStreamingSegment;
+    private findActiveTurnByThreadId;
+    private findActiveTurnsByThreadId;
+    private syncSegmentTimeline;
+}
+export { BridgeSessionCore as BridgeController };