creek 0.3.0 → 0.3.2

package/dist/commands/deployments.d.ts

@@ -1,18 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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/env.d.ts

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

package/dist/commands/env.js

@@ -1,104 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

package/dist/commands/status.js

@@ -1,115 +0,0 @@
-import { defineCommand } from "citty";
-import consola from "consola";
-import { CreekClient } from "@solcreek/sdk";
-import { getToken, getApiUrl, getSandboxApiUrl } 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 statusCommand = defineCommand({
-    meta: {
-        name: "status",
-        description: "Check deployment or sandbox status",
-    },
-    args: {
-        id: {
-            type: "positional",
-            description: "Sandbox ID (optional — defaults to current project)",
-            required: false,
-        },
-        ...globalArgs,
-    },
-    async run({ args }) {
-        const jsonMode = resolveJsonMode(args);
-        // If an ID is provided, check sandbox status (no auth needed)
-        if (args.id) {
-            return await sandboxStatus(args.id, jsonMode);
-        }
-        // Otherwise, check current project status (needs auth + creek.toml)
-        return await projectStatus(jsonMode);
-    },
-});
-async function sandboxStatus(sandboxId, jsonMode) {
-    const sandboxApiUrl = getSandboxApiUrl();
-    const res = await fetch(`${sandboxApiUrl}/api/sandbox/${sandboxId}/status`);
-    if (!res.ok) {
-        if (jsonMode)
-            jsonOutput({ ok: false, error: "not_found", message: "Sandbox not found" }, 1);
-        consola.error("Sandbox not found. It may have expired.");
-        process.exit(1);
-    }
-    const status = await res.json();
-    if (jsonMode) {
-        jsonOutput({ ok: true, type: "sandbox", ...status });
-    }
-    const s = status.status;
-    const statusColor = s === "active" ? `\x1b[32m${s}\x1b[0m`
-        : s === "failed" ? `\x1b[31m${s}\x1b[0m`
-            : s === "expired" ? `\x1b[33m${s}\x1b[0m`
-                : s;
-    consola.log(`\n  Sandbox ${status.sandboxId}`);
-    consola.log(`  Status:   ${statusColor}`);
-    consola.log(`  URL:      ${status.previewUrl}`);
-    if (status.deployDurationMs) {
-        consola.log(`  Duration: ${(status.deployDurationMs / 1000).toFixed(1)}s`);
-    }
-    if (s === "active") {
-        consola.log(`  Expires:  ${status.expiresInSeconds}s remaining`);
-        if (status.claimable) {
-            consola.log(`  Claim:    creek claim ${status.sandboxId}`);
-        }
-    }
-    if (status.failedStep) {
-        consola.log(`  Failed:   ${status.failedStep} — ${status.errorMessage}`);
-    }
-    consola.log("");
-}
-async function projectStatus(jsonMode) {
-    const token = getToken();
-    if (!token) {
-        if (jsonMode)
-            jsonOutput({ ok: false, error: "not_authenticated" }, 1);
-        consola.error("Not authenticated. Run `creek login` first.");
-        consola.info("To check a sandbox: creek status <sandboxId>");
-        process.exit(1);
-    }
-    const configPath = join(process.cwd(), "creek.toml");
-    if (!existsSync(configPath)) {
-        if (jsonMode)
-            jsonOutput({ ok: false, error: "no_project", message: "No creek.toml found" }, 1);
-        consola.error("No creek.toml found.");
-        consola.info("To check a sandbox: creek status <sandboxId>");
-        process.exit(1);
-    }
-    const config = parseConfig(readFileSync(configPath, "utf-8"));
-    const client = new CreekClient(getApiUrl(), token);
-    let project;
-    try {
-        project = await client.getProject(config.project.name);
-    }
-    catch {
-        if (jsonMode)
-            jsonOutput({ ok: false, error: "not_found", message: `Project "${config.project.name}" not found` }, 1);
-        consola.error(`Project "${config.project.name}" not found.`);
-        process.exit(1);
-    }
-    if (jsonMode) {
-        jsonOutput({
-            ok: true,
-            type: "project",
-            project: project.slug,
-            framework: project.framework,
-            productionDeploymentId: project.production_deployment_id,
-            createdAt: project.created_at,
-        });
-    }
-    const deployed = project.production_deployment_id ? "deployed" : "not deployed";
-    const framework = project.framework ? ` (${project.framework})` : "";
-    consola.log(`\n  Project ${project.slug}${framework}`);
-    consola.log(`  Status:  ${deployed}`);
-    if (project.production_deployment_id) {
-        consola.log(`  Deploy:  ${project.production_deployment_id.slice(0, 8)}`);
-    }
-    consola.log("");
-}
-//# sourceMappingURL=status.js.map

package/dist/commands/whoami.d.ts

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