@canonmsg/codex-plugin 0.18.7 → 0.18.8

package/dist/adapter.d.ts

@@ -32,6 +32,8 @@ export type CodexEvent = {
         cached_input_tokens?: number;
         output_tokens?: number;
     };
+} | {
+    type: 'skills.changed';
 };
 export interface CodexServerRequest {
     id: string | number;

package/dist/app-server-adapter.d.ts

@@ -1,4 +1,12 @@
 import type { CodexApprovalPolicy, CodexEvent, CodexRunTurnOptions, CodexSandboxMode, CodexTurnResult } from './adapter.js';
+export interface CodexSkillMetadata {
+    name: string;
+    path: string;
+    scope?: string;
+    description?: string;
+    shortDescription?: string;
+    displayName?: string;
+}
 export declare class CodexAppServerAdapter {
     private readonly cwd;
     private readonly codexBin;
@@ -26,6 +34,7 @@ export declare class CodexAppServerAdapter {
     private currentErrorText;
     private interrupted;
     private initialized;
+    private skillsCache;
     private messageTextByItem;
     private planText;
     constructor(opts: {
@@ -62,6 +71,10 @@ export declare class CodexAppServerAdapter {
     private rememberResolvedModel;
     private sandboxPolicyPayload;
     private buildWritableRoots;
+    listSkills(options?: {
+        forceReload?: boolean;
+    }): Promise<CodexSkillMetadata[]>;
+    private buildTurnInput;
     private ensureStarted;
     private handleLine;
     private handleServerRequest;

package/dist/app-server-adapter.js

@@ -27,6 +27,7 @@ export class CodexAppServerAdapter {
     currentErrorText = null;
     interrupted = false;
     initialized = false;
+    skillsCache = null;
     messageTextByItem = new Map();
     planText = '';
     constructor(opts) {
@@ -142,10 +143,7 @@ export class CodexAppServerAdapter {
             turnPromise.catch(() => { });
             const turnStarted = await this.sendRequest('turn/start', {
                 threadId: this.threadId,
-                input: [
-                    { type: 'text', text: prompt, text_elements: [] },
-                    ...imagePaths.map((path) => ({ type: 'localImage', path })),
-                ],
+                input: await this.buildTurnInput(prompt, imagePaths),
                 ...(this.model ? { model: this.model } : {}),
                 ...this.sandboxPolicyPayload(_extraAddDirs),
                 collaborationMode: {
@@ -226,6 +224,45 @@ export class CodexAppServerAdapter {
         }
         return roots;
     }
+    async listSkills(options = {}) {
+        await this.ensureStarted();
+        if (!options.forceReload && this.skillsCache) {
+            return this.skillsCache;
+        }
+        const result = await this.sendRequest('skills/list', {
+            cwds: [this.cwd],
+            ...(options.forceReload ? { forceReload: true } : {}),
+        });
+        const parsed = parseSkillsListResponse(result);
+        this.skillsCache = parsed;
+        return parsed;
+    }
+    async buildTurnInput(prompt, imagePaths) {
+        const skillPrompt = parseSkillSlashPrompt(prompt);
+        const input = [];
+        if (skillPrompt) {
+            const skills = await this.listSkills().catch(() => []);
+            const selected = skills.find((skill) => skill.name.toLowerCase() === skillPrompt.name.toLowerCase());
+            if (selected) {
+                input.push({ type: 'skill', name: selected.name, path: selected.path });
+                if (skillPrompt.prompt.trim()) {
+                    input.push({ type: 'text', text: skillPrompt.prompt, text_elements: [] });
+                }
+            }
+            else {
+                input.push({
+                    type: 'text',
+                    text: `$${skillPrompt.name}${skillPrompt.prompt.trim() ? ` ${skillPrompt.prompt.trim()}` : ''}`,
+                    text_elements: [],
+                });
+            }
+        }
+        else {
+            input.push({ type: 'text', text: prompt, text_elements: [] });
+        }
+        input.push(...imagePaths.map((path) => ({ type: 'localImage', path })));
+        return input;
+    }
     async ensureStarted() {
         if (this.child && this.initialized)
             return;
@@ -317,6 +354,11 @@ export class CodexAppServerAdapter {
             this.currentOnEvent?.({ type: 'turn.started' });
             return;
         }
+        if (method === 'skills/changed') {
+            this.skillsCache = null;
+            this.currentOnEvent?.({ type: 'skills.changed' });
+            return;
+        }
         if (method === 'thread/status/changed') {
             const status = params.status;
             if (status?.type === 'active' && Array.isArray(status.activeFlags)) {
@@ -487,6 +529,54 @@ function readRawString(record, key) {
     const value = record?.[key];
     return typeof value === 'string' ? value : undefined;
 }
+function readNullableString(record, key) {
+    const value = record?.[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function parseSkillSlashPrompt(prompt) {
+    const match = prompt.trim().match(/^\/skill\s+([A-Za-z0-9:_-]+)(?:\s+([\s\S]*))?$/);
+    if (!match?.[1])
+        return null;
+    return {
+        name: match[1],
+        prompt: match[2]?.trim() ?? '',
+    };
+}
+function parseSkillsListResponse(result) {
+    const entries = Array.isArray(result.data) ? result.data : [];
+    const skills = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        if (!isRecord(entry))
+            continue;
+        const cwdSkills = Array.isArray(entry.skills) ? entry.skills : [];
+        for (const rawSkill of cwdSkills) {
+            if (!isRecord(rawSkill))
+                continue;
+            if (rawSkill.enabled === false)
+                continue;
+            const name = readString(rawSkill, 'name');
+            const path = readString(rawSkill, 'path');
+            if (!name || !path || seen.has(name.toLowerCase()))
+                continue;
+            seen.add(name.toLowerCase());
+            const interfaceMetadata = isRecord(rawSkill.interface) ? rawSkill.interface : undefined;
+            const scope = readNullableString(rawSkill, 'scope');
+            const description = readNullableString(rawSkill, 'description');
+            const shortDescription = readNullableString(rawSkill, 'shortDescription');
+            const displayName = readNullableString(interfaceMetadata, 'displayName');
+            skills.push({
+                name,
+                path,
+                ...(scope ? { scope } : {}),
+                ...(description ? { description } : {}),
+                ...(shortDescription ? { shortDescription } : {}),
+                ...(displayName ? { displayName } : {}),
+            });
+        }
+    }
+    return skills;
+}
 function stringifyPreview(value) {
     if (typeof value === 'string')
         return value;

package/dist/host.d.ts

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { type CanonRuntimeCommandDescriptor } from '@canonmsg/core';
+import { type CodexSkillMetadata } from './app-server-adapter.js';
 interface HostSessionState {
     lastError?: string;
     model?: string;
@@ -32,5 +34,6 @@ export declare const CODEX_EFFORT_OPTIONS: readonly [{
     readonly value: "xhigh";
     readonly label: "Extra high";
 }];
+export declare function buildCodexSkillCommand(skills: ReadonlyArray<CodexSkillMetadata>): CanonRuntimeCommandDescriptor | null;
 export declare function main(): Promise<void>;
 export {};

package/dist/host.js

@@ -85,6 +85,50 @@ export const CODEX_EFFORT_OPTIONS = [
     { value: 'xhigh', label: 'Extra high' },
 ];
 const CODEX_EFFORT_VALUES = new Set(CODEX_EFFORT_OPTIONS.map((option) => option.value));
+const MAX_CODEX_SKILL_COMMAND_CHOICES = 50;
+export function buildCodexSkillCommand(skills) {
+    const choices = skills
+        .filter((skill) => /^[A-Za-z0-9:_-]+$/.test(skill.name))
+        .slice(0, MAX_CODEX_SKILL_COMMAND_CHOICES)
+        .map((skill) => {
+        const description = skill.shortDescription
+            ?? skill.description
+            ?? (skill.scope ? `${skill.scope} skill` : undefined);
+        return {
+            value: skill.name,
+            label: skill.displayName ?? skill.name,
+            ...(description ? { description } : {}),
+        };
+    });
+    if (choices.length === 0)
+        return null;
+    return {
+        id: 'codex-skill',
+        label: 'Use skill',
+        description: 'Invoke one of the Codex skills available to this runtime.',
+        aliases: ['skill'],
+        category: 'skill',
+        placements: ['composer_slash', 'command_palette'],
+        availability: ['always'],
+        trailingTextBehavior: 'send_as_prompt',
+        args: [
+            {
+                id: 'skill',
+                label: 'Skill',
+                kind: 'enum',
+                required: true,
+                choices,
+            },
+            {
+                id: 'prompt',
+                label: 'Prompt',
+                kind: 'string',
+                captureRemaining: true,
+            },
+        ],
+        dispatch: { kind: 'text_passthrough', template: '/skill {args.skill} {args.prompt}' },
+    };
+}
 function buildCodexRuntimeDescriptor(input) {
     const commands = [
         {
@@ -105,6 +149,10 @@ function buildCodexRuntimeDescriptor(input) {
         RUNTIME_STOP_ACTION,
         RUNTIME_STOP_AND_DROP_ACTION,
     ];
+    const skillCommand = input.skills?.length ? buildCodexSkillCommand(input.skills) : null;
+    if (skillCommand) {
+        commands.push(skillCommand);
+    }
     const descriptor = buildFirstPartyCodingRuntimeDescriptor({
         clientType: 'codex',
         models: input.models,
@@ -1437,6 +1485,10 @@ export async function main() {
                     console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Thread ${event.threadId}`);
                     return;
                 }
+                if (event.type === 'skills.changed') {
+                    void refreshCodexSkillInventory(true).then(() => publishRuntimeHeartbeat());
+                    return;
+                }
                 if (event.type === 'message') {
                     session.turnState = 'streaming';
                     markTurnProgress(session);
@@ -1674,7 +1726,8 @@ export async function main() {
         show: stringArgs(args['show-runtime-detail']),
         hide: stringArgs(args['hide-runtime-detail']),
     });
-    let runtimeDescriptor = {
+    let codexSkills = [];
+    const buildCurrentRuntimeDescriptor = () => ({
         defaultWorkspaceId: workspaceOptions[0]?.id,
         ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
         availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
@@ -1693,8 +1746,32 @@ export async function main() {
             presentation: runtimePresentation,
             supportsPlanMode: useAppServer,
             supportsRichCards: useAppServer,
+            skills: codexSkills,
         }),
-    };
+    });
+    let runtimeDescriptor = buildCurrentRuntimeDescriptor();
+    async function refreshCodexSkillInventory(forceReload = false) {
+        if (!useAppServer)
+            return;
+        const probe = new CodexAppServerAdapter({
+            cwd: workingDir,
+            codexBin,
+            model: typeof args.model === 'string' ? args.model : null,
+            configOverrides: args.config ?? [],
+        });
+        try {
+            codexSkills = await probe.listSkills({ forceReload });
+            runtimeDescriptor = buildCurrentRuntimeDescriptor();
+        }
+        catch (error) {
+            codexSkills = [];
+            runtimeDescriptor = buildCurrentRuntimeDescriptor();
+            console.error('[canon-codex] Failed to load Codex skills:', error instanceof Error ? error.message : error);
+        }
+        finally {
+            probe.close();
+        }
+    }
     function applySessionControl(conversationId, control) {
         const session = sessions.get(conversationId);
         if (!session || session.closed)
@@ -1950,51 +2027,7 @@ export async function main() {
             onError: (error) => console.error(`[canon-codex] SSE error: ${error.message}`),
         },
     });
-    try {
-        runtimeDescriptor = {
-            defaultWorkspaceId: workspaceOptions[0]?.id,
-            ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
-            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
-            availableExecutionModes: hostAvailableExecutionModes,
-            availablePermissionModes: [...codexPermissionEnvelope.availablePermissionModes],
-            ...(codexPermissionEnvelope.defaultPermissionMode
-                ? { defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode }
-                : {}),
-            runtimeDescriptor: buildCodexRuntimeDescriptor({
-                models: codexModelOptions,
-                workspaces: buildPublicWorkspaceOptions(workspaceOptions),
-                workspaceRoots: workspaceRootMetadata,
-                executionModes: hostAvailableExecutionModes,
-                permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
-                defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
-                presentation: runtimePresentation,
-                supportsPlanMode: useAppServer,
-                supportsRichCards: useAppServer,
-            }),
-        };
-    }
-    catch {
-        runtimeDescriptor = {
-            defaultWorkspaceId: workspaceOptions[0]?.id,
-            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
-            availableExecutionModes: hostAvailableExecutionModes,
-            availablePermissionModes: [...codexPermissionEnvelope.availablePermissionModes],
-            ...(codexPermissionEnvelope.defaultPermissionMode
-                ? { defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode }
-                : {}),
-            runtimeDescriptor: buildCodexRuntimeDescriptor({
-                models: codexModelOptions,
-                workspaces: buildPublicWorkspaceOptions(workspaceOptions),
-                workspaceRoots: workspaceRootMetadata,
-                executionModes: hostAvailableExecutionModes,
-                permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
-                defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
-                presentation: runtimePresentation,
-                supportsPlanMode: useAppServer,
-                supportsRichCards: useAppServer,
-            }),
-        };
-    }
+    await refreshCodexSkillInventory();
     try {
         const conversations = await client.getConversations();
         lastKnownConversationRefreshAt = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.18.7",
+  "version": "0.18.8",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -29,9 +29,9 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/agent-sdk": "^3.3.1",
+    "@canonmsg/agent-sdk": "^3.4.1",
     "@canonmsg/coding-agent-host": "^0.2.2",
-    "@canonmsg/core": "^2.8.1"
+    "@canonmsg/core": "^2.9.2"
   },
   "engines": {
     "node": ">=18.0.0"