@barekey/cli 0.4.0 → 0.5.1

package/src/commands/env.ts

@@ -1,10 +1,7 @@
 import { writeFile } from "node:fs/promises";
 
-import { cancel, confirm, isCancel } from "@clack/prompts";
-import { BarekeyClient } from "@barekey/sdk/server";
-import type { BarekeyJsonConfig } from "@barekey/sdk/server";
+import { cancel, confirm, isCancel, select, text } from "@clack/prompts";
 import { Command } from "commander";
-import pc from "picocolors";
 
 import { createCliAuthProvider } from "../auth-provider.js";
 import {
@@ -16,8 +13,14 @@ import {
   toJsonOutput,
   type EnvTargetOptions,
 } from "../command-utils.js";
+import {
+  EnvEvaluateBatchResponseSchema,
+  EnvEvaluateResponseSchema,
+  EnvListResponseSchema,
+  EnvPullResponseSchema,
+  EnvWriteResponseSchema,
+} from "../contracts/index.js";
 import { postJson } from "../http.js";
-import { loadRuntimeConfig } from "../runtime-config.js";
 import {
   collectOptionValues,
   parseRolloutFunction,
@@ -27,147 +30,184 @@ import {
   type CliVisibility,
 } from "./env-helpers.js";
 
-function createEnvClient(input: {
-  organization: string | undefined;
-  project: string;
-  environment: string;
-  runtimeConfig: Awaited<ReturnType<typeof loadRuntimeConfig>> | null;
-}): BarekeyClient {
-  if (input.runtimeConfig !== null) {
-    const organization = input.organization?.trim();
-    const isStandalone = input.runtimeConfig.config.config?.mode === "standalone";
-    if (!organization && !isStandalone) {
-      throw new Error("Organization slug is required.");
-    }
+type EnvWriteOptions = EnvTargetOptions & {
+  ab?: string;
+  rollout?: string;
+  function?: string;
+  point?: Array<string>;
+  chance?: string;
+  visibility?: CliVisibility;
+  type?: "string" | "boolean" | "int64" | "float" | "date" | "json";
+  json?: boolean;
+};
+
+async function resolveEnvAccess(options: EnvTargetOptions) {
+  const local = await requireLocalSession();
+  const target = await resolveTarget(options, local);
+  const authProvider = createCliAuthProvider();
+  const accessToken = await authProvider.getAccessToken();
+  return {
+    local,
+    target,
+    accessToken,
+  };
+}
 
-    const jsonConfig: BarekeyJsonConfig = {
-      ...(organization ? { organization } : {}),
-      ...(input.project.trim().length > 0 ? { project: input.project } : {}),
-      ...(input.environment.trim().length > 0 ? { environment: input.environment } : {}),
-      ...(input.runtimeConfig.config.config === undefined
-        ? {}
-        : {
-            config: {
-              typegen: input.runtimeConfig.config.config.typegen,
-              mode: input.runtimeConfig.config.config.mode,
-            },
-          }),
-    };
+function renderScalar(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
 
-    return new BarekeyClient({
-      json: jsonConfig,
-    });
+async function promptForRequiredText(
+  currentValue: string | undefined,
+  message: string,
+): Promise<string> {
+  const existing = currentValue?.trim();
+  if (existing && existing.length > 0) {
+    return existing;
+  }
+  if (!process.stdout.isTTY) {
+    throw new Error(`${message} is required in non-interactive mode.`);
   }
 
-  const organization = input.organization?.trim();
-  if (!organization) {
-    throw new Error("Organization slug is required.");
+  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();
+}
 
-  return new BarekeyClient({
-    organization,
-    project: input.project,
-    environment: input.environment,
+async function maybePromptVariant(writeOptions: EnvWriteOptions): Promise<EnvWriteOptions> {
+  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",
   });
+  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: string,
+  name: string | undefined,
   options: EnvTargetOptions & {
     seed?: string;
     key?: string;
     json?: boolean;
   },
 ): Promise<void> {
-  const runtime = await loadRuntimeConfig();
-  const local = runtime?.config.config?.mode === "standalone" ? null : await requireLocalSession();
-  const target = await resolveTarget(options, local);
-  const client = createEnvClient({
-    organization: target.orgSlug ?? local?.credentials.orgSlug,
-    project: target.projectSlug,
-    environment: target.stageSlug,
-    runtimeConfig: runtime,
-  });
-  const value = await client.get(name, {
-    seed: options.seed,
-    key: options.key,
+  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: EnvTargetOptions & {
-    names: string;
+    names?: string;
     seed?: string;
     key?: string;
     json?: boolean;
   },
 ): Promise<void> {
-  const runtime = await loadRuntimeConfig();
-  const local = runtime?.config.config?.mode === "standalone" ? null : await requireLocalSession();
-  const target = await resolveTarget(options, local);
-  const client = createEnvClient({
-    organization: target.orgSlug ?? local?.credentials.orgSlug,
-    project: target.projectSlug,
-    environment: target.stageSlug,
-    runtimeConfig: runtime,
-  });
+  const namesCsv = await promptForRequiredText(
+    options.names,
+    "Which variable names do you want, comma-separated?",
+  );
+  const { local, target, accessToken } = await resolveEnvAccess(options);
 
-  const names = options.names
+  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, {
-        seed: options.seed,
-        key: options.key,
-      }),
-    })),
-  );
+  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: EnvTargetOptions & { json?: boolean }): Promise<void> {
-  const local = await requireLocalSession();
-  const target = await resolveTarget(options, local);
-  const authProvider = createCliAuthProvider();
-  const accessToken = await authProvider.getAccessToken();
-
-  const response = await postJson<{
-    variables: Array<{
-      name: string;
-      visibility: CliVisibility;
-      kind: "secret" | "ab_roll" | "rollout";
-      declaredType: "string" | "boolean" | "int64" | "float" | "date" | "json";
-      createdAtMs: number;
-      updatedAtMs: number;
-      chance: number | null;
-      rolloutFunction: CliRolloutFunction | null;
-      rolloutMilestones: Array<{ at: string; percentage: number }> | null;
-    }>;
-  }>({
+  const { local, target, accessToken } = await resolveEnvAccess(options);
+  const response = await postJson({
     baseUrl: local.baseUrl,
     path: "/v1/env/list",
     accessToken,
@@ -176,6 +216,7 @@ async function runEnvList(options: EnvTargetOptions & { json?: boolean }): Promi
       projectSlug: target.projectSlug,
       stageSlug: target.stageSlug,
     },
+    schema: EnvListResponseSchema,
   });
 
   if (options.json) {
@@ -192,85 +233,73 @@ async function runEnvList(options: EnvTargetOptions & { json?: boolean }): Promi
     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}`,
+      `${row.name}  ${row.visibility}  ${row.kind}  ${row.declaredType}${chanceSuffix}${rolloutSuffix}`,
     );
   }
 }
 
 async function runEnvWrite(
   operation: "create_only" | "upsert",
-  name: string,
-  value: string,
-  options: EnvTargetOptions & {
-    ab?: string;
-    rollout?: string;
-    function?: string;
-    point?: Array<string>;
-    chance?: string;
-    visibility?: CliVisibility;
-    type?: "string" | "boolean" | "int64" | "float" | "date" | "json";
-    json?: boolean;
-  },
+  name: string | undefined,
+  value: string | undefined,
+  options: EnvWriteOptions,
 ): Promise<void> {
-  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 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 (options.ab !== undefined && options.rollout !== undefined) {
+  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
+    resolvedOptions.rollout !== undefined
       ? {
-          name,
-          visibility: parseVisibility(options.visibility),
+          name: resolvedName,
+          visibility: parseVisibility(resolvedOptions.visibility),
           kind: "rollout" as const,
-          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" as const,
-            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" as const,
-            declaredType: options.type ?? "string",
-            value,
+            declaredType: resolvedOptions.type ?? "string",
+            value: resolvedValue,
           };
 
-  const result = await postJson<{
-    createdCount: number;
-    updatedCount: number;
-    deletedCount: number;
-  }>({
+  const result = await postJson({
     baseUrl: local.baseUrl,
     path: "/v1/env/write",
     accessToken,
@@ -282,9 +311,10 @@ async function runEnvWrite(
       entries: [entry],
       deletes: [],
     },
+    schema: EnvWriteResponseSchema,
   });
 
-  if (options.json) {
+  if (resolvedOptions.json) {
     toJsonOutput(true, result);
     return;
   }
@@ -295,24 +325,18 @@ async function runEnvWrite(
 }
 
 async function runEnvDelete(
-  name: string,
+  name: string | undefined,
   options: EnvTargetOptions & {
     yes?: boolean;
     ignoreMissing?: boolean;
     json?: boolean;
   },
 ): Promise<void> {
-  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<{
-      variables: Array<{
-        name: string;
-      }>;
-    }>({
+    const listed = await postJson({
       baseUrl: local.baseUrl,
       path: "/v1/env/list",
       accessToken,
@@ -321,10 +345,11 @@ async function runEnvDelete(
         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.`);
     }
   }
 
@@ -333,7 +358,7 @@ async function runEnvDelete(
       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)) {
@@ -345,11 +370,7 @@ async function runEnvDelete(
     }
   }
 
-  const result = await postJson<{
-    createdCount: number;
-    updatedCount: number;
-    deletedCount: number;
-  }>({
+  const result = await postJson({
     baseUrl: local.baseUrl,
     path: "/v1/env/write",
     accessToken,
@@ -359,8 +380,9 @@ async function runEnvDelete(
       stageSlug: target.stageSlug,
       mode: "upsert",
       entries: [],
-      deletes: [name],
+      deletes: [resolvedName],
     },
+    schema: EnvWriteResponseSchema,
   });
 
   if (options.json) {
@@ -380,20 +402,8 @@ async function runEnvPull(
     redact?: boolean;
   },
 ): Promise<void> {
-  const local = await requireLocalSession();
-  const target = await resolveTarget(options, local);
-  const authProvider = createCliAuthProvider();
-  const accessToken = await authProvider.getAccessToken();
-
-  const response = await postJson<{
-    values: Array<{
-      name: string;
-      kind: "secret" | "ab_roll" | "rollout";
-      declaredType: "string" | "boolean" | "int64" | "float" | "date" | "json";
-      value: string;
-    }>;
-    byName: Record<string, string>;
-  }>({
+  const { local, target, accessToken } = await resolveEnvAccess(options);
+  const response = await postJson({
     baseUrl: local.baseUrl,
     path: "/v1/env/pull",
     accessToken,
@@ -404,6 +414,7 @@ async function runEnvPull(
       seed: options.seed,
       key: options.key,
     },
+    schema: EnvPullResponseSchema,
   });
 
   const format = options.format ?? "dotenv";
@@ -434,13 +445,13 @@ export function registerEnvCommands(program: Command): void {
     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: string,
+      name: string | undefined,
       options: EnvTargetOptions & { seed?: string; key?: string; json?: boolean },
     ) => {
       await runEnvGet(name, options);
@@ -451,14 +462,14 @@ export function registerEnvCommands(program: Command): void {
     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: EnvTargetOptions & {
-        names: string;
+        names?: string;
         seed?: string;
         key?: string;
         json?: boolean;
@@ -481,8 +492,8 @@ export function registerEnvCommands(program: Command): void {
     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")
@@ -501,18 +512,9 @@ export function registerEnvCommands(program: Command): void {
       .option("--json", "Machine-readable output", false),
   ).action(
     async (
-      name: string,
-      value: string,
-      options: EnvTargetOptions & {
-        ab?: string;
-        rollout?: string;
-        function?: string;
-        point?: Array<string>;
-        chance?: string;
-        visibility?: CliVisibility;
-        type?: "string" | "boolean" | "int64" | "float" | "date" | "json";
-        json?: boolean;
-      },
+      name: string | undefined,
+      value: string | undefined,
+      options: EnvWriteOptions,
     ) => {
       await runEnvWrite("create_only", name, value, options);
     },
@@ -522,8 +524,8 @@ export function registerEnvCommands(program: Command): void {
     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")
@@ -542,18 +544,9 @@ export function registerEnvCommands(program: Command): void {
       .option("--json", "Machine-readable output", false),
   ).action(
     async (
-      name: string,
-      value: string,
-      options: EnvTargetOptions & {
-        ab?: string;
-        rollout?: string;
-        function?: string;
-        point?: Array<string>;
-        chance?: string;
-        visibility?: CliVisibility;
-        type?: "string" | "boolean" | "int64" | "float" | "date" | "json";
-        json?: boolean;
-      },
+      name: string | undefined,
+      value: string | undefined,
+      options: EnvWriteOptions,
     ) => {
       await runEnvWrite("upsert", name, value, options);
     },
@@ -563,13 +556,13 @@ export function registerEnvCommands(program: Command): void {
     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: string,
+      name: string | undefined,
       options: EnvTargetOptions & { yes?: boolean; ignoreMissing?: boolean; json?: boolean },
     ) => {
       await runEnvDelete(name, options);