@actiondock/core 2.0.12 → 2.2.1

package/dist/doctor/doctor.js

@@ -0,0 +1,613 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { ActionResolver } from "../catalog/action-resolver.js";
+import { discoverActionFiles, findProjectRoot, loadActions, loadPlaybooks, loadProjectConfig } from "../project/loader.js";
+import { loadManifest, MANIFEST_FILE_NAME } from "../project/manifest.js";
+import { getRegistryStatus, listLinkedPackages, resolvePackageRoot } from "../registry/registry.js";
+import { createGlobalStorage, createStorage, resolveDatabasePath } from "../storage/index.js";
+import { findExecutable, getActionDockHome } from "../utils/index.js";
+function compareSemver(v1, v2) {
+    const p1 = v1.replace(/^v/, "").split(".").map(Number);
+    const p2 = v2.replace(/^v/, "").split(".").map(Number);
+    for (let i = 0; i < Math.max(p1.length, p2.length); i++) {
+        const num1 = p1[i] || 0;
+        const num2 = p2[i] || 0;
+        if (num1 > num2)
+            return 1;
+        if (num1 < num2)
+            return -1;
+    }
+    return 0;
+}
+export async function runDoctorChecks(options) {
+    const cwd = options?.cwd || process.cwd();
+    const checks = [];
+    // 1. Check Node.js Runtime
+    const nodeVersion = process.versions.node;
+    if (nodeVersion) {
+        const isGte24 = compareSemver(nodeVersion, "24.12.0") >= 0;
+        checks.push({
+            id: "runtime.node",
+            category: "runtime",
+            name: "Node.js Runtime",
+            status: isGte24 ? "ok" : "warn",
+            message: `v${nodeVersion} (${isGte24 ? ">= 24.12.0 supported" : ">= 24.12.0 recommended"})`,
+            fix: isGte24 ? undefined : "Upgrade Node.js to v24.12.0 or higher",
+        });
+    }
+    // 2. Check Bun Runtime (Optional environment for cross-runtime compatibility testing)
+    const bunVersion = (typeof globalThis.Bun !== "undefined" && globalThis.Bun.version) || process.versions.bun;
+    if (bunVersion) {
+        checks.push({
+            id: "runtime.bun",
+            category: "runtime",
+            name: "Bun Runtime",
+            status: "ok",
+            message: `v${bunVersion} (available for cross-environment testing)`,
+        });
+    }
+    else {
+        checks.push({
+            id: "runtime.bun",
+            category: "runtime",
+            name: "Bun Runtime",
+            status: "ok",
+            message: "Bun runtime not detected (optional, used for cross-environment compatibility testing)",
+        });
+    }
+    // 3. Check CLI in PATH
+    const adPath = findExecutable("ad");
+    if (adPath) {
+        checks.push({
+            id: "runtime.cli",
+            category: "runtime",
+            name: "CLI Executable",
+            status: "ok",
+            message: `Found 'ad' in PATH at ${adPath}`,
+        });
+    }
+    else {
+        checks.push({
+            id: "runtime.cli",
+            category: "runtime",
+            name: "CLI Executable",
+            status: "warn",
+            message: "'ad' command not found in PATH",
+            fix: "Run 'npm install -g @actiondock/cli' or in SDK workspace run 'cd packages/cli && npm link'",
+        });
+    }
+    // 3. Check Global Storage
+    const globalHome = getActionDockHome(options?.customHome);
+    try {
+        const globalStorage = createGlobalStorage(options?.customHome);
+        await globalStorage.setConfig("_doctor_probe_", "ok");
+        await globalStorage.deleteConfig("_doctor_probe_");
+        globalStorage.close();
+        checks.push({
+            id: "storage.global",
+            category: "storage",
+            name: "Global Storage",
+            status: "ok",
+            message: `Global SQLite database verified at ${globalHome}`,
+        });
+    }
+    catch (err) {
+        checks.push({
+            id: "storage.global",
+            category: "storage",
+            name: "Global Storage",
+            status: "error",
+            message: `Failed to access global storage: ${err.message}`,
+            fix: `Ensure directory '${globalHome}' is writable`,
+        });
+    }
+    // 4. Check Global Registry Health
+    try {
+        const regStatus = getRegistryStatus(options?.customHome);
+        if (regStatus.staleCount > 0) {
+            checks.push({
+                id: "registry.global",
+                category: "registry",
+                name: "Global Registry",
+                status: "warn",
+                message: `${regStatus.totalPackagesCount} package(s), ${regStatus.workspaces.length} workspace(s), but ${regStatus.staleCount} stale path(s) detected`,
+                fix: "Run 'ad unlink --prune' to clean up stale entries from registry",
+            });
+        }
+        else {
+            checks.push({
+                id: "registry.global",
+                category: "registry",
+                name: "Global Registry",
+                status: "ok",
+                message: `${regStatus.totalPackagesCount} linked package(s), ${regStatus.workspaces.length} workspace(s) (0 stale)`,
+            });
+        }
+    }
+    catch (err) {
+        checks.push({
+            id: "registry.global",
+            category: "registry",
+            name: "Global Registry",
+            status: "error",
+            message: `Failed to read registry: ${err.message}`,
+        });
+    }
+    // 5. Check Linked Package Dependencies (node_modules completeness)
+    try {
+        let linkedList = listLinkedPackages(options?.customHome);
+        if (options?.packageAllowlist && options.packageAllowlist.length > 0) {
+            linkedList = linkedList.filter((pkg) => options.packageAllowlist.includes(pkg.id));
+        }
+        const missingNodeModules = [];
+        for (const pkg of linkedList) {
+            if (!existsSync(pkg.path))
+                continue;
+            const pkgJsonPath = join(pkg.path, "package.json");
+            if (!existsSync(pkgJsonPath))
+                continue;
+            try {
+                const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+                const hasDeps = (pkgJson.dependencies && Object.keys(pkgJson.dependencies).length > 0) ||
+                    (pkgJson.devDependencies && Object.keys(pkgJson.devDependencies).length > 0);
+                if (hasDeps && !existsSync(join(pkg.path, "node_modules"))) {
+                    missingNodeModules.push(pkg.id);
+                }
+            }
+            catch {
+                // 忽略异常 JSON
+            }
+        }
+        if (missingNodeModules.length > 0) {
+            checks.push({
+                id: "registry.dependencies",
+                category: "registry",
+                name: "Linked Package Dependencies",
+                status: "warn",
+                message: `${missingNodeModules.length} linked package(s) declare dependencies but miss node_modules: ${missingNodeModules.join(", ")}`,
+                fix: "Run 'npm install' in the affected package directories, or execute 'ad run' to auto-install",
+            });
+        }
+        else {
+            checks.push({
+                id: "registry.dependencies",
+                category: "registry",
+                name: "Linked Package Dependencies",
+                status: "ok",
+                message: linkedList.length > 0
+                    ? "All linked packages have dependencies installed"
+                    : "No linked packages requiring dependency verification",
+            });
+        }
+    }
+    catch {
+        // 忽略依赖检查异常
+    }
+    // 6. Check Cross-Package Uses Dependency Closure
+    try {
+        let linkedList = listLinkedPackages(options?.customHome);
+        if (options?.packageAllowlist && options.packageAllowlist.length > 0) {
+            linkedList = linkedList.filter((pkg) => options.packageAllowlist.includes(pkg.id));
+        }
+        let packagesToCheck = linkedList.map((p) => ({
+            id: p.id,
+            root: p.path,
+        }));
+        const curProjectRoot = options?.packageIdOrPath
+            ? resolvePackageRoot(options.packageIdOrPath, cwd, options?.customHome) || findProjectRoot(options.packageIdOrPath)
+            : findProjectRoot(cwd);
+        if (curProjectRoot && !packagesToCheck.some((p) => p.root === curProjectRoot)) {
+            try {
+                const cfg = loadProjectConfig(curProjectRoot);
+                packagesToCheck.push({ id: cfg.id, root: curProjectRoot });
+            }
+            catch {
+                // 忽略配置异常
+            }
+        }
+        if (options?.packageAllowlist && options.packageAllowlist.length > 0) {
+            packagesToCheck = packagesToCheck.filter((p) => options.packageAllowlist.includes(p.id));
+        }
+        const unresolvableUses = [];
+        for (const pkg of packagesToCheck) {
+            if (!existsSync(pkg.root))
+                continue;
+            const manifest = loadManifest(pkg.root);
+            if (!manifest || !manifest.actions)
+                continue;
+            for (const [actionId, actionEntry] of Object.entries(manifest.actions)) {
+                if (!Array.isArray(actionEntry.uses))
+                    continue;
+                for (const rawRef of actionEntry.uses) {
+                    if (typeof rawRef !== "string" || !rawRef.trim())
+                        continue;
+                    let parsed;
+                    try {
+                        parsed = ActionResolver.parseRef(rawRef);
+                    }
+                    catch {
+                        unresolvableUses.push(`${pkg.id}/${actionId} -> '${rawRef}'`);
+                        continue;
+                    }
+                    if (parsed.packageId) {
+                        const depRoot = resolvePackageRoot(parsed.packageId, pkg.root, options?.customHome);
+                        if (!depRoot || !existsSync(depRoot)) {
+                            unresolvableUses.push(`${pkg.id}/${actionId} -> '${rawRef}'`);
+                        }
+                    }
+                }
+            }
+        }
+        if (unresolvableUses.length > 0) {
+            checks.push({
+                id: "registry.uses_closure",
+                category: "registry",
+                name: "Cross-Package Uses Dependencies",
+                status: "warn",
+                message: `${unresolvableUses.length} unresolvable cross-package dependency reference(s) found in manifest uses: ${unresolvableUses.join(", ")}`,
+                fix: "Link missing packages with 'ad link', or correct unresolvable uses declarations",
+            });
+        }
+        else {
+            checks.push({
+                id: "registry.uses_closure",
+                category: "registry",
+                name: "Cross-Package Uses Dependencies",
+                status: "ok",
+                message: "All cross-package uses declarations in manifests resolved successfully",
+            });
+        }
+    }
+    catch {
+        // 忽略闭包检查异常
+    }
+    // 7. Check Project Context
+    let projectRoot = null;
+    if (options?.packageIdOrPath) {
+        projectRoot =
+            resolvePackageRoot(options.packageIdOrPath, cwd, options?.customHome) ||
+                findProjectRoot(options.packageIdOrPath);
+    }
+    else {
+        projectRoot = findProjectRoot(cwd);
+    }
+    let packageId;
+    if (projectRoot) {
+        try {
+            const config = loadProjectConfig(projectRoot);
+            if (options?.packageAllowlist &&
+                Array.isArray(options.packageAllowlist) &&
+                options.packageAllowlist.length > 0 &&
+                !options.packageAllowlist.includes(config.id)) {
+                projectRoot = null;
+            }
+        }
+        catch {
+            // 忽略预校验异常，交由后续详细诊断处理
+        }
+    }
+    if (projectRoot) {
+        try {
+            const config = loadProjectConfig(projectRoot);
+            packageId = config.id;
+            // Project Config Check
+            checks.push({
+                id: "project.config",
+                category: "project",
+                name: "Project Configuration",
+                status: "ok",
+                message: `Valid (${config.id} v${config.version})`,
+            });
+            // SDK Resolution Check
+            const hasSdkInNodeModules = existsSync(join(projectRoot, "node_modules", "@actiondock", "sdk")) ||
+                existsSync(join(projectRoot, "node_modules", "@actiondock", "sdk", "package.json"));
+            if (hasSdkInNodeModules) {
+                checks.push({
+                    id: "project.sdk",
+                    category: "project",
+                    name: "SDK Dependency",
+                    status: "ok",
+                    message: "Resolved @actiondock/sdk in node_modules",
+                });
+            }
+            else {
+                checks.push({
+                    id: "project.sdk",
+                    category: "project",
+                    name: "SDK Dependency",
+                    status: "warn",
+                    message: "@actiondock/sdk not found in project node_modules",
+                    fix: "Run 'npm link @actiondock/sdk' or 'npm install' in project directory",
+                });
+            }
+            // Project Runtime Database Check
+            const dbPath = resolveDatabasePath(config.id, { customHome: options?.customHome });
+            try {
+                const projectStorage = createStorage(config.id, { customHome: options?.customHome });
+                await projectStorage.setConfig("_doctor_probe_", "ok");
+                await projectStorage.deleteConfig("_doctor_probe_");
+                projectStorage.close();
+                checks.push({
+                    id: "project.storage",
+                    category: "project",
+                    name: "Project Database",
+                    status: "ok",
+                    message: `Database writable at ${dbPath}`,
+                });
+            }
+            catch (err) {
+                checks.push({
+                    id: "project.storage",
+                    category: "project",
+                    name: "Project Database",
+                    status: "error",
+                    message: `Failed to write project runtime database: ${err.message}`,
+                    fix: `Check write permissions for '${dirname(dbPath)}'`,
+                });
+            }
+            // Actions Check
+            try {
+                const manifest = loadManifest(projectRoot);
+                let actionsCount = 0;
+                if (manifest?.actions) {
+                    actionsCount = Object.keys(manifest.actions).length;
+                }
+                else {
+                    const actions = await loadActions(projectRoot, config.actionsDir, { autoInstall: false });
+                    actionsCount = actions.size;
+                }
+                if (actionsCount === 0) {
+                    checks.push({
+                        id: "project.actions",
+                        category: "project",
+                        name: "Actions",
+                        status: "warn",
+                        message: `No actions found in '${config.actionsDir || "actions"}'`,
+                        fix: "Run 'ad action new <id>' to create your first action",
+                    });
+                }
+                else {
+                    checks.push({
+                        id: "project.actions",
+                        category: "project",
+                        name: "Actions",
+                        status: "ok",
+                        message: `${actionsCount} action(s) valid and loaded`,
+                    });
+                }
+            }
+            catch (err) {
+                checks.push({
+                    id: "project.actions",
+                    category: "project",
+                    name: "Actions",
+                    status: "error",
+                    message: `Failed to load actions: ${err.message}`,
+                });
+            }
+            // Project Manifest Check (Lightweight Static Detection)
+            try {
+                const manifestPath = join(projectRoot, MANIFEST_FILE_NAME);
+                const manifest = loadManifest(projectRoot);
+                const actionFiles = discoverActionFiles(projectRoot, config.actionsDir || "actions");
+                if (!existsSync(manifestPath)) {
+                    if (actionFiles.length > 0) {
+                        checks.push({
+                            id: "project.manifest",
+                            category: "project",
+                            name: "Action Manifest",
+                            status: "warn",
+                            message: `${MANIFEST_FILE_NAME} not found (${actionFiles.length} action source file(s) exist)`,
+                            fix: "Run 'ad validate' to generate or check manifest",
+                        });
+                    }
+                }
+                else if (manifest && manifest.actions) {
+                    const missingFiles = Object.entries(manifest.actions)
+                        .filter(([_, item]) => !existsSync(join(projectRoot, item.entry)))
+                        .map(([id, item]) => `${id} (${item.entry})`);
+                    const manifestEntries = new Set(Object.values(manifest.actions).map((a) => a.entry.replace(/\\/g, "/")));
+                    const untracked = actionFiles
+                        .map((f) => relative(projectRoot, f).replace(/\\/g, "/"))
+                        .filter((rel) => !manifestEntries.has(rel));
+                    if (missingFiles.length > 0) {
+                        checks.push({
+                            id: "project.manifest",
+                            category: "project",
+                            name: "Action Manifest",
+                            status: "warn",
+                            message: `${missingFiles.length} action(s) in manifest point to missing files: ${missingFiles.join(", ")}`,
+                            fix: "Run 'ad validate' to check or update actiondock.json",
+                        });
+                    }
+                    else if (untracked.length > 0) {
+                        checks.push({
+                            id: "project.manifest",
+                            category: "project",
+                            name: "Action Manifest",
+                            status: "warn",
+                            message: `${untracked.length} action file(s) not declared in manifest: ${untracked.join(", ")}`,
+                            fix: "Run 'ad validate' to check or update actiondock.json",
+                        });
+                    }
+                    else {
+                        const manifestStat = statSync(manifestPath);
+                        const newerFiles = actionFiles.filter((f) => statSync(f).mtimeMs > manifestStat.mtimeMs + 2000);
+                        if (newerFiles.length > 0) {
+                            checks.push({
+                                id: "project.manifest",
+                                category: "project",
+                                name: "Action Manifest",
+                                status: "ok",
+                                message: `Manifest valid (Note: ${newerFiles.length} action file(s) modified after manifest; run 'ad validate' if definitions changed)`,
+                            });
+                        }
+                        else {
+                            checks.push({
+                                id: "project.manifest",
+                                category: "project",
+                                name: "Action Manifest",
+                                status: "ok",
+                                message: "Manifest synchronized with action files",
+                            });
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                checks.push({
+                    id: "project.manifest",
+                    category: "project",
+                    name: "Action Manifest",
+                    status: "error",
+                    message: `Failed to inspect manifest: ${err.message}`,
+                });
+            }
+            // Project Declared Files & Source Boundaries Check
+            try {
+                const declaredFiles = config.files || [];
+                const hasSrc = existsSync(join(projectRoot, "src"));
+                const hasLib = existsSync(join(projectRoot, "lib"));
+                if (declaredFiles.length > 0) {
+                    const missingDeclared = declaredFiles.filter((f) => !existsSync(join(projectRoot, f)));
+                    if (missingDeclared.length > 0) {
+                        checks.push({
+                            id: "project.files",
+                            category: "project",
+                            name: "Declared Files",
+                            status: "error",
+                            message: `${missingDeclared.length} path(s) declared in 'files' do not exist: ${missingDeclared.join(", ")}`,
+                            fix: `Verify and update 'files' in ${MANIFEST_FILE_NAME}`,
+                        });
+                    }
+                    else {
+                        checks.push({
+                            id: "project.files",
+                            category: "project",
+                            name: "Declared Files",
+                            status: "ok",
+                            message: `All ${declaredFiles.length} declared file/directory boundaries verified`,
+                        });
+                    }
+                }
+                else if (hasSrc || hasLib) {
+                    const actionFiles = discoverActionFiles(projectRoot, config.actionsDir || "actions");
+                    let hasReferenceToSrcOrLib = false;
+                    for (const actFile of actionFiles) {
+                        try {
+                            const src = readFileSync(actFile, "utf-8");
+                            if (/['"](?:\.\.\/(?:src|lib)|\.\/(?:src|lib))[^'"]*['"]/.test(src)) {
+                                hasReferenceToSrcOrLib = true;
+                                break;
+                            }
+                        }
+                        catch {
+                            // 忽略单个文件读取异常
+                        }
+                    }
+                    if (hasReferenceToSrcOrLib) {
+                        checks.push({
+                            id: "project.files",
+                            category: "project",
+                            name: "Declared Files",
+                            status: "error",
+                            message: `Actions import modules from ${hasSrc ? "'src/'" : ""}${hasSrc && hasLib ? " and " : ""}${hasLib ? "'lib/'" : ""}, but 'files' is not declared in ${MANIFEST_FILE_NAME}`,
+                            fix: `Add "files": [${hasSrc ? '"src"' : ""}${hasSrc && hasLib ? ', "lib"' : hasLib && !hasSrc ? '"lib"' : ""}] to ${MANIFEST_FILE_NAME}`,
+                        });
+                    }
+                    else {
+                        checks.push({
+                            id: "project.files",
+                            category: "project",
+                            name: "Declared Files",
+                            status: "ok",
+                            message: `Project source directories clean (no undeclared references to ${hasSrc ? "src/" : "lib/"})`,
+                        });
+                    }
+                }
+            }
+            catch {
+                // 忽略文件边界检测异常
+            }
+            // Playbooks Check
+            try {
+                const playbooks = loadPlaybooks(projectRoot, config.playbooksDir);
+                checks.push({
+                    id: "project.playbooks",
+                    category: "project",
+                    name: "Playbooks",
+                    status: "ok",
+                    message: `${playbooks.size} playbook(s) valid`,
+                });
+            }
+            catch (err) {
+                checks.push({
+                    id: "project.playbooks",
+                    category: "project",
+                    name: "Playbooks",
+                    status: "warn",
+                    message: `Playbooks issue: ${err.message}`,
+                });
+            }
+            // Config readiness check
+            if (config.config && Object.keys(config.config).length > 0) {
+                const missingKeys = [];
+                const projectStorage = createStorage(config.id, { customHome: options?.customHome });
+                for (const [key, def] of Object.entries(config.config)) {
+                    const inStorage = await projectStorage.getConfig(key);
+                    const envNames = Array.isArray(def.env) ? def.env : def.env ? [def.env] : [key];
+                    const inEnv = envNames.some((e) => process.env[e] !== undefined);
+                    const isRequired = def.required || (def.default === undefined && def.secret);
+                    if ((isRequired || def.default === undefined) && inStorage === undefined && !inEnv) {
+                        missingKeys.push(key);
+                    }
+                }
+                projectStorage.close();
+                if (missingKeys.length > 0) {
+                    checks.push({
+                        id: "project.config_readiness",
+                        category: "project",
+                        name: "Config Readiness",
+                        status: "warn",
+                        message: `Required config item(s) missing: ${missingKeys.join(", ")}`,
+                        fix: `Run 'ad config set <KEY> <VALUE>' to configure missing keys`,
+                    });
+                }
+                else {
+                    checks.push({
+                        id: "project.config_readiness",
+                        category: "project",
+                        name: "Config Readiness",
+                        status: "ok",
+                        message: "All declared configuration dependencies satisfied",
+                    });
+                }
+            }
+        }
+        catch (err) {
+            checks.push({
+                id: "project.config",
+                category: "project",
+                name: "Project Configuration",
+                status: "error",
+                message: `Invalid actiondock.json: ${err.message}`,
+            });
+        }
+    }
+    const okCount = checks.filter((c) => c.status === "ok").length;
+    const warnCount = checks.filter((c) => c.status === "warn").length;
+    const errorCount = checks.filter((c) => c.status === "error").length;
+    return {
+        ok: errorCount === 0,
+        hasProject: !!projectRoot,
+        projectRoot: projectRoot || undefined,
+        packageId,
+        summary: {
+            total: checks.length,
+            ok: okCount,
+            warn: warnCount,
+            error: errorCount,
+        },
+        checks,
+    };
+}

package/dist/doctor/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./doctor";
-export * from "./types";
+export * from "./doctor.js";
+export * from "./types.js";

package/dist/doctor/index.js

@@ -0,0 +1,2 @@
+export * from "./doctor.js";
+export * from "./types.js";

package/dist/doctor/types.js

@@ -0,0 +1 @@
+export {};