@carthooks/arcubase-cli 0.1.0

package/dist/runtime/body_loader.d.ts

@@ -0,0 +1,3 @@
+export declare function loadBodyFromFlags(flags: Record<string, string | boolean>): unknown | undefined;
+export declare function loadQueryFromFlags(flags: Record<string, string | boolean>): Record<string, any> | undefined;
+//# sourceMappingURL=body_loader.d.ts.map

package/dist/runtime/body_loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body_loader.d.ts","sourceRoot":"","sources":["../../src/runtime/body_loader.ts"],"names":[],"mappings":"AAWA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,OAAO,GAAG,SAAS,CAI9F;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAQ3G"}

package/dist/runtime/body_loader.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import { CLIError } from './errors.js';
+function parseJSONFile(filePath, label) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        throw new CLIError('INVALID_JSON_FILE', `${label} file is invalid: ${filePath}`, 2);
+    }
+}
+export function loadBodyFromFlags(flags) {
+    const bodyFile = typeof flags['body-file'] === 'string' ? flags['body-file'] : undefined;
+    if (!bodyFile)
+        return undefined;
+    return parseJSONFile(bodyFile, 'body');
+}
+export function loadQueryFromFlags(flags) {
+    const queryFile = typeof flags['query-file'] === 'string' ? flags['query-file'] : undefined;
+    if (!queryFile)
+        return undefined;
+    const parsed = parseJSONFile(queryFile, 'query');
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new CLIError('INVALID_QUERY_FILE', 'query file must contain a JSON object', 2);
+    }
+    return parsed;
+}

package/dist/runtime/command_registry.d.ts

@@ -0,0 +1,9 @@
+import { adminCommands, userCommands } from '../generated/command_registry.generated.js';
+export { adminCommands, userCommands };
+export type CommandScope = 'admin' | 'user';
+export type CommandDef = (typeof adminCommands)[number] | (typeof userCommands)[number];
+export declare function listCommands(scope: CommandScope): readonly CommandDef[];
+export declare function findCommand(scope: CommandScope, moduleName: string, commandName: string): CommandDef | null;
+export declare function listModules(scope: CommandScope): string[];
+export declare function listModuleCommands(scope: CommandScope, moduleName: string): readonly CommandDef[];
+//# sourceMappingURL=command_registry.d.ts.map

package/dist/runtime/command_registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_registry.d.ts","sourceRoot":"","sources":["../../src/runtime/command_registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAA;AAExF,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,CAAA;AAEtC,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,CAAA;AAC3C,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvF,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,UAAU,EAAE,CAEvE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAE3G;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,EAAE,CAEzD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE,CAEjG"}

package/dist/runtime/command_registry.js

@@ -0,0 +1,14 @@
+import { adminCommands, userCommands } from '../generated/command_registry.generated.js';
+export { adminCommands, userCommands };
+export function listCommands(scope) {
+    return scope === 'admin' ? adminCommands : userCommands;
+}
+export function findCommand(scope, moduleName, commandName) {
+    return listCommands(scope).find((item) => item.commandPath[0] === moduleName && item.commandPath[1] === commandName) ?? null;
+}
+export function listModules(scope) {
+    return [...new Set(listCommands(scope).map((item) => item.commandPath[0]))].sort();
+}
+export function listModuleCommands(scope, moduleName) {
+    return listCommands(scope).filter((item) => item.commandPath[0] === moduleName);
+}

package/dist/runtime/env.d.ts

@@ -0,0 +1,14 @@
+export type RuntimeEnv = {
+    ARCUBASE_BASE_URL: string;
+    ARCUBASE_TENANT_ID: string;
+    ARCUBASE_ACCESS_TOKEN: string;
+    ARCUBASE_TRACE_ID?: string;
+    ARCUBASE_SUBJECT_TYPE?: string;
+    ARCUBASE_SUBJECT_ID?: string;
+    ARCUBASE_TOKEN_EXPIRES_AT?: string;
+};
+export type RuntimeEnvScope = 'admin' | 'user';
+type EnvInput = Record<string, string | undefined>;
+export declare function loadRuntimeEnv(scope: RuntimeEnvScope, env?: EnvInput): RuntimeEnv;
+export {};
+//# sourceMappingURL=env.d.ts.map

package/dist/runtime/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/runtime/env.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,qBAAqB,EAAE,MAAM,CAAA;IAC7B,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,yBAAyB,CAAC,EAAE,MAAM,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,CAAA;AAE9C,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;AAqClD,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,GAAE,QAAsB,GAAG,UAAU,CAU9F"}

package/dist/runtime/env.js

@@ -0,0 +1,42 @@
+const PREFIX_BY_SCOPE = {
+    admin: 'ARCUBASE_ADMIN_',
+    user: 'ARCUBASE_USER_',
+};
+function envValue(env, scope, key) {
+    const direct = env[key];
+    if (direct && direct.trim() !== '') {
+        return direct.trim();
+    }
+    const suffix = String(key).replace(/^ARCUBASE_/, '');
+    const scopedKey = `${PREFIX_BY_SCOPE[scope]}${suffix}`;
+    const scopedValue = env[scopedKey];
+    if (!scopedValue || scopedValue.trim() === '') {
+        return undefined;
+    }
+    return scopedValue.trim();
+}
+function requiredValue(env, scope, key) {
+    const value = envValue(env, scope, key);
+    if (!value || value.trim() === '') {
+        throw new Error(`${key} is required`);
+    }
+    return value;
+}
+function optionalValue(env, scope, key) {
+    const value = envValue(env, scope, key);
+    if (!value || value.trim() === '') {
+        return undefined;
+    }
+    return value;
+}
+export function loadRuntimeEnv(scope, env = process.env) {
+    return {
+        ARCUBASE_BASE_URL: requiredValue(env, scope, 'ARCUBASE_BASE_URL'),
+        ARCUBASE_TENANT_ID: requiredValue(env, scope, 'ARCUBASE_TENANT_ID'),
+        ARCUBASE_ACCESS_TOKEN: requiredValue(env, scope, 'ARCUBASE_ACCESS_TOKEN'),
+        ARCUBASE_TRACE_ID: optionalValue(env, scope, 'ARCUBASE_TRACE_ID'),
+        ARCUBASE_SUBJECT_TYPE: optionalValue(env, scope, 'ARCUBASE_SUBJECT_TYPE'),
+        ARCUBASE_SUBJECT_ID: optionalValue(env, scope, 'ARCUBASE_SUBJECT_ID'),
+        ARCUBASE_TOKEN_EXPIRES_AT: optionalValue(env, scope, 'ARCUBASE_TOKEN_EXPIRES_AT')
+    };
+}

package/dist/runtime/errors.d.ts

@@ -0,0 +1,23 @@
+export type CLIValidationIssue = {
+    path: string;
+    message: string;
+};
+export type CLITSTypeHint = {
+    symbol: string;
+    file: string;
+};
+export type CLIErrorDetails = {
+    operation?: string;
+    requestType?: string;
+    issues?: CLIValidationIssue[];
+    tsHints?: CLITSTypeHint[];
+    reason?: string;
+};
+export declare class CLIError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    readonly details?: CLIErrorDetails;
+    constructor(code: string, message: string, exitCode?: number, details?: CLIErrorDetails);
+    toJSON(): Record<string, unknown>;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/runtime/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAC7B,OAAO,CAAC,EAAE,aAAa,EAAE,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAA;gBAEtB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,OAAO,CAAC,EAAE,eAAe;IAQlF,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CASlC"}

package/dist/runtime/errors.js

@@ -0,0 +1,18 @@
+export class CLIError extends Error {
+    constructor(code, message, exitCode = 1, details) {
+        super(message);
+        this.name = 'CLIError';
+        this.code = code;
+        this.exitCode = exitCode;
+        this.details = details;
+    }
+    toJSON() {
+        return {
+            error: {
+                code: this.code,
+                message: this.message,
+                ...(this.details ? this.details : {}),
+            },
+        };
+    }
+}

package/dist/runtime/execute.d.ts

@@ -0,0 +1,17 @@
+import { type RuntimeEnv } from './env.js';
+import { type CommandScope } from './command_registry.js';
+export type CommandExecutionSummary = {
+    scope: CommandScope;
+    commandPath: readonly [string, string];
+    method: string;
+    endpoint: string;
+    requestType: string | null;
+    pathFlags: readonly string[];
+    scalarFlags: readonly string[];
+};
+export declare function renderRootHelp(scope: CommandScope): string;
+export declare function renderModuleHelp(scope: CommandScope, moduleName: string): string;
+export declare function renderCommandHelp(scope: CommandScope, moduleName: string, commandName: string): string;
+export declare function summarizeCommand(scope: CommandScope, moduleName: string, commandName: string): CommandExecutionSummary;
+export declare function executeCLI(scope: CommandScope, argv: string[], env?: RuntimeEnv, fetchImpl?: typeof fetch): Promise<any>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/runtime/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/runtime/execute.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,UAAU,CAAA;AAG1D,OAAO,EAAgD,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAIvG,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,YAAY,CAAA;IACnB,WAAW,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IAC5B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAQ1D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAWhF;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAatG;AA8CD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,uBAAuB,CActH;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,GAAE,UAAkC,EAAE,SAAS,GAAE,OAAO,KAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAyF5J"}

package/dist/runtime/execute.js

@@ -0,0 +1,183 @@
+import { parseCLIArgs, hasFlag, flagValue } from './argv.js';
+import { loadRuntimeEnv } from './env.js';
+import { CLIError } from './errors.js';
+import { buildRequestHeaders, buildURL } from './http.js';
+import { listModules, listModuleCommands, findCommand } from './command_registry.js';
+import { loadBodyFromFlags, loadQueryFromFlags } from './body_loader.js';
+import { getBodySchema, getTypeHints, getUnsupportedBodySchemaReason } from './zod_registry.js';
+export function renderRootHelp(scope) {
+    const binary = scope === 'admin' ? 'arcubase-admin' : 'arcubase';
+    return [
+        `${binary} <module> <command> [flags]`,
+        '',
+        'modules:',
+        ...listModules(scope).map((item) => `  - ${item}`),
+    ].join('\n');
+}
+export function renderModuleHelp(scope, moduleName) {
+    const items = listModuleCommands(scope, moduleName);
+    if (items.length === 0) {
+        throw new CLIError('UNKNOWN_MODULE', `unknown module: ${moduleName}`, 2);
+    }
+    return [
+        `${scope === 'admin' ? 'arcubase-admin' : 'arcubase'} ${moduleName} <command> [flags]`,
+        '',
+        'commands:',
+        ...items.map((item) => `  - ${item.commandPath[1]}`),
+    ].join('\n');
+}
+export function renderCommandHelp(scope, moduleName, commandName) {
+    const command = findCommand(scope, moduleName, commandName);
+    if (!command) {
+        throw new CLIError('UNKNOWN_COMMAND', `unknown command: ${moduleName} ${commandName}`, 2);
+    }
+    return [
+        `${scope === 'admin' ? 'arcubase-admin' : 'arcubase'} ${moduleName} ${commandName}`,
+        `method: ${command.method}`,
+        `endpoint: ${command.endpoint}`,
+        command.requestType ? `body: ${command.requestType} via --body-file` : 'body: none',
+        command.endpointParams.length ? `path flags: ${command.endpointParams.map((item) => `--${item.replace(/_/g, '-')}`).join(', ')}` : 'path flags: none',
+        command.scalarParams.length ? `scalar flags: ${command.scalarParams.map((item) => `--${item.name.replace(/([A-Z])/g, '-$1').toLowerCase()}`).join(', ')}` : 'scalar flags: none',
+    ].join('\n');
+}
+function coerceScalar(value, typeText) {
+    const normalized = typeText.trim();
+    if (normalized === 'number' || normalized === 'string | number') {
+        const parsed = Number(value);
+        if (Number.isNaN(parsed)) {
+            throw new CLIError('INVALID_FLAG_VALUE', `expected number, got ${value}`, 2);
+        }
+        return parsed;
+    }
+    if (normalized === 'boolean') {
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        throw new CLIError('INVALID_FLAG_VALUE', `expected boolean, got ${value}`, 2);
+    }
+    return value;
+}
+function resolveEndpoint(endpoint, flags) {
+    let resolved = endpoint;
+    for (const placeholder of [...endpoint.matchAll(/:([A-Za-z0-9_]+)/g)].map((match) => match[1])) {
+        const flagName = placeholder.replace(/_/g, '-');
+        const value = flagValue(flags, flagName);
+        if (!value) {
+            throw new CLIError('MISSING_PATH_FLAG', `missing required flag --${flagName}`, 2);
+        }
+        resolved = resolved.replace(`:${placeholder}`, encodeURIComponent(value));
+    }
+    return resolved;
+}
+function buildScalarQuery(command, flags) {
+    if (!command) {
+        return undefined;
+    }
+    const out = {};
+    for (const scalar of command.scalarParams) {
+        const flagName = scalar.name.replace(/([A-Z])/g, '-$1').toLowerCase();
+        const value = flagValue(flags, flagName);
+        if (value === undefined)
+            continue;
+        out[scalar.name] = coerceScalar(value, scalar.type);
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export function summarizeCommand(scope, moduleName, commandName) {
+    const command = findCommand(scope, moduleName, commandName);
+    if (!command) {
+        throw new CLIError('UNKNOWN_COMMAND', `unknown command: ${moduleName} ${commandName}`, 2);
+    }
+    return {
+        scope,
+        commandPath: command.commandPath,
+        method: command.method,
+        endpoint: command.endpoint,
+        requestType: command.requestType,
+        pathFlags: command.endpointParams,
+        scalarFlags: command.scalarParams.map((item) => item.name.replace(/([A-Z])/g, '-$1').toLowerCase()),
+    };
+}
+export async function executeCLI(scope, argv, env = loadRuntimeEnv(scope), fetchImpl = fetch) {
+    const parsed = parseCLIArgs(argv);
+    if (parsed.commandTokens.length === 0) {
+        return { kind: 'help', text: renderRootHelp(scope) };
+    }
+    const [moduleName, commandName] = parsed.commandTokens;
+    if (!moduleName) {
+        return { kind: 'help', text: renderRootHelp(scope) };
+    }
+    if (!commandName) {
+        return { kind: 'help', text: renderModuleHelp(scope, moduleName) };
+    }
+    if (hasFlag(parsed.flags, 'help')) {
+        return { kind: 'help', text: renderCommandHelp(scope, moduleName, commandName) };
+    }
+    const command = findCommand(scope, moduleName, commandName);
+    if (!command) {
+        throw new CLIError('UNKNOWN_COMMAND', `unknown command: ${moduleName} ${commandName}`, 2);
+    }
+    const endpoint = resolveEndpoint(command.endpoint, parsed.flags);
+    const scalarQuery = buildScalarQuery(command, parsed.flags);
+    const fileQuery = loadQueryFromFlags(parsed.flags);
+    const query = { ...(scalarQuery ?? {}), ...(fileQuery ?? {}) };
+    const body = loadBodyFromFlags(parsed.flags);
+    if (command.requestType) {
+        if (body === undefined) {
+            throw new CLIError('MISSING_BODY_FILE', `command requires --body-file for ${command.requestType}`, 2);
+        }
+        const schema = getBodySchema(command.requestType);
+        if (schema) {
+            const parsedBody = schema.safeParse(body);
+            if (!parsedBody.success) {
+                throw new CLIError('BODY_VALIDATION_FAILED', parsedBody.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`).join('; '), 2, {
+                    operation: `${scope}.${command.module}.${command.functionName}`,
+                    requestType: command.requestType,
+                    issues: parsedBody.error.issues.map((issue) => ({
+                        path: issue.path.length > 0 ? `body.${issue.path.join('.')}` : 'body',
+                        message: issue.message,
+                    })),
+                    tsHints: getTypeHints(command.requestType),
+                });
+            }
+        }
+        else {
+            const unsupportedReason = getUnsupportedBodySchemaReason(command.requestType);
+            if (unsupportedReason) {
+                throw new CLIError('UNSUPPORTED_BODY_SCHEMA', `${command.requestType}: ${unsupportedReason}`, 2, {
+                    operation: `${scope}.${command.module}.${command.functionName}`,
+                    requestType: command.requestType,
+                    reason: unsupportedReason,
+                    tsHints: getTypeHints(command.requestType),
+                });
+            }
+        }
+    }
+    const headers = buildRequestHeaders(env);
+    const response = await fetchImpl(buildURL(env.ARCUBASE_BASE_URL, endpoint, Object.keys(query).length > 0 ? query : undefined), {
+        method: command.method,
+        headers: {
+            ...headers,
+            'Content-Type': 'application/json',
+        },
+        body: body === undefined || command.method === 'GET' ? undefined : JSON.stringify(body),
+    });
+    const raw = await response.text();
+    let parsedResponse = raw;
+    try {
+        parsedResponse = raw ? JSON.parse(raw) : null;
+    }
+    catch {
+        // keep raw text
+    }
+    if (!response.ok) {
+        throw new CLIError('UPSTREAM_REQUEST_FAILED', typeof parsedResponse === 'string' ? parsedResponse : JSON.stringify(parsedResponse), 1);
+    }
+    return {
+        kind: 'result',
+        commandPath: command.commandPath,
+        status: response.status,
+        data: parsedResponse,
+    };
+}

package/dist/runtime/http.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeEnv } from './env.js';
+export declare function buildRequestHeaders(env: Pick<RuntimeEnv, 'ARCUBASE_ACCESS_TOKEN' | 'ARCUBASE_TENANT_ID' | 'ARCUBASE_TRACE_ID'>): Record<string, string>;
+export declare function buildURL(baseURL: string, endpoint: string, query?: Record<string, any>): string;
+//# sourceMappingURL=http.d.ts.map

package/dist/runtime/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/runtime/http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,uBAAuB,GAAG,oBAAoB,GAAG,mBAAmB,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASvJ;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAS/F"}

package/dist/runtime/http.js

@@ -0,0 +1,21 @@
+export function buildRequestHeaders(env) {
+    const headers = {
+        Authorization: `Bearer ${env.ARCUBASE_ACCESS_TOKEN}`,
+        'X-Tenant-Id': env.ARCUBASE_TENANT_ID
+    };
+    if (env.ARCUBASE_TRACE_ID) {
+        headers['X-Trace-Id'] = env.ARCUBASE_TRACE_ID;
+    }
+    return headers;
+}
+export function buildURL(baseURL, endpoint, query) {
+    const url = new URL(endpoint, baseURL.endsWith('/') ? baseURL : `${baseURL}/`);
+    if (query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined || value === null)
+                continue;
+            url.searchParams.set(key, typeof value === 'string' ? value : JSON.stringify(value));
+        }
+    }
+    return url.toString();
+}

package/dist/runtime/output.d.ts

@@ -0,0 +1,2 @@
+export declare function writeJSON(value: unknown): void;
+//# sourceMappingURL=output.d.ts.map

package/dist/runtime/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/runtime/output.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAE9C"}

package/dist/runtime/output.js

@@ -0,0 +1,3 @@
+export function writeJSON(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}

package/dist/runtime/paths.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_ARCUBASE_CLI_ROOT = "/opt/arcubase-cli";
+export declare const DEFAULT_ARCUBASE_SDK_ROOT = "/opt/arcubase-sdk";
+export declare function resolveArcubaseSDKRoot(env?: Record<string, string | undefined>): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/runtime/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/runtime/paths.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,sBAAsB,CAAA;AAC5D,eAAO,MAAM,yBAAyB,sBAAsB,CAAA;AAE5D,wBAAgB,sBAAsB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GAAG,MAAM,CAIpG"}

package/dist/runtime/paths.js

@@ -0,0 +1,8 @@
+export const DEFAULT_ARCUBASE_CLI_ROOT = '/opt/arcubase-cli';
+export const DEFAULT_ARCUBASE_SDK_ROOT = '/opt/arcubase-sdk';
+export function resolveArcubaseSDKRoot(env = process.env) {
+    const value = env.ARCUBASE_SDK_ROOT?.trim();
+    if (value)
+        return value;
+    return DEFAULT_ARCUBASE_SDK_ROOT;
+}

package/dist/runtime/zod_registry.d.ts

@@ -0,0 +1,10 @@
+import type { ZodTypeAny } from 'zod';
+export declare function getBodySchema(typeName: string): ZodTypeAny | null;
+export declare function getUnsupportedBodySchemaReason(typeName: string): string | null;
+export declare function requireBodySchema(typeName: string): ZodTypeAny;
+export type RuntimeTypeHint = {
+    symbol: string;
+    file: string;
+};
+export declare function getTypeHints(typeName: string): RuntimeTypeHint[];
+//# sourceMappingURL=zod_registry.d.ts.map

package/dist/runtime/zod_registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod_registry.d.ts","sourceRoot":"","sources":["../../src/runtime/zod_registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAA;AAIrC,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAIjE;AAED,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI9E;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAQ9D;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,EAAE,CAqBhE"}

package/dist/runtime/zod_registry.js

@@ -0,0 +1,50 @@
+import { bodySchemas, unsupportedBodySchemas } from '../generated/zod_registry.generated.js';
+import { typeIndex } from '../generated/type_index.generated.js';
+export function getBodySchema(typeName) {
+    const name = String(typeName || '').trim();
+    if (!name)
+        return null;
+    return bodySchemas[name] ?? null;
+}
+export function getUnsupportedBodySchemaReason(typeName) {
+    const name = String(typeName || '').trim();
+    if (!name)
+        return null;
+    return unsupportedBodySchemas[name] ?? null;
+}
+export function requireBodySchema(typeName) {
+    const schema = getBodySchema(typeName);
+    if (schema)
+        return schema;
+    const reason = getUnsupportedBodySchemaReason(typeName);
+    if (reason) {
+        throw new Error(`runtime validation for ${typeName} is not supported: ${reason}`);
+    }
+    throw new Error(`runtime validation schema not found for ${typeName}`);
+}
+export function getTypeHints(typeName) {
+    const name = String(typeName || '').trim();
+    if (!name)
+        return [];
+    const entry = typeIndex[name];
+    if (!entry?.file)
+        return [];
+    const seen = new Set();
+    const out = [];
+    const append = (symbol, file) => {
+        symbol = String(symbol || '').trim();
+        file = String(file || '').trim();
+        if (!symbol || !file)
+            return;
+        const key = `${symbol}@@${file}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push({ symbol, file });
+    };
+    append(name, entry.file);
+    for (const dep of entry.dependencies ?? []) {
+        append(dep.symbol, dep.file);
+    }
+    return out;
+}

package/dist/tests/bootstrap.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bootstrap.test.d.ts.map

package/dist/tests/bootstrap.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.test.d.ts","sourceRoot":"","sources":["../../src/tests/bootstrap.test.ts"],"names":[],"mappings":""}

package/dist/tests/bootstrap.test.js

@@ -0,0 +1,59 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { loadRuntimeEnv } from '../runtime/env.js';
+test('loadRuntimeEnv requires base url, tenant id and access token', () => {
+    assert.throws(() => loadRuntimeEnv('admin', {}), /ARCUBASE_BASE_URL is required/);
+});
+test('loadRuntimeEnv returns normalized runtime env', () => {
+    const env = loadRuntimeEnv('admin', {
+        ARCUBASE_BASE_URL: ' http://example.com ',
+        ARCUBASE_TENANT_ID: ' tenant-1 ',
+        ARCUBASE_ACCESS_TOKEN: ' token-1 ',
+        ARCUBASE_TRACE_ID: ' trace-1 '
+    });
+    assert.deepEqual(env, {
+        ARCUBASE_BASE_URL: 'http://example.com',
+        ARCUBASE_TENANT_ID: 'tenant-1',
+        ARCUBASE_ACCESS_TOKEN: 'token-1',
+        ARCUBASE_TRACE_ID: 'trace-1',
+        ARCUBASE_SUBJECT_TYPE: undefined,
+        ARCUBASE_SUBJECT_ID: undefined,
+        ARCUBASE_TOKEN_EXPIRES_AT: undefined
+    });
+});
+test('loadRuntimeEnv accepts admin-prefixed runtime env', () => {
+    const env = loadRuntimeEnv('admin', {
+        ARCUBASE_ADMIN_BASE_URL: ' https://admin.example.com ',
+        ARCUBASE_ADMIN_TENANT_ID: ' tenant-admin ',
+        ARCUBASE_ADMIN_ACCESS_TOKEN: ' token-admin ',
+        ARCUBASE_ADMIN_SUBJECT_TYPE: ' system_admin ',
+        ARCUBASE_ADMIN_SUBJECT_ID: ' user-admin ',
+    });
+    assert.deepEqual(env, {
+        ARCUBASE_BASE_URL: 'https://admin.example.com',
+        ARCUBASE_TENANT_ID: 'tenant-admin',
+        ARCUBASE_ACCESS_TOKEN: 'token-admin',
+        ARCUBASE_TRACE_ID: undefined,
+        ARCUBASE_SUBJECT_TYPE: 'system_admin',
+        ARCUBASE_SUBJECT_ID: 'user-admin',
+        ARCUBASE_TOKEN_EXPIRES_AT: undefined
+    });
+});
+test('loadRuntimeEnv accepts user-prefixed runtime env', () => {
+    const env = loadRuntimeEnv('user', {
+        ARCUBASE_USER_BASE_URL: ' https://user.example.com ',
+        ARCUBASE_USER_TENANT_ID: ' tenant-user ',
+        ARCUBASE_USER_ACCESS_TOKEN: ' token-user ',
+        ARCUBASE_USER_SUBJECT_TYPE: ' service_account ',
+        ARCUBASE_USER_SUBJECT_ID: ' sa-user ',
+    });
+    assert.deepEqual(env, {
+        ARCUBASE_BASE_URL: 'https://user.example.com',
+        ARCUBASE_TENANT_ID: 'tenant-user',
+        ARCUBASE_ACCESS_TOKEN: 'token-user',
+        ARCUBASE_TRACE_ID: undefined,
+        ARCUBASE_SUBJECT_TYPE: 'service_account',
+        ARCUBASE_SUBJECT_ID: 'sa-user',
+        ARCUBASE_TOKEN_EXPIRES_AT: undefined
+    });
+});

package/dist/tests/command_registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=command_registry.test.d.ts.map

package/dist/tests/command_registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_registry.test.d.ts","sourceRoot":"","sources":["../../src/tests/command_registry.test.ts"],"names":[],"mappings":""}

package/dist/tests/command_registry.test.js

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { adminCommands, userCommands } from '../generated/command_registry.generated.js';
+test('admin app create-entity command exists', () => {
+    assert.ok(adminCommands.some((c) => c.commandPath.join(' ') === 'app create-entity'));
+});
+test('user workflow query-entity command exists', () => {
+    assert.ok(userCommands.some((c) => c.commandPath.join(' ') === 'workflow query-entity'));
+});
+test('inline request type keeps full object text instead of truncated brace', () => {
+    const command = adminCommands.find((c) => c.commandPath.join(' ') === 'dashboard clone-dashboard');
+    assert.ok(command);
+    const typed = command;
+    assert.match(String(typed.requestType), /^\{\s*name:\s*string\s*\}$/);
+});
+test('tag commands no longer emit truncated inline request type', () => {
+    const command = adminCommands.find((c) => c.commandPath.join(' ') === 'entity-tags batch-add-entity-tags');
+    assert.ok(command);
+    const typed = command;
+    assert.match(String(typed.requestType), /^\{\s*policy_id:\s*string.*selection:\s*any.*tag_names:\s*string\[\]\s*\}$/);
+    assert.equal(typed.scalarParams.length, 0);
+});

package/dist/tests/execute_validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=execute_validation.test.d.ts.map

package/dist/tests/execute_validation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute_validation.test.d.ts","sourceRoot":"","sources":["../../src/tests/execute_validation.test.ts"],"names":[],"mappings":""}