@foxden-app/foxclaw 0.2.0

package/dist/codex_app/deeplink.d.ts

@@ -0,0 +1,7 @@
+export interface OpenUrlCommand {
+    command: string;
+    args: string[];
+}
+export declare function buildThreadDeepLink(threadId: string): string;
+export declare function getOpenUrlCommand(url: string, platform?: NodeJS.Platform): OpenUrlCommand;
+export declare function openUrl(url: string, platform?: NodeJS.Platform): Promise<void>;

package/dist/codex_app/deeplink.js

@@ -0,0 +1,29 @@
+import { spawn } from 'node:child_process';
+export function buildThreadDeepLink(threadId) {
+    return `codex://threads/${encodeURIComponent(threadId)}`;
+}
+export function getOpenUrlCommand(url, platform = process.platform) {
+    switch (platform) {
+        case 'darwin':
+            return { command: 'open', args: [url] };
+        case 'win32':
+            return { command: 'cmd', args: ['/c', 'start', '', url] };
+        default:
+            return { command: 'xdg-open', args: [url] };
+    }
+}
+export async function openUrl(url, platform = process.platform) {
+    const { command, args } = getOpenUrlCommand(url, platform);
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: 'ignore',
+            detached: true,
+            windowsHide: true,
+        });
+        child.once('error', reject);
+        child.once('spawn', () => {
+            child.unref();
+            resolve();
+        });
+    });
+}

package/dist/codex_app/local_usage.d.ts

@@ -0,0 +1,16 @@
+export interface CodexLocalUsageTotals {
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    reasoningOutputTokens: number;
+    totalTokens: number;
+}
+export interface CodexLocalUsageStats {
+    sessionFiles: number;
+    sessionsWithUsage: number;
+    turns: number;
+    usageEvents: number;
+    totals: CodexLocalUsageTotals;
+    latestSessionMtimeMs: number | null;
+}
+export declare function readCodexLocalUsageStats(codexHome?: string): Promise<CodexLocalUsageStats>;

package/dist/codex_app/local_usage.js

@@ -0,0 +1,123 @@
+import { createReadStream } from 'node:fs';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
+    const sessionFiles = await listJsonlFiles([
+        path.join(codexHome, 'sessions'),
+        path.join(codexHome, 'archived_sessions'),
+    ]);
+    const totals = emptyTotals();
+    const turnIds = new Set();
+    let sessionsWithUsage = 0;
+    let usageEvents = 0;
+    let latestSessionMtimeMs = null;
+    for (const filePath of sessionFiles) {
+        const stat = await fs.stat(filePath).catch(() => null);
+        if (stat) {
+            latestSessionMtimeMs = Math.max(latestSessionMtimeMs ?? 0, stat.mtimeMs);
+        }
+        const fileUsage = await readSessionUsage(filePath, turnIds);
+        usageEvents += fileUsage.usageEvents;
+        if (fileUsage.totalUsage) {
+            sessionsWithUsage += 1;
+            addUsage(totals, fileUsage.totalUsage);
+        }
+    }
+    return {
+        sessionFiles: sessionFiles.length,
+        sessionsWithUsage,
+        turns: turnIds.size,
+        usageEvents,
+        totals,
+        latestSessionMtimeMs,
+    };
+}
+function resolveCodexHome() {
+    return process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+}
+async function listJsonlFiles(roots) {
+    const results = [];
+    for (const root of roots) {
+        await collectJsonlFiles(root, results);
+    }
+    return results;
+}
+async function collectJsonlFiles(targetPath, results) {
+    const stat = await fs.stat(targetPath).catch(() => null);
+    if (!stat)
+        return;
+    if (stat.isFile()) {
+        if (targetPath.endsWith('.jsonl')) {
+            results.push(targetPath);
+        }
+        return;
+    }
+    if (!stat.isDirectory())
+        return;
+    const entries = await fs.readdir(targetPath, { withFileTypes: true });
+    for (const entry of entries) {
+        await collectJsonlFiles(path.join(targetPath, entry.name), results);
+    }
+}
+async function readSessionUsage(filePath, turnIds) {
+    const stream = createReadStream(filePath, { encoding: 'utf8' });
+    const reader = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let totalUsage = null;
+    let usageEvents = 0;
+    try {
+        for await (const line of reader) {
+            if (!line.trim())
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const turnId = typeof event?.payload?.turn_id === 'string' ? event.payload.turn_id : null;
+            if (turnId) {
+                turnIds.add(turnId);
+            }
+            const info = event?.payload?.info;
+            if (info?.last_token_usage || info?.lastTokenUsage) {
+                usageEvents += 1;
+            }
+            const totalTokenUsage = info?.total_token_usage ?? info?.totalTokenUsage;
+            if (totalTokenUsage) {
+                totalUsage = totalTokenUsage;
+            }
+        }
+    }
+    finally {
+        reader.close();
+    }
+    return { usageEvents, totalUsage };
+}
+function emptyTotals() {
+    return {
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0,
+    };
+}
+function addUsage(totals, usage) {
+    const inputTokens = numberField(usage, 'input_tokens', 'inputTokens');
+    const outputTokens = numberField(usage, 'output_tokens', 'outputTokens');
+    const totalTokens = numberField(usage, 'total_tokens', 'totalTokens');
+    totals.inputTokens += inputTokens;
+    totals.cachedInputTokens += numberField(usage, 'cached_input_tokens', 'cachedInputTokens');
+    totals.outputTokens += outputTokens;
+    totals.reasoningOutputTokens += numberField(usage, 'reasoning_output_tokens', 'reasoningOutputTokens');
+    totals.totalTokens += totalTokens || inputTokens + outputTokens;
+}
+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;
+}

package/dist/config.d.ts

@@ -0,0 +1,44 @@
+import type { LogLevel } from './logger.js';
+import type { ApprovalPolicyValue, SandboxModeValue } from './types.js';
+export declare const APP_HOME: string;
+export declare const DEFAULT_STORE_PATH: string;
+export declare const DEFAULT_STATUS_PATH: string;
+export declare const DEFAULT_LOG_PATH: string;
+export declare const DEFAULT_LOCK_PATH: string;
+export declare const DEFAULT_CODEX_APP_SERVER_STATE_PATH: string;
+export declare const DEFAULT_CODEX_APP_SERVER_LOG_PATH: string;
+export interface AppConfig {
+    tgBotToken: string;
+    tgAllowedUserId: string;
+    tgAllowedChatId: string | null;
+    tgAllowedTopicId: number | null;
+    codexCliBin: string;
+    codexAppAutolaunch: boolean;
+    codexAppLaunchCmd: string;
+    codexAppServerStatePath: string;
+    codexAppServerLogPath: string;
+    codexAppSyncOnOpen: boolean;
+    codexAppSyncOnTurnComplete: boolean;
+    storePath: string;
+    logLevel: LogLevel;
+    defaultCwd: string;
+    defaultApprovalPolicy: ApprovalPolicyValue;
+    defaultSandboxMode: SandboxModeValue;
+    telegramPollIntervalMs: number;
+    telegramPreviewThrottleMs: number;
+    threadListLimit: number;
+    statusPath: string;
+    logPath: string;
+    lockPath: string;
+    /** When true, start Weixin (iLink) long-poll alongside Telegram. */
+    wxEnabled: boolean;
+    /** Allowed `from_user_id` values for inbound Weixin messages (empty = allow any). */
+    wxAllowedIlinkUserIds: string[];
+    weixinAccountsDir: string;
+    weixinSyncBufDir: string;
+    weixinMediaDir: string;
+    /** Optional `SKRouteTag` header for some IDC deployments. */
+    wxIlinkRouteTag: string | null;
+}
+export declare function loadConfig(): AppConfig;
+export declare function ensureAppDirs(config: AppConfig): void;

package/dist/config.js

@@ -0,0 +1,131 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import dotenv from 'dotenv';
+export const APP_HOME = path.join(os.homedir(), '.foxclaw');
+export const DEFAULT_STORE_PATH = path.join(APP_HOME, 'data', 'bridge.sqlite');
+export const DEFAULT_STATUS_PATH = path.join(APP_HOME, 'runtime', 'status.json');
+export const DEFAULT_LOG_PATH = path.join(APP_HOME, 'logs', 'service.log');
+export const DEFAULT_LOCK_PATH = path.join(APP_HOME, 'runtime', 'bridge.lock');
+export const DEFAULT_CODEX_APP_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime', 'codex-app-server.json');
+export const DEFAULT_CODEX_APP_SERVER_LOG_PATH = path.join(APP_HOME, 'logs', 'codex-app-server.log');
+export function loadConfig() {
+    dotenv.config();
+    const config = {
+        tgBotToken: required('TG_BOT_TOKEN'),
+        tgAllowedUserId: required('TG_ALLOWED_USER_ID'),
+        tgAllowedChatId: optional('TG_ALLOWED_CHAT_ID'),
+        tgAllowedTopicId: nullableIntEnv('TG_ALLOWED_TOPIC_ID'),
+        codexCliBin: process.env.CODEX_CLI_BIN || resolveCommand('codex') || 'codex',
+        codexAppAutolaunch: boolEnv('CODEX_APP_AUTOLAUNCH', true),
+        codexAppLaunchCmd: process.env.CODEX_APP_LAUNCH_CMD || 'codex app',
+        codexAppServerStatePath: process.env.CODEX_APP_SERVER_STATE_PATH || DEFAULT_CODEX_APP_SERVER_STATE_PATH,
+        codexAppServerLogPath: process.env.CODEX_APP_SERVER_LOG_PATH || DEFAULT_CODEX_APP_SERVER_LOG_PATH,
+        codexAppSyncOnOpen: boolEnv('CODEX_APP_SYNC_ON_OPEN', true),
+        codexAppSyncOnTurnComplete: boolEnv('CODEX_APP_SYNC_ON_TURN_COMPLETE', false),
+        storePath: process.env.STORE_PATH || DEFAULT_STORE_PATH,
+        logLevel: parseLogLevel(process.env.LOG_LEVEL || 'info'),
+        defaultCwd: process.env.DEFAULT_CWD || process.cwd(),
+        defaultApprovalPolicy: parseApprovalPolicy(process.env.DEFAULT_APPROVAL_POLICY || 'on-request'),
+        defaultSandboxMode: parseSandboxMode(process.env.DEFAULT_SANDBOX_MODE || 'workspace-write'),
+        telegramPollIntervalMs: intEnv('TELEGRAM_POLL_INTERVAL_MS', 1200),
+        telegramPreviewThrottleMs: intEnv('TELEGRAM_PREVIEW_THROTTLE_MS', 800),
+        threadListLimit: intEnv('THREAD_LIST_LIMIT', 10),
+        statusPath: DEFAULT_STATUS_PATH,
+        logPath: DEFAULT_LOG_PATH,
+        lockPath: process.env.LOCK_PATH || DEFAULT_LOCK_PATH,
+        wxEnabled: boolEnv('WX_ENABLED', false),
+        wxAllowedIlinkUserIds: parseCommaSeparatedIds(process.env.WX_ALLOWED_ILINK_USER_IDS),
+        weixinAccountsDir: process.env.WEIXIN_ACCOUNTS_DIR || path.join(APP_HOME, 'weixin', 'accounts'),
+        weixinSyncBufDir: process.env.WEIXIN_SYNC_BUF_DIR || path.join(APP_HOME, 'weixin', 'sync-buf'),
+        weixinMediaDir: process.env.WEIXIN_MEDIA_DIR || path.join(APP_HOME, 'weixin', 'media'),
+        wxIlinkRouteTag: optional('WX_ILINK_ROUTE_TAG'),
+    };
+    ensureAppDirs(config);
+    return config;
+}
+export function ensureAppDirs(config) {
+    const dirs = [
+        path.dirname(config.storePath),
+        path.dirname(config.statusPath),
+        path.dirname(config.logPath),
+        path.dirname(config.lockPath),
+        path.dirname(config.codexAppServerStatePath),
+        path.dirname(config.codexAppServerLogPath),
+    ];
+    if (config.wxEnabled) {
+        dirs.push(config.weixinAccountsDir, config.weixinSyncBufDir, config.weixinMediaDir);
+    }
+    for (const dir of dirs) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function parseCommaSeparatedIds(raw) {
+    if (!raw?.trim())
+        return [];
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function required(key) {
+    const value = process.env[key];
+    if (!value || !value.trim()) {
+        throw new Error(`${key} is required`);
+    }
+    return value.trim();
+}
+function optional(key) {
+    const value = process.env[key];
+    if (!value || !value.trim())
+        return null;
+    return value.trim();
+}
+function intEnv(key, fallback) {
+    const value = process.env[key];
+    if (!value)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function nullableIntEnv(key) {
+    const value = process.env[key];
+    if (!value || !value.trim())
+        return null;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function boolEnv(key, fallback) {
+    const value = process.env[key];
+    if (!value)
+        return fallback;
+    return value !== 'false' && value !== '0';
+}
+function parseLogLevel(value) {
+    if (value === 'debug' || value === 'info' || value === 'warn' || value === 'error')
+        return value;
+    return 'info';
+}
+function parseApprovalPolicy(value) {
+    if (value === 'on-failure' || value === 'never' || value === 'untrusted' || value === 'on-request')
+        return value;
+    return 'on-request';
+}
+function parseSandboxMode(value) {
+    if (value === 'read-only' || value === 'workspace-write' || value === 'danger-full-access')
+        return value;
+    return 'workspace-write';
+}
+function resolveCommand(commandName) {
+    try {
+        const which = process.platform === 'win32' ? 'where' : 'which';
+        const result = spawnSync(which, [commandName], { encoding: 'utf8' });
+        if (result.status !== 0)
+            return null;
+        return String(result.stdout).trim().split(/\r?\n/, 1)[0] || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/controller/access.d.ts

@@ -0,0 +1,11 @@
+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;

package/dist/controller/access.js

@@ -0,0 +1,33 @@
+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,
+            };
+    }
+}

package/dist/controller/activity.d.ts

@@ -0,0 +1,62 @@
+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;