@treeseed/sdk 0.10.27 → 0.11.0

package/dist/reconcile/platform.d.ts

@@ -0,0 +1,104 @@
+export declare const TREESEED_RECONCILE_RUN_MODEL: readonly ["refresh", "plan", "validate", "apply", "refresh", "verify", "persist"];
+export declare const TREESEED_RECONCILE_ACTION_KINDS: readonly ["noop", "create", "update", "replace", "delete", "adopt", "rename", "reattach", "retain", "taint", "blocked"];
+export type TreeseedCanonicalReconcilePhase = typeof TREESEED_RECONCILE_RUN_MODEL[number];
+export type TreeseedCanonicalReconcileActionKind = typeof TREESEED_RECONCILE_ACTION_KINDS[number];
+export interface TreeseedCanonicalGraphNode {
+    id: string;
+    provider?: string | null;
+    type?: string | null;
+    owner?: string | null;
+    environment?: string | null;
+    spec?: unknown;
+    state?: unknown;
+    locators?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface TreeseedCanonicalDrift {
+    id: string;
+    resourceId?: string | null;
+    severity?: 'info' | 'warning' | 'blocking';
+    reason: string;
+    expected?: unknown;
+    observed?: unknown;
+    provider?: string | null;
+    type?: string | null;
+}
+export interface TreeseedCanonicalAction {
+    id: string;
+    kind: TreeseedCanonicalReconcileActionKind;
+    resourceId: string;
+    reason: string;
+    provider?: string | null;
+    type?: string | null;
+    before?: unknown;
+    after?: unknown;
+}
+export interface TreeseedCanonicalPostcondition {
+    id: string;
+    resourceId: string;
+    description: string;
+    source?: 'api' | 'cli' | 'sdk' | 'http' | 'local' | 'derived';
+    required?: boolean;
+    ok: boolean;
+    issues: string[];
+    expected?: unknown;
+    observed?: unknown;
+}
+export interface TreeseedCanonicalLiveVerification {
+    ok: boolean;
+    source?: string;
+    checkedAt?: string | null;
+    issues: string[];
+    checks?: unknown[];
+}
+export interface TreeseedCanonicalReconcileReport {
+    desiredGraph: TreeseedCanonicalGraphNode[];
+    observedGraph: TreeseedCanonicalGraphNode[];
+    stateGraph: TreeseedCanonicalGraphNode[];
+    diff: TreeseedCanonicalDrift[];
+    actions: TreeseedCanonicalAction[];
+    postconditions: TreeseedCanonicalPostcondition[];
+    selectedResources: string[];
+    skippedResources: Array<{
+        id: string;
+        reason: string;
+    }>;
+    blockedDrift: TreeseedCanonicalDrift[];
+    providerLimitations: TreeseedCanonicalDrift[];
+    retainedResources: TreeseedCanonicalGraphNode[];
+    destroyedResources: TreeseedCanonicalGraphNode[];
+    liveVerification: TreeseedCanonicalLiveVerification;
+    ok: boolean;
+}
+export interface CreateTreeseedCanonicalReconcileReportInput {
+    desiredGraph?: TreeseedCanonicalGraphNode[];
+    observedGraph?: TreeseedCanonicalGraphNode[];
+    stateGraph?: TreeseedCanonicalGraphNode[];
+    diff?: TreeseedCanonicalDrift[];
+    actions?: TreeseedCanonicalAction[];
+    postconditions?: TreeseedCanonicalPostcondition[];
+    selectedResources?: string[];
+    skippedResources?: Array<{
+        id: string;
+        reason: string;
+    }>;
+    blockedDrift?: TreeseedCanonicalDrift[];
+    providerLimitations?: TreeseedCanonicalDrift[];
+    retainedResources?: TreeseedCanonicalGraphNode[];
+    destroyedResources?: TreeseedCanonicalGraphNode[];
+    liveVerification?: Partial<TreeseedCanonicalLiveVerification>;
+}
+export declare function createTreeseedCanonicalReconcileReport(input?: CreateTreeseedCanonicalReconcileReportInput): TreeseedCanonicalReconcileReport;
+export declare function assertTreeseedCanonicalReconcileSuccess(report: TreeseedCanonicalReconcileReport): void;
+export declare function summarizeTreeseedCanonicalReconcileReport(report: TreeseedCanonicalReconcileReport): {
+    ok: boolean;
+    desired: number;
+    observed: number;
+    actions: number;
+    postconditions: number;
+    blockedDrift: number;
+    providerLimitations: number;
+    retainedResources: number;
+    destroyedResources: number;
+    liveVerificationOk: boolean;
+};

package/dist/reconcile/platform.js

@@ -0,0 +1,100 @@
+const TREESEED_RECONCILE_RUN_MODEL = [
+  "refresh",
+  "plan",
+  "validate",
+  "apply",
+  "refresh",
+  "verify",
+  "persist"
+];
+const TREESEED_RECONCILE_ACTION_KINDS = [
+  "noop",
+  "create",
+  "update",
+  "replace",
+  "delete",
+  "adopt",
+  "rename",
+  "reattach",
+  "retain",
+  "taint",
+  "blocked"
+];
+function hasBlockingAction(actions) {
+  return actions.some((action) => action.kind === "blocked");
+}
+function liveVerificationOk(input, postconditions) {
+  if (input?.ok === false) return false;
+  if ((input?.issues ?? []).length > 0) return false;
+  return postconditions.every((postcondition) => postcondition.required === false || postcondition.ok);
+}
+function createTreeseedCanonicalReconcileReport(input = {}) {
+  const desiredGraph = input.desiredGraph ?? [];
+  const observedGraph = input.observedGraph ?? [];
+  const stateGraph = input.stateGraph ?? [];
+  const diff = input.diff ?? [];
+  const actions = input.actions ?? [];
+  const postconditions = input.postconditions ?? [];
+  const selectedResources = input.selectedResources ?? desiredGraph.map((node) => node.id);
+  const skippedResources = input.skippedResources ?? [];
+  const blockedDrift = input.blockedDrift ?? diff.filter((entry) => entry.severity === "blocking");
+  const providerLimitations = input.providerLimitations ?? [];
+  const retainedResources = input.retainedResources ?? [];
+  const destroyedResources = input.destroyedResources ?? [];
+  const liveVerification = {
+    ok: input.liveVerification?.ok ?? liveVerificationOk(input.liveVerification, postconditions),
+    source: input.liveVerification?.source ?? "sdk",
+    checkedAt: input.liveVerification?.checkedAt ?? null,
+    issues: input.liveVerification?.issues ?? [],
+    checks: input.liveVerification?.checks ?? []
+  };
+  const ok = liveVerification.ok && blockedDrift.length === 0 && providerLimitations.length === 0 && !hasBlockingAction(actions) && postconditions.every((postcondition) => postcondition.required === false || postcondition.ok);
+  return {
+    desiredGraph,
+    observedGraph,
+    stateGraph,
+    diff,
+    actions,
+    postconditions,
+    selectedResources,
+    skippedResources,
+    blockedDrift,
+    providerLimitations,
+    retainedResources,
+    destroyedResources,
+    liveVerification,
+    ok
+  };
+}
+function assertTreeseedCanonicalReconcileSuccess(report) {
+  if (report.ok) return;
+  const reasons = [
+    ...report.blockedDrift.map((entry) => `blocked drift ${entry.id}: ${entry.reason}`),
+    ...report.providerLimitations.map((entry) => `provider limitation ${entry.id}: ${entry.reason}`),
+    ...report.actions.filter((action) => action.kind === "blocked").map((action) => `blocked action ${action.id}: ${action.reason}`),
+    ...report.postconditions.filter((postcondition) => postcondition.required !== false && !postcondition.ok).map((postcondition) => `postcondition ${postcondition.id}: ${postcondition.issues.join("; ") || "failed"}`),
+    ...report.liveVerification.issues.map((issue) => `live verification: ${issue}`)
+  ];
+  throw new Error(`Treeseed reconciliation did not converge: ${reasons.join(" | ") || "unknown drift remained"}`);
+}
+function summarizeTreeseedCanonicalReconcileReport(report) {
+  return {
+    ok: report.ok,
+    desired: report.desiredGraph.length,
+    observed: report.observedGraph.length,
+    actions: report.actions.length,
+    postconditions: report.postconditions.length,
+    blockedDrift: report.blockedDrift.length,
+    providerLimitations: report.providerLimitations.length,
+    retainedResources: report.retainedResources.length,
+    destroyedResources: report.destroyedResources.length,
+    liveVerificationOk: report.liveVerification.ok
+  };
+}
+export {
+  TREESEED_RECONCILE_ACTION_KINDS,
+  TREESEED_RECONCILE_RUN_MODEL,
+  assertTreeseedCanonicalReconcileSuccess,
+  createTreeseedCanonicalReconcileReport,
+  summarizeTreeseedCanonicalReconcileReport
+};

package/dist/reconcile/state.js

@@ -6,8 +6,8 @@ function stableHash(value) {
   return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function railwayUnitTypeForServiceKey(serviceKey) {
-  if (serviceKey === "marketOperationsRunner") {
-    return "railway-service:market-operations-runner";
+  if (serviceKey === "operationsRunner") {
+    return "railway-service:operations-runner";
   }
   if (serviceKey === "workdayManager") {
     return "railway-service:workday-manager";
@@ -271,7 +271,7 @@ function loadTreeseedReconcileState(tenantRoot, target) {
   return {
     version: 1,
     target,
-    dependencyGraphVersion: legacyState.reconcile?.dependencyGraphVersion ?? 1,
+    dependencyGraphVersion: legacyState.reconciliation?.dependencyGraphVersion ?? 1,
     units: { ...persistedUnits }
   };
 }
@@ -280,7 +280,7 @@ function writeTreeseedReconcileState(tenantRoot, reconcileState) {
   const legacyState = loadDeployState(tenantRoot, deployConfig, { target: reconcileState.target });
   writeDeployState(tenantRoot, {
     ...legacyState,
-    reconcile: {
+    reconciliation: {
       version: reconcileState.version,
       dependencyGraphVersion: reconcileState.dependencyGraphVersion,
       targetKey: targetKey(reconcileState.target)

package/dist/reconcile/units.js

@@ -1,7 +1,7 @@
 const TRESEED_RECONCILE_UNIT_TYPES = [
   "web-ui",
   "api-runtime",
-  "market-operations-runner-runtime",
+  "operations-runner-runtime",
   "workday-manager-runtime",
   "worker-runner-runtime",
   "edge-worker",
@@ -15,7 +15,7 @@ const TRESEED_RECONCILE_UNIT_TYPES = [
   "custom-domain:api",
   "dns-record",
   "railway-service:api",
-  "railway-service:market-operations-runner",
+  "railway-service:operations-runner",
   "railway-service:workday-manager",
   "railway-service:worker-runner"
 ];

package/dist/scripts/deployment-readiness.js

@@ -0,0 +1,20 @@
+import { collectTreeseedDeploymentReadiness, formatTreeseedReadinessReport } from '../operations/services/deployment-readiness.js';
+function arg(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : null;
+}
+const environment = (arg('--environment') ?? 'staging');
+const strict = process.argv.includes('--strict');
+const report = collectTreeseedDeploymentReadiness({
+    tenantRoot: process.cwd(),
+    environment,
+});
+if (process.argv.includes('--json')) {
+    console.log(JSON.stringify(report, null, 2));
+}
+else {
+    console.log(formatTreeseedReadinessReport(report));
+}
+if (strict && !report.ok) {
+    process.exitCode = 1;
+}

package/dist/scripts/generate-treedx-openapi-types.js

@@ -0,0 +1,186 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse, stringify } from 'yaml';
+const check = process.argv.includes('--check');
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const workspaceRoot = resolve(packageRoot, '../..');
+const workspaceOpenApiPath = resolve(workspaceRoot, 'docs/api/openapi.yaml');
+const packageOpenApiPath = resolve(packageRoot, 'docs/api/openapi.yaml');
+const openApiPath = existsSync(workspaceOpenApiPath) ? workspaceOpenApiPath : packageOpenApiPath;
+const workspaceOpenApiJsonPath = resolve(workspaceRoot, 'docs/api/openapi.json');
+const packageOpenApiJsonPath = resolve(packageRoot, 'docs/api/openapi.json');
+const outPath = resolve(packageRoot, 'src/treedx/generated/openapi-types.ts');
+const openApi = parse(readFileSync(openApiPath, 'utf8'));
+function refName(ref) {
+    return ref.split('/').pop() ?? ref;
+}
+function schemaRefType(ref) {
+    return `components['schemas']['${refName(ref)}']`;
+}
+function literal(value) {
+    return JSON.stringify(value);
+}
+function key(name) {
+    return /^[A-Za-z_$][\w$]*$/u.test(name) ? name : JSON.stringify(name);
+}
+function typeForSchema(schema) {
+    if (!schema || typeof schema !== 'object')
+        return 'unknown';
+    const s = schema;
+    if (typeof s.$ref === 'string')
+        return schemaRefType(s.$ref);
+    if ('const' in s)
+        return literal(s.const);
+    if (Array.isArray(s.enum))
+        return s.enum.map(literal).join(' | ') || 'never';
+    if (Array.isArray(s.oneOf))
+        return s.oneOf.map(typeForSchema).join(' | ') || 'unknown';
+    if (Array.isArray(s.anyOf))
+        return s.anyOf.map(typeForSchema).join(' | ') || 'unknown';
+    if (Array.isArray(s.allOf))
+        return s.allOf.map(typeForSchema).join(' & ') || 'unknown';
+    if (s.nullable === true)
+        return `${typeForSchema({ ...s, nullable: undefined })} | null`;
+    if (s.type === 'string')
+        return 'string';
+    if (s.type === 'integer' || s.type === 'number')
+        return 'number';
+    if (s.type === 'boolean')
+        return 'boolean';
+    if (s.type === 'null')
+        return 'null';
+    if (s.type === 'array')
+        return `${typeForSchema(s.items)}[]`;
+    if (s.type === 'object' || s.properties || s.additionalProperties !== undefined) {
+        const properties = (s.properties ?? {});
+        const required = new Set(Array.isArray(s.required) ? s.required.map(String) : []);
+        const parts = Object.entries(properties).map(([name, prop]) => {
+            const optional = required.has(name) ? '' : '?';
+            return `${key(name)}${optional}: ${typeForSchema(prop)};`;
+        });
+        if (s.additionalProperties === true) {
+            parts.push('[key: string]: unknown;');
+        }
+        else if (s.additionalProperties && typeof s.additionalProperties === 'object') {
+            parts.push(`[key: string]: ${typeForSchema(s.additionalProperties)};`);
+        }
+        return parts.length > 0 ? `{ ${parts.join(' ')} }` : 'Record<string, never>';
+    }
+    return 'unknown';
+}
+function parametersFor(operation, location) {
+    const params = Array.isArray(operation.parameters) ? operation.parameters : [];
+    const entries = params
+        .filter((param) => typeof param === 'object' && param !== null && param.in === location)
+        .map((param) => {
+        const name = String(param.name);
+        const optional = param.required === true ? '' : '?';
+        return `${key(name)}${optional}: ${typeForSchema(param.schema)};`;
+    });
+    return entries.length > 0 ? `{ ${entries.join(' ')} }` : 'never';
+}
+function requestBodyFor(operation) {
+    const body = operation.requestBody;
+    const content = body?.content ?? {};
+    const json = content['application/json']?.schema;
+    if (json)
+        return typeForSchema(json);
+    const octets = content['application/octet-stream']?.schema;
+    if (octets)
+        return 'ArrayBuffer | Uint8Array | Blob';
+    return 'never';
+}
+function responseFor(response) {
+    if (!response || typeof response !== 'object')
+        return 'unknown';
+    if (typeof response.$ref === 'string') {
+        const name = refName(response.$ref);
+        if (name === 'Error')
+            return "components['schemas']['TreeDxErrorEnvelope']";
+        if (name === 'Ok')
+            return "components['schemas']['TreeDxOkEnvelope']";
+    }
+    const r = response;
+    const content = r.content ?? {};
+    const json = content['application/json']?.schema;
+    if (json)
+        return typeForSchema(json);
+    const octets = content['application/octet-stream']?.schema;
+    if (octets)
+        return 'ArrayBuffer';
+    return 'unknown';
+}
+function operationType(operation) {
+    const responses = operation.responses ?? {};
+    const responseEntries = Object.entries(responses).map(([status, response]) => `${JSON.stringify(status)}: ${responseFor(response)};`);
+    return [
+        '{',
+        `parameters: { path: ${parametersFor(operation, 'path')}; query: ${parametersFor(operation, 'query')}; header: ${parametersFor(operation, 'header')}; };`,
+        `requestBody: ${requestBodyFor(operation)};`,
+        `responses: { ${responseEntries.join(' ')} };`,
+        '}',
+    ].join(' ');
+}
+const schemas = openApi.components?.schemas ?? {};
+const schemaLines = Object.entries(schemas)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([name, schema]) => `${key(name)}: ${typeForSchema(schema)};`);
+const operationEntries = [];
+const pathLines = [];
+for (const [path, methods] of Object.entries(openApi.paths ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+    const methodLines = [];
+    for (const [method, operation] of Object.entries(methods).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!operation?.operationId)
+            continue;
+        operationEntries.push([operation.operationId, operation]);
+        methodLines.push(`${method}: operations['${operation.operationId}'];`);
+    }
+    pathLines.push(`${JSON.stringify(path)}: { ${methodLines.join(' ')} };`);
+}
+const operationLines = operationEntries
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([id, operation]) => `${key(id)}: ${operationType(operation)};`);
+const generated = `// Generated from docs/api/openapi.yaml. Do not edit by hand.
+
+export interface paths {
+${pathLines.map((line) => `\t${line}`).join('\n')}
+}
+
+export interface components {
+\tschemas: {
+${schemaLines.map((line) => `\t\t${line}`).join('\n')}
+\t};
+}
+
+export interface operations {
+${operationLines.map((line) => `\t${line}`).join('\n')}
+}
+`;
+const current = (() => {
+    try {
+        return readFileSync(outPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+})();
+if (check && current !== generated) {
+    console.error(`${relative(process.cwd(), outPath)} is not up to date. Run npm run treedx:generate-types.`);
+    process.exit(1);
+}
+if (!check) {
+    mkdirSync(dirname(outPath), { recursive: true });
+    writeFileSync(outPath, generated, 'utf8');
+    for (const target of [workspaceOpenApiJsonPath, packageOpenApiJsonPath]) {
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, `${JSON.stringify(openApi, null, 2)}\n`, 'utf8');
+    }
+    if (openApiPath === workspaceOpenApiPath) {
+        mkdirSync(dirname(packageOpenApiPath), { recursive: true });
+        writeFileSync(packageOpenApiPath, stringify(openApi), 'utf8');
+    }
+    console.log(`Wrote ${relative(process.cwd(), outPath)}`);
+    console.log(`Wrote ${relative(process.cwd(), workspaceOpenApiJsonPath)}`);
+    console.log(`Wrote ${relative(process.cwd(), packageOpenApiJsonPath)}`);
+}

package/dist/scripts/operations-runner-smoke.js

@@ -0,0 +1,16 @@
+import { runTreeseedOperationsRunnerSmoke } from '../operations/services/operations-runner-smoke.js';
+function arg(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : null;
+}
+const environment = (arg('--environment') ?? 'staging') === 'prod' ? 'prod' : 'staging';
+const report = await runTreeseedOperationsRunnerSmoke({
+    tenantRoot: process.cwd(),
+    environment,
+    baseUrl: arg('--base-url'),
+    timeoutMs: arg('--timeout-ms') ? Number(arg('--timeout-ms')) : undefined,
+});
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok) {
+    process.exitCode = 1;
+}

package/dist/scripts/release-verify.js

@@ -101,5 +101,8 @@ assertNoLocalDependencyLinks();
 run('npm', ['run', 'lint']);
 scanDirectory(resolve(packageRoot, 'dist'));
 assertCleanDistArtifacts();
-run('npm', ['run', 'test:unit']);
+run('npm', ['run', 'test:release']);
+if (process.env.TREESEED_SDK_VERIFY_WORKFLOW_LIFECYCLE === '1') {
+    run('npm', ['run', 'test:workflow:lifecycle']);
+}
 run('npm', ['run', 'test:smoke']);

package/dist/scripts/template-catalog.test.js

@@ -36,8 +36,8 @@ function writeCatalogCache(root, endpoint, items) {
 }
 
 const starterTemplate = {
-	id: 'starter-basic',
-	displayName: 'TreeSeed Basic',
+	id: 'fixture-template',
+	displayName: 'Fixture Template',
 	description: 'Starter',
 	summary: 'Starter summary',
 	status: 'live',
@@ -53,7 +53,7 @@ const starterTemplate = {
 	fulfillment: {
 		source: {
 			repoUrl: 'https://example.com/repo.git',
-			directory: 'templates/starter-basic',
+			directory: 'templates/fixture-template',
 			ref: 'main',
 		},
 		hooksPolicy: 'builtin_only',
@@ -69,7 +69,7 @@ test('template registry reads the remote catalog from a configured file endpoint
 
 	const remoteProducts = await listTemplateProducts({ cwd, env: {} });
 	assert.equal(remoteProducts.length, 1);
-	assert.equal(remoteProducts[0]?.id, 'starter-basic');
+	assert.equal(remoteProducts[0]?.id, 'fixture-template');
 
 	writeCatalogCache(cwd, fallbackEndpoint, [starterTemplate]);
 
@@ -83,7 +83,7 @@ test('template registry reads the remote catalog from a configured file endpoint
 	});
 
 	assert.equal(cachedProducts.length, 1);
-	assert.equal(cachedProducts[0]?.id, 'starter-basic');
+	assert.equal(cachedProducts[0]?.id, 'fixture-template');
 	assert.equal(warnings.length, 1);
 	assert.match(warnings[0], /Using cached template catalog/);
 });
@@ -94,7 +94,7 @@ test('template definition resolution rejects templates missing from the remote c
 	const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
 
 	await assert.rejects(
-		() => resolveTemplateDefinition('starter-basic', { cwd, env: {} }),
-		/Unable to resolve remote template product "starter-basic"\./,
+		() => resolveTemplateDefinition('fixture-template', { cwd, env: {} }),
+		/Unable to resolve remote template product "fixture-template"\./,
 	);
 });

package/dist/scripts/tenant-workflow-action.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { pathToFileURL } from 'node:url';
-import { resolveScope, runProjectPlatformAction, } from '../operations/services/project-platform.js';
 const tenantRoot = process.cwd();
+function writeStatus(message) {
+    process.stderr.write(`[tenant-workflow-action] ${message}\n`);
+}
 function parseArgs(argv) {
     const parsed = {
         action: 'deploy_web',
@@ -65,17 +67,24 @@ async function main() {
     const options = parseArgs(process.argv.slice(2));
     process.env.TREESEED_WORKFLOW_ACTION = options.action;
     process.env.TREESEED_WORKFLOW_PLANE ||= 'web';
+    writeStatus(`start action=${options.action} environment=${options.environment ?? '(auto)'}`);
+    writeStatus('loading project platform module...');
+    const { resolveScope, runProjectPlatformAction } = await import('../operations/services/project-platform.js');
+    writeStatus('project platform module loaded.');
     const scope = resolveScope(options.environment);
+    writeStatus(`resolved scope=${scope}; running action...`);
     const result = await runProjectPlatformAction(options.action, {
         tenantRoot,
         scope,
         projectId: options.projectId ?? process.env.TREESEED_PROJECT_ID ?? null,
         previewId: options.previewId,
         dryRun: options.dryRun,
+        write: (line) => writeStatus(line),
     });
     if (result !== undefined) {
         process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
     }
+    writeStatus('complete.');
 }
 function isCliEntrypoint() {
     if (!process.argv[1]) {