fix: source app version from cli package

pallyoung · pallyoung · commit 02ba250c2d73 · 2026-05-07T16:46:37.000+08:00
diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts
@@ -1,11 +1,12 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { clearAuthBlockByIp, listAuthBlocks } from "./auth-control.js";
 import { openBrowser } from "./browser.js";
 import { type CliConfig, readCliConfig, writeCliConfig } from "./config-store.js";
 import { readLogExcerpt } from "./log-excerpt.js";
 import { assertSupportedNodeVersion } from "./node-version.js";
+import { getCliVersion } from "./package-manifest.js";
 import { parseArgs } from "./parse-args.js";
 import { startManagedServer } from "./pm2-control.js";
 import { confirmYesNo, isInteractiveSession } from "./prompts.js";
@@ -133,16 +134,7 @@ EXAMPLES:
 }
 
 function showVersion(): void {
-  const manifestPath = [
-    new URL("../package.json", import.meta.url),
-    new URL("../../package.json", import.meta.url),
-  ].find((candidate) => existsSync(candidate));
-  if (!manifestPath) {
-    throw new Error("Unable to locate CLI package.json");
-  }
-  const manifest = JSON.parse(readFileSync(manifestPath, "utf-8")) as { version?: string };
-  const version = manifest.version ?? "0.0.0";
-  console.log(`@spencer-kit/coder-studio v${version}`);
+  console.log(`@spencer-kit/coder-studio v${getCliVersion(import.meta.url)}`);
 }
 
 function formatAuthBlocks(blocks: Awaited<ReturnType<typeof listAuthBlocks>>): string {
diff --git a/packages/cli/src/package-manifest.test.ts b/packages/cli/src/package-manifest.test.ts
@@ -1,5 +1,7 @@
 import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
 import { describe, expect, it } from "vitest";
+import { getCliVersion, resolveCliPackageManifestUrl } from "./package-manifest.js";
 
 interface PackageManifest {
   dependencies?: Record<string, string>;
@@ -12,6 +14,18 @@ function readPackageManifest(relativePath: string): PackageManifest {
 }
 
 describe("cli package manifest", () => {
+  it("resolves the CLI package manifest instead of the workspace root manifest", () => {
+    expect(fileURLToPath(resolveCliPackageManifestUrl(import.meta.url))).toBe(
+      fileURLToPath(new URL("../package.json", import.meta.url))
+    );
+  });
+
+  it("reads the published CLI version from the CLI package manifest", () => {
+    const cliPackage = readPackageManifest("../package.json") as { version?: string };
+
+    expect(getCliVersion(import.meta.url)).toBe(cliPackage.version);
+  });
+
   it("declares every external server runtime dependency", () => {
     const cliPackage = readPackageManifest("../package.json");
     const serverPackage = readPackageManifest("../../server/package.json");
diff --git a/packages/cli/src/package-manifest.ts b/packages/cli/src/package-manifest.ts
@@ -0,0 +1,28 @@
+import { existsSync, readFileSync } from "fs";
+
+interface CliPackageManifest {
+  version?: string;
+}
+
+export function resolveCliPackageManifestUrl(importMetaUrl: string): URL {
+  const manifestUrl = [
+    new URL("../package.json", importMetaUrl),
+    new URL("../../package.json", importMetaUrl),
+  ].find((candidate) => existsSync(candidate));
+
+  if (!manifestUrl) {
+    throw new Error("Unable to locate CLI package.json");
+  }
+
+  return manifestUrl;
+}
+
+export function getCliPackageManifest(importMetaUrl: string): CliPackageManifest {
+  return JSON.parse(
+    readFileSync(resolveCliPackageManifestUrl(importMetaUrl), "utf-8")
+  ) as CliPackageManifest;
+}
+
+export function getCliVersion(importMetaUrl: string): string {
+  return getCliPackageManifest(importMetaUrl).version ?? "0.0.0";
+}
diff --git a/packages/cli/src/server-runner.test.ts b/packages/cli/src/server-runner.test.ts
@@ -1,5 +1,6 @@
 import { fileURLToPath } from "url";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { getCliVersion } from "./package-manifest.js";
 
 const { createServer, readCliConfig, hasWebAssets, getStaticAssetsDir } = vi.hoisted(() => ({
   createServer: vi.fn(),
@@ -29,6 +30,17 @@ describe("server-runner", () => {
     vi.clearAllMocks();
   });
 
+  it("includes the CLI package version in the server config", () => {
+    readCliConfig.mockReturnValue(null);
+    hasWebAssets.mockReturnValue(true);
+    getStaticAssetsDir.mockReturnValue("/tmp/web");
+
+    expect(buildServerConfig()).toMatchObject({
+      appVersion: getCliVersion(import.meta.url),
+      webRoot: "/tmp/web",
+    });
+  });
+
   it("ignores ephemeral port zero from saved cli config", () => {
     readCliConfig.mockReturnValue({
       host: "127.0.0.1",
@@ -40,6 +52,7 @@ describe("server-runner", () => {
     getStaticAssetsDir.mockReturnValue("/tmp/web");
 
     expect(buildServerConfig()).toEqual({
+      appVersion: getCliVersion(import.meta.url),
       host: "127.0.0.1",
       dataDir: "/tmp/cs-data/coder-studio.db",
       auth: {
@@ -67,6 +80,7 @@ describe("server-runner", () => {
     const runningServer = await startServer();
 
     expect(createServer).toHaveBeenCalledWith({
+      appVersion: getCliVersion(import.meta.url),
       host: "127.0.0.1",
       port: 4173,
       webRoot: "/tmp/web",
diff --git a/packages/cli/src/server-runner.ts b/packages/cli/src/server-runner.ts
@@ -3,12 +3,14 @@ import { fileURLToPath } from "url";
 import { readCliConfig } from "./config-store.js";
 import { getStaticAssetsDir, hasWebAssets } from "./embed.js";
 import { assertSupportedNodeVersion } from "./node-version.js";
+import { getCliVersion } from "./package-manifest.js";
 
 const MISSING_WEB_ASSETS_WARNING = "Warning: Web assets not found. Frontend will not be available.";
 
 export const buildServerConfig = (): Partial<ServerConfig> => {
   const savedConfig = readCliConfig();
   const config: Partial<ServerConfig> = {
+    appVersion: getCliVersion(import.meta.url),
     ...(savedConfig?.host !== undefined ? { host: savedConfig.host } : {}),
     ...(savedConfig?.port !== undefined && savedConfig.port > 0 ? { port: savedConfig.port } : {}),
     ...(savedConfig?.dataDir !== undefined ? { dataDir: savedConfig.dataDir } : {}),
diff --git a/packages/server/src/__tests__/ws-hub.test.ts b/packages/server/src/__tests__/ws-hub.test.ts
@@ -36,8 +36,9 @@ type MessageHandler = ((data: Buffer, isBinary?: boolean) => void) | undefined;
 
 type ResultMessage = Extract<ServerToClient, { kind: "result" }>;
 
-const TEST_CONFIG: Pick<ServerConfig, "auth"> = {
+const TEST_CONFIG: Pick<ServerConfig, "auth" | "appVersion"> = {
   auth: { enabled: false },
+  appVersion: "0.3.0",
 };
 
 const createMockSocket = (): MockSocket => ({
@@ -123,11 +124,21 @@ describe("WsHub", () => {
     eventBus.clear();
   });
 
-  it("should accept first connection as writer", () => {
+  it("sends connection metadata including the CLI version on connect", () => {
     const socket = createMockSocket();
     hub.handleConnection(socket as never, createMockRequest());
 
-    expect(socket.send).toHaveBeenCalledWith(expect.stringContaining("connected"));
+    const sentEvents = parseSentEvents(socket);
+    expect(sentEvents[0]).toMatchObject({
+      kind: "event",
+      topic: "connection.status",
+      data: expect.objectContaining({
+        status: "connected",
+        version: "0.3.0",
+        serverInstanceId: expect.stringMatching(/^server-\d+$/),
+        isWriter: false,
+      }),
+    });
   });
 
   it("should accept multiple connections (writer tracking moved to FencingManager)", () => {
diff --git a/packages/server/src/config.test.ts b/packages/server/src/config.test.ts
@@ -26,6 +26,20 @@ describe("parseServerConfig", () => {
     expect(config.port).toBe(8080);
   });
 
+  it("defaults appVersion to the CLI package version", () => {
+    delete process.env.CODER_STUDIO_APP_VERSION;
+
+    const config = parseServerConfig();
+
+    expect(config.appVersion).toBe("0.3.0");
+  });
+
+  it("prefers explicit appVersion override over inferred CLI version", () => {
+    const config = parseServerConfig({ appVersion: "9.9.9" });
+
+    expect(config.appVersion).toBe("9.9.9");
+  });
+
   it("uses the temp sqlite file by default outside production", () => {
     delete process.env.NODE_ENV;
     delete process.env.DATA_DIR;
diff --git a/packages/server/src/config.ts b/packages/server/src/config.ts
@@ -19,13 +19,15 @@ export interface ServerConfig {
   uploadsDir: string;
   logLevel: "trace" | "debug" | "info" | "warn" | "error";
   webRoot?: string;
+  appVersion?: string;
   auth: {
     enabled: boolean;
     password?: string;
   };
 }
 
 let cachedTestUploadsDir: string | undefined;
+let cachedAppVersion: string | undefined;
 
 function parseLogLevel(value: string | undefined): ServerConfig["logLevel"] | undefined {
   switch (value) {
@@ -40,6 +42,30 @@ function parseLogLevel(value: string | undefined): ServerConfig["logLevel"] | un
   }
 }
 
+function resolveDefaultAppVersion(): string {
+  if (cachedAppVersion) {
+    return cachedAppVersion;
+  }
+
+  const packageJsonPath = [path.resolve(__dirname, "../../cli/package.json")].find((candidate) =>
+    fs.existsSync(candidate)
+  );
+
+  if (!packageJsonPath) {
+    cachedAppVersion = "0.0.0";
+    return cachedAppVersion;
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as { version?: unknown };
+    cachedAppVersion = typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    cachedAppVersion = "0.0.0";
+  }
+
+  return cachedAppVersion;
+}
+
 /**
  * Resolve the database file path.
  *
@@ -96,6 +122,8 @@ export function parseServerConfig(overrides?: Partial<ServerConfig>): ServerConf
     uploadsDir,
     logLevel: overrides?.logLevel ?? parseLogLevel(process.env.LOG_LEVEL) ?? "info",
     webRoot: overrides?.webRoot,
+    appVersion:
+      overrides?.appVersion ?? process.env.CODER_STUDIO_APP_VERSION ?? resolveDefaultAppVersion(),
     auth: overrides?.auth || {
       enabled: !noAuth && !!password,
       password,
diff --git a/packages/server/src/ws/hub.ts b/packages/server/src/ws/hub.ts
@@ -92,12 +92,16 @@ export class WsHub implements Broadcaster {
     const client = new WsClient(socket, uuidv4(), this.deps.logger);
     this.clients.set(client.id, client);
 
-    // Send connection ready (controller status determined later by fencing.request command)
+    // Send initial connection metadata. Writer status is established later by
+    // fencing.request, but the UI still needs the app version immediately.
     client.sendEvent("connection.status", {
       status: "connected",
       clientId: client.id,
       authEnabled: this.deps.config.auth.enabled,
       binaryTerminalTransport: true,
+      version: this.deps.config.appVersion ?? "0.0.0",
+      serverInstanceId: `server-${process.pid}`,
+      isWriter: false,
     });
 
     // Setup handlers
diff --git a/packages/web/src/app/providers.test.tsx b/packages/web/src/app/providers.test.tsx
@@ -1,7 +1,7 @@
 import type { Supervisor, SupervisorCycle } from "@coder-studio/core";
 import { createStore } from "jotai";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { sessionsAtom } from "../atoms";
+import { isWriterAtom, serverInfoAtom, sessionsAtom } from "../atoms";
 import {
   activeWorkspaceAtom,
   activeWorkspaceIdAtom,
@@ -63,6 +63,29 @@ describe("routeEventToAtom", () => {
     expect(store.get(supervisorCyclesAtom).size).toBe(0);
   });
 
+  it("stores server metadata from the initial connected status event", () => {
+    const store = createStore();
+
+    routeEventToAtom(
+      "connection.status",
+      {
+        status: "connected",
+        authEnabled: false,
+        version: "0.3.0",
+        serverInstanceId: "server-123",
+        isWriter: true,
+      },
+      store
+    );
+
+    expect(store.get(serverInfoAtom)).toEqual({
+      version: "0.3.0",
+      serverInstanceId: "server-123",
+      authEnabled: false,
+    });
+    expect(store.get(isWriterAtom)).toBe(true);
+  });
+
   it("appends brand-new workspace meta events to workspace order without reordering existing entries", () => {
     const store = createStore();
 
diff --git a/packages/web/src/app/providers.tsx b/packages/web/src/app/providers.tsx
@@ -466,6 +466,38 @@ export function AppProviders({ children }: AppProvidersProps) {
   return <>{children}</>;
 }
 
+function storeServerMetadata(
+  payload: unknown,
+  store: Store
+): payload is {
+  version: string;
+  serverInstanceId: string;
+  authEnabled?: boolean;
+  isWriter?: boolean;
+} {
+  const data = payload as {
+    version?: unknown;
+    serverInstanceId?: unknown;
+    authEnabled?: unknown;
+    isWriter?: unknown;
+  };
+
+  if (typeof data.version !== "string" || typeof data.serverInstanceId !== "string") {
+    return false;
+  }
+
+  store.set(serverInfoAtom, {
+    version: data.version,
+    serverInstanceId: data.serverInstanceId,
+    authEnabled: typeof data.authEnabled === "boolean" ? data.authEnabled : undefined,
+  });
+  if (typeof data.isWriter === "boolean") {
+    store.set(isWriterAtom, data.isWriter);
+  }
+
+  return true;
+}
+
 /**
  * Route incoming WebSocket events to appropriate Jotai atoms
  */
@@ -475,20 +507,24 @@ export function routeEventToAtom(topic: string, payload: unknown, store: Store):
   // or: connection.ready
 
   if (topic === "connection.ready") {
-    // Server metadata on connect
-    const data = payload as { version: string; serverInstanceId: string; isWriter: boolean };
-    store.set(serverInfoAtom, {
-      version: data.version,
-      serverInstanceId: data.serverInstanceId,
-    });
-    store.set(isWriterAtom, data.isWriter);
+    storeServerMetadata(payload, store);
     store.set(connectionErrorAtom, null);
     return;
   }
 
   if (topic === "connection.status") {
     // Connection-level status event
-    const data = payload as { status: string; message?: string; authEnabled?: boolean };
+    const data = payload as {
+      status: string;
+      message?: string;
+      authEnabled?: boolean;
+      version?: string;
+      serverInstanceId?: string;
+      isWriter?: boolean;
+    };
+    if (data.status === "connected") {
+      storeServerMetadata(payload, store);
+    }
     if (data.status === "connected" && data.authEnabled === false) {
       store.set(authenticatedAtom, true);
     }
diff --git a/packages/web/src/features/settings/components/settings-page.test.tsx b/packages/web/src/features/settings/components/settings-page.test.tsx
diff --git a/packages/web/src/features/settings/components/settings-page.tsx b/packages/web/src/features/settings/components/settings-page.tsx
