@mizchi/k1c 0.1.0

package/dist/cli/main.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { readFile, watch } from 'node:fs/promises';
+import process from 'node:process';
+import { resolve as resolvePath } from 'node:path';
+import Cloudflare from 'cloudflare';
+import { parseArgs, USAGE } from "./args.js";
+import { runApply, runDelete, runDescribe, runDiff, runGet } from "./run.js";
+import { createDefaultRegistry } from "../providers/index.js";
+import { runRolloutCommand } from "../canary/rollout-command.js";
+import pkg from '../../package.json' with { type: 'json' };
+const VERSION = pkg.version;
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.kind === 'help') {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+    if (parsed.kind === 'version') {
+        process.stdout.write(`k1c ${VERSION}\n`);
+        return 0;
+    }
+    if (parsed.kind === 'error') {
+        process.stderr.write(`k1c: ${parsed.message}\n\n${USAGE}`);
+        return 2;
+    }
+    const accountId = process.env['K1C_ACCOUNT_ID'];
+    const apiToken = process.env['CLOUDFLARE_API_TOKEN'];
+    if (!accountId) {
+        process.stderr.write('K1C_ACCOUNT_ID is not set\n');
+        return 2;
+    }
+    if (!apiToken) {
+        process.stderr.write('CLOUDFLARE_API_TOKEN is not set\n');
+        return 2;
+    }
+    const cloudflare = new Cloudflare({ apiToken });
+    const ctx = {
+        cloudflare,
+        accountId,
+        namespace: 'default',
+        managedByLabel: 'k1c.io/managed-by=k1c',
+        signal: new AbortController().signal,
+        readFile: async (path) => readFile(path),
+    };
+    const deps = {
+        registry: createDefaultRegistry(),
+        providerCtx: ctx,
+        readManifest: async (path) => {
+            const buf = await readFile(path);
+            return buf.toString('utf-8');
+        },
+        out: (msg) => process.stdout.write(`${msg}\n`),
+        err: (msg) => process.stderr.write(`${msg}\n`),
+    };
+    if (parsed.kind === 'apply') {
+        return parsed.watch ? runApplyWatch(parsed, deps) : runApply(parsed, deps);
+    }
+    if (parsed.kind === 'diff')
+        return runDiff(parsed, deps);
+    if (parsed.kind === 'get')
+        return runGet(parsed, deps);
+    if (parsed.kind === 'describe')
+        return runDescribe(parsed, deps);
+    if (parsed.kind === 'delete')
+        return runDelete(parsed, deps);
+    if (parsed.kind === 'rollout')
+        return runRollout(parsed, cloudflare, accountId);
+    return 2;
+}
+async function runApplyWatch(args, deps) {
+    const filePath = resolvePath(args.file);
+    process.stdout.write(`(watching ${filePath} — initial apply)\n`);
+    await runApply(args, deps);
+    process.stdout.write(`\n(watching for changes; Ctrl-C to exit)\n`);
+    // Coalesce bursts of fs events; editors often emit multiple events per save.
+    let pending = null;
+    let inFlight = Promise.resolve();
+    const trigger = () => {
+        if (pending !== null)
+            clearTimeout(pending);
+        pending = setTimeout(() => {
+            pending = null;
+            inFlight = inFlight.then(async () => {
+                process.stdout.write(`\n(change detected → re-applying)\n`);
+                try {
+                    await runApply(args, deps);
+                }
+                catch (e) {
+                    process.stderr.write(`apply during watch failed: ${e instanceof Error ? e.message : String(e)}\n`);
+                }
+            });
+        }, 200);
+    };
+    try {
+        for await (const _event of watch(filePath)) {
+            trigger();
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            process.stderr.write(`manifest no longer readable: ${filePath}\n`);
+            return 1;
+        }
+        throw e;
+    }
+    return 0;
+}
+async function runRollout(args, cloudflare, accountId) {
+    const stateKvId = await findStateKvId(cloudflare, accountId, args.dispatch);
+    if (stateKvId === null) {
+        process.stderr.write(`no rollout-state KV found for dispatch namespace "${args.dispatch}"; run \`k1c apply\` first\n`);
+        return 1;
+    }
+    const state = {
+        async read(key) {
+            try {
+                const resp = await cloudflare.kv.namespaces.values.get(stateKvId, key, {
+                    account_id: accountId,
+                });
+                return await resp.text();
+            }
+            catch (e) {
+                if (isApi404(e))
+                    return null;
+                throw e;
+            }
+        },
+        async write(key, value) {
+            await cloudflare.kv.namespaces.values.update(stateKvId, key, {
+                account_id: accountId,
+                value,
+            });
+        },
+    };
+    return runRolloutCommand({ subCommand: args.subCommand, target: args.target }, {
+        state,
+        out: (msg) => process.stdout.write(`${msg}\n`),
+        err: (msg) => process.stderr.write(`${msg}\n`),
+    });
+}
+async function findStateKvId(cf, accountId, dispatch) {
+    const expected = `k1c/rollout-state/${dispatch}`;
+    for await (const ns of cf.kv.namespaces.list({ account_id: accountId })) {
+        if (ns.title === expected)
+            return ns.id;
+    }
+    return null;
+}
+function isApi404(err) {
+    if (err === null || typeof err !== 'object')
+        return false;
+    return err.status === 404;
+}
+main().then((code) => process.exit(code), (err) => {
+    process.stderr.write(`fatal: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map

package/dist/cli/run.d.ts

@@ -0,0 +1,16 @@
+import type { ProviderRegistry } from '../providers/registry.ts';
+import type { ProviderContext } from '../providers/types.ts';
+import type { ApplyArgs, DeleteArgs, DescribeArgs, DiffArgs, GetArgs } from './args.ts';
+export interface RunDeps {
+    readonly registry: ProviderRegistry;
+    readonly providerCtx: ProviderContext;
+    readonly readManifest: (path: string) => Promise<string>;
+    readonly out: (msg: string) => void;
+    readonly err: (msg: string) => void;
+}
+export declare function runApply(args: ApplyArgs, deps: RunDeps): Promise<number>;
+export declare function runDiff(args: DiffArgs, deps: RunDeps): Promise<number>;
+export declare function runGet(args: GetArgs, deps: RunDeps): Promise<number>;
+export declare function runDescribe(args: DescribeArgs, deps: RunDeps): Promise<number>;
+export declare function runDelete(args: DeleteArgs, deps: RunDeps): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

package/dist/cli/run.js

@@ -0,0 +1,246 @@
+import { parseManifest } from "../manifest/parse.js";
+import { lower } from "../manifest/lower.js";
+import { plan } from "../reconciler/plan.js";
+import { apply } from "../reconciler/apply.js";
+import { NotFound } from "../providers/types.js";
+import { formatPlan, formatReport } from "./format.js";
+import { advanceCanaryRolloutsForApply } from "./canary-integration.js";
+export async function runApply(args, deps) {
+    const loaded = await loadParsedAndDesired(args.file, deps);
+    if (loaded === null)
+        return 3;
+    const { parsed, desired } = loaded;
+    const planResult = await plan(desired, deps.registry, deps.providerCtx);
+    deps.out('[plan]');
+    deps.out(formatPlan(planResult));
+    if (args.dryRun) {
+        deps.out('');
+        deps.out('(dry-run: no changes applied)');
+        return 0;
+    }
+    let exitCode = 0;
+    if (planResult.operations.length > 0) {
+        deps.out('');
+        deps.out('[apply]');
+        const report = await apply(planResult, deps.registry, deps.providerCtx);
+        deps.out(formatReport(report));
+        if (report.failed > 0)
+            exitCode = 1;
+    }
+    if (exitCode === 0) {
+        try {
+            await advanceCanaryRolloutsForApply(parsed, desired, {
+                providerCtx: deps.providerCtx,
+                out: deps.out,
+                err: deps.err,
+                now: () => new Date(),
+            });
+        }
+        catch (e) {
+            deps.err(`canary advance failed: ${e instanceof Error ? e.message : String(e)}`);
+            exitCode = 1;
+        }
+    }
+    return exitCode;
+}
+export async function runDiff(args, deps) {
+    const loaded = await loadParsedAndDesired(args.file, deps);
+    if (loaded === null)
+        return 3;
+    const planResult = await plan(loaded.desired, deps.registry, deps.providerCtx);
+    if (args.output === 'json') {
+        deps.out(JSON.stringify({ operations: planResult.operations }, null, 2));
+    }
+    else {
+        deps.out('[plan]');
+        deps.out(formatPlan(planResult));
+    }
+    return 0;
+}
+export async function runGet(args, deps) {
+    if (!deps.registry.has(args.resourceKind)) {
+        deps.err(`unknown resource kind: ${args.resourceKind}`);
+        return 2;
+    }
+    const provider = deps.registry.get(args.resourceKind);
+    const rows = [];
+    try {
+        for await (const item of provider.list(deps.providerCtx)) {
+            if (args.namespace !== undefined && !item.label.startsWith(`${args.namespace}/`))
+                continue;
+            if (args.name !== undefined && !item.label.endsWith(`/${args.name}`))
+                continue;
+            rows.push({ label: item.label, nativeId: item.nativeId });
+        }
+    }
+    catch (e) {
+        deps.err(`get failed: ${e instanceof Error ? e.message : String(e)}`);
+        return 1;
+    }
+    if (args.output === 'json') {
+        deps.out(JSON.stringify({ kind: args.resourceKind, items: rows }, null, 2));
+        return 0;
+    }
+    if (rows.length === 0) {
+        deps.out(`(no ${args.resourceKind} resources found)`);
+        return 0;
+    }
+    const labelW = Math.max(8, ...rows.map((r) => r.label.length));
+    deps.out(`${pad('LABEL', labelW)}  NATIVE_ID`);
+    for (const r of rows)
+        deps.out(`${pad(r.label, labelW)}  ${r.nativeId}`);
+    return 0;
+}
+export async function runDescribe(args, deps) {
+    if (!deps.registry.has(args.resourceKind)) {
+        deps.err(`unknown resource kind: ${args.resourceKind}`);
+        return 2;
+    }
+    const provider = deps.registry.get(args.resourceKind);
+    const ns = args.namespace ?? 'default';
+    const targetLabel = `${ns}/${args.name}`;
+    let nativeId = null;
+    try {
+        for await (const item of provider.list(deps.providerCtx)) {
+            if (item.label === targetLabel) {
+                nativeId = item.nativeId;
+                break;
+            }
+        }
+    }
+    catch (e) {
+        deps.err(`describe failed during list: ${e instanceof Error ? e.message : String(e)}`);
+        return 1;
+    }
+    if (nativeId === null) {
+        deps.err(`${args.resourceKind} ${targetLabel} not found`);
+        return 1;
+    }
+    let props;
+    try {
+        props = await provider.read(deps.providerCtx, nativeId);
+    }
+    catch (e) {
+        deps.err(`describe failed during read: ${e instanceof Error ? e.message : String(e)}`);
+        return 1;
+    }
+    if (props === NotFound) {
+        deps.err(`${args.resourceKind} ${targetLabel} (nativeId=${nativeId}) was listed but read returned NotFound`);
+        return 1;
+    }
+    if (args.output === 'json') {
+        deps.out(JSON.stringify({
+            kind: args.resourceKind,
+            label: targetLabel,
+            nativeId,
+            properties: props,
+        }, null, 2));
+        return 0;
+    }
+    deps.out(`Kind:       ${args.resourceKind}`);
+    deps.out(`Label:      ${targetLabel}`);
+    deps.out(`NativeID:   ${nativeId}`);
+    deps.out('Properties:');
+    deps.out(indent(JSON.stringify(props, null, 2), 2));
+    return 0;
+}
+export async function runDelete(args, deps) {
+    const loaded = await loadParsedAndDesired(args.file, deps);
+    if (loaded === null)
+        return 3;
+    const targets = [];
+    for (const d of loaded.desired) {
+        if (!args.cascade && (d.resourceType === 'R2Bucket' || d.resourceType === 'KVNamespace')) {
+            deps.out(`(skipping ${d.resourceType} ${d.label} — pass --cascade to delete user data)`);
+            continue;
+        }
+        targets.push({ resourceType: d.resourceType, label: d.label });
+    }
+    let succeeded = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const t of targets) {
+        if (!deps.registry.has(t.resourceType)) {
+            deps.err(`no provider for ${t.resourceType}; skipping ${t.label}`);
+            skipped += 1;
+            continue;
+        }
+        const provider = deps.registry.get(t.resourceType);
+        let nativeId = null;
+        try {
+            for await (const item of provider.list(deps.providerCtx)) {
+                if (item.label === t.label) {
+                    nativeId = item.nativeId;
+                    break;
+                }
+            }
+        }
+        catch (e) {
+            deps.err(`delete: list failed for ${t.resourceType} ${t.label}: ${e instanceof Error ? e.message : String(e)}`);
+            failed += 1;
+            continue;
+        }
+        if (nativeId === null) {
+            deps.out(`(${t.resourceType} ${t.label} not found in cluster, skipping)`);
+            skipped += 1;
+            continue;
+        }
+        try {
+            await provider.delete(deps.providerCtx, nativeId);
+            deps.out(`deleted ${t.resourceType} ${t.label} (${nativeId})`);
+            succeeded += 1;
+        }
+        catch (e) {
+            deps.err(`failed to delete ${t.resourceType} ${t.label}: ${e instanceof Error ? e.message : String(e)}`);
+            failed += 1;
+        }
+    }
+    deps.out(`summary: ${succeeded} deleted / ${failed} failed / ${skipped} skipped`);
+    return failed === 0 ? 0 : 1;
+}
+function pad(s, w) {
+    if (s.length >= w)
+        return s;
+    return s + ' '.repeat(w - s.length);
+}
+function indent(text, n) {
+    const prefix = ' '.repeat(n);
+    return text
+        .split('\n')
+        .map((line) => prefix + line)
+        .join('\n');
+}
+async function loadParsedAndDesired(file, deps) {
+    let yamlText;
+    try {
+        yamlText = await deps.readManifest(file);
+    }
+    catch (e) {
+        deps.err(`failed to read manifest ${file}: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = parseManifest(yamlText);
+    }
+    catch (e) {
+        deps.err(`manifest parse error: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+    for (const w of parsed.warnings) {
+        const where = w.ref ? `${w.ref.kind}/${w.ref.namespace}/${w.ref.name}` : '';
+        deps.err(`warning: ${where} ${w.message}`);
+    }
+    let lowered;
+    try {
+        lowered = await lower(parsed.resources, {
+            readFile: deps.providerCtx.readFile,
+        });
+    }
+    catch (e) {
+        deps.err(`lower error: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+    return { parsed: parsed.resources, desired: lowered.desired };
+}
+//# sourceMappingURL=run.js.map

package/dist/manifest/lower.d.ts

@@ -0,0 +1,22 @@
+import type { K1cResource, ResourceRef } from './types.ts';
+import type { DesiredResource } from '../reconciler/types.ts';
+export declare class LowerError extends Error {
+    constructor(message: string);
+}
+export interface LowerWarning {
+    readonly ref: ResourceRef;
+    readonly message: string;
+}
+export interface LowerResult {
+    readonly desired: ReadonlyArray<DesiredResource>;
+    readonly warnings: ReadonlyArray<LowerWarning>;
+}
+export interface LowerOptions {
+    /**
+     * Reads the bytes of a Worker entrypoint file. Defaults to fs/promises.readFile.
+     * Tests inject a stub to keep lower decoupled from disk I/O.
+     */
+    readonly readFile?: (path: string) => Promise<Uint8Array>;
+}
+export declare function lower(resources: ReadonlyArray<K1cResource>, options?: LowerOptions): Promise<LowerResult>;
+//# sourceMappingURL=lower.d.ts.map