@foxden-app/foxclaw 0.2.0

package/dist/lock.d.ts

@@ -0,0 +1,7 @@
+export interface ProcessLock {
+    release(): void;
+}
+export declare class LockHeldError extends Error {
+    constructor(lockPath: string, pid: number | null);
+}
+export declare function acquireProcessLock(lockPath: string): ProcessLock;

package/dist/lock.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+export class LockHeldError extends Error {
+    constructor(lockPath, pid) {
+        super(pid === null
+            ? `Lock already held: ${lockPath}`
+            : `Lock already held by pid ${pid}: ${lockPath}`);
+    }
+}
+export function acquireProcessLock(lockPath) {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    return acquireProcessLockInternal(lockPath, true);
+}
+function acquireProcessLockInternal(lockPath, allowStaleRetry) {
+    try {
+        const fd = fs.openSync(lockPath, 'wx');
+        fs.writeFileSync(fd, `${process.pid}\n`, 'utf8');
+        let released = false;
+        return {
+            release() {
+                if (released) {
+                    return;
+                }
+                released = true;
+                try {
+                    fs.closeSync(fd);
+                }
+                catch {
+                    void 0;
+                }
+                try {
+                    fs.rmSync(lockPath, { force: true });
+                }
+                catch {
+                    void 0;
+                }
+            },
+        };
+    }
+    catch (error) {
+        if (!isAlreadyExistsError(error)) {
+            throw error;
+        }
+        const pid = readLockPid(lockPath);
+        if (allowStaleRetry && pid !== null && !isProcessAlive(pid)) {
+            fs.rmSync(lockPath, { force: true });
+            return acquireProcessLockInternal(lockPath, false);
+        }
+        throw new LockHeldError(lockPath, pid);
+    }
+}
+function readLockPid(lockPath) {
+    try {
+        const value = fs.readFileSync(lockPath, 'utf8').trim();
+        if (!value) {
+            return null;
+        }
+        const pid = Number.parseInt(value, 10);
+        return Number.isFinite(pid) ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+function isAlreadyExistsError(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'EEXIST';
+}

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare class Logger {
+    private level;
+    private filePath;
+    constructor(level: LogLevel, filePath: string);
+    debug(message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+    private write;
+    private rotateIfNeeded;
+}

package/dist/logger.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const RANK = { debug: 10, info: 20, warn: 30, error: 40 };
+const MAX_SIZE = 1_000_000;
+export class Logger {
+    level;
+    filePath;
+    constructor(level, filePath) {
+        this.level = level;
+        this.filePath = filePath;
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    debug(message, meta) { this.write('debug', message, meta); }
+    info(message, meta) { this.write('info', message, meta); }
+    warn(message, meta) { this.write('warn', message, meta); }
+    error(message, meta) { this.write('error', message, meta); }
+    write(level, message, meta) {
+        if (RANK[level] < RANK[this.level])
+            return;
+        const record = {
+            time: new Date().toISOString(),
+            level,
+            message,
+            ...(meta === undefined ? {} : { meta })
+        };
+        const line = JSON.stringify(record);
+        if (level === 'error') {
+            console.error(line);
+        }
+        else if (level === 'warn') {
+            console.warn(line);
+        }
+        else {
+            console.log(line);
+        }
+        this.rotateIfNeeded();
+        fs.appendFileSync(this.filePath, line + '\n', 'utf8');
+    }
+    rotateIfNeeded() {
+        try {
+            const stat = fs.statSync(this.filePath);
+            if (stat.size < MAX_SIZE)
+                return;
+            const rotated = `${this.filePath}.1`;
+            try {
+                fs.rmSync(rotated, { force: true });
+            }
+            catch {
+                return;
+            }
+            fs.renameSync(this.filePath, rotated);
+        }
+        catch {
+            // ignore missing file
+        }
+    }
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import dotenv from 'dotenv';
+import { APP_HOME, DEFAULT_LOG_PATH, DEFAULT_STATUS_PATH, loadConfig } from './config.js';
+import { BridgeMessagingRouter } from './channels/bridge_messaging_router.js';
+import { TelegramMessagingPort } from './channels/telegram/telegram_messaging_port.js';
+import { WeixinChannelAdapter } from './channels/weixin/weixin_channel_adapter.js';
+import { WeixinMessagingPort } from './channels/weixin/weixin_messaging_port.js';
+import { attachIlinkRuntimeFromBridgeLogger } from './channels/weixin/ilink/runtime_attach.js';
+import { startWeixinLoginWithQr, waitForWeixinLogin } from './channels/weixin/ilink/login_qr.js';
+import { accountFilePath, loadWeixinAccount, saveWeixinAccount } from './channels/weixin/account_store.js';
+import { Logger } from './logger.js';
+import { BridgeStore } from './store/database.js';
+import { TelegramGateway } from './telegram/gateway.js';
+import { CodexAppClient } from './codex_app/client.js';
+import { BridgeSessionCore } from './controller/controller.js';
+import { TelegramChannelAdapter } from './channels/telegram/telegram_channel_adapter.js';
+import { acquireProcessLock, LockHeldError } from './lock.js';
+import { readRuntimeStatus, writeRuntimeStatus } from './runtime.js';
+const command = process.argv[2] || 'serve';
+dotenv.config();
+async function main() {
+    if (command === 'status') {
+        const status = readRuntimeStatus(process.env.STATUS_PATH || DEFAULT_STATUS_PATH);
+        if (!status) {
+            console.log('No runtime status found.');
+            process.exit(1);
+        }
+        console.log(JSON.stringify(status, null, 2));
+        return;
+    }
+    if (command === 'doctor') {
+        const configuredCodexBin = process.env.CODEX_CLI_BIN;
+        const checks = [
+            ['node >= 24', Number(process.versions.node.split('.')[0]) >= 24],
+            ['codex cli available', hasConfiguredCodexBin(configuredCodexBin) || hasCommand('codex')],
+            ['telegram bot token configured', Boolean(process.env.TG_BOT_TOKEN)],
+            ['telegram allowed user configured', Boolean(process.env.TG_ALLOWED_USER_ID)],
+        ];
+        if (process.env.WX_ENABLED === 'true' || process.env.WX_ENABLED === '1') {
+            const accountsDir = process.env.WEIXIN_ACCOUNTS_DIR || path.join(APP_HOME, 'weixin', 'accounts');
+            let hasAccounts = false;
+            try {
+                if (fs.existsSync(accountsDir)) {
+                    hasAccounts = fs.readdirSync(accountsDir).some((n) => n.endsWith('.json'));
+                }
+            }
+            catch {
+                hasAccounts = false;
+            }
+            checks.push(['WX_ENABLED: Weixin account JSON present', hasAccounts]);
+            checks.push(['WX_ALLOWED_ILINK_USER_IDS set (recommended)', Boolean(process.env.WX_ALLOWED_ILINK_USER_IDS?.trim())]);
+        }
+        let failed = false;
+        for (const [name, ok] of checks) {
+            console.log(`${ok ? '[OK]' : '[FAIL]'} ${name}`);
+            if (!ok)
+                failed = true;
+        }
+        try {
+            const cwd = process.env.DEFAULT_CWD || process.cwd();
+            fs.accessSync(cwd);
+            console.log(`[OK] default cwd exists: ${cwd}`);
+        }
+        catch {
+            const cwd = process.env.DEFAULT_CWD || process.cwd();
+            console.log(`[FAIL] default cwd missing: ${cwd}`);
+            failed = true;
+        }
+        process.exit(failed ? 1 : 0);
+    }
+    if (command === 'weixin-login') {
+        await runWeixinLoginCli();
+        return;
+    }
+    const config = loadConfig();
+    const logger = new Logger(config.logLevel, config.logPath);
+    attachIlinkRuntimeFromBridgeLogger(logger, config.wxIlinkRouteTag);
+    const processLock = acquireProcessLock(config.lockPath);
+    let store = null;
+    let weixinAdapter = null;
+    try {
+        store = new BridgeStore(config.storePath);
+        const bot = new TelegramGateway(config.tgBotToken, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger);
+        const app = new CodexAppClient(config.codexCliBin, config.codexAppLaunchCmd, config.codexAppAutolaunch, config.codexAppServerStatePath, config.codexAppServerLogPath, logger);
+        const telegramMessaging = new TelegramMessagingPort(bot);
+        const weixinMessaging = config.wxEnabled
+            ? new WeixinMessagingPort(store, (id) => loadWeixinAccount(config.weixinAccountsDir, id))
+            : null;
+        const outbound = new BridgeMessagingRouter(telegramMessaging, weixinMessaging);
+        const core = new BridgeSessionCore(config, store, logger, bot, app, outbound);
+        const telegram = new TelegramChannelAdapter(core);
+        if (config.wxEnabled) {
+            weixinAdapter = new WeixinChannelAdapter(core, store, config, logger);
+        }
+        process.on('unhandledRejection', (error) => {
+            logger.error('process.unhandled_rejection', { error: serializeError(error) });
+        });
+        process.on('uncaughtException', (error) => {
+            logger.error('process.uncaught_exception', { error: serializeError(error) });
+        });
+        await telegram.start();
+        if (weixinAdapter) {
+            await weixinAdapter.start();
+        }
+        logger.info('bridge.started', core.getRuntimeStatus());
+        const shutdown = async (signal) => {
+            logger.info('bridge.shutting_down', { signal });
+            await weixinAdapter?.stop();
+            await telegram.stop();
+            writeRuntimeStatus(config.statusPath, {
+                running: false,
+                connected: false,
+                userAgent: app.getUserAgent(),
+                codexAppServer: app.getServerStatus(),
+                botUsername: bot.username,
+                currentBindings: 0,
+                pendingApprovals: 0,
+                pendingUserInputs: 0,
+                activeTurns: 0,
+                lastError: null,
+                updatedAt: new Date().toISOString(),
+                channels: { telegram: false, weixin: false },
+            });
+            store?.close();
+            processLock.release();
+            process.exit(0);
+        };
+        process.on('SIGINT', () => void shutdown('SIGINT'));
+        process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    }
+    catch (error) {
+        await weixinAdapter?.stop().catch(() => { });
+        store?.close();
+        processLock.release();
+        throw error;
+    }
+}
+async function runWeixinLoginCli() {
+    const logPath = process.env.LOG_PATH || DEFAULT_LOG_PATH;
+    const level = process.env.LOG_LEVEL === 'debug' || process.env.LOG_LEVEL === 'warn' || process.env.LOG_LEVEL === 'error'
+        ? process.env.LOG_LEVEL
+        : 'info';
+    const logger = new Logger(level, logPath);
+    attachIlinkRuntimeFromBridgeLogger(logger, process.env.WX_ILINK_ROUTE_TAG ?? null);
+    const accountsDir = process.env.WEIXIN_ACCOUNTS_DIR || path.join(APP_HOME, 'weixin', 'accounts');
+    fs.mkdirSync(accountsDir, { recursive: true });
+    const accountHint = process.argv.slice(3).find((a) => !a.startsWith('-'))?.trim();
+    const start = await startWeixinLoginWithQr({
+        apiBaseUrl: 'https://ilinkai.weixin.qq.com',
+        force: process.env.WX_LOGIN_FORCE === '1' || process.env.WX_LOGIN_FORCE === 'true',
+        ...(accountHint ? { accountId: accountHint } : {}),
+    });
+    if (!start.qrcodeUrl) {
+        console.error(start.message);
+        process.exit(1);
+    }
+    console.log(start.message);
+    try {
+        const qrterm = await import('qrcode-terminal');
+        qrterm.default.generate(start.qrcodeUrl, { small: true });
+    }
+    catch {
+        console.log('Open this URL in a browser to scan:', start.qrcodeUrl);
+    }
+    const wait = await waitForWeixinLogin({
+        sessionKey: start.sessionKey,
+        apiBaseUrl: 'https://ilinkai.weixin.qq.com',
+        verbose: process.env.WX_LOGIN_VERBOSE === '1',
+        notify: (s) => process.stdout.write(s),
+        onQrRefreshed: async (url) => {
+            try {
+                const qrterm = await import('qrcode-terminal');
+                qrterm.default.generate(url, { small: true });
+                process.stdout.write(`If the QR did not render, open:\n${url}\n`);
+            }
+            catch {
+                process.stdout.write(`Open this URL to scan:\n${url}\n`);
+            }
+        },
+    });
+    if (!wait.connected || !wait.accountId || !wait.botToken) {
+        console.error(wait.message);
+        process.exit(1);
+    }
+    let baseUrl = wait.baseUrl?.trim() || 'https://ilink.weixin.qq.com';
+    if (!/^https?:\/\//i.test(baseUrl)) {
+        baseUrl = `https://${baseUrl}`;
+    }
+    saveWeixinAccount(accountsDir, {
+        accountId: wait.accountId,
+        botToken: wait.botToken,
+        baseUrl,
+        savedAt: Date.now(),
+        ...(wait.userId !== undefined ? { linkedIlinkUserId: wait.userId } : {}),
+    });
+    console.log(`${wait.message} Account saved to ${accountFilePath(accountsDir, wait.accountId)}`);
+}
+void main().catch((error) => {
+    if (error instanceof LockHeldError) {
+        console.error(error.message);
+        process.exit(1);
+    }
+    console.error(error);
+    process.exit(1);
+});
+function hasCommand(commandName) {
+    try {
+        const which = process.platform === 'win32' ? 'where' : 'which';
+        const result = spawnSync(which, [commandName], { stdio: 'ignore' });
+        return result.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function hasConfiguredCodexBin(binPath) {
+    if (!binPath || !binPath.trim())
+        return false;
+    try {
+        fs.accessSync(binPath, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function serializeError(error) {
+    if (error instanceof Error) {
+        return { message: error.message, stack: error.stack };
+    }
+    return { error: String(error) };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeStatus } from './types.js';
+export declare function writeRuntimeStatus(path: string, status: RuntimeStatus): void;
+export declare function readRuntimeStatus(path: string): RuntimeStatus | null;

package/dist/runtime.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+export function writeRuntimeStatus(path, status) {
+    const tmp = `${path}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(status, null, 2), 'utf8');
+    fs.renameSync(tmp, path);
+}
+export function readRuntimeStatus(path) {
+    try {
+        return JSON.parse(fs.readFileSync(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/store/database.d.ts

@@ -0,0 +1,79 @@
+import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, CachedThread, ChatSessionSettings, CollaborationModeValue, PendingApprovalRecord, ReasoningEffortValue, ThreadBinding } from '../types.js';
+export interface ActiveTurnPreviewRecord {
+    turnId: string;
+    scopeId: string;
+    threadId: string;
+    messageId: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface PendingUserInputStoredRecord {
+    localId: string;
+    serverRequestId: string;
+    chatId: string;
+    threadId: string;
+    turnId: string | null;
+    itemId: string;
+    messageId: number | null;
+    questionsJson: string;
+    answersJson: string;
+    currentQuestionIndex: number;
+    awaitingFreeText: boolean;
+    status: string;
+    createdAt: number;
+    submittedAt: number | null;
+    resolvedAt: number | null;
+}
+export declare class BridgeStore {
+    private db;
+    constructor(dbPath: string);
+    getTelegramOffset(botKey: string): number;
+    setTelegramOffset(botKey: string, updateId: number): void;
+    getBinding(chatId: string): ThreadBinding | null;
+    setBinding(chatId: string, threadId: string, cwd: string | null): void;
+    clearBinding(chatId: string): void;
+    getChatSettings(chatId: string): ChatSessionSettings | null;
+    setChatSettings(chatId: string, model: string | null, reasoningEffort: ReasoningEffortValue | null, locale?: AppLocale | null): void;
+    setChatLocale(chatId: string, locale: AppLocale): void;
+    setChatAccessPreset(chatId: string, accessPreset: AccessPresetValue | null): void;
+    setChatCollaborationMode(chatId: string, collaborationMode: CollaborationModeValue | null): void;
+    setChatServiceTier(chatId: string, serviceTier: string | null): void;
+    setChatActiveTurnMessageMode(chatId: string, activeTurnMessageMode: ActiveTurnMessageMode | null): void;
+    findChatIdByThreadId(threadId: string): string | null;
+    findAllChatIdsByThreadId(threadId: string): string[];
+    countBindings(): number;
+    cacheThreadList(chatId: string, threads: Array<Omit<CachedThread, 'index' | 'archived'> & {
+        listIndex?: number;
+        archived?: boolean;
+    }>): void;
+    getCachedThread(chatId: string, index: number): CachedThread | null;
+    listCachedThreads(chatId: string): CachedThread[];
+    savePendingApproval(record: PendingApprovalRecord): void;
+    updatePendingApprovalMessage(localId: string, messageId: number): void;
+    getPendingApproval(localId: string): PendingApprovalRecord | null;
+    getPendingApprovalByServerRequestId(serverRequestId: string): PendingApprovalRecord | null;
+    markApprovalResolved(localId: string): void;
+    countPendingApprovals(): number;
+    saveActiveTurnPreview(record: Pick<ActiveTurnPreviewRecord, 'turnId' | 'scopeId' | 'threadId' | 'messageId'>): void;
+    listActiveTurnPreviews(): ActiveTurnPreviewRecord[];
+    removeActiveTurnPreview(turnId: string): void;
+    removeActiveTurnPreviewByMessage(scopeId: string, messageId: number): void;
+    savePendingUserInput(record: PendingUserInputStoredRecord): void;
+    updatePendingUserInputMessage(localId: string, messageId: number): void;
+    updatePendingUserInputAnswers(localId: string, answersJson: string, currentQuestionIndex: number, awaitingFreeText?: boolean): void;
+    markPendingUserInputSubmitted(localId: string): void;
+    markPendingUserInputResolved(localId: string): void;
+    markPendingUserInputInterrupted(localId: string): void;
+    listPendingUserInputs(): PendingUserInputStoredRecord[];
+    countPendingUserInputs(): number;
+    insertAudit(direction: 'inbound' | 'outbound', chatId: string, eventType: string, summary: string): void;
+    close(): void;
+    private mapApproval;
+    private mapPendingUserInput;
+    private writeChatSettings;
+    getWeixinContextToken(scopeId: string): string | null;
+    setWeixinContextToken(scopeId: string, contextToken: string): void;
+    listDisabledCodexAuthCandidateNames(): Set<string>;
+    setCodexAuthCandidateDisabled(name: string, disabled: boolean): void;
+    private ensureColumn;
+}