@ytinnovation/harness-core 0.0.0

package/dist/skills/command.js

@@ -0,0 +1,713 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join } from 'node:path';
+import { HarnessError } from '../contracts/errors.js';
+import { prepareSkillInstallByName, prepareSkillInstallByUrl, resolveSkillPackageFromUrl } from './install.js';
+import { createGitLabSkillPublishBackend, prepareSkillPublish, resolveLocalSkillGitIdentity } from './publish.js';
+import { createGitLabRestSkillPublishClient } from './gitlab-skill-publish-client.js';
+import { createDefaultInternalSkillProvider } from './default-internal-skill-provider.js';
+import { createStubExternalProvider } from './providers/stub.js';
+import { parseEnterpriseAssetIdFromSourceRef } from './providers/harness-service.js';
+import { createFileSkillRegistry } from './registry.js';
+import { scanWorkspaceSkills } from './list-scan.js';
+import { searchSkills } from './search.js';
+import { createHarnessTelemetryEvent, reportHarnessTelemetryEvents } from '../cloud/telemetry-client.js';
+import { listRemoteTopAssets } from '../assets/remote-list.js';
+import { parseInstallTargets, resolveSkillRegistryPath, resolveSkillTargetDir } from '../assets/install.js';
+import { resolveProjectManifestPath } from '../assets/project-manifest.js';
+import { renderDebugBoundary, renderErrorBlock, renderJson, renderRemoteAssetList, renderSearchResults, renderSkillLocalList, renderSuccessBlock, renderWarningBlock, } from '../cli-output/renderers.js';
+const DEFAULT_REGISTRY_RELATIVE_PATH = ['.harness', 'registry.json'];
+function resolveRegistryPath(options) {
+    if (options.registryPath) {
+        return options.registryPath;
+    }
+    return join(options.homeDir ?? homedir(), ...DEFAULT_REGISTRY_RELATIVE_PATH);
+}
+function resolveHomeRegistryPath(options) {
+    return join(options.homeDir ?? homedir(), ...DEFAULT_REGISTRY_RELATIVE_PATH);
+}
+function renderSkillHelp(programName = 'harness') {
+    return [
+        '管理 Harness Skill 资产。',
+        '',
+        '用法：',
+        `  ${programName} skill <subcommand> [args]`,
+        '',
+        '子命令：',
+        '  list [--remote] [--json]  查看本地或远程热门 Skills。',
+        '  search <query> [--json]   搜索可安装的 Skill。',
+        '  install <name> [--global] [--agents] [--target cursor,agents]  按名称安装 Skill。',
+        '  install --url <url> [--agents] [--target cursor,agents]         按 URL 安装 Skill。',
+        '  remove <name>             移除已安装 Skill。',
+        '  publish --manifest <path> [--repo <path>] [--target-dir <dir>] [--branch <name>] [--target-branch <name>] [--message <message>]',
+        '  -h, --help                查看帮助。',
+    ].join('\n');
+}
+function resolveInstallTargetDir(options) {
+    const workspaceRoot = options.workspaceRoot ?? process.cwd();
+    if (!options.installTargetDir) {
+        return join(workspaceRoot, '.cursor', 'skills');
+    }
+    if (isAbsolute(options.installTargetDir)) {
+        return options.installTargetDir;
+    }
+    return join(workspaceRoot, options.installTargetDir);
+}
+function toInstallTargetPath(targetDir, skillName) {
+    const normalizedSkillName = skillName.trim();
+    return join(targetDir, normalizedSkillName, 'SKILL.md');
+}
+async function planSkillInstall(skillName, targetPath, nextContent) {
+    try {
+        const existingContent = await readFile(targetPath, 'utf8');
+        if (existingContent === nextContent) {
+            return {
+                action: 'skip',
+                skillName,
+                targetPath,
+                reason: 'Existing file content is identical to the incoming skill package.',
+            };
+        }
+        return {
+            action: 'update',
+            skillName,
+            targetPath,
+            reason: 'Target skill file already exists with different local content; review before update.',
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return {
+                action: 'create',
+                skillName,
+                targetPath,
+                reason: 'Target skill file does not exist yet.',
+            };
+        }
+        throw error;
+    }
+}
+function renderSkillPublishUsage() {
+    return [
+        'Usage: harness skill publish --manifest <path> [--repo <path>] [--target-dir <dir>] [--branch <name>] [--target-branch <name>] [--message <message>]',
+        'Default: when HARNESS_SERVICE_URL is configured, upload the Skill to harness-service for Admin Console review/governance.',
+        'Legacy GitLab example: harness skill publish --manifest ./skills/review-helper/manifest.json --repo git@gitlab.example.com:harness/skills.git --target-dir skills/review-helper --target-branch main',
+        'Config fallback: HARNESS_SKILL_PUBLISH_REPO, HARNESS_SKILL_PUBLISH_TARGET_DIR, HARNESS_SKILL_PUBLISH_TARGET_BRANCH',
+        'GitLab publish: set HARNESS_SKILL_PUBLISH_TOKEN or HARNESS_GITLAB_TOKEN (project access token, api scope); optional HARNESS_GITLAB_API_BASE_URL for self-hosted (must include /api/v4). Without a token, publish runs in offline mock mode for tests only.',
+    ].join('\n');
+}
+function resolveHarnessServiceBaseUrl() {
+    const baseUrl = process.env.HARNESS_SERVICE_URL?.trim() || process.env.HARNESS_CLOUD_BASE_URL?.trim();
+    return baseUrl ? baseUrl.replace(/\/+$/, '') : null;
+}
+async function publishSkillToHarnessService(args) {
+    const packageRoot = dirname(args.manifestPath);
+    const entrypointPath = join(packageRoot, ...args.manifest.entrypoint.replace(/\\/g, '/').replace(/^\.\//, '').split('/'));
+    const [manifestRaw, entryRaw] = await Promise.all([
+        readFile(args.manifestPath, 'utf8'),
+        readFile(entrypointPath, 'utf8'),
+    ]);
+    const response = await fetch(`${args.baseUrl}/assets`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            type: 'skill',
+            name: args.manifest.name,
+            version: args.manifest.version,
+            content: [
+                '# Skill Package',
+                '',
+                '## manifest.json',
+                '```json',
+                manifestRaw.trim(),
+                '```',
+                '',
+                `## ${args.manifest.entrypoint}`,
+                '```markdown',
+                entryRaw.trim(),
+                '```',
+            ].join('\n'),
+            description: args.manifest.description,
+            tags: args.manifest.tags,
+            createdBy: `${args.authorName} <${args.authorEmail}>`,
+            metadata: {
+                source: 'cli-skill-publish',
+                targetPath: `.cursor/skills/${args.manifest.name}/SKILL.md`,
+                manifest: args.manifest,
+            },
+        }),
+    });
+    const text = await response.text();
+    const body = text ? JSON.parse(text) : null;
+    if (!response.ok) {
+        throw new HarnessError('SKILL_PUBLISH_SERVICE_FAILED', `harness-service skill publish failed with HTTP ${response.status}: ${text || response.statusText}`);
+    }
+    return body;
+}
+function resolveDefaultSkillPublishBackend() {
+    const token = process.env.HARNESS_SKILL_PUBLISH_TOKEN?.trim() || process.env.HARNESS_GITLAB_TOKEN?.trim();
+    if (token) {
+        return createGitLabSkillPublishBackend({
+            client: createGitLabRestSkillPublishClient({ token }),
+        });
+    }
+    return {
+        prepare: async (request) => ({
+            repositoryPath: request.repositoryPath,
+            mergeRequest: {
+                id: `mock-${request.manifest.name}-${request.manifest.version}`,
+                title: request.mergeRequestTitle,
+                description: request.mergeRequestDescription,
+                branchName: request.branchName,
+                targetBranch: request.targetBranch,
+            },
+        }),
+    };
+}
+function toOutputValue(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : 'unknown';
+}
+function toInstallOutputMetadata(record) {
+    return {
+        source: toOutputValue(record.source),
+        sourceRef: toOutputValue(record.sourceRef),
+        revision: toOutputValue(record.revision),
+        version: toOutputValue(record.manifest?.version),
+    };
+}
+function normalizeSkillManifest(candidate) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        return null;
+    }
+    const value = candidate;
+    const name = typeof value.name === 'string' ? value.name.trim() : '';
+    const version = typeof value.version === 'string' ? value.version.trim() : '';
+    const description = typeof value.description === 'string' ? value.description.trim() : '';
+    const entrypoint = typeof value.entrypoint === 'string' ? value.entrypoint.trim() : '';
+    const tags = Array.isArray(value.tags) ? value.tags.filter((tag) => typeof tag === 'string') : [];
+    if (!name || !version || !description || !entrypoint) {
+        return null;
+    }
+    const manifest = {
+        name,
+        version,
+        description,
+        entrypoint,
+        tags,
+    };
+    if (typeof value.author === 'string' && value.author.trim()) {
+        manifest.author = value.author.trim();
+    }
+    if (typeof value.repository === 'string' && value.repository.trim()) {
+        manifest.repository = value.repository.trim();
+    }
+    if (value.managedBy === 'harness') {
+        manifest.managedBy = 'harness';
+    }
+    return manifest;
+}
+async function readPublishManifest(manifestPath) {
+    let raw;
+    try {
+        raw = await readFile(manifestPath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Missing skill manifest at ${manifestPath}.`);
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid JSON in skill manifest: ${manifestPath}.`);
+    }
+    const manifest = normalizeSkillManifest(parsed);
+    if (!manifest) {
+        throw new Error(`Invalid skill manifest shape at ${manifestPath}.`);
+    }
+    return manifest;
+}
+function parseSkillPublishArgs(args) {
+    const out = {
+        manifestPath: '',
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        const value = args[i + 1];
+        if (!token?.startsWith('--') || !value) {
+            return null;
+        }
+        if (token === '--manifest') {
+            out.manifestPath = value;
+        }
+        else if (token === '--repo') {
+            out.repositoryPath = value;
+        }
+        else if (token === '--target-dir') {
+            out.targetDirectory = value;
+        }
+        else if (token === '--branch') {
+            out.branchName = value;
+        }
+        else if (token === '--target-branch') {
+            out.targetBranch = value;
+        }
+        else if (token === '--message') {
+            out.commitMessage = value;
+        }
+        else {
+            return null;
+        }
+        i += 1;
+    }
+    if (!out.manifestPath) {
+        return null;
+    }
+    return out;
+}
+export async function runSkillCommand(args, options = {}) {
+    const startedAt = Date.now();
+    const workspaceRoot = options.workspaceRoot ?? process.cwd();
+    const registryPath = options.registryPath ?? resolveProjectManifestPath(workspaceRoot);
+    const registry = createFileSkillRegistry(registryPath);
+    const internalProvider = options.internalProvider ?? createDefaultInternalSkillProvider();
+    const externalProvider = options.externalProvider ?? createStubExternalProvider();
+    try {
+        if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+            console.log(renderSkillHelp());
+            return 0;
+        }
+        const json = args.includes('--json');
+        const commandArgs = args.filter((arg) => arg !== '--json');
+        const subcommand = commandArgs[0];
+        if (subcommand === 'list') {
+            const listArgs = commandArgs.slice(1);
+            if (listArgs.some((arg) => arg !== '--remote')) {
+                console.error(renderErrorBlock({
+                    title: 'Skill 列表参数无效',
+                    message: 'skill list 仅支持 --remote 和 --json。',
+                    code: 'SKILL_INVALID_ARGS',
+                    suggestions: ['运行 harness skill list 或 harness skill list --remote。'],
+                }));
+                return 1;
+            }
+            const isRemote = listArgs.includes('--remote');
+            if (isRemote) {
+                try {
+                    const assets = await listRemoteTopAssets({ type: 'skill' });
+                    console.log(json ? renderJson({ assets }) : renderRemoteAssetList('远程热门 Skills', assets));
+                    return 0;
+                }
+                catch (error) {
+                    if (error instanceof HarnessError) {
+                        console.error(renderErrorBlock({
+                            title: '远程 Skill 列表读取失败',
+                            message: error.message,
+                            code: error.code,
+                            suggestions: ['检查 HARNESS_SERVICE_URL / HARNESS_CLOUD_BASE_URL 是否已配置并可访问。'],
+                        }));
+                        return 1;
+                    }
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error(renderErrorBlock({ title: '远程 Skill 列表读取失败', message }));
+                    return 1;
+                }
+            }
+            const scan = await scanWorkspaceSkills(workspaceRoot);
+            const registryInstalled = await registry.list();
+            const payload = {
+                workspaceRoot,
+                scannedRoots: ['.agents', '.cursor'],
+                maintained: scan.maintained,
+                other: scan.other,
+                registry: registryInstalled,
+            };
+            console.log(json ? renderJson(payload) : renderSkillLocalList(payload));
+            return 0;
+        }
+        if (subcommand === 'search') {
+            const query = commandArgs.slice(1).join(' ').trim();
+            if (!query) {
+                console.error(renderErrorBlock({
+                    title: '缺少搜索关键词',
+                    message: '请提供要搜索的 Skill 名称、标签或描述关键词。',
+                    code: 'SKILL_INVALID_ARGS',
+                    suggestions: ['示例：harness skill search code review'],
+                }));
+                return 1;
+            }
+            const results = await searchSkills(query, {
+                internalProvider,
+                externalProvider,
+                maxResults: options.searchMaxResults,
+                vettingProvider: options.externalVettingProvider,
+            });
+            void reportHarnessTelemetryEvents([
+                createHarnessTelemetryEvent('asset.used', {
+                    source: 'cli',
+                    command: 'skill search',
+                    success: true,
+                    payload: { query, resultCount: results.length },
+                }),
+            ], { workspaceRoot: options.workspaceRoot ?? process.cwd() });
+            console.log(json ? renderJson({ query, results }) : renderSearchResults({ query, results }));
+            return 0;
+        }
+        if (subcommand === 'install') {
+            const globalInstall = commandArgs.includes('--global');
+            const { targets, rest: installArgs } = parseInstallTargets(commandArgs.slice(1).filter((arg) => arg !== '--global'));
+            const activeRegistryPath = resolveSkillRegistryPath({
+                workspaceRoot,
+                homeRegistryPath: resolveHomeRegistryPath(options),
+                explicitRegistryPath: options.registryPath,
+                global: globalInstall,
+            });
+            const activeRegistry = createFileSkillRegistry(activeRegistryPath);
+            const isInstallByUrl = installArgs.length === 2 && installArgs[0] === '--url';
+            const isInstallByName = installArgs.length === 1 && installArgs[0] !== '--url';
+            if (!isInstallByUrl && !isInstallByName) {
+                console.error(renderErrorBlock({
+                    title: 'Skill 安装参数无效',
+                    message: '请二选一：按名称安装，或通过 --url 安装。',
+                    code: 'SKILL_INVALID_ARGS',
+                    suggestions: ['harness skill install review-helper', 'harness skill install --url https://example.com/skills/review-helper.md'],
+                }));
+                return 1;
+            }
+            if (isInstallByUrl) {
+                const urlValue = installArgs[1];
+                if (!urlValue) {
+                    console.error(renderErrorBlock({
+                        title: '缺少 Skill URL',
+                        message: '使用 --url 安装时必须提供 http/https URL。',
+                        code: 'SKILL_INVALID_ARGS',
+                    }));
+                    return 1;
+                }
+                const resolveByUrl = options.resolveByUrl ??
+                    resolveSkillPackageFromUrl;
+                try {
+                    const prepared = await prepareSkillInstallByUrl(urlValue, {
+                        resolveByUrl,
+                        now: options.now,
+                    });
+                    const targetDir = resolveSkillTargetDir({
+                        workspaceRoot,
+                        homeDir: options.homeDir ?? homedir(),
+                        installTargetDir: options.installTargetDir,
+                        target: targets[0] ?? 'cursor',
+                        global: false,
+                    });
+                    const targetPath = toInstallTargetPath(targetDir, prepared.installedRecord.skillName);
+                    const skillPlan = await planSkillInstall(prepared.installedRecord.skillName, targetPath, prepared.packageContent);
+                    if (skillPlan.action === 'update') {
+                        const installMetadata = toInstallOutputMetadata(prepared.installedRecord);
+                        const payload = {
+                            status: 'planned',
+                            action: skillPlan.action,
+                            skillName: prepared.installedRecord.skillName,
+                            sourceUrl: prepared.installedRecord.sourceRef,
+                            source: installMetadata.source,
+                            sourceRef: installMetadata.sourceRef,
+                            revision: prepared.installedRecord.revision,
+                            revisionLabel: installMetadata.revision,
+                            version: prepared.installedRecord.manifest.version,
+                            versionLabel: installMetadata.version,
+                            hash: prepared.installedRecord.assetMetadata.hash,
+                            installPath: skillPlan.targetPath,
+                            reason: skillPlan.reason,
+                        };
+                        console.log(json ? renderJson(payload) : renderWarningBlock('Skill 更新需要人工确认', [
+                            ['名称', prepared.installedRecord.skillName],
+                            ['来源', installMetadata.sourceRef],
+                            ['版本', installMetadata.version],
+                            ['安装路径', skillPlan.targetPath],
+                            ['原因', skillPlan.reason],
+                        ], ['目标文件已有本地修改，本次仅生成计划，不会覆盖文件。']));
+                        return 0;
+                    }
+                    if (skillPlan.action === 'create') {
+                        await mkdir(dirname(skillPlan.targetPath), { recursive: true });
+                        await writeFile(skillPlan.targetPath, prepared.packageContent, 'utf8');
+                    }
+                    const installedRecord = {
+                        ...prepared.installedRecord,
+                        installPath: skillPlan.targetPath,
+                    };
+                    const installMetadata = toInstallOutputMetadata(installedRecord);
+                    const payload = {
+                        status: 'installed',
+                        action: skillPlan.action,
+                        skillName: installedRecord.skillName,
+                        sourceUrl: installedRecord.sourceRef,
+                        source: installMetadata.source,
+                        sourceRef: installMetadata.sourceRef,
+                        revision: installMetadata.revision,
+                        version: installMetadata.version,
+                        hash: installedRecord.assetMetadata.hash,
+                        installPath: installedRecord.installPath,
+                        reason: skillPlan.reason,
+                    };
+                    console.log(json ? renderJson(payload) : renderSuccessBlock('Skill 安装完成', [
+                        ['动作', skillPlan.action === 'create' ? '创建' : '跳过'],
+                        ['名称', installedRecord.skillName],
+                        ['来源', installMetadata.sourceRef],
+                        ['版本', installMetadata.version],
+                        ['Revision', installMetadata.revision],
+                        ['安装路径', installedRecord.installPath],
+                    ]));
+                    void reportHarnessTelemetryEvents([
+                        createHarnessTelemetryEvent('asset.installed', {
+                            source: 'cli',
+                            command: 'skill install --url',
+                            success: true,
+                            payload: {
+                                skillName: installedRecord.skillName,
+                                sourceRef: installedRecord.sourceRef,
+                                installPath: installedRecord.installPath,
+                            },
+                        }),
+                    ], { workspaceRoot: options.workspaceRoot ?? process.cwd() });
+                    return 0;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error(renderErrorBlock({ title: 'Skill 安装失败', message }));
+                    return 1;
+                }
+            }
+            const skillName = installArgs[0]?.trim();
+            if (!skillName) {
+                console.error(renderErrorBlock({
+                    title: '缺少 Skill 名称',
+                    message: '按名称安装时必须提供 Skill 名称。',
+                    code: 'SKILL_INVALID_ARGS',
+                }));
+                return 1;
+            }
+            try {
+                const prepared = await prepareSkillInstallByName(skillName, {
+                    provider: internalProvider,
+                    now: options.now,
+                });
+                const installedRecord = prepared.installedRecord;
+                const targetDir = resolveSkillTargetDir({
+                    workspaceRoot,
+                    homeDir: options.homeDir ?? homedir(),
+                    installTargetDir: options.installTargetDir,
+                    target: targets[0] ?? 'cursor',
+                    global: globalInstall,
+                });
+                const targetPath = toInstallTargetPath(targetDir, installedRecord.skillName);
+                const skillPlan = await planSkillInstall(installedRecord.skillName, targetPath, prepared.packageContent);
+                if (skillPlan.action === 'create') {
+                    await mkdir(dirname(skillPlan.targetPath), { recursive: true });
+                    await writeFile(skillPlan.targetPath, prepared.packageContent, 'utf8');
+                }
+                const recordWithPath = {
+                    ...installedRecord,
+                    installPath: skillPlan.targetPath,
+                };
+                await activeRegistry.add(recordWithPath);
+                const assetId = parseEnterpriseAssetIdFromSourceRef(installedRecord.sourceRef);
+                void reportHarnessTelemetryEvents([
+                    createHarnessTelemetryEvent('asset.installed', {
+                        source: 'cli',
+                        command: 'skill install',
+                        success: true,
+                        asset_id: assetId ?? undefined,
+                        payload: {
+                            skillName: installedRecord.skillName,
+                            sourceRef: installedRecord.sourceRef,
+                        },
+                    }),
+                ], { workspaceRoot: options.workspaceRoot ?? process.cwd() });
+                const installMetadata = toInstallOutputMetadata(recordWithPath);
+                const payload = {
+                    status: 'installed',
+                    skillName: recordWithPath.skillName,
+                    source: installMetadata.source,
+                    sourceRef: installMetadata.sourceRef,
+                    revision: installMetadata.revision,
+                    version: installMetadata.version,
+                    installPath: recordWithPath.installPath,
+                };
+                console.log(json ? renderJson(payload) : renderSuccessBlock('Skill 安装完成', [
+                    ['名称', recordWithPath.skillName],
+                    ['来源', installMetadata.source],
+                    ['Source Ref', installMetadata.sourceRef],
+                    ['版本', installMetadata.version],
+                    ['Revision', installMetadata.revision],
+                    ['安装路径', recordWithPath.installPath],
+                ]));
+                return 0;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(renderErrorBlock({ title: 'Skill 安装失败', message }));
+                return 1;
+            }
+        }
+        if (subcommand === 'remove') {
+            const skillName = commandArgs[1]?.trim();
+            if (!skillName) {
+                console.error(renderErrorBlock({
+                    title: '缺少 Skill 名称',
+                    message: '移除 Skill 时必须提供名称。',
+                    code: 'SKILL_INVALID_ARGS',
+                }));
+                return 1;
+            }
+            const removed = await registry.remove(skillName);
+            if (!removed) {
+                console.error(renderErrorBlock({
+                    title: '未找到 Skill',
+                    message: `本地注册表中没有找到 ${skillName}。`,
+                    code: 'SKILL_NOT_FOUND',
+                }));
+                return 1;
+            }
+            const payload = { status: 'removed', skillName };
+            console.log(json ? renderJson(payload) : renderSuccessBlock('Skill 已移除', [['名称', skillName]]));
+            return 0;
+        }
+        if (subcommand === 'publish') {
+            const publishArgs = parseSkillPublishArgs(commandArgs.slice(1));
+            if (!publishArgs) {
+                console.error(renderErrorBlock({
+                    title: 'Skill 发布参数无效',
+                    message: renderSkillPublishUsage(),
+                    code: 'SKILL_INVALID_ARGS',
+                }));
+                return 1;
+            }
+            const backend = options.publishBackend ?? resolveDefaultSkillPublishBackend();
+            try {
+                const cwdForManifest = options.workspaceRoot ?? process.cwd();
+                const resolvedManifestPath = isAbsolute(publishArgs.manifestPath)
+                    ? publishArgs.manifestPath
+                    : join(cwdForManifest, publishArgs.manifestPath);
+                const manifest = await readPublishManifest(resolvedManifestPath);
+                const serviceBaseUrl = resolveHarnessServiceBaseUrl();
+                if (serviceBaseUrl && !publishArgs.repositoryPath?.trim()) {
+                    const gitIdentity = await (options.resolveGitIdentity ?? resolveLocalSkillGitIdentity)(options.workspaceRoot ?? process.cwd());
+                    if (!gitIdentity.name || !gitIdentity.email) {
+                        throw new HarnessError('SKILL_PUBLISH_MISSING_GIT_IDENTITY', 'Missing local Git identity. Configure user.name and user.email before publishing a skill.');
+                    }
+                    const serviceResult = await publishSkillToHarnessService({
+                        baseUrl: serviceBaseUrl,
+                        manifest,
+                        manifestPath: resolvedManifestPath,
+                        authorName: gitIdentity.name,
+                        authorEmail: gitIdentity.email,
+                    });
+                    const payload = {
+                        status: 'uploaded',
+                        serviceUrl: serviceBaseUrl,
+                        review: 'admin-console',
+                        result: serviceResult,
+                    };
+                    console.log(json ? renderJson(payload) : renderSuccessBlock('Skill 已上传，等待审核', [
+                        ['服务地址', serviceBaseUrl],
+                        ['审核入口', 'Admin Console'],
+                        ['结果', JSON.stringify(serviceResult)],
+                    ]));
+                    return 0;
+                }
+                const repositoryPath = publishArgs.repositoryPath?.trim() ?? process.env.HARNESS_SKILL_PUBLISH_REPO?.trim();
+                if (!repositoryPath) {
+                    console.error(renderErrorBlock({
+                        title: '缺少发布目标仓库',
+                        message: '未配置企业 GitLab 仓库路径。',
+                        code: 'SKILL_PUBLISH_MISSING_REPOSITORY',
+                        suggestions: ['传入 --repo <path>，或设置 HARNESS_SKILL_PUBLISH_REPO。'],
+                    }));
+                    return 1;
+                }
+                const targetDirectory = publishArgs.targetDirectory?.trim() ??
+                    process.env.HARNESS_SKILL_PUBLISH_TARGET_DIR?.trim() ??
+                    `skills/${manifest.name}`;
+                const branchName = publishArgs.branchName?.trim() || `publish/${manifest.name}-${manifest.version}`;
+                const targetBranch = publishArgs.targetBranch?.trim() ?? process.env.HARNESS_SKILL_PUBLISH_TARGET_BRANCH?.trim() ?? 'main';
+                const commitMessage = publishArgs.commitMessage?.trim() || `Publish ${manifest.name} ${manifest.version}`;
+                const prepared = await prepareSkillPublish(manifest, {
+                    backend,
+                    repositoryPath,
+                    targetDirectory,
+                    branchName,
+                    targetBranch,
+                    commitMessage,
+                    cwd: options.workspaceRoot ?? process.cwd(),
+                    resolveGitIdentity: options.resolveGitIdentity,
+                    manifestPath: resolvedManifestPath,
+                });
+                const payload = {
+                    status: 'prepared',
+                    repositoryPath: prepared.repositoryPath,
+                    targetDirectory,
+                    branchName: prepared.mergeRequest.branchName,
+                    targetBranch: prepared.mergeRequest.targetBranch,
+                    mergeRequest: prepared.mergeRequest,
+                };
+                console.log(json ? renderJson(payload) : renderSuccessBlock('Skill 发布请求已准备', [
+                    ['仓库', prepared.repositoryPath],
+                    ['目标目录', targetDirectory],
+                    ['分支', prepared.mergeRequest.branchName],
+                    ['目标分支', prepared.mergeRequest.targetBranch],
+                    ['Merge Request', prepared.mergeRequest.webUrl ?? prepared.mergeRequest.id],
+                ]));
+                return 0;
+            }
+            catch (error) {
+                if (error instanceof HarnessError) {
+                    console.error(renderErrorBlock({ title: 'Skill 发布失败', message: error.message, code: error.code }));
+                    if (error.code === 'SKILL_PUBLISH_MISSING_GIT_IDENTITY') {
+                        console.error(renderWarningBlock('需要配置 Git 身份', [], [
+                            'git config --local user.name "Your Name"',
+                            'git config --local user.email "you@example.com"',
+                        ]));
+                    }
+                    return 1;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                if (message.includes('Missing local Git identity')) {
+                    console.error(renderErrorBlock({
+                        title: 'Skill 发布失败',
+                        message,
+                        suggestions: [
+                            'git config --local user.name "Your Name"',
+                            'git config --local user.email "you@example.com"',
+                        ],
+                    }));
+                    return 1;
+                }
+                console.error(renderErrorBlock({ title: 'Skill 发布失败', message }));
+                return 1;
+            }
+        }
+        console.error(renderErrorBlock({
+            title: '未知 Skill 子命令',
+            message: `无法识别子命令：${subcommand}`,
+            code: 'SKILL_INVALID_ARGS',
+            suggestions: ['运行 harness skill --help 查看可用命令。'],
+        }));
+        return 1;
+    }
+    finally {
+        const durationMs = Date.now() - startedAt;
+        const budgetMs = 3_000;
+        const debugLine = renderDebugBoundary('skill', durationMs, budgetMs);
+        if (debugLine) {
+            console.log(debugLine);
+        }
+    }
+}
+export function registerSkillCommand(router) {
+    router.register('skill', runSkillCommand);
+}
+export { renderSkillHelp };
+//# sourceMappingURL=command.js.map