@nocobase/ctl 0.1.5

package/dist/lib/api-client.js

@@ -0,0 +1,196 @@
+import { promises as fs } from 'node:fs';
+import { getCurrentEnvName, getEnv } from "./auth-store.js";
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '');
+}
+async function resolveServerRequestTarget(options) {
+    const envName = options.envName ?? (await getCurrentEnvName());
+    const env = await getEnv(envName);
+    const baseUrl = options.baseUrl ?? env?.baseUrl;
+    const token = options.token ?? env?.auth?.accessToken;
+    if (!baseUrl) {
+        throw new Error('Missing base URL. Use --base-url or configure one with `nocobase env add`.');
+    }
+    return { baseUrl, token };
+}
+async function parseResponse(response) {
+    const text = await response.text();
+    let data = text;
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch (error) {
+            data = text;
+        }
+    }
+    return {
+        ok: response.ok,
+        status: response.status,
+        data,
+    };
+}
+function parseScalarValue(value, type) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (type === 'boolean') {
+        return value;
+    }
+    if (type === 'integer' || type === 'number') {
+        return Number(value);
+    }
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch (error) {
+            return value;
+        }
+    }
+    return value;
+}
+function hasParameterValue(flags, parameter) {
+    const value = flags[parameter.flagName];
+    if (parameter.type === 'boolean') {
+        return value !== undefined;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return value !== undefined && value !== '';
+}
+async function parseBody(flags, operation) {
+    const inlineBody = flags.body;
+    const bodyFile = flags['body-file'];
+    const bodyParameters = operation.parameters.filter((parameter) => parameter.in === 'body');
+    const hasBodyFlags = bodyParameters.some((parameter) => hasParameterValue(flags, parameter));
+    if ((inlineBody || bodyFile) && hasBodyFlags) {
+        throw new Error('Use body field flags or --body/--body-file, not both.');
+    }
+    if (inlineBody) {
+        return JSON.parse(inlineBody);
+    }
+    if (bodyFile) {
+        return fs.readFile(bodyFile, 'utf8').then((content) => JSON.parse(content));
+    }
+    if (!bodyParameters.length) {
+        return undefined;
+    }
+    const body = {};
+    for (const parameter of bodyParameters) {
+        const rawValue = flags[parameter.flagName];
+        const value = parameter.isArray && !parameter.jsonEncoded
+            ? (Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined)
+            : parseScalarValue(rawValue, parameter.type);
+        if (parameter.required && (value === undefined || value === '')) {
+            throw new Error(`Missing required body field --${parameter.flagName}`);
+        }
+        if (value === undefined) {
+            continue;
+        }
+        body[parameter.name] = value;
+    }
+    if (Object.keys(body).length > 0) {
+        return body;
+    }
+    if (operation.hasBody && operation.bodyRequired) {
+        throw new Error('Missing request body. Use body field flags or --body/--body-file.');
+    }
+    return undefined;
+}
+export async function executeApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    const query = new URLSearchParams();
+    let requestPath = options.operation.pathTemplate;
+    for (const parameter of options.operation.parameters) {
+        if (parameter.in === 'body') {
+            continue;
+        }
+        const rawValue = options.flags[parameter.flagName];
+        const value = parameter.isArray
+            ? (Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined)
+            : parseScalarValue(rawValue, parameter.type);
+        if (parameter.required && (value === undefined || value === '')) {
+            throw new Error(`Missing required parameter --${parameter.flagName}`);
+        }
+        if (value === undefined) {
+            continue;
+        }
+        if (parameter.in === 'path') {
+            requestPath = requestPath.replace(`{${parameter.name}}`, encodeURIComponent(String(value)));
+            continue;
+        }
+        if (parameter.in === 'query') {
+            if (Array.isArray(value)) {
+                value.forEach((item) => query.append(parameter.name, String(parseScalarValue(item, parameter.type))));
+            }
+            else if (typeof value === 'object') {
+                query.set(parameter.name, JSON.stringify(value));
+            }
+            else {
+                query.set(parameter.name, String(value));
+            }
+            continue;
+        }
+        if (parameter.in === 'header') {
+            headers.set(parameter.name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+            continue;
+        }
+    }
+    const body = await parseBody(options.flags, options.operation);
+    if (body !== undefined) {
+        headers.set('content-type', 'application/json');
+    }
+    const url = new URL(`${normalizeBaseUrl(baseUrl)}${requestPath}`);
+    query.forEach((value, key) => url.searchParams.append(key, value));
+    const response = await fetch(url, {
+        method: options.operation.method.toUpperCase(),
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    return parseResponse(response);
+}
+export async function executeRawApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    for (const [name, value] of Object.entries(options.headers ?? {})) {
+        if (value === undefined || value === null || value === '') {
+            continue;
+        }
+        headers.set(name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    if (options.body !== undefined) {
+        headers.set('content-type', 'application/json');
+    }
+    const url = new URL(`${normalizeBaseUrl(baseUrl)}${options.path}`);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                url.searchParams.append(key, typeof item === 'object' ? JSON.stringify(item) : String(item));
+            }
+            continue;
+        }
+        url.searchParams.set(key, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    const response = await fetch(url, {
+        method: options.method.toUpperCase(),
+        headers,
+        body: options.body === undefined ? undefined : JSON.stringify(options.body),
+    });
+    return parseResponse(response);
+}

package/dist/lib/auth-store.js

@@ -0,0 +1,92 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { resolveCliHomeDir } from "./cli-home.js";
+const DEFAULT_CONFIG = {
+    currentEnv: 'default',
+    envs: {},
+};
+function getConfigFile(options = {}) {
+    return path.join(resolveCliHomeDir(options.scope), 'config.json');
+}
+export async function loadAuthConfig(options = {}) {
+    try {
+        const content = await fs.readFile(getConfigFile(options), 'utf8');
+        const parsed = JSON.parse(content);
+        return {
+            currentEnv: parsed.currentEnv || 'default',
+            envs: parsed.envs || {},
+        };
+    }
+    catch (error) {
+        return DEFAULT_CONFIG;
+    }
+}
+export async function saveAuthConfig(config, options = {}) {
+    const filePath = getConfigFile(options);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+}
+export async function listEnvs(options = {}) {
+    const config = await loadAuthConfig(options);
+    return {
+        currentEnv: config.currentEnv || 'default',
+        envs: config.envs,
+    };
+}
+export async function getCurrentEnvName(options = {}) {
+    const config = await loadAuthConfig(options);
+    return config.currentEnv || 'default';
+}
+export async function setCurrentEnv(envName, options = {}) {
+    const config = await loadAuthConfig(options);
+    if (!config.envs[envName]) {
+        throw new Error(`Env "${envName}" is not configured`);
+    }
+    config.currentEnv = envName;
+    await saveAuthConfig(config, options);
+}
+export async function getEnv(envName, options = {}) {
+    const config = await loadAuthConfig(options);
+    const resolved = envName || config.currentEnv || 'default';
+    return config.envs[resolved];
+}
+export async function upsertEnv(envName, baseUrl, accessToken, options = {}) {
+    const config = await loadAuthConfig(options);
+    config.envs[envName] = {
+        ...(config.envs[envName] ?? {}),
+        baseUrl,
+        auth: {
+            type: 'token',
+            accessToken,
+        },
+    };
+    config.currentEnv = envName;
+    await saveAuthConfig(config, options);
+}
+export async function setEnvRuntime(envName, runtime, options = {}) {
+    const config = await loadAuthConfig(options);
+    const current = config.envs[envName] ?? {};
+    config.envs[envName] = {
+        ...current,
+        runtime,
+    };
+    config.currentEnv = envName;
+    await saveAuthConfig(config, options);
+}
+export async function removeEnv(envName, options = {}) {
+    const config = await loadAuthConfig(options);
+    if (!config.envs[envName]) {
+        throw new Error(`Env "${envName}" is not configured`);
+    }
+    delete config.envs[envName];
+    if (config.currentEnv === envName) {
+        const nextEnv = Object.keys(config.envs).sort()[0];
+        config.currentEnv = nextEnv ?? 'default';
+    }
+    await saveAuthConfig(config, options);
+    return {
+        removed: envName,
+        currentEnv: config.currentEnv || 'default',
+        hasEnvs: Object.keys(config.envs).length > 0,
+    };
+}

package/dist/lib/bootstrap.js

@@ -0,0 +1,263 @@
+import { getCurrentEnvName, getEnv, setEnvRuntime } from "./auth-store.js";
+import { generateRuntime } from "./runtime-generator.js";
+import { hasRuntimeSync, saveRuntime } from "./runtime-store.js";
+import { confirmAction, printInfo, printVerbose, setVerboseMode, stopTask, updateTask } from "./ui.js";
+const APP_RETRY_INTERVAL = 2000;
+const APP_RETRY_TIMEOUT = 120000;
+function readFlag(argv, name) {
+    const exact = `--${name}`;
+    const prefix = `--${name}=`;
+    const alias = name === 'env' ? '-e' : name === 'scope' ? '-s' : undefined;
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === exact) {
+            return argv[index + 1];
+        }
+        if (alias && value === alias) {
+            return argv[index + 1];
+        }
+        if (value.startsWith(prefix)) {
+            return value.slice(prefix.length);
+        }
+    }
+    return undefined;
+}
+function hasBooleanFlag(argv, name) {
+    const exact = `--${name}`;
+    const negated = `--no-${name}`;
+    const prefix = `--${name}=`;
+    const alias = name === 'verbose' ? '-V' : undefined;
+    for (const value of argv) {
+        if (value === exact) {
+            return true;
+        }
+        if (alias && value === alias) {
+            return true;
+        }
+        if (value === negated) {
+            return false;
+        }
+        if (value.startsWith(prefix)) {
+            return value.slice(prefix.length) !== 'false';
+        }
+    }
+    return false;
+}
+function getCommandToken(argv) {
+    for (const token of argv) {
+        if (!token || token.startsWith('-')) {
+            continue;
+        }
+        return token;
+    }
+    return undefined;
+}
+function hasHelpFlag(argv) {
+    return argv.includes('--help') || argv.includes('-h');
+}
+function hasVersionFlag(argv) {
+    return argv.includes('--version') || argv.includes('-v');
+}
+function isRootHelp(argv) {
+    const commandToken = getCommandToken(argv);
+    return !commandToken && hasHelpFlag(argv);
+}
+function isBuiltinCommand(argv) {
+    const commandToken = getCommandToken(argv);
+    return commandToken === 'env' || commandToken === 'resource';
+}
+async function requestJson(url, options) {
+    const headers = new Headers();
+    if (options.token) {
+        headers.set('authorization', `Bearer ${options.token}`);
+    }
+    let response;
+    try {
+        response = await fetch(url, {
+            method: options.method ?? 'GET',
+            headers,
+        });
+    }
+    catch (error) {
+        return {
+            status: 0,
+            ok: false,
+            data: {
+                error: {
+                    message: error?.message ?? 'fetch failed',
+                },
+            },
+        };
+    }
+    const text = await response.text();
+    let data = undefined;
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch (error) {
+            data = text;
+        }
+    }
+    return {
+        status: response.status,
+        ok: response.ok,
+        data,
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAppRestarting(response) {
+    return response.status === 503 && response.data?.error?.code === 'APP_COMMANDING';
+}
+function shouldRetryAppAvailability(response) {
+    return isAppRestarting(response) || response.status === 0;
+}
+function getSwaggerUrl(baseUrl) {
+    return `${baseUrl.replace(/\/+$/, '')}/swagger:get`;
+}
+function getHealthCheckUrl(baseUrl) {
+    return `${baseUrl.replace(/\/+$/, '')}/__health_check`;
+}
+async function waitForServiceReady(baseUrl, token) {
+    const healthCheckUrl = getHealthCheckUrl(baseUrl);
+    const startedAt = Date.now();
+    let notified = false;
+    while (Date.now() - startedAt < APP_RETRY_TIMEOUT) {
+        const response = await fetch(healthCheckUrl, {
+            method: 'GET',
+            headers: token ? { authorization: `Bearer ${token}` } : undefined,
+        }).catch((error) => {
+            return {
+                ok: false,
+                status: 0,
+                text: async () => error?.message ?? 'fetch failed',
+            };
+        });
+        const text = await response.text();
+        if (response.ok && text.trim().toLowerCase() === 'ok') {
+            return;
+        }
+        if (!notified) {
+            printVerbose(`Waiting for health check: ${healthCheckUrl}`);
+            updateTask(`Waiting for application readiness (${healthCheckUrl})`);
+            notified = true;
+        }
+        await sleep(APP_RETRY_INTERVAL);
+    }
+    throw new Error(`The application did not become ready in time. Expected \`${healthCheckUrl}\` to respond with \`ok\`.`);
+}
+async function waitForSwaggerSchema(baseUrl, token) {
+    const swaggerUrl = getSwaggerUrl(baseUrl);
+    const startedAt = Date.now();
+    printVerbose(`Checking swagger schema: ${swaggerUrl}`);
+    while (Date.now() - startedAt < APP_RETRY_TIMEOUT) {
+        const response = await requestJson(swaggerUrl, { token });
+        if (response.ok) {
+            return response;
+        }
+        if (!shouldRetryAppAvailability(response)) {
+            return response;
+        }
+        await waitForServiceReady(baseUrl, token);
+    }
+    return await requestJson(swaggerUrl, { token });
+}
+async function confirmEnableApiDoc() {
+    return confirmAction('Enable the API documentation plugin now?', { defaultValue: false });
+}
+async function fetchSwaggerSchema(baseUrl, token) {
+    let response = await waitForSwaggerSchema(baseUrl, token);
+    if (response.status === 404) {
+        printInfo('The API documentation plugin is not enabled.');
+        const shouldEnable = await confirmEnableApiDoc();
+        if (!shouldEnable) {
+            throw new Error('`swagger:get` returned 404. Enable the `API documentation plugin` first.');
+        }
+        const enableUrl = `${baseUrl.replace(/\/+$/, '')}/pm:enable?filterByTk=api-doc`;
+        printVerbose(`Enabling API documentation plugin via ${enableUrl}`);
+        const enableResponse = await requestJson(enableUrl, { method: 'POST', token });
+        if (!enableResponse.ok) {
+            throw new Error(`Failed to enable the \`API documentation plugin\` via \`pm:enable\`.\n${JSON.stringify(enableResponse.data, null, 2)}`);
+        }
+        updateTask('Enabled the API documentation plugin. Waiting for application readiness...');
+        await waitForServiceReady(baseUrl, token);
+        response = await waitForSwaggerSchema(baseUrl, token);
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to load swagger schema from \`swagger:get\`.\n${JSON.stringify(response.data, null, 2)}`);
+    }
+    return (response.data?.data ?? response.data);
+}
+export async function ensureRuntimeFromArgv(argv, options) {
+    const commandToken = getCommandToken(argv);
+    setVerboseMode(hasBooleanFlag(argv, 'verbose'));
+    if (hasVersionFlag(argv) || isBuiltinCommand(argv)) {
+        return;
+    }
+    const envName = readFlag(argv, 'env') ?? (await getCurrentEnvName());
+    const env = await getEnv(envName);
+    const baseUrl = readFlag(argv, 'base-url') ?? env?.baseUrl;
+    const token = readFlag(argv, 'token') ?? env?.auth?.accessToken;
+    const runtimeVersion = env?.runtime?.version;
+    if (!commandToken || isRootHelp(argv)) {
+        if (!baseUrl) {
+            return;
+        }
+    }
+    if (runtimeVersion && hasRuntimeSync(runtimeVersion)) {
+        return;
+    }
+    if (!baseUrl) {
+        throw new Error([
+            'No env is configured for runtime commands.',
+            'Run `nocobase env add --name <name> --base-url <url> --token <token>` first.',
+            'If you configure multiple environments later, switch with `nocobase env use <name>`.',
+        ].join('\n'));
+    }
+    updateTask('Loading command runtime...');
+    try {
+        printVerbose(`Runtime source: ${baseUrl}`);
+        const document = await fetchSwaggerSchema(baseUrl, token);
+        const runtime = await generateRuntime(document, options.configFile, baseUrl);
+        await saveRuntime(runtime);
+        await setEnvRuntime(envName, {
+            version: runtime.version,
+            schemaHash: runtime.schemaHash,
+            generatedAt: runtime.generatedAt,
+        });
+    }
+    finally {
+        stopTask();
+    }
+}
+export async function updateEnvRuntime(options) {
+    setVerboseMode(Boolean(options.verbose));
+    const envName = options.envName ?? (await getCurrentEnvName({ scope: options.scope }));
+    const env = await getEnv(envName, { scope: options.scope });
+    const baseUrl = options.baseUrl ?? env?.baseUrl;
+    const token = options.token ?? env?.auth?.accessToken;
+    if (!baseUrl) {
+        throw new Error([
+            `Env "${envName}" is missing a base URL.`,
+            'Update it with `nocobase env add --name <name> --base-url <url>` first.',
+        ].join('\n'));
+    }
+    updateTask('Loading command runtime...');
+    try {
+        printVerbose(`Runtime source: ${baseUrl}`);
+        const document = await fetchSwaggerSchema(baseUrl, token);
+        const runtime = await generateRuntime(document, options.configFile, baseUrl);
+        await saveRuntime(runtime, { scope: options.scope });
+        await setEnvRuntime(envName, {
+            version: runtime.version,
+            schemaHash: runtime.schemaHash,
+            generatedAt: runtime.generatedAt,
+        }, { scope: options.scope });
+        return runtime;
+    }
+    finally {
+        stopTask();
+    }
+}

package/dist/lib/build-config.js

@@ -0,0 +1,10 @@
+import { promises as fs } from 'node:fs';
+export async function loadBuildConfig(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return {};
+    }
+}

package/dist/lib/cli-home.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const CLI_HOME_DIRNAME = '.nocobase-ctl';
+function resolveGlobalCliHomeRoot() {
+    if (process.env.NOCOBASE_CTL_HOME) {
+        return process.env.NOCOBASE_CTL_HOME;
+    }
+    return os.homedir();
+}
+export function resolveCliHomeRoot(scope = 'auto') {
+    const cwdRoot = process.cwd();
+    if (scope === 'project') {
+        return cwdRoot;
+    }
+    if (scope === 'global') {
+        return resolveGlobalCliHomeRoot();
+    }
+    const cwdCliHome = path.join(cwdRoot, CLI_HOME_DIRNAME);
+    if (fs.existsSync(cwdCliHome)) {
+        return cwdRoot;
+    }
+    return resolveGlobalCliHomeRoot();
+}
+export function resolveCliHomeDir(scope = 'auto') {
+    return path.join(resolveCliHomeRoot(scope), CLI_HOME_DIRNAME);
+}
+export function formatCliHomeScope(scope) {
+    return scope === 'project' ? 'project' : 'global';
+}