@solcreek/cli 0.4.21 → 0.4.22

package/dist/commands/stop.js

@@ -0,0 +1,65 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { globalArgs, resolveJsonMode, jsonOutput, shouldAutoConfirm } from "../utils/output.js";
+import { CreekdClient, CreekdApiError, getCreekdUrl } from "../utils/creekd-client.js";
+export const stopCommand = defineCommand({
+    meta: {
+        name: "stop",
+        description: "Stop an app on a creekd instance",
+    },
+    args: {
+        id: {
+            type: "positional",
+            description: "App ID to stop",
+            required: true,
+        },
+        server: {
+            type: "string",
+            description: "creekd admin API URL (or $CREEKD_URL)",
+        },
+        token: {
+            type: "string",
+            description: "Bearer token (or $CREEKD_TOKEN)",
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = new CreekdClient(args.server || getCreekdUrl(), args.token || process.env.CREEKD_TOKEN || process.env.CREEKCTL_TOKEN || "");
+        const id = args.id;
+        if (!shouldAutoConfirm(args) && !jsonMode) {
+            const readline = await import("node:readline/promises");
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await rl.question(`Stop app "${id}"? [y/N] `);
+            rl.close();
+            if (answer.toLowerCase() !== "y") {
+                consola.info("Aborted.");
+                return;
+            }
+        }
+        try {
+            await client.stopApp(id);
+            if (jsonMode) {
+                jsonOutput({ ok: true, stopped: id }, 0, [
+                    { command: `creek top`, description: "Live process overview" },
+                ]);
+            }
+            consola.success(`Stopped ${id}`);
+        }
+        catch (err) {
+            if (err instanceof CreekdApiError) {
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: err.code, message: err.message }, 1);
+                if (err.status === 404) {
+                    consola.error(`App "${id}" not found.`);
+                }
+                else {
+                    consola.error(`Stop failed: ${err.message}`);
+                }
+                process.exit(1);
+            }
+            throw err;
+        }
+    },
+});
+//# sourceMappingURL=stop.js.map

package/dist/commands/top.d.ts

@@ -0,0 +1,28 @@
+export declare const topCommand: import("citty").CommandDef<{
+    server: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+    token: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+    interval: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+}>;
+//# sourceMappingURL=top.d.ts.map

package/dist/commands/top.js

@@ -0,0 +1,171 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { globalArgs, resolveJsonMode, jsonOutput, isTTY } from "../utils/output.js";
+import { CreekdClient, CreekdApiError, getCreekdUrl, } from "../utils/creekd-client.js";
+import { fmtBytes, fmtDuration, calcCpuPercent } from "../utils/top-format.js";
+export const topCommand = defineCommand({
+    meta: {
+        name: "top",
+        description: "Live view of apps on a creekd instance",
+    },
+    args: {
+        ...globalArgs,
+        server: {
+            type: "string",
+            description: "creekd admin API URL (or $CREEKD_URL)",
+            required: false,
+        },
+        token: {
+            type: "string",
+            description: "Bearer token (or $CREEKD_TOKEN)",
+            required: false,
+        },
+        interval: {
+            type: "string",
+            description: "Refresh interval in seconds (default 2)",
+            default: "2",
+        },
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = new CreekdClient(args.server || getCreekdUrl(), args.token || process.env.CREEKD_TOKEN || process.env.CREEKCTL_TOKEN || "");
+        const intervalMs = Math.max(500, parseFloat(args.interval || "2") * 1000);
+        if (jsonMode) {
+            const snapshot = await collectSnapshot(client);
+            jsonOutput({ ok: true, ...snapshot }, 0, [
+                { command: "creek top --json", description: "Refresh snapshot" },
+                { command: "creek logs <app-id>", description: "Stream app logs" },
+            ]);
+        }
+        await liveTop(client, intervalMs);
+    },
+});
+let prevCpu = new Map();
+async function collectSnapshot(client) {
+    const apps = await client.listApps();
+    const now = Date.now();
+    const rows = [];
+    const statsResults = await Promise.allSettled(apps.map((app) => client.getStats(app.id)));
+    for (let i = 0; i < apps.length; i++) {
+        const app = apps[i];
+        const stats = statsResults[i].status === "fulfilled"
+            ? statsResults[i].value
+            : null;
+        let cpuStr = "—";
+        if (stats?.cgroup_enabled && stats.cpu_usage_usec != null) {
+            const prev = prevCpu.get(app.id);
+            if (prev) {
+                const pct = calcCpuPercent(prev.usec, prev.ts, stats.cpu_usage_usec, now);
+                if (pct !== null)
+                    cpuStr = pct.toFixed(1) + "%";
+            }
+            prevCpu.set(app.id, { usec: stats.cpu_usage_usec, ts: now });
+        }
+        rows.push({
+            id: app.id,
+            status: app.status,
+            cpu: cpuStr,
+            mem: stats?.memory_current_bytes != null ? fmtBytes(stats.memory_current_bytes) : "—",
+            memLimit: stats?.memory_max_bytes != null && stats.memory_max_bytes > 0
+                ? fmtBytes(stats.memory_max_bytes)
+                : "—",
+            pids: stats?.pids_current != null ? String(stats.pids_current) : "—",
+            restarts: app.restart_count,
+            uptime: fmtDuration(app.uptime_ms),
+        });
+    }
+    const running = apps.filter((a) => a.status === "running").length;
+    const crashed = apps.filter((a) => a.status === "crash_loop").length;
+    return {
+        apps: rows,
+        summary: { total: apps.length, running, crashed },
+        timestamp: new Date().toISOString(),
+    };
+}
+async function liveTop(client, intervalMs) {
+    const url = client instanceof CreekdClient
+        ? getCreekdUrl()
+        : "creekd";
+    let first = true;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            const snap = await collectSnapshot(client);
+            if (isTTY)
+                process.stdout.write("\x1b[2J\x1b[H");
+            render(snap, url);
+            first = false;
+        }
+        catch (err) {
+            if (first) {
+                if (err instanceof CreekdApiError && err.status === 401) {
+                    consola.error("Authentication failed. Set CREEKD_TOKEN or use --token.");
+                }
+                else {
+                    consola.error(`Cannot reach creekd at ${url}`);
+                    consola.info("Is creekd running? Check with: systemctl status creekd");
+                }
+                process.exit(1);
+            }
+            if (isTTY)
+                process.stdout.write("\x1b[2J\x1b[H");
+            consola.warn(`Refresh failed: ${err.message}`);
+        }
+        await sleep(intervalMs);
+    }
+}
+function render(snap, url) {
+    const { apps, summary } = snap;
+    const dim = "\x1b[2m";
+    const reset = "\x1b[0m";
+    const bold = "\x1b[1m";
+    const green = "\x1b[32m";
+    const red = "\x1b[31m";
+    const yellow = "\x1b[33m";
+    const header = `${bold}creek top${reset}${dim} — ${url}${reset}  ` +
+        `${summary.total} apps, ${green}${summary.running} running${reset}` +
+        (summary.crashed > 0 ? `, ${red}${summary.crashed} crashed${reset}` : "");
+    process.stdout.write(header + "\n\n");
+    if (apps.length === 0) {
+        process.stdout.write(`${dim}  No apps running.${reset}\n`);
+        return;
+    }
+    const cols = ["APP", "STATUS", "CPU", "MEM", "LIMIT", "PIDS", "RESTARTS", "UPTIME"];
+    const widths = cols.map((c, i) => {
+        const dataMax = Math.max(...apps.map((r) => String(cellValue(r, i)).length), 0);
+        return Math.max(c.length, dataMax);
+    });
+    const headerLine = cols.map((c, i) => c.padEnd(widths[i])).join("  ");
+    process.stdout.write(`${dim}  ${headerLine}${reset}\n`);
+    for (const row of apps) {
+        const statusColor = row.status === "running" ? green
+            : row.status === "crash_loop" ? red
+                : row.status === "starting" ? yellow
+                    : dim;
+        const cells = cols.map((_, i) => {
+            const val = String(cellValue(row, i));
+            if (i === 1)
+                return `${statusColor}${val.padEnd(widths[i])}${reset}`;
+            return val.padEnd(widths[i]);
+        });
+        process.stdout.write("  " + cells.join("  ") + "\n");
+    }
+    process.stdout.write(`\n${dim}  Refreshing every ${snap._intervalS || 2}s — Ctrl+C to quit${reset}\n`);
+}
+function cellValue(row, col) {
+    switch (col) {
+        case 0: return row.id;
+        case 1: return row.status;
+        case 2: return row.cpu;
+        case 3: return row.mem;
+        case 4: return row.memLimit;
+        case 5: return row.pids;
+        case 6: return row.restarts;
+        case 7: return row.uptime;
+        default: return "";
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=top.js.map

package/dist/dev/creekd-runner.d.ts

@@ -0,0 +1,22 @@
+import type { ResolvedConfig } from "@solcreek/sdk";
+export interface CreekdDevServerOptions {
+    cwd: string;
+    port: number;
+    config: ResolvedConfig;
+    reset: boolean;
+}
+export declare class CreekdDevServer {
+    private options;
+    private sandboxProcess;
+    constructor(options: CreekdDevServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private requireCreekd;
+    private ensureSandbox;
+    private buildEnvVars;
+    private detectDevCommand;
+    /** For compatibility with DevServer interface */
+    triggerScheduled(): Promise<void>;
+    sendQueueMessage(_payload: unknown): Promise<void>;
+}
+//# sourceMappingURL=creekd-runner.d.ts.map

package/dist/dev/creekd-runner.js

@@ -0,0 +1,188 @@
+// CreekdDevServer for `creek dev --target creekd`.
+//
+// Orchestrates `creekd sandbox` (Go binary) instead of Miniflare.
+// Real Postgres, Redis, SeaweedFS run inside a Lima VM.
+// The app process runs inside the VM with env vars injected.
+//
+// Requirements:
+//   - `creekd` binary in PATH
+//   - Lima (`limactl`) for macOS/Linux sandbox VM
+import { execSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { consola } from "consola";
+export class CreekdDevServer {
+    options;
+    sandboxProcess = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        const { cwd, port, config, reset } = this.options;
+        const startTime = Date.now();
+        // 1. Check creekd is installed
+        this.requireCreekd();
+        // 2. Start sandbox (provisions Lima VM + primitives from creek.toml)
+        consola.info("Starting creekd sandbox...");
+        const status = await this.ensureSandbox(cwd);
+        // 3. Build env var map from sandbox primitives
+        const env = this.buildEnvVars(config, status, port);
+        // 4. Load .env.local if present
+        const envLocalPath = join(cwd, ".env.local");
+        if (existsSync(envLocalPath)) {
+            const { readFileSync } = await import("node:fs");
+            const lines = readFileSync(envLocalPath, "utf-8").split("\n");
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith("#"))
+                    continue;
+                const eqIdx = trimmed.indexOf("=");
+                if (eqIdx > 0) {
+                    const key = trimmed.slice(0, eqIdx);
+                    const val = trimmed.slice(eqIdx + 1).replace(/^["']|["']$/g, "");
+                    if (!env[key])
+                        env[key] = val;
+                }
+            }
+            consola.info(`.env.local loaded`);
+        }
+        // 5. Detect runtime and dev command
+        const devCmd = this.detectDevCommand(cwd, config);
+        // 6. Print status
+        const elapsed = Date.now() - startTime;
+        console.log("");
+        consola.success("⬡ creek dev (creekd sandbox)\n");
+        consola.info(`App:        http://localhost:${port}`);
+        for (const p of status.ports) {
+            if (p.name !== "app") {
+                consola.info(`${p.name.padEnd(12)}localhost:${p.host}`);
+            }
+        }
+        console.log("");
+        for (const [k, v] of Object.entries(env)) {
+            if (k.startsWith("DATABASE") || k.startsWith("REDIS") || k.startsWith("S3_") || k.startsWith("SMTP")) {
+                const masked = v.replace(/:[^:@]+@/, ":***@");
+                consola.info(`  ${k}=${masked}`);
+            }
+        }
+        console.log("");
+        consola.info(`Running: ${devCmd.join(" ")}`);
+        consola.info(`Ready in ${elapsed}ms`);
+        console.log("");
+        // 7. Start the dev server process with env vars
+        this.sandboxProcess = spawn(devCmd[0], devCmd.slice(1), {
+            cwd,
+            env: { ...process.env, ...env },
+            stdio: "inherit",
+        });
+        this.sandboxProcess.on("exit", (code) => {
+            if (code !== null && code !== 0) {
+                consola.error(`Dev server exited with code ${code}`);
+            }
+        });
+    }
+    async stop() {
+        if (this.sandboxProcess) {
+            this.sandboxProcess.kill("SIGTERM");
+            this.sandboxProcess = null;
+        }
+        // Don't stop the sandbox VM — it persists for fast restarts
+    }
+    // --- Internals ---
+    requireCreekd() {
+        try {
+            execSync("creekd --version", { stdio: "pipe" });
+        }
+        catch {
+            throw new Error([
+                "creekd is not installed.",
+                "",
+                "  Install with: curl -fsSL https://install.creek.dev | sh",
+                "",
+                "  Or use --target cf to develop with Miniflare (CF Workers local).",
+            ].join("\n"));
+        }
+    }
+    async ensureSandbox(cwd) {
+        try {
+            const output = execSync(`creekd sandbox --non-interactive --json "${cwd}"`, { encoding: "utf-8", timeout: 300_000 });
+            // Find the JSON line in output (creekd may print logs before JSON)
+            const lines = output.trim().split("\n");
+            for (let i = lines.length - 1; i >= 0; i--) {
+                try {
+                    return JSON.parse(lines[i]);
+                }
+                catch {
+                    continue;
+                }
+            }
+            throw new Error("No JSON status from creekd sandbox");
+        }
+        catch (e) {
+            if (e.message?.includes("not installed"))
+                throw e;
+            throw new Error(`creekd sandbox failed: ${e.message}`);
+        }
+    }
+    buildEnvVars(config, status, port) {
+        const env = {
+            PORT: String(port),
+        };
+        // Map sandbox ports to standard env vars
+        for (const p of status.ports) {
+            switch (p.name) {
+                case "postgres":
+                    env.DATABASE_URL = `postgresql://creek:creek_sandbox@127.0.0.1:${p.host}/app`;
+                    break;
+                case "mysql":
+                    env.DATABASE_URL = `mysql://creek:creek_sandbox@127.0.0.1:${p.host}/app`;
+                    break;
+                case "redis":
+                    env.REDIS_URL = `redis://127.0.0.1:${p.host}/0`;
+                    break;
+                case "s3":
+                    env.S3_ENDPOINT = `http://127.0.0.1:${p.host}`;
+                    env.S3_BUCKET = config.projectName;
+                    env.AWS_ACCESS_KEY_ID = "creek";
+                    env.AWS_SECRET_ACCESS_KEY = "creek_sandbox";
+                    break;
+                case "smtp":
+                    env.SMTP_URL = `smtp://127.0.0.1:${p.host}`;
+                    break;
+            }
+        }
+        // SQLite fallback for database if no postgres/mysql port
+        if (!env.DATABASE_URL) {
+            const dbDir = join(this.options.cwd, ".creek", "dev");
+            env.DATABASE_URL = `sqlite://${dbDir}/dev.db`;
+        }
+        return env;
+    }
+    detectDevCommand(cwd, config) {
+        // Check package.json for dev script
+        const pkgPath = join(cwd, "package.json");
+        if (existsSync(pkgPath)) {
+            const { readFileSync } = require("node:fs");
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (pkg.scripts?.dev) {
+                return ["npm", "run", "dev"];
+            }
+        }
+        // Fallback to bun --watch or node --watch
+        const entryFiles = ["src/index.ts", "src/index.mjs", "src/index.js", "index.ts", "index.mjs", "index.js"];
+        for (const entry of entryFiles) {
+            if (existsSync(join(cwd, entry))) {
+                return ["bun", "--watch", entry];
+            }
+        }
+        return ["bun", "--watch", "."];
+    }
+    /** For compatibility with DevServer interface */
+    async triggerScheduled() {
+        consola.warn("Scheduled triggers not yet supported in creekd dev mode");
+    }
+    async sendQueueMessage(_payload) {
+        consola.warn("Queue messages not yet supported in creekd dev mode");
+    }
+}
+//# sourceMappingURL=creekd-runner.js.map

package/dist/index.js

@@ -24,6 +24,10 @@ import { doctorCommand } from "./commands/doctor.js";
 import { dbCommand } from "./commands/db.js";
 import { storageCommand } from "./commands/storage.js";
 import { cacheCommand } from "./commands/cache.js";
+import { topCommand } from "./commands/top.js";
+import { restartCommand } from "./commands/restart.js";
+import { stopCommand } from "./commands/stop.js";
+import { dashboardCommand } from "./commands/dashboard.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const cliPkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
 // Read version from the "creek" facade package (what users install),
@@ -63,6 +67,10 @@ const main = defineCommand({
         cache: cacheCommand,
         domains: domainsCommand,
         rollback: rollbackCommand,
+        top: topCommand,
+        dashboard: dashboardCommand,
+        restart: restartCommand,
+        stop: stopCommand,
         ops: opsCommand,
     },
 });

package/dist/utils/creekd-client.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Lightweight creekd admin API client for the CLI.
+ *
+ * Uses plain fetch (no openapi-fetch dep) with types matching
+ * the OpenAPI spec. The CLI only needs a handful of endpoints.
+ */
+export interface AppView {
+    id: string;
+    runtime?: string;
+    command: string;
+    args?: string[];
+    env?: string[];
+    port: number;
+    status: "starting" | "running" | "crash_loop" | "stopping" | "stopped";
+    pid: number;
+    uptime_ms: number;
+    restart_count: number;
+    health_failures: number;
+    net_ip?: string;
+}
+export interface StatsView {
+    id: string;
+    cgroup_enabled: boolean;
+    memory_current_bytes?: number;
+    memory_max_bytes?: number;
+    pids_current?: number;
+    cpu_usage_usec?: number;
+    oom_kills?: number;
+    read_err?: string;
+}
+export interface AppEnvelope {
+    apiVersion: string;
+    kind: string;
+    metadata: {
+        name: string;
+        uid: string;
+        generation: number;
+        resourceVersion: string;
+        creationTimestamp: string;
+    };
+    spec: {
+        runtime?: string;
+        command?: string;
+        args?: string[];
+        env?: string[];
+        port?: number;
+    };
+    status: {
+        observedGeneration: number;
+        conditions: Array<{
+            type: string;
+            status: string;
+            lastTransitionTime: string;
+            reason: string;
+            message?: string;
+        }>;
+        currentPid: number;
+        currentPort: number;
+        restartCount: number;
+        healthFailures: number;
+        uptimeMs: number;
+    };
+}
+export interface ListAppsResponse {
+    apps: AppView[];
+}
+/** Release ledger entry returned by POST /v1/apps/{id}/rollback. */
+export interface Release {
+    uid: string;
+    phase: "Active" | "Superseded" | "RolledBack";
+    creationTimestamp: string;
+    spec: {
+        appUid: string;
+        releaseSeq: number;
+        gitSha?: string;
+        image?: string;
+        envHash?: string;
+        createdBy?: string;
+        rolledBackFrom?: number;
+        originalArtifactRelease?: number;
+    };
+}
+export interface ErrorResponse {
+    code: string;
+    error: string;
+}
+export declare class CreekdApiError extends Error {
+    status: number;
+    code: string;
+    constructor(status: number, code: string);
+}
+/**
+ * Thrown specifically on 412 Precondition Failed (If-Match
+ * mismatch). Carries the daemon's CURRENT rv so the caller can
+ * decide between (a) prompting the user to refresh, (b) auto-
+ * retrying with the fresh rv when --bypass-rv was passed, or
+ * (c) emitting a structured machine-readable error to JSON mode.
+ *
+ * Per DESIGN-self-host-state.md §"First-party CLI MUST send
+ * If-Match": "On 412, CLI surfaces a structured prompt and does
+ * NOT auto-retry by default."
+ */
+export declare class CreekdResourceVersionMismatchError extends CreekdApiError {
+    currentResourceVersion: string;
+    attemptedResourceVersion: string;
+    constructor(currentResourceVersion: string, attemptedResourceVersion: string);
+}
+/** Options that apply to every mutating call. */
+export interface MutateOptions {
+    /**
+     * If-Match value to send as the precondition header. Daemon
+     * returns 412 → CreekdResourceVersionMismatchError if it doesn't
+     * match the daemon's current rv. Omit (or pass undefined) for
+     * unconditional writes; the daemon then attaches
+     * `Warning: 299 - "unconditional-write"` to the response.
+     */
+    ifMatch?: string;
+}
+export declare function getCreekdUrl(): string;
+export declare function getCreekdToken(): string;
+export declare class CreekdClient {
+    private token;
+    private baseUrl;
+    constructor(baseUrl?: string, token?: string);
+    listApps(): Promise<AppView[]>;
+    getApp(id: string): Promise<AppEnvelope>;
+    getStats(id: string): Promise<StatsView>;
+    getAppLogs(id: string, tail?: number): Promise<string>;
+    stopApp(id: string, opts?: MutateOptions): Promise<void>;
+    /**
+     * Spawn a brand-new app. POST /v1/apps. Creation is not
+     * spec-mutating in the rv sense — there's no prior version to
+     * If-Match against — so ifMatch is intentionally NOT a parameter.
+     */
+    spawnApp(body: unknown): Promise<AppView>;
+    /**
+     * Blue-green deploy of an existing app. POST /v1/apps/{id}/deploy.
+     * Spec-mutating; pass ifMatch sourced from the local cache (or a
+     * fresh getApp) — 412 surfaces as CreekdResourceVersionMismatchError.
+     */
+    deployApp(id: string, body: unknown, opts?: MutateOptions): Promise<AppView>;
+    restartApp(id: string): Promise<AppView>;
+    /**
+     * Roll back to the target release seq. Spec-mutating — accepts
+     * If-Match. Throws CreekdResourceVersionMismatchError on 412.
+     */
+    rollbackApp(id: string, toSeq: number, opts?: MutateOptions): Promise<Release>;
+    private get;
+    private post;
+    private request;
+}
+//# sourceMappingURL=creekd-client.d.ts.map