@foxden-app/foxclaw 0.2.0

package/dist/channels/weixin/weixin_messaging_port.js

@@ -0,0 +1,113 @@
+import { parseWeixinBridgeScope } from '../../core/bridge_scope.js';
+import { getConfig, sendTyping } from './ilink/api.js';
+import { sendMessageWeixin } from './ilink/send.js';
+import { TypingStatus } from './ilink/types.js';
+const DEFAULT_TYPING_API = { getConfig, sendTyping };
+function stripHtmlBasic(html) {
+    return html
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<\/p>/gi, '\n')
+        .replace(/<[^>]+>/g, '')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .trim();
+}
+/**
+ * Weixin (iLink) outbound: addressed by `weixin:<accountId>:<peerUserId>` scope ids.
+ * Editing/deleting Telegram messages is approximated as new plain text sends or no-ops.
+ */
+export class WeixinMessagingPort {
+    store;
+    loadAccount;
+    typingApi;
+    nextSyntheticId = 1;
+    constructor(store, loadAccount, typingApi = DEFAULT_TYPING_API) {
+        this.store = store;
+        this.loadAccount = loadAccount;
+        this.typingApi = typingApi;
+    }
+    allocMessageId() {
+        const id = this.nextSyntheticId;
+        this.nextSyntheticId += 1;
+        return id;
+    }
+    async sendPlain(scopeId, text, keyboard) {
+        void keyboard;
+        const parsed = parseWeixinBridgeScope(scopeId);
+        if (!parsed) {
+            throw new Error(`Invalid weixin scope: ${scopeId}`);
+        }
+        const account = this.loadAccount(parsed.accountId);
+        if (!account) {
+            throw new Error(`Weixin account not found: ${parsed.accountId}`);
+        }
+        const contextToken = this.store.getWeixinContextToken(scopeId);
+        await sendMessageWeixin({
+            to: parsed.fromUserId,
+            text,
+            opts: {
+                baseUrl: account.baseUrl,
+                token: account.botToken,
+                ...(contextToken !== null && contextToken !== '' ? { contextToken } : {}),
+            },
+        });
+        return this.allocMessageId();
+    }
+    async sendHtml(scopeId, html, keyboard) {
+        return this.sendPlain(scopeId, stripHtmlBasic(html), keyboard);
+    }
+    async editPlain(scopeId, _messageId, text, keyboard) {
+        await this.sendPlain(scopeId, text, keyboard);
+    }
+    async editHtml(scopeId, messageId, html, keyboard) {
+        await this.sendHtml(scopeId, html, keyboard);
+    }
+    async deleteMessage(scopeId, messageId) {
+        void scopeId;
+        void messageId;
+    }
+    async sendTypingInScope(scopeId) {
+        const parsed = parseWeixinBridgeScope(scopeId);
+        if (!parsed) {
+            return;
+        }
+        const account = this.loadAccount(parsed.accountId);
+        if (!account) {
+            return;
+        }
+        const contextToken = this.store.getWeixinContextToken(scopeId);
+        try {
+            const config = await this.typingApi.getConfig({
+                baseUrl: account.baseUrl,
+                token: account.botToken,
+                ilinkUserId: parsed.fromUserId,
+                ...(contextToken !== null && contextToken !== '' ? { contextToken } : {}),
+            });
+            const typingTicket = config.typing_ticket?.trim();
+            if (!typingTicket) {
+                return;
+            }
+            await this.typingApi.sendTyping({
+                baseUrl: account.baseUrl,
+                token: account.botToken,
+                body: {
+                    ilink_user_id: parsed.fromUserId,
+                    typing_ticket: typingTicket,
+                    status: TypingStatus.TYPING,
+                },
+            });
+        }
+        catch {
+            // Typing is a best-effort hint; never block the actual reply path.
+        }
+    }
+    async clearInlineKeyboard(scopeId, messageId) {
+        void scopeId;
+        void messageId;
+    }
+    async sendDraft(scopeId, _draftId, text) {
+        await this.sendPlain(scopeId, text);
+    }
+}

package/dist/codex_app/client.d.ts

@@ -0,0 +1,176 @@
+import { EventEmitter } from 'node:events';
+import type { Logger } from '../logger.js';
+import type { AppThread, AppThreadSnapshot, AppTurnSnapshot, CodexAccountInfo, CodexAccountRateLimits, CodexAppInfo, CodexCollaborationMode, CodexCollaborationModePreset, CodexConfigRequirements, CodexEffectiveConfig, CodexExperimentalFeature, CodexFuzzyFileResult, CodexHooksListEntry, CodexLoginDeviceCode, CodexMcpResourceContent, CodexMcpServerStatus, CodexModelProviderCapabilities, CodexPluginDetail, CodexPluginMarketplace, CodexSkillsListEntry, CodexThreadGoal, ModelInfo, ReasoningEffortValue, ReviewTarget, SandboxModeValue, ThreadSessionState, ThreadGoalStatusValue } from '../types.js';
+export interface JsonRpcNotification {
+    method: string;
+    params?: any;
+}
+export interface JsonRpcServerRequest {
+    id: string | number;
+    method: string;
+    params?: any;
+}
+interface ListThreadsOptions {
+    limit: number;
+    searchTerm?: string | null;
+    archived?: boolean;
+}
+interface StartThreadOptions {
+    cwd: string | null;
+    approvalPolicy: string;
+    sandboxMode: SandboxModeValue;
+    model: string | null;
+}
+interface ResumeThreadOptions {
+    threadId: string;
+    cwd?: string | null;
+    approvalPolicy?: string | null;
+    sandboxMode?: SandboxModeValue | null;
+    model?: string | null;
+}
+export interface TextTurnInput {
+    type: 'text';
+    text: string;
+    text_elements: [];
+}
+export interface LocalImageTurnInput {
+    type: 'localImage';
+    path: string;
+}
+export type TurnInput = TextTurnInput | LocalImageTurnInput;
+interface StartTurnOptions {
+    threadId: string;
+    input: TurnInput[];
+    approvalPolicy: string;
+    sandboxMode: SandboxModeValue;
+    cwd: string | null;
+    model: string | null;
+    effort: ReasoningEffortValue | null;
+    serviceTier?: string | null | undefined;
+    collaborationMode: CodexCollaborationMode | null;
+}
+interface CodexAppServerRuntimeStatus {
+    pid: number | null;
+    port: number | null;
+    running: boolean;
+    managed: boolean;
+}
+interface StopOptions {
+    terminateServer?: boolean;
+}
+export declare class CodexAppClient extends EventEmitter {
+    private readonly codexCliBin;
+    private readonly launchCommand;
+    private readonly autolaunch;
+    private readonly serverStatePath;
+    private readonly serverLogPath;
+    private readonly logger;
+    private child;
+    private socket;
+    private requestId;
+    private pending;
+    private desiredRunning;
+    private reconnectTimer;
+    private starting;
+    private port;
+    private connected;
+    private userAgent;
+    constructor(codexCliBin: string, launchCommand: string, autolaunch: boolean, serverStatePath: string, serverLogPath: string, logger: Logger);
+    isConnected(): boolean;
+    getUserAgent(): string | null;
+    getServerStatus(): CodexAppServerRuntimeStatus;
+    start(): Promise<void>;
+    stop(options?: StopOptions): Promise<void>;
+    restart(): Promise<void>;
+    listThreads(options: ListThreadsOptions): Promise<AppThread[]>;
+    listLoadedThreads(): Promise<string[]>;
+    readThread(threadId: string, includeTurns?: boolean): Promise<AppThread | null>;
+    readThreadSnapshot(threadId: string): Promise<AppThreadSnapshot | null>;
+    startThread(options: StartThreadOptions): Promise<ThreadSessionState>;
+    resumeThread(options: ResumeThreadOptions): Promise<ThreadSessionState>;
+    startTurn(options: StartTurnOptions): Promise<{
+        id: string;
+        status: string;
+    }>;
+    steerTurn(threadId: string, expectedTurnId: string, input: TurnInput[]): Promise<{
+        turnId: string;
+    }>;
+    forkThread(options: {
+        threadId: string;
+        cwd: string | null;
+        approvalPolicy: string;
+        sandboxMode: SandboxModeValue;
+        model: string | null;
+        serviceTier?: string | null;
+    }): Promise<ThreadSessionState>;
+    rollbackThread(threadId: string, numTurns: number): Promise<AppThreadSnapshot | null>;
+    setThreadName(threadId: string, name: string): Promise<void>;
+    compactThread(threadId: string): Promise<void>;
+    getThreadGoal(threadId: string): Promise<CodexThreadGoal | null>;
+    setThreadGoal(options: {
+        threadId: string;
+        objective?: string | null;
+        status?: ThreadGoalStatusValue | null;
+        tokenBudget?: number | null | undefined;
+    }): Promise<CodexThreadGoal>;
+    clearThreadGoal(threadId: string): Promise<boolean>;
+    listThreadTurns(threadId: string, limit?: number): Promise<AppTurnSnapshot[]>;
+    archiveThread(threadId: string): Promise<void>;
+    unarchiveThread(threadId: string): Promise<AppThread | null>;
+    startReview(threadId: string, target: ReviewTarget, delivery?: 'inline' | 'detached'): Promise<{
+        turnId: string;
+        reviewThreadId: string;
+    }>;
+    listModels(): Promise<ModelInfo[]>;
+    readAccount(): Promise<CodexAccountInfo | null>;
+    startDeviceLogin(): Promise<CodexLoginDeviceCode>;
+    cancelLogin(loginId: string): Promise<void>;
+    logoutAccount(): Promise<void>;
+    sendAddCreditsNudgeEmail(creditType: 'credits' | 'usage_limit'): Promise<void>;
+    readAccountRateLimits(): Promise<CodexAccountRateLimits | null>;
+    readEffectiveConfig(cwd: string | null): Promise<CodexEffectiveConfig>;
+    listCollaborationModes(): Promise<CodexCollaborationModePreset[]>;
+    listSkills(cwd: string | null, forceReload?: boolean): Promise<CodexSkillsListEntry[]>;
+    writeSkillConfig(selector: {
+        name?: string | null;
+        path?: string | null;
+    }, enabled: boolean): Promise<void>;
+    listHooks(cwd: string | null): Promise<CodexHooksListEntry[]>;
+    listPlugins(cwd: string | null): Promise<CodexPluginMarketplace[]>;
+    readPlugin(pluginName: string, options?: {
+        marketplacePath?: string | null;
+        remoteMarketplaceName?: string | null;
+    }): Promise<CodexPluginDetail | null>;
+    readPluginSkill(remoteMarketplaceName: string, remotePluginId: string, skillName: string): Promise<string | null>;
+    listApps(threadId?: string | null, forceRefetch?: boolean): Promise<CodexAppInfo[]>;
+    readConfig(cwd: string | null, includeLayers?: boolean): Promise<Record<string, unknown>>;
+    readConfigRequirements(): Promise<CodexConfigRequirements | null>;
+    listExperimentalFeatures(): Promise<CodexExperimentalFeature[]>;
+    readModelProviderCapabilities(): Promise<CodexModelProviderCapabilities>;
+    fuzzyFileSearch(query: string, roots: string[]): Promise<CodexFuzzyFileResult[]>;
+    listMcpServerStatus(detail?: 'full' | 'toolsAndAuthOnly'): Promise<CodexMcpServerStatus[]>;
+    reloadMcpServers(): Promise<void>;
+    loginMcpServer(name: string): Promise<string>;
+    readMcpResource(server: string, uri: string, threadId?: string | null): Promise<CodexMcpResourceContent[]>;
+    interruptTurn(threadId: string, turnId: string): Promise<void>;
+    revealThread(threadId: string): Promise<void>;
+    respond(requestId: string | number, result: unknown): Promise<void>;
+    respondError(requestId: string | number, message: string): Promise<void>;
+    private startServer;
+    private attachPersistedServer;
+    private connectWebSocket;
+    private initialize;
+    private request;
+    private send;
+    private handleMessage;
+    private handleDisconnect;
+    private rejectPending;
+    private scheduleReconnect;
+    private terminateServer;
+    private openServerLogFiles;
+    private readServerState;
+    private writeServerState;
+    private clearServerState;
+    private clearServerStateForPid;
+}
+export {};