@barekey/cli 0.4.0 → 0.5.0

package/src/runtime-config.ts

@@ -1,5 +1,8 @@
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
+import { Either, Schema } from "effect";
+
+import { RuntimeConfigSchema } from "./contracts/index.js";
 
 export type BarekeyRuntimeConfig = {
   org?: string;
@@ -48,42 +51,26 @@ export async function loadRuntimeConfig(): Promise<BarekeyRuntimeConfigResult |
   }
 
   const raw = await readFile(configPath, "utf8");
-  const parsed = JSON.parse(raw) as Record<string, unknown>;
-  const config =
-    typeof parsed.config === "object" && parsed.config !== null
-      ? (parsed.config as Record<string, unknown>)
-      : undefined;
+  const parsed = JSON.parse(raw) as unknown;
+  const decoded = Schema.decodeUnknownEither(RuntimeConfigSchema)(parsed);
+  if (Either.isLeft(decoded)) {
+    throw new Error(`Invalid barekey.json at ${configPath}.`);
+  }
+
+  const config = decoded.right.config;
+  const mode = config?.mode ?? "centralized";
+  const typegen =
+    mode === "standalone" ? "minimal" : (config?.typegen ?? decoded.right.typegen ?? "semantic");
+
   return {
     path: configPath,
     config: {
-      org:
-        typeof parsed.organization === "string"
-          ? parsed.organization.trim()
-          : typeof parsed.org === "string"
-            ? parsed.org.trim()
-            : undefined,
-      project: typeof parsed.project === "string" ? parsed.project.trim() : undefined,
-      environment:
-        typeof parsed.environment === "string"
-          ? parsed.environment.trim()
-          : typeof parsed.stage === "string"
-            ? parsed.stage.trim()
-            : undefined,
+      org: (decoded.right.organization ?? decoded.right.org ?? undefined)?.trim() || undefined,
+      project: decoded.right.project?.trim() || undefined,
+      environment: (decoded.right.environment ?? decoded.right.stage ?? undefined)?.trim() || undefined,
       config: {
-        mode:
-          config?.mode === "centralized" || config?.mode === "standalone"
-            ? config.mode
-            : "centralized",
-        typegen:
-          (config?.mode === "centralized" || config?.mode === "standalone"
-            ? config.mode
-            : "centralized") === "standalone"
-            ? "minimal"
-            : config?.typegen === "semantic" || config?.typegen === "minimal"
-              ? config.typegen
-              : parsed.typegen === "semantic" || parsed.typegen === "minimal"
-                ? parsed.typegen
-                : "semantic",
+        mode,
+        typegen,
       },
     },
   };

package/src/typegen/core.ts

@@ -0,0 +1,311 @@
+import { createRequire } from "node:module";
+import { access, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { Schema } from "effect";
+
+import { TypegenManifestSchema, type TypegenManifest } from "../contracts/index.js";
+
+export type CliTypegenMode = "semantic" | "minimal";
+export type CliRuntimeMode = "centralized" | "standalone";
+
+export type CliTypegenResult = {
+  written: boolean;
+  path: string;
+  serverPath: string;
+  publicPath: string;
+  manifestVersion: string;
+};
+
+type TypegenIdentity = {
+  baseUrl: string | null;
+  orgSlug: string;
+  projectSlug: string;
+  stageSlug: string;
+  typegenMode: CliTypegenMode;
+  runtimeMode: CliRuntimeMode;
+  localEnvRoot: string | null;
+};
+
+const MANIFEST_VERSION_PATTERN = /\/\* barekey-manifest-version: ([^\n]+) \*\//;
+
+const TypegenMetadataSchema = Schema.Struct({
+  version: Schema.Number,
+  last: Schema.String,
+  baseUrl: Schema.NullOr(Schema.String),
+  orgSlug: Schema.NullOr(Schema.String),
+  projectSlug: Schema.NullOr(Schema.String),
+  stageSlug: Schema.NullOr(Schema.String),
+  typegenMode: Schema.NullOr(Schema.Literal("semantic", "minimal")),
+  runtimeMode: Schema.NullOr(Schema.Literal("centralized", "standalone")),
+  localEnvRoot: Schema.NullOr(Schema.String),
+});
+
+type InstalledSdkTypegenTarget = {
+  packageRoot: string;
+  serverGeneratedTypesPath: string;
+  publicGeneratedTypesPath: string;
+  typegenMetadataPath: string;
+};
+
+function renderLinearMilestones(
+  milestones: ReadonlyArray<{ at: string; percentage: number }>,
+): string {
+  if (milestones.length === 0) {
+    return "readonly []";
+  }
+
+  return `readonly [${milestones
+    .map(
+      (milestone) =>
+        `readonly [${JSON.stringify(milestone.at)}, ${String(milestone.percentage)}]`,
+    )
+    .join(", ")}]`;
+}
+
+function renderRolloutMetadataType(row: TypegenManifest["variables"][number]): string {
+  const renderedMilestones = renderLinearMilestones(row.rolloutMilestones ?? []);
+  if (row.rolloutFunction === "step") {
+    return `Step<${renderedMilestones}>`;
+  }
+  if (row.rolloutFunction === "ease_in_out") {
+    return `EaseInOut<${renderedMilestones}>`;
+  }
+  return `Linear<${renderedMilestones}>`;
+}
+
+function renderVariableType(
+  row: TypegenManifest["variables"][number],
+  mode: CliTypegenMode,
+): string {
+  if (mode === "minimal") {
+    return row.typeScriptType;
+  }
+
+  const descriptor = `{ Type: ${row.typeScriptType}; Kind: ${JSON.stringify(row.kind)}; Visibility: ${JSON.stringify(row.visibility)}; Rollout: ${
+    row.kind === "rollout" ? renderRolloutMetadataType(row) : "never"
+  } }`;
+
+  return `Env<${descriptor}>`;
+}
+
+function buildGeneratedTypesContents(
+  manifest: TypegenManifest,
+  input: {
+    mode: CliTypegenMode;
+    typeModulePath: "./dist/types.js" | "./dist/public-types.js";
+    declaredModulePath: "./dist/types.js" | "./dist/public-types.js";
+    interfaceName: "BarekeyGeneratedTypeMap" | "BarekeyPublicGeneratedTypeMap";
+    include: (row: TypegenManifest["variables"][number]) => boolean;
+  },
+): string {
+  const mapLines = manifest.variables
+    .slice()
+    .filter(input.include)
+    .sort((left, right) => left.name.localeCompare(right.name))
+    .map((row) => `    ${JSON.stringify(row.name)}: ${renderVariableType(row, input.mode)};`)
+    .join("\n");
+
+  const importLine =
+    input.mode === "semantic"
+      ? `import type { EaseInOut, Env, Linear, Step } from "${input.typeModulePath}";\n\n`
+      : "";
+
+  return `/* eslint-disable */\n/* This file is generated by barekey typegen. */\n/* barekey-manifest-version: ${manifest.manifestVersion} */\n\n${importLine}declare module "${input.declaredModulePath}" {\n  interface ${input.interfaceName} {\n${mapLines.length > 0 ? mapLines : ""}\n  }\n}\n\nexport {};\n`;
+}
+
+function readManifestVersion(contents: string | null): string | null {
+  return contents?.match(MANIFEST_VERSION_PATTERN)?.[1]?.trim() ?? null;
+}
+
+async function readTextFile(filePath: string): Promise<string | null> {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    const nodeError = error as NodeJS.ErrnoException | null;
+    if (nodeError?.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function writeTextFileAtomic(filePath: string, value: string): Promise<void> {
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temporaryPath, value, "utf8");
+    await rename(temporaryPath, filePath);
+  } catch (error) {
+    try {
+      await unlink(temporaryPath);
+    } catch {
+      // Best-effort cleanup only.
+    }
+    throw error;
+  }
+}
+
+async function resolveInstalledSdkTypegenTarget(): Promise<InstalledSdkTypegenTarget | null> {
+  const require = createRequire(path.join(process.cwd(), "__barekey_typegen__.cjs"));
+
+  let resolvedEntrypoint: string;
+  try {
+    resolvedEntrypoint = require.resolve("@barekey/sdk/package.json");
+  } catch {
+    return null;
+  }
+
+  let current = path.dirname(resolvedEntrypoint);
+  while (true) {
+    const candidatePackageJson = path.join(current, "package.json");
+    const rawPackageJson = await readTextFile(candidatePackageJson);
+    if (rawPackageJson !== null) {
+      try {
+        const parsed = JSON.parse(rawPackageJson) as { name?: unknown };
+        if (parsed.name === "@barekey/sdk") {
+          const serverGeneratedTypesPath = path.join(current, "generated.server.d.ts");
+          const publicGeneratedTypesPath = path.join(current, "generated.public.d.ts");
+          await access(serverGeneratedTypesPath);
+          await access(publicGeneratedTypesPath);
+          return {
+            packageRoot: current,
+            serverGeneratedTypesPath,
+            publicGeneratedTypesPath,
+            typegenMetadataPath: path.join(current, "typegen.json"),
+          };
+        }
+      } catch {
+        // Keep walking upward.
+      }
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function buildTypegenMetadataContents(lastGeneratedAt: Date, identity: TypegenIdentity): string {
+  return `${JSON.stringify(
+    {
+      version: 1,
+      last: lastGeneratedAt.toISOString(),
+      baseUrl: identity.baseUrl,
+      orgSlug: identity.orgSlug,
+      projectSlug: identity.projectSlug,
+      stageSlug: identity.stageSlug,
+      typegenMode: identity.typegenMode,
+      runtimeMode: identity.runtimeMode,
+      localEnvRoot: identity.localEnvRoot,
+    },
+    null,
+    2,
+  )}\n`;
+}
+
+/**
+ * Renders the generated SDK declaration files for one manifest.
+ *
+ * @param manifest The decoded typegen manifest.
+ * @param mode The requested typegen mode.
+ * @returns The rendered server and public declaration contents.
+ * @remarks The CLI owns this rendering so it no longer depends on SDK runtime helpers.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function renderGeneratedTypesForManifest(
+  manifest: TypegenManifest,
+  mode: CliTypegenMode,
+): {
+  serverContents: string;
+  publicContents: string;
+} {
+  const decodedManifest = Schema.decodeUnknownSync(TypegenManifestSchema)(manifest);
+
+  return {
+    serverContents: buildGeneratedTypesContents(decodedManifest, {
+      mode,
+      typeModulePath: "./dist/types.js",
+      declaredModulePath: "./dist/types.js",
+      interfaceName: "BarekeyGeneratedTypeMap",
+      include: () => true,
+    }),
+    publicContents: buildGeneratedTypesContents(decodedManifest, {
+      mode,
+      typeModulePath: "./dist/public-types.js",
+      declaredModulePath: "./dist/public-types.js",
+      interfaceName: "BarekeyPublicGeneratedTypeMap",
+      include: (row) => row.visibility === "public",
+    }),
+  };
+}
+
+/**
+ * Writes generated SDK declaration files into the installed `@barekey/sdk` package.
+ *
+ * @param manifest The decoded typegen manifest.
+ * @param identity The manifest identity used for metadata freshness.
+ * @returns The typegen write result.
+ * @remarks This preserves the existing generated file locations without importing the SDK package at runtime.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export async function writeInstalledSdkGeneratedTypes(
+  manifest: TypegenManifest,
+  identity: TypegenIdentity,
+): Promise<CliTypegenResult> {
+  const target = await resolveInstalledSdkTypegenTarget();
+  if (target === null) {
+    return {
+      written: false,
+      path: "",
+      serverPath: "",
+      publicPath: "",
+      manifestVersion: manifest.manifestVersion,
+    };
+  }
+
+  const [existingServerContents, existingPublicContents] = await Promise.all([
+    readTextFile(target.serverGeneratedTypesPath),
+    readTextFile(target.publicGeneratedTypesPath),
+  ]);
+  const rendered = renderGeneratedTypesForManifest(manifest, identity.typegenMode);
+
+  if (
+    existingServerContents === rendered.serverContents &&
+    existingPublicContents === rendered.publicContents &&
+    readManifestVersion(existingServerContents) === manifest.manifestVersion &&
+    readManifestVersion(existingPublicContents) === manifest.manifestVersion
+  ) {
+    await writeTextFileAtomic(
+      target.typegenMetadataPath,
+      buildTypegenMetadataContents(new Date(), identity),
+    );
+    return {
+      written: false,
+      path: target.serverGeneratedTypesPath,
+      serverPath: target.serverGeneratedTypesPath,
+      publicPath: target.publicGeneratedTypesPath,
+      manifestVersion: manifest.manifestVersion,
+    };
+  }
+
+  await Promise.all([
+    writeTextFileAtomic(target.serverGeneratedTypesPath, rendered.serverContents),
+    writeTextFileAtomic(target.publicGeneratedTypesPath, rendered.publicContents),
+  ]);
+  await writeTextFileAtomic(
+    target.typegenMetadataPath,
+    buildTypegenMetadataContents(new Date(), identity),
+  );
+
+  return {
+    written: true,
+    path: target.serverGeneratedTypesPath,
+    serverPath: target.serverGeneratedTypesPath,
+    publicPath: target.publicGeneratedTypesPath,
+    manifestVersion: manifest.manifestVersion,
+  };
+}

package/src/types.ts

@@ -4,11 +4,13 @@ export type CliCredentials = {
   accessTokenExpiresAtMs: number;
   refreshTokenExpiresAtMs: number;
   clerkUserId: string;
-  orgId: string;
-  orgSlug: string;
+  orgId: string | null;
+  orgSlug: string | null;
+  lastOrgId?: string | null;
+  lastOrgSlug?: string | null;
 };
 
 export type CliConfig = {
   baseUrl: string;
-  activeAccountId: string;
+  activeSessionId: string;
 };

package/test/command-utils.test.ts

@@ -0,0 +1,47 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { describe, expect, test } from "bun:test";
+
+import { resolveTarget } from "../src/command-utils";
+
+async function withWorkingDirectory<TValue>(
+  nextCwd: string,
+  fn: () => Promise<TValue>,
+): Promise<TValue> {
+  const previousCwd = process.cwd();
+  process.chdir(nextCwd);
+  try {
+    return await fn();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+
+describe("resolveTarget", () => {
+  test("does not fall back to stored org auth metadata when local repo context is missing", async () => {
+    const tempDir = await mkdtemp(path.join(tmpdir(), "barekey-cli-target-"));
+
+    await withWorkingDirectory(tempDir, async () => {
+      await expect(
+        resolveTarget(
+          {},
+          {
+            baseUrl: "https://api.barekey.dev",
+            accountId: "user_123",
+            credentials: {
+              accessToken: "token",
+              refreshToken: "refresh",
+              accessTokenExpiresAtMs: Date.now() + 60_000,
+              refreshTokenExpiresAtMs: Date.now() + 120_000,
+              clerkUserId: "user_123",
+              orgId: "org_123",
+              orgSlug: "should-not-be-used",
+            },
+          },
+        ),
+      ).rejects.toThrow("Run barekey init or pass --org/--project/--stage.");
+    });
+  });
+});

package/test/credentials-store.test.ts

@@ -0,0 +1,40 @@
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { describe, expect, test } from "bun:test";
+
+describe("loadConfig", () => {
+  test("migrates the legacy activeAccountId shape into activeSessionId", async () => {
+    const tempHome = await mkdtemp(path.join(tmpdir(), "barekey-cli-home-"));
+    const configDir = path.join(tempHome, ".config", "barekey");
+    await mkdir(configDir, {
+      recursive: true,
+    });
+    await writeFile(
+      path.join(configDir, "config.json"),
+      JSON.stringify({
+        baseUrl: "https://api.barekey.dev",
+        activeAccountId: "user_legacy",
+      }),
+      "utf8",
+    );
+
+    const previousHome = process.env.HOME;
+    process.env.HOME = tempHome;
+
+    try {
+      const module = await import(`../src/credentials-store.ts?case=${Date.now()}`);
+      await expect(module.loadConfig()).resolves.toEqual({
+        baseUrl: "https://api.barekey.dev",
+        activeSessionId: "user_legacy",
+      });
+    } finally {
+      if (previousHome === undefined) {
+        delete process.env.HOME;
+      } else {
+        process.env.HOME = previousHome;
+      }
+    }
+  });
+});