@barekey/cli 0.4.0 → 0.5.1

package/src/commands/init.ts

@@ -0,0 +1,47 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { Command } from "commander";
+
+import { type EnvTargetOptions } from "../command-utils.js";
+import {
+  promptForOrganizationSlug,
+  promptForProjectSlug,
+  promptForStageSlug,
+} from "./target-prompts.js";
+
+async function runInit(options: EnvTargetOptions & { path?: string }) {
+  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: Command): void {
+  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: EnvTargetOptions & { path?: string }) => {
+      await runInit(options);
+    });
+}

package/src/commands/org.ts

@@ -0,0 +1,104 @@
+import { text, isCancel, cancel } from "@clack/prompts";
+import { Command } from "commander";
+
+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: string | undefined): Promise<string> {
+  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: { json?: boolean }) {
+  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: string | undefined,
+  options: {
+    slug?: string;
+    json?: boolean;
+  },
+) {
+  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 as { organization: { name: string; slug: string } }).organization;
+  console.log(`Created organization ${organization.name} (${organization.slug}).`);
+}
+
+export function registerOrgCommands(program: Command): void {
+  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: { json?: boolean }) => {
+      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: string | undefined, options: { slug?: string; json?: boolean }) => {
+      await runOrgCreate(name, options);
+    });
+}

package/src/commands/project.ts

@@ -0,0 +1,130 @@
+import { cancel, confirm, isCancel, text } from "@clack/prompts";
+import { Command } from "commander";
+
+import { toJsonOutput, type EnvTargetOptions } from "../command-utils.js";
+import {
+  createProjectForOrganization,
+  deleteProjectForOrganization,
+  listProjectsForOrganization,
+  promptForOrganizationSlug,
+  promptForProjectSlug,
+} from "./target-prompts.js";
+
+async function promptForProjectName(name: string | undefined): Promise<string> {
+  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: EnvTargetOptions & { json?: boolean }) {
+  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: string | undefined,
+  options: EnvTargetOptions & { json?: boolean },
+) {
+  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: Command): void {
+  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: EnvTargetOptions & { json?: boolean }) => {
+      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: string | undefined, options: EnvTargetOptions & { json?: boolean }) => {
+      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: string | undefined,
+        options: EnvTargetOptions & { yes?: boolean; json?: boolean },
+      ) => {
+        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/src/commands/stage.ts

@@ -0,0 +1,167 @@
+import { cancel, confirm, isCancel, text } from "@clack/prompts";
+import { Command } from "commander";
+
+import { toJsonOutput, type EnvTargetOptions } from "../command-utils.js";
+import {
+  createStageForProject,
+  deleteStageForProject,
+  listStagesForProject,
+  promptForOrganizationSlug,
+  promptForProjectSlug,
+  promptForStageSlug,
+  renameStageForProject,
+} from "./target-prompts.js";
+
+async function promptForStageName(name: string | undefined): Promise<string> {
+  const existing = name?.trim();
+  if (existing && existing.length > 0) {
+    return existing;
+  }
+  if (!process.stdout.isTTY) {
+    throw new Error("Stage name is required in non-interactive mode.");
+  }
+  const prompted = await text({
+    message: "What’s the name of this stage?",
+    validate: (value) => (value.trim().length > 0 ? undefined : "Stage name is required."),
+  });
+  if (isCancel(prompted)) {
+    cancel("Command canceled.");
+    process.exit(0);
+  }
+  return prompted.trim();
+}
+
+async function runStageList(options: EnvTargetOptions & { json?: boolean }) {
+  const orgSlug = await promptForOrganizationSlug(options.org);
+  const projectSlug = await promptForProjectSlug(orgSlug, options.project);
+  const stages = await listStagesForProject(orgSlug, projectSlug);
+
+  if (options.json) {
+    toJsonOutput(true, stages);
+    return;
+  }
+
+  if (stages.length === 0) {
+    console.log("No stages found.");
+    return;
+  }
+
+  for (const stage of stages) {
+    console.log(`${stage.name} (${stage.slug}) variables=${stage.variableCount}`);
+  }
+}
+
+async function runStageCreate(
+  name: string | undefined,
+  options: EnvTargetOptions & { json?: boolean },
+) {
+  const orgSlug = await promptForOrganizationSlug(options.org);
+  const projectSlug = await promptForProjectSlug(orgSlug, options.project);
+  const stageName = await promptForStageName(name);
+  const stage = await createStageForProject(orgSlug, projectSlug, stageName);
+
+  if (options.json) {
+    toJsonOutput(true, stage);
+    return;
+  }
+
+  console.log(`Created stage ${stage.name} (${stage.slug}).`);
+}
+
+export function registerStageCommands(program: Command): void {
+  const stage = program.command("stage").description("Stage management");
+
+  stage
+    .command("list")
+    .description("List stages in a project")
+    .option("--org <slug>", "Organization slug")
+    .option("--project <slug>", "Project slug")
+    .option("--json", "Machine-readable output", false)
+    .action(async (options: EnvTargetOptions & { json?: boolean }) => {
+      await runStageList(options);
+    });
+
+  stage
+    .command("create")
+    .description("Create a stage")
+    .argument("[name]", "Stage name")
+    .option("--org <slug>", "Organization slug")
+    .option("--project <slug>", "Project slug")
+    .option("--json", "Machine-readable output", false)
+    .action(async (name: string | undefined, options: EnvTargetOptions & { json?: boolean }) => {
+      await runStageCreate(name, options);
+    });
+
+  stage
+    .command("rename")
+    .description("Rename a stage")
+    .argument("[slug]", "Stage slug")
+    .argument("[name]", "New stage display name")
+    .option("--org <slug>", "Organization slug")
+    .option("--project <slug>", "Project slug")
+    .option("--json", "Machine-readable output", false)
+    .action(
+      async (
+        slug: string | undefined,
+        name: string | undefined,
+        options: EnvTargetOptions & { json?: boolean },
+      ) => {
+        const orgSlug = await promptForOrganizationSlug(options.org);
+        const projectSlug = await promptForProjectSlug(orgSlug, options.project);
+        const stageSlug = await promptForStageSlug(orgSlug, projectSlug, slug);
+        const stageName = await promptForStageName(name);
+        const stage = await renameStageForProject(orgSlug, projectSlug, stageSlug, stageName);
+
+        if (options.json) {
+          toJsonOutput(true, stage);
+          return;
+        }
+
+        console.log(`Renamed stage ${stage.slug} to ${stage.name}.`);
+      },
+    );
+
+  stage
+    .command("delete")
+    .description("Delete a stage")
+    .argument("[slug]", "Stage slug")
+    .option("--org <slug>", "Organization slug")
+    .option("--project <slug>", "Project slug")
+    .option("--yes", "Skip confirmation prompt", false)
+    .option("--json", "Machine-readable output", false)
+    .action(
+      async (
+        slug: string | undefined,
+        options: EnvTargetOptions & { yes?: boolean; json?: boolean },
+      ) => {
+        const orgSlug = await promptForOrganizationSlug(options.org);
+        const projectSlug = await promptForProjectSlug(orgSlug, options.project);
+        const stageSlug = await promptForStageSlug(orgSlug, projectSlug, slug);
+
+        if (!options.yes) {
+          if (!process.stdout.isTTY) {
+            throw new Error("Stage deletion requires --yes in non-interactive mode.");
+          }
+          const confirmed = await confirm({
+            message: `Delete stage ${stageSlug}?`,
+            initialValue: false,
+          });
+          if (isCancel(confirmed)) {
+            cancel("Command canceled.");
+            process.exit(0);
+          }
+          if (!confirmed) {
+            throw new Error("Delete canceled.");
+          }
+        }
+
+        const response = await deleteStageForProject(orgSlug, projectSlug, stageSlug);
+        if (options.json) {
+          toJsonOutput(true, response);
+          return;
+        }
+
+        console.log(`Deleted stage ${response.deletedStageSlug}.`);
+      },
+    );
+}