invokora 0.1.0

package/dist/cli/prompts.js

@@ -0,0 +1,175 @@
+import { createInterface } from 'node:readline';
+import { cancel as clackCancel, confirm as clackConfirm, isCancel, multiselect, select } from '@clack/prompts';
+import { DEFAULT_MCP_TARGET_INPUT, DEFAULT_SYNC_TARGET_INPUT, MCP_TARGET_ALIASES, MCP_TARGET_PICKER_OPTIONS, SYNC_TARGET_ALIASES, } from './constants.js';
+export class CliPrompts {
+    async line(question) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+    }
+    async yesNo(question, defaultValue) {
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+            const result = await clackConfirm({
+                message: question,
+                initialValue: defaultValue,
+            });
+            if (isCancel(result)) {
+                clackCancel('Operation cancelled.');
+                throw new Error('Cancelled');
+            }
+            return result;
+        }
+        const suffix = defaultValue ? ' [Y/n]: ' : ' [y/N]: ';
+        const answer = (await this.line(`${question}${suffix}`)).toLowerCase();
+        if (!answer)
+            return defaultValue;
+        if (answer === 'y' || answer === 'yes')
+            return true;
+        if (answer === 'n' || answer === 'no')
+            return false;
+        return defaultValue;
+    }
+    async pickMcpTargets() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            return this.defaultMcpTargets();
+        }
+        const result = await multiselect({
+            message: 'Choose where to install the MCP server config.',
+            options: MCP_TARGET_PICKER_OPTIONS.map((option) => ({
+                value: option.target,
+                label: option.label,
+                hint: `${option.summary} · ${option.path}`,
+            })),
+            initialValues: MCP_TARGET_PICKER_OPTIONS.map((option) => option.target),
+            required: true,
+        });
+        if (isCancel(result)) {
+            clackCancel('Operation cancelled.');
+            throw new Error('Cancelled');
+        }
+        return this.uniqueTargets(result);
+    }
+    async pickSyncScope() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            return 'project';
+        }
+        const result = await select({
+            message: 'Where should Invokora sync these local skills?',
+            options: [
+                {
+                    value: 'project',
+                    label: 'Project',
+                    hint: 'Only this repository/workspace',
+                },
+                {
+                    value: 'user',
+                    label: 'User',
+                    hint: 'Available across your machine',
+                },
+            ],
+            initialValue: 'project',
+        });
+        if (isCancel(result)) {
+            clackCancel('Operation cancelled.');
+            throw new Error('Cancelled');
+        }
+        return result;
+    }
+    async pickSyncTargets(scope) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            return this.defaultSyncTargets();
+        }
+        const options = [
+            {
+                value: 'codex',
+                label: 'Codex',
+                hint: scope === 'user' ? '~/.codex/skills' : '.agents/skills',
+            },
+            {
+                value: 'claude',
+                label: 'Claude Code',
+                hint: scope === 'user' ? '~/.claude/skills' : '.claude/skills',
+            },
+            {
+                value: 'cursor',
+                label: 'Cursor',
+                hint: scope === 'user' ? '~/.cursor/skills' : '.cursor/skills',
+            },
+        ];
+        const result = await multiselect({
+            message: 'Choose which client(s) should receive the synced skills.',
+            options,
+            initialValues: ['codex', 'claude', 'cursor'],
+            required: true,
+        });
+        if (isCancel(result)) {
+            clackCancel('Operation cancelled.');
+            throw new Error('Cancelled');
+        }
+        return this.uniqueTargets(result);
+    }
+    async pickSyncableSkills(skills) {
+        return this.pickMany('Choose which Skill(s) to add or refresh locally.', skills);
+    }
+    async pickSyncableSkillAddMode() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            return 'all';
+        }
+        const result = await select({
+            message: 'How should Invokora add local Skills?',
+            options: [
+                { value: 'all', label: 'All syncable Skills', hint: 'Add or refresh every Skill in the list' },
+                { value: 'custom', label: 'Choose Skills', hint: 'Select individual Skills from the list' },
+                { value: 'none', label: 'No Skills', hint: 'Leave local Skills unchanged' },
+            ],
+            initialValue: 'custom',
+        });
+        if (isCancel(result)) {
+            clackCancel('Operation cancelled.');
+            throw new Error('Cancelled');
+        }
+        return result;
+    }
+    async pickSyncableWorkflows(workflows) {
+        return this.pickMany('Choose which Workflow(s) to add or refresh locally.', workflows);
+    }
+    async pickLocalManagedSkills(skills) {
+        return this.pickMany('Choose which local Skill(s) to remove.', skills);
+    }
+    async pickMany(message, choices) {
+        if (choices.length === 0) {
+            return [];
+        }
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            return choices.map((choice) => choice.value);
+        }
+        const result = await multiselect({
+            message,
+            options: choices,
+            initialValues: choices.map((choice) => choice.value),
+            required: true,
+        });
+        if (isCancel(result)) {
+            clackCancel('Operation cancelled.');
+            throw new Error('Cancelled');
+        }
+        return this.uniqueTargets(result);
+    }
+    defaultMcpTargets() {
+        return this.uniqueTargets(DEFAULT_MCP_TARGET_INPUT.split(',')
+            .map((item) => MCP_TARGET_ALIASES[item])
+            .filter((item) => Boolean(item)));
+    }
+    defaultSyncTargets() {
+        return this.uniqueTargets(DEFAULT_SYNC_TARGET_INPUT.split(',')
+            .map((item) => SYNC_TARGET_ALIASES[item])
+            .filter((item) => Boolean(item)));
+    }
+    uniqueTargets(targets) {
+        return [...new Set(targets)];
+    }
+}

package/dist/cli/release.d.ts

@@ -0,0 +1,3 @@
+export declare const RELEASE_CHANNEL = "prod";
+export declare const RELEASE_VERSION = "0.1.0";
+export declare const DEFAULT_BACKEND_URL = "https://useskilz.com";

package/dist/cli/release.js

@@ -0,0 +1,3 @@
+export const RELEASE_CHANNEL = "prod";
+export const RELEASE_VERSION = "0.1.0";
+export const DEFAULT_BACKEND_URL = "https://useskilz.com";

package/dist/cli/skills.d.ts

@@ -0,0 +1,43 @@
+import type { AccessibleSkill, Config, LocalSkillRemovalResult, LocalManagedSkill, SkillSummary, SyncDestination, SyncOptions, SyncResult, SyncScope, SyncTarget, EntitlementSummary, WorkflowDetailSummary, WorkflowSummary, SyncableSkillContent } from './types.js';
+type SyncedSkillContentMap = Map<string, SyncableSkillContent>;
+export declare class InvokoraApiClient {
+    private readonly config;
+    private readonly fetchImpl;
+    constructor(config: Config, fetchImpl?: typeof fetch);
+    listSyncableDetails(): Promise<AccessibleSkill[]>;
+    getSyncableSkillContent(skillID: string): Promise<SyncableSkillContent>;
+    listEntitlements(): Promise<EntitlementSummary[]>;
+    getWorkflowDetail(workflowID: string): Promise<WorkflowDetailSummary>;
+    listPersonalWorkflows(): Promise<WorkflowSummary[]>;
+    getPersonalWorkflowDetail(workflowID: string): Promise<WorkflowDetailSummary>;
+    private request;
+}
+export declare class SkillShellManager {
+    private readonly baseDir;
+    constructor(baseDir?: string);
+    resolveSyncDestination(target: SyncTarget, scope: SyncScope): SyncDestination;
+    slugifySkillName(name: string): string;
+    resolveSkillShellPath(skillName: string): {
+        slug: string;
+        outDir: string;
+        outPath: string;
+    };
+    generateShellContent(skill: SkillSummary, slug: string, commandSlug?: string): string;
+    sync(skills: SkillSummary[], options: SyncOptions, syncedContentBySkill?: SyncedSkillContentMap): SyncResult;
+    private planSkillWrites;
+    private baseSkillSlug;
+    private uniqueDerivedSlug;
+    private localWritePriority;
+    listManagedSkills(rootDir: string): LocalManagedSkill[];
+    removeManagedSkills(rootDir: string, slugs?: string[]): LocalSkillRemovalResult;
+    private writeManagedMetadata;
+    private writeBundleFiles;
+    private resolveSafeBundlePath;
+    private buildManagedSkillWrite;
+    private isMarketplaceManagedSkill;
+    private managedContentKind;
+    private shouldEnsureLocalManagedFrontmatter;
+    private readManagedMetadata;
+    private hasMarketplaceShellMarker;
+}
+export {};

package/dist/cli/skills.js

@@ -0,0 +1,443 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { API_V1, SKILL_SHELL_MARKER } from './constants.js';
+import { errorMessageFromJson, readJsonResponse } from './http.js';
+const MANAGED_SKILL_META_FILE = '.skilz-managed.json';
+function quoteYamlSingleLineString(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function unquoteYamlSingleLineString(value) {
+    if (value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1).replace(/''/g, "'");
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    return value;
+}
+function quoteSkillFrontmatterDescription(content) {
+    const lines = content.split('\n');
+    if (lines[0]?.trim() !== '---') {
+        return content;
+    }
+    for (let i = 1; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed === '---') {
+            break;
+        }
+        if (!trimmed.startsWith('description:')) {
+            continue;
+        }
+        const value = trimmed.slice('description:'.length).trim();
+        if (value.startsWith('|') || value.startsWith('>')) {
+            return content;
+        }
+        const unquotedValue = unquoteYamlSingleLineString(value);
+        const indent = lines[i].slice(0, lines[i].indexOf('description:'));
+        lines[i] = `${indent}description: ${quoteYamlSingleLineString(unquotedValue)}`;
+        return lines.join('\n');
+    }
+    return content;
+}
+function ensureLocalManagedSkillFrontmatter(content, skill, slug) {
+    const description = skill.description || skill.name;
+    const lines = content.split('\n');
+    if (lines[0]?.trim() !== '---') {
+        return `---
+name: ${slug}
+description: ${quoteYamlSingleLineString(description)}
+---
+
+${content}`;
+    }
+    const frontmatterEndIndex = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+    if (frontmatterEndIndex === -1) {
+        return `---
+name: ${slug}
+description: ${quoteYamlSingleLineString(description)}
+---
+
+${content}`;
+    }
+    let nameIndex = -1;
+    let descriptionIndex = -1;
+    for (let i = 1; i < frontmatterEndIndex; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('name:')) {
+            nameIndex = i;
+        }
+        else if (trimmed.startsWith('description:')) {
+            descriptionIndex = i;
+        }
+    }
+    if (nameIndex === -1) {
+        lines.splice(1, 0, `name: ${slug}`);
+        if (descriptionIndex !== -1) {
+            descriptionIndex++;
+        }
+    }
+    else {
+        const value = lines[nameIndex].trim().slice('name:'.length).trim();
+        if (!value) {
+            const indent = lines[nameIndex].slice(0, lines[nameIndex].indexOf('name:'));
+            lines[nameIndex] = `${indent}name: ${slug}`;
+        }
+    }
+    const updatedFrontmatterEndIndex = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+    if (descriptionIndex === -1) {
+        lines.splice(updatedFrontmatterEndIndex, 0, `description: ${quoteYamlSingleLineString(description)}`);
+    }
+    else {
+        const value = lines[descriptionIndex].trim().slice('description:'.length).trim();
+        if (!value.startsWith('|') && !value.startsWith('>')) {
+            const unquotedValue = unquoteYamlSingleLineString(value) || description;
+            const indent = lines[descriptionIndex].slice(0, lines[descriptionIndex].indexOf('description:'));
+            lines[descriptionIndex] = `${indent}description: ${quoteYamlSingleLineString(unquotedValue)}`;
+        }
+    }
+    return lines.join('\n');
+}
+export class InvokoraApiClient {
+    config;
+    fetchImpl;
+    constructor(config, fetchImpl = fetch) {
+        this.config = config;
+        this.fetchImpl = fetchImpl;
+    }
+    async listSyncableDetails() {
+        const data = await this.request('GET', `${API_V1}/access/syncable`);
+        return data.skills ?? [];
+    }
+    async getSyncableSkillContent(skillID) {
+        return this.request('GET', `${API_V1}/access/syncable/${encodeURIComponent(skillID)}/content`);
+    }
+    async listEntitlements() {
+        const data = await this.request('GET', `${API_V1}/me/entitlements`);
+        return data.entitlements ?? [];
+    }
+    async getWorkflowDetail(workflowID) {
+        return this.request('GET', `${API_V1}/workflows/${encodeURIComponent(workflowID)}/detail`);
+    }
+    async listPersonalWorkflows() {
+        const data = await this.request('GET', `${API_V1}/personal-workflows`);
+        return data.workflows ?? [];
+    }
+    async getPersonalWorkflowDetail(workflowID) {
+        return this.request('GET', `${API_V1}/personal-workflows/${encodeURIComponent(workflowID)}`);
+    }
+    async request(method, path, body) {
+        const url = new URL(path, this.config.backend_url);
+        const response = await this.fetchImpl(url, {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.config.token}`,
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const json = await readJsonResponse(response);
+        if (!response.ok) {
+            throw new Error(errorMessageFromJson(json, response.status));
+        }
+        return json;
+    }
+}
+export class SkillShellManager {
+    baseDir;
+    constructor(baseDir = process.cwd()) {
+        this.baseDir = baseDir;
+    }
+    resolveSyncDestination(target, scope) {
+        if (target === 'codex') {
+            return {
+                target,
+                scope,
+                rootDir: scope === 'user' ? join(homedir(), '.codex', 'skills') : join(this.baseDir, '.agents', 'skills'),
+                label: scope === 'user' ? 'codex:user' : 'codex:project',
+            };
+        }
+        if (target === 'claude') {
+            return {
+                target,
+                scope,
+                rootDir: scope === 'user' ? join(homedir(), '.claude', 'skills') : join(this.baseDir, '.claude', 'skills'),
+                label: scope === 'user' ? 'claude:user' : 'claude:project',
+            };
+        }
+        return {
+            target,
+            scope,
+            rootDir: scope === 'user' ? join(homedir(), '.cursor', 'skills') : join(this.baseDir, '.cursor', 'skills'),
+            label: scope === 'user' ? 'cursor:user' : 'cursor:project',
+        };
+    }
+    slugifySkillName(name) {
+        return name
+            .replace(/\//g, '-')
+            .replace(/[^a-z0-9-]/gi, '-')
+            .replace(/-+/g, '-')
+            .toLowerCase();
+    }
+    resolveSkillShellPath(skillName) {
+        const slug = this.slugifySkillName(skillName);
+        const outDir = join(this.baseDir, '.agents', 'skills', slug);
+        return {
+            slug,
+            outDir,
+            outPath: join(outDir, 'SKILL.md'),
+        };
+    }
+    generateShellContent(skill, slug, commandSlug = slug) {
+        const description = quoteYamlSingleLineString(`${skill.description || skill.name} (via Invokora)`);
+        return `---
+name: ${slug}
+description: ${description}
+---
+
+When the user asks for help related to this skill, call the Invokora MCP \`chat\` tool.
+Send the user's intent in \`messages\` and include the slash command \`/${commandSlug}\` in the latest user message, for example:
+
+\`\`\`json
+{"messages":[{"role":"user","content":"/${commandSlug} 帮我分析这个仓库"}]}
+\`\`\`
+
+If local files are relevant, inspect them with the host agent's own tools first, then include the necessary excerpts in the \`chat\` message. The Invokora MCP server itself does not read files, write files, or run shell commands.
+
+${SKILL_SHELL_MARKER}
+`.trimStart();
+    }
+    sync(skills, options, syncedContentBySkill = new Map()) {
+        const skillsRoot = options.rootDir ?? join(this.baseDir, '.agents', 'skills');
+        mkdirSync(skillsRoot, { recursive: true });
+        let written = 0;
+        const activeSlugs = new Set();
+        const plans = this.planSkillWrites(skills, syncedContentBySkill);
+        for (const plan of plans) {
+            const { skill, slug } = plan;
+            activeSlugs.add(slug);
+            const outDir = join(skillsRoot, slug);
+            if (existsSync(outDir) && this.isMarketplaceManagedSkill(outDir)) {
+                rmSync(outDir, { recursive: true, force: true });
+            }
+            mkdirSync(outDir, { recursive: true });
+            const skillWrite = this.buildManagedSkillWrite(skill, slug, plan.syncedContent, plan.commandSlug);
+            writeFileSync(join(outDir, 'SKILL.md'), skillWrite.content, 'utf-8');
+            this.writeBundleFiles(outDir, skillWrite.files);
+            this.writeManagedMetadata(outDir, skillWrite.metadata);
+            written++;
+        }
+        let pruned = 0;
+        if (options.prune && existsSync(skillsRoot)) {
+            const entries = readdirSync(skillsRoot, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (activeSlugs.has(entry.name))
+                    continue;
+                const dirPath = join(skillsRoot, entry.name);
+                // prune 只清理 Invokora 托管目录，避免误删用户自己写的本地技能目录。
+                if (!this.isMarketplaceManagedSkill(dirPath))
+                    continue;
+                rmSync(dirPath, { recursive: true, force: true });
+                pruned++;
+            }
+        }
+        return { written, pruned, activeSlugs };
+    }
+    planSkillWrites(skills, syncedContentBySkill) {
+        const groups = new Map();
+        skills.forEach((skill, index) => {
+            const baseSlug = this.baseSkillSlug(skill);
+            const group = groups.get(baseSlug) ?? [];
+            group.push({ skill, index, syncedContent: syncedContentBySkill.get(skill.id) });
+            groups.set(baseSlug, group);
+        });
+        const preferredByBaseSlug = new Map();
+        for (const [baseSlug, group] of groups.entries()) {
+            const preferred = [...group].sort((a, b) => {
+                const priority = this.localWritePriority(a.skill, a.syncedContent) - this.localWritePriority(b.skill, b.syncedContent);
+                return priority !== 0 ? priority : a.index - b.index;
+            })[0];
+            if (preferred) {
+                preferredByBaseSlug.set(baseSlug, preferred.skill.id);
+            }
+        }
+        const usedSlugs = new Set();
+        return skills.map((skill, index) => {
+            const baseSlug = this.baseSkillSlug(skill);
+            const syncedContent = syncedContentBySkill.get(skill.id);
+            const preferredID = preferredByBaseSlug.get(baseSlug);
+            const slug = skill.id === preferredID && !usedSlugs.has(baseSlug)
+                ? baseSlug
+                : this.uniqueDerivedSlug(baseSlug, skill.id || String(index), usedSlugs);
+            usedSlugs.add(slug);
+            return {
+                skill,
+                slug,
+                commandSlug: baseSlug,
+                syncedContent,
+            };
+        });
+    }
+    baseSkillSlug(skill) {
+        return this.slugifySkillName(skill.name) || this.slugifySkillName(skill.id) || 'skill';
+    }
+    uniqueDerivedSlug(baseSlug, skillID, usedSlugs) {
+        const idSlug = this.slugifySkillName(skillID) || 'skill';
+        let candidate = `${baseSlug}-${idSlug}`;
+        let counter = 2;
+        while (usedSlugs.has(candidate)) {
+            candidate = `${baseSlug}-${idSlug}-${counter}`;
+            counter++;
+        }
+        return candidate;
+    }
+    localWritePriority(skill, syncedContent) {
+        if (syncedContent && skill.access_source === 'personal')
+            return 0;
+        if (syncedContent)
+            return 1;
+        return 2;
+    }
+    listManagedSkills(rootDir) {
+        if (!existsSync(rootDir)) {
+            return [];
+        }
+        const skills = [];
+        const entries = readdirSync(rootDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const dirPath = join(rootDir, entry.name);
+            if (!this.isMarketplaceManagedSkill(dirPath))
+                continue;
+            const metadata = this.readManagedMetadata(dirPath);
+            skills.push({
+                slug: entry.name,
+                path: dirPath,
+                skill_id: typeof metadata?.skill_id === 'string' ? metadata.skill_id : undefined,
+                kind: typeof metadata?.kind === 'string' ? metadata.kind : undefined,
+            });
+        }
+        return skills.sort((a, b) => a.slug.localeCompare(b.slug));
+    }
+    removeManagedSkills(rootDir, slugs) {
+        if (!existsSync(rootDir)) {
+            return { removed: 0 };
+        }
+        let removed = 0;
+        const selectedSlugs = slugs ? new Set(slugs) : null;
+        for (const skill of this.listManagedSkills(rootDir)) {
+            if (selectedSlugs && !selectedSlugs.has(skill.slug))
+                continue;
+            // remove 只删除 Invokora 托管目录，避免误删用户自己维护的本地技能。
+            rmSync(skill.path, { recursive: true, force: true });
+            removed++;
+        }
+        return { removed };
+    }
+    writeManagedMetadata(outDir, metadata) {
+        writeFileSync(join(outDir, MANAGED_SKILL_META_FILE), `${JSON.stringify(metadata, null, 2)}\n`, 'utf-8');
+    }
+    writeBundleFiles(outDir, files) {
+        const root = resolve(outDir);
+        for (const file of files) {
+            if (file.path === 'SKILL.md')
+                continue;
+            const target = this.resolveSafeBundlePath(root, file.path);
+            mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, file.content, 'utf-8');
+        }
+    }
+    resolveSafeBundlePath(root, filePath) {
+        if (!filePath || isAbsolute(filePath) || filePath.includes('\\')) {
+            throw new Error(`Unsafe skill bundle path: ${filePath}`);
+        }
+        const target = resolve(root, filePath);
+        if (target !== root && !target.startsWith(`${root}/`)) {
+            throw new Error(`Unsafe skill bundle path: ${filePath}`);
+        }
+        return target;
+    }
+    buildManagedSkillWrite(skill, slug, syncedContent, commandSlug = slug) {
+        if (syncedContent) {
+            const content = this.shouldEnsureLocalManagedFrontmatter(skill)
+                ? ensureLocalManagedSkillFrontmatter(syncedContent.content, skill, slug)
+                : quoteSkillFrontmatterDescription(syncedContent.content);
+            const files = (syncedContent.files ?? [])
+                .filter((file) => typeof file.content === 'string' && file.path)
+                .map((file) => ({
+                path: file.path,
+                content: file.path === 'SKILL.md' ? content : (file.content ?? ''),
+            }));
+            return {
+                content,
+                files,
+                metadata: {
+                    managed_by: 'skilz',
+                    kind: this.managedContentKind(skill),
+                    skill_id: skill.id,
+                    resolved_version_id: syncedContent.resolved_version_id,
+                    version: syncedContent.version,
+                    content_hash: syncedContent.content_hash,
+                    files: (syncedContent.files ?? []).map((file) => ({
+                        path: file.path,
+                        content_hash: file.content_hash,
+                        size_bytes: file.size_bytes,
+                        kind: file.kind,
+                    })),
+                },
+            };
+        }
+        return {
+            content: this.generateShellContent(skill, slug, commandSlug),
+            files: [],
+            metadata: {
+                managed_by: 'skilz',
+                kind: 'shell',
+                skill_id: skill.id,
+            },
+        };
+    }
+    isMarketplaceManagedSkill(dirPath) {
+        const metadata = this.readManagedMetadata(dirPath);
+        if (metadata) {
+            return metadata.managed_by === 'skilz';
+        }
+        return this.hasMarketplaceShellMarker(dirPath);
+    }
+    managedContentKind(skill) {
+        if (skill.access_source === 'personal') {
+            return 'personal_content';
+        }
+        return 'public_content';
+    }
+    shouldEnsureLocalManagedFrontmatter(skill) {
+        return skill.access_source === 'personal';
+    }
+    readManagedMetadata(dirPath) {
+        const metadataPath = join(dirPath, MANAGED_SKILL_META_FILE);
+        if (!existsSync(metadataPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(readFileSync(metadataPath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    hasMarketplaceShellMarker(dirPath) {
+        const skillFilePath = join(dirPath, 'SKILL.md');
+        if (!existsSync(skillFilePath))
+            return false;
+        try {
+            const content = readFileSync(skillFilePath, 'utf-8');
+            return content.includes(SKILL_SHELL_MARKER);
+        }
+        catch {
+            return false;
+        }
+    }
+}