@barekey/cli 0.3.3 → 0.5.0

package/dist/commands/env.js

@@ -1,77 +1,136 @@
 import { writeFile } from "node:fs/promises";
-import { cancel, confirm, isCancel } from "@clack/prompts";
-import { BarekeyClient } from "@barekey/sdk/server";
-import pc from "picocolors";
+import { cancel, confirm, isCancel, select, text } from "@clack/prompts";
 import { createCliAuthProvider } from "../auth-provider.js";
 import { addTargetOptions, dotenvEscape, parseChance, requireLocalSession, resolveTarget, toJsonOutput, } from "../command-utils.js";
+import { EnvEvaluateBatchResponseSchema, EnvEvaluateResponseSchema, EnvListResponseSchema, EnvPullResponseSchema, EnvWriteResponseSchema, } from "../contracts/index.js";
 import { postJson } from "../http.js";
 import { collectOptionValues, parseRolloutFunction, parseRolloutMilestones, parseVisibility, } from "./env-helpers.js";
-function createEnvClient(input) {
-    const organization = input.organization?.trim();
-    if (!organization) {
-        throw new Error("Organization slug is required.");
+async function resolveEnvAccess(options) {
+    const local = await requireLocalSession();
+    const target = await resolveTarget(options, local);
+    const authProvider = createCliAuthProvider();
+    const accessToken = await authProvider.getAccessToken();
+    return {
+        local,
+        target,
+        accessToken,
+    };
+}
+function renderScalar(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+async function promptForRequiredText(currentValue, message) {
+    const existing = currentValue?.trim();
+    if (existing && existing.length > 0) {
+        return existing;
     }
-    return new BarekeyClient({
-        organization,
-        project: input.project,
-        environment: input.environment,
+    if (!process.stdout.isTTY) {
+        throw new Error(`${message} is required in non-interactive mode.`);
+    }
+    const prompted = await text({
+        message,
+        validate(value) {
+            return value.trim().length > 0 ? undefined : "This value is required.";
+        },
     });
+    if (isCancel(prompted)) {
+        cancel("Command canceled.");
+        process.exit(0);
+    }
+    return prompted.trim();
 }
-async function runEnvGet(name, options) {
-    const local = await requireLocalSession();
-    const target = await resolveTarget(options, local);
-    const client = createEnvClient({
-        organization: target.orgSlug ?? local.credentials.orgSlug,
-        project: target.projectSlug,
-        environment: target.stageSlug,
+async function maybePromptVariant(writeOptions) {
+    if (writeOptions.ab !== undefined || writeOptions.rollout !== undefined || !process.stdout.isTTY) {
+        return writeOptions;
+    }
+    const selectedKind = await select({
+        message: "What kind of variable is this?",
+        options: [
+            { value: "secret", label: "Secret", hint: "One stored value" },
+            { value: "ab_roll", label: "A/B roll", hint: "Two values plus traffic split" },
+            { value: "rollout", label: "Rollout", hint: "Two values plus rollout milestones" },
+        ],
+        initialValue: "secret",
     });
-    const value = await client.get(name, {
-        seed: options.seed,
-        key: options.key,
+    if (isCancel(selectedKind)) {
+        cancel("Command canceled.");
+        process.exit(0);
+    }
+    if (selectedKind === "ab_roll") {
+        const valueB = await promptForRequiredText(undefined, "What's the alternate value?");
+        const chance = await promptForRequiredText(writeOptions.chance, "What's the A-branch probability between 0 and 1?");
+        return {
+            ...writeOptions,
+            ab: valueB,
+            chance,
+        };
+    }
+    if (selectedKind === "rollout") {
+        const valueB = await promptForRequiredText(undefined, "What's the rollout value B?");
+        return {
+            ...writeOptions,
+            rollout: valueB,
+        };
+    }
+    return writeOptions;
+}
+async function runEnvGet(name, options) {
+    const resolvedName = await promptForRequiredText(name, "What's the name of this variable?");
+    const { local, target, accessToken } = await resolveEnvAccess(options);
+    const value = await postJson({
+        baseUrl: local.baseUrl,
+        path: "/v1/env/evaluate",
+        accessToken,
+        payload: {
+            orgSlug: target.orgSlug,
+            projectSlug: target.projectSlug,
+            stageSlug: target.stageSlug,
+            name: resolvedName,
+            seed: options.seed,
+            key: options.key,
+        },
+        schema: EnvEvaluateResponseSchema,
     });
     if (options.json) {
-        toJsonOutput(true, {
-            name,
-            value,
-        });
+        toJsonOutput(true, value);
         return;
     }
-    console.log(String(value));
+    console.log(renderScalar(value.value));
 }
 async function runEnvGetMany(options) {
-    const local = await requireLocalSession();
-    const target = await resolveTarget(options, local);
-    const client = createEnvClient({
-        organization: target.orgSlug ?? local.credentials.orgSlug,
-        project: target.projectSlug,
-        environment: target.stageSlug,
-    });
-    const names = options.names
+    const namesCsv = await promptForRequiredText(options.names, "Which variable names do you want, comma-separated?");
+    const { local, target, accessToken } = await resolveEnvAccess(options);
+    const names = namesCsv
         .split(",")
         .map((value) => value.trim())
         .filter((value) => value.length > 0);
-    const resolved = await Promise.all(names.map(async (resolvedName) => ({
-        name: resolvedName,
-        value: await client.get(resolvedName, {
+    const response = await postJson({
+        baseUrl: local.baseUrl,
+        path: "/v1/env/evaluate-batch",
+        accessToken,
+        payload: {
+            orgSlug: target.orgSlug,
+            projectSlug: target.projectSlug,
+            stageSlug: target.stageSlug,
+            names,
             seed: options.seed,
             key: options.key,
-        }),
-    })));
+        },
+        schema: EnvEvaluateBatchResponseSchema,
+    });
     if (options.json) {
-        toJsonOutput(true, resolved);
+        toJsonOutput(true, response.values);
         return;
     }
-    for (const value of resolved.sort((left, right) => left.name.localeCompare(right.name))) {
-        if (value) {
-            console.log(`${value.name}=${String(value.value)}`);
-        }
+    for (const value of [...response.values].sort((left, right) => left.name.localeCompare(right.name))) {
+        console.log(`${value.name}=${renderScalar(value.value)}`);
     }
 }
 async function runEnvList(options) {
-    const local = await requireLocalSession();
-    const target = await resolveTarget(options, local);
-    const authProvider = createCliAuthProvider();
-    const accessToken = await authProvider.getAccessToken();
+    const { local, target, accessToken } = await resolveEnvAccess(options);
     const response = await postJson({
         baseUrl: local.baseUrl,
         path: "/v1/env/list",
@@ -81,6 +140,7 @@ async function runEnvList(options) {
             projectSlug: target.projectSlug,
             stageSlug: target.stageSlug,
         },
+        schema: EnvListResponseSchema,
     });
     if (options.json) {
         toJsonOutput(true, response.variables);
@@ -93,56 +153,57 @@ async function runEnvList(options) {
     for (const row of response.variables) {
         const chanceSuffix = row.kind === "ab_roll" ? ` chance=${row.chance ?? 0}` : "";
         const rolloutSuffix = row.kind === "rollout"
-            ? ` ${pc.dim(`${row.rolloutFunction ?? "linear"}(${row.rolloutMilestones?.length ?? 0} milestones)`)}`
+            ? ` ${row.rolloutFunction ?? "linear"}(${row.rolloutMilestones?.length ?? 0} milestones)`
             : "";
-        console.log(`${row.name}  ${pc.dim(row.visibility)}  ${pc.dim(row.kind)}  ${pc.dim(row.declaredType)}${chanceSuffix}${rolloutSuffix}`);
+        console.log(`${row.name}  ${row.visibility}  ${row.kind}  ${row.declaredType}${chanceSuffix}${rolloutSuffix}`);
     }
 }
 async function runEnvWrite(operation, name, value, options) {
-    const local = await requireLocalSession();
-    const target = await resolveTarget(options, local);
-    const authProvider = createCliAuthProvider();
-    const accessToken = await authProvider.getAccessToken();
-    if (options.ab !== undefined && options.rollout !== undefined) {
+    const resolvedName = await promptForRequiredText(name, "What's the name of this variable?");
+    const resolvedValue = await promptForRequiredText(value, "What's the value of this variable?");
+    const resolvedOptions = await maybePromptVariant(options);
+    const { local, target, accessToken } = await resolveEnvAccess(resolvedOptions);
+    if (resolvedOptions.ab !== undefined && resolvedOptions.rollout !== undefined) {
         throw new Error("Use either --ab or --rollout, not both.");
     }
-    const hasRolloutPoints = (options.point?.length ?? 0) > 0;
-    if (options.rollout === undefined && (options.function !== undefined || hasRolloutPoints)) {
+    const hasRolloutPoints = (resolvedOptions.point?.length ?? 0) > 0;
+    if (resolvedOptions.rollout === undefined &&
+        (resolvedOptions.function !== undefined || hasRolloutPoints)) {
         throw new Error("--function and --point can only be used together with --rollout.");
     }
-    if (options.ab !== undefined && (options.function !== undefined || hasRolloutPoints)) {
+    if (resolvedOptions.ab !== undefined && (resolvedOptions.function !== undefined || hasRolloutPoints)) {
         throw new Error("--function and --point are only supported for --rollout, not --ab.");
     }
-    if (options.rollout !== undefined && options.chance !== undefined) {
+    if (resolvedOptions.rollout !== undefined && resolvedOptions.chance !== undefined) {
         throw new Error("--chance only applies to --ab.");
     }
-    const entry = options.rollout !== undefined
+    const entry = resolvedOptions.rollout !== undefined
         ? {
-            name,
-            visibility: parseVisibility(options.visibility),
+            name: resolvedName,
+            visibility: parseVisibility(resolvedOptions.visibility),
             kind: "rollout",
-            declaredType: options.type ?? "string",
-            valueA: value,
-            valueB: options.rollout,
-            rolloutFunction: parseRolloutFunction(options.function),
-            rolloutMilestones: parseRolloutMilestones(options.point),
+            declaredType: resolvedOptions.type ?? "string",
+            valueA: resolvedValue,
+            valueB: resolvedOptions.rollout,
+            rolloutFunction: parseRolloutFunction(resolvedOptions.function),
+            rolloutMilestones: parseRolloutMilestones(resolvedOptions.point),
         }
-        : options.ab !== undefined
+        : resolvedOptions.ab !== undefined
             ? {
-                name,
-                visibility: parseVisibility(options.visibility),
+                name: resolvedName,
+                visibility: parseVisibility(resolvedOptions.visibility),
                 kind: "ab_roll",
-                declaredType: options.type ?? "string",
-                valueA: value,
-                valueB: options.ab,
-                chance: parseChance(options.chance),
+                declaredType: resolvedOptions.type ?? "string",
+                valueA: resolvedValue,
+                valueB: resolvedOptions.ab,
+                chance: parseChance(resolvedOptions.chance),
             }
             : {
-                name,
-                visibility: parseVisibility(options.visibility),
+                name: resolvedName,
+                visibility: parseVisibility(resolvedOptions.visibility),
                 kind: "secret",
-                declaredType: options.type ?? "string",
-                value,
+                declaredType: resolvedOptions.type ?? "string",
+                value: resolvedValue,
             };
     const result = await postJson({
         baseUrl: local.baseUrl,
@@ -156,18 +217,17 @@ async function runEnvWrite(operation, name, value, options) {
             entries: [entry],
             deletes: [],
         },
+        schema: EnvWriteResponseSchema,
     });
-    if (options.json) {
+    if (resolvedOptions.json) {
         toJsonOutput(true, result);
         return;
     }
     console.log(`Created: ${result.createdCount}, Updated: ${result.updatedCount}, Deleted: ${result.deletedCount}`);
 }
 async function runEnvDelete(name, options) {
-    const local = await requireLocalSession();
-    const target = await resolveTarget(options, local);
-    const authProvider = createCliAuthProvider();
-    const accessToken = await authProvider.getAccessToken();
+    const resolvedName = await promptForRequiredText(name, "What's the name of the variable to delete?");
+    const { local, target, accessToken } = await resolveEnvAccess(options);
     if (!options.ignoreMissing) {
         const listed = await postJson({
             baseUrl: local.baseUrl,
@@ -178,10 +238,11 @@ async function runEnvDelete(name, options) {
                 projectSlug: target.projectSlug,
                 stageSlug: target.stageSlug,
             },
+            schema: EnvListResponseSchema,
         });
-        const exists = listed.variables.some((row) => row.name === name);
+        const exists = listed.variables.some((row) => row.name === resolvedName);
         if (!exists) {
-            throw new Error(`Variable ${name} was not found in this stage.`);
+            throw new Error(`Variable ${resolvedName} was not found in this stage.`);
         }
     }
     if (!options.yes) {
@@ -189,7 +250,7 @@ async function runEnvDelete(name, options) {
             throw new Error("Deletion requires --yes in non-interactive mode.");
         }
         const confirmed = await confirm({
-            message: `Delete variable ${name}?`,
+            message: `Delete variable ${resolvedName}?`,
             initialValue: false,
         });
         if (isCancel(confirmed)) {
@@ -210,8 +271,9 @@ async function runEnvDelete(name, options) {
             stageSlug: target.stageSlug,
             mode: "upsert",
             entries: [],
-            deletes: [name],
+            deletes: [resolvedName],
         },
+        schema: EnvWriteResponseSchema,
     });
     if (options.json) {
         toJsonOutput(true, result);
@@ -220,10 +282,7 @@ async function runEnvDelete(name, options) {
     console.log(`Deleted: ${result.deletedCount}`);
 }
 async function runEnvPull(options) {
-    const local = await requireLocalSession();
-    const target = await resolveTarget(options, local);
-    const authProvider = createCliAuthProvider();
-    const accessToken = await authProvider.getAccessToken();
+    const { local, target, accessToken } = await resolveEnvAccess(options);
     const response = await postJson({
         baseUrl: local.baseUrl,
         path: "/v1/env/pull",
@@ -235,6 +294,7 @@ async function runEnvPull(options) {
             seed: options.seed,
             key: options.key,
         },
+        schema: EnvPullResponseSchema,
     });
     const format = options.format ?? "dotenv";
     const sortedKeys = Object.keys(response.byName).sort((left, right) => left.localeCompare(right));
@@ -257,7 +317,7 @@ export function registerEnvCommands(program) {
     addTargetOptions(env
         .command("get")
         .description("Evaluate one variable")
-        .argument("<name>", "Variable name")
+        .argument("[name]", "Variable name")
         .option("--seed <value>", "Deterministic seed")
         .option("--key <value>", "Deterministic key")
         .option("--json", "Machine-readable output", false)).action(async (name, options) => {
@@ -266,7 +326,7 @@ export function registerEnvCommands(program) {
     addTargetOptions(env
         .command("get-many")
         .description("Evaluate a batch of variables")
-        .requiredOption("--names <csv>", "Comma-separated variable names")
+        .option("--names <csv>", "Comma-separated variable names")
         .option("--seed <value>", "Deterministic seed")
         .option("--key <value>", "Deterministic key")
         .option("--json", "Machine-readable output", false)).action(async (options) => {
@@ -281,8 +341,8 @@ export function registerEnvCommands(program) {
     addTargetOptions(env
         .command("new")
         .description("Create one variable")
-        .argument("<name>", "Variable name")
-        .argument("<value>", "Variable value")
+        .argument("[name]", "Variable name")
+        .argument("[value]", "Variable value")
         .option("--ab <value-b>", "Second value for ab_roll")
         .option("--rollout <value-b>", "Second value for rollout")
         .option("--chance <number>", "A-branch probability between 0 and 1")
@@ -296,8 +356,8 @@ export function registerEnvCommands(program) {
     addTargetOptions(env
         .command("set")
         .description("Upsert one variable")
-        .argument("<name>", "Variable name")
-        .argument("<value>", "Variable value")
+        .argument("[name]", "Variable name")
+        .argument("[value]", "Variable value")
         .option("--ab <value-b>", "Second value for ab_roll")
         .option("--rollout <value-b>", "Second value for rollout")
         .option("--chance <number>", "A-branch probability between 0 and 1")
@@ -311,7 +371,7 @@ export function registerEnvCommands(program) {
     addTargetOptions(env
         .command("delete")
         .description("Delete one variable")
-        .argument("<name>", "Variable name")
+        .argument("[name]", "Variable name")
         .option("--yes", "Skip confirmation", false)
         .option("--ignore-missing", "Do not fail when variable is missing", false)
         .option("--json", "Machine-readable output", false)).action(async (name, options) => {

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerInitCommand(program: Command): void;

package/dist/commands/init.js

@@ -0,0 +1,32 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promptForOrganizationSlug, promptForProjectSlug, promptForStageSlug, } from "./target-prompts.js";
+async function runInit(options) {
+    const orgSlug = await promptForOrganizationSlug(options.org);
+    const projectSlug = await promptForProjectSlug(orgSlug, options.project);
+    const stageSlug = await promptForStageSlug(orgSlug, projectSlug, options.stage);
+    const configPath = path.resolve(options.path?.trim() || "barekey.json");
+    const contents = `${JSON.stringify({
+        organization: orgSlug,
+        project: projectSlug,
+        environment: stageSlug,
+        config: {
+            mode: "centralized",
+            typegen: "semantic",
+        },
+    }, null, 2)}\n`;
+    await writeFile(configPath, contents, "utf8");
+    console.log(`Wrote ${configPath}`);
+}
+export function registerInitCommand(program) {
+    program
+        .command("init")
+        .description("Create or update barekey.json for the current repo")
+        .option("--org <slug>", "Organization slug")
+        .option("--project <slug>", "Project slug")
+        .option("--stage <slug>", "Stage slug")
+        .option("--path <path>", "Config path", "barekey.json")
+        .action(async (options) => {
+        await runInit(options);
+    });
+}

package/dist/commands/org.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerOrgCommands(program: Command): void;

package/dist/commands/org.js

@@ -0,0 +1,85 @@
+import { text, isCancel, cancel } from "@clack/prompts";
+import { createCliAuthProvider } from "../auth-provider.js";
+import { requireLocalSession, toJsonOutput } from "../command-utils.js";
+import { OrganizationsResponseSchema } from "../contracts/index.js";
+import { getJson, postJson } from "../http.js";
+async function promptForName(name) {
+    const existing = name?.trim();
+    if (existing && existing.length > 0) {
+        return existing;
+    }
+    if (!process.stdout.isTTY) {
+        throw new Error("Organization name is required in non-interactive mode.");
+    }
+    const prompted = await text({
+        message: "What’s the name of this organization?",
+        validate: (value) => (value.trim().length > 0 ? undefined : "Name is required."),
+    });
+    if (isCancel(prompted)) {
+        cancel("Command canceled.");
+        process.exit(0);
+    }
+    return prompted.trim();
+}
+async function runOrgList(options) {
+    const local = await requireLocalSession();
+    const authProvider = createCliAuthProvider();
+    const accessToken = await authProvider.getAccessToken();
+    const response = await getJson({
+        baseUrl: local.baseUrl,
+        path: "/v1/cli/orgs",
+        accessToken,
+        schema: OrganizationsResponseSchema,
+    });
+    if (options.json) {
+        toJsonOutput(true, response.organizations);
+        return;
+    }
+    if (response.organizations.length === 0) {
+        console.log("No organizations found.");
+        return;
+    }
+    for (const organization of response.organizations) {
+        console.log(`${organization.name} (${organization.slug}) ${organization.role}`);
+    }
+}
+async function runOrgCreate(name, options) {
+    const resolvedName = await promptForName(name);
+    const local = await requireLocalSession();
+    const authProvider = createCliAuthProvider();
+    const accessToken = await authProvider.getAccessToken();
+    const response = await postJson({
+        baseUrl: local.baseUrl,
+        path: "/v1/cli/orgs/create",
+        accessToken,
+        payload: {
+            name: resolvedName,
+            slug: options.slug?.trim() || null,
+        },
+    });
+    if (options.json) {
+        toJsonOutput(true, response);
+        return;
+    }
+    const organization = response.organization;
+    console.log(`Created organization ${organization.name} (${organization.slug}).`);
+}
+export function registerOrgCommands(program) {
+    const org = program.command("org").description("Organization management");
+    org
+        .command("list")
+        .description("List organizations available to the current user")
+        .option("--json", "Machine-readable output", false)
+        .action(async (options) => {
+        await runOrgList(options);
+    });
+    org
+        .command("create")
+        .description("Create an organization")
+        .argument("[name]", "Organization name")
+        .option("--slug <slug>", "Organization slug")
+        .option("--json", "Machine-readable output", false)
+        .action(async (name, options) => {
+        await runOrgCreate(name, options);
+    });
+}

package/dist/commands/project.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerProjectCommands(program: Command): void;

package/dist/commands/project.js

@@ -0,0 +1,99 @@
+import { cancel, confirm, isCancel, text } from "@clack/prompts";
+import { toJsonOutput } from "../command-utils.js";
+import { createProjectForOrganization, deleteProjectForOrganization, listProjectsForOrganization, promptForOrganizationSlug, promptForProjectSlug, } from "./target-prompts.js";
+async function promptForProjectName(name) {
+    const existing = name?.trim();
+    if (existing && existing.length > 0) {
+        return existing;
+    }
+    if (!process.stdout.isTTY) {
+        throw new Error("Project name is required in non-interactive mode.");
+    }
+    const prompted = await text({
+        message: "What’s the name of this project?",
+        validate: (value) => (value.trim().length > 0 ? undefined : "Project name is required."),
+    });
+    if (isCancel(prompted)) {
+        cancel("Command canceled.");
+        process.exit(0);
+    }
+    return prompted.trim();
+}
+async function runProjectList(options) {
+    const orgSlug = await promptForOrganizationSlug(options.org);
+    const projects = await listProjectsForOrganization(orgSlug);
+    if (options.json) {
+        toJsonOutput(true, projects);
+        return;
+    }
+    if (projects.length === 0) {
+        console.log("No projects found.");
+        return;
+    }
+    for (const project of projects) {
+        console.log(`${project.name} (${project.slug}) secrets=${project.secretCount}`);
+    }
+}
+async function runProjectCreate(name, options) {
+    const orgSlug = await promptForOrganizationSlug(options.org);
+    const projectName = await promptForProjectName(name);
+    const project = await createProjectForOrganization(orgSlug, projectName);
+    if (options.json) {
+        toJsonOutput(true, project);
+        return;
+    }
+    console.log(`Created project ${project.name} (${project.slug}).`);
+}
+export function registerProjectCommands(program) {
+    const project = program.command("project").description("Project management");
+    project
+        .command("list")
+        .description("List projects in an organization")
+        .option("--org <slug>", "Organization slug")
+        .option("--json", "Machine-readable output", false)
+        .action(async (options) => {
+        await runProjectList(options);
+    });
+    project
+        .command("create")
+        .description("Create a project")
+        .argument("[name]", "Project name")
+        .option("--org <slug>", "Organization slug")
+        .option("--json", "Machine-readable output", false)
+        .action(async (name, options) => {
+        await runProjectCreate(name, options);
+    });
+    project
+        .command("delete")
+        .description("Delete a project")
+        .argument("[slug]", "Project slug")
+        .option("--org <slug>", "Organization slug")
+        .option("--yes", "Skip confirmation prompt", false)
+        .option("--json", "Machine-readable output", false)
+        .action(async (slug, options) => {
+        const orgSlug = await promptForOrganizationSlug(options.org);
+        const projectSlug = await promptForProjectSlug(orgSlug, slug);
+        if (!options.yes) {
+            if (!process.stdout.isTTY) {
+                throw new Error("Project deletion requires --yes in non-interactive mode.");
+            }
+            const confirmed = await confirm({
+                message: `Delete project ${projectSlug}?`,
+                initialValue: false,
+            });
+            if (isCancel(confirmed)) {
+                cancel("Command canceled.");
+                process.exit(0);
+            }
+            if (!confirmed) {
+                throw new Error("Delete canceled.");
+            }
+        }
+        const response = await deleteProjectForOrganization(orgSlug, projectSlug);
+        if (options.json) {
+            toJsonOutput(true, response);
+            return;
+        }
+        console.log(`Deleted project ${response.deletedProjectSlug}.`);
+    });
+}

package/dist/commands/stage.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerStageCommands(program: Command): void;