@nocobase/cli 2.1.0-alpha.4 → 2.1.0-alpha.40

package/dist/lib/session-store.js

@@ -0,0 +1,118 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { resolveCliHomeDir } from './cli-home.js';
+export function getSessionId() {
+    const value = String(process.env.NB_SESSION_ID ?? '').trim();
+    return value || undefined;
+}
+function sessionsDir(scope) {
+    return path.join(resolveCliHomeDir(scope), 'sessions');
+}
+export function getSessionFilePath(sessionId, scope) {
+    return path.join(sessionsDir(scope), `${sessionId}.json`);
+}
+export async function loadSessionState(sessionId, scope) {
+    try {
+        const content = await fs.readFile(getSessionFilePath(sessionId, scope), 'utf8');
+        const parsed = JSON.parse(content);
+        return parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch (_error) {
+        return undefined;
+    }
+}
+export async function saveSessionState(sessionId, state, scope) {
+    const filePath = getSessionFilePath(sessionId, scope);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(state, null, 2));
+}
+export async function deleteSessionState(sessionId, scope) {
+    await fs.rm(getSessionFilePath(sessionId, scope), { force: true });
+}
+export async function getSessionCurrentEnv(scope) {
+    const sessionId = getSessionId();
+    if (!sessionId) {
+        return undefined;
+    }
+    const state = await loadSessionState(sessionId, scope);
+    const currentEnv = String(state?.currentEnv ?? '').trim();
+    return currentEnv || undefined;
+}
+export async function setSessionCurrentEnv(envName, scope) {
+    const sessionId = getSessionId();
+    if (!sessionId) {
+        return false;
+    }
+    await saveSessionState(sessionId, {
+        currentEnv: envName,
+        updatedAt: new Date().toISOString(),
+    }, scope);
+    return true;
+}
+export async function clearSessionCurrentEnv(scope) {
+    const sessionId = getSessionId();
+    if (!sessionId) {
+        return false;
+    }
+    await deleteSessionState(sessionId, scope);
+    return true;
+}
+export async function resolveEffectiveCurrentEnv(validEnvNames, options = {}) {
+    const sessionId = getSessionId();
+    const normalizedValidNames = validEnvNames.filter(Boolean);
+    if (sessionId) {
+        const state = await loadSessionState(sessionId, options.scope);
+        const sessionEnv = String(state?.currentEnv ?? '').trim();
+        if (sessionEnv && normalizedValidNames.includes(sessionEnv)) {
+            return sessionEnv;
+        }
+        if (sessionEnv) {
+            const lastEnv = String(options.lastEnv ?? '').trim();
+            const fallbackEnv = lastEnv && normalizedValidNames.includes(lastEnv)
+                ? lastEnv
+                : normalizedValidNames[0];
+            if (fallbackEnv) {
+                await saveSessionState(sessionId, {
+                    currentEnv: fallbackEnv,
+                    updatedAt: new Date().toISOString(),
+                }, options.scope);
+                return fallbackEnv;
+            }
+            await deleteSessionState(sessionId, options.scope);
+        }
+    }
+    const lastEnv = String(options.lastEnv ?? '').trim();
+    if (lastEnv && normalizedValidNames.includes(lastEnv)) {
+        return lastEnv;
+    }
+    return normalizedValidNames[0] || 'default';
+}
+export async function cleanupCurrentSessionAfterEnvRemoval(removedEnv, options = {}) {
+    const sessionId = getSessionId();
+    if (!sessionId) {
+        return false;
+    }
+    const state = await loadSessionState(sessionId, options.scope);
+    const sessionEnv = String(state?.currentEnv ?? '').trim();
+    if (sessionEnv !== removedEnv) {
+        return false;
+    }
+    const fallbackEnv = String(options.fallbackEnv ?? '').trim();
+    if (fallbackEnv) {
+        await saveSessionState(sessionId, {
+            currentEnv: fallbackEnv,
+            updatedAt: new Date().toISOString(),
+        }, options.scope);
+        return true;
+    }
+    await deleteSessionState(sessionId, options.scope);
+    return true;
+}

package/dist/lib/skills-manager.js

@@ -0,0 +1,360 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { createGunzip } from 'node:zlib';
+import * as tar from 'tar';
+import { resolveCliHomeDir } from './cli-home.js';
+import { compareVersions } from './self-manager.js';
+import { commandOutput, commandOutputViaFile, run } from './run-npm.js';
+export const NOCOBASE_SKILLS_SOURCE = 'nocobase/skills';
+export const NOCOBASE_SKILLS_PACKAGE_NAME = '@nocobase/skills';
+const NOCOBASE_SKILLS_NAME_PREFIX = 'nocobase-';
+function normalizePath(value) {
+    return path.resolve(value);
+}
+export function resolveGlobalSkillsRoot(_startCwd = process.cwd()) {
+    return normalizePath(resolveCliHomeDir('global'));
+}
+export function resolveSkillsWorkspaceRoot(startCwd = process.cwd()) {
+    return resolveGlobalSkillsRoot(startCwd);
+}
+function resolveSkillsRoot(options = {}) {
+    return options.globalRoot
+        ? normalizePath(options.globalRoot)
+        : options.workspaceRoot
+            ? normalizePath(options.workspaceRoot)
+            : resolveGlobalSkillsRoot();
+}
+function getSkillsCacheRoot(globalRoot) {
+    return path.join(globalRoot, 'cache', 'skills');
+}
+function getCachedSkillsPackageDir(cacheRoot) {
+    return path.join(cacheRoot, 'node_modules', '@nocobase', 'skills');
+}
+function getCachedSkillsPackRoot(cacheRoot) {
+    return path.join(cacheRoot, 'pack');
+}
+function getCachedSkillsExtractRoot(cacheRoot) {
+    return path.join(cacheRoot, 'extract');
+}
+export function getManagedSkillsStateFile(workspaceRoot) {
+    return path.join(workspaceRoot, 'skills.json');
+}
+async function ensureSkillsWorkspaceRoot(workspaceRoot) {
+    await fsp.mkdir(workspaceRoot, { recursive: true });
+}
+async function readManagedSkillsState(workspaceRoot) {
+    const filePath = getManagedSkillsStateFile(workspaceRoot);
+    try {
+        const content = await fsp.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeManagedSkillsState(workspaceRoot, state) {
+    const filePath = getManagedSkillsStateFile(workspaceRoot);
+    await fsp.mkdir(path.dirname(filePath), { recursive: true });
+    await fsp.writeFile(filePath, JSON.stringify(state, null, 2));
+}
+export async function listGlobalSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    await ensureSkillsWorkspaceRoot(globalRoot);
+    const output = await (options.commandOutputFn ?? commandOutputViaFile)('npx', ['-y', 'skills', 'list', '-g', '--json'], {
+        cwd: globalRoot,
+        errorName: 'skills list',
+    });
+    const parsed = JSON.parse(output);
+    return Array.isArray(parsed) ? parsed : [];
+}
+export async function listProjectSkills(options = {}) {
+    return await listGlobalSkills(options);
+}
+function pickInstalledNocoBaseSkillNames(installedSkills, state) {
+    const installedNames = new Set(installedSkills.map((skill) => String(skill.name ?? '').trim()).filter(Boolean));
+    if (state?.skillNames?.length) {
+        return state.skillNames.filter((name) => installedNames.has(name)).sort();
+    }
+    return Array.from(installedNames)
+        .filter((name) => name.startsWith(NOCOBASE_SKILLS_NAME_PREFIX))
+        .sort();
+}
+async function readPublishedSkillsVersion(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    await ensureSkillsWorkspaceRoot(globalRoot);
+    try {
+        const output = await (options.commandOutputFn ?? commandOutput)('npm', ['view', NOCOBASE_SKILLS_PACKAGE_NAME, 'version', '--json'], {
+            cwd: globalRoot,
+            errorName: 'npm view',
+        });
+        const parsed = JSON.parse(output);
+        const version = String(parsed ?? '').trim();
+        return { version: version || undefined };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function readCachedSkillsVersion(cacheRoot) {
+    const packageJsonPath = path.join(getCachedSkillsPackageDir(cacheRoot), 'package.json');
+    try {
+        const content = await fsp.readFile(packageJsonPath, 'utf8');
+        const parsed = JSON.parse(content);
+        const version = String(parsed.version ?? '').trim();
+        return version || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolvePackedSkillsTarball(packRoot) {
+    const entries = await fsp.readdir(packRoot, { withFileTypes: true });
+    const tarballs = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
+        .map((entry) => path.join(packRoot, entry.name))
+        .sort();
+    if (tarballs.length === 1) {
+        return tarballs[0];
+    }
+    if (tarballs.length === 0) {
+        throw new Error(`npm pack did not produce a local tarball for ${NOCOBASE_SKILLS_PACKAGE_NAME}.`);
+    }
+    throw new Error(`npm pack produced multiple tarballs for ${NOCOBASE_SKILLS_PACKAGE_NAME}.`);
+}
+async function extractPackedSkillsTarball(tarballPath, cacheRoot, targetVersion) {
+    const packageDir = getCachedSkillsPackageDir(cacheRoot);
+    const extractRoot = getCachedSkillsExtractRoot(cacheRoot);
+    await fsp.rm(extractRoot, { recursive: true, force: true });
+    await fsp.mkdir(extractRoot, { recursive: true });
+    try {
+        await new Promise((resolve, reject) => {
+            fs.createReadStream(tarballPath)
+                .pipe(createGunzip())
+                .pipe(tar.extract({ cwd: extractRoot, strip: 1 }))
+                .on('finish', () => resolve())
+                .on('error', reject);
+        });
+        const packageJsonPath = path.join(extractRoot, 'package.json');
+        const packageJsonRaw = await fsp.readFile(packageJsonPath, 'utf8');
+        const manifest = JSON.parse(packageJsonRaw);
+        const packageName = String(manifest.name ?? '').trim();
+        const packageVersion = String(manifest.version ?? '').trim();
+        if (packageName !== NOCOBASE_SKILLS_PACKAGE_NAME) {
+            throw new Error(`packed tarball resolved to ${packageName || '(missing package name)'} instead of ${NOCOBASE_SKILLS_PACKAGE_NAME}.`);
+        }
+        if (targetVersion && packageVersion !== targetVersion) {
+            throw new Error(`packed tarball resolved to version ${packageVersion || '(missing version)'} instead of ${targetVersion}.`);
+        }
+        await fsp.rm(packageDir, { recursive: true, force: true });
+        await fsp.mkdir(path.dirname(packageDir), { recursive: true });
+        await fsp.rename(extractRoot, packageDir);
+        return packageDir;
+    }
+    catch (error) {
+        await fsp.rm(extractRoot, { recursive: true, force: true });
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`failed to extract ${NOCOBASE_SKILLS_PACKAGE_NAME} tarball: ${message}`);
+    }
+}
+async function prepareLocalSkillsPackage(globalRoot, options = {}, targetVersion) {
+    const cacheRoot = getSkillsCacheRoot(globalRoot);
+    const packageDir = getCachedSkillsPackageDir(cacheRoot);
+    const packRoot = getCachedSkillsPackRoot(cacheRoot);
+    const packageSpec = targetVersion ? `${NOCOBASE_SKILLS_PACKAGE_NAME}@${targetVersion}` : NOCOBASE_SKILLS_PACKAGE_NAME;
+    const cachedVersion = await readCachedSkillsVersion(cacheRoot);
+    await fsp.mkdir(cacheRoot, { recursive: true });
+    if (targetVersion && cachedVersion && compareVersions(cachedVersion, targetVersion) === 0) {
+        return {
+            packageDir,
+            cleanup: async () => undefined,
+        };
+    }
+    await fsp.rm(packRoot, { recursive: true, force: true });
+    await fsp.mkdir(packRoot, { recursive: true });
+    try {
+        await (options.runFn ?? run)('npm', ['pack', '--silent', packageSpec], {
+            cwd: packRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'npm pack',
+        });
+        const tarballPath = await resolvePackedSkillsTarball(packRoot);
+        await extractPackedSkillsTarball(tarballPath, cacheRoot, targetVersion);
+    }
+    finally {
+        await fsp.rm(packRoot, { recursive: true, force: true });
+    }
+    return {
+        packageDir,
+        cleanup: async () => undefined,
+    };
+}
+export async function inspectSkillsStatus(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const stateFile = getManagedSkillsStateFile(globalRoot);
+    const [installedSkills, managedState] = await Promise.all([
+        listGlobalSkills({
+            globalRoot,
+            commandOutputFn: options.commandOutputFn,
+        }),
+        readManagedSkillsState(globalRoot),
+    ]);
+    const installedSkillNames = pickInstalledNocoBaseSkillNames(installedSkills, managedState);
+    const managedByNb = managedState?.packageName === NOCOBASE_SKILLS_PACKAGE_NAME;
+    let latestVersion;
+    let registryError;
+    let updateAvailable = installedSkillNames.length > 0 ? null : false;
+    if (installedSkillNames.length > 0 || managedByNb) {
+        const published = await readPublishedSkillsVersion({
+            globalRoot,
+            commandOutputFn: options.commandOutputFn,
+        });
+        latestVersion = published.version;
+        registryError = published.error;
+        const installedVersion = managedState?.installedVersion ?? managedState?.installedRef;
+        if (installedVersion && latestVersion) {
+            updateAvailable = compareVersions(latestVersion, installedVersion) > 0;
+        }
+    }
+    const installedVersion = managedState?.installedVersion ?? managedState?.installedRef;
+    return {
+        globalRoot,
+        workspaceRoot: globalRoot,
+        stateFile,
+        installed: installedSkillNames.length > 0,
+        managedByNb,
+        sourcePackage: managedState?.sourcePackage ?? NOCOBASE_SKILLS_SOURCE,
+        npmPackageName: managedState?.packageName ?? NOCOBASE_SKILLS_PACKAGE_NAME,
+        installedSkillNames,
+        latestVersion,
+        installedVersion,
+        latestRef: latestVersion,
+        installedRef: installedVersion,
+        updateAvailable,
+        registryError,
+    };
+}
+async function persistManagedSkillsState(globalRoot, options = {}) {
+    const installedSkills = await listGlobalSkills({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    const managedState = await readManagedSkillsState(globalRoot);
+    const installedSkillNames = pickInstalledNocoBaseSkillNames(installedSkills, managedState);
+    const published = await readPublishedSkillsVersion({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    const now = new Date().toISOString();
+    await writeManagedSkillsState(globalRoot, {
+        packageName: NOCOBASE_SKILLS_PACKAGE_NAME,
+        sourcePackage: NOCOBASE_SKILLS_SOURCE,
+        installedAt: managedState?.installedAt ?? now,
+        updatedAt: now,
+        installedVersion: published.version,
+        skillNames: installedSkillNames,
+    });
+    return await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+}
+async function reinstallManagedSkills(globalRoot, options = {}, targetVersion) {
+    const prepared = await prepareLocalSkillsPackage(globalRoot, options, targetVersion);
+    try {
+        await (options.runFn ?? run)('npx', ['-y', 'skills', 'add', prepared.packageDir, '-g', '-y'], {
+            cwd: globalRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'skills add',
+        });
+    }
+    finally {
+        await prepared.cleanup();
+    }
+}
+export async function installNocoBaseSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const status = await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (status.installed) {
+        return {
+            action: 'noop',
+            status,
+        };
+    }
+    await ensureSkillsWorkspaceRoot(globalRoot);
+    await reinstallManagedSkills(globalRoot, options, status.latestVersion);
+    return {
+        action: 'installed',
+        status: await persistManagedSkillsState(globalRoot, options),
+    };
+}
+export async function updateNocoBaseSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const status = await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (!status.installed) {
+        return {
+            action: 'noop',
+            reason: 'not-installed',
+            status,
+        };
+    }
+    if (status.managedByNb
+        && status.latestVersion
+        && status.installedVersion
+        && compareVersions(status.latestVersion, status.installedVersion) <= 0) {
+        return {
+            action: 'noop',
+            reason: 'up-to-date',
+            status,
+        };
+    }
+    await reinstallManagedSkills(globalRoot, options, status.latestVersion);
+    return {
+        action: 'updated',
+        status: await persistManagedSkillsState(globalRoot, options),
+    };
+}
+export async function removeNocoBaseSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const status = await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (!status.installed || status.installedSkillNames.length === 0) {
+        return {
+            action: 'noop',
+            status,
+        };
+    }
+    for (const skillName of status.installedSkillNames) {
+        await (options.runFn ?? run)('npx', ['-y', 'skills', 'remove', skillName, '-g', '-y'], {
+            cwd: globalRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'skills remove',
+        });
+    }
+    await fsp.rm(getManagedSkillsStateFile(globalRoot), { force: true });
+    return {
+        action: 'removed',
+        status: await inspectSkillsStatus({
+            globalRoot,
+            commandOutputFn: options.commandOutputFn,
+        }),
+    };
+}