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

package/dist/commands/v1.js

@@ -0,0 +1,210 @@
+/**
+ * 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 { Command } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../lib/env-guard.js';
+import { announceTargetEnv } from '../lib/ui.js';
+const SILENT_LIKE_PASSTHROUGH_FLAGS = new Set(['--help', '-h', '--silent']);
+const SILENT_RUNTIME_ENV_VARS = {
+    LOGGER_SILENT: 'true',
+    NODE_NO_WARNINGS: '1',
+};
+const SILENT_STDERR_FILTERS = [
+    /^\(node:\d+\) \[DEP0040\] DeprecationWarning: The `punycode` module is deprecated\..*$/,
+    /^\(Use `node --trace-deprecation .*$/,
+    /^About to overwrite ArrayBuffer\.prototype properties /,
+];
+function parseBridgeArgv(argv) {
+    let requestedEnv;
+    let yes = false;
+    const passthroughArgs = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--') {
+            passthroughArgs.push(...argv.slice(index + 1));
+            break;
+        }
+        if (token === '--env') {
+            const value = argv[index + 1];
+            if (!value || value === '--') {
+                throw new Error('Missing value for `--env`.');
+            }
+            requestedEnv = value.trim() || undefined;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--env=')) {
+            requestedEnv = token.slice('--env='.length).trim() || undefined;
+            continue;
+        }
+        if (token === '-e') {
+            const value = argv[index + 1];
+            if (!value || value === '--') {
+                throw new Error('Missing value for `-e`.');
+            }
+            requestedEnv = value.trim() || undefined;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('-e') && token.length > 2) {
+            requestedEnv = token.slice(2).trim() || undefined;
+            continue;
+        }
+        if (token === '--yes') {
+            yes = true;
+            continue;
+        }
+        passthroughArgs.push(...argv.slice(index));
+        break;
+    }
+    return {
+        requestedEnv,
+        yes,
+        passthroughArgs,
+    };
+}
+function formatHttpEnvError(envName) {
+    return [
+        `Can't run \`nb v1\` for "${envName}" yet.`,
+        'This env only has an API connection, so the v1 bridge is not available here.',
+        'Use a local or Docker env instead.',
+    ].join('\n');
+}
+function formatSshEnvError(envName) {
+    return [
+        `Can't run \`nb v1\` for "${envName}" yet.`,
+        'SSH env support is reserved but not implemented yet.',
+        'Use a local or Docker env right now.',
+    ].join('\n');
+}
+function hasSilentLikePassthrough(args) {
+    return args.some((arg) => SILENT_LIKE_PASSTHROUGH_FLAGS.has(arg));
+}
+function shouldFilterSilentStderrLine(line) {
+    const normalized = line.replace(/\r$/, '');
+    return SILENT_STDERR_FILTERS.some((pattern) => pattern.test(normalized));
+}
+function createSilentBridgeOptions() {
+    let pendingStderr = '';
+    const flushBufferedStderr = (force) => {
+        while (true) {
+            const newlineIndex = pendingStderr.indexOf('\n');
+            if (newlineIndex === -1) {
+                break;
+            }
+            const line = pendingStderr.slice(0, newlineIndex);
+            pendingStderr = pendingStderr.slice(newlineIndex + 1);
+            if (!shouldFilterSilentStderrLine(line)) {
+                process.stderr.write(`${line}\n`);
+            }
+        }
+        if (force && pendingStderr) {
+            if (!shouldFilterSilentStderrLine(pendingStderr)) {
+                process.stderr.write(pendingStderr);
+            }
+            pendingStderr = '';
+        }
+    };
+    return {
+        commandOptions: {
+            stdio: 'pipe',
+            env: {
+                ...SILENT_RUNTIME_ENV_VARS,
+            },
+            onStdout: (chunk) => {
+                process.stdout.write(chunk);
+            },
+            onStderr: (chunk) => {
+                pendingStderr += chunk;
+                flushBufferedStderr(false);
+            },
+        },
+        flush: () => {
+            flushBufferedStderr(true);
+        },
+    };
+}
+export default class V1 extends Command {
+    static hidden = true;
+    static strict = false;
+    static summary = 'Forward commands to the selected env through the v1 bridge';
+    static description = 'Forward v1-compatible commands to the selected env. Defaults to the current env when `--env` is omitted. Local envs run `nocobase-v1`, and Docker envs run inside the saved app container. Bridge flags (`--env`, `--yes`) must appear before the forwarded command. Use `--` when the forwarded command needs the same flag names.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> build',
+        '<%= config.bin %> <%= command.id %> --env local pm list',
+        '<%= config.bin %> <%= command.id %> --env docker-local -- pm enable @nocobase/plugin-sample --yes',
+    ];
+    async run() {
+        const originalArgv = [...this.argv];
+        await this.parse({ strict: false, flags: {}, args: {} }, []);
+        this.argv = originalArgv;
+        let parsed;
+        try {
+            parsed = parseBridgeArgv(this.argv);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+        const { requestedEnv, yes, passthroughArgs } = parsed;
+        if (passthroughArgs.length === 0) {
+            this.error('Pass at least one v1 command to forward.');
+        }
+        const explicitEnvSelection = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        if (explicitEnvSelection) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes,
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        const silentLike = hasSilentLikePassthrough(passthroughArgs);
+        const silentBridge = silentLike ? createSilentBridgeOptions() : undefined;
+        if (!silentLike) {
+            announceTargetEnv(runtime.envName);
+        }
+        if (runtime.kind === 'local') {
+            try {
+                await runLocalNocoBaseCommand(runtime, passthroughArgs, silentBridge?.commandOptions);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            finally {
+                silentBridge?.flush();
+            }
+            return;
+        }
+        if (runtime.kind === 'docker') {
+            try {
+                await runDockerNocoBaseCommand(runtime.containerName, passthroughArgs, silentBridge?.commandOptions);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            finally {
+                silentBridge?.flush();
+            }
+            return;
+        }
+        if (runtime.kind === 'http') {
+            this.error(formatHttpEnvError(runtime.envName));
+        }
+        this.error(formatSshEnvError(runtime.envName));
+    }
+}

package/dist/generated/command-registry.js

@@ -0,0 +1,133 @@
+/**
+ * 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.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { Command, loadHelpClass } from '@oclif/core';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { collectCommandModulePaths, commandRelativePathToRegistryKey, } from "../lib/command-discovery.js";
+import { getCurrentEnvName, getEnv } from "../lib/auth-store.js";
+import { createGeneratedFlags, GeneratedApiCommand } from "../lib/generated-command.js";
+import { toKebabCase } from "../lib/naming.js";
+import { loadRuntimeSync } from "../lib/runtime-store.js";
+const registryFilePath = fileURLToPath(import.meta.url);
+const commandsRoot = join(dirname(registryFilePath), '../commands');
+const commandModuleExtension = registryFilePath.endsWith('.ts') ? '.ts' : '.js';
+async function loadCommandsFromDirectory() {
+    const absolutePaths = await collectCommandModulePaths(commandsRoot, commandModuleExtension);
+    const entries = await Promise.all(absolutePaths.map(async (absolutePath) => {
+        const rel = relative(commandsRoot, absolutePath).replace(/\\/g, '/');
+        const key = commandRelativePathToRegistryKey(rel);
+        const mod = await import(__rewriteRelativeImportExtension(pathToFileURL(absolutePath).href));
+        return [key, mod.default];
+    }));
+    return Object.fromEntries(entries);
+}
+function readEnvName(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--env') {
+            return argv[index + 1];
+        }
+        if (token === '-e') {
+            return argv[index + 1];
+        }
+        if (token.startsWith('--env=')) {
+            return token.slice('--env='.length);
+        }
+    }
+    return undefined;
+}
+function createRuntimeCommand(operation) {
+    return class RuntimeCommand extends GeneratedApiCommand {
+        static summary = operation.summary;
+        static description = operation.description;
+        static examples = operation.examples;
+        static flags = createGeneratedFlags(operation);
+        static operation = operation;
+    };
+}
+function createRuntimeIndexCommand(commandId, metadata) {
+    const summary = metadata.summary || `Work with ${commandId}`;
+    const description = metadata.description && metadata.description !== summary ? metadata.description : undefined;
+    return class RuntimeIndexCommand extends Command {
+        static summary = summary;
+        static description = description;
+        async run() {
+            await this.parse(RuntimeIndexCommand);
+            const Help = await loadHelpClass(this.config);
+            await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+                this.id ?? commandId.replaceAll(' ', ':'),
+                ...this.argv,
+            ]);
+        }
+    };
+}
+function getRuntimeTopicEntries(operation) {
+    const commandSegments = operation.commandId.split(' ');
+    const topLevelCommandId = commandSegments[0];
+    const modulePrefix = toKebabCase(operation.moduleDisplayName || operation.moduleName || '');
+    const isTopLevelResource = Boolean(topLevelCommandId && modulePrefix && topLevelCommandId !== modulePrefix);
+    const entries = [];
+    if (!topLevelCommandId) {
+        return entries;
+    }
+    if (isTopLevelResource) {
+        entries.push([
+            topLevelCommandId,
+            {
+                summary: operation.resourceDescription || operation.resourceDisplayName,
+                description: operation.resourceDescription,
+            },
+        ]);
+        return entries;
+    }
+    entries.push([
+        topLevelCommandId,
+        {
+            summary: operation.moduleDescription || operation.moduleDisplayName || operation.moduleName,
+            description: operation.moduleDescription,
+        },
+    ]);
+    const resourceCommandId = commandSegments.slice(0, 2).join(' ');
+    if (commandSegments[1]) {
+        entries.push([
+            resourceCommandId,
+            {
+                summary: operation.resourceDescription || operation.resourceDisplayName,
+                description: operation.resourceDescription,
+            },
+        ]);
+    }
+    return entries;
+}
+const registry = {
+    ...(await loadCommandsFromDirectory()),
+};
+const envName = readEnvName(process.argv.slice(2)) ?? (await getCurrentEnvName());
+const env = await getEnv(envName);
+const runtime = loadRuntimeSync(env?.runtime?.version);
+for (const operation of runtime?.commands ?? []) {
+    const commandSegments = operation.commandId.split(' ');
+    const commandKey = commandSegments.join(':');
+    registry[`api:${commandKey}`] = createRuntimeCommand(operation);
+    for (const [topicCommandId, metadata] of getRuntimeTopicEntries(operation)) {
+        const topicKey = `api:${topicCommandId.split(' ').join(':')}`;
+        if (!registry[topicKey]) {
+            registry[topicKey] = createRuntimeIndexCommand(`api ${topicCommandId}`, metadata);
+        }
+    }
+}
+export default registry;

package/dist/help/runtime-help.js

@@ -0,0 +1,23 @@
+/**
+ * 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 { Help } from '@oclif/core';
+export function isTopicIndexCommand(commandId, topics) {
+    if (!commandId) {
+        return false;
+    }
+    return topics.some((topic) => topic.name.startsWith(`${commandId}:`));
+}
+export default class RuntimeHelp extends Help {
+    get sortedCommands() {
+        return super.sortedCommands.filter((command) => !isTopicIndexCommand(command.id, this.config.topics));
+    }
+    get sortedTopics() {
+        return super.sortedTopics.filter((topic) => !topic.hidden);
+    }
+}

package/dist/lib/api-client.js

@@ -0,0 +1,329 @@
+/**
+ * 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.
+ */
+/**
+ * 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 { createWriteStream } from 'node:fs';
+import { promises as fs } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { resolveServerRequestTarget } from './env-auth.js';
+import { fetchWithPreservedAuthRedirect } from './http-request.js';
+const CLI_REQUEST_SOURCE_HEADER = 'x-request-source';
+const CLI_REQUEST_SOURCE_VALUE = 'cli';
+function stripUtf8Bom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+function parseJsonInput(raw, flagName) {
+    const content = stripUtf8Bom(raw);
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON for --${flagName}: ${error?.message ?? 'parse failed'}`);
+    }
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '');
+}
+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,
+    };
+}
+async function parseBinaryResponse(response, outputPath) {
+    if (response.ok && response.body) {
+        await fs.mkdir(dirname(outputPath), { recursive: true }).catch(() => undefined);
+        await pipeline(Readable.fromWeb(response.body), createWriteStream(outputPath));
+        return {
+            ok: response.ok,
+            status: response.status,
+            data: {
+                output: outputPath,
+            },
+        };
+    }
+    return parseResponse(response);
+}
+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 !== '';
+}
+function listProvidedBodyFlags(flags, parameters) {
+    return parameters
+        .filter((parameter) => hasParameterValue(flags, parameter))
+        .map((parameter) => `--${parameter.flagName}`);
+}
+function parseBodyFieldValue(rawValue, parameter) {
+    if (rawValue === undefined) {
+        return undefined;
+    }
+    if (parameter.isArray && !parameter.jsonEncoded) {
+        return Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined;
+    }
+    if (parameter.jsonEncoded || parameter.type === 'object' || parameter.type === 'array') {
+        if (typeof rawValue !== 'string') {
+            return rawValue;
+        }
+        const parsed = parseJsonInput(rawValue, parameter.flagName);
+        if (parameter.type === 'array' && !Array.isArray(parsed)) {
+            throw new Error(`--${parameter.flagName} must be a JSON array`);
+        }
+        if (parameter.type === 'object' && (parsed === null || Array.isArray(parsed) || typeof parsed !== 'object')) {
+            throw new Error(`--${parameter.flagName} must be a JSON object`);
+        }
+        return parsed;
+    }
+    return parseScalarValue(rawValue, parameter.type);
+}
+export async function parseBody(flags, operation) {
+    if (operation.requestContentType === 'multipart/form-data') {
+        return undefined;
+    }
+    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) {
+        const providedBodyFlags = listProvidedBodyFlags(flags, bodyParameters);
+        const rawBodyInput = inlineBody ? '--body' : '--body-file';
+        throw new Error(`Conflicting request body inputs: received ${rawBodyInput} together with body field flags (${providedBodyFlags.join(', ')}). Use either body field flags or --body/--body-file.`);
+    }
+    if (inlineBody) {
+        return parseJsonInput(inlineBody, 'body');
+    }
+    if (bodyFile) {
+        return fs.readFile(bodyFile, 'utf8').then((content) => parseJsonInput(content, 'body-file'));
+    }
+    if (!bodyParameters.length) {
+        return undefined;
+    }
+    const body = {};
+    for (const parameter of bodyParameters) {
+        const rawValue = flags[parameter.flagName];
+        const value = parseBodyFieldValue(rawValue, parameter);
+        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;
+}
+async function createMultipartBody(flags, operation) {
+    const bodyParameters = operation.parameters.filter((parameter) => parameter.in === 'body');
+    const formData = new FormData();
+    let hasValues = false;
+    for (const parameter of bodyParameters) {
+        const rawValue = flags[parameter.flagName];
+        const hasValue = hasParameterValue(flags, parameter);
+        if (parameter.required && !hasValue) {
+            throw new Error(`Missing required body field --${parameter.flagName}`);
+        }
+        if (!hasValue) {
+            continue;
+        }
+        if (parameter.isFile) {
+            const filePath = String(rawValue);
+            const content = await fs.readFile(filePath);
+            const arrayBuffer = content.buffer.slice(content.byteOffset, content.byteOffset + content.byteLength);
+            formData.append(parameter.name, new Blob([arrayBuffer]), basename(filePath));
+            hasValues = true;
+            continue;
+        }
+        const value = parseBodyFieldValue(rawValue, parameter);
+        if (value === undefined) {
+            continue;
+        }
+        formData.append(parameter.name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+        hasValues = true;
+    }
+    if (!hasValues && operation.bodyRequired) {
+        throw new Error('Missing multipart request body.');
+    }
+    return hasValues ? formData : undefined;
+}
+export async function executeApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    headers.set(CLI_REQUEST_SOURCE_HEADER, CLI_REQUEST_SOURCE_VALUE);
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    if (options.role) {
+        headers.set('x-role', options.role);
+    }
+    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 = options.operation.requestContentType === 'multipart/form-data'
+        ? await createMultipartBody(options.flags, options.operation)
+        : await parseBody(options.flags, options.operation);
+    if (body !== undefined && options.operation.requestContentType !== 'multipart/form-data') {
+        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 fetchWithPreservedAuthRedirect(url.toString(), {
+        method: options.operation.method.toUpperCase(),
+        headers,
+        body: body === undefined ? undefined : body instanceof FormData ? body : JSON.stringify(body),
+    });
+    if (options.operation.responseType === 'binary') {
+        const outputPath = options.flags.output;
+        if (!outputPath) {
+            throw new Error('Missing required output path --output');
+        }
+        return parseBinaryResponse(response, outputPath);
+    }
+    return parseResponse(response);
+}
+export async function executeRawApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    headers.set(CLI_REQUEST_SOURCE_HEADER, CLI_REQUEST_SOURCE_VALUE);
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    if (options.role) {
+        headers.set('x-role', options.role);
+    }
+    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 controller = options.timeoutMs && options.timeoutMs > 0 ? new AbortController() : undefined;
+    const timeout = controller
+        ? setTimeout(() => {
+            controller.abort();
+        }, options.timeoutMs)
+        : undefined;
+    try {
+        const response = await fetchWithPreservedAuthRedirect(url.toString(), {
+            method: options.method.toUpperCase(),
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal: controller?.signal,
+        });
+        return parseResponse(response);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}