@share-crm/sharecrm-cli 1.1.0

package/dist/commands/help/help.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHelpCommand = runHelpCommand;
+exports.renderGlobalHelp = renderGlobalHelp;
+exports.renderManifestHelp = renderManifestHelp;
+exports.renderCommandHelp = renderCommandHelp;
+exports.renderExecuteHelp = renderExecuteHelp;
+const constants_1 = require("../../shared/constants");
+const apiClient_1 = require("../../core/http/apiClient");
+const errors_1 = require("../../core/output/errors");
+const stdout_1 = require("../../core/output/stdout");
+const sessionStore_1 = require("../../core/state/sessionStore");
+async function runHelpCommand(command, helpTarget = []) {
+    if (helpTarget.length === 0) {
+        command.outputHelp();
+        const session = await loadSessionForHelp();
+        if (!session?.accessToken) {
+            (0, stdout_1.writeStdout)('Login to view available business commands.');
+            return;
+        }
+        const manifest = await new apiClient_1.ApiClient().fetchCommandManifest(session);
+        (0, stdout_1.writeStdout)(renderGlobalHelp(manifest.commands));
+        return;
+    }
+    const session = await loadSessionForHelp();
+    if (!session?.accessToken) {
+        (0, stdout_1.writeStdout)('Please login first to view remote command help.');
+        return;
+    }
+    const commandKey = helpTarget.join(' ');
+    try {
+        const manifest = await new apiClient_1.ApiClient().fetchCommandManifest(session, commandKey);
+        (0, stdout_1.writeStdout)(renderManifestHelp(helpTarget, manifest.commands));
+    }
+    catch (error) {
+        const remoteError = extractRemoteError(error);
+        if (remoteError?.help) {
+            (0, stdout_1.writeStdout)(renderExecuteHelp(remoteError.help, remoteError.commandKey ?? commandKey));
+            return;
+        }
+        throw error;
+    }
+}
+async function loadSessionForHelp() {
+    try {
+        return await new sessionStore_1.SessionStore().load();
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError && error.message === 'Failed to read session file.') {
+            return null;
+        }
+        throw error;
+    }
+}
+function renderGlobalHelp(commands) {
+    if (commands.length === 0) {
+        return 'No business commands available.';
+    }
+    return [
+        renderUsageBlock('sharecrm <command>'),
+        renderCommandList(commands),
+    ].join('\n\n');
+}
+function renderManifestHelp(helpTarget, commands) {
+    if (commands.length === 0) {
+        return 'Command not found.';
+    }
+    if (shouldRenderCommandList(helpTarget, commands)) {
+        return [
+            renderUsageBlock(`sharecrm ${helpTarget.join(' ')} <command>`),
+            renderCommandList(commands, helpTarget.join(' ')),
+        ].join('\n\n');
+    }
+    return renderCommandHelp(commands);
+}
+function renderCommandHelp(commands) {
+    if (commands.length === 0) {
+        return 'Command not found.';
+    }
+    const [current, ...subCommands] = commands;
+    const lines = [
+        current.description ?? current.summary ?? current.commandKey,
+        '',
+        renderUsageBlock(resolveUsage(current.commandKey, current.usage)),
+    ];
+    if (subCommands.length > 0) {
+        lines.push('', renderCommandList(subCommands, current.commandKey));
+    }
+    const properties = current.argumentsSchema && 'properties' in current.argumentsSchema
+        ? current.argumentsSchema.properties
+        : undefined;
+    if (properties && Object.keys(properties).length > 0) {
+        lines.push('', 'Flags:');
+        for (const [key, value] of Object.entries(properties)) {
+            lines.push(formatFlagRow(value.title ?? key, value.type ?? 'unknown', value.description ?? ''));
+        }
+    }
+    return lines.join('\n');
+}
+function renderExecuteHelp(content, commandKey) {
+    const normalizedCommandKey = commandKey.trim();
+    const schemaCommandKey = normalizedCommandKey || content.apiName || content.command || 'unknown';
+    const helpCommandKey = content.command
+        ? normalizedCommandKey
+        : schemaCommandKey;
+    return renderCommandHelp([
+        {
+            commandKey: helpCommandKey,
+            description: content.description,
+            usage: content.usage,
+            argumentsSchema: content.input ?? null,
+        },
+    ]);
+}
+function extractRemoteError(error) {
+    if (!(error instanceof errors_1.CliError)) {
+        return null;
+    }
+    const remoteError = error.details?.remoteError;
+    if (!remoteError || typeof remoteError !== 'object') {
+        return null;
+    }
+    return remoteError;
+}
+function shouldRenderCommandList(helpTarget, commands) {
+    if (commands.length <= 1) {
+        return false;
+    }
+    const target = helpTarget.join(' ').trim();
+    if (!target) {
+        return true;
+    }
+    return commands.every((command) => command.commandKey.length > target.length && command.commandKey.startsWith(`${target} `));
+}
+function renderUsageBlock(usage) {
+    return ['Usage:', `  ${usage}`].join('\n');
+}
+function renderCommandList(commands, parentCommandKey) {
+    const lines = ['Available Commands:'];
+    for (const command of commands) {
+        const relativeCommand = parentCommandKey && command.commandKey.startsWith(`${parentCommandKey} `)
+            ? command.commandKey.slice(parentCommandKey.length).trim()
+            : command.commandKey;
+        lines.push(formatCommandRow(relativeCommand, command.description ?? command.summary ?? ''));
+    }
+    return lines.join('\n');
+}
+function resolveUsage(commandKey, usage) {
+    const normalizedUsage = normalizeUsage(usage ?? commandKey);
+    if (!usage) {
+        return normalizedUsage;
+    }
+    const withoutCliPrefix = normalizedUsage.replace(/^cli\s+/, '');
+    const commandKeyParts = commandKey.trim().split(/\s+/).filter(Boolean);
+    const usageParts = withoutCliPrefix.split(/\s+/).filter(Boolean);
+    if (usageParts.length === 0) {
+        return `${constants_1.CLI_NAME} ${commandKey}`;
+    }
+    const remainder = usageParts.slice(1).join(' ');
+    if (usageParts[0] === commandKeyParts[commandKeyParts.length - 1] && commandKeyParts.length > 1) {
+        return `${constants_1.CLI_NAME} ${commandKey}${remainder ? ` ${remainder}` : ''}`;
+    }
+    return normalizedUsage;
+}
+function normalizeUsage(usage) {
+    return usage.replace(/^share-cli\b/, `${constants_1.CLI_NAME}`);
+}
+function formatCommandRow(command, description) {
+    return `  ${command.padEnd(18)} ${description}`.trimEnd();
+}
+function formatFlagRow(name, type, description) {
+    const header = `${name} ${type}`.trim();
+    return `  ${header.padEnd(24)} ${description}`.trimEnd();
+}

package/dist/commands/remote/execute.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRemoteCommand = runRemoteCommand;
+const apiClient_1 = require("../../core/http/apiClient");
+const errors_1 = require("../../core/output/errors");
+const stdout_1 = require("../../core/output/stdout");
+const sessionStore_1 = require("../../core/state/sessionStore");
+const help_1 = require("../help/help");
+const constants_1 = require("../../shared/constants");
+async function runRemoteCommand(commandKey, arg, mode) {
+    const session = await new sessionStore_1.SessionStore().load();
+    if (!session?.accessToken) {
+        throw new errors_1.AuthenticationRequiredCliError();
+    }
+    const isHelpFlag = mode === 'help';
+    //console.log('arg:' + arg + ',commandKey:' + commandKey + ' ,isHelpFlag:' + mode);
+    const argumentsPayload = parseArguments(arg);
+    let result;
+    try {
+        result = await new apiClient_1.ApiClient().executeRemoteCommand(session, commandKey, argumentsPayload);
+    }
+    catch (error) {
+        const remoteError = extractRemoteError(error);
+        if (remoteError) {
+            (0, stdout_1.writeStdout)(formatRemoteErrorSummary(remoteError, isHelpFlag));
+            return;
+        }
+        throw error;
+    }
+    if (result.helpInfoReturned) {
+        (0, stdout_1.writeStdout)((0, help_1.renderExecuteHelp)(result.content, result.commandKey));
+        return;
+    }
+    if (result.errorMessage) {
+        throw new errors_1.CliError(result.errorMessage, 1, { commandKey: result.commandKey });
+    }
+    (0, stdout_1.writeStdout)(formatExecuteResult(result));
+}
+function extractRemoteError(error) {
+    if (!(error instanceof errors_1.CliError)) {
+        return null;
+    }
+    const remoteError = error.details?.remoteError;
+    if (!remoteError || typeof remoteError !== 'object') {
+        return null;
+    }
+    return remoteError;
+}
+function formatRemoteErrorSummary(remoteError, isHelpFlag = false) {
+    const lines = [];
+    if (!isHelpFlag) {
+        if (remoteError.commandKey) {
+            lines.push(`\ncommand：${constants_1.CLI_NAME} ${remoteError.commandKey}`);
+        }
+        if (remoteError.errorCode) {
+            lines.push(`errorCode：${remoteError.errorCode}`);
+        }
+        if (remoteError.errorMessage) {
+            lines.push(`errorMsg：${remoteError.errorMessage}`);
+        }
+        if (remoteError.hint) {
+            lines.push(`Tips：${remoteError.hint.replace(/^share-cli\b/, constants_1.CLI_NAME)} view the command help info`);
+        }
+    }
+    const summary = lines.join('\n');
+    const helpText = remoteError.help ? formatRemoteErrorHelp(remoteError.help, remoteError.commandKey) : '';
+    if (!helpText) {
+        return summary;
+    }
+    if (!summary) {
+        return helpText;
+    }
+    return `${summary}\n\n${helpText}`;
+}
+function formatRemoteErrorHelp(help, commandKey) {
+    if (help.hasSubCommands === false && help.input) {
+        return (0, help_1.renderExecuteHelp)(help, commandKey ?? help.command ?? help.apiName ?? '');
+    }
+    const lines = [];
+    if (help.description) {
+        lines.push(help.description.replace(/^Share CLI\b/g, constants_1.CLI_NAME));
+    }
+    if (help.usage) {
+        lines.push('', 'Usage:', `  ${help.usage.replaceAll(/\bshare-cli\b/g, constants_1.CLI_NAME).replace('--userInput', '--data').replace('--query', '--data')}`);
+    }
+    if (help.subCommands?.length) {
+        lines.push('', 'Commands:');
+        for (const subCommand of help.subCommands) {
+            const command = subCommand.command ?? '';
+            const description = subCommand.description ?? '';
+            lines.push(`  ${command.padEnd(21, ' ')}${description}`.trimEnd());
+        }
+    }
+    return lines.join('\n');
+}
+function parseArguments(arg) {
+    if (!arg) {
+        throw new errors_1.CliError('The -d option requires a JSON object payload.', 1);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(arg);
+    }
+    catch {
+        throw new errors_1.CliError('The -d option must be valid JSON.', 1);
+    }
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object') {
+        throw new errors_1.CliError('The -d option must be a JSON object.', 1);
+    }
+    return parsed;
+}
+function formatExecuteResult(result) {
+    switch (result.outputType) {
+        case 'text':
+        case 'markdown':
+            return typeof result.content === 'string' ? result.content : stringifyValue(result.content);
+        case 'json':
+            return JSON.stringify(result.content ?? null, null, 2);
+        default:
+            return stringifyValue(result.content);
+    }
+}
+function stringifyValue(content) {
+    if (content === null || content === undefined) {
+        return 'null';
+    }
+    if (typeof content === 'string') {
+        return content;
+    }
+    return JSON.stringify(content, null, 2);
+}

package/dist/core/auth/authTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/auth/deviceFlow.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toScope = toScope;
+exports.requestDeviceCode = requestDeviceCode;
+exports.pollDeviceAuthorization = pollDeviceAuthorization;
+exports.refreshAccessToken = refreshAccessToken;
+const errors_1 = require("../output/errors");
+const apiClient_1 = require("../http/apiClient");
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toScope(scope) {
+    return scope?.split(/\s+/).map((value) => value.trim()).filter(Boolean) ?? [];
+}
+function toSessionRecord(response, existing) {
+    return {
+        accessToken: response.accessToken,
+        refreshToken: response.refreshToken ?? existing?.refreshToken,
+        tokenExpireAt: Date.now() + response.expiresIn * 1000,
+        scope: toScope(response.scope),
+        userId: response.userId ?? existing?.userId,
+        appId: response.appId ?? existing?.appId,
+        apiUrl: response.apiUrl ?? existing?.apiUrl,
+        grantedAt: existing?.grantedAt,
+        identity: existing?.identity,
+        userName: response.userName ?? existing?.userName,
+    };
+}
+async function requestDeviceCode(clientId, apiClient = new apiClient_1.ApiClient()) {
+    void clientId;
+    const response = await apiClient.requestDeviceCode();
+    return {
+        deviceCode: response.deviceCode,
+        userCode: response.userCode,
+        verificationUrl: response.verificationUrl,
+        interval: response.interval,
+        expiresIn: response.expireIn,
+        traceId: response.traceId,
+    };
+}
+async function pollDeviceAuthorization(deviceCode, intervalSeconds = 5, apiClient = new apiClient_1.ApiClient(), { maxAttempts = 600 } = {}) {
+    let intervalMs = intervalSeconds * 1000;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        attempts++;
+        try {
+            const response = await apiClient.requestDeviceToken(deviceCode);
+            return toSessionRecord(response);
+        }
+        catch (error) {
+            if (!(error instanceof errors_1.ApiResponseCliError)) {
+                throw error;
+            }
+            if (error.errorCode === 40001) {
+                await sleep(intervalMs);
+                continue;
+            }
+            if (error.errorCode === 40002) {
+                intervalMs += 5_000;
+                await sleep(intervalMs);
+                continue;
+            }
+            if (error.errorCode === 40003) {
+                throw new errors_1.CliError('Device code expired. Please run auth login again.', 1, error.details);
+            }
+            if (error.errorCode === 40004) {
+                throw new errors_1.CliError('Authorization was denied. Please try again after granting access.', 1, error.details);
+            }
+            throw error;
+        }
+    }
+    throw new errors_1.CliError('设备授权超时，请重新尝试登录。', 1);
+}
+async function refreshAccessToken(refreshToken, appId, apiClient = new apiClient_1.ApiClient(), existing) {
+    const response = await apiClient.refreshToken(refreshToken, appId);
+    return toSessionRecord(response, existing);
+}

package/dist/core/auth/tokenManager.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenManager = exports.SessionRefreshPersistenceError = void 0;
+const deviceFlow_1 = require("./deviceFlow");
+const sessionStore_1 = require("../state/sessionStore");
+class SessionRefreshPersistenceError extends Error {
+    session;
+    constructor(session, options) {
+        super('Failed to persist refreshed session.');
+        this.session = session;
+        this.name = 'SessionRefreshPersistenceError';
+        if (options?.cause !== undefined) {
+            this.cause = options.cause;
+        }
+    }
+}
+exports.SessionRefreshPersistenceError = SessionRefreshPersistenceError;
+class TokenManager {
+    isExpired(session) {
+        if (!session?.tokenExpireAt) {
+            return false;
+        }
+        return session.tokenExpireAt <= Date.now();
+    }
+    shouldRefresh(session, skewMs = 60_000) {
+        if (!session?.tokenExpireAt || !session.refreshToken) {
+            return false;
+        }
+        return session.tokenExpireAt <= Date.now() + skewMs;
+    }
+    async refreshSession(session) {
+        if (!session.refreshToken || !session.appId) {
+            return session;
+        }
+        const refreshed = await (0, deviceFlow_1.refreshAccessToken)(session.refreshToken, session.appId, undefined, session);
+        try {
+            await new sessionStore_1.SessionStore().save(refreshed);
+        }
+        catch (error) {
+            throw new SessionRefreshPersistenceError(refreshed, { cause: error });
+        }
+        return refreshed;
+    }
+}
+exports.TokenManager = TokenManager;

package/dist/core/cache/cacheTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/cache/commandCache.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandCache = void 0;
+const constants_1 = require("../../shared/constants");
+const utils_1 = require("../../shared/utils");
+class CommandCache {
+    record = null;
+    get() {
+        return this.record;
+    }
+    set(commands, ttlSeconds = constants_1.DEFAULT_COMMAND_CACHE_TTL_SECONDS) {
+        const expireAt = Date.now() + ttlSeconds * 1000;
+        this.record = {
+            fetchedAt: (0, utils_1.toIsoTimestamp)(),
+            expireAt,
+            commands: [...commands],
+        };
+        return this.record;
+    }
+    has(commandKey) {
+        return Boolean(this.record?.commands.includes(commandKey));
+    }
+}
+exports.CommandCache = CommandCache;

package/dist/core/config/authBaseUrl.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAuthBaseUrl = normalizeAuthBaseUrl;
+const errors_1 = require("../output/errors");
+function normalizeAuthBaseUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('https://')) {
+        throw new errors_1.CliError('FS_CLI_AUTH_BASE_URL 必须使用 HTTPS 协议。', 1);
+    }
+    return trimmed.endsWith('/') ? trimmed : `${trimmed}/`;
+}

package/dist/core/config/envPersistence.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistAuthBaseUrl = persistAuthBaseUrl;
+exports.setWindowsUserEnvironmentVariable = setWindowsUserEnvironmentVariable;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../output/errors");
+function resolveShellProfilePath(homedirFn, platform, env) {
+    if (platform === 'win32') {
+        throw new errors_1.CliError('Use setWindowsUserEnvironmentVariable for Windows.', 1);
+    }
+    const shell = env.SHELL ?? '/bin/sh';
+    const home = homedirFn();
+    if (shell.includes('zsh')) {
+        return node_path_1.default.join(home, '.zshrc');
+    }
+    if (shell.includes('bash')) {
+        return node_path_1.default.join(home, '.bashrc');
+    }
+    return node_path_1.default.join(home, '.bashrc');
+}
+function upsertShellExport(content, envName, newLine) {
+    const lines = content.split('\n');
+    const existingIndex = lines.findIndex((line) => line.startsWith(`export ${envName}=`));
+    if (existingIndex >= 0) {
+        lines[existingIndex] = newLine;
+    }
+    else {
+        lines.push(newLine);
+    }
+    return lines.join('\n');
+}
+async function persistAuthBaseUrl(value, opts = {}) {
+    const platform = opts.platform ?? process.platform;
+    const env = opts.env ?? process.env;
+    const homedirFn = opts.homedirFn ?? (() => node_os_1.default.homedir());
+    if (platform === 'win32') {
+        await setWindowsUserEnvironmentVariable('FS_CLI_AUTH_BASE_URL', value, opts.execFile ?? (0, node_util_1.promisify)(node_child_process_1.execFile));
+        return;
+    }
+    const profilePath = resolveShellProfilePath(homedirFn, platform, env);
+    const line = `export FS_CLI_AUTH_BASE_URL="${value}"`;
+    const content = await (0, promises_1.readFile)(profilePath, 'utf8').catch(() => '');
+    const next = upsertShellExport(content, 'FS_CLI_AUTH_BASE_URL', line);
+    await (0, promises_1.writeFile)(profilePath, next, 'utf8');
+}
+async function setWindowsUserEnvironmentVariable(name, value, execFile) {
+    const quotedValue = `"${value}"`;
+    const { stderr } = await execFile('setx', [name, quotedValue]);
+    if (stderr) {
+        throw new errors_1.CliError(`setx stderr: ${stderr}`, 1);
+    }
+}

package/dist/core/config/interactive.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptText = promptText;
+exports.readStdinText = readStdinText;
+exports.promptSelect = promptSelect;
+const promises_1 = __importDefault(require("node:readline/promises"));
+const node_events_1 = require("node:events");
+const node_process_1 = require("node:process");
+const errors_1 = require("../output/errors");
+async function promptText(message) {
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        return (await rl.question(message)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function readStdinText(message) {
+    node_process_1.stdout.write(message);
+    if (node_process_1.stdin.readableEnded) {
+        return '';
+    }
+    if (node_process_1.stdin.isTTY) {
+        const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout, terminal: false });
+        try {
+            const line = await rl.question('');
+            return line.trim();
+        }
+        finally {
+            rl.close();
+        }
+    }
+    node_process_1.stdin.setEncoding('utf8');
+    let buffer = '';
+    node_process_1.stdin.resume();
+    node_process_1.stdin.on('data', onData);
+    try {
+        await (0, node_events_1.once)(node_process_1.stdin, 'end');
+    }
+    finally {
+        node_process_1.stdin.off('data', onData);
+    }
+    return buffer.trim();
+    function onData(chunk) {
+        buffer += chunk.toString();
+    }
+}
+async function promptSelect(message, options) {
+    const rendered = options.map((option, index) => `${index + 1}. ${option.label}`).join('\n');
+    const answer = await promptText(`${message}\n${rendered}\n请输入序号: `);
+    const picked = options[Number(answer) - 1];
+    if (!picked) {
+        throw new errors_1.CliError('无效的选项，请重新执行 config init。', 1);
+    }
+    return picked.value;
+}

package/dist/core/config/locale.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LOCALE = exports.SUPPORTED_LOCALES = void 0;
+exports.isCliLocale = isCliLocale;
+exports.SUPPORTED_LOCALES = ['zh-CN', 'en', 'zh-TW'];
+exports.DEFAULT_LOCALE = 'zh-CN';
+function isCliLocale(value) {
+    return exports.SUPPORTED_LOCALES.includes(value);
+}

package/dist/core/debug/debugOutput.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeDebugRequest = writeDebugRequest;
+exports.writeDebugResponse = writeDebugResponse;
+exports.writeDebugException = writeDebugException;
+const stderr_1 = require("../output/stderr");
+function writeDebugBlock(label, payload) {
+    (0, stderr_1.writeStderr)(`[debug] ${label} ${JSON.stringify(payload, null, 2)}`);
+}
+function writeDebugRequest(payload) {
+    writeDebugBlock('request', payload);
+}
+function writeDebugResponse(payload) {
+    writeDebugBlock('response', payload);
+}
+function writeDebugException(payload) {
+    writeDebugBlock('exception', payload);
+}

package/dist/core/debug/runtimeDebug.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Process-local debug state primitive.
+ * Used to control global debug logging across the CLI.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDebugEnabled = setDebugEnabled;
+exports.isDebugEnabled = isDebugEnabled;
+exports.resetDebugState = resetDebugState;
+let debugEnabled = false;
+function setDebugEnabled(value) {
+    debugEnabled = value;
+}
+function isDebugEnabled() {
+    return debugEnabled;
+}
+function resetDebugState() {
+    debugEnabled = false;
+}