@foxian/esl 0.1.0

package/dist/commands/login.js

@@ -0,0 +1,132 @@
+import { loadConfig, initializeLocalStore, saveConfig, saveCredentials } from '../vendor/core/index.js';
+import { resolveLocale, translateApiError } from '../vendor/i18n/index.js';
+import fs from 'node:fs/promises';
+import { isInteractive, readHidden, readText } from '../prompt.js';
+import { resolveServer } from './config.js';
+import { fetchWithTimeout } from './network-options.js';
+// 全局身份登录（ADR-0032）：username + password 一条凭据，无组织输入；
+// 所属组织列表由服务端按 Gitea 成员关系派生。
+export async function executeLogin(options) {
+    const fetchImpl = options.customFetch ?? fetch;
+    await initializeLocalStore({ homeDir: options.homeDir });
+    const currentConfig = await loadConfig({ homeDir: options.homeDir });
+    const activeLocale = resolveLocale({
+        override: options.locale,
+        accountLocale: currentConfig.locale
+    });
+    const server = await resolveServerForLogin(options);
+    const username = await resolveUsername(options);
+    const { token, organizations, locale } = await resolveLoginToken(options, server, username, fetchImpl, activeLocale);
+    await saveCredentials({ token, loginAt: new Date().toISOString() }, { homeDir: options.homeDir });
+    // 显式清掉旧版标记：重新登录后 organizations 已是新形状，提示不该跟着旧配置
+    // 一直留在 whoami 输出里。
+    await saveConfig({ server, username, organizations, locale, legacyIdentity: false }, { homeDir: options.homeDir });
+    return { token, username, organizations, locale };
+}
+// 首次使用未配置 server 时交互式询问并记住;非交互环境直接报错。
+async function resolveServerForLogin(options) {
+    try {
+        return await resolveServer({ server: options.server, homeDir: options.homeDir });
+    }
+    catch (error) {
+        if (options.noInput) {
+            throw error;
+        }
+        if (options.readServer) {
+            const url = (await options.readServer()).trim();
+            if (!url) {
+                throw error;
+            }
+            return url;
+        }
+        if (!isInteractive()) {
+            throw error;
+        }
+        const url = (await readText('Server URL (e.g. http://localhost:3000): ')).trim();
+        if (!url) {
+            throw error;
+        }
+        return url;
+    }
+}
+async function resolveUsername(options) {
+    if (options.username) {
+        return options.username;
+    }
+    if (options.noInput) {
+        throw new Error('A username is required; pass --username or run interactively');
+    }
+    if (options.readUsername) {
+        return (await options.readUsername('Username: ')).trim();
+    }
+    if (!isInteractive()) {
+        throw new Error('A username is required; pass --username or run interactively');
+    }
+    return (await readText('Username: ')).trim();
+}
+async function resolveLoginToken(options, server, username, fetchImpl, locale) {
+    if (options.tokenFile) {
+        const token = (await fs.readFile(options.tokenFile, 'utf8')).trim();
+        if (!token) {
+            throw new Error(`Token file ${options.tokenFile} is empty`);
+        }
+        // token-file 登录不联网,拿不到成员关系;组织列表留空,whoami/status
+        // 以本地已有信息展示。
+        return { token, organizations: [], locale: null };
+    }
+    const password = options.passwordFile
+        ? (await fs.readFile(options.passwordFile, 'utf8')).trim()
+        : await promptForPassword(options);
+    if (!password) {
+        throw new Error('Password is required for login');
+    }
+    return exchangePasswordForToken(server, username, password, fetchImpl, locale);
+}
+async function promptForPassword(options) {
+    if (options.noInput) {
+        throw new Error('Login requires a password or token; pass --password-file or --token-file when using --no-input');
+    }
+    if (options.readInput) {
+        return (await options.readInput()).trim();
+    }
+    if (!isInteractive()) {
+        throw new Error('Login requires a password; run interactively or pass --password-file/--token-file');
+    }
+    return (await readHidden('Password: ')).trim();
+}
+async function exchangePasswordForToken(server, username, password, fetchImpl, locale) {
+    const base = server.replace(/\/$/, '');
+    const res = await fetchWithTimeout(fetchImpl, `${base}/api/auth/login`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ username, password })
+    });
+    if (!res.ok) {
+        const err = await res.text();
+        try {
+            const body = JSON.parse(err);
+            if (typeof body.code === 'string') {
+                throw new Error(translateApiError({
+                    locale,
+                    code: body.code,
+                    params: body.params,
+                    fallback: body.message ?? 'Failed to authenticate with ESL Server'
+                }));
+            }
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError)) {
+                throw error;
+            }
+        }
+        throw new Error(`Failed to authenticate with ESL Server: ${err}`);
+    }
+    const data = (await res.json());
+    return {
+        token: data.token,
+        organizations: Array.isArray(data.organizations) ? data.organizations : [],
+        locale: data.locale ?? null
+    };
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,6 @@
+import { type LocalStoreOptions } from '@esl/core';
+export interface LogoutResult {
+    hadCredentials: boolean;
+}
+export declare function executeLogout(options?: LocalStoreOptions): Promise<LogoutResult>;
+export declare function formatLogout(result: LogoutResult): string;

package/dist/commands/logout.js

@@ -0,0 +1,18 @@
+import { clearCredentials, loadCredentials } from '../vendor/core/index.js';
+export async function executeLogout(options = {}) {
+    let hadCredentials = false;
+    try {
+        const credentials = await loadCredentials({ homeDir: options.homeDir });
+        hadCredentials = Boolean(credentials.token);
+    }
+    catch {
+        hadCredentials = false;
+    }
+    await clearCredentials({ homeDir: options.homeDir });
+    return { hadCredentials };
+}
+export function formatLogout(result) {
+    return result.hadCredentials
+        ? 'Logged out. Local credentials cleared.'
+        : 'Not logged in; no credentials to clear.';
+}

package/dist/commands/network-options.d.ts

@@ -0,0 +1,27 @@
+import { type LocalStoreOptions } from '@esl/core';
+export interface NetworkCommandOptions extends LocalStoreOptions {
+    server?: string;
+    customFetch?: typeof fetch;
+    builtinDir?: string;
+}
+export interface ResolvedNetworkConfig {
+    server: string;
+    token: string | null;
+}
+export declare function resolveNetworkConfig(options: NetworkCommandOptions): Promise<ResolvedNetworkConfig>;
+export declare function requireConfigured(value: string | null | undefined, name: string): string;
+export declare function withAuthGuidanceIfForbidden(status: number, message: string): string;
+export declare function resolveTimeoutMs(): number;
+export declare function resolveLoginTtlMs(): number;
+export declare function isLoginFresh(loginAt: string | null | undefined): boolean;
+export declare function requireFreshToken(options?: LocalStoreOptions): Promise<string>;
+export declare function resolveOptionalFreshToken(options?: LocalStoreOptions): Promise<string | null>;
+export declare function fetchWithTimeout(fetchImpl: typeof fetch, url: string, init?: RequestInit, timeoutMs?: number): Promise<Response>;
+export declare function apiUrl(server: string, path: string): string;
+export declare function parseHttpOrigin(url: string): string | null;
+export declare function sourceRemoteOriginDrifted(remoteUrl: string, server: string): boolean;
+export declare function gitAuthHeaderConfig(token: string): string;
+export declare function installTargetDir(skillName: string, options: LocalStoreOptions): string;
+export declare function projectSkillsDir(projectRoot: string, skillName: string): string;
+export declare function publishedInstallTargetDir(skillName: string, options: LocalStoreOptions): string;
+export declare function publishedProjectSkillsDir(projectRoot: string, skillName: string): string;

package/dist/commands/network-options.js

@@ -0,0 +1,133 @@
+import { loadConfig, loadCredentials, resolveLocalStorePaths, resolveProjectStorePaths, skillSourceDirectoryName } from '../vendor/core/index.js';
+import path from 'node:path';
+export async function resolveNetworkConfig(options) {
+    const config = await loadConfig({ homeDir: options.homeDir });
+    const credentials = await loadCredentials({ homeDir: options.homeDir });
+    return {
+        server: options.server ?? requireConfigured(config.server, 'server'),
+        token: credentials.token
+    };
+}
+export function requireConfigured(value, name) {
+    if (!value) {
+        throw new Error(`Missing ${name}; run esl login or pass --${name}`);
+    }
+    return value;
+}
+// ADR-0021 后续：403 通常意味着技能由其他账号/组织维护（各组织账号相互独立）。
+// 在原始错误后附加可行动指引，替代裸 403 信息。
+function withAuthGuidance(message) {
+    return `${message}\nThis skill may be maintained by another account or organization; log in with the maintaining organization ("esl login") and retry.`;
+}
+// 403 时附加跨账号指引，其余状态码原样返回。
+export function withAuthGuidanceIfForbidden(status, message) {
+    return status === 403 ? withAuthGuidance(message) : message;
+}
+export function resolveTimeoutMs() {
+    const env = process.env.ESL_HTTP_TIMEOUT;
+    if (env) {
+        const parsed = Number(env);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return 30_000;
+}
+export function resolveLoginTtlMs() {
+    const env = process.env.ESL_LOGIN_TTL_HOURS;
+    if (env) {
+        const parsed = Number(env);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed * 3_600_000;
+        }
+    }
+    return 720 * 3_600_000;
+}
+// 登录是否仍在 TTL 有效期内（本地时间戳判断，不向服务器验证）。
+export function isLoginFresh(loginAt) {
+    if (!loginAt) {
+        return false;
+    }
+    const loginAtMs = Date.parse(loginAt);
+    return !Number.isNaN(loginAtMs) && Date.now() - loginAtMs <= resolveLoginTtlMs();
+}
+export async function requireFreshToken(options = {}) {
+    const credentials = await loadCredentials({ homeDir: options.homeDir });
+    const token = requireConfigured(credentials.token, 'token');
+    if (!isLoginFresh(credentials.loginAt)) {
+        throw new Error('Login expired; run esl login to re-authenticate');
+    }
+    return token;
+}
+// 匿名也可用的请求所用尽力而为的凭据：登录仍在有效期则返回 token，缺失或过期返回 null（调用方按匿名处理）。
+export async function resolveOptionalFreshToken(options = {}) {
+    let token;
+    let loginAt;
+    try {
+        const credentials = await loadCredentials({ homeDir: options.homeDir });
+        token = credentials.token;
+        loginAt = credentials.loginAt;
+    }
+    catch {
+        return null;
+    }
+    if (!token || !isLoginFresh(loginAt)) {
+        return null;
+    }
+    return token;
+}
+export async function fetchWithTimeout(fetchImpl, url, init = {}, timeoutMs = resolveTimeoutMs()) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetchImpl(url, { ...init, signal: controller.signal });
+    }
+    catch (error) {
+        if (controller.signal.aborted && error?.name === 'AbortError') {
+            throw new Error(`Request timed out after ${timeoutMs} ms`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function apiUrl(server, path) {
+    const base = server.replace(/\/$/, '');
+    return `${base}${path}`;
+}
+// 解析 http(s) URL 的 origin（scheme://host[:port]）；非 http(s) 或无法解析时返回 null。
+export function parseHttpOrigin(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            return null;
+        }
+        return parsed.origin;
+    }
+    catch {
+        return null;
+    }
+}
+// ADR-0023：Source Remote origin 与当前配置 ESL Server origin 是否漂移
+// （Server Origin 迁移检测）。任一侧不是 http(s) 时视为无漂移，维持既有行为。
+export function sourceRemoteOriginDrifted(remoteUrl, server) {
+    const remoteOrigin = parseHttpOrigin(remoteUrl);
+    const serverOrigin = parseHttpOrigin(server);
+    return remoteOrigin !== null && serverOrigin !== null && remoteOrigin !== serverOrigin;
+}
+export function gitAuthHeaderConfig(token) {
+    return `http.extraHeader=Authorization: Bearer ${token}`;
+}
+export function installTargetDir(skillName, options) {
+    return path.join(resolveLocalStorePaths(options).skillsDir, skillSourceDirectoryName(skillName));
+}
+export function projectSkillsDir(projectRoot, skillName) {
+    return path.join(resolveProjectStorePaths(projectRoot).skillsDir, skillSourceDirectoryName(skillName));
+}
+export function publishedInstallTargetDir(skillName, options) {
+    return installTargetDir(skillName, options);
+}
+export function publishedProjectSkillsDir(projectRoot, skillName) {
+    return projectSkillsDir(projectRoot, skillName);
+}

package/dist/commands/notes.d.ts

@@ -0,0 +1,10 @@
+import { type NetworkCommandOptions } from './network-options.js';
+export interface NotesOptions extends NetworkCommandOptions {
+    message: string;
+}
+export interface UpdatedNotes {
+    skillName: string;
+    version: string;
+    notes?: string;
+}
+export declare function executeNotes(identity: string, version: string, options: NotesOptions): Promise<UpdatedNotes>;

package/dist/commands/notes.js

@@ -0,0 +1,24 @@
+import { parseSkillName, isBuiltinIdentity } from '../vendor/core/index.js';
+import { requireOkResponse } from '../api-error.js';
+import { apiUrl, fetchWithTimeout, requireFreshToken, resolveNetworkConfig } from './network-options.js';
+export async function executeNotes(identity, version, options) {
+    if (isBuiltinIdentity(identity)) {
+        throw new Error(`Unknown built-in skill: ${identity}; built-in skills have no releases`);
+    }
+    const token = await requireFreshToken(options);
+    const server = options.server ?? (await resolveNetworkConfig(options)).server;
+    const { scope, skillName } = parseSkillName(identity);
+    const fetchImpl = options.customFetch ?? fetch;
+    const response = await fetchWithTimeout(fetchImpl, apiUrl(server, `/api/skills/${encodeURIComponent(scope)}/${encodeURIComponent(skillName)}/releases/${encodeURIComponent(version)}/notes`), {
+        method: 'POST',
+        headers: {
+            Authorization: `token ${token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ message: options.message })
+    });
+    if (!response.ok) {
+        await requireOkResponse(response, 'Failed to update release notes');
+    }
+    return response.json();
+}

package/dist/commands/publish.d.ts

@@ -0,0 +1,19 @@
+import { execFile } from 'node:child_process';
+import { type NetworkCommandOptions } from './network-options.js';
+declare const defaultExecFileAsync: typeof execFile.__promisify__;
+export interface PublishOptions extends NetworkCommandOptions {
+    directory?: string;
+    /** @deprecated Version is now read from release.json; pass --version to point users at `esl version` */
+    version?: string;
+    visibility?: string;
+    force?: boolean;
+    noInput?: boolean;
+    license?: string;
+    message?: string;
+    confirmInput?: () => Promise<boolean>;
+    noteInput?: (collected: string) => Promise<string>;
+    execFileAsync?: typeof defaultExecFileAsync;
+    dryRun?: boolean;
+}
+export declare function executePublish(options?: PublishOptions): Promise<unknown>;
+export {};

package/dist/commands/publish.js

@@ -0,0 +1,271 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import semver from 'semver';
+import { fileExists, highestStableVersion, isBuiltinIdentity, validateSkillSourceDirectory } from '../vendor/core/index.js';
+import { requireOkResponse } from '../api-error.js';
+import { confirm, isInteractive, readText } from '../prompt.js';
+import { apiUrl, fetchWithTimeout, gitAuthHeaderConfig, requireFreshToken, resolveNetworkConfig } from './network-options.js';
+import { ensureReleaseManifest } from './release-manifest.js';
+const defaultExecFileAsync = promisify(execFile);
+export async function executePublish(options = {}) {
+    const directory = options.directory ?? process.cwd();
+    const skillJsonPath = path.join(directory, 'skill.json');
+    if (await fileExists(skillJsonPath)) {
+        const raw = await fs.readFile(skillJsonPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed.name && isBuiltinIdentity(parsed.name)) {
+            throw new Error('Built-in skills cannot be published; they are bundled with the ESL CLI');
+        }
+    }
+    if (!(await fileExists(`${directory}/release.json`))) {
+        await ensureReleaseManifest(options, directory);
+        throw new Error('Created release.json in the source directory; commit it, then run `esl version <SemVer>` to set the version before publishing.');
+    }
+    if (options.version !== undefined) {
+        throw new Error('`esl publish` no longer takes a version argument. The version is read from release.json. Use `esl version` (major | minor | patch | <SemVer>) to set the version first.');
+    }
+    return executeSourceRelease(options, directory);
+}
+async function executeSourceRelease(options, directory) {
+    const validation = await validateSkillSourceDirectory(directory);
+    if (!validation.success) {
+        throw new Error(`Invalid skill source: ${validation.errors.join(', ')}`);
+    }
+    const version = validation.data.releaseManifest.version;
+    const status = await git(options, directory, ['status', '--porcelain']);
+    if (status.trim()) {
+        throw new Error('Cannot publish: working tree is not clean');
+    }
+    let remoteUrl = '';
+    try {
+        remoteUrl = await git(options, directory, ['remote', 'get-url', 'esl']);
+    }
+    catch {
+        throw new Error('Cannot publish: the skill source has no esl remote; run esl upload first');
+    }
+    const identity = inferIdentityFromRemote(remoteUrl);
+    if (identity.startsWith('@local/')) {
+        throw new Error('@local/* skills use the local namespace and must be renamed to a stable namespace before publishing');
+    }
+    // A dry run stays entirely local: it validates the source and previews what
+    // would be released, without syncing the source or creating a Skill Release.
+    const head = options.dryRun
+        ? (await git(options, directory, ['rev-parse', 'HEAD'])).trim()
+        : await syncSource(options, directory, await requireFreshToken(options));
+    await verifyReleaseTag(options, directory, version, head);
+    const notes = await resolveReleaseNotes(options, directory);
+    if (options.dryRun) {
+        return {
+            dryRun: true,
+            name: identity,
+            version,
+            sourceCommit: head,
+            files: Object.keys(await collectSourceFiles(directory)).sort(),
+            notes
+        };
+    }
+    await assertNotOlderThanPublished(options, identity, version);
+    await confirmPublish(options, identity, version);
+    const fetchImpl = options.customFetch ?? fetch;
+    const { server } = await resolveNetworkConfig(options);
+    const authToken = await requireFreshToken(options);
+    const response = await fetchWithTimeout(fetchImpl, apiUrl(server, `/api/skills/${encodeURIComponent(identity)}/releases`), {
+        method: 'POST',
+        headers: {
+            Authorization: `token ${authToken}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            version,
+            sourceCommit: head,
+            releaseManifest: validation.data.releaseManifest,
+            files: await collectSourceFiles(directory),
+            notes
+        })
+    });
+    if (!response.ok) {
+        await requireOkResponse(response, 'Failed to publish Skill Release');
+    }
+    return response.json();
+}
+async function collectSourceFiles(directory) {
+    const files = {};
+    async function visit(current) {
+        for (const entry of await fs.readdir(current, { withFileTypes: true })) {
+            if (entry.name === '.git')
+                continue;
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await visit(fullPath);
+            }
+            else {
+                files[path.relative(directory, fullPath).replaceAll(path.sep, '/')] = await fs.readFile(fullPath, 'utf8');
+            }
+        }
+    }
+    await visit(directory);
+    return files;
+}
+async function git(options, directory, args) {
+    const execFileAsync = options.execFileAsync ?? defaultExecFileAsync;
+    const result = await execFileAsync('git', args, { cwd: directory });
+    return result.stdout;
+}
+async function resolveReleaseNotes(options, directory) {
+    if (options.message) {
+        return options.message;
+    }
+    const collected = await collectChangesSinceLastTag(options, directory);
+    if (options.noInput || options.noteInput) {
+        if (options.noteInput) {
+            return (await options.noteInput(collected)).trim() || collected;
+        }
+        return collected;
+    }
+    if (!isInteractive()) {
+        return collected;
+    }
+    if (collected) {
+        console.log(`\nChanges since the last release:\n${collected}\n`);
+    }
+    const answer = (await readText(collected ? 'Release note (Enter to use the above): ' : 'Release note (optional): ')).trim();
+    return answer || collected;
+}
+async function collectChangesSinceLastTag(options, directory) {
+    let lastTag = '';
+    try {
+        lastTag = (await git(options, directory, ['describe', '--tags', '--abbrev=0'])).trim();
+    }
+    catch {
+        lastTag = '';
+    }
+    try {
+        const range = lastTag ? `${lastTag}..HEAD` : 'HEAD';
+        const subjects = (await git(options, directory, ['log', range, '--format=%s'])).trim();
+        if (!subjects) {
+            return '';
+        }
+        return subjects.split('\n').map((subject) => `- ${subject.trim()}`).join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Guard against publishing a version older than what is already released, which
+ * would silently burn a version number on an immutable release. Releasing an
+ * older line on purpose (a backport) stays possible through --force, which skips
+ * this check along with the confirmation prompt.
+ */
+async function assertNotOlderThanPublished(options, identity, version) {
+    if (options.force) {
+        return;
+    }
+    const fetchImpl = options.customFetch ?? fetch;
+    const { server } = await resolveNetworkConfig(options);
+    const authToken = await requireFreshToken(options);
+    let published = [];
+    try {
+        const response = await fetchWithTimeout(fetchImpl, apiUrl(server, `/api/skills/${encodeURIComponent(identity)}`), { headers: { Authorization: `token ${authToken}` } });
+        if (!response.ok) {
+            return; // best effort: an unreachable listing must not block a release
+        }
+        const info = (await response.json());
+        published = info.versions ?? [];
+    }
+    catch {
+        return;
+    }
+    const highest = highestStableVersion(published);
+    if (highest && semver.lt(version, highest)) {
+        throw new Error(`Cannot publish ${version}: ${highest} is already published and versions must move forward. Bump with \`esl version\` instead, or pass --force to release the older version on purpose.`);
+    }
+}
+/**
+ * Bring the server source up to date with the local branch before releasing, and
+ * return the commit that will be released. An already-synced source is left
+ * untouched (no push); a source that is behind is rebased and then pushed.
+ */
+async function syncSource(options, directory, authToken) {
+    const execFileAsync = options.execFileAsync ?? defaultExecFileAsync;
+    const authHeader = gitAuthHeaderConfig(authToken);
+    try {
+        await execFileAsync('git', ['-c', authHeader, 'fetch', 'esl'], { cwd: directory });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Cannot publish: failed to read the server source. Check that you are logged in and have access to this skill. (${detail})`);
+    }
+    let remoteHead = '';
+    try {
+        remoteHead = (await git(options, directory, ['rev-parse', 'esl/main'])).trim();
+    }
+    catch {
+        remoteHead = ''; // the server source has no commits yet
+    }
+    if ((await git(options, directory, ['rev-parse', 'HEAD'])).trim() === remoteHead) {
+        return remoteHead;
+    }
+    const behind = parseInt((await git(options, directory, ['rev-list', '--count', 'HEAD..esl/main'])).trim() || '0', 10);
+    if (behind > 0) {
+        try {
+            await execFileAsync('git', ['rebase', 'esl/main'], { cwd: directory });
+        }
+        catch {
+            throw new Error('Cannot publish: the server source has newer commits and rebasing onto them hit a conflict. Resolve the conflicted files, finish the rebase, then run esl publish again.');
+        }
+    }
+    try {
+        await execFileAsync('git', ['-c', authHeader, 'push', 'esl', 'HEAD:main'], { cwd: directory });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Cannot publish: failed to push the source to the server. (${detail})`);
+    }
+    return (await git(options, directory, ['rev-parse', 'HEAD'])).trim();
+}
+async function verifyReleaseTag(options, directory, version, head) {
+    const tag = `v${version}`;
+    try {
+        const tagCommit = (await git(options, directory, ['rev-list', '-n', '1', tag])).trim();
+        if (tagCommit !== head) {
+            throw new Error(`Tag ${tag} points to a different commit than HEAD. Run \`esl version\` on the commit you want to release.`);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes('unknown revision') || msg.includes('bad revision') || msg.includes('fatal')) {
+            throw new Error(`No release tag ${tag} found on HEAD. Run \`esl version <release>\` to bump the version and create the tag before publishing.`);
+        }
+        throw error;
+    }
+}
+function inferIdentityFromRemote(remoteUrl) {
+    const match = remoteUrl.trim().match(/\/git\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (!match) {
+        throw new Error('Cannot determine Skill Identity from the esl remote URL');
+    }
+    return `@${match[1]}/${match[2]}`;
+}
+async function confirmPublish(options, name, version) {
+    if (options.force) {
+        return;
+    }
+    if (options.noInput) {
+        throw new Error('Publishing requires confirmation; pass --force to skip it');
+    }
+    const question = `Publish ${name} v${version} to the ESL Server? `;
+    const confirmFn = options.confirmInput ??
+        (async () => {
+            if (!isInteractive()) {
+                throw new Error('Publishing requires confirmation in an interactive terminal; pass --force to skip');
+            }
+            return confirm(question);
+        });
+    const confirmed = await confirmFn();
+    if (!confirmed) {
+        throw new Error('Publish cancelled');
+    }
+}

package/dist/commands/release-delete.d.ts

@@ -0,0 +1,21 @@
+import { type NetworkCommandOptions } from './network-options.js';
+export interface ReleaseDeleteOptions extends NetworkCommandOptions {
+    /** Must equal the version being deleted — the server's explicit-confirmation contract. */
+    confirm?: string;
+    /** Overrides the dependency-pinning guard; requires a platform administrator on the server. */
+    force?: boolean;
+}
+export interface DeletedRelease {
+    deleted: boolean;
+    name: string;
+    version: string;
+    dependents: string[];
+}
+/**
+ * Delete a single Skill Release (CONTEXT:单版本删除). The version number stays burned,
+ * so this is a deliberate, hard-to-undo action: the caller has to echo the version.
+ *
+ * A release other skills pin through their Release Dependency Lock is refused unless
+ * `force` is passed, and the server only accepts that from a platform administrator.
+ */
+export declare function executeReleaseDelete(identity: string, version: string, options?: ReleaseDeleteOptions): Promise<DeletedRelease>;