poe-code 3.0.184 → 3.0.186

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

@@ -0,0 +1,175 @@
+import path from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { runMutations, configMutation, fileMutation, readFileIfExists } from "@poe-code/config-mutations";
+import { getAgentConfig, resolveConfigPath, isSupported } from "./configs.js";
+import { getShapeTransformer } from "./shapes.js";
+function getConfigDirectory(configPath) {
+    return path.dirname(configPath);
+}
+export class UnsupportedAgentError extends Error {
+    constructor(agentId) {
+        super(`Unsupported agent: ${agentId}`);
+        this.name = "UnsupportedAgentError";
+    }
+}
+function isConfigObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveServerMap(document, configKey) {
+    const value = document[configKey];
+    return isConfigObject(value) ? value : {};
+}
+function mergeServerMap(document, configKey, servers) {
+    return { ...document, [configKey]: servers };
+}
+function expandHomePath(configPath, homeDir) {
+    if (!configPath.startsWith("~")) {
+        return configPath;
+    }
+    if (configPath === "~") {
+        return homeDir;
+    }
+    if (configPath.startsWith("~/")) {
+        return path.join(homeDir, configPath.slice(2));
+    }
+    return path.join(homeDir, configPath.slice(1));
+}
+function parseYamlDocument(content) {
+    if (content.trim() === "") {
+        return {};
+    }
+    const parsed = parseYaml(content);
+    if (parsed === null || parsed === undefined) {
+        return {};
+    }
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected YAML document to be an object.");
+    }
+    return parsed;
+}
+function serializeYamlDocument(document) {
+    const serialized = stringifyYaml(document);
+    return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+}
+async function readYamlConfig(configPath, options) {
+    const absolutePath = expandHomePath(configPath, options.homeDir);
+    const existingContent = await readFileIfExists(options.fs, absolutePath);
+    if (existingContent === null) {
+        return {};
+    }
+    return parseYamlDocument(existingContent);
+}
+async function writeYamlConfig(configPath, document, options) {
+    if (options.dryRun) {
+        return;
+    }
+    const absolutePath = expandHomePath(configPath, options.homeDir);
+    const configDir = path.dirname(absolutePath);
+    await options.fs.mkdir(configDir, { recursive: true });
+    await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
+        encoding: "utf8"
+    });
+}
+function removeServer(document, configKey, serverName) {
+    const servers = resolveServerMap(document, configKey);
+    if (!(serverName in servers)) {
+        return { changed: false, content: document };
+    }
+    const nextServers = { ...servers };
+    delete nextServers[serverName];
+    if (Object.keys(nextServers).length === 0) {
+        const nextDocument = { ...document };
+        delete nextDocument[configKey];
+        return { changed: true, content: nextDocument };
+    }
+    return {
+        changed: true,
+        content: mergeServerMap(document, configKey, nextServers)
+    };
+}
+export async function configure(agentId, server, options) {
+    if (!isSupported(agentId)) {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const config = getAgentConfig(agentId);
+    const configPath = resolveConfigPath(config, options.platform);
+    const shapeTransformer = getShapeTransformer(config.shape);
+    const shaped = shapeTransformer(server);
+    if (shaped === undefined) {
+        await unconfigure(agentId, server.name, options);
+        return;
+    }
+    if (config.format === "yaml") {
+        const document = await readYamlConfig(configPath, options);
+        const servers = resolveServerMap(document, config.configKey);
+        const nextDocument = mergeServerMap(document, config.configKey, {
+            ...servers,
+            [server.name]: shaped
+        });
+        await writeYamlConfig(configPath, nextDocument, options);
+        return;
+    }
+    const configDir = getConfigDirectory(configPath);
+    await runMutations([
+        fileMutation.ensureDirectory({
+            path: configDir,
+            label: `Ensure directory ${configDir}`
+        }),
+        // Use transform to replace the server entry entirely (not deep-merge)
+        // This ensures old fields like 'args' are removed when switching to array 'command'
+        configMutation.transform({
+            target: configPath,
+            format: config.format,
+            transform: (document) => {
+                const servers = resolveServerMap(document, config.configKey);
+                const newServers = {
+                    ...servers,
+                    [server.name]: shaped
+                };
+                return {
+                    changed: true,
+                    content: mergeServerMap(document, config.configKey, newServers)
+                };
+            },
+            label: `Add ${server.name} to ${configPath}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir: options.homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers
+    });
+}
+export async function unconfigure(agentId, serverName, options) {
+    if (!isSupported(agentId)) {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const config = getAgentConfig(agentId);
+    const configPath = resolveConfigPath(config, options.platform);
+    if (config.format === "yaml") {
+        const document = await readYamlConfig(configPath, options);
+        const { changed, content } = removeServer(document, config.configKey, serverName);
+        if (!changed) {
+            return;
+        }
+        await writeYamlConfig(configPath, content, options);
+        return;
+    }
+    await runMutations([
+        configMutation.prune({
+            target: configPath,
+            format: config.format,
+            shape: {
+                [config.configKey]: {
+                    [serverName]: {}
+                }
+            },
+            label: `Remove ${serverName} from ${configPath}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir: options.homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers
+    });
+}

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

@@ -0,0 +1,22 @@
+import type { ShapeName } from "./shapes.js";
+export type ConfigFormat = "json" | "toml" | "yaml";
+export type Platform = "darwin" | "linux" | "win32";
+export interface AgentMcpConfig {
+    configFile: string | ((platform: Platform) => string);
+    configKey: string;
+    format: ConfigFormat;
+    shape: ShapeName;
+    mcpOutputFormat?: string;
+}
+export declare const supportedAgents: readonly string[];
+export type AgentSupportStatus = "supported" | "unsupported" | "unknown";
+export interface AgentSupportResult {
+    status: AgentSupportStatus;
+    input: string;
+    id?: string;
+    config?: AgentMcpConfig;
+}
+export declare function resolveAgentSupport(input: string, registry?: Record<string, AgentMcpConfig>): AgentSupportResult;
+export declare function isSupported(agentId: string): boolean;
+export declare function getAgentConfig(agentId: string): AgentMcpConfig | undefined;
+export declare function resolveConfigPath(config: AgentMcpConfig, platform: Platform): string;

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";