@mizchi/k1c 0.1.0

package/dist/canary/state-machine.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Pure state-machine for canary rollouts. Given the current KV-stored RolloutState,
+ * the desired content hash, the rollout's `canary.steps[]`, and the current time,
+ * compute the next RolloutState and the side-effects to execute.
+ *
+ * No I/O. All state is in inputs and outputs. Wiring (KV reads, API calls) lives
+ * in the apply layer.
+ */
+export interface RolloutState {
+    readonly status: 'idle' | 'progressing' | 'paused';
+    readonly currentStepIndex: number;
+    /** ISO8601 timestamp when the current canary started, or null when idle. */
+    readonly startedAt: string | null;
+    /** ISO8601 timestamp when the last setWeight took effect, or null when idle. */
+    readonly lastAdvanceAt: string | null;
+    /** Script name of the stable variant (e.g. `k1c--default--api--stable`). */
+    readonly stableScript: string;
+    /** Script name of the canary variant, or null when no canary in flight. */
+    readonly canaryScript: string | null;
+    /** 0-100, percentage routed to canary. 0 when idle / paused at step 0. */
+    readonly weight: number;
+    /** Hash of the deployed stable content. */
+    readonly stableHash: string;
+    /** Hash of the canary content currently being rolled out, or null when idle. */
+    readonly canaryHash: string | null;
+}
+export type CanaryStep = {
+    readonly setWeight: number;
+} | {
+    readonly pause: {
+        readonly duration?: string;
+    };
+};
+export interface AdvanceInput {
+    /** Current state from KV; null on first apply. */
+    readonly state: RolloutState | null;
+    /** Hash of the desired stable content the user wants live. */
+    readonly desiredHash: string;
+    /** The Rollout's strategy.canary.steps[]. */
+    readonly steps: ReadonlyArray<CanaryStep>;
+    /** Stable script name (k1c naming convention, deterministic). */
+    readonly stableScriptName: string;
+    /** Canary script name. */
+    readonly canaryScriptName: string;
+    /** Current time. */
+    readonly now: Date;
+}
+export type Action = {
+    readonly kind: 'init-stable';
+    readonly hash: string;
+} | {
+    readonly kind: 'upload-canary';
+    readonly hash: string;
+} | {
+    readonly kind: 'set-weight';
+    readonly weight: number;
+} | {
+    readonly kind: 'promote-canary';
+    readonly hash: string;
+} | {
+    readonly kind: 'remove-canary';
+} | {
+    readonly kind: 'wait';
+    readonly reason: 'duration-not-elapsed' | 'manual-promote-needed';
+};
+export interface AdvanceOutput {
+    readonly nextState: RolloutState;
+    readonly actions: ReadonlyArray<Action>;
+}
+export declare function advance(input: AdvanceInput): AdvanceOutput;
+export declare function parseDurationMs(input: string): number;
+//# sourceMappingURL=state-machine.d.ts.map

package/dist/canary/state-machine.js

@@ -0,0 +1,161 @@
+/**
+ * Pure state-machine for canary rollouts. Given the current KV-stored RolloutState,
+ * the desired content hash, the rollout's `canary.steps[]`, and the current time,
+ * compute the next RolloutState and the side-effects to execute.
+ *
+ * No I/O. All state is in inputs and outputs. Wiring (KV reads, API calls) lives
+ * in the apply layer.
+ */
+export function advance(input) {
+    const { state, desiredHash, steps, stableScriptName, canaryScriptName, now } = input;
+    // First apply: no prior state. Upload as stable, mark idle.
+    if (state === null) {
+        return {
+            nextState: {
+                status: 'idle',
+                currentStepIndex: 0,
+                startedAt: null,
+                lastAdvanceAt: null,
+                stableScript: stableScriptName,
+                canaryScript: null,
+                weight: 0,
+                stableHash: desiredHash,
+                canaryHash: null,
+            },
+            actions: [{ kind: 'init-stable', hash: desiredHash }],
+        };
+    }
+    // Workload changed mid-canary: restart the canary with the new content.
+    if (state.canaryHash !== null && state.canaryHash !== desiredHash) {
+        return startCanary(state, desiredHash, canaryScriptName, steps, now);
+    }
+    // No active canary, but desired matches stable: nothing to do.
+    if (state.status === 'idle' && state.stableHash === desiredHash) {
+        return { nextState: state, actions: [] };
+    }
+    // No active canary, desired differs from stable: start a new canary.
+    if (state.status === 'idle' && state.stableHash !== desiredHash) {
+        return startCanary(state, desiredHash, canaryScriptName, steps, now);
+    }
+    // Canary in progress (status === 'progressing' or 'paused'). Try to advance.
+    return advanceStep(state, steps, now, canaryScriptName);
+}
+function startCanary(state, desiredHash, canaryScriptName, steps, now) {
+    if (steps.length === 0) {
+        // Edge case: empty steps → immediate cutover (treat as 100%).
+        return {
+            nextState: {
+                ...state,
+                stableHash: desiredHash,
+                canaryScript: null,
+                canaryHash: null,
+                weight: 0,
+                status: 'idle',
+                currentStepIndex: 0,
+            },
+            actions: [{ kind: 'upload-canary', hash: desiredHash }, { kind: 'promote-canary', hash: desiredHash }],
+        };
+    }
+    const firstStep = steps[0];
+    const initialWeight = 'setWeight' in firstStep ? firstStep.setWeight : 0;
+    const actions = [
+        { kind: 'upload-canary', hash: desiredHash },
+        { kind: 'set-weight', weight: initialWeight },
+    ];
+    return {
+        nextState: {
+            ...state,
+            canaryScript: canaryScriptName,
+            canaryHash: desiredHash,
+            weight: initialWeight,
+            status: 'progressing',
+            currentStepIndex: 'setWeight' in firstStep ? 1 : 0,
+            startedAt: now.toISOString(),
+            lastAdvanceAt: now.toISOString(),
+        },
+        actions,
+    };
+}
+function advanceStep(state, steps, now, canaryScriptName) {
+    const idx = state.currentStepIndex;
+    // Finished all steps without an explicit setWeight 100 → promote.
+    if (idx >= steps.length) {
+        return promote(state);
+    }
+    const step = steps[idx];
+    if ('setWeight' in step) {
+        const w = step.setWeight;
+        const advanced = {
+            ...state,
+            weight: w,
+            currentStepIndex: idx + 1,
+            lastAdvanceAt: now.toISOString(),
+            status: 'progressing',
+        };
+        if (w >= 100) {
+            return promote(advanced);
+        }
+        return {
+            nextState: advanced,
+            actions: [{ kind: 'set-weight', weight: w }],
+        };
+    }
+    // pause step
+    const duration = step.pause.duration;
+    if (duration === undefined) {
+        return {
+            nextState: { ...state, status: 'paused' },
+            actions: [{ kind: 'wait', reason: 'manual-promote-needed' }],
+        };
+    }
+    const elapsedMs = now.getTime() - new Date(state.lastAdvanceAt ?? state.startedAt ?? now).getTime();
+    if (elapsedMs >= parseDurationMs(duration)) {
+        // Pause complete, advance past it and recurse to consume the next step.
+        return advanceStep({ ...state, currentStepIndex: idx + 1, lastAdvanceAt: now.toISOString() }, steps, now, canaryScriptName);
+    }
+    return {
+        nextState: state,
+        actions: [{ kind: 'wait', reason: 'duration-not-elapsed' }],
+    };
+}
+function promote(state) {
+    if (state.canaryHash === null) {
+        return { nextState: state, actions: [] };
+    }
+    return {
+        nextState: {
+            ...state,
+            stableHash: state.canaryHash,
+            canaryScript: null,
+            canaryHash: null,
+            weight: 0,
+            status: 'idle',
+            currentStepIndex: 0,
+        },
+        actions: [{ kind: 'promote-canary', hash: state.canaryHash }, { kind: 'remove-canary' }],
+    };
+}
+const DURATION_RE = /^(\d+)(ms|s|m|h|d)$/;
+export function parseDurationMs(input) {
+    const match = DURATION_RE.exec(input.trim());
+    if (!match) {
+        throw new Error(`invalid duration: ${input}`);
+    }
+    const n = Number(match[1]);
+    const unit = match[2];
+    switch (unit) {
+        case 'ms':
+            return n;
+        case 's':
+            return n * 1000;
+        case 'm':
+            return n * 60 * 1000;
+        case 'h':
+            return n * 60 * 60 * 1000;
+        case 'd':
+            return n * 24 * 60 * 60 * 1000;
+        default:
+            throw new Error(`invalid duration unit: ${unit}`);
+    }
+}
+//# sourceMappingURL=state-machine.js.map

package/dist/cli/args.d.ts

@@ -0,0 +1,51 @@
+export type OutputFormat = 'text' | 'json';
+export interface ApplyArgs {
+    readonly kind: 'apply';
+    readonly file: string;
+    readonly dryRun: boolean;
+    readonly watch: boolean;
+}
+export interface DiffArgs {
+    readonly kind: 'diff';
+    readonly file: string;
+    readonly output: OutputFormat;
+}
+export interface RolloutArgs {
+    readonly kind: 'rollout';
+    readonly subCommand: 'status' | 'promote' | 'abort';
+    readonly target: string;
+    readonly dispatch: string;
+}
+export interface GetArgs {
+    readonly kind: 'get';
+    readonly resourceKind: string;
+    readonly name?: string;
+    readonly namespace?: string;
+    readonly output: OutputFormat;
+}
+export interface DescribeArgs {
+    readonly kind: 'describe';
+    readonly resourceKind: string;
+    readonly name: string;
+    readonly namespace?: string;
+    readonly output: OutputFormat;
+}
+export interface VersionArgs {
+    readonly kind: 'version';
+}
+export interface DeleteArgs {
+    readonly kind: 'delete';
+    readonly file: string;
+    readonly cascade: boolean;
+}
+export interface HelpArgs {
+    readonly kind: 'help';
+}
+export interface ErrorArgs {
+    readonly kind: 'error';
+    readonly message: string;
+}
+export type ParsedArgs = ApplyArgs | DiffArgs | RolloutArgs | GetArgs | DescribeArgs | DeleteArgs | VersionArgs | HelpArgs | ErrorArgs;
+export declare function parseArgs(argv: ReadonlyArray<string>): ParsedArgs;
+export declare const USAGE = "k1c \u2014 apply a subset of Kubernetes manifests to Cloudflare\n\nusage:\n  k1c apply    -f <manifest.yaml> [--dry-run | --watch]\n  k1c diff     -f <manifest.yaml> [-o text|json]\n  k1c delete   -f <manifest.yaml> [--cascade]\n  k1c get      <kind> [name] [-n <namespace>] [-o text|json]\n  k1c describe <kind> <name> [-n <namespace>] [-o text|json]\n  k1c rollout  {status|promote|abort} <ns>/<name> --dispatch <name>\n  k1c version\n\nenvironment:\n  K1C_ACCOUNT_ID        Cloudflare account id\n  CLOUDFLARE_API_TOKEN  API token with Workers Edit + R2 + KV permissions\n";
+//# sourceMappingURL=args.d.ts.map

package/dist/cli/args.js

@@ -0,0 +1,239 @@
+export function parseArgs(argv) {
+    if (argv.length === 0)
+        return { kind: 'help' };
+    const first = argv[0];
+    if (first === '--help' || first === '-h')
+        return { kind: 'help' };
+    if (first === '--version' || first === '-V' || first === 'version') {
+        return { kind: 'version' };
+    }
+    if (first === 'apply')
+        return parseApply(argv.slice(1));
+    if (first === 'diff')
+        return parseDiff(argv.slice(1));
+    if (first === 'rollout')
+        return parseRollout(argv.slice(1));
+    if (first === 'get')
+        return parseGet(argv.slice(1));
+    if (first === 'describe')
+        return parseDescribe(argv.slice(1));
+    if (first === 'delete')
+        return parseDelete(argv.slice(1));
+    return { kind: 'error', message: `unknown command: ${first}` };
+}
+function parseOutput(value) {
+    if (value === undefined)
+        return { error: '--output requires a value (text|json)' };
+    if (value === 'text' || value === 'json')
+        return value;
+    return { error: `--output must be one of: text, json (got "${value}")` };
+}
+function parseGet(rest) {
+    const resourceKind = rest[0];
+    if (resourceKind === undefined || resourceKind.startsWith('-')) {
+        return { kind: 'error', message: 'get requires a resource kind (e.g. Worker, R2Bucket)' };
+    }
+    let name;
+    let namespace;
+    let output = 'text';
+    let i = 1;
+    if (rest[1] !== undefined && !rest[1].startsWith('-')) {
+        name = rest[1];
+        i = 2;
+    }
+    for (; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === '-n' || arg === '--namespace') {
+            const value = rest[i + 1];
+            if (value === undefined)
+                return { kind: 'error', message: `${arg} requires a value` };
+            namespace = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '-o' || arg === '--output') {
+            const parsed = parseOutput(rest[i + 1]);
+            if (typeof parsed === 'object')
+                return { kind: 'error', message: parsed.error };
+            output = parsed;
+            i += 1;
+            continue;
+        }
+        return { kind: 'error', message: `unknown flag for get: ${arg}` };
+    }
+    return {
+        kind: 'get',
+        resourceKind,
+        output,
+        ...(name !== undefined ? { name } : {}),
+        ...(namespace !== undefined ? { namespace } : {}),
+    };
+}
+function parseDescribe(rest) {
+    const resourceKind = rest[0];
+    if (resourceKind === undefined || resourceKind.startsWith('-')) {
+        return { kind: 'error', message: 'describe requires a resource kind' };
+    }
+    const name = rest[1];
+    if (name === undefined || name.startsWith('-')) {
+        return { kind: 'error', message: 'describe requires a resource name' };
+    }
+    let namespace;
+    let output = 'text';
+    for (let i = 2; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === '-n' || arg === '--namespace') {
+            const value = rest[i + 1];
+            if (value === undefined)
+                return { kind: 'error', message: `${arg} requires a value` };
+            namespace = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '-o' || arg === '--output') {
+            const parsed = parseOutput(rest[i + 1]);
+            if (typeof parsed === 'object')
+                return { kind: 'error', message: parsed.error };
+            output = parsed;
+            i += 1;
+            continue;
+        }
+        return { kind: 'error', message: `unknown flag for describe: ${arg}` };
+    }
+    return {
+        kind: 'describe',
+        resourceKind,
+        name,
+        output,
+        ...(namespace !== undefined ? { namespace } : {}),
+    };
+}
+function parseDelete(rest) {
+    let file;
+    let cascade = false;
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === '-f' || arg === '--file') {
+            const value = rest[i + 1];
+            if (value === undefined)
+                return { kind: 'error', message: `${arg} requires a value` };
+            file = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--cascade') {
+            cascade = true;
+            continue;
+        }
+        return { kind: 'error', message: `unknown flag for delete: ${arg}` };
+    }
+    if (file === undefined)
+        return { kind: 'error', message: 'delete requires -f / --file' };
+    return { kind: 'delete', file, cascade };
+}
+function parseRollout(rest) {
+    const sub = rest[0];
+    if (sub === undefined) {
+        return { kind: 'error', message: 'rollout requires a subcommand: status | promote | abort' };
+    }
+    if (sub !== 'status' && sub !== 'promote' && sub !== 'abort') {
+        return { kind: 'error', message: `unknown rollout subcommand: ${sub}` };
+    }
+    const target = rest[1];
+    if (target === undefined || target.startsWith('-')) {
+        return { kind: 'error', message: `rollout ${sub} requires a target <namespace>/<name>` };
+    }
+    let dispatch;
+    for (let i = 2; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === '--dispatch') {
+            const value = rest[i + 1];
+            if (value === undefined)
+                return { kind: 'error', message: '--dispatch requires a value' };
+            dispatch = value;
+            i += 1;
+            continue;
+        }
+        return { kind: 'error', message: `unknown flag for rollout: ${arg}` };
+    }
+    if (dispatch === undefined) {
+        return { kind: 'error', message: `rollout ${sub} requires --dispatch <name>` };
+    }
+    return { kind: 'rollout', subCommand: sub, target, dispatch };
+}
+function parseApply(rest) {
+    let file;
+    let dryRun = false;
+    let watch = false;
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === '-f' || arg === '--file') {
+            const value = rest[i + 1];
+            if (value === undefined)
+                return { kind: 'error', message: `${arg} requires a value` };
+            file = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        if (arg === '--watch' || arg === '-w') {
+            watch = true;
+            continue;
+        }
+        return { kind: 'error', message: `unknown flag for apply: ${arg}` };
+    }
+    if (file === undefined) {
+        return { kind: 'error', message: 'apply requires -f / --file' };
+    }
+    if (dryRun && watch) {
+        return { kind: 'error', message: '--dry-run and --watch are mutually exclusive' };
+    }
+    return { kind: 'apply', file, dryRun, watch };
+}
+function parseDiff(rest) {
+    let file;
+    let output = 'text';
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === '-f' || arg === '--file') {
+            const value = rest[i + 1];
+            if (value === undefined)
+                return { kind: 'error', message: `${arg} requires a value` };
+            file = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '-o' || arg === '--output') {
+            const parsed = parseOutput(rest[i + 1]);
+            if (typeof parsed === 'object')
+                return { kind: 'error', message: parsed.error };
+            output = parsed;
+            i += 1;
+            continue;
+        }
+        return { kind: 'error', message: `unknown flag for diff: ${arg}` };
+    }
+    if (file === undefined) {
+        return { kind: 'error', message: 'diff requires -f / --file' };
+    }
+    return { kind: 'diff', file, output };
+}
+export const USAGE = `k1c — apply a subset of Kubernetes manifests to Cloudflare
+
+usage:
+  k1c apply    -f <manifest.yaml> [--dry-run | --watch]
+  k1c diff     -f <manifest.yaml> [-o text|json]
+  k1c delete   -f <manifest.yaml> [--cascade]
+  k1c get      <kind> [name] [-n <namespace>] [-o text|json]
+  k1c describe <kind> <name> [-n <namespace>] [-o text|json]
+  k1c rollout  {status|promote|abort} <ns>/<name> --dispatch <name>
+  k1c version
+
+environment:
+  K1C_ACCOUNT_ID        Cloudflare account id
+  CLOUDFLARE_API_TOKEN  API token with Workers Edit + R2 + KV permissions
+`;
+//# sourceMappingURL=args.js.map

package/dist/cli/canary-integration.d.ts

@@ -0,0 +1,11 @@
+import type { K1cResource } from '../manifest/types.ts';
+import type { DesiredResource } from '../reconciler/types.ts';
+import type { ProviderContext } from '../providers/types.ts';
+export interface CanaryIntegrationDeps {
+    readonly providerCtx: ProviderContext;
+    readonly out: (msg: string) => void;
+    readonly err: (msg: string) => void;
+    readonly now: () => Date;
+}
+export declare function advanceCanaryRolloutsForApply(parsed: ReadonlyArray<K1cResource>, desired: ReadonlyArray<DesiredResource>, deps: CanaryIntegrationDeps): Promise<void>;
+//# sourceMappingURL=canary-integration.d.ts.map

package/dist/cli/canary-integration.js

@@ -0,0 +1,101 @@
+import { runCanaryAdvance, } from "../canary/runtime.js";
+import { buildCloudflareEffects } from "../canary/effects-cloudflare.js";
+const CANARY_ANNOTATION = 'cloudflare.com/dispatch-namespace';
+export async function advanceCanaryRolloutsForApply(parsed, desired, deps) {
+    const annotatedRollouts = parsed.filter((r) => r.kind === 'Rollout' &&
+        typeof r.metadata.annotations?.[CANARY_ANNOTATION] === 'string');
+    if (annotatedRollouts.length === 0)
+        return;
+    const inputs = await Promise.all(annotatedRollouts.map((rollout) => buildInputForRollout(rollout, desired, deps)));
+    const valid = inputs.filter((i) => i !== null);
+    if (valid.length === 0)
+        return;
+    const stateClient = await buildStateClient(annotatedRollouts, deps);
+    if (stateClient === null) {
+        deps.err(`canary advance skipped: rollout-state KV not yet provisioned (re-run \`k1c apply\` after the standard apply finishes)`);
+        return;
+    }
+    const effects = buildCloudflareEffects({
+        cloudflare: deps.providerCtx.cloudflare,
+        accountId: deps.providerCtx.accountId,
+        managedByLabel: deps.providerCtx.managedByLabel,
+    });
+    deps.out('');
+    deps.out('[canary]');
+    const reports = await runCanaryAdvance(valid, {
+        state: stateClient,
+        effects,
+        now: deps.now,
+    });
+    for (const r of reports) {
+        deps.out(`  ${r.label}: ${r.previousStatus} → ${r.nextStatus} (weight=${r.nextWeight}%)` +
+            (r.actions.length ? `, actions: ${r.actions.map((a) => a.kind).join(', ')}` : ''));
+    }
+}
+async function buildInputForRollout(rollout, desired, deps) {
+    const ns = rollout.metadata.namespace ?? 'default';
+    const name = rollout.metadata.name;
+    const stableLabel = `${ns}/${name}--stable`;
+    const stable = desired.find((d) => d.resourceType === 'Worker' && d.label === stableLabel);
+    if (!stable) {
+        deps.err(`canary: stable DesiredResource for ${ns}/${name} not found in lowered output`);
+        return null;
+    }
+    const stableProps = stable.properties;
+    const entrypointContent = await readEntrypoint(stableProps, deps);
+    return { rollout, stableProps, entrypointContent };
+}
+async function readEntrypoint(props, deps) {
+    if (props.entrypointContent !== undefined) {
+        return new TextEncoder().encode(props.entrypointContent);
+    }
+    const reader = deps.providerCtx.readFile ??
+        (async (p) => {
+            const fs = await import('node:fs/promises');
+            return fs.readFile(p);
+        });
+    return reader(props.entrypoint);
+}
+async function buildStateClient(rollouts, deps) {
+    // For v0.1.2, we assume a single dispatch namespace per apply (the common case).
+    const dispatch = rollouts[0]?.metadata.annotations?.[CANARY_ANNOTATION];
+    if (dispatch === undefined)
+        return null;
+    const expected = `k1c/rollout-state/${dispatch}`;
+    let stateKvId = null;
+    for await (const ns of deps.providerCtx.cloudflare.kv.namespaces.list({
+        account_id: deps.providerCtx.accountId,
+    })) {
+        if (ns.title === expected) {
+            stateKvId = ns.id;
+            break;
+        }
+    }
+    if (stateKvId === null)
+        return null;
+    const accountId = deps.providerCtx.accountId;
+    const cf = deps.providerCtx.cloudflare;
+    return {
+        async read(key) {
+            try {
+                const resp = await cf.kv.namespaces.values.get(stateKvId, key, {
+                    account_id: accountId,
+                });
+                return await resp.text();
+            }
+            catch (e) {
+                if (e !== null && typeof e === 'object' && e.status === 404) {
+                    return null;
+                }
+                throw e;
+            }
+        },
+        async write(key, value) {
+            await cf.kv.namespaces.values.update(stateKvId, key, {
+                account_id: accountId,
+                value,
+            });
+        },
+    };
+}
+//# sourceMappingURL=canary-integration.js.map

package/dist/cli/format.d.ts

@@ -0,0 +1,4 @@
+import type { ApplyReport, Plan } from '../reconciler/types.ts';
+export declare function formatPlan(plan: Plan): string;
+export declare function formatReport(report: ApplyReport): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/cli/format.js

@@ -0,0 +1,44 @@
+const KIND_WIDTH = 7;
+const TYPE_WIDTH = 12;
+const LABEL_WIDTH = 24;
+function pad(s, width) {
+    if (s.length >= width)
+        return s;
+    return s + ' '.repeat(width - s.length);
+}
+export function formatPlan(plan) {
+    if (plan.operations.length === 0)
+        return '(no changes)';
+    const lines = plan.operations.map((op) => {
+        const kind = pad(op.kind.toUpperCase(), KIND_WIDTH);
+        const rt = pad(op.resourceType, TYPE_WIDTH);
+        return `  ${kind} ${rt} ${op.label}`;
+    });
+    return lines.join('\n');
+}
+export function formatReport(report) {
+    const lines = report.results.map((r) => formatResult(r.op, r.status, r.nativeId, r.error));
+    lines.push('');
+    lines.push(`summary: ${report.succeeded} ok / ${report.failed} failed / ${report.skipped} skipped`);
+    return lines.join('\n');
+}
+function formatResult(op, status, nativeId, error) {
+    const tag = pad(statusTag(status), 8);
+    const kind = pad(op.kind.toUpperCase(), KIND_WIDTH);
+    const rt = pad(op.resourceType, TYPE_WIDTH);
+    const label = pad(op.label, LABEL_WIDTH);
+    const trail = error
+        ? `${error.code}: ${error.message}`
+        : nativeId !== undefined
+            ? `(${nativeId})`
+            : '';
+    return `  ${tag} ${kind} ${rt} ${label}${trail ? ' ' + trail : ''}`;
+}
+function statusTag(status) {
+    if (status === 'succeeded')
+        return 'ok';
+    if (status === 'failed')
+        return 'FAILED';
+    return 'skip';
+}
+//# sourceMappingURL=format.js.map

package/dist/cli/main.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=main.d.ts.map