@solcreek/cli 0.4.20 → 0.4.22

package/dist/utils/local-cache.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Project-local cache of the laptop's view of creekd's state.
+ *
+ * Lives at `<project>/.creek/local.json` and is the canonical
+ * source for the `If-Match` header per DESIGN-self-host-state.md
+ * §"First-party CLI MUST send If-Match" (line 230-232):
+ *
+ *   "The creek CLI ... MUST send If-Match on every mutating call,
+ *    sourced from .creek/local.json.lastDeploy.resourceVersion."
+ *
+ * Schema is intentionally narrow in 0.0.x:
+ *   {
+ *     "schemaVersion": 1,
+ *     "lastDeploy": {
+ *       "appId": "...",
+ *       "host": "...",       // hosts.json name; "" for default loopback
+ *       "resourceVersion": "<opaque>",
+ *       "generation": <int>,
+ *       "at": "RFC3339"
+ *     }
+ *   }
+ *
+ * Writes are atomic (tmp + rename) to match the hosts.json
+ * convention; corrupt-then-crash leaves the file untouched.
+ *
+ * NOTE: this is per-project state, NOT per-host. Multi-host
+ * deploys of the same project use a single lastDeploy slot —
+ * switching --host between deploys invalidates the cache and
+ * triggers a fresh GET to re-seed. This is intentional: the cache
+ * is a hot path optimisation, not authoritative — the daemon's
+ * current rv is always the truth.
+ */
+export declare const LOCAL_SCHEMA_VERSION = 1;
+/** Snapshot of the last successful spec-mutation against creekd. */
+export interface LastDeploy {
+    appId: string;
+    /** hosts.json `name` if any was used; empty string for default localhost. */
+    host: string;
+    /** Opaque rv string from the wire — clients MUST NOT do arithmetic on it. */
+    resourceVersion: string;
+    /** Generation as of last successful deploy (sanity check). */
+    generation: number;
+    /** RFC3339 timestamp of the write. */
+    at: string;
+}
+export interface LocalCacheFile {
+    schemaVersion: number;
+    lastDeploy?: LastDeploy;
+}
+/** Resolve <project>/.creek/local.json. */
+export declare function localCachePath(projectRoot: string): string;
+/** Read the cache. Returns an empty file shape if absent. */
+export declare function readLocalCache(projectRoot: string): LocalCacheFile;
+/** Atomic write — tmp + rename. */
+export declare function writeLocalCache(projectRoot: string, file: LocalCacheFile): void;
+/**
+ * Update lastDeploy after a successful spec mutation. Reads the
+ * existing file, replaces lastDeploy, writes back. Convenience
+ * wrapper for the most common write pattern.
+ */
+export declare function recordLastDeploy(projectRoot: string, lastDeploy: LastDeploy): void;
+/**
+ * Read the cached rv for an If-Match header. Returns undefined
+ * when the cache is empty, when the appId/host don't match
+ * (different project or host than last deploy), or when the cache
+ * is corrupt. Callers fall back to a fresh GET on undefined.
+ */
+export declare function cachedResourceVersion(projectRoot: string, appId: string, host: string): string | undefined;
+//# sourceMappingURL=local-cache.d.ts.map

package/dist/utils/local-cache.js

@@ -0,0 +1,100 @@
+/**
+ * Project-local cache of the laptop's view of creekd's state.
+ *
+ * Lives at `<project>/.creek/local.json` and is the canonical
+ * source for the `If-Match` header per DESIGN-self-host-state.md
+ * §"First-party CLI MUST send If-Match" (line 230-232):
+ *
+ *   "The creek CLI ... MUST send If-Match on every mutating call,
+ *    sourced from .creek/local.json.lastDeploy.resourceVersion."
+ *
+ * Schema is intentionally narrow in 0.0.x:
+ *   {
+ *     "schemaVersion": 1,
+ *     "lastDeploy": {
+ *       "appId": "...",
+ *       "host": "...",       // hosts.json name; "" for default loopback
+ *       "resourceVersion": "<opaque>",
+ *       "generation": <int>,
+ *       "at": "RFC3339"
+ *     }
+ *   }
+ *
+ * Writes are atomic (tmp + rename) to match the hosts.json
+ * convention; corrupt-then-crash leaves the file untouched.
+ *
+ * NOTE: this is per-project state, NOT per-host. Multi-host
+ * deploys of the same project use a single lastDeploy slot —
+ * switching --host between deploys invalidates the cache and
+ * triggers a fresh GET to re-seed. This is intentional: the cache
+ * is a hot path optimisation, not authoritative — the daemon's
+ * current rv is always the truth.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { dirname, join } from "node:path";
+export const LOCAL_SCHEMA_VERSION = 1;
+/** Resolve <project>/.creek/local.json. */
+export function localCachePath(projectRoot) {
+    return join(projectRoot, ".creek", "local.json");
+}
+/** Read the cache. Returns an empty file shape if absent. */
+export function readLocalCache(projectRoot) {
+    const path = localCachePath(projectRoot);
+    if (!existsSync(path)) {
+        return { schemaVersion: LOCAL_SCHEMA_VERSION };
+    }
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.schemaVersion !== "number") {
+        throw new Error(`local.json: missing schemaVersion`);
+    }
+    if (parsed.schemaVersion !== LOCAL_SCHEMA_VERSION) {
+        throw new Error(`local.json: unsupported schemaVersion ${parsed.schemaVersion} ` +
+            `(want ${LOCAL_SCHEMA_VERSION})`);
+    }
+    return parsed;
+}
+/** Atomic write — tmp + rename. */
+export function writeLocalCache(projectRoot, file) {
+    if (file.schemaVersion !== LOCAL_SCHEMA_VERSION) {
+        throw new Error(`writeLocalCache: schemaVersion ${file.schemaVersion} != ${LOCAL_SCHEMA_VERSION}`);
+    }
+    const path = localCachePath(projectRoot);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = path + ".tmp";
+    writeFileSync(tmp, JSON.stringify(file, null, 2) + "\n", { mode: 0o600 });
+    renameSync(tmp, path);
+}
+/**
+ * Update lastDeploy after a successful spec mutation. Reads the
+ * existing file, replaces lastDeploy, writes back. Convenience
+ * wrapper for the most common write pattern.
+ */
+export function recordLastDeploy(projectRoot, lastDeploy) {
+    const file = readLocalCache(projectRoot);
+    writeLocalCache(projectRoot, { ...file, lastDeploy });
+}
+/**
+ * Read the cached rv for an If-Match header. Returns undefined
+ * when the cache is empty, when the appId/host don't match
+ * (different project or host than last deploy), or when the cache
+ * is corrupt. Callers fall back to a fresh GET on undefined.
+ */
+export function cachedResourceVersion(projectRoot, appId, host) {
+    let file;
+    try {
+        file = readLocalCache(projectRoot);
+    }
+    catch {
+        return undefined;
+    }
+    const last = file.lastDeploy;
+    if (!last)
+        return undefined;
+    if (last.appId !== appId)
+        return undefined;
+    if (last.host !== host)
+        return undefined;
+    return last.resourceVersion;
+}
+//# sourceMappingURL=local-cache.js.map

package/dist/utils/nextjs.d.ts

@@ -15,8 +15,10 @@ export declare function getNextVersion(cwd: string): string | null;
 /**
  * Unified Next.js build entry point.
  *
- * - Next.js >= 16.2.3: Creek adapter path (recommended)
- * - Next.js < 16.2.3: legacy opennext path (best effort)
+ * - Next.js >= 16.2.3: Creek adapter path (recommended). The adapter is
+ *   lazily installed into .creek/node_modules on first use — the CLI never
+ *   depends on it directly, so non-Next.js users never pay for it.
+ * - Next.js < 16.2.3 (or adapter install fails): legacy opennext path.
  *
  * Min version for the adapter path matches @solcreek/adapter-creek's
  * peerDependency, which pins Next.js >= 16.2.3 to fix CVE-2026-23869.

package/dist/utils/nextjs.js

@@ -40,27 +40,38 @@ function semverGte(version, target) {
     return aPat >= bPat;
 }
 /**
- * Build a Next.js app using the Creek adapter (>= 16.2.3).
+ * Resolve @solcreek/adapter-creek from any reachable location.
  *
- * Sets NEXT_ADAPTER_PATH to the adapter bundled with the CLI.
- * No opennext, no wrangler, no config patching — the adapter handles
- * everything inside onBuildComplete().
+ * Tries, in order: the CLI's own install (monorepo workspace / global
+ * install alongside the adapter), the project's own node_modules, then the
+ * lazy-installed copy under .creek/node_modules. Returns the adapter entry
+ * path (for NEXT_ADAPTER_PATH), or null if not installed anywhere.
  */
-function resolveAdapterPath() {
-    try {
-        const require = createRequire(import.meta.url);
-        return require.resolve("@solcreek/adapter-creek");
+function resolveAdapterPath(cwd) {
+    const bases = [import.meta.url];
+    if (cwd) {
+        // createRequire walks node_modules up from the base file's directory;
+        // the base file itself need not exist.
+        bases.push(join(cwd, "package.json"));
+        bases.push(join(cwd, CREEK_DIR, "package.json"));
     }
-    catch {
-        return null;
+    for (const base of bases) {
+        try {
+            return createRequire(base).resolve("@solcreek/adapter-creek");
+        }
+        catch {
+            // try next base
+        }
     }
+    return null;
 }
-function buildWithAdapter(cwd) {
-    const adapterPath = resolveAdapterPath();
-    if (!adapterPath) {
-        consola.warn("  @solcreek/adapter-creek not found — install it for optimal Next.js builds");
-        return; // caller falls back to legacy
-    }
+/**
+ * Build a Next.js app using the Creek adapter (>= 16.2.3).
+ *
+ * Sets NEXT_ADAPTER_PATH to the resolved adapter. No opennext, no wrangler,
+ * no config patching — the adapter handles everything inside onBuildComplete().
+ */
+function buildWithAdapter(cwd, adapterPath) {
     consola.start("  Building Next.js with Creek adapter...\n");
     // --webpack is required: Turbopack does not generate standalone output,
     // and its chunked format uses a custom runtime incompatible with esbuild.
@@ -73,24 +84,28 @@ function buildWithAdapter(cwd) {
 /**
  * Unified Next.js build entry point.
  *
- * - Next.js >= 16.2.3: Creek adapter path (recommended)
- * - Next.js < 16.2.3: legacy opennext path (best effort)
+ * - Next.js >= 16.2.3: Creek adapter path (recommended). The adapter is
+ *   lazily installed into .creek/node_modules on first use — the CLI never
+ *   depends on it directly, so non-Next.js users never pay for it.
+ * - Next.js < 16.2.3 (or adapter install fails): legacy opennext path.
  *
  * Min version for the adapter path matches @solcreek/adapter-creek's
  * peerDependency, which pins Next.js >= 16.2.3 to fix CVE-2026-23869.
  */
 export function buildNextjs(cwd, isMonorepo, projectName) {
     const version = getNextVersion(cwd);
-    const useAdapter = version && semverGte(version, "16.2.3") && resolveAdapterPath();
-    if (useAdapter) {
-        buildWithAdapter(cwd);
-    }
-    else {
-        if (version) {
-            consola.warn(`  Next.js ${version} — using legacy build path`);
+    if (version && semverGte(version, "16.2.3")) {
+        const adapterPath = ensureAdapter(cwd);
+        if (adapterPath) {
+            buildWithAdapter(cwd, adapterPath);
+            return;
         }
-        buildNextjsForWorkers(cwd, isMonorepo, projectName);
+        consola.warn(`  Falling back to legacy build path for Next.js ${version}`);
     }
+    else if (version) {
+        consola.warn(`  Next.js ${version} — using legacy build path`);
+    }
+    buildNextjsForWorkers(cwd, isMonorepo, projectName);
 }
 /** Check if the adapter output exists (vs legacy opennext output). */
 export function hasAdapterOutput(cwd) {
@@ -132,6 +147,71 @@ export function patchBundledWorker(bundleDir, openNextDir) {
 const CREEK_DIR = ".creek";
 const OPENNEXT_PKG = "@opennextjs/cloudflare";
 const OPENNEXT_VERSION = "^1.18.0";
+const ADAPTER_PKG = "@solcreek/adapter-creek";
+const ADAPTER_VERSION = "^0.2.0";
+/**
+ * Merge a dependency into .creek/package.json without clobbering deps that
+ * a previous install (adapter or opennext) may have already written.
+ */
+function upsertCreekDep(creekDir, pkg, version) {
+    const pkgPath = join(creekDir, "package.json");
+    let manifest = {
+        private: true,
+        dependencies: {},
+    };
+    if (existsSync(pkgPath)) {
+        try {
+            manifest = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            manifest.dependencies ??= {};
+        }
+        catch {
+            manifest = { private: true, dependencies: {} };
+        }
+    }
+    manifest.dependencies[pkg] = version;
+    writeFileSync(pkgPath, JSON.stringify(manifest, null, 2));
+}
+/**
+ * Install a package into .creek/node_modules. Returns false if npm fails.
+ */
+function installCreekDep(creekDir, pkg, version) {
+    mkdirSync(creekDir, { recursive: true });
+    upsertCreekDep(creekDir, pkg, version);
+    try {
+        execSync("npm install --no-audit --no-fund --ignore-scripts --no-optional", {
+            cwd: creekDir,
+            stdio: "pipe",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure @solcreek/adapter-creek is resolvable, lazily installing it into
+ * .creek/node_modules on demand. Returns the resolved adapter entry path
+ * (for NEXT_ADAPTER_PATH), or null if it could not be made available.
+ *
+ * Lazy by design: the CLI stays framework-neutral, so the adapter — a
+ * Next.js-specific package with its own Next peerDependency — is only
+ * fetched when a Next.js project is actually deployed. It is never a hard
+ * CLI dependency that every `npx creek` user would pay for.
+ */
+function ensureAdapter(cwd) {
+    const existing = resolveAdapterPath(cwd);
+    if (existing)
+        return existing;
+    consola.start(`  Installing ${ADAPTER_PKG} (one-time setup)...`);
+    if (!installCreekDep(join(cwd, CREEK_DIR), ADAPTER_PKG, ADAPTER_VERSION)) {
+        consola.warn(`  Could not install ${ADAPTER_PKG}`);
+        return null;
+    }
+    const resolved = resolveAdapterPath(cwd);
+    if (resolved)
+        consola.success(`  ${ADAPTER_PKG} installed`);
+    return resolved;
+}
 /**
  * Ensure @opennextjs/cloudflare is available in .creek/node_modules.
  * Returns the path to the opennextjs-cloudflare CLI binary.
@@ -142,18 +222,7 @@ function ensureOpenNext(cwd) {
     if (existsSync(opennextBin))
         return opennextBin;
     consola.start(`  Installing ${OPENNEXT_PKG} (one-time setup)...`);
-    mkdirSync(creekDir, { recursive: true });
-    const pkgPath = join(creekDir, "package.json");
-    if (!existsSync(pkgPath)) {
-        writeFileSync(pkgPath, JSON.stringify({
-            private: true,
-            dependencies: { [OPENNEXT_PKG]: OPENNEXT_VERSION },
-        }, null, 2));
-    }
-    execSync("npm install --no-audit --no-fund --ignore-scripts --no-optional", {
-        cwd: creekDir,
-        stdio: "pipe",
-    });
+    installCreekDep(creekDir, OPENNEXT_PKG, OPENNEXT_VERSION);
     consola.success(`  ${OPENNEXT_PKG} installed`);
     return opennextBin;
 }

package/dist/utils/prepare-bundle.js

@@ -82,7 +82,7 @@ export async function prepareDeployBundle(input) {
     const useAdapterOutput = framework === "nextjs" && hasAdapterOutput(cwd);
     const outputDir = useAdapterOutput
         ? resolve(cwd, ".creek/adapter-output")
-        : resolve(cwd, resolved.buildOutput || getDefaultBuildOutput(framework));
+        : resolve(cwd, resolved.buildOutput || getDefaultBuildOutput(framework, cwd));
     // 4. Post-build framework adapter detection. Astro can be either SSG
     // or CF-adapter-SSR; we only know which after build.
     const astroAdapter = framework === "astro" ? detectAstroCloudflareBuild(cwd) : null;

package/dist/utils/top-format.d.ts

@@ -0,0 +1,4 @@
+export declare function fmtBytes(bytes: number): string;
+export declare function fmtDuration(ms: number): string;
+export declare function calcCpuPercent(prevUsec: number, prevTs: number, currUsec: number, currTs: number): number | null;
+//# sourceMappingURL=top-format.d.ts.map

package/dist/utils/top-format.js

@@ -0,0 +1,32 @@
+export function fmtBytes(bytes) {
+    if (bytes < 1024)
+        return bytes + "B";
+    if (bytes < 1024 * 1024)
+        return (bytes / 1024).toFixed(1) + "K";
+    if (bytes < 1024 * 1024 * 1024)
+        return (bytes / (1024 * 1024)).toFixed(1) + "M";
+    return (bytes / (1024 * 1024 * 1024)).toFixed(1) + "G";
+}
+export function fmtDuration(ms) {
+    if (ms < 1000)
+        return "0s";
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return s + "s";
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return m + "m" + (s % 60 > 0 ? (s % 60) + "s" : "");
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return h + "h" + (m % 60 > 0 ? (m % 60) + "m" : "");
+    const d = Math.floor(h / 24);
+    return d + "d" + (h % 24 > 0 ? (h % 24) + "h" : "");
+}
+export function calcCpuPercent(prevUsec, prevTs, currUsec, currTs) {
+    const dtMs = currTs - prevTs;
+    if (dtMs <= 0)
+        return null;
+    const dtUs = currUsec - prevUsec;
+    return (dtUs / 1000 / dtMs) * 100;
+}
+//# sourceMappingURL=top-format.js.map

package/dist/utils/watch.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Poll `GET /v1/apps/{id}` until the app reaches a terminal
+ * deploy state: Ready=True + Progressing=False (success), or
+ * Degraded=True reason=DeployTimeout (the daemon's own
+ * progressing_timeout has flipped — surfaces here as
+ * deploy_stuck per DESIGN-self-host-state.md §"progressing_timeout
+ * uses monotonic clock"), or the client-side watch budget runs
+ * out.
+ *
+ * This is the consumer of #10's observedGeneration / conditions
+ * machinery and #8a's status.conditions[] surface. The whole
+ * point of those server-side primitives is exactly THIS loop:
+ * a watcher polling GET, inspecting conditions[], deciding
+ * "still progressing vs converged vs stuck" without needing a
+ * separate event stream.
+ *
+ * `watchDeploy` is pure (modulo fetch + setTimeout) — the
+ * test harness drives it through synthetic state transitions
+ * by sequencing mock responses.
+ */
+import type { CreekdClient, AppEnvelope } from "./creekd-client.js";
+/** Terminal outcome of a watch loop. */
+export type WatchResult = {
+    ok: true;
+    reason: "ready";
+    envelope: AppEnvelope;
+} | {
+    ok: false;
+    reason: "deploy_stuck";
+    envelope: AppEnvelope;
+} | {
+    ok: false;
+    reason: "watch_timeout";
+    elapsedMs: number;
+    lastEnvelope?: AppEnvelope;
+} | {
+    ok: false;
+    reason: "fetch_failed";
+    error: Error;
+};
+export interface WatchOptions {
+    /** Milliseconds between polls. Default 1000. Clamped to >=100. */
+    pollIntervalMs?: number;
+    /**
+     * Maximum total wall time the watch will hang before returning
+     * watch_timeout. Default 5 min. Independent of the daemon's
+     * progressing_timeout — the client's bound is "user's patience"
+     * not "server's deploy budget"; the two normally agree.
+     */
+    timeoutMs?: number;
+    /**
+     * Injected clock + sleep for tests. Production callers omit; the
+     * defaults are Date.now + setTimeout-based delay.
+     */
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    /**
+     * Optional progress callback invoked after each poll. Tests use
+     * this to assert intermediate state; production callers can
+     * stream it to a spinner.
+     */
+    onPoll?: (envelope: AppEnvelope, elapsedMs: number) => void;
+}
+export declare function watchDeploy(client: CreekdClient, appId: string, opts?: WatchOptions): Promise<WatchResult>;
+type Verdict = "ready" | "deploy_stuck" | "progressing" | "unknown";
+/**
+ * Inspect a single envelope's status.conditions[] and decide
+ * whether the watch loop is done.
+ *
+ *   Ready=True AND Progressing=False     → ready (success)
+ *   Degraded=True AND reason=DeployTimeout → deploy_stuck (DESIGN code)
+ *   Progressing=True (any reason)         → progressing (keep polling)
+ *   anything else                         → unknown (keep polling — server
+ *                                                    hasn't classified yet)
+ *
+ * Exported for unit-test visibility; not part of the consumer
+ * API.
+ */
+export declare function classifyConditions(envelope: AppEnvelope): Verdict;
+export {};
+//# sourceMappingURL=watch.d.ts.map

package/dist/utils/watch.js

@@ -0,0 +1,87 @@
+/**
+ * Poll `GET /v1/apps/{id}` until the app reaches a terminal
+ * deploy state: Ready=True + Progressing=False (success), or
+ * Degraded=True reason=DeployTimeout (the daemon's own
+ * progressing_timeout has flipped — surfaces here as
+ * deploy_stuck per DESIGN-self-host-state.md §"progressing_timeout
+ * uses monotonic clock"), or the client-side watch budget runs
+ * out.
+ *
+ * This is the consumer of #10's observedGeneration / conditions
+ * machinery and #8a's status.conditions[] surface. The whole
+ * point of those server-side primitives is exactly THIS loop:
+ * a watcher polling GET, inspecting conditions[], deciding
+ * "still progressing vs converged vs stuck" without needing a
+ * separate event stream.
+ *
+ * `watchDeploy` is pure (modulo fetch + setTimeout) — the
+ * test harness drives it through synthetic state transitions
+ * by sequencing mock responses.
+ */
+const DEFAULT_POLL_MS = 1000;
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const MIN_POLL_MS = 100;
+export async function watchDeploy(client, appId, opts = {}) {
+    const pollMs = Math.max(MIN_POLL_MS, opts.pollIntervalMs ?? DEFAULT_POLL_MS);
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const now = opts.now ?? Date.now;
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const start = now();
+    let lastEnvelope;
+    while (true) {
+        const elapsedMs = now() - start;
+        if (elapsedMs > timeoutMs) {
+            return { ok: false, reason: "watch_timeout", elapsedMs, lastEnvelope };
+        }
+        let envelope;
+        try {
+            envelope = await client.getApp(appId);
+        }
+        catch (e) {
+            return { ok: false, reason: "fetch_failed", error: e instanceof Error ? e : new Error(String(e)) };
+        }
+        lastEnvelope = envelope;
+        opts.onPoll?.(envelope, elapsedMs);
+        const verdict = classifyConditions(envelope);
+        if (verdict === "ready")
+            return { ok: true, reason: "ready", envelope };
+        if (verdict === "deploy_stuck")
+            return { ok: false, reason: "deploy_stuck", envelope };
+        // "progressing" or "unknown" → keep polling.
+        await sleep(pollMs);
+    }
+}
+/**
+ * Inspect a single envelope's status.conditions[] and decide
+ * whether the watch loop is done.
+ *
+ *   Ready=True AND Progressing=False     → ready (success)
+ *   Degraded=True AND reason=DeployTimeout → deploy_stuck (DESIGN code)
+ *   Progressing=True (any reason)         → progressing (keep polling)
+ *   anything else                         → unknown (keep polling — server
+ *                                                    hasn't classified yet)
+ *
+ * Exported for unit-test visibility; not part of the consumer
+ * API.
+ */
+export function classifyConditions(envelope) {
+    const conds = envelope.status?.conditions ?? [];
+    const ready = conds.find((c) => c.type === "Ready");
+    const progressing = conds.find((c) => c.type === "Progressing");
+    const degraded = conds.find((c) => c.type === "Degraded");
+    // deploy_stuck has highest priority — even if Ready=True somehow,
+    // a DeployTimeout-flagged Degraded means the daemon gave up on
+    // this generation's convergence and the client should report
+    // failure rather than racing the wire.
+    if (degraded?.status === "True" && degraded.reason === "DeployTimeout") {
+        return "deploy_stuck";
+    }
+    if (ready?.status === "True" && progressing?.status === "False") {
+        return "ready";
+    }
+    if (progressing?.status === "True") {
+        return "progressing";
+    }
+    return "unknown";
+}
+//# sourceMappingURL=watch.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.20",
+  "version": "0.4.22",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,7 +33,7 @@
     "esbuild": "^0.25.0",
     "smol-toml": "^1.3.1",
     "ws": "^8.20.0",
-    "@solcreek/sdk": "0.4.9"
+    "@solcreek/sdk": "0.4.10"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",