gaoding-cli 1.0.0-alpha.5

package/dist/src/update/notifier.js

@@ -0,0 +1,59 @@
+import chalk from "chalk";
+import { buildUpdateCommand } from "./install-source.js";
+import { checkForUpdate } from "./update-checker.js";
+export async function maybeNotifyUpdate(command) {
+    if (!shouldNotify(command))
+        return;
+    try {
+        const info = await checkForUpdate({ timeoutMs: 1200 });
+        if (!info.update_available)
+            return;
+        const updateCommand = buildUpdateCommand(info.latest_version, info.install_source);
+        const message = [
+            "",
+            chalk.yellow(`发现 gd-cli 新版本 ${info.latest_version}，当前版本 ${info.current_version}`),
+            `升级: ${chalk.cyan(updateCommand.display)}`,
+            chalk.dim("关闭提醒: export GD_CLI_NO_UPDATE_NOTIFIER=1"),
+            "",
+        ].join("\n");
+        process.stderr.write(message);
+    }
+    catch {
+        // 升级提醒不能影响业务命令。
+    }
+}
+function shouldNotify(command) {
+    if (!process.stderr.isTTY)
+        return false;
+    if (process.env.CI)
+        return false;
+    if (process.env.GD_CLI_NO_UPDATE_NOTIFIER === "1")
+        return false;
+    if (process.env.NO_UPDATE_NOTIFIER === "1")
+        return false;
+    const root = rootCommand(command);
+    const format = root.opts().format;
+    if (format === "json")
+        return false;
+    const names = commandPath(command);
+    if (names.includes("update"))
+        return false;
+    return true;
+}
+function commandPath(command) {
+    const names = [];
+    let cur = command;
+    while (cur) {
+        const name = cur.name();
+        if (name)
+            names.unshift(name);
+        cur = cur.parent;
+    }
+    return names;
+}
+function rootCommand(command) {
+    let cur = command;
+    while (cur.parent)
+        cur = cur.parent;
+    return cur;
+}

package/dist/src/update/update-checker.d.ts

@@ -0,0 +1,22 @@
+import { type InstallSource } from "./install-source.js";
+export interface UpdateInfo {
+    package_name: string;
+    current_version: string;
+    latest_version: string;
+    channel: string;
+    update_available: boolean;
+    registry: string;
+    checked_at: string;
+    install_source: InstallSource;
+    from_cache: boolean;
+    unavailable_reason?: string;
+}
+interface CheckOptions {
+    channel?: string;
+    force?: boolean;
+    timeoutMs?: number;
+    ttlMs?: number;
+}
+export declare function checkForUpdate(options?: CheckOptions): Promise<UpdateInfo>;
+export declare function clearUpdateCache(): void;
+export {};

package/dist/src/update/update-checker.js

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CLI_PACKAGE_NAME, CLI_VERSION, GD_DIR } from "../utils/config.js";
+import { ensureCredentialDir, ensureCredentialFile } from "../utils/credential-permissions.js";
+import { detectInstallSource } from "./install-source.js";
+import { isVersionGreater } from "./version.js";
+import { assertSafeHttpUrl } from "../utils/url-safety.js";
+const UPDATE_CACHE_FILE = path.join(GD_DIR, "update-check.json");
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+export async function checkForUpdate(options = {}) {
+    const channel = options.channel ?? process.env.GD_CLI_UPDATE_CHANNEL ?? "latest";
+    const registry = resolveRegistry();
+    const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    const cached = options.force ? null : readCache();
+    const installSource = detectInstallSource();
+    if (cached &&
+        cached.channel === channel &&
+        cached.registry === registry &&
+        cached.current_version === CLI_VERSION &&
+        Date.now() - new Date(cached.checked_at).getTime() < ttlMs) {
+        return {
+            ...cached,
+            install_source: installSource,
+            from_cache: true,
+        };
+    }
+    const metadata = await fetchPackageMetadata(registry, options.timeoutMs);
+    if (!metadata) {
+        const info = {
+            package_name: CLI_PACKAGE_NAME,
+            current_version: CLI_VERSION,
+            latest_version: CLI_VERSION,
+            channel,
+            update_available: false,
+            registry,
+            checked_at: new Date().toISOString(),
+            install_source: installSource,
+            from_cache: false,
+            unavailable_reason: "package_not_found",
+        };
+        writeCache(info);
+        return info;
+    }
+    const latestVersion = metadata["dist-tags"]?.[channel];
+    if (!latestVersion) {
+        throw new Error(`npm registry 未找到 dist-tag: ${channel}`);
+    }
+    const info = {
+        package_name: CLI_PACKAGE_NAME,
+        current_version: CLI_VERSION,
+        latest_version: latestVersion,
+        channel,
+        update_available: isVersionGreater(latestVersion, CLI_VERSION),
+        registry,
+        checked_at: new Date().toISOString(),
+        install_source: installSource,
+        from_cache: false,
+    };
+    writeCache(info);
+    return info;
+}
+export function clearUpdateCache() {
+    if (fs.existsSync(UPDATE_CACHE_FILE))
+        fs.unlinkSync(UPDATE_CACHE_FILE);
+}
+function resolveRegistry() {
+    const raw = (process.env.GD_CLI_REGISTRY ??
+        process.env.npm_config_registry ??
+        process.env.NPM_CONFIG_REGISTRY ??
+        DEFAULT_REGISTRY).replace(/\/$/, "");
+    return assertSafeHttpUrl(raw, { context: "npm registry" }).replace(/\/$/, "");
+}
+async function fetchPackageMetadata(registry, timeoutMs = 5000) {
+    const packagePath = encodeURIComponent(CLI_PACKAGE_NAME).replace("%2F", "%2f");
+    const url = `${registry}/${packagePath}`;
+    const response = await fetch(url, {
+        headers: {
+            Accept: "application/vnd.npm.install-v1+json, application/json",
+        },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (response.status === 404) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`检查版本失败: ${response.status} ${response.statusText}`);
+    }
+    return (await response.json());
+}
+function readCache() {
+    try {
+        if (!fs.existsSync(UPDATE_CACHE_FILE))
+            return null;
+        ensureCredentialDir(GD_DIR);
+        ensureCredentialFile(UPDATE_CACHE_FILE);
+        const data = JSON.parse(fs.readFileSync(UPDATE_CACHE_FILE, "utf8"));
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(info) {
+    ensureCredentialDir(GD_DIR);
+    fs.writeFileSync(UPDATE_CACHE_FILE, `${JSON.stringify(info, null, 2)}\n`, "utf8");
+    ensureCredentialFile(UPDATE_CACHE_FILE);
+}

package/dist/src/update/version.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string[];
+}
+export declare function parseVersion(version: string): ParsedVersion | null;
+export declare function compareVersions(left: string, right: string): number;
+export declare function isVersionGreater(candidate: string, current: string): boolean;

package/dist/src/update/version.js

@@ -0,0 +1,52 @@
+export function parseVersion(version) {
+    const trimmed = version.trim().replace(/^v/, "");
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.+)?$/.exec(trimmed);
+    if (!match)
+        return null;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4] ? match[4].split(".") : [],
+    };
+}
+export function compareVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return left.localeCompare(right);
+    for (const key of ["major", "minor", "patch"]) {
+        if (a[key] !== b[key])
+            return a[key] > b[key] ? 1 : -1;
+    }
+    if (a.prerelease.length === 0 && b.prerelease.length === 0)
+        return 0;
+    if (a.prerelease.length === 0)
+        return 1;
+    if (b.prerelease.length === 0)
+        return -1;
+    const len = Math.max(a.prerelease.length, b.prerelease.length);
+    for (let i = 0; i < len; i += 1) {
+        const ai = a.prerelease[i];
+        const bi = b.prerelease[i];
+        if (ai === undefined)
+            return -1;
+        if (bi === undefined)
+            return 1;
+        if (ai === bi)
+            continue;
+        const an = /^\d+$/.test(ai) ? Number(ai) : null;
+        const bn = /^\d+$/.test(bi) ? Number(bi) : null;
+        if (an !== null && bn !== null)
+            return an > bn ? 1 : -1;
+        if (an !== null)
+            return -1;
+        if (bn !== null)
+            return 1;
+        return ai > bi ? 1 : -1;
+    }
+    return 0;
+}
+export function isVersionGreater(candidate, current) {
+    return compareVersions(candidate, current) > 0;
+}

package/dist/src/utils/agent-skill-installer.d.ts

@@ -0,0 +1,57 @@
+export type AgentSkillTargetId = "universal" | "claude-code" | "codex" | "cursor" | "opencode" | "openclaw" | "workbuddy";
+export type AgentSkillStatus = "installed" | "outdated" | "missing" | "broken" | "conflict";
+export type AgentSkillMode = "canonical" | "symlink" | "junction" | "copy";
+export interface AgentSkillTarget {
+    id: AgentSkillTargetId;
+    name: string;
+    path: string;
+    detected: boolean;
+}
+export interface AgentSkillTargetResult {
+    agent: AgentSkillTargetId;
+    path: string;
+    status: AgentSkillStatus;
+    mode?: AgentSkillMode;
+    changed: boolean;
+    reason?: string;
+}
+export interface AgentSkillResult {
+    skill: "gd-cli";
+    version: string;
+    canonical_path: string;
+    changed: boolean;
+    restart_required: boolean;
+    targets: AgentSkillTargetResult[];
+}
+export declare class AgentSkillOperationError extends Error {
+    readonly result: AgentSkillResult;
+    constructor(message: string, result: AgentSkillResult);
+}
+export interface AgentSkillInstallerOptions {
+    homeDir?: string;
+    env?: NodeJS.ProcessEnv;
+    packageRoot?: string;
+    platform?: NodeJS.Platform;
+}
+export declare class AgentSkillInstaller {
+    private readonly homeDir;
+    private readonly env;
+    private readonly platform;
+    private readonly sourceDir;
+    constructor(options?: AgentSkillInstallerOptions);
+    listTargets(): AgentSkillTarget[];
+    detectedTargets(): AgentSkillTargetId[];
+    status(): AgentSkillResult;
+    install(agents: AgentSkillTargetId[]): AgentSkillResult;
+    update(): AgentSkillResult;
+    uninstall(agents: AgentSkillTargetId[]): AgentSkillResult;
+    private target;
+    private targetById;
+    private targets;
+    private inspect;
+    private result;
+    private replaceManagedDirectory;
+    private createLinkOrCopy;
+    private linkMode;
+    private ioError;
+}