@solcreek/cli 0.4.19 → 0.4.21

package/dist/commands/login.js

@@ -62,7 +62,7 @@ export const loginCommand = defineCommand({
  * Default login: open browser → dashboard creates API key → redirect to localhost callback.
  */
 async function browserLogin() {
-    const { port, state, waitForCallback, close } = startAuthServer();
+    const { port, state, waitForCallback, close } = await startAuthServer();
     const dashboardUrl = getDashboardUrl();
     const authUrl = `${dashboardUrl}/cli-auth?port=${port}&state=${state}`;
     consola.info("Opening browser to authenticate...");

package/dist/commands/metrics.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `creek metrics` — read project traffic + error aggregates from the
+ * control-plane metrics endpoint (Analytics Engine + zone GraphQL).
+ *
+ * Auth: requires `creek login`. Server enforces tenant isolation from
+ * the session — the CLI passes only the project slug.
+ *
+ * Output shape matches the Dashboard Analytics tab: total requests
+ * (including edge-cache hits), worker invocations, error count, and
+ * three breakdowns (HTTP method, scriptType, statusBucket). Live p50/
+ * p99 CPU times aren't exposed here yet; they live in the Workers
+ * GraphQL subset the Dashboard reads separately.
+ *
+ * Pair with `--json` to pipe into reports / dashboards.
+ */
+export declare const metricsCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    project: {
+        type: "string";
+        description: string;
+    };
+    period: {
+        type: "string";
+        description: string;
+    };
+}>;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/commands/metrics.js

@@ -0,0 +1,167 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient, resolveConfig, ConfigNotFoundError, } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, NO_PROJECT_BREADCRUMBS, } from "../utils/output.js";
+const VALID_PERIODS = ["1h", "6h", "24h", "7d", "30d"];
+/**
+ * `creek metrics` — read project traffic + error aggregates from the
+ * control-plane metrics endpoint (Analytics Engine + zone GraphQL).
+ *
+ * Auth: requires `creek login`. Server enforces tenant isolation from
+ * the session — the CLI passes only the project slug.
+ *
+ * Output shape matches the Dashboard Analytics tab: total requests
+ * (including edge-cache hits), worker invocations, error count, and
+ * three breakdowns (HTTP method, scriptType, statusBucket). Live p50/
+ * p99 CPU times aren't exposed here yet; they live in the Workers
+ * GraphQL subset the Dashboard reads separately.
+ *
+ * Pair with `--json` to pipe into reports / dashboards.
+ */
+export const metricsCommand = defineCommand({
+    meta: {
+        name: "metrics",
+        description: "Read request + error metrics for a project. One-shot query — pair with --json for agent use or `| jq` piping.",
+    },
+    args: {
+        project: {
+            type: "string",
+            description: "Project slug. Defaults to creek.toml in cwd.",
+        },
+        period: {
+            type: "string",
+            description: `Time window. One of: ${VALID_PERIODS.join(", ")}. Default: 24h`,
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const token = getToken();
+        if (!token) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_authenticated" }, 1, AUTH_BREADCRUMBS);
+            consola.error("Not authenticated. Run `creek login` first.");
+            process.exit(1);
+        }
+        const projectSlug = await resolveProjectSlug(args.project, jsonMode);
+        const period = validatePeriod(args.period, jsonMode);
+        const client = new CreekClient(getApiUrl(), token);
+        let response;
+        try {
+            response = await client.getMetrics(projectSlug, period);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "metrics_failed", message: msg }, 1, []);
+            consola.error(`Failed to read metrics: ${msg}`);
+            process.exit(1);
+        }
+        if (jsonMode) {
+            jsonOutput({ ok: true, project: projectSlug, ...response }, 0, [
+                {
+                    command: `creek logs --project ${projectSlug} --since ${period}`,
+                    description: "Tail logs for the same window",
+                },
+            ]);
+            return;
+        }
+        printHuman(projectSlug, response);
+    },
+});
+function validatePeriod(raw, jsonMode) {
+    if (!raw)
+        return "24h";
+    if (VALID_PERIODS.includes(raw))
+        return raw;
+    const message = `Invalid --period: ${raw}. Valid: ${VALID_PERIODS.join(", ")}`;
+    if (jsonMode)
+        jsonOutput({ ok: false, error: "invalid_period", message }, 1, []);
+    consola.error(message);
+    process.exit(1);
+}
+async function resolveProjectSlug(override, jsonMode) {
+    if (override)
+        return override;
+    let resolved;
+    try {
+        resolved = resolveConfig(process.cwd());
+    }
+    catch (err) {
+        if (err instanceof ConfigNotFoundError) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "no_project", message: "No project config in cwd" }, 1, NO_PROJECT_BREADCRUMBS);
+            consola.error("No project config in cwd. Pass --project <slug>.");
+            process.exit(1);
+        }
+        throw err;
+    }
+    return resolved.projectName;
+}
+// ─── Human output ────────────────────────────────────────────────────────
+const COLOR = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+};
+function tty() {
+    return process.stdout.isTTY ?? false;
+}
+function c(s, color) {
+    return tty() ? `${COLOR[color]}${s}${COLOR.reset}` : s;
+}
+function fmtNumber(n) {
+    if (n === 0)
+        return "0";
+    if (n < 1000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return `${(n / 1_000_000).toFixed(2)}M`;
+}
+function fmtPct(n, total) {
+    if (total === 0)
+        return "0%";
+    return `${((n / total) * 100).toFixed(1)}%`;
+}
+function printHuman(slug, r) {
+    const { totals } = r;
+    const cachePct = fmtPct(totals.cachedReqs, totals.reqs);
+    const errPct = fmtPct(totals.errs, totals.invocations);
+    consola.log("");
+    consola.log(`  ${c("⬡ creek metrics", "bold")}  ${c(`${slug} · ${r.period}`, "dim")}`);
+    consola.log("");
+    consola.log(`  Requests:      ${c(fmtNumber(totals.reqs), "bold")}`);
+    consola.log(`  Cache hits:    ${fmtNumber(totals.cachedReqs)} ${c(`(${cachePct})`, "dim")}`);
+    consola.log(`  Invocations:   ${fmtNumber(totals.invocations)} ${c("worker ran", "dim")}`);
+    const errColor = totals.errs > 0 ? "red" : "green";
+    consola.log(`  Errors:        ${c(fmtNumber(totals.errs), errColor)} ${c(`(${errPct} of invocations)`, "dim")}`);
+    consola.log("");
+    printBreakdown("Method", r.breakdowns.method);
+    printBreakdown("Script type", r.breakdowns.scriptType);
+    printBreakdown("Status bucket", r.breakdowns.statusBucket);
+}
+function printBreakdown(title, rows) {
+    if (rows.length === 0)
+        return;
+    consola.log(`  ${c(title, "dim")}`);
+    const total = rows.reduce((sum, r) => sum + r.reqs, 0);
+    const top = rows.slice(0, 5);
+    for (const row of top) {
+        const pct = fmtPct(row.reqs, total);
+        const label = row.label || c("(empty)", "gray");
+        const errBadge = row.errs > 0 ? c(` ${row.errs} err`, "red") : "";
+        consola.log(`    ${label.padEnd(12)} ${fmtNumber(row.reqs).padStart(8)} ${c(pct.padStart(6), "dim")}${errBadge}`);
+    }
+    if (rows.length > top.length) {
+        consola.log(`    ${c(`+${rows.length - top.length} more`, "dim")}`);
+    }
+    consola.log("");
+}
+//# sourceMappingURL=metrics.js.map

package/dist/index.js

@@ -19,6 +19,7 @@ import { rollbackCommand } from "./commands/rollback.js";
 import { opsCommand } from "./commands/ops.js";
 import { queueCommand } from "./commands/queue.js";
 import { logsCommand } from "./commands/logs.js";
+import { metricsCommand } from "./commands/metrics.js";
 import { doctorCommand } from "./commands/doctor.js";
 import { dbCommand } from "./commands/db.js";
 import { storageCommand } from "./commands/storage.js";
@@ -49,6 +50,7 @@ const main = defineCommand({
         projects: projectsCommand,
         deployments: deploymentsCommand,
         logs: logsCommand,
+        metrics: metricsCommand,
         doctor: doctorCommand,
         login: loginCommand,
         whoami: whoamiCommand,

package/dist/utils/auth-server.d.ts

@@ -13,10 +13,10 @@ export interface AuthCallbackResult {
  * 4. This server receives the callback, validates state, resolves the promise
  * 5. Server auto-closes
  */
-export declare function startAuthServer(): {
+export declare function startAuthServer(): Promise<{
     port: number;
     state: string;
     waitForCallback: () => Promise<string>;
     close: () => void;
-};
+}>;
 //# sourceMappingURL=auth-server.d.ts.map

package/dist/utils/auth-server.js

@@ -11,7 +11,7 @@ import { randomBytes } from "node:crypto";
  * 4. This server receives the callback, validates state, resolves the promise
  * 5. Server auto-closes
  */
-export function startAuthServer() {
+export async function startAuthServer() {
     const state = randomBytes(16).toString("hex");
     let resolveCallback;
     let rejectCallback;
@@ -45,10 +45,23 @@ export function startAuthServer() {
         res.writeHead(404);
         res.end("Not found");
     });
-    // Listen on port 0 = OS picks a random available port
-    server.listen(0, "localhost");
+    // Listen on port 0 = OS picks a random available port.
+    // server.listen() is async — we MUST await the 'listening' event before
+    // reading server.address(), otherwise address() returns null and the
+    // callback URL ships ?port=0 to the dashboard (which correctly rejects
+    // with "Missing port or state parameter"). Regression seen in the wild
+    // on macOS — Node's behavior here is timing-dependent.
+    await new Promise((resolve, reject) => {
+        server.once("listening", () => resolve());
+        server.once("error", (err) => reject(err));
+        server.listen(0, "localhost");
+    });
     const address = server.address();
     const port = typeof address === "object" && address ? address.port : 0;
+    if (port === 0) {
+        server.close();
+        throw new Error("Could not determine local port for auth callback — server.address() returned null after listening.");
+    }
     // Timeout after 2 minutes
     const timeout = setTimeout(() => {
         rejectCallback(new Error("Login timed out after 2 minutes"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.19",
+  "version": "0.4.21",
   "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.8"
+    "@solcreek/sdk": "0.4.9"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",