@kora-platform/cli 0.8.2-rc4 → 0.9.0-rc2

package/dist/extension-commands.js

@@ -1,6 +1,6 @@
-import { readOptionalStringFlag, readRequiredStringFlag } from "./command-flags.js";
+import { readOptionalNumberFlag, readOptionalStringFlag, readRequiredStringFlag } from "./command-flags.js";
 import { genericProblem, usageProblem } from "./cli-errors.js";
-import { isZipArchivePath, readArchiveBytes, readJsonInputSpecifier, readPackageFileEntries, readWorkspaceExportMetadata, writeArchiveExport, writePackageExport } from "./files.js";
+import { isZipArchivePath, readArchiveBytes, readJsonInputSpecifier, readJsonValueInputSpecifier, readPackageFileEntries, readWorkspaceExportMetadata, writeArchiveExport, writePackageExport } from "./files.js";
 import { renderKeyValue, renderPrettyJson, renderSuccess, renderTable } from "./format.js";
 import { confirmDestructive } from "./interaction.js";
 import { readCliEnvironmentFlag, readRequiredCliEnvironmentFlag } from "./environment-context.js";
@@ -73,7 +73,7 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
                 : await api.publishExtensionPackage(session, org.id, { files: await readPackageFileEntries(path, parsed.definition.id) });
             return {
                 data,
-                human: renderSuccess(`Published extension ${data.package.name} revision ${data.revision.id}.`),
+                human: renderSuccess(`Published extension package ${data.package.name}.`),
                 kind: "extensions_publish",
                 meta: withExtensionSummary({ command: parsed.definition.path.join(" "), mutated: true, orgId: org.id }, "Extension published.")
             };
@@ -85,8 +85,8 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
             const data = await api.installExtension(session, org.id, {
                 environment,
                 ...(permissions ? { grantedPermissions: permissions } : {}),
-                packageRevisionId: readRequiredArg(parsed, "package-revision"),
-                slug: readRequiredArg(parsed, "slug")
+                packageArtifactId: readRequiredArg(parsed, "published-package"),
+                slug: readRequiredArg(parsed, "name")
             });
             return {
                 data,
@@ -98,7 +98,7 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
         case "extensions.grant": {
             const environment = readRequiredCliEnvironmentFlag(parsed);
             const permissions = await readRequiredPermissions(parsed, context);
-            const installRef = readRequiredArg(parsed, "install");
+            const installRef = readRequiredArg(parsed, "name");
             announceResolvedEnvironment(parsed, context, environment);
             const data = await api.grantExtensionPermissions(session, org.id, installRef, {
                 environment,
@@ -112,34 +112,6 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
                 meta: withExtensionSummary({ command: parsed.definition.path.join(" "), environment, mutated: true, orgId: org.id }, "Extension grants updated.")
             };
         }
-        case "extensions.update": {
-            const environment = readRequiredCliEnvironmentFlag(parsed);
-            const installRef = readRequiredArg(parsed, "install");
-            const input = {
-                environment,
-                ...await readInstallPreconditions(parsed, context, installRef),
-                packageRevisionId: readRequiredStringFlag(parsed, "revision")
-            };
-            if (parsed.flags["dry-run"] === true) {
-                const data = await api.planExtensionInstallUpdate(session, org.id, installRef, input);
-                const plan = data.plan;
-                return {
-                    data,
-                    exitCode: plan.updateAllowed === false ? 1 : 0,
-                    human: renderPrettyJson(data.plan),
-                    kind: "extensions_update_plan",
-                    meta: withExtensionSummary({ command: parsed.definition.path.join(" "), dryRun: true, environment, mutated: false, orgId: org.id }, summarizeExtensionUpdatePlan(plan))
-                };
-            }
-            announceResolvedEnvironment(parsed, context, environment);
-            const data = await api.updateExtensionInstall(session, org.id, installRef, input);
-            return {
-                data,
-                human: renderSuccess(`Updated extension ${data.install.slug} to ${data.install.packageRevisionId} in ${environment}.`),
-                kind: "extensions_update",
-                meta: withExtensionSummary({ command: parsed.definition.path.join(" "), environment, mutated: true, orgId: org.id }, "Extension updated.")
-            };
-        }
         case "extensions.built-ins.list": {
             const environment = readCliEnvironmentFlag(parsed);
             const data = await api.listBuiltInExtensions(session, org.id, {
@@ -155,12 +127,12 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
         case "extensions.built-ins.install": {
             const environment = readRequiredCliEnvironmentFlag(parsed);
             const permissions = await readOptionalPermissions(parsed, context);
-            const slug = readOptionalStringFlag(parsed, "slug");
+            const name = readOptionalStringFlag(parsed, "name");
             announceResolvedEnvironment(parsed, context, environment);
             const data = await api.installBuiltInExtension(session, org.id, readRequiredArg(parsed, "built-in"), {
                 environment,
                 ...(permissions ? { grantedPermissions: permissions } : {}),
-                ...(slug ? { slug } : {})
+                ...(name ? { slug: name } : {})
             });
             return {
                 data,
@@ -169,45 +141,79 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
                 meta: withExtensionSummary({ command: parsed.definition.path.join(" "), environment, mutated: true, orgId: org.id }, "Built-in extension installed.")
             };
         }
-        case "extensions.list": {
+        case "extensions.search": {
             const environment = readCliEnvironmentFlag(parsed);
-            const data = await api.listExtensionInstalls(session, org.id, {
-                ...(environment ? { environment } : {})
+            const extensionRef = readOptionalArg(parsed, "extension");
+            if (extensionRef) {
+                const effectiveEnvironment = readRequiredCliEnvironmentFlag(parsed);
+                const data = await api.searchExtensionCapabilities(session, org.id, extensionRef, {
+                    environment: effectiveEnvironment,
+                    ...readExtensionSearchFilters(parsed, { capabilities: true })
+                });
+                return {
+                    data,
+                    human: renderCapabilitySearchHuman(data.matches, data),
+                    kind: "extensions_search",
+                    meta: withExtensionSummary({ command: parsed.definition.path.join(" "), environment: effectiveEnvironment, orgId: org.id }, summarizeSearchResult(data))
+                };
+            }
+            const data = await api.searchExtensions(session, org.id, {
+                ...(environment ? { environment } : {}),
+                ...readExtensionSearchFilters(parsed, { capabilities: false })
             });
             return {
                 data,
-                human: renderExtensionInstallTable(data.installs),
-                kind: "extensions_list",
-                meta: { command: parsed.definition.path.join(" "), ...(environment ? { environment } : {}), orgId: org.id }
+                human: renderExtensionSearchHuman(data.matches, data),
+                kind: "extensions_search",
+                meta: withExtensionSummary({ command: parsed.definition.path.join(" "), ...(environment ? { environment } : {}), orgId: org.id }, summarizeSearchResult(data))
             };
         }
-        case "extensions.inspect": {
+        case "extensions.get": {
             const environment = readRequiredCliEnvironmentFlag(parsed);
-            const data = await api.getExtensionInstall(session, org.id, readRequiredArg(parsed, "install"), {
-                environment
-            });
+            const extensionRef = readRequiredArg(parsed, "extension");
+            const selectedCapability = readSelectedCapability(parsed);
+            if (selectedCapability) {
+                const data = await api.getExtensionCapability(session, org.id, extensionRef, selectedCapability.kind, selectedCapability.name, { environment });
+                return {
+                    data,
+                    human: renderPrettyJson(data.capability),
+                    kind: "extensions_get",
+                    meta: withExtensionSummary({ command: parsed.definition.path.join(" "), environment, orgId: org.id }, `${selectedCapability.kind} ${selectedCapability.name} loaded.`)
+                };
+            }
+            const data = await api.getExtensionDiscovery(session, org.id, extensionRef, { environment });
             return {
                 data,
-                human: renderPrettyJson(data.install),
-                kind: "extensions_inspect",
+                human: renderPrettyJson(data.extension),
+                kind: "extensions_get",
                 meta: { command: parsed.definition.path.join(" "), environment, orgId: org.id }
             };
         }
-        case "extensions.detail": {
+        case "extensions.invoke": {
             const environment = readRequiredCliEnvironmentFlag(parsed);
-            const data = await api.getExtensionInstallDetail(session, org.id, readRequiredArg(parsed, "install"), {
-                environment
+            const extensionRef = readRequiredArg(parsed, "extension");
+            const functionName = readRequiredArg(parsed, "function");
+            const invocationInput = await readOptionalInvocationInput(parsed, context);
+            await confirmDestructive(parsed, context, `Invoke extension function ${extensionRef}.${functionName} in ${environment}?`);
+            const data = await api.invokeExtensionFunction(session, org.id, extensionRef, functionName, {
+                environment,
+                ...(invocationInput.provided ? { input: invocationInput.value } : {})
             });
             return {
                 data,
-                human: renderExtensionInstallDetailHuman(data.detail),
-                kind: "extensions_detail",
-                meta: { command: parsed.definition.path.join(" "), environment, orgId: org.id }
+                human: renderExtensionInvocationHuman(data),
+                kind: "extensions_invoke",
+                meta: withExtensionSummary({
+                    command: parsed.definition.path.join(" "),
+                    environment,
+                    executionId: data.invocation.executionId,
+                    orgId: org.id
+                }, `Extension function ${functionName} invoked.`)
             };
         }
         case "extensions.disable": {
             const environment = readRequiredCliEnvironmentFlag(parsed);
-            const installRef = readRequiredArg(parsed, "install");
+            const installRef = readRequiredArg(parsed, "name");
             announceResolvedEnvironment(parsed, context, environment);
             const data = await api.disableExtensionInstall(session, org.id, installRef, {
                 environment
@@ -221,7 +227,7 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
         }
         case "extensions.enable": {
             const environment = readRequiredCliEnvironmentFlag(parsed);
-            const installRef = readRequiredArg(parsed, "install");
+            const installRef = readRequiredArg(parsed, "name");
             announceResolvedEnvironment(parsed, context, environment);
             const data = await api.enableExtensionInstall(session, org.id, installRef, {
                 environment
@@ -235,15 +241,15 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
         }
         case "extensions.delete": {
             const environment = readRequiredCliEnvironmentFlag(parsed);
-            const installRef = readRequiredArg(parsed, "install");
+            const installRef = readRequiredArg(parsed, "name");
             announceResolvedEnvironment(parsed, context, environment);
-            await confirmDestructive(parsed, context, `Delete extension install ${installRef} from ${environment}?`);
+            await confirmDestructive(parsed, context, `Delete extension ${installRef} from ${environment}?`);
             await api.deleteExtensionInstall(session, org.id, installRef, {
                 environment
             });
             return {
                 data: {},
-                human: renderSuccess(`Deleted extension install ${installRef} from ${environment}.`),
+                human: renderSuccess(`Deleted extension ${installRef} from ${environment}.`),
                 kind: "extensions_delete",
                 meta: { command: parsed.definition.path.join(" "), environment, orgId: org.id }
             };
@@ -252,6 +258,94 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
             throw genericProblem(`Unhandled extensions command ${parsed.definition.id}.`, parsed.definition.id);
     }
 }
+function readExtensionSearchFilters(parsed, input) {
+    const description = readOptionalStringFlag(parsed, "description");
+    const kind = readOptionalStringFlag(parsed, "kind");
+    const limit = readOptionalNumberFlag(parsed, "limit");
+    const name = readOptionalStringFlag(parsed, "name");
+    const scope = readOptionalStringFlag(parsed, "scope");
+    const title = readOptionalStringFlag(parsed, "title");
+    if (input.capabilities && title) {
+        throw usageProblem("--title can only be used when searching extensions.", parsed.definition.id);
+    }
+    if (input.capabilities && scope) {
+        throw usageProblem("--scope can only be used when searching extensions.", parsed.definition.id);
+    }
+    if (!input.capabilities && kind) {
+        throw usageProblem("--kind can only be used when searching inside one extension.", parsed.definition.id);
+    }
+    return {
+        ...(description ? { description } : {}),
+        ...(input.capabilities && kind ? { kind } : {}),
+        ...(limit !== undefined ? { limit } : {}),
+        ...(name ? { name } : {}),
+        ...(!input.capabilities && scope ? { scope } : {}),
+        ...(!input.capabilities && title ? { title } : {})
+    };
+}
+function readSelectedCapability(parsed) {
+    const selected = [
+        { kind: "function", name: readOptionalStringFlag(parsed, "function") },
+        { kind: "tool", name: readOptionalStringFlag(parsed, "tool") },
+        { kind: "skill", name: readOptionalStringFlag(parsed, "skill") }
+    ].filter((entry) => Boolean(entry.name));
+    if (selected.length > 1) {
+        throw usageProblem("Use only one of --function, --tool, or --skill.", parsed.definition.id);
+    }
+    return selected[0] ?? null;
+}
+function summarizeSearchResult(input) {
+    return input.truncated
+        ? `Found ${input.matches.length} of ${input.totalCount} matches. Narrow the search or raise --limit.`
+        : `Found ${input.matches.length} match${input.matches.length === 1 ? "" : "es"}.`;
+}
+function renderExtensionSearchHuman(matches, input) {
+    const rows = matches.map((match) => ({
+        ...match,
+        nextCommand: match.nextCommands?.install ?? match.nextCommands?.get ?? "",
+        stateLabel: formatExtensionState(match)
+    }));
+    return [
+        renderTable(rows, [
+            { key: "name", label: "Name" },
+            { key: "status", label: "Status" },
+            { key: "stateLabel", label: "State" },
+            { key: "title", label: "Title" },
+            { key: "description", label: "Description" },
+            { key: "nextCommand", label: "Next" }
+        ]),
+        renderSearchLimitHint(input, "extension")
+    ].filter(Boolean).join("\n");
+}
+function renderCapabilitySearchHuman(matches, input) {
+    return [
+        renderTable(matches, [
+            { key: "kind", label: "Kind" },
+            { key: "name", label: "Name" },
+            { key: "description", label: "Description" },
+            { key: "nextCommand", label: "Get" }
+        ]),
+        renderSearchLimitHint(input, "capability")
+    ].filter(Boolean).join("\n");
+}
+function renderSearchLimitHint(input, context) {
+    if (!input.truncated)
+        return "";
+    const filters = context === "extension" ? "--name, --title, --description, --scope" : "--name, --description, --kind";
+    return `Too many matches (${input.totalCount}). Narrow the search with ${filters}, or raise --limit.`;
+}
+function formatExtensionState(match) {
+    switch (match.state) {
+        case "ready":
+            return "Ready";
+        case "setup_required":
+            return "Setup required";
+        case "disabled":
+            return "Disabled";
+        default:
+            return "";
+    }
+}
 function withExtensionSummary(meta, summary) {
     const trimmed = summary?.trim();
     return trimmed && trimmed.length > 0 ? { ...meta, summary: trimmed } : meta;
@@ -261,14 +355,6 @@ function summarizeExtensionValidation(input) {
         ? `Extension validation passed${formatExtensionDiagnosticSuffix(input.diagnostics)}.`
         : `Extension validation failed${formatExtensionDiagnosticSuffix(input.diagnostics)}.`;
 }
-function summarizeExtensionUpdatePlan(plan) {
-    const diagnostics = Array.isArray(plan.diagnostics)
-        ? plan.diagnostics.filter((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry))
-        : [];
-    return plan.updateAllowed === false
-        ? `Extension update dry run blocked${formatExtensionDiagnosticSuffix(diagnostics)}.`
-        : `Extension update dry run passed${formatExtensionDiagnosticSuffix(diagnostics)}.`;
-}
 function formatExtensionDiagnosticSuffix(diagnostics) {
     if (diagnostics.length === 0) {
         return "";
@@ -285,8 +371,7 @@ function renderValidationHuman(input) {
     const summary = renderKeyValue([
         { label: "Valid", value: input.ok },
         { label: "Files", value: input.fileCount },
-        { label: "Bytes", value: input.totalBytes },
-        { label: "Revision hash", value: input.revisionHash ?? "" }
+        { label: "Bytes", value: input.totalBytes }
     ]);
     if (input.diagnostics.length === 0) {
         return summary;
@@ -301,53 +386,41 @@ function renderValidationHuman(input) {
         ])
     ].join("\n");
 }
-function renderExtensionInstallTable(installs) {
-    return renderTable(installs, [
-        { key: "slug", label: "Slug" },
-        { key: "enabled", label: "Enabled" },
-        { key: "packageRevisionId", label: "Revision" },
-        { key: "grantedPermissions", label: "Grants" }
-    ]);
-}
 function renderBuiltInExtensionTable(builtIns) {
     return renderTable(builtIns, [
-        { key: "slug", label: "Slug" },
+        { key: "slug", label: "Name" },
         { key: "title", label: "Title" },
         { key: "availability", label: "Availability" },
         { key: "installedSlug", label: "Installed" },
         { key: "description", label: "Description" }
     ]);
 }
-function renderExtensionInstallDetailHuman(detail) {
-    const registrations = readRecord(detail.registrations?.registrations);
-    const functions = Object.keys(readRecord(registrations?.functions) ?? {});
-    const tools = Object.keys(readRecord(registrations?.tools) ?? {});
-    return [
+function renderExtensionInvocationHuman(data) {
+    const lines = [
         renderKeyValue([
-            { label: "Slug", value: detail.install.slug },
-            { label: "Package", value: detail.package.name },
-            { label: "Revision", value: detail.install.packageRevisionId },
-            { label: "Functions", value: functions.join(", ") },
-            { label: "Tools", value: tools.join(", ") }
-        ]),
-        "",
-        renderPrettyJson(detail)
-    ].join("\n");
+            { label: "Execution", value: data.invocation.executionId },
+            { label: "Status", value: data.invocation.status }
+        ])
+    ];
+    if (Object.prototype.hasOwnProperty.call(data.invocation, "output")) {
+        lines.push("", "Output:", renderPrettyJson(data.invocation.output));
+    }
+    return lines.join("\n");
 }
 function resolveExtensionExportSelector(parsed) {
-    const install = readOptionalStringFlag(parsed, "install");
-    const revision = readOptionalStringFlag(parsed, "revision");
+    const install = readOptionalStringFlag(parsed, "name");
+    const artifact = readOptionalStringFlag(parsed, "artifact");
     const packageName = readOptionalStringFlag(parsed, "package");
-    const selectedCount = [Boolean(install), Boolean(revision), Boolean(packageName)].filter(Boolean).length;
+    const selectedCount = [Boolean(install), Boolean(artifact), Boolean(packageName)].filter(Boolean).length;
     if (selectedCount !== 1) {
-        throw usageProblem("Use exactly one of --install, --revision, or --package --latest.", parsed.definition.id);
+        throw usageProblem("Use exactly one of --name, --artifact, or --package --latest.", parsed.definition.id);
     }
     if (install) {
         const environment = readRequiredCliEnvironmentFlag(parsed);
         return { install, ...(environment ? { environment } : {}) };
     }
-    if (revision) {
-        return { revision };
+    if (artifact) {
+        return { artifact };
     }
     if (packageName && parsed.flags.latest === true) {
         return { latest: true, package: packageName };
@@ -356,18 +429,11 @@ function resolveExtensionExportSelector(parsed) {
 }
 async function readInstallPreconditions(parsed, context, installRef) {
     const metadata = await readExtensionInstallExportMetadata(context.cwd, installRef);
-    const explicitBasePackageRevision = readOptionalStringFlag(parsed, "base-package-revision");
     const explicitBaseUpdatedAt = readOptionalStringFlag(parsed, "base-updated-at");
     return {
-        ...(metadata?.packageRevisionId
-            ? { basePackageRevisionId: metadata.packageRevisionId }
-            : {}),
         ...(metadata?.installUpdatedAt
             ? { baseUpdatedAt: metadata.installUpdatedAt }
             : {}),
-        ...(explicitBasePackageRevision
-            ? { basePackageRevisionId: explicitBasePackageRevision }
-            : {}),
         ...(explicitBaseUpdatedAt
             ? { baseUpdatedAt: explicitBaseUpdatedAt }
             : {})
@@ -384,9 +450,6 @@ async function readExtensionInstallExportMetadata(cwd, installRef) {
     return {
         ...(typeof metadata.installUpdatedAt === "string"
             ? { installUpdatedAt: metadata.installUpdatedAt }
-            : {}),
-        ...(typeof metadata.packageRevisionId === "string"
-            ? { packageRevisionId: metadata.packageRevisionId }
             : {})
     };
 }
@@ -401,6 +464,16 @@ async function readRequiredPermissions(parsed, context) {
     const specifier = readRequiredStringFlag(parsed, "permissions");
     return normalizePermissions(await readJsonInputSpecifier(specifier, context.stdin, parsed.definition.id, { flag: "permissions" }), parsed.definition.id);
 }
+async function readOptionalInvocationInput(parsed, context) {
+    const specifier = readOptionalStringFlag(parsed, "input");
+    if (!specifier) {
+        return { provided: false };
+    }
+    return {
+        provided: true,
+        value: await readJsonValueInputSpecifier(specifier, context.stdin, parsed.definition.id, { flag: "input" })
+    };
+}
 function normalizePermissions(input, instance) {
     const permissions = input.grantedPermissions && isRecord(input.grantedPermissions)
         ? input.grantedPermissions
@@ -429,9 +502,6 @@ function normalizePermissions(input, instance) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readRecord(value) {
-    return isRecord(value) ? value : null;
-}
 function announceResolvedEnvironment(parsed, context, environment) {
     if (!parsed.json) {
         context.stdout.write(`Environment: ${environment}\n`);
@@ -444,3 +514,7 @@ function readRequiredArg(parsed, name) {
     }
     return value;
 }
+function readOptionalArg(parsed, name) {
+    const value = parsed.args[name];
+    return value && value.length > 0 ? value : undefined;
+}

package/dist/files.d.ts

@@ -4,6 +4,7 @@ interface ReadStructuredInputOptions {
     flag?: string;
 }
 export declare function readJsonInputSpecifier(specifier: string, stdin: Readable, instance: string, options?: ReadStructuredInputOptions): Promise<Record<string, unknown>>;
+export declare function readJsonValueInputSpecifier(specifier: string, stdin: Readable, instance: string, options?: ReadStructuredInputOptions): Promise<unknown>;
 export declare function readTextInputSpecifier(specifier: string, stdin: Readable, instance: string): Promise<string>;
 export declare function readImportEntries(pathValue: string): Promise<Array<{
     content: string;

package/dist/files.js

@@ -8,11 +8,22 @@ const MAX_IMPORT_FILE_BYTES = 1_000_000;
 const MAX_PACKAGE_FILE_BYTES = 2_000_000;
 const MAX_IMPORT_TOTAL_BYTES = 10_000_000;
 export async function readJsonInputSpecifier(specifier, stdin, instance, options = {}) {
+    const input = await readStructuredJsonInputSource(specifier, stdin, instance, options);
+    return readJsonObject(input.text, instance, input.options);
+}
+export async function readJsonValueInputSpecifier(specifier, stdin, instance, options = {}) {
+    const input = await readStructuredJsonInputSource(specifier, stdin, instance, options);
+    return readJsonValue(input.text, instance, input.options);
+}
+async function readStructuredJsonInputSource(specifier, stdin, instance, options = {}) {
     if (specifier === "-") {
-        return readJsonObject(await readStream(stdin), instance, {
-            source: "stdin",
-            ...options
-        });
+        return {
+            options: {
+                source: "stdin",
+                ...options
+            },
+            text: await readStream(stdin)
+        };
     }
     if (!specifier.startsWith("@")) {
         throw usageProblem("Structured JSON input must use @file.json or - for stdin.", instance, {
@@ -35,10 +46,13 @@ export async function readJsonInputSpecifier(specifier, stdin, instance, options
         }
         throw error;
     }
-    return readJsonObject(source, instance, {
-        filePath,
-        ...options
-    });
+    return {
+        options: {
+            filePath,
+            ...options
+        },
+        text: source
+    };
 }
 export async function readTextInputSpecifier(specifier, stdin, instance) {
     if (specifier === "-") {
@@ -214,25 +228,27 @@ export async function readPackageFileEntries(pathValue, instance) {
     return entries;
 }
 function readJsonObject(source, instance, options) {
-    let parsed;
-    try {
-        parsed = JSON.parse(source);
-    }
-    catch {
+    const parsed = readJsonValue(source, instance, options);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
         const sourceLabel = "filePath" in options ? `file ${options.filePath}` : "from stdin";
-        throw usageProblem(`Structured JSON input ${sourceLabel} must be valid JSON.`, instance, {
+        throw usageProblem(`Structured JSON input ${sourceLabel} must be a JSON object.`, instance, {
             ...("filePath" in options ? { filePath: options.filePath } : { source: options.source }),
             ...(options.flag ? { flag: options.flag } : {})
         });
     }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return parsed;
+}
+function readJsonValue(source, instance, options) {
+    try {
+        return JSON.parse(source);
+    }
+    catch {
         const sourceLabel = "filePath" in options ? `file ${options.filePath}` : "from stdin";
-        throw usageProblem(`Structured JSON input ${sourceLabel} must be a JSON object.`, instance, {
+        throw usageProblem(`Structured JSON input ${sourceLabel} must be valid JSON.`, instance, {
             ...("filePath" in options ? { filePath: options.filePath } : { source: options.source }),
             ...(options.flag ? { flag: options.flag } : {})
         });
     }
-    return parsed;
 }
 async function readStream(stream) {
     const chunks = [];