Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
Cache provider status and gate desktop startup (#1962)
Julius Marminge008ac5c3e5c8
diff --git a/apps/desktop/src/backendReadiness.test.ts b/apps/desktop/src/backendReadiness.test.tsindex fd6180b5d..33a5ef6b7 100644--- a/apps/desktop/src/backendReadiness.test.ts+++ b/apps/desktop/src/backendReadiness.test.ts@@ -7,7 +7,7 @@ import {} from "./backendReadiness";describe("waitForHttpReady", () => {- it("returns once the backend reports a successful session endpoint", async () => {+ it("returns once the backend serves the requested readiness path", async () => {const fetchImpl = vi.fn<typeof fetch>().mockResolvedValueOnce(new Response(null, { status: 503 }))@@ -20,6 +20,11 @@ describe("waitForHttpReady", () => {});expect(fetchImpl).toHaveBeenCalledTimes(2);+ expect(fetchImpl).toHaveBeenNthCalledWith(+ 1,+ "http://127.0.0.1:3773/",+ expect.objectContaining({ redirect: "manual" }),+ );});it("retries after a readiness request stalls past the per-request timeout", async () => {@@ -80,4 +85,30 @@ describe("waitForHttpReady", () => {expect(isBackendReadinessAborted(new BackendReadinessAbortedError())).toBe(true);expect(isBackendReadinessAborted(new Error("nope"))).toBe(false);});++ it("supports custom readiness predicates", async () => {+ const fetchImpl = vi+ .fn<typeof fetch>()+ .mockResolvedValueOnce(new Response(null, { status: 200 }))+ .mockResolvedValueOnce(new Response(null, { status: 204 }));++ await waitForHttpReady("http://127.0.0.1:3773", {+ fetchImpl,+ timeoutMs: 1_000,+ intervalMs: 0,+ path: "/api/healthz",+ isReady: (response) => response.status === 204,+ });++ expect(fetchImpl).toHaveBeenNthCalledWith(+ 1,+ "http://127.0.0.1:3773/api/healthz",+ expect.objectContaining({ redirect: "manual" }),+ );+ expect(fetchImpl).toHaveBeenNthCalledWith(+ 2,+ "http://127.0.0.1:3773/api/healthz",+ expect.objectContaining({ redirect: "manual" }),+ );+ });});diff --git a/apps/desktop/src/backendReadiness.ts b/apps/desktop/src/backendReadiness.tsindex 73081823a..71c28929e 100644--- a/apps/desktop/src/backendReadiness.ts+++ b/apps/desktop/src/backendReadiness.ts@@ -4,6 +4,8 @@ export interface WaitForHttpReadyOptions {readonly requestTimeoutMs?: number;readonly fetchImpl?: typeof fetch;readonly signal?: AbortSignal;+ readonly path?: string;+ readonly isReady?: (response: Response) => boolean;}const DEFAULT_TIMEOUT_MS = 30_000;@@ -57,6 +59,8 @@ export async function waitForHttpReady(const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;const intervalMs = options?.intervalMs ?? DEFAULT_INTERVAL_MS;const requestTimeoutMs = options?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;+ const readinessPath = options?.path ?? "/";+ const isReady = options?.isReady ?? ((response: Response) => response.ok);const deadline = Date.now() + timeoutMs;for (;;) {@@ -74,11 +78,11 @@ export async function waitForHttpReady(signal?.addEventListener("abort", abortRequest, { once: true });try {- const response = await fetchImpl(`${baseUrl}/api/auth/session`, {+ const response = await fetchImpl(new URL(readinessPath, baseUrl).toString(), {redirect: "manual",signal: requestController.signal,});- if (response.ok) {+ if (isReady(response)) {return;}} catch (error) {diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.tsindex fa0ad50da..cdabb2d74 100644--- a/apps/desktop/src/main.ts+++ b/apps/desktop/src/main.ts@@ -55,6 +55,7 @@ import { showDesktopConfirmDialog } from "./confirmDialog";import { resolveDesktopServerExposure } from "./serverExposure";import { syncShellEnvironment } from "./syncShellEnvironment";import { getAutoUpdateDisabledReason, shouldBroadcastDownloadProgress } from "./updateState";+import { ServerListeningDetector } from "./serverListeningDetector";import {createInitialDesktopUpdateState,reduceDesktopUpdateStateOnCheckFailure,@@ -144,6 +145,8 @@ let backendWsUrl = "";let backendEndpointUrl: string | null = null;let backendAdvertisedHost: string | null = null;let backendReadinessAbortController: AbortController | null = null;+let backendInitialWindowOpenInFlight: Promise<void> | null = null;+let backendListeningDetector: ServerListeningDetector | null = null;let restartAttempt = 0;let restartTimer: ReturnType<typeof setTimeout> | null = null;let isQuitting = false;@@ -362,13 +365,17 @@ function getSafeTheme(rawTheme: unknown): DesktopTheme | null {return null;}-async function waitForBackendHttpReady(baseUrl: string): Promise<void> {+async function waitForBackendHttpReady(+ baseUrl: string,+ options?: Parameters<typeof waitForHttpReady>[1],+): Promise<void> {cancelBackendReadinessWait();const controller = new AbortController();backendReadinessAbortController = controller;try {await waitForHttpReady(baseUrl, {+ ...options,signal: controller.signal,});} finally {@@ -383,6 +390,88 @@ function cancelBackendReadinessWait(): void {backendReadinessAbortController = null;}+async function waitForBackendWindowReady(baseUrl: string): Promise<"listening" | "http"> {+ const httpReadyPromise = waitForBackendHttpReady(baseUrl, {+ timeoutMs: 60_000,+ });+ const listeningPromise = backendListeningDetector?.promise;++ if (!listeningPromise) {+ await httpReadyPromise;+ return "http";+ }++ return await new Promise<"listening" | "http">((resolve, reject) => {+ let settled = false;++ const settleResolve = (source: "listening" | "http") => {+ if (settled) {+ return;+ }+ settled = true;+ if (source === "listening") {+ cancelBackendReadinessWait();+ }+ resolve(source);+ };++ const settleReject = (error: unknown) => {+ if (settled) {+ return;+ }+ settled = true;+ reject(error);+ };++ listeningPromise.then(+ () => settleResolve("listening"),+ (error) => settleReject(error),+ );+ httpReadyPromise.then(+ () => settleResolve("http"),+ (error) => {+ if (settled && isBackendReadinessAborted(error)) {+ return;+ }+ settleReject(error);+ },+ );+ });+}++function ensureInitialBackendWindowOpen(): void {+ const existingWindow = mainWindow ?? BrowserWindow.getAllWindows()[0] ?? null;+ if (isDevelopment || existingWindow !== null || backendInitialWindowOpenInFlight !== null) {+ return;+ }++ const nextOpen = waitForBackendWindowReady(backendHttpUrl)+ .then((source) => {+ writeDesktopLogHeader(`bootstrap backend ready source=${source}`);+ if (mainWindow ?? BrowserWindow.getAllWindows()[0]) {+ return;+ }+ mainWindow = createWindow();+ writeDesktopLogHeader("bootstrap main window created");+ })+ .catch((error) => {+ if (isBackendReadinessAborted(error)) {+ return;+ }+ writeDesktopLogHeader(+ `bootstrap backend readiness warning message=${formatErrorMessage(error)}`,+ );+ console.warn("[desktop] backend readiness check timed out during packaged bootstrap", error);+ })+ .finally(() => {+ if (backendInitialWindowOpenInFlight === nextOpen) {+ backendInitialWindowOpenInFlight = null;+ }+ });++ backendInitialWindowOpenInFlight = nextOpen;+}+function writeDesktopStreamChunk(streamName: "stdout" | "stderr",chunk: unknown,@@ -460,14 +549,16 @@ function initializePackagedLogging(): void {}function captureBackendOutput(child: ChildProcess.ChildProcess): void {- if (!app.isPackaged || backendLogSink === null) return;- const writeChunk = (chunk: unknown): void => {- if (!backendLogSink) return;- const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), "utf8");- backendLogSink.write(buffer);+ const attachStream = (stream: NodeJS.ReadableStream | null | undefined): void => {+ stream?.on("data", (chunk: unknown) => {+ const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), "utf8");+ backendLogSink?.write(buffer);+ backendListeningDetector?.push(buffer);+ });};- child.stdout?.on("data", writeChunk);- child.stderr?.on("data", writeChunk);++ attachStream(child.stdout);+ attachStream(child.stderr);}initializePackagedLogging();@@ -1222,7 +1313,7 @@ function startBackend(): void {return;}- const captureBackendLogs = app.isPackaged && backendLogSink !== null;+ const captureBackendLogs = !isDevelopment;const child = ChildProcess.spawn(process.execPath, [backendEntry, "--bootstrap-fd", "3"], {cwd: resolveBackendCwd(),// In Electron main, process.execPath points to the Electron binary.@@ -1259,6 +1350,8 @@ function startBackend(): void {scheduleBackendRestart("missing desktop bootstrap pipe");return;}+ const listeningDetector = new ServerListeningDetector();+ backendListeningDetector = listeningDetector;backendProcess = child;let backendSessionClosed = false;const closeBackendSession = (details: string) => {@@ -1277,6 +1370,10 @@ function startBackend(): void {});child.on("error", (error) => {+ if (backendListeningDetector === listeningDetector) {+ listeningDetector.fail(error);+ backendListeningDetector = null;+ }const wasExpected = expectedBackendExitChildren.has(child);if (backendProcess === child) {backendProcess = null;@@ -1289,6 +1386,14 @@ function startBackend(): void {});child.on("exit", (code, signal) => {+ if (backendListeningDetector === listeningDetector) {+ listeningDetector.fail(+ new Error(+ `backend exited before logging readiness (code=${code ?? "null"} signal=${signal ?? "null"})`,+ ),+ );+ backendListeningDetector = null;+ }const wasExpected = expectedBackendExitChildren.has(child);if (backendProcess === child) {backendProcess = null;@@ -1300,10 +1405,13 @@ function startBackend(): void {const reason = `code=${code ?? "null"} signal=${signal ?? "null"}`;scheduleBackendRestart(reason);});++ ensureInitialBackendWindowOpen();}function stopBackend(): void {cancelBackendReadinessWait();+ backendListeningDetector = null;if (restartTimer) {clearTimeout(restartTimer);restartTimer = null;@@ -1705,7 +1813,7 @@ function createWindow(): BrowserWindow {height: 780,minWidth: 840,minHeight: 620,- show: isDevelopment,+ show: false,autoHideMenuBar: true,backgroundColor: getInitialWindowBackgroundColor(),...getIconOption(),@@ -1779,20 +1887,23 @@ function createWindow(): BrowserWindow {window.setTitle(APP_DISPLAY_NAME);emitUpdateState();});- if (!isDevelopment) {- window.once("ready-to-show", () => {- revealWindow(window);- });- }++ let initialRevealScheduled = false;+ const revealInitialWindow = () => {+ if (initialRevealScheduled) {+ return;+ }+ initialRevealScheduled = true;+ revealWindow(window);+ };++ window.once("ready-to-show", revealInitialWindow);if (isDevelopment) {void window.loadURL(resolveDesktopDevServerUrl());window.webContents.openDevTools({ mode: "detach" });- setImmediate(() => {- revealWindow(window);- });} else {- void window.loadURL(resolveDesktopWindowUrl());+ void window.loadURL(backendHttpUrl);}window.on("closed", () => {@@ -1804,14 +1915,6 @@ function createWindow(): BrowserWindow {return window;}-function resolveDesktopWindowUrl(): string {- if (backendHttpUrl) {- return backendHttpUrl;- }-- return `${DESKTOP_SCHEME}://app`;-}-// Override Electron's userData path before the `ready` event so that// Chromium session data uses a filesystem-friendly directory name.// Must be called synchronously at the top level — before `app.whenReady()`.@@ -1885,10 +1988,7 @@ async function bootstrap(): Promise<void> {return;}- await waitForBackendHttpReady(backendHttpUrl);- writeDesktopLogHeader("bootstrap backend ready");- mainWindow = createWindow();- writeDesktopLogHeader("bootstrap main window created");+ ensureInitialBackendWindowOpen();}app.on("before-quit", () => {@@ -1922,7 +2022,11 @@ apprevealWindow(existingWindow);return;}- mainWindow = createWindow();+ if (isDevelopment) {+ mainWindow = createWindow();+ return;+ }+ ensureInitialBackendWindowOpen();});}).catch((error) => {diff --git a/apps/desktop/src/serverListeningDetector.test.ts b/apps/desktop/src/serverListeningDetector.test.tsnew file mode 100644index 000000000..b7c66b631--- /dev/null+++ b/apps/desktop/src/serverListeningDetector.test.ts@@ -0,0 +1,31 @@+import { describe, expect, it } from "vitest";++import { ServerListeningDetector } from "./serverListeningDetector";++describe("ServerListeningDetector", () => {+ it("resolves when the server logs the listening line", async () => {+ const detector = new ServerListeningDetector();++ detector.push("[01:23:30.571] INFO (#148): Listening on http://0.0.0.0:7011\n");++ await expect(detector.promise).resolves.toBeUndefined();+ });++ it("resolves when the listening line arrives across multiple chunks", async () => {+ const detector = new ServerListeningDetector();++ detector.push("[01:23:30.571] INFO (#148): Listen");+ detector.push("ing on http://0.0.0.0:7011\n");++ await expect(detector.promise).resolves.toBeUndefined();+ });++ it("rejects when the server exits before logging readiness", async () => {+ const detector = new ServerListeningDetector();+ const error = new Error("server exited");++ detector.fail(error);++ await expect(detector.promise).rejects.toBe(error);+ });+});diff --git a/apps/desktop/src/serverListeningDetector.ts b/apps/desktop/src/serverListeningDetector.tsnew file mode 100644index 000000000..e738aacc3--- /dev/null+++ b/apps/desktop/src/serverListeningDetector.ts@@ -0,0 +1,56 @@+const LISTENING_LOG_FRAGMENT = "Listening on http://";+const MAX_BUFFER_CHARS = 8_192;++export class ServerListeningDetector {+ private buffer = "";+ private settled = false;+ private readonly resolvePromise: () => void;+ private readonly rejectPromise: (error: unknown) => void;+ readonly promise: Promise<void>;++ constructor() {+ let resolvePromise: (() => void) | null = null;+ let rejectPromise: ((error: unknown) => void) | null = null;++ this.promise = new Promise<void>((resolve, reject) => {+ resolvePromise = resolve;+ rejectPromise = reject;+ });++ this.resolvePromise = () => {+ if (this.settled) {+ return;+ }+ this.settled = true;+ resolvePromise?.();+ };+ this.rejectPromise = (error) => {+ if (this.settled) {+ return;+ }+ this.settled = true;+ rejectPromise?.(error);+ };+ }++ push(chunk: unknown): void {+ if (this.settled) {+ return;+ }++ const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);+ this.buffer = `${this.buffer}${text.replace(/\r/g, "")}`;+ if (this.buffer.includes(LISTENING_LOG_FRAGMENT)) {+ this.resolvePromise();+ return;+ }++ if (this.buffer.length > MAX_BUFFER_CHARS) {+ this.buffer = this.buffer.slice(-MAX_BUFFER_CHARS);+ }+ }++ fail(error: unknown): void {+ this.rejectPromise(error);+ }+}diff --git a/apps/server/src/config.ts b/apps/server/src/config.tsindex c2e5ecee4..7840c7611 100644--- a/apps/server/src/config.ts+++ b/apps/server/src/config.ts@@ -24,6 +24,7 @@ export interface ServerDerivedPaths {readonly dbPath: string;readonly keybindingsConfigPath: string;readonly settingsPath: string;+ readonly providerStatusCacheDir: string;readonly worktreesDir: string;readonly attachmentsDir: string;readonly logsDir: string;@@ -76,11 +77,13 @@ export const deriveServerPaths = Effect.fn(function* (const attachmentsDir = join(stateDir, "attachments");const logsDir = join(stateDir, "logs");const providerLogsDir = join(logsDir, "provider");+ const providerStatusCacheDir = join(baseDir, "caches");return {stateDir,dbPath,keybindingsConfigPath: join(stateDir, "keybindings.json"),settingsPath: join(stateDir, "settings.json"),+ providerStatusCacheDir,worktreesDir: join(baseDir, "worktrees"),attachmentsDir,logsDir,@@ -110,6 +113,7 @@ export const ensureServerDirectories = Effect.fn(function* (derivedPaths: Serverfs.makeDirectory(derivedPaths.worktreesDir, { recursive: true }),fs.makeDirectory(path.dirname(derivedPaths.keybindingsConfigPath), { recursive: true }),fs.makeDirectory(path.dirname(derivedPaths.settingsPath), { recursive: true }),+ fs.makeDirectory(derivedPaths.providerStatusCacheDir, { recursive: true }),fs.makeDirectory(path.dirname(derivedPaths.anonymousIdPath), { recursive: true }),fs.makeDirectory(path.dirname(derivedPaths.serverRuntimeStatePath), { recursive: true }),],diff --git a/apps/server/src/http.ts b/apps/server/src/http.tsindex ed4038942..7420156b2 100644--- a/apps/server/src/http.ts+++ b/apps/server/src/http.ts@@ -226,6 +226,7 @@ export const staticAndDevRouteLayer = HttpRouter.add(Effect.gen(function* () {const request = yield* HttpServerRequest.HttpServerRequest;const url = HttpServerRequest.toURL(request);+if (Option.isNone(url)) {return HttpServerResponse.text("Bad Request", { status: 400 });}diff --git a/apps/server/src/provider/Layers/ClaudeProvider.ts b/apps/server/src/provider/Layers/ClaudeProvider.tsindex d00be86d3..b7c3c3140 100644--- a/apps/server/src/provider/Layers/ClaudeProvider.ts+++ b/apps/server/src/provider/Layers/ClaudeProvider.ts@@ -663,6 +663,46 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(});});+const makePendingClaudeProvider = (claudeSettings: ClaudeSettings): ServerProvider => {+ const checkedAt = new Date().toISOString();+ const models = providerModelsFromSettings(+ BUILT_IN_MODELS,+ PROVIDER,+ claudeSettings.customModels,+ DEFAULT_CLAUDE_MODEL_CAPABILITIES,+ );++ if (!claudeSettings.enabled) {+ return buildServerProvider({+ provider: PROVIDER,+ enabled: false,+ checkedAt,+ models,+ probe: {+ installed: false,+ version: null,+ status: "warning",+ auth: { status: "unknown" },+ message: "Claude is disabled in T3 Code settings.",+ },+ });+ }++ return buildServerProvider({+ provider: PROVIDER,+ enabled: true,+ checkedAt,+ models,+ probe: {+ installed: false,+ version: null,+ status: "warning",+ auth: { status: "unknown" },+ message: "Claude provider status has not been checked in this session yet.",+ },+ });+};+export const ClaudeProviderLive = Layer.effect(ClaudeProvider,Effect.gen(function* () {@@ -698,6 +738,7 @@ export const ClaudeProviderLive = Layer.effect(Stream.map((settings) => settings.providers.claudeAgent),),haveSettingsChanged: (previous, next) => !Equal.equals(previous, next),+ initialSnapshot: makePendingClaudeProvider,checkProvider,});}),diff --git a/apps/server/src/provider/Layers/CodexProvider.ts b/apps/server/src/provider/Layers/CodexProvider.tsindex 421621c96..d3f8c742e 100644--- a/apps/server/src/provider/Layers/CodexProvider.ts+++ b/apps/server/src/provider/Layers/CodexProvider.ts@@ -552,6 +552,46 @@ export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(fu});});+const makePendingCodexProvider = (codexSettings: CodexSettings): ServerProvider => {+ const checkedAt = new Date().toISOString();+ const models = providerModelsFromSettings(+ BUILT_IN_MODELS,+ PROVIDER,+ codexSettings.customModels,+ DEFAULT_CODEX_MODEL_CAPABILITIES,+ );++ if (!codexSettings.enabled) {+ return buildServerProvider({+ provider: PROVIDER,+ enabled: false,+ checkedAt,+ models,+ probe: {+ installed: false,+ version: null,+ status: "warning",+ auth: { status: "unknown" },+ message: "Codex is disabled in T3 Code settings.",+ },+ });+ }++ return buildServerProvider({+ provider: PROVIDER,+ enabled: true,+ checkedAt,+ models,+ probe: {+ installed: false,+ version: null,+ status: "warning",+ auth: { status: "unknown" },+ message: "Codex provider status has not been checked in this session yet.",+ },+ });+};+export const CodexProviderLive = Layer.effect(CodexProvider,Effect.gen(function* () {@@ -602,6 +642,7 @@ export const CodexProviderLive = Layer.effect(Stream.map((settings) => settings.providers.codex),),haveSettingsChanged: (previous, next) => !Equal.equals(previous, next),+ initialSnapshot: makePendingCodexProvider,checkProvider,});}),diff --git a/apps/server/src/provider/Layers/ProviderRegistry.test.ts b/apps/server/src/provider/Layers/ProviderRegistry.test.tsindex 9c12048e4..93d146acf 100644--- a/apps/server/src/provider/Layers/ProviderRegistry.test.ts+++ b/apps/server/src/provider/Layers/ProviderRegistry.test.ts@@ -31,6 +31,7 @@ import {} from "./CodexProvider";import { checkClaudeProviderStatus, parseClaudeAuthStatusFromOutput } from "./ClaudeProvider";import { haveProvidersChanged, ProviderRegistryLive } from "./ProviderRegistry";+import { ServerConfig } from "../../config";import { ServerSettingsService, type ServerSettingsShape } from "../../serverSettings";import { ProviderRegistry } from "../Services/ProviderRegistry";@@ -562,6 +563,61 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsService.layerTest()))(assert.strictEqual(haveProvidersChanged(providers, [...providers]), false);});+ it.effect("does not probe provider health during registry startup", () =>+ Effect.gen(function* () {+ let spawnCount = 0;+ const serverSettings = yield* makeMutableServerSettingsService();+ const scope = yield* Scope.make();+ yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));+ const providerRegistryLayer = ProviderRegistryLive.pipe(+ Layer.provideMerge(Layer.succeed(ServerSettingsService, serverSettings)),+ Layer.provideMerge(+ ServerConfig.layerTest(process.cwd(), {+ prefix: "t3-provider-registry-",+ }),+ ),+ Layer.provideMerge(+ mockCommandSpawnerLayer((command, args) => {+ spawnCount += 1;+ const joined = args.join(" ");+ if (joined === "--version") {+ if (command === "codex") {+ return { stdout: "codex 1.0.0\n", stderr: "", code: 0 };+ }+ return { stdout: "claude 1.0.0\n", stderr: "", code: 0 };+ }+ if (joined === "login status") {+ return { stdout: "Logged in\n", stderr: "", code: 0 };+ }+ if (joined === "auth status") {+ return { stdout: '{"authenticated":true}\n', stderr: "", code: 0 };+ }+ throw new Error(`Unexpected args: ${command} ${joined}`);+ }),+ ),+ );+ const runtimeServices = yield* Layer.build(+ Layer.mergeAll(+ Layer.succeed(ServerSettingsService, serverSettings),+ providerRegistryLayer,+ ),+ ).pipe(Scope.provide(scope));++ yield* Effect.gen(function* () {+ const registry = yield* ProviderRegistry;+ assert.deepStrictEqual(yield* registry.getProviders, []);+ assert.strictEqual(spawnCount, 0);++ const refreshed = yield* registry.refresh("codex");+ assert.strictEqual(spawnCount > 0, true);+ assert.strictEqual(+ refreshed.find((provider) => provider.provider === "codex")?.status,+ "ready",+ );+ }).pipe(Effect.provide(runtimeServices));+ }),+ );+it.effect("reruns codex health when codex provider settings change", () =>Effect.gen(function* () {const serverSettings = yield* makeMutableServerSettingsService();@@ -569,6 +625,11 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsService.layerTest()))(yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));const providerRegistryLayer = ProviderRegistryLive.pipe(Layer.provideMerge(Layer.succeed(ServerSettingsService, serverSettings)),+ Layer.provideMerge(+ ServerConfig.layerTest(process.cwd(), {+ prefix: "t3-provider-registry-",+ }),+ ),Layer.provideMerge(mockCommandSpawnerLayer((command, args) => {const joined = args.join(" ");@@ -596,8 +657,11 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsService.layerTest()))(const registry = yield* ProviderRegistry;const initial = yield* registry.getProviders;+ assert.deepStrictEqual(initial, []);++ const refreshed = yield* registry.refresh("codex");assert.strictEqual(- initial.find((status) => status.provider === "codex")?.status,+ refreshed.find((status) => status.provider === "codex")?.status,"ready",);diff --git a/apps/server/src/provider/Layers/ProviderRegistry.ts b/apps/server/src/provider/Layers/ProviderRegistry.tsindex fb2f33c29..41bb81e74 100644--- a/apps/server/src/provider/Layers/ProviderRegistry.ts+++ b/apps/server/src/provider/Layers/ProviderRegistry.ts@@ -4,8 +4,9 @@* @module ProviderRegistryLive*/import type { ProviderKind, ServerProvider } from "@t3tools/contracts";-import { Effect, Equal, Layer, PubSub, Ref, Stream } from "effect";+import { Effect, Equal, FileSystem, Layer, Path, PubSub, Ref, Stream } from "effect";+import { ServerConfig } from "../../config";import { ClaudeProviderLive } from "./ClaudeProvider";import { CodexProviderLive } from "./CodexProvider";import type { ClaudeProviderShape } from "../Services/ClaudeProvider";@@ -13,6 +14,14 @@ import { ClaudeProvider } from "../Services/ClaudeProvider";import type { CodexProviderShape } from "../Services/CodexProvider";import { CodexProvider } from "../Services/CodexProvider";import { ProviderRegistry, type ProviderRegistryShape } from "../Services/ProviderRegistry";+import {+ hydrateCachedProvider,+ PROVIDER_CACHE_IDS,+ orderProviderSnapshots,+ readProviderStatusCache,+ resolveProviderStatusCachePath,+ writeProviderStatusCache,+} from "../providerStatusCache";const loadProviders = (codexProvider: CodexProviderShape,@@ -32,61 +41,152 @@ export const ProviderRegistryLive = Layer.effect(Effect.gen(function* () {const codexProvider = yield* CodexProvider;const claudeProvider = yield* ClaudeProvider;+ const config = yield* ServerConfig;+ const fileSystem = yield* FileSystem.FileSystem;+ const path = yield* Path.Path;const changesPubSub = yield* Effect.acquireRelease(PubSub.unbounded<ReadonlyArray<ServerProvider>>(),PubSub.shutdown,);- const providersRef = yield* Ref.make<ReadonlyArray<ServerProvider>>(- yield* loadProviders(codexProvider, claudeProvider),+ const fallbackProviders = yield* loadProviders(codexProvider, claudeProvider);+ const cachePathByProvider = new Map(+ PROVIDER_CACHE_IDS.map(+ (provider) =>+ [+ provider,+ resolveProviderStatusCachePath({+ cacheDir: config.providerStatusCacheDir,+ provider,+ }),+ ] as const,+ ),+ );+ const fallbackByProvider = new Map(+ fallbackProviders.map((provider) => [provider.provider, provider] as const),);+ const cachedProviders = yield* Effect.forEach(+ PROVIDER_CACHE_IDS,+ (provider) => {+ const filePath = cachePathByProvider.get(provider)!;+ const fallbackProvider = fallbackByProvider.get(provider)!;+ return readProviderStatusCache(filePath).pipe(+ Effect.provideService(FileSystem.FileSystem, fileSystem),+ Effect.map((cachedProvider) =>+ cachedProvider === undefined+ ? undefined+ : hydrateCachedProvider({+ cachedProvider,+ fallbackProvider,+ }),+ ),+ );+ },+ { concurrency: "unbounded" },+ ).pipe(+ Effect.map((providers) =>+ orderProviderSnapshots(+ providers.filter((provider): provider is ServerProvider => provider !== undefined),+ ),+ ),+ );+ const providersRef = yield* Ref.make<ReadonlyArray<ServerProvider>>(cachedProviders);++ const persistProvider = (provider: ServerProvider) =>+ writeProviderStatusCache({+ filePath: cachePathByProvider.get(provider.provider)!,+ provider,+ }).pipe(+ Effect.provideService(FileSystem.FileSystem, fileSystem),+ Effect.provideService(Path.Path, path),+ Effect.tapError(Effect.logError),+ Effect.ignore,+ );++ const upsertProviders = Effect.fn("upsertProviders")(function* (+ nextProviders: ReadonlyArray<ServerProvider>,+ options?: {+ readonly publish?: boolean;+ },+ ) {+ const [previousProviders, providers] = yield* Ref.modify(+ providersRef,+ (previousProviders) => {+ const mergedProviders = new Map(+ previousProviders.map((provider) => [provider.provider, provider] as const),+ );++ for (const provider of nextProviders) {+ mergedProviders.set(provider.provider, provider);+ }- const syncProviders = Effect.fn("syncProviders")(function* (options?: {- readonly publish?: boolean;- }) {- const previousProviders = yield* Ref.get(providersRef);- const providers = yield* loadProviders(codexProvider, claudeProvider);- yield* Ref.set(providersRef, providers);+ const providers = orderProviderSnapshots([...mergedProviders.values()]);+ return [[previousProviders, providers] as const, providers];+ },+ );- if (options?.publish !== false && haveProvidersChanged(previousProviders, providers)) {- yield* PubSub.publish(changesPubSub, providers);+ if (haveProvidersChanged(previousProviders, providers)) {+ yield* Effect.forEach(nextProviders, persistProvider, {+ concurrency: "unbounded",+ discard: true,+ });+ if (options?.publish !== false) {+ yield* PubSub.publish(changesPubSub, providers);+ }}return providers;});- yield* Stream.runForEach(codexProvider.streamChanges, () => syncProviders()).pipe(- Effect.forkScoped,- );- yield* Stream.runForEach(claudeProvider.streamChanges, () => syncProviders()).pipe(- Effect.forkScoped,- );+ const syncProvider = Effect.fn("syncProvider")(function* (+ provider: ServerProvider,+ options?: {+ readonly publish?: boolean;+ },+ ) {+ return yield* upsertProviders([provider], options);+ });const refresh = Effect.fn("refresh")(function* (provider?: ProviderKind) {switch (provider) {case "codex":- yield* codexProvider.refresh;- break;+ return yield* codexProvider.refresh.pipe(+ Effect.flatMap((nextProvider) => syncProvider(nextProvider)),+ );case "claudeAgent":- yield* claudeProvider.refresh;- break;+ return yield* claudeProvider.refresh.pipe(+ Effect.flatMap((nextProvider) => syncProvider(nextProvider)),+ );default:- yield* Effect.all([codexProvider.refresh, claudeProvider.refresh], {- concurrency: "unbounded",- });- break;+ return yield* Effect.all(+ [+ codexProvider.refresh.pipe(+ Effect.flatMap((nextProvider) => syncProvider(nextProvider)),+ ),+ claudeProvider.refresh.pipe(+ Effect.flatMap((nextProvider) => syncProvider(nextProvider)),+ ),+ ],+ {+ concurrency: "unbounded",+ discard: true,+ },+ ).pipe(Effect.andThen(Ref.get(providersRef)));}- return yield* syncProviders();});+ yield* Stream.runForEach(codexProvider.streamChanges, (provider) =>+ syncProvider(provider),+ ).pipe(Effect.forkScoped);+ yield* Stream.runForEach(claudeProvider.streamChanges, (provider) =>+ syncProvider(provider),+ ).pipe(Effect.forkScoped);+return {- getProviders: syncProviders({ publish: false }).pipe(- Effect.tapError(Effect.logError),- Effect.orElseSucceed(() => []),- ),+ getProviders: Ref.get(providersRef),refresh: (provider?: ProviderKind) =>refresh(provider).pipe(Effect.tapError(Effect.logError),- Effect.orElseSucceed(() => []),+ Effect.orElseSucceed(() => [] as ReadonlyArray<ServerProvider>),),get streamChanges() {return Stream.fromPubSub(changesPubSub);diff --git a/apps/server/src/provider/makeManagedServerProvider.ts b/apps/server/src/provider/makeManagedServerProvider.tsindex 59aeac1ab..856594c1f 100644--- a/apps/server/src/provider/makeManagedServerProvider.ts+++ b/apps/server/src/provider/makeManagedServerProvider.ts@@ -11,6 +11,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(readonly getSettings: Effect.Effect<Settings>;readonly streamSettings: Stream.Stream<Settings>;readonly haveSettingsChanged: (previous: Settings, next: Settings) => boolean;+ readonly initialSnapshot: (settings: Settings) => ServerProvider;readonly checkProvider: Effect.Effect<ServerProvider, ServerSettingsError>;readonly refreshInterval?: Duration.Input;}): Effect.fn.Return<ServerProviderShape, ServerSettingsError, Scope.Scope> {@@ -20,7 +21,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(PubSub.shutdown,);const initialSettings = yield* input.getSettings;- const initialSnapshot = yield* input.checkProvider;+ const initialSnapshot = input.initialSnapshot(initialSettings);const snapshotRef = yield* Ref.make(initialSnapshot);const settingsRef = yield* Ref.make(initialSettings);diff --git a/apps/server/src/provider/providerStatusCache.test.ts b/apps/server/src/provider/providerStatusCache.test.tsnew file mode 100644index 000000000..5f0d88322--- /dev/null+++ b/apps/server/src/provider/providerStatusCache.test.ts@@ -0,0 +1,136 @@+import * as NodeServices from "@effect/platform-node/NodeServices";+import type { ServerProvider } from "@t3tools/contracts";+import { assert, it } from "@effect/vitest";+import { Effect, FileSystem } from "effect";++import {+ hydrateCachedProvider,+ readProviderStatusCache,+ resolveProviderStatusCachePath,+ writeProviderStatusCache,+} from "./providerStatusCache";++const makeProvider = (+ provider: ServerProvider["provider"],+ overrides?: Partial<ServerProvider>,+): ServerProvider => ({+ provider,+ enabled: true,+ installed: true,+ version: "1.0.0",+ status: "ready",+ auth: { status: "authenticated" },+ checkedAt: "2026-04-11T00:00:00.000Z",+ models: [],+ slashCommands: [],+ skills: [],+ ...overrides,+});++it.layer(NodeServices.layer)("providerStatusCache", (it) => {+ it.effect("writes and reads provider status snapshots", () =>+ Effect.gen(function* () {+ const fs = yield* FileSystem.FileSystem;+ const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-provider-cache-" });+ const codexProvider = makeProvider("codex");+ const claudeProvider = makeProvider("claudeAgent", {+ status: "warning",+ auth: { status: "unknown" },+ });+ const codexPath = resolveProviderStatusCachePath({+ cacheDir: tempDir,+ provider: "codex",+ });+ const claudePath = resolveProviderStatusCachePath({+ cacheDir: tempDir,+ provider: "claudeAgent",+ });++ yield* writeProviderStatusCache({+ filePath: codexPath,+ provider: codexProvider,+ });+ yield* writeProviderStatusCache({+ filePath: claudePath,+ provider: claudeProvider,+ });++ assert.deepStrictEqual(yield* readProviderStatusCache(codexPath), codexProvider);+ assert.deepStrictEqual(yield* readProviderStatusCache(claudePath), claudeProvider);+ }),+ );++ it("hydrates cached provider status onto current settings-derived models", () => {+ const cachedCodex = makeProvider("codex", {+ checkedAt: "2026-04-10T12:00:00.000Z",+ models: [],+ message: "Cached message",+ skills: [+ {+ name: "github:gh-fix-ci",+ path: "/tmp/skills/gh-fix-ci/SKILL.md",+ enabled: true,+ displayName: "CI Debug",+ },+ ],+ });+ const fallbackCodex = makeProvider("codex", {+ models: [+ {+ slug: "gpt-5.4",+ name: "GPT-5.4",+ isCustom: false,+ capabilities: {+ reasoningEffortLevels: [],+ supportsFastMode: false,+ supportsThinkingToggle: false,+ contextWindowOptions: [],+ promptInjectedEffortLevels: [],+ },+ },+ ],+ message: "Pending refresh",+ });++ assert.deepStrictEqual(+ hydrateCachedProvider({+ cachedProvider: cachedCodex,+ fallbackProvider: fallbackCodex,+ }),+ {+ ...fallbackCodex,+ installed: cachedCodex.installed,+ version: cachedCodex.version,+ status: cachedCodex.status,+ auth: cachedCodex.auth,+ checkedAt: cachedCodex.checkedAt,+ slashCommands: cachedCodex.slashCommands,+ skills: cachedCodex.skills,+ message: cachedCodex.message,+ },+ );+ });++ it("ignores stale cached enabled state when the provider is now disabled", () => {+ const cachedCodex = makeProvider("codex", {+ checkedAt: "2026-04-10T12:00:00.000Z",+ message: "Cached ready status",+ });+ const disabledFallback = makeProvider("codex", {+ enabled: false,+ installed: false,+ version: null,+ status: "disabled",+ auth: { status: "unknown" },+ message: "Codex is disabled in T3 Code settings.",+ });++ assert.deepStrictEqual(+ hydrateCachedProvider({+ cachedProvider: cachedCodex,+ fallbackProvider: disabledFallback,+ }),+ disabledFallback,+ );+ });+});diff --git a/apps/server/src/provider/providerStatusCache.ts b/apps/server/src/provider/providerStatusCache.tsnew file mode 100644index 000000000..abedf99d1--- /dev/null+++ b/apps/server/src/provider/providerStatusCache.ts@@ -0,0 +1,105 @@+import * as nodePath from "node:path";+import { type ServerProvider, ServerProvider as ServerProviderSchema } from "@t3tools/contracts";+import { Cause, Effect, FileSystem, Path, Schema } from "effect";++export const PROVIDER_CACHE_IDS = ["codex", "claudeAgent"] as const satisfies ReadonlyArray<+ ServerProvider["provider"]+>;++const decodeProviderStatusCache = Schema.decodeUnknownEffect(+ Schema.fromJsonString(ServerProviderSchema),+);++const providerOrderRank = (provider: ServerProvider["provider"]): number => {+ const rank = PROVIDER_CACHE_IDS.indexOf(provider);+ return rank === -1 ? Number.MAX_SAFE_INTEGER : rank;+};++export const orderProviderSnapshots = (+ providers: ReadonlyArray<ServerProvider>,+): ReadonlyArray<ServerProvider> =>+ [...providers].toSorted(+ (left, right) => providerOrderRank(left.provider) - providerOrderRank(right.provider),+ );++export const hydrateCachedProvider = (input: {+ readonly cachedProvider: ServerProvider;+ readonly fallbackProvider: ServerProvider;+}): ServerProvider => {+ if (+ !input.fallbackProvider.enabled ||+ input.cachedProvider.enabled !== input.fallbackProvider.enabled+ ) {+ return input.fallbackProvider;+ }++ const { message: _fallbackMessage, ...fallbackWithoutMessage } = input.fallbackProvider;+ const hydratedProvider: ServerProvider = {+ ...fallbackWithoutMessage,+ installed: input.cachedProvider.installed,+ version: input.cachedProvider.version,+ status: input.cachedProvider.status,+ auth: input.cachedProvider.auth,+ checkedAt: input.cachedProvider.checkedAt,+ slashCommands: input.cachedProvider.slashCommands,+ skills: input.cachedProvider.skills,+ };++ return input.cachedProvider.message+ ? { ...hydratedProvider, message: input.cachedProvider.message }+ : hydratedProvider;+};++export const resolveProviderStatusCachePath = (input: {+ readonly cacheDir: string;+ readonly provider: ServerProvider["provider"];+}) => nodePath.join(input.cacheDir, `${input.provider}.json`);++export const readProviderStatusCache = (filePath: string) =>+ Effect.gen(function* () {+ const fs = yield* FileSystem.FileSystem;+ const exists = yield* fs.exists(filePath).pipe(Effect.orElseSucceed(() => false));+ if (!exists) {+ return undefined;+ }++ const raw = yield* fs.readFileString(filePath).pipe(Effect.orElseSucceed(() => ""));+ const trimmed = raw.trim();+ if (trimmed.length === 0) {+ return undefined;+ }++ return yield* decodeProviderStatusCache(trimmed).pipe(+ Effect.matchCauseEffect({+ onFailure: (cause) =>+ Effect.logWarning("failed to parse provider status cache, ignoring", {+ path: filePath,+ issues: Cause.pretty(cause),+ }).pipe(Effect.as(undefined)),+ onSuccess: Effect.succeed,+ }),+ );+ });++export const writeProviderStatusCache = (input: {+ readonly filePath: string;+ readonly provider: ServerProvider;+}) => {+ const tempPath = `${input.filePath}.${process.pid}.${Date.now()}.tmp`;+ return Effect.gen(function* () {+ const fs = yield* FileSystem.FileSystem;+ const path = yield* Path.Path;+ const encoded = `${JSON.stringify(input.provider, null, 2)}\n`;++ yield* fs.makeDirectory(path.dirname(input.filePath), { recursive: true });+ yield* fs.writeFileString(tempPath, encoded);+ yield* fs.rename(tempPath, input.filePath);+ }).pipe(+ Effect.ensuring(+ Effect.gen(function* () {+ const fs = yield* FileSystem.FileSystem;+ yield* fs.remove(tempPath, { force: true }).pipe(Effect.ignore({ log: true }));+ }),+ ),+ );+};diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.tsindex 5e5b172f4..276bc1d9b 100644--- a/apps/server/src/server.test.ts+++ b/apps/server/src/server.test.ts@@ -1790,7 +1790,20 @@ it.layer(NodeServices.layer)("server router seam", (it) => {it.effect("routes websocket rpc subscribeServerConfig streams snapshot then update", () =>Effect.gen(function* () {- const providers = [] as const;+ const providers = [+ {+ provider: "codex" as const,+ enabled: true,+ installed: true,+ version: "1.0.0",+ status: "ready" as const,+ auth: { status: "authenticated" as const },+ checkedAt: "2026-04-11T00:00:00.000Z",+ models: [],+ slashCommands: [],+ skills: [],+ },+ ] as const;const changeEvent = {keybindings: [],issues: [],@@ -1847,7 +1860,20 @@ it.layer(NodeServices.layer)("server router seam", (it) => {it.effect("routes websocket rpc subscribeServerConfig emits provider status updates", () =>Effect.gen(function* () {- const providers = [] as const;+ const nextProviders = [+ {+ provider: "codex" as const,+ enabled: true,+ installed: true,+ version: "1.0.0",+ status: "ready" as const,+ auth: { status: "authenticated" as const },+ checkedAt: "2026-04-11T00:00:00.000Z",+ models: [],+ slashCommands: [],+ skills: [],+ },+ ] as const;yield* buildAppUnderTest({layers: {@@ -1860,7 +1886,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => {},providerRegistry: {getProviders: Effect.succeed([]),- streamChanges: Stream.succeed(providers),+ streamChanges: Stream.succeed(nextProviders),},},});@@ -1874,10 +1900,13 @@ it.layer(NodeServices.layer)("server router seam", (it) => {const [first, second] = Array.from(events);assert.equal(first?.type, "snapshot");+ if (first?.type === "snapshot") {+ assert.deepEqual(first.config.providers, []);+ }assert.deepEqual(second, {version: 1,type: "providerStatuses",- payload: { providers },+ payload: { providers: nextProviders },});}).pipe(Effect.provide(NodeHttpServer.layerTest)),);diff --git a/apps/server/src/serverRuntimeStartup.test.ts b/apps/server/src/serverRuntimeStartup.test.tsindex 7e8c0e14b..836b71c7e 100644--- a/apps/server/src/serverRuntimeStartup.test.ts+++ b/apps/server/src/serverRuntimeStartup.test.ts@@ -1,13 +1,21 @@-import { DEFAULT_MODEL_BY_PROVIDER } from "@t3tools/contracts";+import * as NodeServices from "@effect/platform-node/NodeServices";+import { DEFAULT_MODEL_BY_PROVIDER, ProjectId, ThreadId } from "@t3tools/contracts";import { assert, it } from "@effect/vitest";-import { Deferred, Effect, Fiber, Option, Ref } from "effect";+import { Deferred, Effect, Fiber, Option, Ref, Stream } from "effect";-import { AnalyticsService } from "./telemetry/Services/AnalyticsService.ts";+import { ServerConfig } from "./config.ts";+import {+ OrchestrationEngineService,+ type OrchestrationEngineShape,+} from "./orchestration/Services/OrchestrationEngine.ts";import { ProjectionSnapshotQuery } from "./orchestration/Services/ProjectionSnapshotQuery.ts";+import { AnalyticsService } from "./telemetry/Services/AnalyticsService.ts";import {getAutoBootstrapDefaultModelSelection,launchStartupHeartbeat,makeCommandGate,+ resolveAutoBootstrapWelcomeTargets,+ resolveWelcomeBase,ServerRuntimeStartupError,} from "./serverRuntimeStartup.ts";@@ -93,3 +101,109 @@ it.effect("launchStartupHeartbeat does not block the caller while counts are loa}),),);++it.effect("resolveWelcomeBase derives cwd and project name from server config", () =>+ Effect.gen(function* () {+ const welcome = yield* resolveWelcomeBase.pipe(+ Effect.provideService(ServerConfig, {+ cwd: "/tmp/startup-project",+ } as never),+ );++ assert.deepStrictEqual(welcome, {+ cwd: "/tmp/startup-project",+ projectName: "startup-project",+ });+ }),+);++it.effect("resolveAutoBootstrapWelcomeTargets returns existing project and thread ids", () => {+ const bootstrapProjectId = ProjectId.make("project-startup-bootstrap");+ const bootstrapThreadId = ThreadId.make("thread-startup-bootstrap");++ return Effect.gen(function* () {+ const dispatchCalls = yield* Ref.make<ReadonlyArray<string>>([]);+ const targets = yield* resolveAutoBootstrapWelcomeTargets.pipe(+ Effect.provideService(ServerConfig, {+ cwd: "/tmp/startup-project",+ autoBootstrapProjectFromCwd: true,+ } as never),+ Effect.provideService(ProjectionSnapshotQuery, {+ getSnapshot: () => Effect.die("unused"),+ getShellSnapshot: () => Effect.die("unused"),+ getCounts: () => Effect.die("unused"),+ getActiveProjectByWorkspaceRoot: () =>+ Effect.succeed(+ Option.some({+ id: bootstrapProjectId,+ title: "Startup Project",+ workspaceRoot: "/tmp/startup-project",+ defaultModelSelection: getAutoBootstrapDefaultModelSelection(),+ scripts: [],+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-01T00:00:00.000Z",+ deletedAt: null,+ }),+ ),+ getProjectShellById: () => Effect.die("unused"),+ getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.some(bootstrapThreadId)),+ getThreadCheckpointContext: () => Effect.succeed(Option.none()),+ getThreadShellById: () => Effect.die("unused"),+ getThreadDetailById: () => Effect.die("unused"),+ }),+ Effect.provideService(OrchestrationEngineService, {+ getReadModel: () => Effect.die("unused"),+ readEvents: () => Stream.empty,+ dispatch: (command) =>+ Ref.update(dispatchCalls, (calls) => [...calls, command.type]).pipe(+ Effect.as({ sequence: 1 }),+ ),+ streamDomainEvents: Stream.empty,+ } satisfies OrchestrationEngineShape),+ Effect.provide(NodeServices.layer),+ );++ assert.deepStrictEqual(targets, {+ bootstrapProjectId,+ bootstrapThreadId,+ });+ assert.deepStrictEqual(yield* Ref.get(dispatchCalls), []);+ });+});++it.effect("resolveAutoBootstrapWelcomeTargets creates a project and thread when missing", () =>+ Effect.gen(function* () {+ const dispatchCalls = yield* Ref.make<ReadonlyArray<string>>([]);+ const targets = yield* resolveAutoBootstrapWelcomeTargets.pipe(+ Effect.provideService(ServerConfig, {+ cwd: "/tmp/startup-project",+ autoBootstrapProjectFromCwd: true,+ } as never),+ Effect.provideService(ProjectionSnapshotQuery, {+ getSnapshot: () => Effect.die("unused"),+ getShellSnapshot: () => Effect.die("unused"),+ getCounts: () => Effect.die("unused"),+ getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),+ getProjectShellById: () => Effect.die("unused"),+ getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),+ getThreadCheckpointContext: () => Effect.succeed(Option.none()),+ getThreadShellById: () => Effect.die("unused"),+ getThreadDetailById: () => Effect.die("unused"),+ }),+ Effect.provideService(OrchestrationEngineService, {+ getReadModel: () => Effect.die("unused"),+ readEvents: () => Stream.empty,+ dispatch: (command) =>+ Ref.update(dispatchCalls, (calls) => [...calls, command.type]).pipe(+ Effect.as({ sequence: 1 }),+ ),+ streamDomainEvents: Stream.empty,+ } satisfies OrchestrationEngineShape),+ Effect.provide(NodeServices.layer),+ );++ assert.equal(typeof targets.bootstrapProjectId, "string");+ assert.equal(typeof targets.bootstrapThreadId, "string");+ assert.deepStrictEqual(yield* Ref.get(dispatchCalls), ["project.create", "thread.create"]);+ }),+);diff --git a/apps/server/src/serverRuntimeStartup.ts b/apps/server/src/serverRuntimeStartup.tsindex 441df3395..823e3b477 100644--- a/apps/server/src/serverRuntimeStartup.ts+++ b/apps/server/src/serverRuntimeStartup.ts@@ -157,7 +157,18 @@ export const getAutoBootstrapDefaultModelSelection = (): ModelSelection => ({model: DEFAULT_MODEL_BY_PROVIDER.codex,});-const autoBootstrapWelcome = Effect.gen(function* () {+export const resolveWelcomeBase = Effect.gen(function* () {+ const serverConfig = yield* ServerConfig;+ const segments = serverConfig.cwd.split(/[/\\]/).filter(Boolean);+ const projectName = segments[segments.length - 1] ?? "project";++ return {+ cwd: serverConfig.cwd,+ projectName,+ } as const;+});++export const resolveAutoBootstrapWelcomeTargets = Effect.gen(function* () {const serverConfig = yield* ServerConfig;const projectionReadModelQuery = yield* ProjectionSnapshotQuery;const orchestrationEngine = yield* OrchestrationEngineService;@@ -221,12 +232,7 @@ const autoBootstrapWelcome = Effect.gen(function* () {});}- const segments = serverConfig.cwd.split(/[/\\]/).filter(Boolean);- const projectName = segments[segments.length - 1] ?? "project";-return {- cwd: serverConfig.cwd,- projectName,...(bootstrapProjectId ? { bootstrapProjectId } : {}),...(bootstrapThreadId ? { bootstrapThreadId } : {}),} as const;@@ -271,7 +277,7 @@ const runStartupPhase = <A, E, R>(phase: string, effect: Effect.Effect<A, E, R>)Effect.withSpan(`server.startup.${phase}`),);-const makeServerRuntimeStartup = Effect.gen(function* () {+export const makeServerRuntimeStartup = Effect.gen(function* () {const serverConfig = yield* ServerConfig;const keybindings = yield* Keybindings;const orchestrationReactor = yield* OrchestrationReactor;@@ -322,15 +328,13 @@ const makeServerRuntimeStartup = Effect.gen(function* () {orchestrationReactor.start().pipe(Scope.provide(reactorScope)),);- yield* Effect.logDebug("startup phase: preparing welcome payload");- const welcome = yield* runStartupPhase("welcome.prepare", autoBootstrapWelcome);+ const welcomeBase = yield* resolveWelcomeBase;const environment = yield* serverEnvironment.getDescriptor;+ yield* Effect.logDebug("startup phase: preparing welcome payload");yield* Effect.logDebug("startup phase: publishing welcome event", {environmentId: environment.environmentId,- cwd: welcome.cwd,- projectName: welcome.projectName,- bootstrapProjectId: welcome.bootstrapProjectId,- bootstrapThreadId: welcome.bootstrapThreadId,+ cwd: welcomeBase.cwd,+ projectName: welcomeBase.projectName,});yield* runStartupPhase("welcome.publish",@@ -339,10 +343,47 @@ const makeServerRuntimeStartup = Effect.gen(function* () {type: "welcome",payload: {environment,- ...welcome,+ ...welcomeBase,},}),);++ if (serverConfig.autoBootstrapProjectFromCwd) {+ yield* Effect.forkScoped(+ runStartupPhase(+ "welcome.autobootstrap",+ Effect.gen(function* () {+ const bootstrapTargets = yield* resolveAutoBootstrapWelcomeTargets;+ if (!bootstrapTargets.bootstrapProjectId && !bootstrapTargets.bootstrapThreadId) {+ return;+ }++ yield* Effect.logDebug("startup phase: publishing bootstrapped welcome event", {+ environmentId: environment.environmentId,+ cwd: welcomeBase.cwd,+ projectName: welcomeBase.projectName,+ bootstrapProjectId: bootstrapTargets.bootstrapProjectId,+ bootstrapThreadId: bootstrapTargets.bootstrapThreadId,+ });+ yield* lifecycleEvents.publish({+ version: 1,+ type: "welcome",+ payload: {+ environment,+ ...welcomeBase,+ ...bootstrapTargets,+ },+ });+ }).pipe(+ Effect.catch((cause) =>+ Effect.logWarning("startup auto-bootstrap welcome failed", {+ cause,+ }),+ ),+ ),+ ),+ );+ }}).pipe(Effect.annotateSpans({"server.mode": serverConfig.mode,diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.tsindex c685bbc76..3214cef80 100644--- a/apps/server/src/ws.ts+++ b/apps/server/src/ws.ts@@ -1,4 +1,4 @@-import { Cause, Effect, Layer, Option, Queue, Ref, Schema, Stream } from "effect";+import { Cause, Duration, Effect, Layer, Option, Queue, Ref, Schema, Stream } from "effect";import {type AuthAccessStreamEvent,AuthSessionId,@@ -85,6 +85,8 @@ function isThreadDetailEvent(event: OrchestrationEvent): event is Extract<);}+const PROVIDER_STATUS_DEBOUNCE_MS = 200;+function toAuthAccessStreamEvent(change: BootstrapCredentialChange | SessionCredentialChange,revision: number,@@ -919,6 +921,7 @@ const makeWsRpcLayer = (currentSessionId: AuthSessionId) =>type: "providerStatuses" as const,payload: { providers },})),+ Stream.debounce(Duration.millis(PROVIDER_STATUS_DEBOUNCE_MS)),);const settingsUpdates = serverSettings.streamChanges.pipe(Stream.map((settings) => ({@@ -928,13 +931,26 @@ const makeWsRpcLayer = (currentSessionId: AuthSessionId) =>})),);+ yield* Effect.all(+ [providerRegistry.refresh("codex"), providerRegistry.refresh("claudeAgent")],+ {+ concurrency: "unbounded",+ discard: true,+ },+ ).pipe(Effect.ignoreCause({ log: true }), Effect.forkScoped);++ const liveUpdates = Stream.merge(+ keybindingsUpdates,+ Stream.merge(providerStatuses, settingsUpdates),+ );+return Stream.concat(Stream.make({version: 1 as const,type: "snapshot" as const,config: yield* loadServerConfig,}),- Stream.merge(keybindingsUpdates, Stream.merge(providerStatuses, settingsUpdates)),+ liveUpdates,);}),{ "rpc.aggregate": "server" },