@barekey/cli 0.4.0 → 0.5.1

package/src/commands/target-prompts.ts

@@ -0,0 +1,357 @@
+import { cancel, isCancel, select } from "@clack/prompts";
+
+import { createCliAuthProvider } from "../auth-provider.js";
+import { requireLocalSession } from "../command-utils.js";
+import {
+  OrganizationsResponseSchema,
+  ProjectCreateResponseSchema,
+  ProjectDeleteResponseSchema,
+  ProjectsListResponseSchema,
+  StageCreateResponseSchema,
+  StageDeleteResponseSchema,
+  StageRenameResponseSchema,
+  StagesListResponseSchema,
+} from "../contracts/index.js";
+import { getJson, postJson } from "../http.js";
+
+async function resolveManagementAccess() {
+  const local = await requireLocalSession();
+  const authProvider = createCliAuthProvider();
+  const accessToken = await authProvider.getAccessToken();
+
+  return {
+    local,
+    accessToken,
+  };
+}
+
+/**
+ * Loads organizations for the current CLI user.
+ *
+ * @returns The accessible organizations for the signed-in user.
+ * @remarks Interactive command flows use this to avoid any hidden org-scoped auth fallback.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function listOrganizationsForCurrentUser() {
+  const { local, accessToken } = await resolveManagementAccess();
+  const response = await getJson({
+    baseUrl: local.baseUrl,
+    path: "/v1/cli/orgs",
+    accessToken,
+    schema: OrganizationsResponseSchema,
+  });
+  return response.organizations;
+}
+
+/**
+ * Loads projects for one organization.
+ *
+ * @param orgSlug The organization slug to inspect.
+ * @returns The projects for the organization.
+ * @remarks Project-scoped CLI flows call the same backend contract as `barekey init`.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function listProjectsForOrganization(orgSlug: string) {
+  const { local, accessToken } = await resolveManagementAccess();
+  const response = await postJson({
+    baseUrl: local.baseUrl,
+    path: "/v1/cli/projects/list",
+    accessToken,
+    payload: {
+      orgSlug,
+    },
+    schema: ProjectsListResponseSchema,
+  });
+  return response.projects;
+}
+
+/**
+ * Loads stages for one project.
+ *
+ * @param orgSlug The organization slug to inspect.
+ * @param projectSlug The project slug to inspect.
+ * @returns The stages for the selected project.
+ * @remarks Stage prompts use this to drive repo initialization and stage management flows.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function listStagesForProject(orgSlug: string, projectSlug: string) {
+  const { local, accessToken } = await resolveManagementAccess();
+  const response = await postJson({
+    baseUrl: local.baseUrl,
+    path: "/v1/cli/stages/list",
+    accessToken,
+    payload: {
+      orgSlug,
+      projectSlug,
+    },
+    schema: StagesListResponseSchema,
+  });
+  return response.stages;
+}
+
+/**
+ * Creates one project for one organization.
+ *
+ * @param orgSlug The organization slug that should own the project.
+ * @param name The project name to create.
+ * @returns The created project summary.
+ * @remarks CLI project-create flows use this helper so the command stays a thin prompt wrapper.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function createProjectForOrganization(orgSlug: string, name: string) {
+  const { local, accessToken } = await resolveManagementAccess();
+  const response = await postJson({
+    baseUrl: local.baseUrl,
+    path: "/v1/cli/projects/create",
+    accessToken,
+    payload: {
+      orgSlug,
+      name,
+    },
+    schema: ProjectCreateResponseSchema,
+  });
+  return response.project;
+}
+
+/**
+ * Deletes one project for one organization.
+ *
+ * @param orgSlug The organization slug that owns the project.
+ * @param projectSlug The project slug to delete.
+ * @returns The deleted project payload.
+ * @remarks Destructive project flows use this shared helper so command handlers stay focused on prompts and output.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function deleteProjectForOrganization(orgSlug: string, projectSlug: string) {
+  const { local, accessToken } = await resolveManagementAccess();
+  return await postJson({
+    baseUrl: local.baseUrl,
+    path: "/v1/cli/projects/delete",
+    accessToken,
+    payload: {
+      orgSlug,
+      projectSlug,
+    },
+    schema: ProjectDeleteResponseSchema,
+  });
+}
+
+/**
+ * Creates one stage for one project.
+ *
+ * @param orgSlug The organization slug that owns the project.
+ * @param projectSlug The project slug that should receive the stage.
+ * @param name The stage name to create.
+ * @returns The created stage summary.
+ * @remarks CLI stage-create flows use this helper so the command stays a thin prompt wrapper.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function createStageForProject(orgSlug: string, projectSlug: string, name: string) {
+  const { local, accessToken } = await resolveManagementAccess();
+  const response = await postJson({
+    baseUrl: local.baseUrl,
+    path: "/v1/cli/stages/create",
+    accessToken,
+    payload: {
+      orgSlug,
+      projectSlug,
+      name,
+    },
+    schema: StageCreateResponseSchema,
+  });
+  return response.stage;
+}
+
+/**
+ * Renames one stage for one project.
+ *
+ * @param orgSlug The organization slug that owns the project.
+ * @param projectSlug The project slug that owns the stage.
+ * @param stageSlug The stage slug to rename.
+ * @param name The next display name for the stage.
+ * @returns The updated stage summary.
+ * @remarks Stage rename keeps immutable slugs and only patches the display name.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function renameStageForProject(
+  orgSlug: string,
+  projectSlug: string,
+  stageSlug: string,
+  name: string,
+) {
+  const { local, accessToken } = await resolveManagementAccess();
+  const response = await postJson({
+    baseUrl: local.baseUrl,
+    path: "/v1/cli/stages/rename",
+    accessToken,
+    payload: {
+      orgSlug,
+      projectSlug,
+      stageSlug,
+      name,
+    },
+    schema: StageRenameResponseSchema,
+  });
+  return response.stage;
+}
+
+/**
+ * Deletes one stage for one project.
+ *
+ * @param orgSlug The organization slug that owns the project.
+ * @param projectSlug The project slug that owns the stage.
+ * @param stageSlug The stage slug to delete.
+ * @returns The deleted stage payload.
+ * @remarks Destructive stage flows use this helper so command handlers stay prompt-focused.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function deleteStageForProject(
+  orgSlug: string,
+  projectSlug: string,
+  stageSlug: string,
+) {
+  const { local, accessToken } = await resolveManagementAccess();
+  return await postJson({
+    baseUrl: local.baseUrl,
+    path: "/v1/cli/stages/delete",
+    accessToken,
+    payload: {
+      orgSlug,
+      projectSlug,
+      stageSlug,
+    },
+    schema: StageDeleteResponseSchema,
+  });
+}
+
+/**
+ * Resolves one organization target from an explicit flag or an interactive selection.
+ *
+ * @param orgSlug The optionally supplied organization slug.
+ * @returns The resolved organization slug.
+ * @remarks Non-interactive runs must provide the target explicitly or via local repo config higher up the call stack.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function promptForOrganizationSlug(orgSlug: string | undefined): Promise<string> {
+  const explicit = orgSlug?.trim();
+  if (explicit && explicit.length > 0) {
+    return explicit;
+  }
+  if (!process.stdout.isTTY) {
+    throw new Error("Organization slug is required in non-interactive mode.");
+  }
+
+  const organizations = await listOrganizationsForCurrentUser();
+  if (organizations.length === 0) {
+    throw new Error("No organizations found. Create one first with barekey org create.");
+  }
+
+  const selected = await select({
+    message: "Which organization should Barekey use?",
+    options: organizations.map((organization) => ({
+      value: organization.slug,
+      label: organization.name,
+      hint: organization.slug,
+    })),
+  });
+  if (isCancel(selected)) {
+    cancel("Command canceled.");
+    process.exit(0);
+  }
+  return selected;
+}
+
+/**
+ * Resolves one project target from an explicit flag or an interactive selection.
+ *
+ * @param orgSlug The owning organization slug.
+ * @param projectSlug The optionally supplied project slug.
+ * @returns The resolved project slug.
+ * @remarks This intentionally loads live project choices instead of guessing from auth state.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function promptForProjectSlug(
+  orgSlug: string,
+  projectSlug: string | undefined,
+): Promise<string> {
+  const explicit = projectSlug?.trim();
+  if (explicit && explicit.length > 0) {
+    return explicit;
+  }
+  if (!process.stdout.isTTY) {
+    throw new Error("Project slug is required in non-interactive mode.");
+  }
+
+  const projects = await listProjectsForOrganization(orgSlug);
+  if (projects.length === 0) {
+    throw new Error("No projects found. Create one first with barekey project create.");
+  }
+
+  const selected = await select({
+    message: "Which project should Barekey use?",
+    options: projects.map((project) => ({
+      value: project.slug,
+      label: project.name,
+      hint: project.slug,
+    })),
+  });
+  if (isCancel(selected)) {
+    cancel("Command canceled.");
+    process.exit(0);
+  }
+  return selected;
+}
+
+/**
+ * Resolves one stage target from an explicit flag or an interactive selection.
+ *
+ * @param orgSlug The owning organization slug.
+ * @param projectSlug The owning project slug.
+ * @param stageSlug The optionally supplied stage slug.
+ * @returns The resolved stage slug.
+ * @remarks This is used by `barekey init` so local repo setup can be a guided flow.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function promptForStageSlug(
+  orgSlug: string,
+  projectSlug: string,
+  stageSlug: string | undefined,
+): Promise<string> {
+  const explicit = stageSlug?.trim();
+  if (explicit && explicit.length > 0) {
+    return explicit;
+  }
+  if (!process.stdout.isTTY) {
+    throw new Error("Stage slug is required in non-interactive mode.");
+  }
+
+  const stages = await listStagesForProject(orgSlug, projectSlug);
+  if (stages.length === 0) {
+    throw new Error("No stages found. Create one first with barekey stage create.");
+  }
+
+  const selected = await select({
+    message: "Which stage should Barekey use?",
+    options: stages.map((stage) => ({
+      value: stage.slug,
+      label: stage.name,
+      hint: stage.slug,
+    })),
+  });
+  if (isCancel(selected)) {
+    cancel("Command canceled.");
+    process.exit(0);
+  }
+  return selected;
+}

package/src/commands/typegen.ts

@@ -1,19 +1,24 @@
-import { BarekeyClient } from "@barekey/sdk/server";
-import type { BarekeyJsonConfig, BarekeyTypegenResult } from "@barekey/sdk/server";
 import { Command } from "commander";
 import pc from "picocolors";
 
+import { createCliAuthProvider } from "../auth-provider.js";
 import {
   addTargetOptions,
   requireLocalSession,
   resolveTarget,
   type EnvTargetOptions,
 } from "../command-utils.js";
+import { TypegenManifestSchema } from "../contracts/index.js";
+import { getJson } from "../http.js";
 import { loadRuntimeConfig } from "../runtime-config.js";
+import {
+  type CliTypegenResult,
+  writeInstalledSdkGeneratedTypes,
+} from "../typegen/core.js";
 
 const DEFAULT_TYPEGEN_WATCH_INTERVAL_MS = 5_000;
 
-export function formatTypegenResultMessage(result: BarekeyTypegenResult): string {
+export function formatTypegenResultMessage(result: CliTypegenResult): string {
   const title = result.written
     ? pc.green(pc.bold("Typegen complete"))
     : pc.cyan(pc.bold("Typegen already up to date"));
@@ -61,54 +66,69 @@ function sleep(milliseconds: number): Promise<void> {
   });
 }
 
-async function resolveTypegenClient(options: EnvTargetOptions): Promise<{
-  client: BarekeyClient;
+async function resolveTypegenContext(options: EnvTargetOptions): Promise<{
+  baseUrl: string | null;
+  accessToken: string | null;
   organization: string;
   project: string;
   environment: string;
+  runtimeMode: "centralized" | "standalone";
+  typegenMode: "semantic" | "minimal";
+  localEnvRoot: string | null;
 }> {
   const runtime = await loadRuntimeConfig();
   const local = runtime?.config.config?.mode === "standalone" ? null : await requireLocalSession();
   const target = await resolveTarget(options, local);
-  const isStandalone = runtime?.config.config?.mode === "standalone";
-  const organization = target.orgSlug ?? local?.credentials.orgSlug;
-  if ((!organization || organization.trim().length === 0) && !isStandalone) {
-    throw new Error("Organization slug is required.");
-  }
-
-  const jsonConfig = {
-    ...(organization && organization.trim().length > 0 ? { organization } : {}),
-    ...(target.projectSlug.trim().length > 0 ? { project: target.projectSlug } : {}),
-    ...(target.stageSlug.trim().length > 0 ? { environment: target.stageSlug } : {}),
-    ...(runtime?.config.config?.typegen === undefined
-      ? {}
-      : {
-            config: {
-              typegen: runtime.config.config.typegen,
-              mode: runtime.config.config.mode,
-            },
-          }),
-  } as BarekeyJsonConfig & {
-    config?: {
-      typegen?: "semantic" | "minimal";
-      mode?: "centralized" | "standalone";
-    };
-  };
+  const authProvider = local === null ? null : createCliAuthProvider();
 
   return {
-    client: new BarekeyClient({
-      json: jsonConfig as BarekeyJsonConfig,
-      typegen: false,
-    }),
-    organization: organization && organization.trim().length > 0 ? organization : "local",
+    baseUrl: local?.baseUrl ?? null,
+    accessToken: authProvider === null ? null : await authProvider.getAccessToken(),
+    organization: target.orgSlug ?? "local",
     project: target.projectSlug.trim().length > 0 ? target.projectSlug : "standalone",
     environment: target.stageSlug.trim().length > 0 ? target.stageSlug : "local",
+    runtimeMode: runtime?.config.config?.mode ?? "centralized",
+    typegenMode: runtime?.config.config?.typegen ?? "semantic",
+    localEnvRoot: runtime?.path ?? null,
+  };
+}
+
+async function fetchManifest(options: EnvTargetOptions) {
+  const context = await resolveTypegenContext(options);
+  if (context.baseUrl === null || context.accessToken === null) {
+    throw new Error("Typegen currently requires centralized Barekey auth.");
+  }
+
+  const searchParams = new URLSearchParams({
+    orgSlug: context.organization,
+    projectSlug: context.project,
+    stageSlug: context.environment,
+  });
+
+  const manifest = await getJson({
+    baseUrl: context.baseUrl,
+    path: `/v1/typegen/manifest?${searchParams.toString()}`,
+    accessToken: context.accessToken,
+    schema: TypegenManifestSchema,
+  });
+
+  return {
+    manifest,
+    context,
   };
 }
 
 async function runTypegen(options: EnvTargetOptions): Promise<void> {
-  const { client } = await resolveTypegenClient(options);
-  const result = await client.typegen();
+  const { manifest, context } = await fetchManifest(options);
+  const result = await writeInstalledSdkGeneratedTypes(manifest, {
+    baseUrl: context.baseUrl,
+    orgSlug: context.organization,
+    projectSlug: context.project,
+    stageSlug: context.environment,
+    typegenMode: context.typegenMode,
+    runtimeMode: context.runtimeMode,
+    localEnvRoot: context.localEnvRoot,
+  });
 
   console.log(formatTypegenResultMessage(result));
 }
@@ -119,13 +139,13 @@ async function runTypegenWatch(
   },
 ): Promise<void> {
   const intervalMs = parseTypegenWatchInterval(options.interval);
-  const { client, organization, project, environment } = await resolveTypegenClient(options);
+  const { context } = await fetchManifest(options);
 
   console.log(
     formatTypegenWatchStartedMessage({
-      organization,
-      project,
-      environment,
+      organization: context.organization,
+      project: context.project,
+      environment: context.environment,
       intervalMs,
     }),
   );
@@ -140,7 +160,16 @@ async function runTypegenWatch(
   try {
     let isFirstRun = true;
     while (!stopped) {
-      const result = await client.typegen();
+      const { manifest, context: nextContext } = await fetchManifest(options);
+      const result = await writeInstalledSdkGeneratedTypes(manifest, {
+        baseUrl: nextContext.baseUrl,
+        orgSlug: nextContext.organization,
+        projectSlug: nextContext.project,
+        stageSlug: nextContext.environment,
+        typegenMode: nextContext.typegenMode,
+        runtimeMode: nextContext.runtimeMode,
+        localEnvRoot: nextContext.localEnvRoot,
+      });
       if (isFirstRun || result.written) {
         if (!isFirstRun) {
           console.log("");
@@ -167,10 +196,7 @@ export function registerTypegenCommand(program: Command): void {
       .command("typegen")
       .description("Generate Barekey SDK types in the installed @barekey/sdk module")
       .option("--watch", "Keep generated types up to date during development", false)
-      .option(
-        "--interval <ms>",
-        "Polling interval for --watch in milliseconds",
-      ),
+      .option("--interval <ms>", "Polling interval for --watch in milliseconds"),
   ).action(async (options: EnvTargetOptions & { watch?: boolean; interval?: string }) => {
     if (options.watch) {
       await runTypegenWatch(options);

package/src/constants.ts

@@ -1,4 +1,4 @@
 export const CLI_NAME = "barekey";
 export const CLI_DESCRIPTION = "Barekey CLI";
-export const CLI_VERSION = "0.4.0";
+export const CLI_VERSION = "0.5.0";
 export const DEFAULT_BAREKEY_API_URL = "https://api.barekey.dev";

package/src/context/session-id.ts

@@ -0,0 +1,14 @@
+/**
+ * Builds the stable CLI session id for one base URL and Clerk user.
+ *
+ * @param baseUrl The Barekey API base URL.
+ * @param clerkUserId The authenticated Clerk user id.
+ * @returns The normalized CLI session id.
+ * @remarks CLI auth is global per user and base URL, not per organization.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function buildSessionId(baseUrl: string, clerkUserId: string): string {
+  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  return `${normalizedBaseUrl}::${clerkUserId}`;
+}