@ccpocket/bridge 1.33.3 → 1.34.0

package/dist/codex-process.d.ts

@@ -27,6 +27,15 @@ export interface CodexSkillMetadata {
     defaultPrompt?: string;
     brandColor?: string;
 }
+/** App / connector metadata returned by the Codex `app/list` RPC. */
+export interface CodexAppMetadata {
+    id: string;
+    name: string;
+    description: string;
+    installUrl?: string;
+    isAccessible: boolean;
+    isEnabled: boolean;
+}
 export interface CodexThreadSummary {
     id: string;
     preview: string;
@@ -64,10 +73,17 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private lastTokenUsage;
     /** Full skill metadata from the last `skills/list` response. */
     private _skills;
+    /** Full app metadata from the last `app/list` response. */
+    private _apps;
     /** Project path stored for re-fetching skills on `skills/changed`. */
     private _projectPath;
+    /** Prevent redundant completion fetch storms from repeated change notifications. */
+    private _completionFetchInFlight;
+    private _completionFetchQueued;
+    private _lastCompletionEntitiesSignature;
     /** Expose skill metadata so session/websocket can access it. */
     get skills(): CodexSkillMetadata[];
+    get apps(): CodexAppMetadata[];
     private rpcSeq;
     private pendingRpc;
     private stdoutBuffer;
@@ -135,6 +151,20 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
         name: string;
         path: string;
     }): void;
+    sendInputStructured(text: string, options?: {
+        images?: Array<{
+            base64: string;
+            mimeType: string;
+        }>;
+        skills?: Array<{
+            name: string;
+            path: string;
+        }>;
+        mentions?: Array<{
+            name: string;
+            path: string;
+        }>;
+    }): void;
     approve(toolUseId?: string, _updatedInput?: Record<string, unknown>): void;
     approveAlways(toolUseId?: string): void;
     reject(toolUseId?: string, _message?: string): void;
@@ -158,12 +188,8 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private handlePlanRejected;
     private bootstrap;
     private initializeRpcConnection;
-    /**
-     * Fetch skills from Codex app-server via `skills/list` RPC and emit them
-     * as a `supported_commands` system message so the Flutter client can display
-     * skill entries alongside built-in slash commands.
-     */
-    private fetchSkills;
+    private fetchCompletionEntities;
+    private _fetchCompletionEntitiesInternal;
     private runInputLoop;
     private handleStdoutChunk;
     private handleRpcEnvelope;

package/dist/codex-process.js

@@ -45,12 +45,21 @@ export class CodexProcess extends EventEmitter {
     lastTokenUsage = null;
     /** Full skill metadata from the last `skills/list` response. */
     _skills = [];
+    /** Full app metadata from the last `app/list` response. */
+    _apps = [];
     /** Project path stored for re-fetching skills on `skills/changed`. */
     _projectPath = null;
+    /** Prevent redundant completion fetch storms from repeated change notifications. */
+    _completionFetchInFlight = null;
+    _completionFetchQueued = false;
+    _lastCompletionEntitiesSignature = null;
     /** Expose skill metadata so session/websocket can access it. */
     get skills() {
         return this._skills;
     }
+    get apps() {
+        return this._apps;
+    }
     rpcSeq = 1;
     pendingRpc = new Map();
     stdoutBuffer = "";
@@ -273,13 +282,21 @@ export class CodexProcess extends EventEmitter {
         resolve({ text, images });
     }
     sendInputWithSkill(text, skill) {
+        this.sendInputStructured(text, { skills: [skill] });
+    }
+    sendInputStructured(text, options) {
         if (!this.inputResolve) {
-            console.error("[codex-process] No pending input resolver for sendInputWithSkill");
+            console.error("[codex-process] No pending input resolver for sendInputStructured");
             return;
         }
         const resolve = this.inputResolve;
         this.inputResolve = null;
-        resolve({ text, skill });
+        resolve({
+            text,
+            images: options?.images,
+            skills: options?.skills,
+            mentions: options?.mentions,
+        });
     }
     approve(toolUseId, _updatedInput) {
         // Check if this is a plan completion approval
@@ -369,7 +386,7 @@ export class CodexProcess extends EventEmitter {
             return undefined;
         return {
             toolUseId: pendingAsk.toolUseId,
-            toolName: "AskUserQuestion",
+            toolName: pendingAsk.toolName,
             input: { ...pendingAsk.input },
         };
     }
@@ -526,9 +543,13 @@ export class CodexProcess extends EventEmitter {
                     : {}),
             });
             this.setStatus("idle");
-            // Fetch skills in background (non-blocking)
+            // Fetch skills/apps in background (non-blocking)
             this._projectPath = projectPath;
-            void this.fetchSkills(projectPath);
+            setTimeout(() => {
+                if (!this.stopped) {
+                    void this.fetchCompletionEntities(projectPath);
+                }
+            }, 25);
             await this.runInputLoop(options);
         }
         catch (err) {
@@ -560,58 +581,101 @@ export class CodexProcess extends EventEmitter {
         });
         this.notify("initialized", {});
     }
-    /**
-     * Fetch skills from Codex app-server via `skills/list` RPC and emit them
-     * as a `supported_commands` system message so the Flutter client can display
-     * skill entries alongside built-in slash commands.
-     */
-    async fetchSkills(projectPath) {
+    async fetchCompletionEntities(projectPath) {
+        if (this._completionFetchInFlight) {
+            this._completionFetchQueued = true;
+            return this._completionFetchInFlight;
+        }
+        this._completionFetchInFlight = this._fetchCompletionEntitiesInternal(projectPath);
+        try {
+            await this._completionFetchInFlight;
+        }
+        finally {
+            this._completionFetchInFlight = null;
+            if (this._completionFetchQueued && !this.stopped && this._projectPath) {
+                this._completionFetchQueued = false;
+                void this.fetchCompletionEntities(this._projectPath);
+            }
+        }
+    }
+    async _fetchCompletionEntitiesInternal(projectPath) {
         const TIMEOUT_MS = 10_000;
         try {
-            const result = (await Promise.race([
+            const skillsResult = (await Promise.race([
                 this.request("skills/list", { cwds: [projectPath] }),
                 new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS)),
             ]));
-            if (this.stopped || !result?.data)
-                return;
+            const appsResult = (await Promise.race([
+                this.request("app/list", {
+                    cursor: null,
+                    limit: 100,
+                    threadId: this._threadId ?? undefined,
+                    forceRefetch: false,
+                }),
+                new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS)),
+            ]));
             const skills = [];
-            const slashCommands = [];
             const skillMetadata = [];
-            for (const entry of result.data) {
-                for (const skill of entry.skills) {
-                    if (skill.enabled) {
-                        skills.push(skill.name);
-                        slashCommands.push(skill.name);
-                        skillMetadata.push({
-                            name: skill.name,
-                            path: skill.path,
-                            description: skill.description,
-                            shortDescription: skill.shortDescription ??
-                                skill.interface?.shortDescription ??
-                                undefined,
-                            enabled: skill.enabled,
-                            scope: skill.scope,
-                            displayName: skill.interface?.displayName ?? undefined,
-                            defaultPrompt: skill.interface?.defaultPrompt ?? undefined,
-                            brandColor: skill.interface?.brandColor ?? undefined,
-                        });
+            if (skillsResult?.data) {
+                for (const entry of skillsResult.data) {
+                    for (const skill of entry.skills) {
+                        if (skill.enabled) {
+                            skills.push(skill.name);
+                            skillMetadata.push({
+                                name: skill.name,
+                                path: skill.path,
+                                description: skill.description,
+                                shortDescription: skill.shortDescription ??
+                                    skill.interface?.shortDescription ??
+                                    undefined,
+                                enabled: skill.enabled,
+                                scope: skill.scope,
+                                displayName: skill.interface?.displayName ?? undefined,
+                                defaultPrompt: skill.interface?.defaultPrompt ?? undefined,
+                                brandColor: skill.interface?.brandColor ?? undefined,
+                            });
+                        }
                     }
                 }
             }
             this._skills = skillMetadata;
-            if (slashCommands.length > 0) {
-                console.log(`[codex-process] skills/list returned ${slashCommands.length} skills`);
+            const appMetadata = (appsResult?.data ?? [])
+                .filter((app) => (app.isAccessible ?? true) && (app.isEnabled ?? true))
+                .map((app) => ({
+                id: app.id,
+                name: app.name,
+                description: app.description,
+                installUrl: app.installUrl ?? undefined,
+                isAccessible: app.isAccessible ?? true,
+                isEnabled: app.isEnabled ?? true,
+            }));
+            this._apps = appMetadata;
+            if (this.stopped)
+                return;
+            const signature = JSON.stringify({
+                skills,
+                skillMetadata,
+                apps: appMetadata.map((app) => app.id),
+                appMetadata,
+            });
+            if (signature === this._lastCompletionEntitiesSignature) {
+                return;
+            }
+            this._lastCompletionEntitiesSignature = signature;
+            if (skills.length > 0 || appMetadata.length > 0) {
+                console.log(`[codex-process] completion entities loaded: ${skills.length} skills, ${appMetadata.length} apps`);
                 this.emitMessage({
                     type: "system",
                     subtype: "supported_commands",
-                    slashCommands,
                     skills,
                     skillMetadata,
+                    apps: appMetadata.map((app) => app.id),
+                    appMetadata,
                 });
             }
         }
         catch (err) {
-            console.log(`[codex-process] skills/list failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+            console.log(`[codex-process] completion entity fetch failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     async runInputLoop(options) {
@@ -997,9 +1061,15 @@ export class CodexProcess extends EventEmitter {
                 break;
             }
             case "skills/changed": {
-                // Re-fetch skills when Codex notifies us of changes
+                // Re-fetch skills/apps when Codex notifies us of changes
                 if (this._projectPath) {
-                    void this.fetchSkills(this._projectPath);
+                    void this.fetchCompletionEntities(this._projectPath);
+                }
+                break;
+            }
+            case "app/list/updated": {
+                if (this._projectPath) {
+                    void this.fetchCompletionEntities(this._projectPath);
                 }
                 break;
             }
@@ -1367,12 +1437,19 @@ export class CodexProcess extends EventEmitter {
     async toRpcInput(pendingInput) {
         const input = [];
         const tempPaths = [];
-        // Prepend SkillUserInput if a skill reference is attached
-        if (pendingInput.skill) {
+        // Prepend structured input items before the free-form text body.
+        for (const skill of pendingInput.skills ?? []) {
             input.push({
                 type: "skill",
-                name: pendingInput.skill.name,
-                path: pendingInput.skill.path,
+                name: skill.name,
+                path: skill.path,
+            });
+        }
+        for (const mention of pendingInput.mentions ?? []) {
+            input.push({
+                type: "mention",
+                name: mention.name,
+                path: mention.path,
             });
         }
         input.push({ type: "text", text: pendingInput.text });