@botcord/daemon 0.2.88 → 0.2.90

package/dist/runtime-models.js

@@ -54,6 +54,36 @@ const KIMI_FALLBACK_MODELS = [
     { id: "kimi-k2-5-preview", displayName: "kimi-k2-5-preview", provider: "kimi", source: "builtin" },
     { id: "kimi-k2-0711", displayName: "kimi-k2-0711", provider: "kimi", source: "builtin" },
 ];
+// Gemini CLI has no `gemini models list` command — the model set is
+// hard-coded inside the bundle's `VALID_GEMINI_MODELS` (see `@google/gemini-cli`
+// bundle `chunk-BE42OOYM.js:275832`). We mirror the documented user-facing
+// names here as a static catalog; the actual availability depends on the
+// user's auth tier (gcloud ADC / Vertex / GEMINI_API_KEY) and project quota.
+// The `auto` alias is the default — it lets gemini pick the best model.
+const GEMINI_FALLBACK_MODELS = [
+    { id: "auto", displayName: "Auto (let Gemini pick)", provider: "google", source: "builtin", isDefault: true },
+    { id: "pro", displayName: "Pro alias", provider: "google", source: "builtin" },
+    { id: "flash", displayName: "Flash alias", provider: "google", source: "builtin" },
+    { id: "flash-lite", displayName: "Flash Lite alias", provider: "google", source: "builtin" },
+    { id: "gemini-2.5-pro", displayName: "Gemini 2.5 Pro", provider: "google", source: "builtin" },
+    { id: "gemini-2.5-flash", displayName: "Gemini 2.5 Flash", provider: "google", source: "builtin" },
+    { id: "gemini-2.5-flash-lite", displayName: "Gemini 2.5 Flash Lite", provider: "google", source: "builtin" },
+    { id: "gemini-3-pro-preview", displayName: "Gemini 3 Pro (preview)", provider: "google", source: "builtin" },
+    { id: "gemini-3-flash-preview", displayName: "Gemini 3 Flash (preview)", provider: "google", source: "builtin" },
+    { id: "gemini-3.1-pro-preview", displayName: "Gemini 3.1 Pro (preview)", provider: "google", source: "builtin" },
+    {
+        id: "gemini-3.1-pro-preview-customtools",
+        displayName: "Gemini 3.1 Pro Custom Tools (preview)",
+        provider: "google",
+        source: "builtin",
+    },
+    {
+        id: "gemini-3.1-flash-lite-preview",
+        displayName: "Gemini 3.1 Flash Lite (preview)",
+        provider: "google",
+        source: "builtin",
+    },
+];
 const backgroundRefreshes = new Set();
 export function discoverRuntimeModelCatalog(entry) {
     if (!entry.result.available)
@@ -126,6 +156,22 @@ function runtimeCatalogStrategy(entry) {
                     ],
                 }),
             };
+        case "gemini":
+            // Gemini CLI exposes no runtime discovery command and its thinking
+            // budget / level (see bundle `ThinkingLevel`, `thinkingBudget`) is
+            // configured per-installation in `~/.gemini/settings.json`, not via
+            // any CLI flag — so we ship a static model catalog with no parameter
+            // controls. settings.json + BOTCORD_GEMINI_BIN feed the cache key so
+            // user-side reconfig (e.g. switching auth type) busts the cache.
+            return {
+                id: entry.id,
+                contextKey: runtimeCatalogContextKey(entry, {
+                    settings: fileStatKey(path.join(homedir(), ".gemini", "settings.json")),
+                    env: pickEnv(["BOTCORD_GEMINI_BIN", "GEMINI_CLI_HOME"]),
+                }),
+                discoverFresh: () => ({ models: GEMINI_FALLBACK_MODELS.slice() }),
+                fallback: () => ({ models: GEMINI_FALLBACK_MODELS.slice() }),
+            };
         default:
             return null;
     }

package/dist/skill-index.d.ts

@@ -2,29 +2,41 @@ export interface SoftSkillEntry {
     name: string;
     path: string;
     source: string;
+    runtime?: string;
+    profile?: string;
     description?: string;
     mtimeMs: number;
 }
 export interface AgentSkillSnapshotEntry {
     name: string;
     source: string;
+    sourceDetail?: string;
+    runtime?: string;
+    path?: string;
+    profile?: string;
     description?: string;
     mtimeMs: number;
 }
 export interface AgentSkillSnapshot {
     agentId: string;
+    runtime?: string;
     skills: AgentSkillSnapshotEntry[];
     probedAt: number;
 }
 export interface SkillIndexOptions {
     extraDirs?: string[];
+    hermesProfile?: string;
     includeGlobal?: boolean;
     runtime?: string;
 }
-export declare function defaultSkillDirs(agentId: string, opts?: SkillIndexOptions): Array<{
+interface SkillRoot {
     dir: string;
     source: string;
-}>;
+    runtime?: string;
+    profile?: string;
+}
+export declare function defaultSkillDirs(agentId: string, opts?: SkillIndexOptions): SkillRoot[];
 export declare function scanSoftSkills(agentId: string, opts?: SkillIndexOptions): SoftSkillEntry[];
 export declare function collectAgentSkillSnapshot(agentId: string, opts?: SkillIndexOptions): AgentSkillSnapshot;
 export declare function buildSoftSkillIndexPrompt(agentId: string, opts?: SkillIndexOptions): string | null;
+export {};

package/dist/skill-index.js

@@ -1,7 +1,8 @@
 import { existsSync, readdirSync, readFileSync, statSync, } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
-import { agentCodexHomeDir, agentWorkspaceDir, } from "./agent-workspace.js";
+import { agentCodexHomeDir, agentHermesHomeDir, agentWorkspaceDir, } from "./agent-workspace.js";
+import { hermesProfileHomeDir } from "./gateway/runtimes/hermes-agent.js";
 const MAX_SKILLS = 24;
 const MAX_DESCRIPTION_CHARS = 260;
 const MAX_SKILL_MD_READ_CHARS = 8192;
@@ -10,24 +11,50 @@ export function defaultSkillDirs(agentId, opts = {}) {
     const agentClaude = {
         dir: path.join(agentWorkspaceDir(agentId), ".claude", "skills"),
         source: "agent-claude",
+        runtime: "claude-code",
     };
     const agentCodex = {
         dir: path.join(agentCodexHomeDir(agentId), "skills"),
         source: "agent-codex",
+        runtime: "codex",
     };
-    const dirs = runtimeFamily(opts.runtime) === "codex"
-        ? [agentCodex, agentClaude]
-        : [agentClaude, agentCodex];
-    if (includeGlobal) {
-        const globalClaude = { dir: path.join(homedir(), ".claude", "skills"), source: "global-claude" };
-        const globalCodex = { dir: path.join(homedir(), ".codex", "skills"), source: "global-codex" };
-        dirs.push(...(runtimeFamily(opts.runtime) === "codex"
-            ? [globalCodex, globalClaude]
-            : [globalClaude, globalCodex]));
+    const agentHermes = hermesSkillRoot(agentId, opts.hermesProfile);
+    const dirs = [];
+    switch (runtimeFamily(opts.runtime)) {
+        case "codex":
+            dirs.push(agentCodex);
+            if (includeGlobal) {
+                dirs.push({
+                    dir: path.join(homedir(), ".codex", "skills"),
+                    source: "global-codex",
+                    runtime: "codex",
+                });
+            }
+            break;
+        case "hermes":
+            dirs.push(agentHermes);
+            break;
+        case "claude":
+            dirs.push(agentClaude);
+            if (includeGlobal) {
+                dirs.push({
+                    dir: path.join(homedir(), ".claude", "skills"),
+                    source: "global-claude",
+                    runtime: "claude-code",
+                });
+            }
+            break;
+        case "other":
+            break;
     }
     const envDirs = parseSkillDirsEnv(process.env.BOTCORD_SKILL_DIRS);
     for (const dir of [...envDirs, ...(opts.extraDirs ?? [])]) {
-        dirs.push({ dir, source: "external" });
+        dirs.push({
+            dir,
+            source: "external",
+            ...(opts.runtime ? { runtime: opts.runtime } : {}),
+            ...(opts.hermesProfile ? { profile: opts.hermesProfile } : {}),
+        });
     }
     return dedupeDirs(expandSkillRoots(dirs));
 }
@@ -65,6 +92,8 @@ export function scanSoftSkills(agentId, opts = {}) {
                 name: parsed.name,
                 path: skillMd,
                 source: root.source,
+                ...(root.runtime ? { runtime: root.runtime } : {}),
+                ...(root.profile ? { profile: root.profile } : {}),
                 description: parsed.description,
                 mtimeMs: st.mtimeMs,
             };
@@ -79,9 +108,14 @@ export function scanSoftSkills(agentId, opts = {}) {
 export function collectAgentSkillSnapshot(agentId, opts = {}) {
     return {
         agentId,
+        ...(opts.runtime ? { runtime: opts.runtime } : {}),
         skills: scanSoftSkills(agentId, opts).map((skill) => ({
             name: skill.name,
-            source: skill.source.startsWith("agent-") ? "workspace" : "runtime-global",
+            source: snapshotSource(skill.source),
+            sourceDetail: skill.source,
+            ...(skill.runtime ? { runtime: skill.runtime } : {}),
+            path: skill.path,
+            ...(skill.profile ? { profile: skill.profile } : {}),
             ...(skill.description ? { description: skill.description } : {}),
             mtimeMs: skill.mtimeMs,
         })),
@@ -157,7 +191,7 @@ function dedupeDirs(dirs) {
         if (seen.has(resolved))
             continue;
         seen.add(resolved);
-        out.push({ dir: resolved, source: entry.source });
+        out.push({ ...entry, dir: resolved });
     }
     return out;
 }
@@ -166,46 +200,59 @@ function expandSkillRoots(dirs) {
     for (const entry of dirs) {
         out.push(entry);
         if (entry.source.includes("codex")) {
-            out.push({ dir: path.join(entry.dir, ".system"), source: entry.source });
+            out.push({ ...entry, dir: path.join(entry.dir, ".system") });
         }
     }
     return out;
 }
+function hermesSkillRoot(agentId, profile) {
+    if (profile) {
+        try {
+            return {
+                dir: path.join(hermesProfileHomeDir(profile), "skills"),
+                source: "agent-hermes-profile",
+                runtime: "hermes-agent",
+                profile,
+            };
+        }
+        catch {
+            // Corrupt legacy credentials should not make the whole skill snapshot fail.
+        }
+    }
+    return {
+        dir: path.join(agentHermesHomeDir(agentId), "skills"),
+        source: "agent-hermes",
+        runtime: "hermes-agent",
+    };
+}
 function runtimeFamily(runtime) {
     if (runtime === "codex")
         return "codex";
+    if (runtime === "hermes-agent")
+        return "hermes";
+    if (!runtime)
+        return "claude";
     if (runtime === "claude-code")
         return "claude";
     return "other";
 }
-function priority(source, runtime) {
-    if (runtimeFamily(runtime) === "codex") {
-        switch (source) {
-            case "agent-codex":
-                return 0;
-            case "global-codex":
-                return 1;
-            case "agent-claude":
-                return 2;
-            case "global-claude":
-                return 3;
-            default:
-                return 4;
-        }
-    }
+function priority(source, _runtime) {
     switch (source) {
         case "agent-claude":
-            return 0;
         case "agent-codex":
-            return 1;
+        case "agent-hermes":
+        case "agent-hermes-profile":
+            return 0;
         case "global-claude":
-            return 2;
         case "global-codex":
-            return 3;
+            return 1;
         default:
-            return 4;
+            return 2;
     }
 }
+function snapshotSource(source) {
+    return source.startsWith("agent-") ? "workspace" : "runtime-global";
+}
 function unquote(value) {
     const trimmed = value.trim();
     if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||

package/dist/skill-installer.d.ts

@@ -0,0 +1,61 @@
+import { type ExecFileOptions } from "node:child_process";
+import { type AgentSkillSnapshot } from "./skill-index.js";
+export type SkillInstallTarget = "claude-code" | "codex";
+export interface SkillFileManifest {
+    path: string;
+    content?: string;
+    sourcePath?: string;
+}
+export interface SkillManifestInput {
+    name?: string;
+    id?: string;
+    description?: string;
+    skillMd?: string;
+    markdown?: string;
+    files?: SkillFileManifest[];
+    targetRuntimes?: SkillInstallTarget[];
+}
+export interface SkillArchiveManifestInput {
+    name?: string;
+    id?: string;
+    description?: string;
+    skillMd?: string;
+    markdown?: string;
+    files?: SkillFileManifest[];
+    skills?: SkillManifestInput[];
+    targetRuntimes?: SkillInstallTarget[];
+}
+export interface NormalizedSkillManifest {
+    name: string;
+    description?: string;
+    skillMd: string;
+    files: SkillFileManifest[];
+    targetRuntimes?: SkillInstallTarget[];
+}
+export interface InstalledSkillRecord {
+    name: string;
+    targets: SkillInstallTarget[];
+    paths: string[];
+}
+export interface AgentSkillInstallResult {
+    agentId: string;
+    installed: InstalledSkillRecord[];
+    snapshot: AgentSkillSnapshot;
+}
+export interface InstallAgentSkillManifestOptions {
+    runtime?: string;
+    sourceRoot?: string;
+}
+export interface VercelSkillsInstallOptions {
+    agentId: string;
+    packageSpec: string;
+    skills?: string[];
+    runtime?: string;
+    executor?: VercelSkillsExecutor;
+}
+export type VercelSkillsExecutor = (command: string, args: string[], options: ExecFileOptions) => Promise<void>;
+export declare function normalizeSkillManifest(input: SkillManifestInput): NormalizedSkillManifest;
+export declare function installAgentSkillManifest(agentId: string, manifest: SkillManifestInput, opts?: InstallAgentSkillManifestOptions): AgentSkillInstallResult;
+export declare function installBotLearnArchiveManifest(agentId: string, archive: SkillArchiveManifestInput, opts?: InstallAgentSkillManifestOptions): AgentSkillInstallResult;
+export declare function installVercelSkillsForAgent(opts: VercelSkillsInstallOptions): Promise<AgentSkillInstallResult>;
+export declare function buildVercelSkillsArgs(packageSpec: string, skills: string[] | undefined, targets: SkillInstallTarget[]): string[];

package/dist/skill-installer.js

@@ -0,0 +1,340 @@
+import { execFile } from "node:child_process";
+import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { agentCodexHomeDir, agentWorkspaceDir, } from "./agent-workspace.js";
+import { collectAgentSkillSnapshot, } from "./skill-index.js";
+const execFileAsync = promisify(execFile);
+const SAFE_SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+const MAX_INLINE_FILE_BYTES = 256 * 1024;
+const TRUSTED_VERCEL_PACKAGE_SPECS = new Set([
+    "https://github.com/vercel-labs/skills",
+    "github:vercel-labs/skills",
+    "vercel-labs/skills",
+]);
+export function normalizeSkillManifest(input) {
+    const rawName = input.name ?? input.id;
+    if (!rawName)
+        throw new Error("skill manifest requires name or id");
+    const name = assertSafeSkillName(rawName);
+    const description = sanitizeInline(input.description ?? "");
+    const skillMd = input.skillMd ?? input.markdown ?? renderSkillMarkdown(name, description);
+    if (!skillMd.trim())
+        throw new Error(`skill ${name} has empty SKILL.md content`);
+    return {
+        name,
+        ...(description ? { description } : {}),
+        skillMd,
+        files: input.files ?? [],
+        ...(input.targetRuntimes ? { targetRuntimes: normalizeTargets(input.targetRuntimes) } : {}),
+    };
+}
+export function installAgentSkillManifest(agentId, manifest, opts = {}) {
+    const normalized = normalizeSkillManifest(manifest);
+    const installed = [
+        installNormalizedSkill(agentId, normalized, opts),
+    ];
+    return {
+        agentId,
+        installed,
+        snapshot: collectAgentSkillSnapshot(agentId, { runtime: opts.runtime }),
+    };
+}
+export function installBotLearnArchiveManifest(agentId, archive, opts = {}) {
+    const skills = archive.skills && archive.skills.length > 0
+        ? archive.skills
+        : [archive];
+    const installed = skills.map((skill) => installNormalizedSkill(agentId, normalizeSkillManifest({
+        ...skill,
+        targetRuntimes: skill.targetRuntimes ?? archive.targetRuntimes,
+    }), opts));
+    return {
+        agentId,
+        installed,
+        snapshot: collectAgentSkillSnapshot(agentId, { runtime: opts.runtime }),
+    };
+}
+export async function installVercelSkillsForAgent(opts) {
+    const packageSpec = normalizeTrustedVercelPackageSpec(opts.packageSpec);
+    const workspace = agentWorkspaceDir(opts.agentId);
+    const tempHome = mkdtempSync(path.join(tmpdir(), "botcord-skills-"));
+    const targets = targetsForRuntime(opts.runtime);
+    const executor = opts.executor ?? defaultVercelSkillsExecutor;
+    const args = buildVercelSkillsArgs(packageSpec, opts.skills, targets);
+    try {
+        await executor("npx", args, {
+            cwd: workspace,
+            env: {
+                ...process.env,
+                HOME: tempHome,
+                USERPROFILE: tempHome,
+            },
+        });
+        const installed = importVercelInstalledSkills(opts.agentId, tempHome, targets);
+        return {
+            agentId: opts.agentId,
+            installed,
+            snapshot: collectAgentSkillSnapshot(opts.agentId, { runtime: opts.runtime }),
+        };
+    }
+    finally {
+        rmSync(tempHome, { recursive: true, force: true });
+    }
+}
+export function buildVercelSkillsArgs(packageSpec, skills, targets) {
+    const normalizedPackageSpec = normalizeTrustedVercelPackageSpec(packageSpec);
+    const args = ["--yes", "skills", "add", normalizedPackageSpec, "--global", "--copy", "--yes"];
+    for (const skill of skills ?? []) {
+        if (!skill.trim())
+            continue;
+        args.push("--skill", skill);
+    }
+    for (const target of targets) {
+        args.push("--agent", target === "codex" ? "codex" : "claude-code");
+    }
+    return args;
+}
+function installNormalizedSkill(agentId, manifest, opts) {
+    const targets = manifest.targetRuntimes ?? targetsForRuntime(opts.runtime);
+    validateSkillFiles(manifest.files, opts.sourceRoot);
+    const paths = [];
+    for (const target of targets) {
+        const skillDir = path.join(skillRootForTarget(agentId, target), manifest.name);
+        writeSkillDir(skillDir, manifest, opts.sourceRoot);
+        paths.push(skillDir);
+    }
+    return { name: manifest.name, targets, paths };
+}
+function writeSkillDir(skillDir, manifest, sourceRoot) {
+    const parent = path.dirname(skillDir);
+    mkdirSync(parent, { recursive: true, mode: 0o700 });
+    const tempDir = mkdtempSync(path.join(parent, `.${path.basename(skillDir)}-tmp-`));
+    try {
+        writeFileSync(path.join(tempDir, "SKILL.md"), manifest.skillMd, { mode: 0o600 });
+        for (const file of manifest.files) {
+            const relativePath = assertSafeRelativePath(file.path);
+            const dest = path.join(tempDir, relativePath);
+            mkdirSync(path.dirname(dest), { recursive: true, mode: 0o700 });
+            if (file.content !== undefined) {
+                writeFileSync(dest, file.content, { mode: 0o600 });
+                continue;
+            }
+            copySafeSourcePath(sourceRoot, file.sourcePath, dest);
+        }
+        rmSync(skillDir, { recursive: true, force: true });
+        renameSync(tempDir, skillDir);
+    }
+    catch (err) {
+        rmSync(tempDir, { recursive: true, force: true });
+        throw err;
+    }
+}
+function importVercelInstalledSkills(agentId, tempHome, targets) {
+    const byName = new Map();
+    for (const target of targets) {
+        const sourceRoot = target === "codex"
+            ? path.join(tempHome, ".codex", "skills")
+            : path.join(tempHome, ".claude", "skills");
+        if (!existsSync(sourceRoot))
+            continue;
+        for (const sourceSkillDir of findSkillDirs(sourceRoot)) {
+            const name = assertSafeSkillName(readSkillName(sourceSkillDir));
+            const dest = path.join(skillRootForTarget(agentId, target), name);
+            copySafeSkillDir(sourceSkillDir, dest);
+            const existing = byName.get(name);
+            if (existing) {
+                existing.targets.push(target);
+                existing.paths.push(dest);
+            }
+            else {
+                byName.set(name, { name, targets: [target], paths: [dest] });
+            }
+        }
+    }
+    return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function findSkillDirs(root) {
+    const out = [];
+    const visit = (dir, depth) => {
+        if (depth > 3)
+            return;
+        const skillMd = path.join(dir, "SKILL.md");
+        if (existsSync(skillMd) && lstatSync(skillMd).isFile()) {
+            out.push(dir);
+            return;
+        }
+        let children;
+        try {
+            children = readdirSync(dir).sort((a, b) => a.localeCompare(b));
+        }
+        catch {
+            return;
+        }
+        for (const child of children) {
+            const childPath = path.join(dir, child);
+            try {
+                const childStat = lstatSync(childPath);
+                if (childStat.isSymbolicLink())
+                    continue;
+                if (childStat.isDirectory())
+                    visit(childPath, depth + 1);
+            }
+            catch {
+                /* skip unreadable entries */
+            }
+        }
+    };
+    visit(root, 0);
+    return out;
+}
+function readSkillName(skillDir) {
+    const fallback = path.basename(skillDir);
+    let raw = "";
+    try {
+        raw = readFileSync(path.join(skillDir, "SKILL.md"), "utf8").slice(0, 8192);
+    }
+    catch {
+        return fallback;
+    }
+    const fm = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const name = fm?.[1]?.match(/^name:\s*(.+?)\s*$/m)?.[1];
+    return name ? unquote(name).trim() : fallback;
+}
+function targetsForRuntime(runtime) {
+    if (runtime === "codex")
+        return ["codex"];
+    if (runtime === "claude-code")
+        return ["claude-code"];
+    return ["claude-code", "codex"];
+}
+function normalizeTargets(targets) {
+    const out = [];
+    for (const target of targets) {
+        if (target !== "claude-code" && target !== "codex") {
+            throw new Error(`unsupported skill target: ${String(target)}`);
+        }
+        if (!out.includes(target))
+            out.push(target);
+    }
+    if (out.length === 0)
+        throw new Error("at least one target runtime is required");
+    return out;
+}
+function normalizeTrustedVercelPackageSpec(packageSpec) {
+    const cleaned = packageSpec.trim();
+    if (!cleaned)
+        throw new Error("packageSpec is required");
+    if (!TRUSTED_VERCEL_PACKAGE_SPECS.has(cleaned)) {
+        throw new Error(`unsupported vercel skills packageSpec: ${cleaned}`);
+    }
+    return cleaned;
+}
+function validateSkillFiles(files, sourceRoot) {
+    for (const file of files) {
+        assertSafeRelativePath(file.path);
+        if (file.content !== undefined) {
+            if (Buffer.byteLength(file.content, "utf8") > MAX_INLINE_FILE_BYTES) {
+                throw new Error(`skill file too large: ${file.path}`);
+            }
+            continue;
+        }
+        if (!sourceRoot || !file.sourcePath) {
+            throw new Error(`skill file ${file.path} requires content or sourcePath with sourceRoot`);
+        }
+        resolveSafeSourcePath(sourceRoot, file.sourcePath);
+    }
+}
+function resolveSafeSourcePath(sourceRoot, relativeSourcePath) {
+    const safeRelativePath = assertSafeRelativePath(relativeSourcePath);
+    const rootReal = realpathSync(sourceRoot);
+    const sourcePath = path.resolve(sourceRoot, safeRelativePath);
+    if (lstatSync(sourcePath).isSymbolicLink()) {
+        throw new Error(`unsafe source path symlink: ${relativeSourcePath}`);
+    }
+    const sourceReal = realpathSync(sourcePath);
+    if (sourceReal !== rootReal && !sourceReal.startsWith(`${rootReal}${path.sep}`)) {
+        throw new Error(`unsafe source path: ${relativeSourcePath}`);
+    }
+    return sourceReal;
+}
+function copySafeSourcePath(sourceRoot, relativeSourcePath, dest) {
+    const source = resolveSafeSourcePath(sourceRoot, relativeSourcePath);
+    copyNoSymlinks(source, dest);
+}
+function copySafeSkillDir(sourceSkillDir, dest) {
+    const parent = path.dirname(dest);
+    mkdirSync(parent, { recursive: true, mode: 0o700 });
+    const tempDir = mkdtempSync(path.join(parent, `.${path.basename(dest)}-tmp-`));
+    try {
+        copyNoSymlinks(sourceSkillDir, tempDir);
+        rmSync(dest, { recursive: true, force: true });
+        renameSync(tempDir, dest);
+    }
+    catch (err) {
+        rmSync(tempDir, { recursive: true, force: true });
+        throw err;
+    }
+}
+function copyNoSymlinks(source, dest) {
+    const sourceStat = lstatSync(source);
+    if (sourceStat.isSymbolicLink()) {
+        throw new Error(`skill import rejects symlink: ${source}`);
+    }
+    if (sourceStat.isDirectory()) {
+        mkdirSync(dest, { recursive: true, mode: 0o700 });
+        for (const child of readdirSync(source)) {
+            copyNoSymlinks(path.join(source, child), path.join(dest, child));
+        }
+        return;
+    }
+    if (!sourceStat.isFile()) {
+        throw new Error(`skill import supports only files and directories: ${source}`);
+    }
+    cpSync(source, dest, { force: true, dereference: false });
+}
+function skillRootForTarget(agentId, target) {
+    return target === "codex"
+        ? path.join(agentCodexHomeDir(agentId), "skills")
+        : path.join(agentWorkspaceDir(agentId), ".claude", "skills");
+}
+function assertSafeSkillName(value) {
+    const name = value.trim();
+    if (!SAFE_SKILL_NAME.test(name) || name === "." || name === "..") {
+        throw new Error(`unsafe skill name: ${JSON.stringify(value)}`);
+    }
+    return name;
+}
+function assertSafeRelativePath(value) {
+    const normalized = path.normalize(value);
+    if (!value ||
+        path.isAbsolute(value) ||
+        normalized === "." ||
+        normalized.startsWith("..") ||
+        normalized.split(path.sep).includes("..")) {
+        throw new Error(`unsafe skill file path: ${JSON.stringify(value)}`);
+    }
+    return normalized;
+}
+function renderSkillMarkdown(name, description) {
+    const desc = description ? `description: "${description.replace(/"/g, '\\"')}"\n` : "";
+    return `---\nname: ${name}\n${desc}---\n\n# ${name}\n`;
+}
+function sanitizeInline(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+async function defaultVercelSkillsExecutor(command, args, options) {
+    await execFileAsync(command, args, {
+        ...options,
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+    });
+}