@foxian/esl 0.1.0

package/dist/commands/admin.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs/promises';
+import { requireOkResponse } from '../api-error.js';
+import { isInteractive, readHidden } from '../prompt.js';
+import { apiUrl, fetchWithTimeout, requireConfigured, requireFreshToken, resolveNetworkConfig } from './network-options.js';
+export async function executeChangeOwnPassword(options) {
+    const fetchImpl = options.customFetch ?? fetch;
+    const { server, token } = await resolveAdminAuth(options);
+    const currentPassword = await resolveCurrentPassword(options);
+    const newPassword = await resolveNewPassword(options);
+    const res = await fetchWithTimeout(fetchImpl, apiUrl(server, '/api/auth/password'), {
+        method: 'POST',
+        headers: {
+            Authorization: `token ${token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ oldPassword: currentPassword, newPassword })
+    });
+    if (!res.ok) {
+        await requireOkResponse(res, 'Failed to change password');
+    }
+}
+async function resolveNewPassword(options) {
+    if (options.passwordFile) {
+        const password = (await fs.readFile(options.passwordFile, 'utf8')).trim();
+        if (!password) {
+            throw new Error(`Password file ${options.passwordFile} is empty`);
+        }
+        return password;
+    }
+    if (options.noInput) {
+        if (options.readInput) {
+            return readPasswordFromInput(options.readInput);
+        }
+        throw new Error('A new password is required; pass --password-file or pipe a password on stdin when using --no-input');
+    }
+    if (options.readInput) {
+        return readPasswordFromInput(options.readInput);
+    }
+    if (options.readPassword) {
+        return readConfirmedPassword(options.readPassword);
+    }
+    if (!isInteractive()) {
+        throw new Error('A new password is required; run interactively, pass --password-file, or pipe a password on stdin');
+    }
+    return readConfirmedPassword((prompt) => readHidden(prompt));
+}
+async function readPasswordFromInput(readInput) {
+    const password = (await readInput()).trim();
+    if (!password) {
+        throw new Error('Password is required');
+    }
+    return password;
+}
+async function resolveCurrentPassword(options) {
+    if (options.currentPasswordFile) {
+        const password = (await fs.readFile(options.currentPasswordFile, 'utf8')).trim();
+        if (!password) {
+            throw new Error(`Password file ${options.currentPasswordFile} is empty`);
+        }
+        return password;
+    }
+    if (options.noInput) {
+        if (options.readInput) {
+            return readPasswordFromInput(options.readInput);
+        }
+        throw new Error('A current password is required; pass --current-password-file or pipe a password on stdin when using --no-input');
+    }
+    if (options.readInput) {
+        return readPasswordFromInput(options.readInput);
+    }
+    if (options.readPassword) {
+        return (await options.readPassword('Current password: ')).trim();
+    }
+    if (!isInteractive()) {
+        throw new Error('A current password is required; run interactively or pass --current-password-file');
+    }
+    return (await readHidden('Current password: ')).trim();
+}
+async function readConfirmedPassword(readPassword) {
+    const password = (await readPassword('New password: ')).trim();
+    if (!password) {
+        throw new Error('Password is required');
+    }
+    const confirmPassword = (await readPassword('Confirm new password: ')).trim();
+    if (password !== confirmPassword) {
+        throw new Error('Passwords do not match');
+    }
+    return password;
+}
+async function resolveAdminAuth(options) {
+    const config = await resolveNetworkConfig(options);
+    return {
+        server: config.server,
+        token: requireConfigured(await requireFreshToken(options), 'token')
+    };
+}

package/dist/commands/clone.d.ts

@@ -0,0 +1,10 @@
+import { execFile } from 'node:child_process';
+import { type NetworkCommandOptions } from './network-options.js';
+declare const defaultExecFileAsync: typeof execFile.__promisify__;
+export interface CloneOptions extends NetworkCommandOptions {
+    target?: string;
+    cwd?: string;
+    execFileAsync?: typeof defaultExecFileAsync;
+}
+export declare function executeClone(name: string, options?: CloneOptions): Promise<string>;
+export {};

package/dist/commands/clone.js

@@ -0,0 +1,21 @@
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { parseSkillName } from '../vendor/core/index.js';
+import { authenticatedGitUrl, requireConfigured, resolveNetworkConfig } from './network-options.js';
+import { executeInfo } from './info.js';
+const defaultExecFileAsync = promisify(execFile);
+export async function executeClone(name, options = {}) {
+    const execFileAsync = options.execFileAsync ?? defaultExecFileAsync;
+    const { gitBase, token } = await resolveNetworkConfig(options);
+    const gitHttpBase = requireConfigured(gitBase, 'git-base');
+    const authToken = requireConfigured(token, 'token');
+    const info = await executeInfo(name, options);
+    const repoPath = requireConfigured(info.gitRepoPath, 'gitRepoPath');
+    const remoteUrl = authenticatedGitUrl(gitHttpBase, authToken, repoPath);
+    const { skillName } = parseSkillName(name);
+    const cwd = options.cwd ?? process.cwd();
+    const targetDir = options.target ?? path.join(cwd, skillName);
+    await execFileAsync('git', ['clone', remoteUrl, targetDir]);
+    return targetDir;
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,8 @@
+import { type LocalStoreOptions } from '@esl/core';
+export interface ConfigCommandOptions extends LocalStoreOptions {
+    server?: string;
+}
+export declare function executeSetServer(url: string, options?: LocalStoreOptions): Promise<{
+    server: string;
+}>;
+export declare function resolveServer(options?: ConfigCommandOptions): Promise<string>;

package/dist/commands/config.js

@@ -0,0 +1,19 @@
+import { loadConfig, saveConfig } from '../vendor/core/index.js';
+export async function executeSetServer(url, options = {}) {
+    const config = await saveConfig({ server: url }, { homeDir: options.homeDir });
+    return { server: config.server };
+}
+export async function resolveServer(options = {}) {
+    if (options.server) {
+        return options.server;
+    }
+    const fromEnv = process.env.ESL_SERVER;
+    if (fromEnv) {
+        return fromEnv;
+    }
+    const config = await loadConfig({ homeDir: options.homeDir });
+    if (!config.server) {
+        throw new Error('Missing server; run esl config set-server <url> or pass --server');
+    }
+    return config.server;
+}

package/dist/commands/delete.d.ts

@@ -0,0 +1,13 @@
+import { type NetworkCommandOptions } from './network-options.js';
+export interface DeleteOptions extends NetworkCommandOptions {
+    yes?: boolean;
+    noInput?: boolean;
+    confirmInput?: () => Promise<boolean>;
+}
+export interface DeletedSkill {
+    deleted: boolean;
+    name: string;
+    skillId?: string;
+    releasesRemoved?: number;
+}
+export declare function executeDelete(identity: string, options: DeleteOptions): Promise<DeletedSkill>;

package/dist/commands/delete.js

@@ -0,0 +1,51 @@
+import { parseSkillName, isBuiltinIdentity } from '../vendor/core/index.js';
+import { apiUrl, fetchWithTimeout, requireFreshToken, resolveNetworkConfig } from './network-options.js';
+import { confirm, isInteractive, readText } from '../prompt.js';
+export async function executeDelete(identity, options) {
+    if (isBuiltinIdentity(identity)) {
+        throw new Error(`Unknown built-in skill: ${identity}; built-in skills cannot be deleted`);
+    }
+    await confirmDelete(identity, options);
+    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)}/delete`), {
+        method: 'POST',
+        headers: {
+            Authorization: `token ${token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ confirm: identity })
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to delete skill: ${await response.text()}`);
+    }
+    return response.json();
+}
+async function confirmDelete(identity, options) {
+    if (options.yes) {
+        return;
+    }
+    if (options.noInput) {
+        throw new Error('Deleting a skill requires confirmation; pass --yes to skip it');
+    }
+    const confirmFn = options.confirmInput ??
+        (async () => {
+            if (!isInteractive()) {
+                throw new Error('Deleting a skill requires confirmation in an interactive terminal; pass --yes to skip');
+            }
+            // Double confirmation: an explicit yes, then retyping the full identity so
+            // accidental deletion cannot be triggered by a stray "y".
+            const first = await confirm(`Permanently delete ${identity}? This cannot be undone. [y/N] `);
+            if (!first) {
+                return false;
+            }
+            const typed = (await readText(`Type "${identity}" to confirm deletion: `)).trim();
+            return typed === identity;
+        });
+    const confirmed = await confirmFn();
+    if (!confirmed) {
+        throw new Error('Delete cancelled');
+    }
+}

package/dist/commands/deprecate.d.ts

@@ -0,0 +1,16 @@
+import { type NetworkCommandOptions } from './network-options.js';
+export interface DeprecateOptions extends NetworkCommandOptions {
+    /** The warning shown to anyone installing this release; an empty message clears the mark. */
+    message?: string;
+}
+export interface DeprecatedRelease {
+    skillName: string;
+    version: string;
+    deprecatedMessage?: string | null;
+}
+/**
+ * Mark a published Skill Release as deprecated (npm deprecate's counterpart), or
+ * clear the mark with an empty message. The release stays installable — it just
+ * carries a warning.
+ */
+export declare function executeDeprecate(identity: string, version: string, options?: DeprecateOptions): Promise<DeprecatedRelease>;

package/dist/commands/deprecate.js

@@ -0,0 +1,29 @@
+import { isBuiltinIdentity, parseSkillName } from '../vendor/core/index.js';
+import { requireOkResponse } from '../api-error.js';
+import { apiUrl, fetchWithTimeout, requireFreshToken, resolveNetworkConfig } from './network-options.js';
+/**
+ * Mark a published Skill Release as deprecated (npm deprecate's counterpart), or
+ * clear the mark with an empty message. The release stays installable — it just
+ * carries a warning.
+ */
+export async function executeDeprecate(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)}/deprecate`), {
+        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 the release deprecation');
+    }
+    return response.json();
+}

package/dist/commands/import.d.ts

@@ -0,0 +1,14 @@
+export interface ImportOptions {
+    namespace?: string;
+    noAdapt?: boolean;
+    projectRoot?: string;
+    homeDir?: string;
+    author?: string;
+}
+export interface ImportResult {
+    skillName: string;
+    sourceDir: string;
+    targetDir: string;
+    createdSkillJson: boolean;
+}
+export declare function executeImport(sourcePath: string, options?: ImportOptions): Promise<ImportResult>;

package/dist/commands/import.js

@@ -0,0 +1,21 @@
+import path from 'node:path';
+import { prepareSkillImport } from '../vendor/core/index.js';
+import { executeInstall } from './install.js';
+export async function executeImport(sourcePath, options = {}) {
+    const sourceDir = path.resolve(sourcePath);
+    const prepared = await prepareSkillImport(sourceDir, {
+        namespace: options.namespace,
+        author: options.author
+    });
+    const targetDir = await executeInstall(prepared.directory, {
+        projectRoot: options.projectRoot,
+        homeDir: options.homeDir,
+        noAdapt: options.noAdapt
+    });
+    return {
+        skillName: prepared.skillName,
+        sourceDir: prepared.directory,
+        targetDir,
+        createdSkillJson: prepared.createdSkillJson
+    };
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,28 @@
+import { type NetworkCommandOptions } from './network-options.js';
+export interface SkillInfo {
+    name: string;
+    /** 对外当前显示名（ADR-0048）：曾发布取最近 Release 快照，否则取 upload 同步值。 */
+    displayName?: string;
+    description?: string;
+    createdBy?: string;
+    owner?: string;
+    maintainers?: string[];
+    versions?: string[];
+    gitRepoPath?: string;
+    cloneUrl?: string;
+    publishedPackage?: boolean;
+    skillId?: string;
+    status?: string;
+    packageUrl?: string;
+    releases?: Array<{
+        version: string;
+        checksum: string;
+        packageUrl?: string;
+        /** Present when the release is deprecated: the warning shown on install. */
+        deprecatedMessage?: string | null;
+    }>;
+    currentName?: string;
+    oldName?: string;
+}
+export declare function executeInfo(name: string, options?: NetworkCommandOptions): Promise<SkillInfo>;
+export declare function formatSkillInfo(info: SkillInfo): string;

package/dist/commands/info.js

@@ -0,0 +1,69 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { apiUrl, fetchWithTimeout, resolveOptionalFreshToken, withAuthGuidanceIfForbidden, resolveNetworkConfig } from './network-options.js';
+import { isBuiltinIdentity, loadBuiltinPackageOrThrow, sortVersionsDescending } from '../vendor/core/index.js';
+import { resolveBuiltinDir } from '../builtin-dir.js';
+import { ApiError } from '../api-error.js';
+export async function executeInfo(name, options = {}) {
+    if (isBuiltinIdentity(name)) {
+        return infoFromBuiltin(name, options);
+    }
+    const fetchImpl = options.customFetch ?? fetch;
+    const server = options.server ?? (await resolveNetworkConfig(options)).server;
+    // 存在有效登录态时随请求携带 Skill User Token，private 技能对其维护账号可见；
+    // public 技能匿名也能访问。
+    const token = await resolveOptionalFreshToken({ homeDir: options.homeDir });
+    const res = await fetchWithTimeout(fetchImpl, apiUrl(server, `/api/skills/${encodeURIComponent(name)}`), { headers: token ? { Authorization: `token ${token}` } : {} });
+    if (!res.ok && res.status !== 301) {
+        const err = await res.text();
+        const message = `Failed to fetch skill info: ${err}`;
+        try {
+            const apiError = new ApiError(res.status, message, JSON.parse(err));
+            apiError.message = withAuthGuidanceIfForbidden(res.status, message);
+            throw apiError;
+        }
+        catch (error) {
+            if (error instanceof ApiError) {
+                throw error;
+            }
+        }
+        throw new Error(withAuthGuidanceIfForbidden(res.status, message));
+    }
+    const info = (await res.json());
+    if (res.status !== 301 || !info.currentName) {
+        return info;
+    }
+    const current = await executeInfo(info.currentName, options);
+    return {
+        ...current,
+        oldName: name,
+        currentName: info.currentName
+    };
+}
+async function infoFromBuiltin(name, options) {
+    const builtinDir = options.builtinDir ?? resolveBuiltinDir();
+    const builtin = await loadBuiltinPackageOrThrow(builtinDir, name);
+    const skillJson = JSON.parse(await fs.readFile(path.join(builtin.directory, 'skill.json'), 'utf8'));
+    return {
+        name,
+        description: skillJson.description,
+        versions: [builtin.version]
+    };
+}
+export function formatSkillInfo(info) {
+    const lines = [
+        info.displayName && info.displayName !== info.name
+            ? `Name: ${info.displayName} (${info.name})`
+            : `Name: ${info.name}`
+    ];
+    if (info.description) {
+        lines.push(`Description: ${info.description}`);
+    }
+    if (info.versions && info.versions.length > 0) {
+        lines.push(`Versions: ${sortVersionsDescending(info.versions).join(', ')}`);
+    }
+    if (info.gitRepoPath) {
+        lines.push(`Repository: ${info.gitRepoPath}`);
+    }
+    return lines.join('\n');
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,28 @@
+import { type LocalStoreOptions, type ToolName } from '@esl/core';
+export interface InitOptions extends LocalStoreOptions {
+    /** Skill directory to fill in (created when missing). Defaults to the current directory. */
+    directory?: string;
+    /** Skill short name for a generated SKILL.md. Defaults to the directory basename. */
+    name?: string;
+    /** Namespace for release.json: "personal" (default) or an organization name. */
+    namespace?: string;
+    runGitInit?: boolean;
+    license?: string;
+    keywords?: string[];
+    description?: string;
+    /** release.json displayName；默认按短名 Title Case 生成种子（ADR-0048）。 */
+    displayName?: string;
+    /** Skips every prompt and writes the missing artifacts as-is. */
+    noInput?: boolean;
+    /** Injected by tests in place of the interactive prompt. */
+    promptText?: (question: string, fallback: string) => Promise<string>;
+    /** Injected by tests in place of the real fetch for the namespace menu. */
+    customFetch?: typeof fetch;
+    /** Emits a structured interaction request instead of reading from the terminal. */
+    agentInteraction?: boolean;
+    /** AI 工具标识（来自 --agent-tool），用于在交互请求中给出宿主专属提示。 */
+    agentTool?: ToolName;
+    /** Injected by tests that need a stable interaction request identifier. */
+    interactionRequestId?: string;
+}
+export declare function executeInit(options?: InitOptions): Promise<string>;