@foxden-app/foxclaw 0.12.0 → 0.13.0

package/dist/controller/shared_helpers.d.ts

@@ -0,0 +1,53 @@
+import type { AppLocale, ActiveTurnMessageMode, CodexThreadGoal, CollaborationModeValue, AppTurnSnapshot, ReviewTarget } from '../types.js';
+import { ApprovalAction, McpElicitationAction, AuthRetryContext } from './state_types.js';
+export declare function firstLine(value: string): string;
+export declare function parseReviewTarget(args: string[]): ReviewTarget | null;
+export declare function summarizeTurnItems(items: AppTurnSnapshot['items']): string;
+export declare function turnHasRelayableOutcome(turn: AppTurnSnapshot): boolean;
+export declare function mapGoalNotification(raw: any): CodexThreadGoal | null;
+export declare function formatWarningNotification(locale: AppLocale, method: string, params: any): string;
+export declare function isCodexTransportFallbackWarning(method: string, params: any): boolean;
+export declare function normalizeThreadStatusLabel(raw: any): string;
+export declare function formatThreadTokenUsage(raw: any): {
+    percent: number;
+    total: number;
+    limit: number;
+} | null;
+export declare function numberOrNull(value: unknown): number | null;
+export declare function parsePositiveInt(value: string | undefined, fallback: number, min: number, max: number): number | null;
+export declare function formatConfigValue(value: unknown): string;
+export declare function formatRawLabel(value: unknown): string;
+export declare function toErrorMeta(error: unknown): Record<string, unknown>;
+export declare function formatUserError(error: unknown): string;
+export declare function normalizeRequestedCollaborationMode(value: string): CollaborationModeValue | null;
+export declare function normalizeRequestedActiveTurnMessageMode(value: string): ActiveTurnMessageMode | null;
+export declare function normalizeApprovalTextAction(value: string): ApprovalAction | null;
+export declare function normalizePlanImplementationTextAction(value: string): 'run' | 'fresh' | 'stay' | null;
+export declare function normalizeMcpElicitationTextAction(value: string): McpElicitationAction | null;
+export declare function resolveCollaborationMode(mode: CollaborationModeValue | null | undefined): CollaborationModeValue;
+export declare function attachedThreadKey(scopeId: string, threadId: string): string;
+export declare function activeTurnKey(scopeId: string, turnId: string): string;
+export declare function parseActiveTurnKey(key: string): {
+    scopeId: string;
+    turnId: string;
+} | null;
+export declare function normalizeHelpUsageKey(name: string): string | null;
+export declare function formatWatchCallbackText(locale: AppLocale, mode: 'already' | 'active' | 'idle', threadId: string): string;
+export declare function cloneAuthRetryContext(context: AuthRetryContext): AuthRetryContext;
+export declare function clipButtonText(text: string): string;
+export declare function stringOrNull(value: unknown): string | null;
+export declare function formatCompactNumber(value: number): string;
+export declare function formatTokenCount(value: number): string;
+export declare function formatCodexTokenCountWithMetric(value: number): string;
+export declare function formatLocalTimestamp(seconds: number): string;
+export declare function formatShortStatusError(error: unknown): string;
+export declare function isThreadNotFoundError(error: unknown): boolean;
+export declare function isThreadActiveWriterError(error: unknown): boolean;
+export declare function isNoActiveTurnToSteerError(error: unknown): boolean;
+export declare function isThreadQueueUnsupportedError(error: unknown): boolean;
+export declare function isThreadNewCwdCreateConfirmation(text: string): boolean;
+export declare function isThreadNewCwdCancelConfirmation(text: string): boolean;
+export declare function isTelegramMessageGone(error: unknown): boolean;
+export declare function isTelegramMessageTooLong(error: unknown): boolean;
+export declare function isFileMissingError(error: unknown): boolean;
+export declare function isReadableSessionPath(sessionPath: string): Promise<boolean>;

package/dist/controller/shared_helpers.js

@@ -0,0 +1,399 @@
+import { t } from '../i18n.js';
+import { formatMetricTokenCount } from '../store/token_usage.js';
+import fs from 'node:fs/promises';
+import { truncateInline } from './turn_rendering.js';
+import { DEFAULT_COLLABORATION_MODE, PINNED_HELP_COMMANDS, DYNAMIC_HELP_COMMANDS, } from './state_types.js';
+import { formatKnownCodexAccessError, cleanUserFacingError } from './auth_errors.js';
+export function firstLine(value) {
+    return value.split(/\r?\n/, 1)[0]?.trim() || value.trim();
+}
+export function parseReviewTarget(args) {
+    if (args.length === 0) {
+        return { type: 'uncommittedChanges' };
+    }
+    const [kind, ...rest] = args;
+    if (kind === 'base') {
+        const branch = rest.join(' ').trim();
+        return branch ? { type: 'baseBranch', branch } : null;
+    }
+    if (kind === 'commit') {
+        const sha = rest[0]?.trim();
+        return sha ? { type: 'commit', sha, title: rest.slice(1).join(' ').trim() || null } : null;
+    }
+    if (kind === 'custom') {
+        const instructions = rest.join(' ').trim();
+        return instructions ? { type: 'custom', instructions } : null;
+    }
+    return { type: 'custom', instructions: args.join(' ').trim() };
+}
+export function summarizeTurnItems(items) {
+    const counts = new Map();
+    for (const item of items) {
+        const type = item.type || 'item';
+        counts.set(type, (counts.get(type) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .slice(0, 8)
+        .map(([type, count]) => `${type}=${count}`)
+        .join(', ');
+}
+export function turnHasRelayableOutcome(turn) {
+    if (turn.error?.trim()) {
+        return true;
+    }
+    return turn.items.some((item) => {
+        const type = item.type.toLowerCase();
+        if (!item.text?.trim()) {
+            return false;
+        }
+        if (type === 'plan') {
+            return true;
+        }
+        if (type !== 'agentmessage' && type !== 'assistantmessage') {
+            return false;
+        }
+        const phase = item.phase?.toLowerCase() ?? null;
+        return phase === null || phase.startsWith('final');
+    });
+}
+export function mapGoalNotification(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const status = raw.status === 'paused' || raw.status === 'budgetLimited' || raw.status === 'complete'
+        ? raw.status
+        : 'active';
+    return {
+        threadId: String(raw.threadId ?? ''),
+        objective: String(raw.objective ?? ''),
+        status,
+        tokenBudget: numberOrNull(raw.tokenBudget),
+        tokensUsed: numberOrNull(raw.tokensUsed) ?? 0,
+        timeUsedSeconds: numberOrNull(raw.timeUsedSeconds) ?? 0,
+        createdAt: numberOrNull(raw.createdAt) ?? 0,
+        updatedAt: numberOrNull(raw.updatedAt) ?? 0,
+    };
+}
+export function formatWarningNotification(locale, method, params) {
+    if (method === 'configWarning') {
+        return [
+            t(locale, 'warning_config_title'),
+            String(params?.summary ?? t(locale, 'unknown')),
+            params?.path ? `path: ${String(params.path)}` : null,
+            params?.details ? truncateInline(String(params.details), 600) : null,
+        ].filter(Boolean).join('\n');
+    }
+    if (method === 'deprecationNotice') {
+        return [
+            t(locale, 'warning_deprecation_title'),
+            String(params?.summary ?? t(locale, 'unknown')),
+            params?.details ? truncateInline(String(params.details), 600) : null,
+        ].filter(Boolean).join('\n');
+    }
+    if (method === 'guardianWarning') {
+        return `${t(locale, 'warning_guardian_title')}\n${String(params?.message ?? t(locale, 'unknown'))}`;
+    }
+    return `${t(locale, 'warning_title')}\n${String(params?.message ?? t(locale, 'unknown'))}`;
+}
+export function isCodexTransportFallbackWarning(method, params) {
+    if (method !== 'warning') {
+        return false;
+    }
+    return /falling back from websockets? to https transport/i.test(String(params?.message ?? ''));
+}
+export function normalizeThreadStatusLabel(raw) {
+    if (typeof raw === 'string') {
+        return raw;
+    }
+    if (typeof raw?.type === 'string') {
+        return raw.type;
+    }
+    return 'unknown';
+}
+export function formatThreadTokenUsage(raw) {
+    const total = numberOrNull(raw?.last?.totalTokens ?? raw?.last?.total_tokens);
+    const limit = numberOrNull(raw?.modelContextWindow ?? raw?.model_context_window);
+    if (total === null || limit === null || total <= 0 || limit <= 0) {
+        return null;
+    }
+    const rawPercent = Math.round((total / limit) * 100);
+    const percent = Math.min(100, rawPercent);
+    return rawPercent >= 85 ? { percent, total, limit } : null;
+}
+export function numberOrNull(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+export function parsePositiveInt(value, fallback, min, max) {
+    if (value === undefined || value.trim() === '') {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed < min || parsed > max) {
+        return null;
+    }
+    return parsed;
+}
+export function formatConfigValue(value) {
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(formatConfigValue).join(', ');
+    }
+    if (value && typeof value === 'object') {
+        const keys = Object.keys(value);
+        if (keys.length === 1) {
+            return keys[0];
+        }
+    }
+    return truncateInline(JSON.stringify(value), 160);
+}
+export function formatRawLabel(value) {
+    if (value === null || value === undefined) {
+        return 'unknown';
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        if (keys.length === 1) {
+            return keys[0];
+        }
+    }
+    return truncateInline(JSON.stringify(value), 160);
+}
+export function toErrorMeta(error) {
+    if (error instanceof Error) {
+        return { message: error.message, stack: error.stack };
+    }
+    return { error: String(error) };
+}
+export function formatUserError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export function normalizeRequestedCollaborationMode(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'plan' || normalized === '计划' || normalized === '规划') {
+        return 'plan';
+    }
+    if (normalized === 'default' || normalized === 'agent' || normalized === '默认') {
+        return 'default';
+    }
+    return null;
+}
+export function normalizeRequestedActiveTurnMessageMode(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'steer' || normalized === 'guide' || normalized === '引导') {
+        return 'steer';
+    }
+    if (normalized === 'queue' || normalized === '排队') {
+        return 'queue';
+    }
+    return null;
+}
+export function normalizeApprovalTextAction(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'allow' || normalized === 'accept' || normalized === 'yes' || normalized === '同意' || normalized === '允许') {
+        return 'accept';
+    }
+    if (normalized === 'session' || normalized === 'allow_session' || normalized === '本会话' || normalized === '本会话允许') {
+        return 'session';
+    }
+    if (normalized === 'deny' || normalized === 'decline' || normalized === 'no' || normalized === '拒绝') {
+        return 'deny';
+    }
+    return null;
+}
+export function normalizePlanImplementationTextAction(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'run' || normalized === 'execute' || normalized === '执行') {
+        return 'run';
+    }
+    if (normalized === 'fresh' || normalized === 'clear' || normalized === '新上下文') {
+        return 'fresh';
+    }
+    if (normalized === 'stay' || normalized === 'plan' || normalized === '继续规划') {
+        return 'stay';
+    }
+    return null;
+}
+export function normalizeMcpElicitationTextAction(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'accept' || normalized === 'allow' || normalized === '同意' || normalized === '接受') {
+        return 'accept';
+    }
+    if (normalized === 'decline' || normalized === 'deny' || normalized === '拒绝') {
+        return 'decline';
+    }
+    if (normalized === 'cancel' || normalized === '取消') {
+        return 'cancel';
+    }
+    return null;
+}
+export function resolveCollaborationMode(mode) {
+    return mode ?? DEFAULT_COLLABORATION_MODE;
+}
+export function attachedThreadKey(scopeId, threadId) {
+    return `${scopeId}:${threadId}`;
+}
+export function activeTurnKey(scopeId, turnId) {
+    return `${encodeURIComponent(scopeId)}:${encodeURIComponent(turnId)}`;
+}
+export function parseActiveTurnKey(key) {
+    const split = key.indexOf(':');
+    if (split === -1) {
+        return null;
+    }
+    return {
+        scopeId: decodeURIComponent(key.slice(0, split)),
+        turnId: decodeURIComponent(key.slice(split + 1)),
+    };
+}
+export function normalizeHelpUsageKey(name) {
+    const normalized = name.toLowerCase();
+    switch (normalized) {
+        case 'start':
+            return 'help';
+        case 'followup':
+            return 'active';
+        case 'login':
+            return 'login_device';
+        case 'codex_restart':
+            return 'auth_reload';
+        case 'file':
+            return 'files';
+        case 'rollback':
+            return 'undo';
+        case 'access':
+            return 'permissions';
+        case 'focus':
+            return 'reveal';
+        case 'model':
+            return 'models';
+        default:
+            if (PINNED_HELP_COMMANDS.some(entry => entry.key === normalized)) {
+                return normalized;
+            }
+            if (DYNAMIC_HELP_COMMANDS.some(entry => entry.key === normalized)) {
+                return normalized;
+            }
+            return null;
+    }
+}
+export function formatWatchCallbackText(locale, mode, threadId) {
+    if (mode === 'already') {
+        return t(locale, 'watch_already_enabled', { threadId });
+    }
+    if (mode === 'active') {
+        return t(locale, 'watch_started_active', { threadId });
+    }
+    return t(locale, 'watch_started_idle', { threadId });
+}
+export function cloneAuthRetryContext(context) {
+    return {
+        input: context.input,
+        threadId: context.threadId,
+        cwd: context.cwd,
+        chatId: context.chatId,
+        chatType: context.chatType,
+        topicId: context.topicId,
+        collaborationMode: context.collaborationMode,
+        failedAuthTargets: new Set(context.failedAuthTargets),
+    };
+}
+export function clipButtonText(text) {
+    const trimmed = text.replace(/\s+/g, ' ').trim();
+    return trimmed.length > 48 ? `${trimmed.slice(0, 47)}...` : trimmed;
+}
+export function stringOrNull(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+export function formatCompactNumber(value) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(1).replace(/\.0$/, '');
+}
+export function formatTokenCount(value) {
+    if (!Number.isFinite(value)) {
+        return '?';
+    }
+    return Math.round(value).toLocaleString('en-US');
+}
+export function formatCodexTokenCountWithMetric(value) {
+    if (value >= 1_000_000) {
+        return `${formatMetricTokenCount(value)} (${formatTokenCount(value)})`;
+    }
+    return formatTokenCount(value);
+}
+export function formatLocalTimestamp(seconds) {
+    const date = new Date(seconds * 1000);
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+export function formatShortStatusError(error) {
+    const raw = formatUserError(error);
+    const known = formatKnownCodexAccessError(raw);
+    if (known) {
+        return known.length > 120 ? `${known.slice(0, 117)}...` : known;
+    }
+    const message = cleanUserFacingError(raw);
+    return message.length > 120 ? `${message.slice(0, 117)}...` : message;
+}
+export function isThreadNotFoundError(error) {
+    return error instanceof Error && /(thread not found|no rollout found for thread id)/i.test(error.message);
+}
+export function isThreadActiveWriterError(error) {
+    return error instanceof Error && /thread\s+\S+\s+already has an active writer/i.test(error.message);
+}
+export function isNoActiveTurnToSteerError(error) {
+    return error instanceof Error && /no active turn to steer/i.test(error.message);
+}
+export function isThreadQueueUnsupportedError(error) {
+    const message = formatUserError(error).toLowerCase();
+    return message.includes('method not found')
+        || message.includes('unknown method')
+        || message.includes('thread/queue/add') && message.includes('not supported');
+}
+export function isThreadNewCwdCreateConfirmation(text) {
+    return /^(y|yes|ok|okay|confirm|create|mkdir|确定|确认|创建|新建|好)$/i.test(text.trim());
+}
+export function isThreadNewCwdCancelConfirmation(text) {
+    return /^(n|no|cancel|stop|取消|不要|不用|算了)$/i.test(text.trim());
+}
+export function isTelegramMessageGone(error) {
+    const message = formatUserError(error).toLowerCase();
+    return message.includes('message to delete not found')
+        || message.includes('message to edit not found')
+        || message.includes('message not found');
+}
+export function isTelegramMessageTooLong(error) {
+    const message = formatUserError(error).toLowerCase();
+    return message.includes('message_too_long')
+        || message.includes('message is too long')
+        || message.includes('message too long');
+}
+export function isFileMissingError(error) {
+    return error instanceof Error && /enoent|no such file or directory/i.test(error.message);
+}
+export async function isReadableSessionPath(sessionPath) {
+    try {
+        const stats = await fs.stat(sessionPath);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
+}