bazis 0.105.1 → 0.105.3

package/cli/main.ts

@@ -6,7 +6,7 @@ import { parseCliArgs, type ParsedGenerateArgs } from "./parseCli";
 import { runCodegen, type CodegenOptions } from "./codegen";
 import { generateProject } from "./generateProject";
 import { runBuild, runDev, runTest } from "./build";
-import { commandFailed, commandHeader, createScreens, lineOutput, type CliOutput } from "./ui";
+import { bazisVersion, commandFailed, commandHeader, createScreens, lineOutput, requiredBun, type CliOutput } from "./ui";
 
 export const USAGE = `Usage:
   bazis new <Name> [options]                  Create a new application project
@@ -21,6 +21,7 @@ export const USAGE = `Usage:
   bazis build --bin [--outfile <path>]        Also compile a standalone executable (default bin/<name>)
   bazis build --bin --dotenv                  The executable also reads .env files from its working directory
   bazis --help
+  bazis --version                             Print the bazis version (also -v)
   g can also be written as generate.
   --lang <en|ru> sets the output language (also BAZIS_LANG, "language" in bazis.config.json).
 
@@ -72,6 +73,8 @@ export interface CliRuntime {
   readonly stderr?: ScreenOutput;
   /** Output language when `--lang` is not given; detected from the environment otherwise. */
   readonly language?: Language;
+  /** The running Bun: version and executable (default: this process). */
+  readonly bun?: { readonly version: string; readonly path: string };
 }
 
 const defaultRuntime: CliRuntime = {
@@ -107,6 +110,18 @@ export async function runCli(argv: readonly string[], runtime: CliRuntime = defa
     runtime.log(USAGE.trim());
     return parsed.help ? 0 : 1;
   }
+  if (parsed.kind === "version") {
+    runtime.log(bazisVersion());
+    return 0;
+  }
+  // `#!/usr/bin/env bun` runs the CLI on the first bun in PATH, which may be
+  // older than the one the user called; stop before it fails somewhere later.
+  const bun = runtime.bun ?? { version: Bun.version, path: process.execPath };
+  const required = requiredBun();
+  if (required !== undefined && !Bun.semver.satisfies(bun.version, required)) {
+    const t = ui.err.t.errors;
+    return commandFailed(ui.err, ui.err.t.failure.command, [{ tag: "BUN", where: bun.path, cause: t.bunTooOld(required, bun.version), fixes: [t.bunWhich(bun.path), t.bunUpgrade] }], 1);
+  }
   if (parsed.kind === "error") {
     return commandFailed(ui.err, ui.err.t.failure.command, [{ tag: "CLI", where: "bazis", cause: parsed.message, fixes: [ui.err.t.errors.unknown] }], 1);
   }

package/cli/parseCli.ts

@@ -20,6 +20,7 @@ export interface ParsedGenerateArgs {
 
 export type ParseCliResult =
   | { readonly kind: "help"; readonly help: boolean }
+  | { readonly kind: "version" }
   | { readonly kind: "new"; readonly name: string; readonly outputPath?: string; readonly frameworkPath?: string; readonly linkFramework: boolean; readonly vendor: boolean; readonly dryRun: boolean }
   | { readonly kind: "generate"; readonly args: ParsedGenerateArgs }
   | { readonly kind: "codegen"; readonly target?: string }
@@ -38,6 +39,7 @@ const FLAG_OPTIONS = new Set(["--no-register", "--force", "--full", "--enterpris
 /** Parsing is pure: help and invalid input can never start generation. */
 export function parseCliArgs(argv: readonly string[]): ParseCliResult {
   if (argv.some((arg) => arg === "--help" || arg === "-h")) return { kind: "help", help: true };
+  if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) return { kind: "version" };
   if (argv.length === 0) return { kind: "help", help: false };
   // Everything after `test` (or `test --`) belongs to `bun test`.
   if (argv[0] === "test") return { kind: "test", args: argv[1] === "--" ? argv.slice(2) : argv.slice(1) };

package/cli/ui.ts

@@ -37,18 +37,28 @@ export function projectInfo(cwd: string): { name?: string; version?: string } {
   }
 }
 
-/** Version of the bazis package this CLI belongs to. */
-export function bazisVersion(): string {
+function bazisPackage(): { version?: unknown; engines?: { bun?: unknown } } | undefined {
   try {
     const file = fileURLToPath(new URL("../package.json", import.meta.url));
-    if (!existsSync(file)) return "?";
-    const version = (JSON.parse(readFileSync(file, "utf8")) as { version?: unknown }).version;
-    return typeof version === "string" ? version : "?";
+    if (!existsSync(file)) return undefined;
+    return JSON.parse(readFileSync(file, "utf8")) as { version?: unknown; engines?: { bun?: unknown } };
   } catch {
-    return "?";
+    return undefined;
   }
 }
 
+/** Version of the bazis package this CLI belongs to. */
+export function bazisVersion(): string {
+  const version = bazisPackage()?.version;
+  return typeof version === "string" ? version : "?";
+}
+
+/** The Bun range the package declares in `engines` (`>=1.4.0`). */
+export function requiredBun(): string | undefined {
+  const range = bazisPackage()?.engines?.bun;
+  return typeof range === "string" ? range : undefined;
+}
+
 /** The logo with the command badge: project, versions, and the command's own facts. */
 export function commandHeader(screen: Screen, mode: keyof typeof MODE, cwd: string, facts: readonly string[], project = projectInfo(cwd)): void {
   screen.header(mode, MODE[mode], [

package/core/app/runApp.ts

@@ -21,6 +21,7 @@ import {
 } from "../../library/ui";
 import { modelValidatorAdapter } from "../../library/validation";
 import { createLocalize, type AppLanguage, type AppMessages } from "./messages";
+import { useCodexLanguage } from "../infra/connectors/codex/contracts";
 import {
   type RunAppUiOptions,
   type RunAppUiSurfaceOptions,
@@ -290,6 +291,7 @@ export async function runApp(root: BazisModuleRef, options: RunAppOptions = {}):
 export function composeApp(root: BazisModuleRef, options: RunAppOptions = {}): BazisModuleRef {
   // Checked even without HTTP: an unknown language is a startup error.
   const localize = createLocalize(options.language, options.messages);
+  useCodexLanguage(options.language ?? "en");
   // Infrastructure and cache are global modules; add them to the graph next to the feature root.
   const globals: BazisModuleRef[] = [];
   if (options.infra !== undefined) {

package/core/di/internal/GraphValidator.ts

@@ -1,6 +1,6 @@
 import { ServiceValidationError } from "../errors";
 import { missingNamedDependencyIssue } from "../errors/NamedDependencyNotFoundError";
-import { isLazyDependency, isNamedDependency, isOptionalDependency } from "../provider";
+import { isClassProvider, isLazyDependency, isNamedDependency, isOptionalDependency } from "../provider";
 import type {
   KeyedDependency,
   NamedDependency,
@@ -99,7 +99,7 @@ export class GraphValidator {
         const inner = isLazy || isOptional ? dependency.inner : dependency;
         // An optional dependency on a name nothing registered is simply absent.
         if (isNamedDependency(inner) && !this.context.hasName(inner.name)) {
-          if (!isOptional) issues.add(missingNamedDependencyIssue(inner.name, tokenToDebugName(registration.token)));
+          if (!isOptional) issues.add(missingNamedDependencyIssue(inner.name, serviceName(registration)));
           continue;
         }
         const descriptor = this.context.describeDependency(inner);
@@ -109,15 +109,15 @@ export class GraphValidator {
         }
         if (!depRegistration) {
           issues.add(
-            `Missing dependency "${tokenToDebugName(descriptor.token)}" for "${tokenToDebugName(registration.token)}"`,
+            `Missing dependency "${tokenToDebugName(descriptor.token)}" for "${serviceName(registration)}"`,
           );
           continue;
         }
 
         if (this.context.validateScopes && rootLifetime === "singleton" && depRegistration.lifetime === "scoped") {
           issues.add(
-            `Singleton "${tokenToDebugName(registration.token)}" depends on scoped "${tokenToDebugName(descriptor.token)}". `
-              + `A scoped service lives for one request or scope: make "${tokenToDebugName(registration.token)}" scoped too, `
+            `Singleton "${serviceName(registration)}" depends on scoped "${tokenToDebugName(descriptor.token)}". `
+              + `A scoped service lives for one request or scope: make "${className(registration) ?? tokenToDebugName(registration.token)}" scoped too, `
               + `or inject ServiceProvider and resolve "${tokenToDebugName(descriptor.token)}" in a scope you create (provider.createScope()).`,
           );
         }
@@ -136,3 +136,17 @@ export class GraphValidator {
     }
   }
 }
+
+/** The class behind a token registration, when it is not the token itself: `singleton(LIFECYCLE_HOOK, WarmUp)`. */
+function className(registration: ServiceRegistration): string | undefined {
+  if (!isClassProvider(registration.provider)) return undefined;
+  const name = registration.provider.useClass.name;
+  return name && name !== tokenToDebugName(registration.token) ? name : undefined;
+}
+
+/** `WarmUp (as BazisLifecycleHook)` for a class under a token, else the token. */
+function serviceName(registration: ServiceRegistration): string {
+  const token = tokenToDebugName(registration.token);
+  const name = className(registration);
+  return name ? `${name} (as ${token})` : token;
+}

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.105.1" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.105.3" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/core/infra/connectors/codex/contracts.ts

@@ -52,7 +52,7 @@ const EN_CODEX_MESSAGES: Readonly<Record<CodexErrorCode, string>> = Object.freez
   LOGIN_EXPIRED: "The sign-in window expired. Start signing in again.",
 });
 
-/** Russian texts for every code: `CodexError.useMessages(RU_CODEX_MESSAGES)` at startup. */
+/** Russian texts for every code; `runApp({ language: "ru" })` turns them on. */
 export const RU_CODEX_MESSAGES: Readonly<Record<CodexErrorCode, string>> = Object.freeze({
   NOT_CONFIGURED: "Подключение ChatGPT не настроено на сервере.",
   UNAVAILABLE: "Codex App Server недоступен. Проверьте его установку и настройки.",
@@ -67,15 +67,31 @@ export const RU_CODEX_MESSAGES: Readonly<Record<CodexErrorCode, string>> = Objec
   LOGIN_EXPIRED: "Время для входа истекло. Начните вход заново.",
 });
 
+const CODEX_LANGUAGES = { en: EN_CODEX_MESSAGES, ru: RU_CODEX_MESSAGES } as const;
+let language: Readonly<Record<CodexErrorCode, string>> = EN_CODEX_MESSAGES;
+let own: Partial<Record<CodexErrorCode, string>> = {};
 let messages: Readonly<Record<CodexErrorCode, string>> = EN_CODEX_MESSAGES;
 
-/** `message` is user-facing text for `code`; switch its language with `useMessages`. */
+/**
+ * @internal `runApp({ language })` sets the language of the texts. It is
+ * process-wide, like the texts themselves: the last started application wins.
+ */
+export function useCodexLanguage(name: keyof typeof CODEX_LANGUAGES): void {
+  language = CODEX_LANGUAGES[name];
+  messages = Object.freeze({ ...language, ...own });
+}
+
+/** `message` is user-facing text for `code`, in the language of `runApp({ language })`. */
 export class CodexError extends Error {
   constructor(readonly code: CodexErrorCode) { super(messages[code]); this.name = "CodexError"; }
 
-  /** Replace texts for some or all codes (process-wide); missing codes keep English. */
+  /**
+   * Own texts for some or all codes (process-wide), on top of the application
+   * language; missing codes keep it. `useMessages({})` drops own texts.
+   */
   static useMessages(overrides: Partial<Record<CodexErrorCode, string>>): void {
-    messages = Object.freeze({ ...EN_CODEX_MESSAGES, ...overrides });
+    own = { ...overrides };
+    messages = Object.freeze({ ...language, ...own });
   }
 }
 export const CODEX_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,120}$/;

package/library/terminal/messages.ts

@@ -238,6 +238,9 @@ const en = {
   },
   errors: {
     unknown: "Use bazis --help to list commands and options.",
+    bunTooOld: (required: string, actual: string) => `bazis needs Bun ${required.startsWith(">=") ? `${required.slice(2).trim()} or newer` : required}; this is Bun ${actual}.`,
+    bunWhich: (file: string) => `This Bun is ${file}. bunx bazis and bun run scripts start bazis with the first bun in PATH, not with the Bun that called them.`,
+    bunUpgrade: "Update that Bun: bun upgrade. Or put the newer Bun first in PATH.",
   },
 };
 
@@ -397,6 +400,9 @@ const ru: Messages = {
   },
   errors: {
     unknown: "Список команд и опций: bazis --help.",
+    bunTooOld: (required, actual) => `bazis нужен Bun ${required.startsWith(">=") ? `${required.slice(2).trim()} или новее` : required}, а запущен Bun ${actual}.`,
+    bunWhich: (file) => `Запущен ${file}. bunx bazis и скрипты bun run запускают bazis первым bun из PATH, а не тем Bun, который их вызвал.`,
+    bunUpgrade: "Обновите этот Bun: bun upgrade. Или поставьте новый Bun первым в PATH.",
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.105.1",
+  "version": "0.105.3",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",