@barekey/cli 0.5.8 → 0.6.0

package/src/commands/typegen.ts

@@ -1,5 +1,4 @@
 import { Command } from "commander";
-import pc from "picocolors";
 
 import { createCliAuthProvider } from "../auth-provider.js";
 import {
@@ -15,22 +14,23 @@ import {
   type CliTypegenResult,
   writeInstalledSdkGeneratedTypes,
 } from "../typegen/core.js";
+import { accent, info, muted, strong, success, warning } from "../output/theme.js";
 
 const DEFAULT_TYPEGEN_WATCH_INTERVAL_MS = 5_000;
 
 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"));
+    ? success(strong("Typegen complete"))
+    : info(strong("Typegen already up to date"));
   const detail = result.written
     ? "Fresh SDK types are ready in your installed @barekey/sdk package."
     : "Your installed @barekey/sdk package already has the latest generated types.";
 
   return [
     title,
-    detail,
-    `${pc.bold("Server types")}: ${result.serverPath}`,
-    `${pc.bold("Public types")}: ${result.publicPath}`,
+    muted(detail),
+    `${accent("Server types")} ${muted(result.serverPath)}`,
+    `${accent("Public types")} ${muted(result.publicPath)}`,
   ].join("\n");
 }
 
@@ -41,9 +41,9 @@ export function formatTypegenWatchStartedMessage(input: {
   intervalMs: number;
 }): string {
   return [
-    pc.cyan(pc.bold("Watching Barekey typegen")),
-    `Target: ${pc.bold(`${input.organization}/${input.project}@${input.environment}`)}`,
-    `Polling every ${pc.bold(`${input.intervalMs}ms`)}. Press ${pc.bold("Ctrl+C")} to stop.`,
+    info(strong("Watching Barekey typegen")),
+    `${accent("Target")} ${strong(`${input.organization}/${input.project}@${input.environment}`)}`,
+    `${warning("Polling every")} ${strong(`${input.intervalMs}ms`)}${muted(". Press Ctrl+C to stop.")}`,
   ].join("\n");
 }
 
@@ -74,6 +74,7 @@ async function resolveTypegenContext(options: EnvTargetOptions): Promise<{
   environment: string;
   runtimeMode: "centralized" | "standalone";
   typegenMode: "semantic" | "minimal";
+  strictGeneratedKeys: boolean;
   localEnvRoot: string | null;
 }> {
   const runtime = await loadRuntimeConfig();
@@ -89,6 +90,7 @@ async function resolveTypegenContext(options: EnvTargetOptions): Promise<{
     environment: target.stageSlug.trim().length > 0 ? target.stageSlug : "local",
     runtimeMode: runtime?.config.config?.mode ?? "centralized",
     typegenMode: runtime?.config.config?.typegen ?? "semantic",
+    strictGeneratedKeys: runtime?.config.config?.strictGeneratedKeys ?? false,
     localEnvRoot: runtime?.path ?? null,
   };
 }
@@ -126,6 +128,7 @@ async function runTypegen(options: EnvTargetOptions): Promise<void> {
     projectSlug: context.project,
     stageSlug: context.environment,
     typegenMode: context.typegenMode,
+    strictGeneratedKeys: context.strictGeneratedKeys,
     runtimeMode: context.runtimeMode,
     localEnvRoot: context.localEnvRoot,
   });
@@ -167,6 +170,7 @@ async function runTypegenWatch(
         projectSlug: nextContext.project,
         stageSlug: nextContext.environment,
         typegenMode: nextContext.typegenMode,
+        strictGeneratedKeys: nextContext.strictGeneratedKeys,
         runtimeMode: nextContext.runtimeMode,
         localEnvRoot: nextContext.localEnvRoot,
       });

package/src/contracts/index.ts

@@ -26,6 +26,7 @@ export const RuntimeConfigSchema = Schema.Struct({
   config: Schema.optional(
     Schema.Struct({
       typegen: Schema.optional(TypegenModeSchema),
+      strictGeneratedKeys: Schema.optional(Schema.Boolean),
       mode: Schema.optional(RuntimeModeSchema),
     }),
   ),

package/src/index.ts

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import pc from "picocolors";
 
 import { registerAuthCommands } from "./commands/auth.js";
 import { registerAuditCommands } from "./commands/audit.js";
@@ -12,9 +11,14 @@ import { registerProjectCommands } from "./commands/project.js";
 import { registerStageCommands } from "./commands/stage.js";
 import { registerTypegenCommand } from "./commands/typegen.js";
 import { CLI_DESCRIPTION, CLI_NAME, CLI_VERSION } from "./constants.js";
+import { danger } from "./output/theme.js";
 
 const program = new Command();
 program.name(CLI_NAME).description(CLI_DESCRIPTION).version(CLI_VERSION);
+program.configureOutput({
+  writeErr: (message) => process.stderr.write(message),
+  outputError: (message, write) => write(danger(message)),
+});
 
 registerAuthCommands(program);
 registerAuditCommands(program);
@@ -28,6 +32,6 @@ registerTypegenCommand(program);
 
 program.parseAsync(process.argv).catch((error: unknown) => {
   const message = error instanceof Error ? error.message : "Command failed.";
-  console.error(pc.red(message));
+  console.error(danger(message));
   process.exitCode = 1;
 });

package/src/output/theme.ts

@@ -0,0 +1,166 @@
+import pc from "picocolors";
+
+const MINECRAFT_HEX = {
+  "1": "#0000AA",
+  "6": "#FFAA00",
+  "7": "#AAAAAA",
+  "8": "#555555",
+  "a": "#55FF55",
+  "b": "#55FFFF",
+  "c": "#FF5555",
+  "e": "#FFFF55",
+} as const;
+
+type MinecraftColorCode = keyof typeof MINECRAFT_HEX;
+
+/**
+ * Returns whether styled terminal output should be emitted.
+ *
+ * @returns `true` when stdout is interactive and color has not been disabled.
+ * @remarks This keeps human output colorful while preserving clean automation output in dumb/no-color terminals.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function supportsCliColor(): boolean {
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+
+  if ((process.env.NO_COLOR ?? "").trim().length > 0) {
+    return false;
+  }
+
+  return (process.env.TERM ?? "").toLowerCase() !== "dumb";
+}
+
+function hexToRgb(hex: string): { red: number; green: number; blue: number } {
+  const normalized = hex.replace(/^#/, "");
+  return {
+    red: Number.parseInt(normalized.slice(0, 2), 16),
+    green: Number.parseInt(normalized.slice(2, 4), 16),
+    blue: Number.parseInt(normalized.slice(4, 6), 16),
+  };
+}
+
+/**
+ * Applies one Minecraft-style truecolor swatch to a string.
+ *
+ * @param code The legacy Minecraft color code to emulate.
+ * @param value The text to colorize.
+ * @returns The styled string, or the original text when colors are disabled.
+ * @remarks This uses truecolor ANSI so the palette stays stable across modern terminals.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function mc(code: MinecraftColorCode, value: string): string {
+  if (!supportsCliColor()) {
+    return value;
+  }
+
+  const { red, green, blue } = hexToRgb(MINECRAFT_HEX[code]);
+  return `\u001b[38;2;${red};${green};${blue}m${value}\u001b[39m`;
+}
+
+/**
+ * Styles one primary CLI label.
+ *
+ * @param value The label text.
+ * @returns The highlighted label.
+ * @remarks Gold is used as the main CLI accent color.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function accent(value: string): string {
+  return mc("6", value);
+}
+
+/**
+ * Styles one positive/success string.
+ *
+ * @param value The text to colorize.
+ * @returns The success-colored string.
+ * @remarks Green is used for successful actions and positive counts.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function success(value: string): string {
+  return mc("a", value);
+}
+
+/**
+ * Styles one informational string.
+ *
+ * @param value The text to colorize.
+ * @returns The info-colored string.
+ * @remarks Aqua is used for list metadata and secondary highlights.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function info(value: string): string {
+  return mc("b", value);
+}
+
+/**
+ * Styles one warning string.
+ *
+ * @param value The text to colorize.
+ * @returns The warning-colored string.
+ * @remarks Bright yellow is used for cautionary or count summary output.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function warning(value: string): string {
+  return mc("e", value);
+}
+
+/**
+ * Styles one muted metadata string.
+ *
+ * @param value The text to colorize.
+ * @returns The muted string.
+ * @remarks Gray is used for low-emphasis metadata like slugs and file paths.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function muted(value: string): string {
+  return mc("7", value);
+}
+
+/**
+ * Styles one subtle low-contrast string.
+ *
+ * @param value The text to colorize.
+ * @returns The subtle string.
+ * @remarks Dark gray is used for separators, labels, and empty-state output.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function subtle(value: string): string {
+  return mc("8", value);
+}
+
+/**
+ * Styles one failure/error string.
+ *
+ * @param value The text to colorize.
+ * @returns The danger-colored string.
+ * @remarks Red is reserved for errors and destructive outcomes.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function danger(value: string): string {
+  return mc("c", value);
+}
+
+/**
+ * Styles one prominent value with bold emphasis.
+ *
+ * @param value The text to emphasize.
+ * @returns The bold string.
+ * @remarks This intentionally leaves color choice to the caller.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function strong(value: string): string {
+  return pc.bold(value);
+}

package/src/runtime-config.ts

@@ -10,6 +10,7 @@ export type BarekeyRuntimeConfig = {
   environment?: string;
   config?: {
     typegen?: "semantic" | "minimal";
+    strictGeneratedKeys?: boolean;
     mode?: "centralized" | "standalone";
   };
 };
@@ -61,6 +62,7 @@ export async function loadRuntimeConfig(): Promise<BarekeyRuntimeConfigResult |
   const mode = config?.mode ?? "centralized";
   const typegen =
     mode === "standalone" ? "minimal" : (config?.typegen ?? decoded.right.typegen ?? "semantic");
+  const strictGeneratedKeys = config?.strictGeneratedKeys ?? false;
 
   return {
     path: configPath,
@@ -71,6 +73,7 @@ export async function loadRuntimeConfig(): Promise<BarekeyRuntimeConfigResult |
       config: {
         mode,
         typegen,
+        strictGeneratedKeys,
       },
     },
   };

package/src/typegen/core.ts

@@ -8,6 +8,7 @@ import { TypegenManifestSchema, type TypegenManifest } from "../contracts/index.
 
 export type CliTypegenMode = "semantic" | "minimal";
 export type CliRuntimeMode = "centralized" | "standalone";
+export type CliStrictGeneratedKeys = boolean;
 
 export type CliTypegenResult = {
   written: boolean;
@@ -23,6 +24,7 @@ type TypegenIdentity = {
   projectSlug: string;
   stageSlug: string;
   typegenMode: CliTypegenMode;
+  strictGeneratedKeys: CliStrictGeneratedKeys;
   runtimeMode: CliRuntimeMode;
   localEnvRoot: string | null;
 };
@@ -37,6 +39,7 @@ const TypegenMetadataSchema = Schema.Struct({
   projectSlug: Schema.NullOr(Schema.String),
   stageSlug: Schema.NullOr(Schema.String),
   typegenMode: Schema.NullOr(Schema.Literal("semantic", "minimal")),
+  strictGeneratedKeys: Schema.Boolean,
   runtimeMode: Schema.NullOr(Schema.Literal("centralized", "standalone")),
   localEnvRoot: Schema.NullOr(Schema.String),
 });
@@ -93,9 +96,11 @@ function buildGeneratedTypesContents(
   manifest: TypegenManifest,
   input: {
     mode: CliTypegenMode;
+    strictGeneratedKeys: CliStrictGeneratedKeys;
     typeModulePath: "./dist/types.js" | "./dist/public-types.js";
     declaredModulePath: "./dist/types.js" | "./dist/public-types.js";
     interfaceName: "BarekeyGeneratedTypeMap" | "BarekeyPublicGeneratedTypeMap";
+    configInterfaceName: "BarekeyGeneratedTypeConfig" | "BarekeyPublicGeneratedTypeConfig";
     include: (row: TypegenManifest["variables"][number]) => boolean;
   },
 ): string {
@@ -111,7 +116,7 @@ function buildGeneratedTypesContents(
       ? `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`;
+  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  interface ${input.configInterfaceName} {\n    allowUnknownKeys: ${input.strictGeneratedKeys ? "false" : "true"};\n  }\n}\n\nexport {};\n`;
 }
 
 function readManifestVersion(contents: string | null): string | null {
@@ -197,6 +202,7 @@ function buildTypegenMetadataContents(lastGeneratedAt: Date, identity: TypegenId
       projectSlug: identity.projectSlug,
       stageSlug: identity.stageSlug,
       typegenMode: identity.typegenMode,
+      strictGeneratedKeys: identity.strictGeneratedKeys,
       runtimeMode: identity.runtimeMode,
       localEnvRoot: identity.localEnvRoot,
     },
@@ -218,6 +224,7 @@ function buildTypegenMetadataContents(lastGeneratedAt: Date, identity: TypegenId
 export function renderGeneratedTypesForManifest(
   manifest: TypegenManifest,
   mode: CliTypegenMode,
+  strictGeneratedKeys = false,
 ): {
   serverContents: string;
   publicContents: string;
@@ -227,16 +234,20 @@ export function renderGeneratedTypesForManifest(
   return {
     serverContents: buildGeneratedTypesContents(decodedManifest, {
       mode,
+      strictGeneratedKeys,
       typeModulePath: "./dist/types.js",
       declaredModulePath: "./dist/types.js",
       interfaceName: "BarekeyGeneratedTypeMap",
+      configInterfaceName: "BarekeyGeneratedTypeConfig",
       include: () => true,
     }),
     publicContents: buildGeneratedTypesContents(decodedManifest, {
       mode,
+      strictGeneratedKeys,
       typeModulePath: "./dist/public-types.js",
       declaredModulePath: "./dist/public-types.js",
       interfaceName: "BarekeyPublicGeneratedTypeMap",
+      configInterfaceName: "BarekeyPublicGeneratedTypeConfig",
       include: (row) => row.visibility === "public",
     }),
   };
@@ -271,7 +282,11 @@ export async function writeInstalledSdkGeneratedTypes(
     readTextFile(target.serverGeneratedTypesPath),
     readTextFile(target.publicGeneratedTypesPath),
   ]);
-  const rendered = renderGeneratedTypesForManifest(manifest, identity.typegenMode);
+  const rendered = renderGeneratedTypesForManifest(
+    manifest,
+    identity.typegenMode,
+    identity.strictGeneratedKeys,
+  );
 
   if (
     existingServerContents === rendered.serverContents &&

package/test/runtime-config.test.ts

@@ -86,6 +86,37 @@ describe("loadRuntimeConfig", () => {
           config: {
             mode: "centralized",
             typegen: "semantic",
+            strictGeneratedKeys: false,
+          },
+        },
+      });
+    });
+  });
+
+  test("reads config.strictGeneratedKeys when present", async () => {
+    const tempDir = await createTempDir();
+    await writeFile(
+      path.join(tempDir, "barekey.json"),
+      JSON.stringify(
+        {
+          organization: "acme",
+          project: "api",
+          environment: "development",
+          config: {
+            strictGeneratedKeys: true,
+          },
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    );
+
+    await withWorkingDirectory(tempDir, async () => {
+      await expect(loadRuntimeConfig()).resolves.toMatchObject({
+        config: {
+          config: {
+            strictGeneratedKeys: true,
           },
         },
       });