@solarains/va-cli 0.1.3 → 0.1.5

package/dist/features/init/managed-pack.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectManagedPack = inspectManagedPack;
+exports.collectManagedPackStatuses = collectManagedPackStatuses;
+exports.syncManagedPacks = syncManagedPacks;
+exports.removeManagedPacks = removeManagedPacks;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const version_1 = require("../update/version");
+const package_metadata_1 = require("../runtime/package-metadata");
+const manifest_1 = require("./manifest");
+const installer_1 = require("./installer");
+const target_registry_1 = require("./target-registry");
+const templates_1 = require("./templates");
+async function readText(path) {
+    try {
+        return await (0, promises_1.readFile)(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+async function pruneEmptyDirectories(startDir, stopDir) {
+    let current = startDir;
+    while (current.startsWith(stopDir) && current !== stopDir) {
+        try {
+            await (0, promises_1.rmdir)(current);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOTEMPTY' || code === 'ENOENT') {
+                return;
+            }
+            throw error;
+        }
+        current = (0, node_path_1.dirname)(current);
+    }
+}
+function resolveRoot(input) {
+    const target = (0, target_registry_1.getAgentTarget)(input.targetId);
+    const cwd = input.cwd ?? process.cwd();
+    const homeDir = input.homeDir ?? (0, node_os_1.homedir)();
+    const rootDir = target.resolveRoot({
+        cwd,
+        homeDir,
+        scope: input.scope,
+    });
+    return {
+        target,
+        rootDir,
+        manifestPath: (0, node_path_1.join)(rootDir, manifest_1.MANIFEST_FILE_NAME),
+    };
+}
+async function inspectManagedPack(input) {
+    const runtimePackage = input.currentVersion === undefined
+        ? await (0, package_metadata_1.resolveRuntimePackageInfo)()
+        : null;
+    const currentVersion = input.currentVersion ?? runtimePackage?.version ?? '';
+    const { target, rootDir, manifestPath } = resolveRoot(input);
+    const manifest = await (0, manifest_1.readManagedManifest)(manifestPath);
+    const managedSkillPath = (0, node_path_1.join)(rootDir, templates_1.SKILL_NAME, 'SKILL.md');
+    const existingSkill = await readText(managedSkillPath);
+    const hasManagedSkillFile = existingSkill?.includes(templates_1.MANAGED_MARKER) ?? false;
+    if (!manifest) {
+        return {
+            target,
+            scope: input.scope,
+            rootDir,
+            manifestPath,
+            kind: hasManagedSkillFile ? 'untracked' : 'missing',
+            currentVersion,
+        };
+    }
+    const installedVersion = manifest.packVersion;
+    if (!installedVersion) {
+        return {
+            target,
+            scope: input.scope,
+            rootDir,
+            manifestPath,
+            kind: 'legacy',
+            currentVersion,
+        };
+    }
+    const comparison = (0, version_1.compareVersions)(installedVersion, currentVersion);
+    return {
+        target,
+        scope: input.scope,
+        rootDir,
+        manifestPath,
+        kind: comparison === 0 ? 'current' : comparison < 0 ? 'stale' : 'ahead',
+        currentVersion,
+        installedVersion,
+    };
+}
+async function collectManagedPackStatuses(input) {
+    const runtimePackage = input?.currentVersion === undefined
+        ? await (0, package_metadata_1.resolveRuntimePackageInfo)()
+        : null;
+    const currentVersion = input?.currentVersion ?? runtimePackage?.version ?? '';
+    const agentIds = input?.agentIds ?? (0, target_registry_1.getAgentTargetRegistry)().map((target) => target.id);
+    const scopes = input?.scopes ?? ['project', 'user'];
+    const statuses = [];
+    for (const scope of scopes) {
+        for (const agentId of agentIds) {
+            statuses.push(await inspectManagedPack({
+                targetId: agentId,
+                scope,
+                cwd: input?.cwd,
+                homeDir: input?.homeDir,
+                currentVersion,
+            }));
+        }
+    }
+    return statuses;
+}
+async function syncManagedPacks(input) {
+    const runtimePackage = input?.currentVersion === undefined
+        ? await (0, package_metadata_1.resolveRuntimePackageInfo)()
+        : null;
+    const currentVersion = input?.currentVersion ?? runtimePackage?.version ?? '';
+    const statuses = await collectManagedPackStatuses({
+        ...input,
+        currentVersion,
+    });
+    const refreshed = [];
+    for (const status of statuses) {
+        if (status.kind !== 'legacy' && status.kind !== 'stale') {
+            continue;
+        }
+        const prepared = await (0, installer_1.prepareInstallations)({
+            agentIds: [status.target.id],
+            scope: status.scope,
+            cwd: input?.cwd ?? process.cwd(),
+            homeDir: input?.homeDir ?? (0, node_os_1.homedir)(),
+        });
+        await (0, installer_1.applyInstallations)(prepared, {
+            allowUnmanagedOverwrite: false,
+        });
+        refreshed.push({
+            target: status.target,
+            scope: status.scope,
+            rootDir: status.rootDir,
+            previousStatus: status.kind,
+        });
+    }
+    return refreshed;
+}
+async function removeManagedPacks(input) {
+    const agentIds = input?.agentIds ?? (0, target_registry_1.getAgentTargetRegistry)().map((target) => target.id);
+    const scopes = input?.scopes ?? ['project', 'user'];
+    const removed = [];
+    for (const scope of scopes) {
+        for (const agentId of agentIds) {
+            const { target, rootDir, manifestPath } = resolveRoot({
+                targetId: agentId,
+                scope,
+                cwd: input?.cwd,
+                homeDir: input?.homeDir,
+            });
+            const manifest = await (0, manifest_1.readManagedManifest)(manifestPath);
+            if (!manifest) {
+                continue;
+            }
+            const removedFiles = [];
+            for (const relativePath of manifest.files) {
+                await (0, promises_1.rm)((0, node_path_1.join)(rootDir, relativePath), { force: true });
+                removedFiles.push(relativePath);
+            }
+            await (0, promises_1.rm)(manifestPath, { force: true });
+            await pruneEmptyDirectories((0, node_path_1.join)(rootDir, templates_1.SKILL_NAME), rootDir);
+            removed.push({
+                target,
+                scope,
+                rootDir,
+                removedFiles,
+            });
+        }
+    }
+    return removed;
+}

package/dist/features/init/target-registry.js

@@ -29,7 +29,9 @@ const TARGET_REGISTRY = [
         displayName: 'OpenClaw',
         supportedScopes: ['project', 'user'],
         resolveRoot({ cwd, homeDir, scope }) {
-            return scope === 'project' ? (0, node_path_1.join)(cwd, 'skills') : (0, node_path_1.join)(homeDir, '.openclaw', 'skills');
+            return scope === 'project'
+                ? (0, node_path_1.join)(cwd, 'skills')
+                : (0, node_path_1.join)(homeDir, '.openclaw', 'skills');
         },
     },
 ];

package/dist/features/init/templates.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MANAGED_MARKER = void 0;
+exports.SKILL_NAME = exports.MANAGED_MARKER = void 0;
 exports.resolveSkillSourceRoot = resolveSkillSourceRoot;
 exports.createAgentPackFiles = createAgentPackFiles;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const package_metadata_1 = require("../runtime/package-metadata");
 exports.MANAGED_MARKER = 'VAONE-MANAGED FILE';
-const SKILL_NAME = 'visionalpha-operator';
+exports.SKILL_NAME = 'visionalpha-operator';
 async function pathExists(path) {
     try {
         await (0, promises_1.access)((0, node_path_1.join)(path, 'SKILL.md'));
@@ -23,12 +24,12 @@ async function resolveSkillSourceRoot(input) {
     const env = input?.env ?? process.env;
     const candidates = [
         env.VAONE_SKILL_SOURCE_DIR,
-        (0, node_path_1.join)(moduleDir, '..', '..', '..', 'skills', SKILL_NAME),
-        (0, node_path_1.join)(cwd, 'skills', SKILL_NAME),
-        (0, node_path_1.join)(cwd, 'va-cli', 'skills', SKILL_NAME),
-        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), 'skills', SKILL_NAME),
-        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'skills', SKILL_NAME),
-        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'va-cli', 'skills', SKILL_NAME),
+        (0, node_path_1.join)(moduleDir, '..', '..', '..', 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)(cwd, 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)(cwd, 'va-cli', 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'va-cli', 'skills', exports.SKILL_NAME),
     ]
         .filter((candidate) => Boolean(candidate))
         .map((candidate) => (0, node_path_1.resolve)(candidate));
@@ -38,7 +39,7 @@ async function resolveSkillSourceRoot(input) {
             return candidate;
         }
     }
-    throw new Error(`Unable to locate the managed skill source for "${SKILL_NAME}". Checked: ${deduped.join(', ')}. Set VAONE_SKILL_SOURCE_DIR to override the lookup path.`);
+    throw new Error(`Unable to locate the managed skill source for "${exports.SKILL_NAME}". Checked: ${deduped.join(', ')}. Set VAONE_SKILL_SOURCE_DIR to override the lookup path.`);
 }
 function buildManagedHeader(target, relativePath) {
     if (relativePath.endsWith('.yaml') || relativePath.endsWith('.yml')) {
@@ -58,6 +59,27 @@ function injectManagedHeader(target, relativePath, contents) {
     const insertAt = closingIndex + '\n---\n'.length;
     return `${contents.slice(0, insertAt)}${header}\n\n${contents.slice(insertAt)}`;
 }
+function upsertFrontMatterValue(contents, key, value) {
+    if (!contents.startsWith('---\n')) {
+        return contents;
+    }
+    const closingIndex = contents.indexOf('\n---\n', 4);
+    if (closingIndex === -1) {
+        return contents;
+    }
+    const frontMatter = contents.slice(4, closingIndex);
+    const body = contents.slice(closingIndex);
+    const lines = frontMatter.split('\n');
+    const nextLine = `${key}: "${value}"`;
+    const existingIndex = lines.findIndex((line) => line.startsWith(`${key}:`));
+    if (existingIndex >= 0) {
+        lines[existingIndex] = nextLine;
+    }
+    else {
+        lines.push(nextLine);
+    }
+    return `---\n${lines.join('\n')}${body}`;
+}
 async function listRelativeFiles(rootDir, currentDir = rootDir) {
     const entries = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
     const files = await Promise.all(entries.map(async (entry) => {
@@ -71,14 +93,18 @@ async function listRelativeFiles(rootDir, currentDir = rootDir) {
 }
 async function createAgentPackFiles(target, scope) {
     void scope;
+    const runtimePackage = await (0, package_metadata_1.resolveRuntimePackageInfo)();
     const skillSourceRoot = await resolveSkillSourceRoot();
     const relativeFiles = await listRelativeFiles(skillSourceRoot);
     return Promise.all(relativeFiles.map(async (relativePath) => {
-        const contents = await (0, promises_1.readFile)((0, node_path_1.join)(skillSourceRoot, relativePath), 'utf8');
+        const rawContents = await (0, promises_1.readFile)((0, node_path_1.join)(skillSourceRoot, relativePath), 'utf8');
+        const contents = relativePath.endsWith('SKILL.md')
+            ? upsertFrontMatterValue(rawContents, 'version', runtimePackage.version)
+            : rawContents;
         return {
-            relativePath: (0, node_path_1.join)(SKILL_NAME, relativePath),
+            relativePath: (0, node_path_1.join)(exports.SKILL_NAME, relativePath),
             description: `${target.displayName} VisionAlpha operator skill asset`,
-            contents: injectManagedHeader(target, (0, node_path_1.join)(SKILL_NAME, relativePath), contents),
+            contents: injectManagedHeader(target, (0, node_path_1.join)(exports.SKILL_NAME, relativePath), contents),
         };
     }));
 }

package/dist/features/runtime/package-metadata.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimePackageInfo = resolveRuntimePackageInfo;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+async function pathExists(path) {
+    try {
+        await (0, promises_1.access)(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findNearestPackageJson(startDir) {
+    let current = (0, node_path_1.resolve)(startDir);
+    for (;;) {
+        const packageJsonPath = (0, node_path_1.resolve)(current, 'package.json');
+        if (await pathExists(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+async function resolveRuntimePackageInfo(input) {
+    const entryPath = input?.entryPath ?? process.argv[1];
+    const moduleDir = input?.moduleDir ?? __dirname;
+    const candidateDirs = [
+        entryPath ? (0, node_path_1.dirname)((0, node_path_1.resolve)(entryPath)) : null,
+        (0, node_path_1.resolve)(moduleDir),
+    ].filter((value) => Boolean(value));
+    const seen = new Set();
+    for (const candidateDir of candidateDirs) {
+        const packageJsonPath = await findNearestPackageJson(candidateDir);
+        if (!packageJsonPath || seen.has(packageJsonPath)) {
+            continue;
+        }
+        seen.add(packageJsonPath);
+        const raw = await (0, promises_1.readFile)(packageJsonPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.name || !parsed.version) {
+            continue;
+        }
+        return {
+            rootDir: (0, node_path_1.dirname)(packageJsonPath),
+            packageJsonPath,
+            name: parsed.name,
+            version: parsed.version,
+            private: parsed.private === true,
+            isPackagedInstall: parsed.private !== true,
+        };
+    }
+    throw new Error('Unable to resolve runtime package metadata for `vaone`.');
+}