@foxden-app/foxclaw 0.3.11 → 0.3.13

package/.env.example

@@ -29,12 +29,15 @@ TELEGRAM_PREVIEW_THROTTLE_MS=800
 THREAD_LIST_LIMIT=10
 CODEX_CLI_BIN=/absolute/path/to/codex
 
-# Optional: proxy for ChatGPT/Codex backend requests when FoxClaw runs as a service.
+# Optional: standard HTTP(S) proxy for Telegram and ChatGPT/Codex backend requests.
 # Put these in the same env file that `foxclaw start` installs into systemd/launchd.
+# FoxClaw passes them to the service and enables Node's env proxy support.
 # HTTP_PROXY=http://127.0.0.1:7890
 # HTTPS_PROXY=http://127.0.0.1:7890
 # ALL_PROXY=socks5://127.0.0.1:7891
 # NO_PROXY=127.0.0.1,localhost
+# Optional Linux-only fallback when a service must run through proxychains4.
+# FOXCLAW_PROXYCHAINS_CONF=/absolute/path/to/proxychains.conf
 
 # Weixin (iLink): run `foxclaw weixin-login` once, then enable:
 # WX_ENABLED=true

package/dist/codex_app/local_usage.d.ts

@@ -11,6 +11,14 @@ export interface CodexLocalUsageStats {
     turns: number;
     usageEvents: number;
     totals: CodexLocalUsageTotals;
+    outputSpeed: CodexLocalOutputSpeedStats;
     latestSessionMtimeMs: number | null;
 }
+export interface CodexLocalOutputSpeedStats {
+    samples: number;
+    outputTokens: number;
+    seconds: number;
+    latestTokensPerSecond: number | null;
+    latestSampleAtMs: number | null;
+}
 export declare function readCodexLocalUsageStats(codexHome?: string): Promise<CodexLocalUsageStats>;

package/dist/codex_app/local_usage.js

@@ -13,6 +13,7 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
     let sessionsWithUsage = 0;
     let usageEvents = 0;
     let latestSessionMtimeMs = null;
+    const outputSpeed = emptyOutputSpeedStats();
     for (const filePath of sessionFiles) {
         const stat = await fs.stat(filePath).catch(() => null);
         if (stat) {
@@ -20,6 +21,7 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
         }
         const fileUsage = await readSessionUsage(filePath, turnIds);
         usageEvents += fileUsage.usageEvents;
+        addOutputSpeed(outputSpeed, fileUsage.outputSpeed);
         if (fileUsage.totalUsage) {
             sessionsWithUsage += 1;
             addUsage(totals, fileUsage.totalUsage);
@@ -31,6 +33,7 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
         turns: turnIds.size,
         usageEvents,
         totals,
+        outputSpeed,
         latestSessionMtimeMs,
     };
 }
@@ -66,6 +69,8 @@ async function readSessionUsage(filePath, turnIds) {
     const reader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let totalUsage = null;
     let usageEvents = 0;
+    let generationStartMs = null;
+    const outputSpeed = emptyOutputSpeedStats();
     try {
         for await (const line of reader) {
             if (!line.trim())
@@ -77,13 +82,22 @@ async function readSessionUsage(filePath, turnIds) {
             catch {
                 continue;
             }
+            const timestampMs = parseTimestampMs(event?.timestamp);
             const turnId = typeof event?.payload?.turn_id === 'string' ? event.payload.turn_id : null;
             if (turnId) {
                 turnIds.add(turnId);
             }
+            if (timestampMs !== null && isGenerationBoundary(event)) {
+                generationStartMs = timestampMs;
+            }
             const info = event?.payload?.info;
-            if (info?.last_token_usage || info?.lastTokenUsage) {
+            const lastTokenUsage = info?.last_token_usage ?? info?.lastTokenUsage;
+            if (lastTokenUsage) {
                 usageEvents += 1;
+                addOutputSpeedSample(outputSpeed, lastTokenUsage, generationStartMs, timestampMs);
+                if (timestampMs !== null) {
+                    generationStartMs = timestampMs;
+                }
             }
             const totalTokenUsage = info?.total_token_usage ?? info?.totalTokenUsage;
             if (totalTokenUsage) {
@@ -94,7 +108,7 @@ async function readSessionUsage(filePath, turnIds) {
     finally {
         reader.close();
     }
-    return { usageEvents, totalUsage };
+    return { usageEvents, totalUsage, outputSpeed };
 }
 function emptyTotals() {
     return {
@@ -105,6 +119,15 @@ function emptyTotals() {
         totalTokens: 0,
     };
 }
+function emptyOutputSpeedStats() {
+    return {
+        samples: 0,
+        outputTokens: 0,
+        seconds: 0,
+        latestTokensPerSecond: null,
+        latestSampleAtMs: null,
+    };
+}
 function addUsage(totals, usage) {
     const inputTokens = numberField(usage, 'input_tokens', 'inputTokens');
     const outputTokens = numberField(usage, 'output_tokens', 'outputTokens');
@@ -115,9 +138,57 @@ function addUsage(totals, usage) {
     totals.reasoningOutputTokens += numberField(usage, 'reasoning_output_tokens', 'reasoningOutputTokens');
     totals.totalTokens += totalTokens || inputTokens + outputTokens;
 }
+function addOutputSpeed(target, source) {
+    target.samples += source.samples;
+    target.outputTokens += source.outputTokens;
+    target.seconds += source.seconds;
+    if (source.latestTokensPerSecond !== null
+        && source.latestSampleAtMs !== null
+        && (target.latestSampleAtMs === null || source.latestSampleAtMs > target.latestSampleAtMs)) {
+        target.latestTokensPerSecond = source.latestTokensPerSecond;
+        target.latestSampleAtMs = source.latestSampleAtMs;
+    }
+}
+function addOutputSpeedSample(stats, usage, generationStartMs, timestampMs) {
+    if (generationStartMs === null || timestampMs === null || timestampMs <= generationStartMs) {
+        return;
+    }
+    const outputTokens = numberField(usage, 'output_tokens', 'outputTokens');
+    if (outputTokens <= 0) {
+        return;
+    }
+    const seconds = (timestampMs - generationStartMs) / 1000;
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return;
+    }
+    stats.samples += 1;
+    stats.outputTokens += outputTokens;
+    stats.seconds += seconds;
+    stats.latestTokensPerSecond = outputTokens / seconds;
+    stats.latestSampleAtMs = timestampMs;
+}
 function numberField(source, snakeKey, camelKey) {
     const snakeValue = source[snakeKey];
     const value = snakeValue === undefined || snakeValue === null ? source[camelKey] : snakeValue;
     const numeric = Number(value);
     return Number.isFinite(numeric) ? numeric : 0;
 }
+function parseTimestampMs(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return null;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+function isGenerationBoundary(event) {
+    const payload = event?.payload;
+    if (event?.type === 'response_item' && payload?.type === 'function_call_output') {
+        return true;
+    }
+    if (event?.type !== 'event_msg') {
+        return false;
+    }
+    return payload?.type === 'task_started'
+        || payload?.type === 'exec_command_end'
+        || payload?.type === 'user_message';
+}

package/dist/controller/controller.d.ts

@@ -255,8 +255,10 @@ export declare class BridgeSessionCore {
     private buildNativeCollaborationMode;
     private buildCodexUsageStatusLines;
     private buildCodexLocalUsageStatusLines;
+    private formatCodexLocalOutputSpeedStatusLines;
     private resolveFastStatusLabel;
     private readCachedCodexLocalUsageStats;
+    private sendThreadContextSummary;
     private handleModelCommand;
     private handleEffortCommand;
     private handleThreadOpenCallback;

package/dist/controller/controller.js

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { normalizeLocale, t } from '../i18n.js';
 import { parseCommand } from './commands.js';
-import { buildAccessSettingsKeyboard, buildModelSettingsKeyboard, buildSetupPanelKeyboard, buildThreadListKeyboard, buildThreadsKeyboard, clampEffortToModel, formatAccessPresetLabel, formatActiveTurnMessageModeLabel, formatAccessSettingsMessage, formatApprovalPolicyLabel, formatCollaborationModeLabel, formatModelSettingsMessage, formatSandboxModeLabel, formatServiceTierStatusLabel, formatSetupPanelMessage, formatThreadsMessage, formatWeixinAccessCopyPaste, formatWeixinModelCopyPaste, formatWeixinThreadsCopyPaste, formatWeixinWhereNavCopyPaste, formatWhereMessage, normalizeRequestedEffort, resolveCurrentModel, resolveActiveTurnMessageMode, resolveRequestedModel, } from './presentation.js';
+import { buildAccessSettingsKeyboard, buildModelSettingsKeyboard, buildSetupPanelKeyboard, buildThreadListKeyboard, buildThreadsKeyboard, clampEffortToModel, formatAccessPresetLabel, formatActiveTurnMessageModeLabel, formatAccessSettingsMessage, formatApprovalPolicyLabel, formatCollaborationModeLabel, formatModelSettingsMessage, formatSandboxModeLabel, formatServiceTierStatusLabel, formatSetupPanelMessage, formatThreadContextSummary, formatThreadsMessage, formatWeixinAccessCopyPaste, formatWeixinModelCopyPaste, formatWeixinThreadsCopyPaste, formatWeixinWhereNavCopyPaste, formatWhereMessage, normalizeRequestedEffort, resolveCurrentModel, resolveActiveTurnMessageMode, resolveRequestedModel, } from './presentation.js';
 import { clampServiceTierToModel, resolveFastTierForModel } from './service_tier.js';
 import { TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES, buildAttachmentPrompt, isNativeImageAttachment, planAttachmentStoragePath, summarizeTelegramInput, } from '../telegram/media.js';
 import { TELEGRAM_MESSAGE_LIMIT, chunkTelegramMessage, chunkTelegramStreamMessage, clipTelegramDraftMessage, } from '../telegram/text.js';
@@ -505,6 +505,7 @@ export class BridgeSessionCore {
                     lines.push(revealError ? t(locale, 'codex_sync_failed', { error: revealError }) : t(locale, 'opened_in_codex'));
                 }
                 await this.sendMessage(scopeId, lines.join('\n'));
+                await this.sendThreadContextSummary(scopeId, locale, binding.threadId);
                 return;
             }
             case 'watch': {
@@ -831,13 +832,16 @@ export class BridgeSessionCore {
         const mode = watch.mode;
         if (mode === 'already') {
             await this.sendMessage(scopeId, t(locale, 'watch_already_enabled', { threadId: watchedThreadId }));
+            await this.sendThreadContextSummary(scopeId, locale, watchedThreadId);
             return;
         }
         if (mode === 'active') {
             await this.sendMessage(scopeId, t(locale, 'watch_started_active', { threadId: watchedThreadId }));
+            await this.sendThreadContextSummary(scopeId, locale, watchedThreadId);
             return;
         }
         await this.sendMessage(scopeId, t(locale, 'watch_started_idle', { threadId: watchedThreadId }));
+        await this.sendThreadContextSummary(scopeId, locale, watchedThreadId);
     }
     async handleThreadArchiveIndexCommand(scopeId, locale, args) {
         const index = Number.parseInt(args[0] || '', 10);
@@ -4439,6 +4443,7 @@ export class BridgeSessionCore {
                     cached: formatTokenCount(stats.totals.cachedInputTokens),
                     reasoning: formatTokenCount(stats.totals.reasoningOutputTokens),
                 }),
+                ...this.formatCodexLocalOutputSpeedStatusLines(locale, stats),
             ];
         }
         catch (error) {
@@ -4446,6 +4451,18 @@ export class BridgeSessionCore {
             return [t(locale, 'status_codex_local_usage_unavailable', { error: formatShortStatusError(error) })];
         }
     }
+    formatCodexLocalOutputSpeedStatusLines(locale, stats) {
+        const speed = stats.outputSpeed;
+        if (speed.samples === 0 || speed.outputTokens <= 0 || speed.seconds <= 0) {
+            return [];
+        }
+        const avg = speed.outputTokens / speed.seconds;
+        return [t(locale, 'status_codex_local_speed', {
+                avg: formatCompactNumber(avg),
+                latest: speed.latestTokensPerSecond === null ? t(locale, 'unknown') : formatCompactNumber(speed.latestTokensPerSecond),
+                samples: formatTokenCount(speed.samples),
+            })];
+    }
     async resolveFastStatusLabel(locale, settings) {
         try {
             const models = await this.app.listModels();
@@ -4466,6 +4483,22 @@ export class BridgeSessionCore {
         this.localUsageCache = { stats, expiresAt: now + CODEX_LOCAL_USAGE_CACHE_MS };
         return stats;
     }
+    async sendThreadContextSummary(scopeId, locale, threadId) {
+        try {
+            const turns = await this.app.listThreadTurns(threadId, 5);
+            const text = formatThreadContextSummary(locale, turns);
+            if (text) {
+                await this.sendMessage(scopeId, text);
+            }
+        }
+        catch (error) {
+            this.logger.warn('codex.thread_context_summary_failed', {
+                scopeId,
+                threadId,
+                error: formatUserError(error),
+            });
+        }
+    }
     async handleModelCommand(event, locale, args) {
         const scopeId = event.scopeId;
         if (args.length === 0) {
@@ -4627,6 +4660,7 @@ export class BridgeSessionCore {
             callbackText = revealError ? t(locale, 'opened_sync_failed_short') : t(locale, 'opened_in_codex_short');
         }
         await this.messaging.answerCallback(event.callbackQueryId, callbackText);
+        await this.sendThreadContextSummary(scopeId, locale, binding.threadId);
     }
     async handleThreadActionCallback(event, action, threadId, locale) {
         const scopeId = event.scopeId;
@@ -4673,6 +4707,7 @@ export class BridgeSessionCore {
             const watch = await this.watchThread(scopeId, target.chatId, target.chatType, target.topicId, binding);
             await this.showThreadsPanelFromStoredState(scopeId, event.messageId, locale, false);
             await this.messaging.answerCallback(event.callbackQueryId, formatWatchCallbackText(locale, watch.mode, watch.threadId));
+            await this.sendThreadContextSummary(scopeId, locale, watch.threadId);
             return;
         }
         if (action === 'archive') {

package/dist/controller/presentation.d.ts

@@ -1,4 +1,4 @@
-import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, AppThread, ApprovalPolicyValue, ChatSessionSettings, CollaborationModeValue, ModelInfo, ReasoningEffortValue, SandboxModeValue } from '../types.js';
+import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, AppThread, AppTurnSnapshot, ApprovalPolicyValue, ChatSessionSettings, CollaborationModeValue, ModelInfo, ReasoningEffortValue, SandboxModeValue } from '../types.js';
 import type { ResolvedAccessMode } from './access.js';
 type InlineButton = {
     text: string;
@@ -60,6 +60,7 @@ pageOffset?: number): string;
 export declare function formatWeixinModelCopyPaste(locale: AppLocale, models: ModelInfo[], settings: ChatSessionSettings | null): string;
 export declare function formatWeixinAccessCopyPaste(locale: AppLocale): string;
 export declare function formatWeixinWhereNavCopyPaste(locale: AppLocale, hasBinding: boolean, defaultCwd?: string): string;
+export declare function formatThreadContextSummary(locale: AppLocale, turns: AppTurnSnapshot[]): string | null;
 export declare function formatSetupPanelMessage(locale: AppLocale, ctx: SetupPanelContext): string;
 export declare function buildSetupPanelKeyboard(locale: AppLocale, ctx: SetupPanelContext): InlineButton[][];
 export declare function resolveSetupSummaryLine(ctx: SetupPanelContext, locale?: AppLocale): string;

package/dist/controller/presentation.js

@@ -225,6 +225,20 @@ export function formatWeixinWhereNavCopyPaste(locale, hasBinding, defaultCwd) {
     }
     return lines.join('\n');
 }
+export function formatThreadContextSummary(locale, turns) {
+    const context = selectRecentThreadContext(turns);
+    if (!context) {
+        return null;
+    }
+    return [
+        t(locale, 'thread_context_title'),
+        t(locale, 'thread_context_user'),
+        context.userText || t(locale, 'empty'),
+        '',
+        t(locale, 'thread_context_codex'),
+        context.codexText || t(locale, 'empty'),
+    ].join('\n');
+}
 export function formatSetupPanelMessage(locale, ctx) {
     const currentModel = resolveCurrentModel(ctx.models, ctx.settings?.model ?? null);
     const fastTier = resolveFastTierForModel(currentModel);
@@ -393,6 +407,52 @@ function formatFastSetupLabel(locale, supported, enabled, tierName) {
 function resolveCollaborationMode(mode) {
     return mode === 'plan' ? 'plan' : 'default';
 }
+function selectRecentThreadContext(turns) {
+    for (const turn of turns) {
+        const userText = lastItemText(turn.items, isUserTurnItem);
+        const codexText = lastItemText(turn.items, isCodexTurnItem);
+        if (userText || codexText) {
+            return { userText, codexText };
+        }
+    }
+    return null;
+}
+function lastItemText(items, predicate) {
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        const item = items[index];
+        if (!predicate(item)) {
+            continue;
+        }
+        const text = normalizeThreadContextText(item.text ?? item.aggregatedOutput ?? item.command ?? '');
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+function isUserTurnItem(item) {
+    const type = normalizeTurnItemType(item.type);
+    return type === 'user'
+        || type === 'usermessage'
+        || type === 'humanmessage'
+        || type === 'userinput'
+        || type === 'userrequest';
+}
+function isCodexTurnItem(item) {
+    const type = normalizeTurnItemType(item.type);
+    return type === 'agent'
+        || type === 'assistant'
+        || type === 'agentmessage'
+        || type === 'assistantmessage'
+        || type === 'plan';
+}
+function normalizeTurnItemType(value) {
+    return value.replace(/[^a-z]/gi, '').toLowerCase();
+}
+function normalizeThreadContextText(value) {
+    const trimmed = value.replace(/\r\n/g, '\n').trim().replace(/\n{3,}/g, '\n\n');
+    return truncate(trimmed, 1200);
+}
 function selectedButtonText(selected, label) {
     return `${selected ? '• ' : ''}${label}`;
 }

package/dist/i18n.d.ts

@@ -111,6 +111,7 @@ declare const MESSAGES: {
         readonly status_codex_usage_unavailable: "Codex usage: unavailable ({error})";
         readonly status_codex_local_history: "Codex local history: {sessions} sessions, {turns} turns, {events} usage records";
         readonly status_codex_local_tokens: "Codex local tokens: total {total}; input {input}, output {output}, cached input {cached}, reasoning output {reasoning}";
+        readonly status_codex_local_speed: "Codex local output speed: avg {avg} token/s, latest {latest} token/s ({samples} samples)";
         readonly status_codex_local_usage_unavailable: "Codex local history: unavailable ({error})";
         readonly status_codex_credits: "Codex credits: {value}";
         readonly status_codex_limit_reached: "Codex limit: {value}";
@@ -315,6 +316,9 @@ declare const MESSAGES: {
         readonly threads_filter: "Filter: <code>{searchTerm}</code>";
         readonly threads_range: "Showing {start}-{end}";
         readonly threads_filter_cleared_short: "Filter cleared";
+        readonly thread_context_title: "Recent context:";
+        readonly thread_context_user: "User:";
+        readonly thread_context_codex: "Codex:";
         readonly button_prev_page: "⬅️ Prev";
         readonly button_next_page: "➡️ Next";
         readonly button_clear_filter: "🧹 Clear";
@@ -661,6 +665,7 @@ declare const MESSAGES: {
         readonly status_codex_usage_unavailable: "Codex 用量：无法获取（{error}）";
         readonly status_codex_local_history: "Codex 本地历史：{sessions} 个会话，{turns} 轮，{events} 条用量记录";
         readonly status_codex_local_tokens: "Codex 本地 Token：总计 {total}；输入 {input}，输出 {output}，缓存输入 {cached}，推理输出 {reasoning}";
+        readonly status_codex_local_speed: "Codex 本地输出速度：平均 {avg} token/s，最近 {latest} token/s（{samples} 个样本）";
         readonly status_codex_local_usage_unavailable: "Codex 本地历史：无法获取（{error}）";
         readonly status_codex_credits: "Codex 额度：{value}";
         readonly status_codex_limit_reached: "Codex 限制：{value}";
@@ -865,6 +870,9 @@ declare const MESSAGES: {
         readonly threads_filter: "筛选：<code>{searchTerm}</code>";
         readonly threads_range: "显示第 {start}-{end} 条";
         readonly threads_filter_cleared_short: "已清除筛选";
+        readonly thread_context_title: "最近上下文：";
+        readonly thread_context_user: "用户指令：";
+        readonly thread_context_codex: "Codex 最后输出：";
         readonly button_prev_page: "⬅️ 上一页";
         readonly button_next_page: "➡️ 下一页";
         readonly button_clear_filter: "🧹 清除";

package/dist/i18n.js

@@ -109,6 +109,7 @@ const MESSAGES = {
         status_codex_usage_unavailable: 'Codex usage: unavailable ({error})',
         status_codex_local_history: 'Codex local history: {sessions} sessions, {turns} turns, {events} usage records',
         status_codex_local_tokens: 'Codex local tokens: total {total}; input {input}, output {output}, cached input {cached}, reasoning output {reasoning}',
+        status_codex_local_speed: 'Codex local output speed: avg {avg} token/s, latest {latest} token/s ({samples} samples)',
         status_codex_local_usage_unavailable: 'Codex local history: unavailable ({error})',
         status_codex_credits: 'Codex credits: {value}',
         status_codex_limit_reached: 'Codex limit: {value}',
@@ -313,6 +314,9 @@ const MESSAGES = {
         threads_filter: 'Filter: <code>{searchTerm}</code>',
         threads_range: 'Showing {start}-{end}',
         threads_filter_cleared_short: 'Filter cleared',
+        thread_context_title: 'Recent context:',
+        thread_context_user: 'User:',
+        thread_context_codex: 'Codex:',
         button_prev_page: '⬅️ Prev',
         button_next_page: '➡️ Next',
         button_clear_filter: '🧹 Clear',
@@ -659,6 +663,7 @@ const MESSAGES = {
         status_codex_usage_unavailable: 'Codex 用量：无法获取（{error}）',
         status_codex_local_history: 'Codex 本地历史：{sessions} 个会话，{turns} 轮，{events} 条用量记录',
         status_codex_local_tokens: 'Codex 本地 Token：总计 {total}；输入 {input}，输出 {output}，缓存输入 {cached}，推理输出 {reasoning}',
+        status_codex_local_speed: 'Codex 本地输出速度：平均 {avg} token/s，最近 {latest} token/s（{samples} 个样本）',
         status_codex_local_usage_unavailable: 'Codex 本地历史：无法获取（{error}）',
         status_codex_credits: 'Codex 额度：{value}',
         status_codex_limit_reached: 'Codex 限制：{value}',
@@ -863,6 +868,9 @@ const MESSAGES = {
         threads_filter: '筛选：<code>{searchTerm}</code>',
         threads_range: '显示第 {start}-{end} 条',
         threads_filter_cleared_short: '已清除筛选',
+        thread_context_title: '最近上下文：',
+        thread_context_user: '用户指令：',
+        thread_context_codex: 'Codex 最后输出：',
         button_prev_page: '⬅️ 上一页',
         button_next_page: '➡️ 下一页',
         button_clear_filter: '🧹 清除',

package/dist/main.js

@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { APP_HOME, DEFAULT_ENV_PATH, DEFAULT_LOG_PATH, DEFAULT_STATUS_PATH, getLoadedEnvPath, loadConfig, loadEnv, } from './config.js';
 import { acquireProcessLock, LockHeldError } from './lock.js';
 import { readRuntimeStatus, writeRuntimeStatus } from './runtime.js';
-import { refreshFoxclawExecStartDropIns } from './systemd.js';
+import { refreshFoxclawExecStartDropIns, removeFoxclawExecStartDropIns } from './systemd.js';
 const rawCommand = process.argv[2];
 const command = rawCommand || 'serve';
 loadEnv();
@@ -24,6 +24,7 @@ const PROXY_ENV_KEYS = [
     'all_proxy',
     'no_proxy',
 ];
+const STANDARD_NODE_PROXY_ENV_KEYS = ['HTTP_PROXY', 'HTTPS_PROXY', 'http_proxy', 'https_proxy'];
 async function main() {
     if (isVersionCommand(command)) {
         console.log(readPackageVersion());
@@ -493,9 +494,38 @@ function runDoctorChecks() {
         passed = false;
     }
     warnIfProxyEnvMissingFromLoadedEnv();
+    warnIfProxyConfigNeedsAttention();
     warnIfInstalledServiceNodeLooksWrong();
     return passed;
 }
+function warnIfProxyConfigNeedsAttention() {
+    const proxychainsConf = process.env.FOXCLAW_PROXYCHAINS_CONF?.trim() || '';
+    if (proxychainsConf) {
+        if (process.platform !== 'linux') {
+            console.log('[WARN] FOXCLAW_PROXYCHAINS_CONF is only used by systemd on Linux.');
+        }
+        else if (!fs.existsSync(proxychainsConf)) {
+            console.log(`[WARN] FOXCLAW_PROXYCHAINS_CONF does not exist: ${proxychainsConf}`);
+        }
+        else if (!hasCommand('proxychains4')) {
+            console.log('[WARN] proxychains4 is not available, but FOXCLAW_PROXYCHAINS_CONF is set.');
+        }
+        else {
+            console.log(`[OK] proxychains config exists: ${proxychainsConf}`);
+        }
+        return;
+    }
+    const proxyKeys = PROXY_ENV_KEYS.filter((key) => proxyEnvValue(key));
+    if (proxyKeys.length === 0) {
+        return;
+    }
+    if (hasStandardNodeProxyEnv()) {
+        console.log(`[OK] service proxy env configured: ${proxyKeys.join(', ')}`);
+        return;
+    }
+    console.log('[WARN] Only ALL_PROXY/all_proxy is configured. Node service proxying works best with HTTP_PROXY/HTTPS_PROXY.');
+    console.log('[WARN] For SOCKS-only hosts, set FOXCLAW_PROXYCHAINS_CONF=/absolute/path/to/proxychains.conf and run foxclaw restart.');
+}
 function warnIfProxyEnvMissingFromLoadedEnv() {
     const envPath = serviceEnvPath();
     const proxyUpdates = detectMissingProxyEnv(envPath);
@@ -519,7 +549,7 @@ function warnIfInstalledServiceNodeLooksWrong() {
         return;
     }
     const execStart = text.match(/^ExecStart=(.+)$/m)?.[1]?.trim();
-    const nodePath = execStart ? systemdUnescape(execStart.split(/\s+/)[0] ?? '') : '';
+    const nodePath = execStart ? extractNodePathFromExecStart(execStart) : '';
     if (!nodePath) {
         return;
     }
@@ -538,6 +568,14 @@ function warnIfInstalledServiceNodeLooksWrong() {
     console.log(`[WARN] installed service node is older than 24: ${nodePath}${version ? ` (${version})` : ''}`);
     console.log('[WARN] Run foxclaw start from a Node 24 shell to refresh the service unit.');
 }
+function extractNodePathFromExecStart(execStart) {
+    const tokens = execStart.split(/\s+/).map(systemdUnescape).filter(Boolean);
+    const directNode = tokens[0] || '';
+    if (path.basename(directNode) === 'node') {
+        return directNode;
+    }
+    return tokens.find((token) => path.basename(token) === 'node') || directNode;
+}
 function installSystemd() {
     if (!hasCommand('systemctl')) {
         console.error('systemctl not found (need systemd)');
@@ -551,6 +589,12 @@ function installSystemd() {
     const nodeBin = process.execPath;
     const nodeDir = path.dirname(nodeBin);
     const pathValue = buildServicePath(nodeDir);
+    const proxychainsConf = process.env.FOXCLAW_PROXYCHAINS_CONF?.trim() || '';
+    const proxychainsBin = proxychainsConf ? resolveCommand('proxychains4') || '/usr/bin/proxychains4' : '';
+    const nodeProxyArgs = !proxychainsConf && hasStandardNodeProxyEnv() ? ' --use-env-proxy' : '';
+    const execStart = proxychainsConf
+        ? `${systemdEscape(proxychainsBin)} -f ${systemdEscape(proxychainsConf)} ${systemdEscape(nodeBin)} ${systemdEscape(entryPoint)} serve`
+        : `${systemdEscape(nodeBin)}${nodeProxyArgs} ${systemdEscape(entryPoint)} serve`;
     fs.mkdirSync(userSystemdDir, { recursive: true });
     fs.mkdirSync(configDir, { recursive: true });
     fs.mkdirSync(path.join(APP_HOME, 'logs'), { recursive: true });
@@ -566,12 +610,13 @@ StartLimitBurst=5
 [Service]
 Type=simple
 WorkingDirectory=${systemdEscape(configDir)}
+EnvironmentFile=-${systemdEscape(envPath)}
 Environment=HOME=${systemdEscape(process.env.HOME || '')}
 Environment=USER=${systemdEscape(process.env.USER || '')}
 Environment=LOGNAME=${systemdEscape(process.env.LOGNAME || process.env.USER || '')}
 Environment=PATH=${systemdEscape(pathValue)}
 Environment=FOXCLAW_ENV=${systemdEscape(envPath)}
-ExecStart=${systemdEscape(nodeBin)} ${escapedEntryPoint} serve
+ExecStart=${execStart}
 Restart=always
 RestartSec=10
 TimeoutStopSec=45
@@ -580,9 +625,23 @@ KillMode=process
 [Install]
 WantedBy=default.target
 `);
-    const dropInUpdates = refreshFoxclawExecStartDropIns(userSystemdDir, unitName, escapedEntryPoint);
-    for (const update of dropInUpdates) {
-        console.log(`[OK] updated FoxClaw ExecStart override: ${update.path}`);
+    if (proxychainsConf) {
+        console.log(`[OK] systemd proxychains enabled: ${proxychainsConf}`);
+    }
+    else if (nodeProxyArgs) {
+        console.log('[OK] systemd Node env proxy enabled');
+    }
+    if (proxychainsConf) {
+        const dropInUpdates = removeFoxclawExecStartDropIns(userSystemdDir, unitName);
+        for (const update of dropInUpdates) {
+            console.log(`[OK] removed stale FoxClaw ExecStart override: ${update.path}`);
+        }
+    }
+    else {
+        const dropInUpdates = refreshFoxclawExecStartDropIns(userSystemdDir, unitName, escapedEntryPoint);
+        for (const update of dropInUpdates) {
+            console.log(`[OK] updated FoxClaw ExecStart override: ${update.path}`);
+        }
     }
     spawnChecked('systemctl', ['--user', 'daemon-reload']);
     spawnChecked('systemctl', ['--user', 'enable', unitName]);
@@ -625,6 +684,9 @@ function installLaunchd() {
     const plist = path.join(home, 'Library', 'LaunchAgents', 'app.foxden.foxclaw.plist');
     const envPath = serviceEnvPath();
     const configDir = path.dirname(envPath);
+    const nodeProxyArgs = hasStandardNodeProxyEnv() ? ['--use-env-proxy'] : [];
+    const nodeProxyArgXml = nodeProxyArgs.map((arg) => `    <string>${xmlEscape(arg)}</string>`).join('\n');
+    const proxyEnvXml = buildLaunchdProxyEnvironmentXml();
     fs.mkdirSync(path.dirname(plist), { recursive: true });
     fs.mkdirSync(configDir, { recursive: true });
     fs.mkdirSync(path.join(APP_HOME, 'logs'), { recursive: true });
@@ -637,7 +699,7 @@ function installLaunchd() {
   <key>ProgramArguments</key>
   <array>
     <string>${xmlEscape(process.execPath)}</string>
-    <string>${xmlEscape(entryPoint)}</string>
+${nodeProxyArgXml ? `${nodeProxyArgXml}\n` : ''}    <string>${xmlEscape(entryPoint)}</string>
     <string>serve</string>
   </array>
   <key>WorkingDirectory</key>
@@ -654,6 +716,7 @@ function installLaunchd() {
     <string>${xmlEscape(process.env.LOGNAME || process.env.USER || '')}</string>
     <key>FOXCLAW_ENV</key>
     <string>${xmlEscape(envPath)}</string>
+${proxyEnvXml}
   </dict>
   <key>RunAtLoad</key>
   <true/>
@@ -669,6 +732,9 @@ function installLaunchd() {
     spawnSync('launchctl', ['unload', plist], { stdio: 'ignore' });
     spawnChecked('launchctl', ['load', plist]);
     console.log(`Installed ${plist}`);
+    if (nodeProxyArgs.length > 0) {
+        console.log('[OK] launchd Node env proxy enabled');
+    }
 }
 function stopLaunchd() {
     if (process.platform !== 'darwin') {
@@ -699,6 +765,23 @@ function buildServicePath(nodeDir) {
 function serviceEnvPath() {
     return path.resolve(process.env.FOXCLAW_ENV?.trim() || getLoadedEnvPath() || DEFAULT_ENV_PATH);
 }
+function hasStandardNodeProxyEnv() {
+    return STANDARD_NODE_PROXY_ENV_KEYS.some((key) => Boolean(proxyEnvValue(key)));
+}
+function proxyEnvValue(key) {
+    return process.env[key]?.trim() || '';
+}
+function buildLaunchdProxyEnvironmentXml() {
+    const entries = [];
+    for (const key of PROXY_ENV_KEYS) {
+        const value = proxyEnvValue(key);
+        if (!value)
+            continue;
+        entries.push(`    <key>${xmlEscape(key)}</key>`);
+        entries.push(`    <string>${xmlEscape(value)}</string>`);
+    }
+    return entries.length > 0 ? `${entries.join('\n')}\n` : '';
+}
 function spawnChecked(commandName, args) {
     const result = spawnSync(commandName, args, { stdio: 'inherit' });
     if (result.status !== 0) {

package/dist/systemd.d.ts

@@ -3,7 +3,12 @@ export interface SystemdDropInUpdate {
     replacements: number;
 }
 export declare function refreshFoxclawExecStartDropIns(userSystemdDir: string, unitName: string, escapedEntryPoint: string): SystemdDropInUpdate[];
+export declare function removeFoxclawExecStartDropIns(userSystemdDir: string, unitName: string): SystemdDropInUpdate[];
 export declare function refreshFoxclawExecStartText(text: string, escapedEntryPoint: string): {
     text: string;
     replacements: number;
 };
+export declare function removeFoxclawExecStartText(text: string): {
+    text: string;
+    replacements: number;
+};

package/dist/systemd.js

@@ -29,6 +29,39 @@ export function refreshFoxclawExecStartDropIns(userSystemdDir, unitName, escaped
     }
     return updates;
 }
+export function removeFoxclawExecStartDropIns(userSystemdDir, unitName) {
+    const dropInDir = path.join(userSystemdDir, `${unitName}.d`);
+    let names;
+    try {
+        names = fs.readdirSync(dropInDir).filter((name) => name.endsWith('.conf')).sort();
+    }
+    catch {
+        return [];
+    }
+    const updates = [];
+    for (const name of names) {
+        const filePath = path.join(dropInDir, name);
+        let before = '';
+        try {
+            before = fs.readFileSync(filePath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const { text, replacements } = removeFoxclawExecStartText(before);
+        if (replacements === 0 || text === before) {
+            continue;
+        }
+        if (isEmptyServiceDropIn(text)) {
+            fs.rmSync(filePath, { force: true });
+        }
+        else {
+            fs.writeFileSync(filePath, text, 'utf8');
+        }
+        updates.push({ path: filePath, replacements });
+    }
+    return updates;
+}
 export function refreshFoxclawExecStartText(text, escapedEntryPoint) {
     let replacements = 0;
     const lines = text.split(/(\r?\n)/);
@@ -43,3 +76,28 @@ export function refreshFoxclawExecStartText(text, escapedEntryPoint) {
     });
     return { text: refreshed.join(''), replacements };
 }
+export function removeFoxclawExecStartText(text) {
+    const hasFoxclawExecStart = text
+        .split(/\r?\n/)
+        .some((line) => line.startsWith('ExecStart=') && FOXCLAW_MAIN_PATH_RE.test(line));
+    if (!hasFoxclawExecStart) {
+        return { text, replacements: 0 };
+    }
+    let replacements = 0;
+    const lines = text.split(/(\r?\n)/);
+    const cleaned = lines.map((part) => {
+        if (!part.startsWith('ExecStart=')) {
+            return part;
+        }
+        replacements += 1;
+        return '';
+    });
+    return { text: cleaned.join(''), replacements };
+}
+function isEmptyServiceDropIn(text) {
+    const meaningfulLines = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return meaningfulLines.length === 0 || (meaningfulLines.length === 1 && meaningfulLines[0] === '[Service]');
+}

package/docs/troubleshooting.md

@@ -203,12 +203,28 @@ ALL_PROXY=socks5://127.0.0.1:20170
 NO_PROXY=127.0.0.1,localhost
 ```
 
+When `HTTP_PROXY` or `HTTPS_PROXY` is configured, FoxClaw passes those variables to systemd/launchd explicitly and starts Node with `--use-env-proxy`. Do not rely on proxy variables from the current shell; service processes do not inherit them automatically.
+
 Restart FoxClaw after editing. The restart also restarts the managed Codex app-server so the new proxy environment takes effect:
 
 ```bash
 foxclaw restart
 ```
 
+If a Linux host must use `proxychains4` to reach Telegram or ChatGPT, do not hand-write a systemd drop-in that overrides `ExecStart`. Add this to the FoxClaw env file instead:
+
+```dotenv
+FOXCLAW_PROXYCHAINS_CONF=/home/wuya/.proxychains-rt.conf
+```
+
+Then run:
+
+```bash
+foxclaw restart
+```
+
+FoxClaw writes proxychains into the main service and removes stale FoxClaw `ExecStart` overrides, so later upgrades still only need the normal `pnpm install -g` and `foxclaw restart`.
+
 ## Service Starts With The Wrong Node Version
 
 The systemd installer records the absolute path of the Node process that is currently running FoxClaw. It does not rely on systemd loading `nvm.sh` or any other shell init script. Whether you use nvm, fnm, asdf, mise, Volta, Homebrew, or system Node, run `foxclaw start` from a Node 24+ shell and the service will keep using that Node 24+ path.

package/docs/user-manual.md

@@ -100,7 +100,7 @@ Both install the same published npm package. Use one global package manager cons
 
 ### 1.6 Fill In The Config
 
-`foxclaw init` creates the default config file at `~/.foxclaw/.env` and prompts for the Telegram bot token, your numeric Telegram user id, and the default workspace. If the current shell has proxy variables such as `HTTP_PROXY`, `HTTPS_PROXY`, or `ALL_PROXY`, it also asks whether to save them into the FoxClaw config so the service-side Codex app-server uses the same network. Press Enter on any field to skip it, then edit manually if needed:
+`foxclaw init` creates the default config file at `~/.foxclaw/.env` and prompts for the Telegram bot token, your numeric Telegram user id, and the default workspace. If the current shell has proxy variables such as `HTTP_PROXY`, `HTTPS_PROXY`, or `ALL_PROXY`, it also asks whether to save them into the FoxClaw config. When `HTTP_PROXY` or `HTTPS_PROXY` is configured, FoxClaw passes it to systemd/launchd explicitly and enables Node's env proxy support. Press Enter on any field to skip it, then edit manually if needed:
 
 ```bash
 $EDITOR ~/.foxclaw/.env

package/docs/zh/troubleshooting.md

@@ -204,12 +204,28 @@ ALL_PROXY=socks5://127.0.0.1:20170
 NO_PROXY=127.0.0.1,localhost
 ```
 
+只要配置了 `HTTP_PROXY` 或 `HTTPS_PROXY`，FoxClaw 安装 systemd/launchd 时会把这些变量显式传给服务，并给 Node 加上 `--use-env-proxy`。不要依赖“当前 shell 里有代理变量”，服务进程不会自动继承它们。
+
 改完后重启 FoxClaw。重启会同时重启托管的 Codex app-server，让新代理生效：
 
 ```bash
 foxclaw restart
 ```
 
+如果这台 Linux 机器必须用 `proxychains4` 才能访问 Telegram 或 ChatGPT，不要手写 systemd drop-in 覆盖 `ExecStart`。在 FoxClaw env 文件里写：
+
+```dotenv
+FOXCLAW_PROXYCHAINS_CONF=/home/wuya/.proxychains-rt.conf
+```
+
+然后运行：
+
+```bash
+foxclaw restart
+```
+
+FoxClaw 会把 proxychains 写进主 service，并清理旧的 FoxClaw `ExecStart` 覆盖，后续升级仍然只需要正常 `pnpm install -g` 和 `foxclaw restart`。
+
 ## 服务用了错误的 Node 版本
 
 systemd 安装脚本会记录当时正在运行的 Node 绝对路径，不依赖 systemd 去加载 `nvm.sh` 或其它 shell 初始化脚本。无论你用 nvm、fnm、asdf、mise、Volta、Homebrew 还是系统 Node，原则都是：从 Node 24+ 的 shell 里执行 `foxclaw start`，服务之后就固定使用这个 Node 24+ 路径。

package/docs/zh/user-manual.md

@@ -100,7 +100,7 @@ foxclaw init
 
 ### 1.6 填写配置
 
-`foxclaw init` 会创建默认配置文件 `~/.foxclaw/.env`，并提示填写 Telegram bot token、Telegram 数字用户 ID 和默认工作目录。如果当前 shell 里有 `HTTP_PROXY`、`HTTPS_PROXY`、`ALL_PROXY` 等代理变量，它也会询问是否写入 FoxClaw 配置，让服务里的 Codex app-server 使用同样的网络。任何一项都可以直接回车跳过，之后再手动编辑：
+`foxclaw init` 会创建默认配置文件 `~/.foxclaw/.env`，并提示填写 Telegram bot token、Telegram 数字用户 ID 和默认工作目录。如果当前 shell 里有 `HTTP_PROXY`、`HTTPS_PROXY`、`ALL_PROXY` 等代理变量，它也会询问是否写入 FoxClaw 配置。配置了 `HTTP_PROXY` 或 `HTTPS_PROXY` 后，FoxClaw 会在安装服务时显式传给 systemd/launchd，并启用 Node 的 env proxy。任何一项都可以直接回车跳过，之后再手动编辑：
 
 ```bash
 $EDITOR ~/.foxclaw/.env

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",

package/skills/foxclaw/SKILL.md

@@ -184,6 +184,7 @@ Use this checklist when the user asks for standard closing actions, release wrap
    - If the user has a pnpm global FoxClaw install, prefer `pnpm add -g <repo-path>` so the global `foxclaw` points at the local repo.
    - Rebuild before restarting because local linked installs run `dist/main.js`.
    - Refresh systemd with the existing service env path, for example `FOXCLAW_ENV=<existing-env> <node24> dist/main.js install-systemd`. Do not run `install-systemd` from the repo without `FOXCLAW_ENV`, because it may rewrite the service to use the repo `.env`.
+   - Do not create systemd drop-ins that override FoxClaw `ExecStart`. For Linux hosts that require proxychains, set `FOXCLAW_PROXYCHAINS_CONF=/absolute/path/to/proxychains.conf` in the FoxClaw env file and rerun `foxclaw restart`.
    - For macOS launchd, use the launchd install/start path from this skill and verify with `node dist/main.js status`.
    - Verify the running service reports the expected FoxClaw version in `status`.
    - If `doctor` fails only because `DEFAULT_CWD` is missing, report that separately; do not treat it as evidence that the service update failed.