@solcreek/cli 0.3.0

package/dist/commands/deployments.d.ts

@@ -0,0 +1,18 @@
+export declare const deploymentsCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    project: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=deployments.d.ts.map

package/dist/commands/deployments.js

@@ -0,0 +1,84 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseConfig } from "@solcreek/sdk";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
+export const deploymentsCommand = defineCommand({
+    meta: {
+        name: "deployments",
+        description: "List recent deployments for the current project",
+    },
+    args: {
+        project: {
+            type: "string",
+            description: "Project slug (default: from creek.toml)",
+            required: false,
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const token = getToken();
+        if (!token) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_authenticated" }, 1);
+            consola.error("Not authenticated. Run `creek login` first.");
+            process.exit(1);
+        }
+        // Resolve project slug
+        let slug = args.project;
+        if (!slug) {
+            const configPath = join(process.cwd(), "creek.toml");
+            if (!existsSync(configPath)) {
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "no_project", message: "No creek.toml found. Use --project <slug> or run from a project directory." }, 1);
+                consola.error("No creek.toml found. Use --project <slug> or run from a project directory.");
+                process.exit(1);
+            }
+            slug = parseConfig(readFileSync(configPath, "utf-8")).project.name;
+        }
+        const client = new CreekClient(getApiUrl(), token);
+        let deployments;
+        try {
+            deployments = await client.listDeployments(slug);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to list deployments";
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+            consola.error(msg);
+            process.exit(1);
+        }
+        if (jsonMode) {
+            jsonOutput({ ok: true, project: slug, deployments });
+        }
+        if (deployments.length === 0) {
+            consola.info(`No deployments for ${slug}. Run \`creek deploy\` to create one.`);
+            return;
+        }
+        consola.info(`${deployments.length} deployment(s) for ${slug}\n`);
+        for (const d of deployments) {
+            const status = d.status === "active" ? "\x1b[32mactive\x1b[0m" : d.status;
+            const branch = d.branch ? ` (${d.branch})` : "";
+            const age = timeAgo(d.created_at);
+            consola.log(`  ${d.id.slice(0, 8)}  ${status}  ${age}${branch}`);
+        }
+    },
+});
+function timeAgo(dateStr) {
+    const diff = Date.now() - new Date(dateStr).getTime();
+    const mins = Math.floor(diff / 60_000);
+    if (mins < 1)
+        return "just now";
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+//# sourceMappingURL=deployments.js.map

package/dist/commands/domains.d.ts

@@ -0,0 +1,2 @@
+export declare const domainsCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=domains.d.ts.map

package/dist/commands/domains.js

@@ -0,0 +1,159 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient, parseConfig } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
+function getProjectSlug(args) {
+    if (args?.project)
+        return args.project;
+    const configPath = join(process.cwd(), "creek.toml");
+    if (!existsSync(configPath)) {
+        consola.error("No creek.toml found. Use --project <slug> or run from a project directory.");
+        process.exit(1);
+    }
+    return parseConfig(readFileSync(configPath, "utf-8")).project.name;
+}
+const projectArg = {
+    project: { type: "string", description: "Project slug (default: from creek.toml)" },
+};
+function getClient() {
+    const token = getToken();
+    if (!token) {
+        consola.error("Not authenticated. Run `creek login` first.");
+        process.exit(1);
+    }
+    return new CreekClient(getApiUrl(), token);
+}
+const domainsLs = defineCommand({
+    meta: { name: "ls", description: "List custom domains" },
+    args: {
+        ...projectArg,
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = getClient();
+        const slug = getProjectSlug(args);
+        const domains = await client.listDomains(slug);
+        if (jsonMode) {
+            jsonOutput({ ok: true, project: slug, domains });
+            return;
+        }
+        if (domains.length === 0) {
+            consola.info("No custom domains configured.");
+            return;
+        }
+        for (const d of domains) {
+            const statusIcon = d.status === "active" ? "\x1b[32m●\x1b[0m" :
+                d.status === "pending" ? "\x1b[33m○\x1b[0m" :
+                    d.status === "failed" ? "\x1b[31m✕\x1b[0m" : "○";
+            consola.log(`  ${statusIcon} ${d.hostname}  ${d.status}  (${d.id.slice(0, 8)})`);
+        }
+    },
+});
+const domainsAdd = defineCommand({
+    meta: { name: "add", description: "Add a custom domain" },
+    args: {
+        hostname: { type: "positional", description: "Domain to add (e.g., app.example.com)", required: true },
+        ...projectArg,
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = getClient();
+        const slug = getProjectSlug(args);
+        const result = await client.addDomain(slug, args.hostname);
+        const { domain, verification } = result;
+        if (jsonMode) {
+            jsonOutput({ ok: true, project: slug, domain, verification });
+            return;
+        }
+        if (domain.status === "active") {
+            consola.success(`Added ${domain.hostname} (active — SSL provisioned)`);
+            return;
+        }
+        consola.success(`Added ${domain.hostname} (status: ${domain.status})`);
+        consola.info("");
+        consola.info("  Point your DNS to Creek:");
+        consola.info(`    CNAME  ${domain.hostname}  →  cname.creek.dev`);
+        if (verification?.txt) {
+            consola.info("");
+            consola.info("  Or verify ownership first with a TXT record:");
+            consola.info(`    TXT  ${verification.txt.name}  →  ${verification.txt.value}`);
+        }
+        consola.info("");
+        consola.info("  Creek will automatically verify and provision SSL.");
+        consola.info(`  Run \`creek domains ls --project ${slug}\` to check status.`);
+    },
+});
+const domainsRm = defineCommand({
+    meta: { name: "rm", description: "Remove a custom domain" },
+    args: {
+        hostname: { type: "positional", description: "Domain to remove", required: true },
+        ...projectArg,
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = getClient();
+        const slug = getProjectSlug(args);
+        // Resolve hostname to domain ID
+        const domains = await client.listDomains(slug);
+        const domain = domains.find((d) => d.hostname === args.hostname.toLowerCase());
+        if (!domain) {
+            consola.error(`Domain "${args.hostname}" not found.`);
+            process.exit(1);
+        }
+        await client.deleteDomain(slug, domain.id);
+        if (jsonMode) {
+            jsonOutput({ ok: true, hostname: domain.hostname, removed: true, project: slug });
+            return;
+        }
+        consola.success(`Removed ${domain.hostname}`);
+    },
+});
+const domainsActivate = defineCommand({
+    meta: { name: "activate", description: "Activate a pending custom domain" },
+    args: {
+        hostname: { type: "positional", description: "Domain to activate", required: true },
+        ...projectArg,
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = getClient();
+        const slug = getProjectSlug(args);
+        // Resolve hostname to domain ID
+        const domains = await client.listDomains(slug);
+        const domain = domains.find((d) => d.hostname === args.hostname.toLowerCase());
+        if (!domain) {
+            consola.error(`Domain "${args.hostname}" not found.`);
+            process.exit(1);
+        }
+        if (domain.status === "active") {
+            consola.info(`${domain.hostname} is already active.`);
+            return;
+        }
+        await client.activateDomain(slug, domain.id);
+        if (jsonMode) {
+            jsonOutput({ ok: true, hostname: domain.hostname, status: "active", project: slug });
+            return;
+        }
+        consola.success(`Activated ${domain.hostname}`);
+    },
+});
+export const domainsCommand = defineCommand({
+    meta: {
+        name: "domains",
+        description: "Manage custom domains",
+    },
+    subCommands: {
+        ls: domainsLs,
+        add: domainsAdd,
+        rm: domainsRm,
+        activate: domainsActivate,
+    },
+});
+//# sourceMappingURL=domains.js.map

package/dist/commands/env.d.ts

@@ -0,0 +1,2 @@
+export declare const envCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=env.d.ts.map

package/dist/commands/env.js

@@ -0,0 +1,104 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient, parseConfig } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
+function getProjectSlug() {
+    const configPath = join(process.cwd(), "creek.toml");
+    if (!existsSync(configPath)) {
+        consola.error("No creek.toml found. Run `creek init` first.");
+        process.exit(1);
+    }
+    return parseConfig(readFileSync(configPath, "utf-8")).project.name;
+}
+function getClient() {
+    const token = getToken();
+    if (!token) {
+        consola.error("Not authenticated. Run `creek login` first.");
+        process.exit(1);
+    }
+    return new CreekClient(getApiUrl(), token);
+}
+const envSet = defineCommand({
+    meta: { name: "set", description: "Set an environment variable" },
+    args: {
+        key: { type: "positional", description: "Variable name (e.g. DATABASE_URL)", required: true },
+        value: { type: "positional", description: "Variable value", required: true },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = getClient();
+        const slug = getProjectSlug();
+        await client.setEnvVar(slug, args.key, args.value);
+        if (jsonMode)
+            jsonOutput({ ok: true, key: args.key, project: slug });
+        consola.success(`Set ${args.key}`);
+    },
+});
+function redact(value) {
+    if (value.length <= 4)
+        return "••••";
+    return value.slice(0, 2) + "•".repeat(Math.min(value.length - 4, 20)) + value.slice(-2);
+}
+const envGet = defineCommand({
+    meta: { name: "ls", description: "List environment variables" },
+    args: {
+        show: { type: "boolean", description: "Show values in plaintext (default: redacted)", default: false },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = getClient();
+        const slug = getProjectSlug();
+        const vars = await client.listEnvVars(slug);
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                project: slug,
+                vars: vars.map((v) => ({ key: v.key, value: args.show ? v.value : redact(v.value) })),
+            });
+        }
+        if (vars.length === 0) {
+            consola.info("No environment variables set.");
+            return;
+        }
+        for (const v of vars) {
+            const displayed = args.show ? v.value : redact(v.value);
+            consola.log(`  ${v.key} = ${displayed}`);
+        }
+        if (!args.show) {
+            consola.info("  (use --show to reveal values)");
+        }
+    },
+});
+const envRm = defineCommand({
+    meta: { name: "rm", description: "Remove an environment variable" },
+    args: {
+        key: { type: "positional", description: "Variable name to remove", required: true },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = getClient();
+        const slug = getProjectSlug();
+        await client.deleteEnvVar(slug, args.key);
+        if (jsonMode)
+            jsonOutput({ ok: true, key: args.key, removed: true, project: slug });
+        consola.success(`Removed ${args.key}`);
+    },
+});
+export const envCommand = defineCommand({
+    meta: {
+        name: "env",
+        description: "Manage environment variables",
+    },
+    subCommands: {
+        set: envSet,
+        ls: envGet,
+        rm: envRm,
+    },
+});
+//# sourceMappingURL=env.js.map

package/dist/commands/init.d.ts

@@ -0,0 +1,18 @@
+export declare const initCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    name: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -0,0 +1,69 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import { stringify } from "smol-toml";
+import { detectFramework } from "@solcreek/sdk";
+import { globalArgs, resolveJsonMode, jsonOutput, shouldAutoConfirm } from "../utils/output.js";
+export const initCommand = defineCommand({
+    meta: {
+        name: "init",
+        description: "Initialize a new Creek project",
+    },
+    args: {
+        name: {
+            type: "string",
+            description: "Project name",
+            required: false,
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const cwd = process.cwd();
+        const configPath = join(cwd, "creek.toml");
+        if (existsSync(configPath)) {
+            if (!shouldAutoConfirm(args)) {
+                consola.warn("creek.toml already exists");
+                const overwrite = await consola.prompt("Overwrite?", { type: "confirm" });
+                if (!overwrite)
+                    return;
+            }
+        }
+        // Detect framework
+        const pkgPath = join(cwd, "package.json");
+        let framework;
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const detected = detectFramework(pkg);
+            if (detected) {
+                framework = detected;
+                if (!jsonMode)
+                    consola.info(`Detected framework: ${framework}`);
+            }
+        }
+        const defaultName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+        const name = args.name ?? defaultName;
+        const config = {
+            project: {
+                name,
+                ...(framework ? { framework } : {}),
+            },
+            build: {
+                command: "npm run build",
+                output: "dist",
+            },
+            resources: {
+                d1: false,
+                kv: false,
+                r2: false,
+            },
+        };
+        writeFileSync(configPath, stringify(config));
+        if (jsonMode) {
+            jsonOutput({ ok: true, name, framework: framework ?? null, path: configPath });
+        }
+        consola.success(`Created creek.toml for "${name}"`);
+    },
+});
+//# sourceMappingURL=init.js.map

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,120 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { execFileSync } from "node:child_process";
+import { CreekClient } from "@solcreek/sdk";
+import { writeCliConfig, readCliConfig, getApiUrl } from "../utils/config.js";
+import { startAuthServer } from "../utils/auth-server.js";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
+function getDashboardUrl() {
+    const apiUrl = getApiUrl();
+    // http://localhost:8787 → http://localhost:3000
+    // https://api.creek.dev → https://app.creek.dev
+    return apiUrl
+        .replace("api.", "app.")
+        .replace(":8787", ":3000");
+}
+function openBrowser(url) {
+    try {
+        const cmd = process.platform === "darwin"
+            ? "open"
+            : process.platform === "win32"
+                ? "start"
+                : "xdg-open";
+        execFileSync(cmd, [url], { stdio: "ignore" });
+    }
+    catch {
+        // Browser open failed — user will need to copy the URL manually
+    }
+}
+export const loginCommand = defineCommand({
+    meta: {
+        name: "login",
+        description: "Authenticate with Creek",
+    },
+    args: {
+        token: {
+            type: "string",
+            description: "API key (for CI/CD, skips interactive prompt)",
+            required: false,
+        },
+        headless: {
+            type: "boolean",
+            description: "Use headless mode (paste API key manually, for SSH/remote)",
+            default: false,
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        // Mode 1: --token (CI/CD)
+        if (args.token) {
+            return await saveAndVerify(args.token, jsonMode);
+        }
+        // Mode 2: --headless (SSH/remote — prompt for API key)
+        if (args.headless) {
+            return await headlessLogin();
+        }
+        // Mode 3: Default — localhost redirect (best UX)
+        return await browserLogin();
+    },
+});
+/**
+ * Default login: open browser → dashboard creates API key → redirect to localhost callback.
+ */
+async function browserLogin() {
+    const { port, state, waitForCallback, close } = startAuthServer();
+    const dashboardUrl = getDashboardUrl();
+    const authUrl = `${dashboardUrl}/cli-auth?port=${port}&state=${state}`;
+    consola.info("Opening browser to authenticate...");
+    consola.info(`If the browser doesn't open, visit: ${authUrl}`);
+    consola.info("");
+    openBrowser(authUrl);
+    consola.start("Waiting for authentication...");
+    try {
+        const key = await waitForCallback();
+        await saveAndVerify(key);
+    }
+    catch (err) {
+        close();
+        consola.error(err instanceof Error ? err.message : "Authentication failed");
+        consola.info("Try `creek login --headless` if browser login isn't working.");
+        process.exit(1);
+    }
+}
+/**
+ * Headless login: prompt user to paste API key from dashboard.
+ */
+async function headlessLogin() {
+    const dashboardUrl = getDashboardUrl();
+    consola.info("Create an API key in the Creek dashboard:");
+    consola.info(`  ${dashboardUrl}/api-keys`);
+    consola.info("");
+    const apiKey = await consola.prompt("Paste your API key:", { type: "text" });
+    if (!apiKey || typeof apiKey !== "string") {
+        consola.error("No API key provided");
+        process.exit(1);
+    }
+    await saveAndVerify(apiKey.trim());
+}
+/**
+ * Validate key against API, save to config, print success.
+ */
+async function saveAndVerify(apiKey, jsonMode = false) {
+    if (!jsonMode)
+        consola.start("Verifying...");
+    const client = new CreekClient(getApiUrl(), apiKey);
+    const session = await client.getSession();
+    if (!session?.user) {
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "invalid_token", message: "Invalid API key" }, 1);
+        consola.error("Invalid API key. Please check and try again.");
+        process.exit(1);
+    }
+    const config = readCliConfig();
+    writeCliConfig({ ...config, token: apiKey });
+    if (jsonMode) {
+        jsonOutput({ ok: true, user: session.user.name, email: session.user.email });
+    }
+    consola.success(`Logged in as ${session.user.name} (${session.user.email})`);
+}
+//# sourceMappingURL=login.js.map

package/dist/commands/projects.d.ts

@@ -0,0 +1,13 @@
+export declare const projectsCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+}>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/commands/projects.js

@@ -0,0 +1,38 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
+export const projectsCommand = defineCommand({
+    meta: {
+        name: "projects",
+        description: "List all projects",
+    },
+    args: { ...globalArgs },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const token = getToken();
+        if (!token) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_authenticated" }, 1);
+            consola.error("Not authenticated. Run `creek login` first.");
+            process.exit(1);
+        }
+        const client = new CreekClient(getApiUrl(), token);
+        const projects = await client.listProjects();
+        if (jsonMode) {
+            jsonOutput({ ok: true, projects });
+        }
+        if (projects.length === 0) {
+            consola.info("No projects yet. Deploy one with `creek deploy`.");
+            return;
+        }
+        consola.info(`${projects.length} project(s)\n`);
+        for (const p of projects) {
+            const framework = p.framework ? ` (${p.framework})` : "";
+            const deployed = p.production_deployment_id ? "deployed" : "not deployed";
+            consola.log(`  ${p.slug}${framework} — ${deployed}`);
+        }
+    },
+});
+//# sourceMappingURL=projects.js.map

package/dist/commands/status.d.ts

@@ -0,0 +1,18 @@
+export declare const statusCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    id: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=status.d.ts.map