poe-code 3.0.183 → 3.0.185

package/packages/agent-mcp-config/dist/configs.js

@@ -0,0 +1,74 @@
+import { resolveAgentId } from "@poe-code/agent-defs";
+const agentMcpConfigs = {
+    "claude-code": {
+        configFile: "~/.claude.json",
+        configKey: "mcpServers",
+        format: "json",
+        shape: "standard"
+    },
+    "claude-desktop": {
+        configFile: (platform) => {
+            switch (platform) {
+                case "darwin":
+                    return "~/Library/Application Support/Claude/claude_desktop_config.json";
+                case "win32":
+                    return "~/AppData/Roaming/Claude/claude_desktop_config.json";
+                default:
+                    return "~/.config/Claude/claude_desktop_config.json";
+            }
+        },
+        configKey: "mcpServers",
+        format: "json",
+        shape: "standard",
+        mcpOutputFormat: "markdown_instructions"
+    },
+    codex: {
+        configFile: "~/.codex/config.toml",
+        configKey: "mcp_servers",
+        format: "toml",
+        shape: "standard"
+    },
+    opencode: {
+        configFile: "~/.config/opencode/opencode.json",
+        configKey: "mcp",
+        format: "json",
+        shape: "opencode"
+    },
+    kimi: {
+        configFile: "~/.kimi/mcp.json",
+        configKey: "mcpServers",
+        format: "json",
+        shape: "standard"
+    },
+    goose: {
+        configFile: "~/.config/goose/config.yaml",
+        configKey: "extensions",
+        format: "yaml",
+        shape: "goose"
+    }
+};
+export const supportedAgents = Object.keys(agentMcpConfigs);
+export function resolveAgentSupport(input, registry = agentMcpConfigs) {
+    const resolvedId = resolveAgentId(input);
+    if (!resolvedId) {
+        return { status: "unknown", input };
+    }
+    const config = registry[resolvedId];
+    if (!config) {
+        return { status: "unsupported", input, id: resolvedId };
+    }
+    return { status: "supported", input, id: resolvedId, config };
+}
+export function isSupported(agentId) {
+    return resolveAgentSupport(agentId).status === "supported";
+}
+export function getAgentConfig(agentId) {
+    const support = resolveAgentSupport(agentId);
+    return support.status === "supported" ? support.config : undefined;
+}
+export function resolveConfigPath(config, platform) {
+    if (typeof config.configFile === "function") {
+        return config.configFile(platform);
+    }
+    return config.configFile;
+}

package/packages/agent-mcp-config/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { McpStdioServer, McpHttpServer, McpServerConfig, McpServerEntry, ApplyOptions } from "./types.js";
+export { supportedAgents, isSupported, resolveAgentSupport } from "./configs.js";
+export { configure, unconfigure, UnsupportedAgentError } from "./apply.js";

package/packages/agent-mcp-config/dist/index.js

@@ -0,0 +1,2 @@
+export { supportedAgents, isSupported, resolveAgentSupport } from "./configs.js";
+export { configure, unconfigure, UnsupportedAgentError } from "./apply.js";

package/packages/agent-mcp-config/dist/shapes.d.ts

@@ -0,0 +1,31 @@
+import type { McpServerEntry } from "./types.js";
+export type ShapeName = "standard" | "opencode" | "goose";
+export interface StandardShapeOutput {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface OpencodeShapeOutput {
+    type: "local";
+    command: string[];
+    env?: Record<string, string>;
+    enabled: boolean;
+}
+export interface GooseStdioShapeOutput {
+    type: "stdio";
+    cmd: string;
+    args?: string[];
+    envs?: Record<string, string>;
+}
+export interface GooseHttpShapeOutput {
+    type: "http";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type GooseShapeOutput = GooseStdioShapeOutput | GooseHttpShapeOutput;
+export type ShapeOutput = StandardShapeOutput | OpencodeShapeOutput | GooseShapeOutput;
+export type ShapeTransformer = (entry: McpServerEntry) => ShapeOutput | undefined;
+export declare function standardShape(entry: McpServerEntry): ShapeOutput | undefined;
+export declare function opencodeShape(entry: McpServerEntry): OpencodeShapeOutput;
+export declare function gooseShape(entry: McpServerEntry): GooseShapeOutput | undefined;
+export declare function getShapeTransformer(shape: ShapeName): ShapeTransformer;

package/packages/agent-mcp-config/dist/shapes.js

@@ -0,0 +1,87 @@
+function transformStdioServer(config, enabled) {
+    if (!enabled) {
+        return undefined;
+    }
+    const result = {
+        command: config.command
+    };
+    if (config.args && config.args.length > 0) {
+        result.args = config.args;
+    }
+    if (config.env && Object.keys(config.env).length > 0) {
+        result.env = config.env;
+    }
+    return result;
+}
+export function standardShape(entry) {
+    const enabled = entry.enabled !== false;
+    if (entry.config.transport === "stdio") {
+        return transformStdioServer(entry.config, enabled);
+    }
+    if (!enabled) {
+        return undefined;
+    }
+    return {
+        command: entry.config.url
+    };
+}
+function transformStdioServerOpencode(config, enabled) {
+    const command = config.args && config.args.length > 0
+        ? [config.command, ...config.args]
+        : [config.command];
+    const result = {
+        type: "local",
+        command,
+        enabled
+    };
+    if (config.env && Object.keys(config.env).length > 0) {
+        result.env = config.env;
+    }
+    return result;
+}
+export function opencodeShape(entry) {
+    const enabled = entry.enabled !== false;
+    if (entry.config.transport === "stdio") {
+        return transformStdioServerOpencode(entry.config, enabled);
+    }
+    return {
+        type: "local",
+        command: [entry.config.url],
+        enabled
+    };
+}
+export function gooseShape(entry) {
+    const enabled = entry.enabled !== false;
+    if (!enabled) {
+        return undefined;
+    }
+    if (entry.config.transport === "stdio") {
+        const result = {
+            type: "stdio",
+            cmd: entry.config.command
+        };
+        if (entry.config.args && entry.config.args.length > 0) {
+            result.args = entry.config.args;
+        }
+        if (entry.config.env && Object.keys(entry.config.env).length > 0) {
+            result.envs = entry.config.env;
+        }
+        return result;
+    }
+    const result = {
+        type: "http",
+        url: entry.config.url
+    };
+    if (entry.config.headers && Object.keys(entry.config.headers).length > 0) {
+        result.headers = entry.config.headers;
+    }
+    return result;
+}
+const shapeTransformers = {
+    standard: standardShape,
+    opencode: opencodeShape,
+    goose: gooseShape
+};
+export function getShapeTransformer(shape) {
+    return shapeTransformers[shape];
+}

package/packages/agent-mcp-config/dist/types.d.ts

@@ -0,0 +1,25 @@
+import type { FileSystem, MutationObservers } from "../../config-mutations/dist/index.js";
+export interface McpStdioServer {
+    transport: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface McpHttpServer {
+    transport: "http";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type McpServerConfig = McpStdioServer | McpHttpServer;
+export interface McpServerEntry {
+    name: string;
+    config: McpServerConfig;
+    enabled?: boolean;
+}
+export interface ApplyOptions {
+    fs: FileSystem;
+    homeDir: string;
+    platform: "darwin" | "linux" | "win32";
+    dryRun?: boolean;
+    observers?: MutationObservers;
+}

package/packages/agent-mcp-config/dist/types.js

@@ -0,0 +1 @@
+export {};

package/packages/agent-skill-config/dist/apply.d.ts

@@ -0,0 +1,25 @@
+import type { ApplyOptions, SkillFile } from "./types.js";
+export declare class UnsupportedAgentError extends Error {
+    constructor(agentId: string);
+}
+export declare function configure(agentId: string, options: ApplyOptions): Promise<void>;
+export declare function unconfigure(agentId: string, options: ApplyOptions & {
+    force?: boolean;
+}): Promise<void>;
+export type InstallSkillOptions = {
+    fs: ApplyOptions["fs"];
+    cwd: string;
+    homeDir: string;
+    scope: ApplyOptions["scope"];
+    dryRun?: boolean;
+    observers?: ApplyOptions["observers"];
+};
+export type InstallSkillResult = {
+    skillPath: string;
+    displayPath: string;
+};
+/**
+ * Install a skill for an agent.
+ * Creates folder structure: skillDir/<skill.name>/SKILL.md
+ */
+export declare function installSkill(agentId: string, skill: SkillFile, options: InstallSkillOptions): Promise<InstallSkillResult>;

package/packages/agent-skill-config/dist/apply.js

@@ -0,0 +1,109 @@
+import { fileMutation, runMutations, templateMutation } from "@poe-code/config-mutations";
+import { resolveAgentSupport } from "./configs.js";
+import { createTemplateLoader } from "./templates.js";
+export class UnsupportedAgentError extends Error {
+    constructor(agentId) {
+        super(`Unsupported agent: ${agentId}`);
+        this.name = "UnsupportedAgentError";
+    }
+}
+function toHomeRelative(localSkillDir) {
+    if (localSkillDir.startsWith("~/") || localSkillDir === "~") {
+        return localSkillDir;
+    }
+    const normalized = localSkillDir.startsWith("./")
+        ? localSkillDir.slice(2)
+        : localSkillDir;
+    return `~/${normalized}`;
+}
+const bundledSkillTemplateIds = ["poe-generate.md"];
+export async function configure(agentId, options) {
+    const support = resolveAgentSupport(agentId);
+    if (support.status !== "supported") {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const scope = options.scope ?? "global";
+    const config = support.config;
+    const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+    const homeDir = scope === "global" ? options.homeDir : options.cwd;
+    await runMutations([
+        fileMutation.ensureDirectory({
+            path: skillDir,
+            label: `Ensure directory ${skillDir}`
+        }),
+        ...bundledSkillTemplateIds.map((templateId) => templateMutation.write({
+            target: `${skillDir}/${templateId}`,
+            templateId,
+            label: `Write bundled skill ${templateId} to ${skillDir}`
+        }))
+    ], {
+        fs: options.fs,
+        homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers,
+        templates: createTemplateLoader()
+    });
+}
+export async function unconfigure(agentId, options) {
+    const support = resolveAgentSupport(agentId);
+    if (support.status !== "supported") {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const scope = options.scope ?? "global";
+    const config = support.config;
+    const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+    const homeDir = scope === "global" ? options.homeDir : options.cwd;
+    await runMutations([
+        fileMutation.removeDirectory({
+            path: skillDir,
+            force: options.force,
+            label: `Remove skills directory ${skillDir}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers
+    });
+}
+const SKILL_TEMPLATE_ID = "__skill_content__";
+/**
+ * Install a skill for an agent.
+ * Creates folder structure: skillDir/<skill.name>/SKILL.md
+ */
+export async function installSkill(agentId, skill, options) {
+    const support = resolveAgentSupport(agentId);
+    if (support.status !== "supported") {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const scope = options.scope ?? "local";
+    const config = support.config;
+    // Use home-relative paths for mutations (same pattern as configure/unconfigure)
+    const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+    const skillFolderPath = `${skillDir}/${skill.name}`;
+    const skillFilePath = `${skillFolderPath}/SKILL.md`;
+    const displayPath = `${scope === "global" ? config.globalSkillDir : config.localSkillDir}/${skill.name}/SKILL.md`;
+    await runMutations([
+        fileMutation.ensureDirectory({
+            path: skillFolderPath,
+            label: `Ensure skill directory ${skill.name}`
+        }),
+        templateMutation.write({
+            target: skillFilePath,
+            templateId: SKILL_TEMPLATE_ID,
+            label: `Write skill ${skill.name}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir: scope === "global" ? options.homeDir : options.cwd,
+        dryRun: options.dryRun,
+        observers: options.observers,
+        templates: async (templateId) => {
+            if (templateId === SKILL_TEMPLATE_ID) {
+                return skill.content;
+            }
+            throw new Error(`Unknown template: ${templateId}`);
+        }
+    });
+    return { skillPath: skillFilePath, displayPath };
+}

package/packages/agent-skill-config/dist/configs.d.ts

@@ -0,0 +1,16 @@
+export interface AgentSkillConfig {
+    globalSkillDir: string;
+    localSkillDir: string;
+}
+export type SkillScope = "global" | "local";
+export declare const supportedAgents: readonly string[];
+export type AgentSupportStatus = "supported" | "unsupported" | "unknown";
+export interface AgentSupportResult {
+    status: AgentSupportStatus;
+    input: string;
+    id?: string;
+    config?: AgentSkillConfig;
+}
+export declare function resolveAgentSupport(input: string, registry?: Record<string, AgentSkillConfig>): AgentSupportResult;
+export declare function getAgentConfig(agentId: string): AgentSkillConfig | undefined;
+export declare function resolveSkillDir(config: AgentSkillConfig, scope: SkillScope, cwd: string): string;

package/packages/agent-skill-config/dist/configs.js

@@ -0,0 +1,66 @@
+import os from "node:os";
+import path from "node:path";
+import { resolveAgentId } from "@poe-code/agent-defs";
+const agentSkillConfigs = {
+    "claude-code": {
+        globalSkillDir: "~/.claude/skills",
+        localSkillDir: ".claude/skills"
+    },
+    codex: {
+        globalSkillDir: "~/.codex/skills",
+        localSkillDir: ".codex/skills"
+    },
+    opencode: {
+        globalSkillDir: "~/.config/opencode/skills",
+        localSkillDir: ".opencode/skills"
+    },
+    goose: {
+        globalSkillDir: "~/.agents/skills",
+        localSkillDir: ".agents/skills"
+    }
+};
+export const supportedAgents = Object.keys(agentSkillConfigs);
+export function resolveAgentSupport(input, registry = agentSkillConfigs) {
+    const resolvedId = resolveAgentId(input);
+    if (!resolvedId) {
+        return { status: "unknown", input };
+    }
+    const config = registry[resolvedId];
+    if (!config) {
+        return { status: "unsupported", input, id: resolvedId };
+    }
+    return { status: "supported", input, id: resolvedId, config };
+}
+export function getAgentConfig(agentId) {
+    const support = resolveAgentSupport(agentId);
+    return support.status === "supported" ? support.config : undefined;
+}
+function expandHome(targetPath) {
+    if (!targetPath?.startsWith("~")) {
+        return targetPath;
+    }
+    if (targetPath === "~") {
+        return os.homedir();
+    }
+    // Handle ~./ -> ~/.
+    if (targetPath.startsWith("~./")) {
+        targetPath = `~/.${targetPath.slice(3)}`;
+    }
+    let remainder = targetPath.slice(1);
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+        remainder = remainder.slice(1);
+    }
+    else if (remainder.startsWith(".")) {
+        remainder = remainder.slice(1);
+        if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+            remainder = remainder.slice(1);
+        }
+    }
+    return remainder.length === 0 ? os.homedir() : path.join(os.homedir(), remainder);
+}
+export function resolveSkillDir(config, scope, cwd) {
+    if (scope === "global") {
+        return path.resolve(expandHome(config.globalSkillDir));
+    }
+    return path.resolve(cwd, config.localSkillDir);
+}

package/packages/agent-skill-config/dist/exports.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/agent-skill-config/dist/exports.compile-check.js

@@ -0,0 +1 @@
+export {};

package/packages/agent-skill-config/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { AgentSkillConfig, AgentSupportResult, AgentSupportStatus, SkillScope } from "./configs.js";
+export type { ApplyOptions, SkillFile } from "./types.js";
+export { supportedAgents, resolveAgentSupport, getAgentConfig, resolveSkillDir } from "./configs.js";
+export { configure, unconfigure, installSkill, UnsupportedAgentError } from "./apply.js";
+export type { InstallSkillOptions, InstallSkillResult } from "./apply.js";

package/packages/agent-skill-config/dist/index.js

@@ -0,0 +1,2 @@
+export { supportedAgents, resolveAgentSupport, getAgentConfig, resolveSkillDir } from "./configs.js";
+export { configure, unconfigure, installSkill, UnsupportedAgentError } from "./apply.js";

package/packages/agent-skill-config/dist/templates/poe-generate.md

@@ -0,0 +1,47 @@
+---
+name: poe-generate
+description: 'Poe code generation skill'
+---
+
+# poe-code generate
+
+Use `poe-code generate` to create text, images, audio, or video via the Poe API.
+
+## Text generation
+
+```bash
+poe-code generate "Write a short function that parses a JSON string safely."
+```
+
+Specify the model/bot:
+
+```bash
+# CLI option
+poe-code generate --model "gpt-4.1" "Summarize this codebase change."
+
+# Some agent runtimes call the model selector `--bot`
+poe-code generate --bot "gpt-4.1" "Summarize this codebase change."
+```
+
+## Media generation
+
+The CLI supports media generation as subcommands:
+
+```bash
+poe-code generate image "A 3D render of a rubber duck wearing sunglasses" --model "gpt-image-1" -o duck.png
+poe-code generate video "A cinematic timelapse of a city at night" --model "veo" -o city.mp4
+poe-code generate audio "A calm 10 second lo-fi beat" --model "audio-model" -o beat.wav
+```
+
+Some agent runtimes expose the same media types as flags. If available, these are equivalent:
+
+```bash
+poe-code generate --image "A 3D render of a rubber duck wearing sunglasses" --bot "gpt-image-1" -o duck.png
+poe-code generate --video "A cinematic timelapse of a city at night" --bot "veo" -o city.mp4
+poe-code generate --audio "A calm 10 second lo-fi beat" --bot "audio-model" -o beat.wav
+```
+
+## Tips
+
+- Use `--param key=value` to pass provider/model parameters (repeatable).
+- Use `--output <path>` (or `-o`) for media outputs.

package/packages/agent-skill-config/dist/templates/terminal-pilot.md

@@ -0,0 +1,45 @@
+---
+name: terminal-pilot
+description: 'Terminal automation skill using the terminal-pilot CLI'
+---
+
+# Terminal Pilot
+
+Use the `terminal-pilot` CLI when you need to automate or inspect interactive
+CLI applications through a real PTY session.
+
+## Commands
+
+- `terminal-pilot create-session` - start a PTY-backed command
+- `terminal-pilot fill` - paste text into a session
+- `terminal-pilot type` - type character-by-character for TUIs and readline
+- `terminal-pilot press-key` - send named keys such as `Enter` or `ArrowDown`
+- `terminal-pilot wait-for` - wait for terminal output to match a pattern
+- `terminal-pilot wait-for-exit` - block until a session exits
+- `terminal-pilot read-screen` - inspect the current visible terminal screen
+- `terminal-pilot read-history` - read scrollback output
+- `terminal-pilot list-sessions` - list active sessions
+- `terminal-pilot close-session` - close a session and return its exit code
+
+## Examples
+
+```bash
+terminal-pilot --help
+terminal-pilot create-session --help
+terminal-pilot read-screen --help
+```
+
+Use JSON output when another tool or script needs to read the result:
+
+```bash
+terminal-pilot list-sessions --output json
+terminal-pilot read-screen --session s1 --output json
+```
+
+## Tips
+
+- Use `fill` for pasted text and multi-line input.
+- Use `type` when the app reacts to individual keystrokes.
+- Use `press-key` for Enter, Tab, arrow keys, Escape, and control-key chords.
+- Use `wait-for --literal` for exact string matching.
+- Default terminal size is 120x40.

package/packages/agent-skill-config/dist/templates.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateLoader } from "../../config-mutations/dist/index.js";
+export declare function loadTemplate(templateId: string): Promise<string>;
+export declare function createTemplateLoader(): TemplateLoader;

package/packages/agent-skill-config/dist/templates.js

@@ -0,0 +1,63 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const TEMPLATE_IDS = ["poe-generate.md", "terminal-pilot.md"];
+const cache = new Map();
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function findPackageRoot(entryFilePath) {
+    let current = path.dirname(entryFilePath);
+    while (true) {
+        if (await pathExists(path.join(current, "package.json"))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error("Unable to locate package root for agent-skill-config templates.");
+        }
+        current = parent;
+    }
+}
+async function resolveTemplatePath(templateId) {
+    const packageRoot = await findPackageRoot(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.join(packageRoot, "src", "templates", templateId),
+        path.join(packageRoot, "dist", "templates", templateId),
+        path.join(packageRoot, "dist", "templates", "skill", templateId)
+    ];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Template not found: ${templateId}`);
+}
+function isKnownTemplate(templateId) {
+    return TEMPLATE_IDS.includes(templateId);
+}
+export async function loadTemplate(templateId) {
+    if (!isKnownTemplate(templateId)) {
+        throw new Error(`Template not found: ${templateId}`);
+    }
+    const cached = cache.get(templateId);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const resolved = await resolveTemplatePath(templateId);
+    const content = await readFile(resolved, "utf8");
+    cache.set(templateId, content);
+    return content;
+}
+export function createTemplateLoader() {
+    return loadTemplate;
+}

package/packages/agent-skill-config/dist/types.d.ts

@@ -0,0 +1,16 @@
+import type { FileSystem, MutationObservers } from "../../config-mutations/dist/index.js";
+import type { SkillScope } from "./configs.js";
+export interface ApplyOptions {
+    fs: FileSystem;
+    homeDir: string;
+    cwd: string;
+    scope?: SkillScope;
+    dryRun?: boolean;
+    observers?: MutationObservers;
+}
+export interface SkillFile {
+    /** Skill folder name */
+    name: string;
+    /** Content to write to SKILL.md */
+    content: string;
+}

package/packages/agent-skill-config/dist/types.js

@@ -0,0 +1 @@
+export {};

package/packages/cmdkit/dist/cli.js

@@ -1276,8 +1276,13 @@ function createOption(field) {
     if (collidesWithGlobalFlag) {
       return [createCommanderOption(flags, field.description, field)];
     }
+    const mainOption = createCommanderOption(`${flags} [value]`, field.description, field);
+    mainOption.preset(true);
+    mainOption.argParser(
+      (value) => typeof value === "boolean" ? value : parseBooleanText(value, field.displayPath)
+    );
     return [
-      createCommanderOption(flags, field.description, field),
+      mainOption,
       createCommanderOption(`--no-${field.optionFlag.slice(2)}`, field.description, field)
     ];
   }
@@ -1395,7 +1400,7 @@ function formatHelpFieldFlags(field) {
     return formatPositionalToken(field);
   }
   if (field.schema.kind === "boolean") {
-    return formatOptionFlags(field);
+    return `${formatOptionFlags(field)} [value]`;
   }
   return `${formatOptionFlags(field)} <${describeSchemaType(field.schema)}>`;
 }