@ccpocket/bridge 1.45.3 → 1.46.0

package/dist/codex-process.d.ts

@@ -40,6 +40,23 @@ export interface CodexAppMetadata {
     isAccessible: boolean;
     isEnabled: boolean;
 }
+/** Plugin metadata returned by the Codex `plugin/list` RPC. */
+export interface CodexPluginMetadata {
+    id: string;
+    name: string;
+    path: string;
+    marketplaceName: string;
+    marketplacePath?: string;
+    installed: boolean;
+    enabled: boolean;
+    displayName?: string;
+    shortDescription?: string;
+    longDescription?: string;
+    defaultPrompt?: string;
+    brandColor?: string;
+    composerIcon?: string;
+    composerIconUrl?: string;
+}
 export interface CodexThreadSummary {
     id: string;
     preview: string;

package/dist/codex-process.js

@@ -370,7 +370,7 @@ export class CodexProcess extends EventEmitter {
         const pending = this.resolvePendingApproval(toolUseId);
         if (!pending) {
             // Fallback: McpElicitation lives in pendingUserInputs
-            if (this.approveUserInput(toolUseId, "Accept"))
+            if (this.approveUserInput(toolUseId, "Allow for this session"))
                 return;
             console.log("[codex-process] approveAlways() called but no pending permission requests");
             return;
@@ -398,7 +398,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingApprovals.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "decline"));
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, resolveApprovalRejectDecision(pending)));
         this.emitToolResult(pending.toolUseId, "Rejected");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
@@ -491,7 +491,7 @@ export class CodexProcess extends EventEmitter {
         if (!pending)
             return false;
         this.pendingUserInputs.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
+        this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, resolveUserInputRejectResult(pending, result)));
         this.emitToolResult(pending.toolUseId, "Rejected");
         if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
             this.setStatus("running");
@@ -759,6 +759,13 @@ export class CodexProcess extends EventEmitter {
     async _fetchCompletionEntitiesInternal(projectPath) {
         const TIMEOUT_MS = 10_000;
         try {
+            const requestOrNull = (method, params) => Promise.race([
+                this.request(method, params).catch((err) => {
+                    console.log(`[codex-process] ${method} failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+                    return null;
+                }),
+                new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS)),
+            ]);
             const skillsResult = (await Promise.race([
                 this.request("skills/list", { cwds: [projectPath] }),
                 new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS)),
@@ -772,6 +779,15 @@ export class CodexProcess extends EventEmitter {
                 }),
                 new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS)),
             ]));
+            const pluginsResult = await requestOrNull("plugin/list", { cwds: [projectPath] });
+            const optionalString = (value) => typeof value === "string" ? value : undefined;
+            const optionalFirstString = (value) => {
+                if (typeof value === "string")
+                    return value;
+                if (!Array.isArray(value))
+                    return undefined;
+                return value.find((entry) => typeof entry === "string");
+            };
             const skills = [];
             const skillMetadata = [];
             if (skillsResult?.data) {
@@ -808,6 +824,30 @@ export class CodexProcess extends EventEmitter {
                 isEnabled: app.isEnabled ?? true,
             }));
             this._apps = appMetadata;
+            const pluginMetadata = [];
+            for (const marketplace of pluginsResult?.marketplaces ?? []) {
+                for (const plugin of marketplace.plugins ?? []) {
+                    if (!plugin.installed || !plugin.enabled)
+                        continue;
+                    pluginMetadata.push({
+                        id: plugin.id,
+                        name: plugin.name,
+                        path: `plugin://${plugin.id}`,
+                        marketplaceName: marketplace.name,
+                        marketplacePath: marketplace.path ?? undefined,
+                        installed: plugin.installed,
+                        enabled: plugin.enabled,
+                        displayName: optionalString(plugin.interface?.displayName),
+                        shortDescription: optionalString(plugin.interface?.shortDescription),
+                        longDescription: optionalString(plugin.interface?.longDescription),
+                        defaultPrompt: optionalFirstString(plugin.interface?.defaultPrompt),
+                        brandColor: optionalString(plugin.interface?.brandColor),
+                        composerIcon: optionalString(plugin.interface?.composerIcon),
+                        composerIconUrl: optionalString(plugin.interface?.composerIconUrl),
+                    });
+                }
+            }
+            const plugins = pluginMetadata.map((plugin) => plugin.name);
             if (this.stopped)
                 return;
             const signature = JSON.stringify({
@@ -815,13 +855,17 @@ export class CodexProcess extends EventEmitter {
                 skillMetadata,
                 apps: appMetadata.map((app) => app.id),
                 appMetadata,
+                plugins,
+                pluginMetadata,
             });
             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`);
+            if (skills.length > 0 ||
+                appMetadata.length > 0 ||
+                pluginMetadata.length > 0) {
+                console.log(`[codex-process] completion entities loaded: ${skills.length} skills, ${appMetadata.length} apps, ${pluginMetadata.length} plugins`);
                 this.emitMessage({
                     type: "system",
                     subtype: "supported_commands",
@@ -829,6 +873,8 @@ export class CodexProcess extends EventEmitter {
                     skillMetadata,
                     apps: appMetadata.map((app) => app.id),
                     appMetadata,
+                    plugins,
+                    pluginMetadata,
                 });
             }
         }
@@ -1783,6 +1829,16 @@ function buildApprovalResponse(pending, decision) {
         decision,
     };
 }
+function resolveApprovalRejectDecision(pending) {
+    const availableDecisions = pending.input.availableDecisions;
+    if (!Array.isArray(availableDecisions))
+        return "decline";
+    const decisions = new Set(availableDecisions.filter((entry) => typeof entry === "string"));
+    if (decisions.has("cancel") && !decisions.has("decline")) {
+        return "cancel";
+    }
+    return "decline";
+}
 function buildUserInputResponse(pending, rawResult) {
     if (pending.kind === "questions") {
         return {
@@ -1791,6 +1847,18 @@ function buildUserInputResponse(pending, rawResult) {
     }
     return buildElicitationResponse(pending, rawResult);
 }
+function resolveUserInputRejectResult(pending, fallback) {
+    if (pending.kind !== "elicitation_approval")
+        return fallback;
+    const availableDecisions = pending.input.availableDecisions;
+    if (!Array.isArray(availableDecisions))
+        return fallback;
+    const decisions = new Set(availableDecisions.filter((entry) => typeof entry === "string"));
+    if (decisions.has("cancel") && !decisions.has("decline")) {
+        return "Cancel";
+    }
+    return fallback;
+}
 function extractWritableRootsFromConfigRead(response) {
     if (!response || typeof response !== "object")
         return [];
@@ -2410,8 +2478,9 @@ function createElicitationInput(params) {
     }
     const schema = asRecord(params.requestedSchema);
     const elicitationMeta = asRecord(params._meta);
-    if (isToolApprovalElicitation(schema, elicitationMeta)) {
+    if (isApprovalActionElicitation(schema, elicitationMeta)) {
         const questionId = "approval";
+        const isToolApproval = isToolApprovalElicitation(elicitationMeta);
         return {
             kind: "elicitation_approval",
             questions: [{ id: questionId, question: message }],
@@ -2420,12 +2489,13 @@ function createElicitationInput(params) {
                 serverName,
                 message,
                 _meta: elicitationMeta ?? null,
+                availableDecisions: buildApprovalActionElicitationAvailableDecisions(elicitationMeta, isToolApproval),
                 questions: [
                     {
                         id: questionId,
                         header: "Approve app tool call?",
                         question: message,
-                        options: buildToolApprovalElicitationOptions(elicitationMeta),
+                        options: buildApprovalActionElicitationOptions(elicitationMeta, isToolApproval),
                         multiSelect: false,
                         isOther: false,
                         isSecret: false,
@@ -2504,10 +2574,8 @@ function createElicitationInput(params) {
         },
     };
 }
-function isToolApprovalElicitation(schema, meta) {
-    if (meta?.codex_approval_kind !== "mcp_tool_call")
-        return false;
-    return isEmptyObjectSchema(schema);
+function isApprovalActionElicitation(schema, meta) {
+    return isEmptyObjectSchema(schema) && !isToolSuggestionElicitation(meta);
 }
 function isEmptyObjectSchema(schema) {
     if (!schema)
@@ -2517,29 +2585,63 @@ function isEmptyObjectSchema(schema) {
     const properties = asRecord(schema.properties);
     return properties != null && Object.keys(properties).length === 0;
 }
-function buildToolApprovalElicitationOptions(meta) {
+function isToolApprovalElicitation(meta) {
+    return meta?.codex_approval_kind === "mcp_tool_call";
+}
+function isToolSuggestionElicitation(meta) {
+    return meta?.codex_approval_kind === "tool_suggestion";
+}
+function buildApprovalActionElicitationOptions(meta, isToolApproval) {
     const persistModes = extractPersistModes(meta);
     const options = [
-        { label: "Allow", description: "Run the tool and continue." },
+        {
+            label: "Allow",
+            description: isToolApproval
+                ? "Run the tool and continue."
+                : "Allow this request and continue.",
+        },
     ];
     if (persistModes.has("session")) {
         options.push({
             label: "Allow for this session",
-            description: "Run the tool and remember this choice for this session.",
+            description: isToolApproval
+                ? "Run the tool and remember this choice for this session."
+                : "Allow this request and remember this choice for this session.",
         });
     }
     if (persistModes.has("always")) {
         options.push({
             label: "Always allow",
-            description: "Run the tool and remember this choice for future tool calls.",
+            description: isToolApproval
+                ? "Run the tool and remember this choice for future tool calls."
+                : "Allow this request and remember this choice for future requests.",
         });
     }
-    options.push({
-        label: "Cancel",
-        description: "Cancel this tool call.",
-    });
+    if (!isToolApproval) {
+        options.push({
+            label: "Deny",
+            description: "Decline this request and continue.",
+        });
+    }
+    options.push(isToolApproval
+        ? {
+            label: "Cancel",
+            description: "Cancel this tool call.",
+        }
+        : {
+            label: "Cancel",
+            description: "Cancel this request.",
+        });
     return options;
 }
+function buildApprovalActionElicitationAvailableDecisions(meta, isToolApproval) {
+    const persistModes = extractPersistModes(meta);
+    return [
+        "accept",
+        ...(persistModes.has("session") ? ["acceptForSession"] : []),
+        isToolApproval ? "cancel" : "decline",
+    ];
+}
 function extractPersistModes(meta) {
     const persist = meta?.persist;
     const modes = new Set();