Skip to content

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.

chore: effect rpc and layer based startup (#929)

Julius Marminged8aa2f85dfd7
diff --git a/.oxfmtrc.json b/.oxfmtrc.json
index ef2236d0f..a3e32c979 100644
--- a/.oxfmtrc.json
+++ b/.oxfmtrc.json
@@ -1,6 +1,7 @@
{
"$schema": "./node_modules/oxfmt/configuration_schema.json",
"ignorePatterns": [
+ ".reference",
".plans",
"dist",
"dist-electron",
diff --git a/.plans/effect-atom.md b/.plans/effect-atom.md
new file mode 100644
index 000000000..ff6894f56
--- /dev/null
+++ b/.plans/effect-atom.md
@@ -0,0 +1,89 @@
+# Replace React Query With AtomRpc + Atom State
+
+## Summary
+- Use `effect/unstable/reactivity/AtomRpc` over the existing `WsRpcGroup`; stop wrapping RPC in promises via [wsRpcClient.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsRpcClient.ts) and [wsNativeApi.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsNativeApi.ts).
+- Keep Zustand for orchestration read model and UI state.
+- Keep a narrow `desktopBridge` adapter for dialogs, menus, external links, theme, and updater APIs.
+- Do not introduce Suspense in this migration. Atom-backed hooks should keep returning `data`, `error`, `isLoading|isPending`, `refresh`, and `mutateAsync`-style surfaces so component churn stays low.
+
+## Target Architecture
+- Extract the websocket `RpcClient.Protocol` layer from [wsTransport.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsTransport.ts) into `rpc/protocol.ts`.
+- Define one `AtomRpc.Service` for `WsRpcGroup` in `rpc/client.ts`.
+- Add `rpc/invalidation.ts` with explicit scoped invalidation keys: `git:${cwd}`, `project:${cwd}`, `checkpoint:${threadId}`, `server-config`.
+- Add `platform/desktopBridge.ts` as the only browser/desktop facade.
+- Remove from web by the end: [wsNativeApi.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsNativeApi.ts), [nativeApi.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/nativeApi.ts), [wsNativeApiState.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsNativeApiState.ts), [wsNativeApiAtoms.tsx](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsNativeApiAtoms.tsx), [wsRpcClient.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsRpcClient.ts), and all `*ReactQuery.ts` modules.
+
+## Phase 1: Infrastructure First
+1. Extract the shared websocket RPC protocol layer from [wsTransport.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsTransport.ts) without changing behavior.
+2. Build the AtomRpc client on top of that layer.
+3. Add one temporary `runRpc` helper for imperative handlers that still want `Promise` ergonomics; it must call the AtomRpc service directly and must not reintroduce a facade object.
+4. Replace manual registry wiring with one app-level registry provider based on `@effect/atom-react`.
+5. Land this as a no-behavior-change PR.
+
+## Phase 2: Replace `wsNativeApi`-Owned Push State
+1. Migrate welcome/config/provider/settings state first, because it is already atom-shaped and is the lowest-risk way to delete `wsNativeApi` responsibilities.
+2. Replace [wsNativeApiState.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsNativeApiState.ts) with `rpc/serverState.ts`, updated directly from `subscribeServerLifecycle` and `subscribeServerConfig`.
+3. Keep the current hook names for one PR: `useServerConfig`, `useServerSettings`, `useServerProviders`, `useServerKeybindings`, `useServerWelcomeSubscription`, `useServerConfigUpdatedSubscription`.
+4. Move bootstrap side effects out of [wsNativeApiAtoms.tsx](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsNativeApiAtoms.tsx) into a new root bootstrap component mounted from [__root.tsx](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/routes/__root.tsx).
+5. Delete the `server.getConfig()` fallback logic from [wsNativeApi.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsNativeApi.ts); snapshot fetch now lives beside the stream atoms.
+
+## Phase 3: Replace React Query Domain By Domain
+1. Replace [gitReactQuery.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/lib/gitReactQuery.ts) first.
+2. Add `rpc/gitAtoms.ts` and `rpc/useGit.ts` with `useGitStatus`, `useGitBranches`, `useResolvePullRequest`, and `useGitMutation`.
+3. Mutation settlement must invalidate scoped keys, not a global cache. `checkout`, `pull`, `init`, `createWorktree`, `removeWorktree`, `preparePullRequestThread`, and stacked actions invalidate `git:${cwd}`. Worktree create/remove also invalidates `project:${cwd}`.
+4. Replace [projectReactQuery.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/lib/projectReactQuery.ts) second. `useProjectSearchEntries` must preserve current “keep previous results while loading” behavior.
+5. Replace [providerReactQuery.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/lib/providerReactQuery.ts) third. Preserve current checkpoint error normalization and retry/backoff semantics inside the atom effect. Invalidate by `checkpoint:${threadId}`.
+6. Defer the desktop updater until the last phase.
+
+## Phase 4: Move Root Invalidation Off `queryClient`
+1. In [__root.tsx](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/routes/__root.tsx), remove `QueryClient` usage and replace the throttled `invalidateQueries` block with throttled invalidation helpers.
+2. Keep Zustand orchestration/event application unchanged.
+3. Map current effects exactly:
+- git or checkpoint-affecting orchestration events touch `checkpoint:${threadId}`
+- file creation/deletion/restoration touches `project:${cwd}`
+- config-affecting server events touch `server-config`
+
+## Phase 5: Remove Imperative `NativeApi` Usage
+1. Create narrow modules instead of a replacement mega-facade:
+- `rpc/orchestrationActions.ts`
+- `rpc/terminalActions.ts`
+- `rpc/gitActions.ts`
+- `rpc/projectActions.ts`
+- `platform/desktopBridge.ts`
+2. Migrate direct [nativeApi.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/nativeApi.ts) callers by domain, not file-by-file: git-heavy components first, then orchestration/thread actions, then shell/dialog helpers.
+3. After the last caller is gone, delete [nativeApi.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/nativeApi.ts) and the `window.nativeApi` fallback entirely.
+4. In the final cleanup PR, remove `NativeApi` from [ipc.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/packages/contracts/src/ipc.ts) if nothing outside web still needs it.
+
+## Phase 6: Remove React Query Completely
+1. Delete `@tanstack/react-query` from `apps/web/package.json`.
+2. Remove `QueryClientProvider` and router context from [router.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/router.ts) and [__root.tsx](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/routes/__root.tsx).
+3. Replace [desktopUpdateReactQuery.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/lib/desktopUpdateReactQuery.ts) with a writable atom plus `desktopBridge.onUpdateState`.
+4. Delete the old query-option tests.
+
+## Public Interfaces And Types
+- Preserve the current server-state hook names during the transition.
+- Add permanent domain hooks: `useGitStatus`, `useGitBranches`, `useResolvePullRequest`, `useProjectSearchEntries`, `useCheckpointDiff`, `useDesktopUpdateState`.
+- Do not expose raw AtomRpc clients to components.
+- Do not add Suspense as part of this migration.
+- Final boundary is direct RPC for server features plus `desktopBridge` for local desktop features.
+
+## Test Plan
+- Add unit tests for `rpc/serverState.ts`: snapshot bootstrapping, stream replay, provider/settings updates.
+- Add unit tests for git/project/checkpoint hooks: loading, error mapping, retry behavior, invalidation, keep-previous-result behavior.
+- Update the browser harness in [wsRpcHarness.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/test/wsRpcHarness.ts) to assert direct RPC + atom behavior instead of `__resetNativeApiForTests`.
+- Replace [wsNativeApi.test.ts](/Users/julius/.t3/worktrees/codething-mvp/effect-http-router/apps/web/src/wsNativeApi.test.ts), `gitReactQuery.test.ts`, `providerReactQuery.test.ts`, and `desktopUpdateReactQuery.test.ts` with equivalent atom-backed coverage.
+- Acceptance scenarios:
+- welcome still bootstraps snapshot and navigation
+- keybindings toast still responds to config stream updates
+- git status/branches refresh after checkout/pull/worktree actions
+- PR resolve dialog keeps cached result while typing
+- `@` path search refreshes after file mutations and orchestration events
+- diff panel refreshes when checkpoints arrive
+- desktop updater still reflects push events and button actions
+
+## Assumptions And Defaults
+- Zustand stays in scope; only `react-query` is being removed.
+- `desktopBridge` remains the only non-RPC boundary.
+- The migration lands as 5-6 small PRs, each green independently.
+- Invalidations are explicit and scoped; do not recreate a global cache client abstraction.
+- Orchestration recovery/order logic stays as-is; only the data-fetching and mutation layer changes.
diff --git a/apps/desktop/scripts/dev-electron.mjs b/apps/desktop/scripts/dev-electron.mjs
index 1506d80e9..5244d51db 100644
--- a/apps/desktop/scripts/dev-electron.mjs
+++ b/apps/desktop/scripts/dev-electron.mjs
@@ -10,11 +10,11 @@ const devServerUrl = `http://localhost:${port}`;
const requiredFiles = [
"dist-electron/main.js",
"dist-electron/preload.js",
- "../server/dist/index.mjs",
+ "../server/dist/bin.mjs",
];
const watchedDirectories = [
{ directory: "dist-electron", files: new Set(["main.js", "preload.js"]) },
- { directory: "../server/dist", files: new Set(["index.mjs"]) },
+ { directory: "../server/dist", files: new Set(["bin.mjs"]) },
];
const forcedShutdownTimeoutMs = 1_500;
const restartDebounceMs = 120;
diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts
index 6954dc9e3..34391a599 100644
--- a/apps/desktop/src/main.ts
+++ b/apps/desktop/src/main.ts
@@ -399,7 +399,7 @@ function resolveAboutCommitHash(): string | null {
}
function resolveBackendEntry(): string {
- return Path.join(resolveAppRoot(), "apps/server/dist/index.mjs");
+ return Path.join(resolveAppRoot(), "apps/server/dist/bin.mjs");
}
function resolveBackendCwd(): string {
diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts
index 9340b9460..408ea827c 100644
--- a/apps/server/integration/OrchestrationEngineHarness.integration.ts
+++ b/apps/server/integration/OrchestrationEngineHarness.integration.ts
@@ -69,6 +69,7 @@ import {
} from "./TestProviderAdapter.integration.ts";
import { deriveServerPaths, ServerConfig } from "../src/config.ts";
import { WorkspaceEntriesLive } from "../src/workspace/Layers/WorkspaceEntries.ts";
+import { WorkspacePathsLive } from "../src/workspace/Layers/WorkspacePaths.ts";
function runGit(cwd: string, args: ReadonlyArray<string>) {
return execFileSync("git", args, {
@@ -125,7 +126,7 @@ function waitFor<A, E>(
read: Effect.Effect<A, E>,
predicate: (value: A) => boolean,
description: string,
- timeoutMs = 10_000,
+ timeoutMs = 40_000,
): Effect.Effect<A, never> {
const RETRY_SIGNAL = "wait_for_retry";
const retryIntervalMs = 10;
@@ -320,10 +321,12 @@ export const makeOrchestrationIntegrationHarness = (
Layer.provideMerge(runtimeServicesLayer),
Layer.provideMerge(
WorkspaceEntriesLive.pipe(
+ Layer.provide(WorkspacePathsLive),
Layer.provideMerge(gitCoreLayer),
Layer.provide(NodeServices.layer),
),
),
+ Layer.provideMerge(WorkspacePathsLive),
);
const orchestrationReactorLayer = OrchestrationReactorLive.pipe(
Layer.provideMerge(runtimeIngestionLayer),
diff --git a/apps/server/integration/orchestrationEngine.integration.test.ts b/apps/server/integration/orchestrationEngine.integration.test.ts
index d6b100474..a5cc8f8cc 100644
--- a/apps/server/integration/orchestrationEngine.integration.test.ts
+++ b/apps/server/integration/orchestrationEngine.integration.test.ts
@@ -57,7 +57,7 @@ function waitForSync<A>(
read: () => A,
predicate: (value: A) => boolean,
description: string,
- timeoutMs = 3000,
+ timeoutMs = 10_000,
): Effect.Effect<A, never> {
return Effect.gen(function* () {
const deadline = Date.now() + timeoutMs;
diff --git a/apps/server/package.json b/apps/server/package.json
index e473e21fd..e59c7c208 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -8,29 +8,29 @@
"directory": "apps/server"
},
"bin": {
- "t3": "./dist/index.mjs"
+ "t3": "./dist/bin.mjs"
},
"files": [
"dist"
],
"type": "module",
"scripts": {
- "dev": "bun run src/index.ts",
+ "dev": "bun run src/bin.ts",
"build": "node scripts/cli.ts build",
- "start": "node dist/index.mjs",
+ "start": "node dist/bin.mjs",
"prepare": "effect-language-service patch",
"typecheck": "tsc --noEmit",
"test": "vitest run"
},
"dependencies": {
"@anthropic-ai/claude-agent-sdk": "^0.2.77",
+ "@effect/platform-bun": "catalog:",
"@effect/platform-node": "catalog:",
"@effect/sql-sqlite-bun": "catalog:",
"@pierre/diffs": "^1.1.0-beta.16",
"effect": "catalog:",
"node-pty": "^1.1.0",
- "open": "^10.1.0",
- "ws": "^8.18.0"
+ "open": "^10.1.0"
},
"devDependencies": {
"@effect/language-service": "catalog:",
@@ -40,7 +40,6 @@
"@t3tools/web": "workspace:*",
"@types/bun": "catalog:",
"@types/node": "catalog:",
- "@types/ws": "^8.5.13",
"tsdown": "catalog:",
"typescript": "catalog:",
"vitest": "catalog:"
diff --git a/apps/server/src/bin.ts b/apps/server/src/bin.ts
new file mode 100644
index 000000000..063d43326
--- /dev/null
+++ b/apps/server/src/bin.ts
@@ -0,0 +1,17 @@
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Command } from "effect/unstable/cli";
+
+import { NetService } from "@t3tools/shared/Net";
+import { cli } from "./cli";
+import { version } from "../package.json" with { type: "json" };
+
+const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer);
+
+Command.run(cli, { version }).pipe(
+ Effect.scoped,
+ Effect.provide(CliRuntimeLayer),
+ NodeRuntime.runMain,
+);
diff --git a/apps/server/src/checkpointing/Errors.ts b/apps/server/src/checkpointing/Errors.ts
index 782d0918e..cb873559c 100644
--- a/apps/server/src/checkpointing/Errors.ts
+++ b/apps/server/src/checkpointing/Errors.ts
@@ -1,6 +1,6 @@
import { Schema } from "effect";
import type { ProjectionRepositoryError } from "../persistence/Errors.ts";
-import { GitCommandError } from "../git/Errors.ts";
+import { GitCommandError } from "@t3tools/contracts";
/**
* CheckpointUnavailableError - Expected checkpoint does not exist.
diff --git a/apps/server/src/checkpointing/Layers/CheckpointStore.test.ts b/apps/server/src/checkpointing/Layers/CheckpointStore.test.ts
index c430dbbde..7df1c71c2 100644
--- a/apps/server/src/checkpointing/Layers/CheckpointStore.test.ts
+++ b/apps/server/src/checkpointing/Layers/CheckpointStore.test.ts
@@ -10,7 +10,7 @@ import { CheckpointStoreLive } from "./CheckpointStore.ts";
import { CheckpointStore } from "../Services/CheckpointStore.ts";
import { GitCoreLive } from "../../git/Layers/GitCore.ts";
import { GitCore } from "../../git/Services/GitCore.ts";
-import { GitCommandError } from "../../git/Errors.ts";
+import { GitCommandError } from "@t3tools/contracts";
import { ServerConfig } from "../../config.ts";
import { ThreadId } from "@t3tools/contracts";
diff --git a/apps/server/src/checkpointing/Layers/CheckpointStore.ts b/apps/server/src/checkpointing/Layers/CheckpointStore.ts
index b20204780..0a1d7abb9 100644
--- a/apps/server/src/checkpointing/Layers/CheckpointStore.ts
+++ b/apps/server/src/checkpointing/Layers/CheckpointStore.ts
@@ -14,7 +14,7 @@ import { randomUUID } from "node:crypto";
import { Effect, Layer, FileSystem, Path } from "effect";
import { CheckpointInvariantError } from "../Errors.ts";
-import { GitCommandError } from "../../git/Errors.ts";
+import { GitCommandError } from "@t3tools/contracts";
import { GitCore } from "../../git/Services/GitCore.ts";
import { CheckpointStore, type CheckpointStoreShape } from "../Services/CheckpointStore.ts";
import { CheckpointRef } from "@t3tools/contracts";
diff --git a/apps/server/src/cli-config.test.ts b/apps/server/src/cli-config.test.ts
new file mode 100644
index 000000000..27bc60b1b
--- /dev/null
+++ b/apps/server/src/cli-config.test.ts
@@ -0,0 +1,318 @@
+import os from "node:os";
+
+import { assert, expect, it } from "@effect/vitest";
+import { ConfigProvider, Effect, FileSystem, Layer, Option, Path } from "effect";
+
+import { NetService } from "@t3tools/shared/Net";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { deriveServerPaths } from "./config";
+import { resolveServerConfig } from "./cli";
+
+it.layer(NodeServices.layer)("cli config resolution", (it) => {
+ const openBootstrapFd = Effect.fn(function* (payload: Record<string, unknown>) {
+ const fs = yield* FileSystem.FileSystem;
+ const filePath = yield* fs.makeTempFileScoped({ prefix: "t3-bootstrap-", suffix: ".ndjson" });
+ yield* fs.writeFileString(filePath, `${JSON.stringify(payload)}\n`);
+ const { fd } = yield* fs.open(filePath, { flag: "r" });
+ return fd;
+ });
+
+ it.effect("falls back to effect/config values when flags are omitted", () =>
+ Effect.gen(function* () {
+ const { join } = yield* Path.Path;
+ const baseDir = join(os.tmpdir(), "t3-cli-config-env-base");
+ const derivedPaths = yield* deriveServerPaths(baseDir, new URL("http://127.0.0.1:5173"));
+ const resolved = yield* resolveServerConfig(
+ {
+ mode: Option.none(),
+ port: Option.none(),
+ host: Option.none(),
+ baseDir: Option.none(),
+ devUrl: Option.none(),
+ noBrowser: Option.none(),
+ authToken: Option.none(),
+ bootstrapFd: Option.none(),
+ autoBootstrapProjectFromCwd: Option.none(),
+ logWebSocketEvents: Option.none(),
+ },
+ Option.none(),
+ ).pipe(
+ Effect.provide(
+ Layer.mergeAll(
+ ConfigProvider.layer(
+ ConfigProvider.fromEnv({
+ env: {
+ T3CODE_LOG_LEVEL: "Warn",
+ T3CODE_MODE: "desktop",
+ T3CODE_PORT: "4001",
+ T3CODE_HOST: "0.0.0.0",
+ T3CODE_HOME: baseDir,
+ VITE_DEV_SERVER_URL: "http://127.0.0.1:5173",
+ T3CODE_NO_BROWSER: "true",
+ T3CODE_AUTH_TOKEN: "env-token",
+ T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD: "false",
+ T3CODE_LOG_WS_EVENTS: "true",
+ },
+ }),
+ ),
+ NetService.layer,
+ ),
+ ),
+ );
+
+ expect(resolved).toEqual({
+ logLevel: "Warn",
+ mode: "desktop",
+ port: 4001,
+ cwd: process.cwd(),
+ baseDir,
+ ...derivedPaths,
+ host: "0.0.0.0",
+ staticDir: undefined,
+ devUrl: new URL("http://127.0.0.1:5173"),
+ noBrowser: true,
+ authToken: "env-token",
+ autoBootstrapProjectFromCwd: false,
+ logWebSocketEvents: true,
+ });
+ }),
+ );
+
+ it.effect("uses CLI flags when provided", () =>
+ Effect.gen(function* () {
+ const { join } = yield* Path.Path;
+ const baseDir = join(os.tmpdir(), "t3-cli-config-flags-base");
+ const derivedPaths = yield* deriveServerPaths(baseDir, new URL("http://127.0.0.1:4173"));
+ const resolved = yield* resolveServerConfig(
+ {
+ mode: Option.some("web"),
+ port: Option.some(8788),
+ host: Option.some("127.0.0.1"),
+ baseDir: Option.some(baseDir),
+ devUrl: Option.some(new URL("http://127.0.0.1:4173")),
+ noBrowser: Option.some(true),
+ authToken: Option.some("flag-token"),
+ bootstrapFd: Option.none(),
+ autoBootstrapProjectFromCwd: Option.some(true),
+ logWebSocketEvents: Option.some(true),
+ },
+ Option.some("Debug"),
+ ).pipe(
+ Effect.provide(
+ Layer.mergeAll(
+ ConfigProvider.layer(
+ ConfigProvider.fromEnv({
+ env: {
+ T3CODE_LOG_LEVEL: "Warn",
+ T3CODE_MODE: "desktop",
+ T3CODE_PORT: "4001",
+ T3CODE_HOST: "0.0.0.0",
+ T3CODE_HOME: join(os.tmpdir(), "ignored-base"),
+ VITE_DEV_SERVER_URL: "http://127.0.0.1:5173",
+ T3CODE_NO_BROWSER: "false",
+ T3CODE_AUTH_TOKEN: "ignored-token",
+ T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD: "false",
+ T3CODE_LOG_WS_EVENTS: "false",
+ },
+ }),
+ ),
+ NetService.layer,
+ ),
+ ),
+ );
+
+ expect(resolved).toEqual({
+ logLevel: "Debug",
+ mode: "web",
+ port: 8788,
+ cwd: process.cwd(),
+ baseDir,
+ ...derivedPaths,
+ host: "127.0.0.1",
+ staticDir: undefined,
+ devUrl: new URL("http://127.0.0.1:4173"),
+ noBrowser: true,
+ authToken: "flag-token",
+ autoBootstrapProjectFromCwd: true,
+ logWebSocketEvents: true,
+ });
+ }),
+ );
+
+ it.effect("uses bootstrap envelope values as fallbacks when flags and env are absent", () =>
+ Effect.gen(function* () {
+ const { join } = yield* Path.Path;
+ const baseDir = "/tmp/t3-bootstrap-home";
+ const fd = yield* openBootstrapFd({
+ mode: "desktop",
+ port: 4888,
+ host: "127.0.0.2",
+ t3Home: baseDir,
+ devUrl: "http://127.0.0.1:5173",
+ noBrowser: true,
+ authToken: "bootstrap-token",
+ autoBootstrapProjectFromCwd: false,
+ logWebSocketEvents: true,
+ });
+ const derivedPaths = yield* deriveServerPaths(baseDir, new URL("http://127.0.0.1:5173"));
+
+ const resolved = yield* resolveServerConfig(
+ {
+ mode: Option.none(),
+ port: Option.none(),
+ host: Option.none(),
+ baseDir: Option.none(),
+ devUrl: Option.none(),
+ noBrowser: Option.none(),
+ authToken: Option.none(),
+ bootstrapFd: Option.none(),
+ autoBootstrapProjectFromCwd: Option.none(),
+ logWebSocketEvents: Option.none(),
+ },
+ Option.none(),
+ ).pipe(
+ Effect.provide(
+ Layer.mergeAll(
+ ConfigProvider.layer(
+ ConfigProvider.fromEnv({
+ env: {
+ T3CODE_BOOTSTRAP_FD: String(fd),
+ },
+ }),
+ ),
+ NetService.layer,
+ ),
+ ),
+ );
+
+ expect(resolved).toEqual({
+ logLevel: "Info",
+ mode: "desktop",
+ port: 4888,
+ cwd: process.cwd(),
+ baseDir,
+ ...derivedPaths,
+ host: "127.0.0.2",
+ staticDir: undefined,
+ devUrl: new URL("http://127.0.0.1:5173"),
+ noBrowser: true,
+ authToken: "bootstrap-token",
+ autoBootstrapProjectFromCwd: false,
+ logWebSocketEvents: true,
+ });
+ assert.equal(join(baseDir, "dev"), resolved.stateDir);
+ }),
+ );
+
+ it.effect("creates derived runtime directories during config resolution", () =>
+ Effect.gen(function* () {
+ const fs = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-cli-config-dirs-" });
+
+ const resolved = yield* resolveServerConfig(
+ {
+ mode: Option.some("desktop"),
+ port: Option.some(4888),
+ host: Option.none(),
+ baseDir: Option.some(baseDir),
+ devUrl: Option.some(new URL("http://127.0.0.1:5173")),
+ noBrowser: Option.none(),
+ authToken: Option.none(),
+ bootstrapFd: Option.none(),
+ autoBootstrapProjectFromCwd: Option.none(),
+ logWebSocketEvents: Option.none(),
+ },
+ Option.none(),
+ ).pipe(
+ Effect.provide(
+ Layer.mergeAll(
+ ConfigProvider.layer(ConfigProvider.fromEnv({ env: {} })),
+ NetService.layer,
+ ),
+ ),
+ );
+
+ for (const directory of [
+ resolved.stateDir,
+ resolved.logsDir,
+ resolved.providerLogsDir,
+ resolved.terminalLogsDir,
+ resolved.attachmentsDir,
+ resolved.worktreesDir,
+ path.dirname(resolved.serverLogPath),
+ ]) {
+ expect(yield* fs.exists(directory)).toBe(true);
+ }
+ }),
+ );
+
+ it.effect("applies flag then env precedence over bootstrap envelope values", () =>
+ Effect.gen(function* () {
+ const { join } = yield* Path.Path;
+ const baseDir = join(os.tmpdir(), "t3-cli-config-env-wins");
+ const fd = yield* openBootstrapFd({
+ mode: "desktop",
+ port: 4888,
+ host: "127.0.0.2",
+ t3Home: "/tmp/t3-bootstrap-home",
+ devUrl: "http://127.0.0.1:5173",
+ noBrowser: false,
+ authToken: "bootstrap-token",
+ autoBootstrapProjectFromCwd: false,
+ logWebSocketEvents: false,
+ });
+ const derivedPaths = yield* deriveServerPaths(baseDir, new URL("http://127.0.0.1:4173"));
+
+ const resolved = yield* resolveServerConfig(
+ {
+ mode: Option.none(),
+ port: Option.some(8788),
+ host: Option.some("127.0.0.1"),
+ baseDir: Option.none(),
+ devUrl: Option.some(new URL("http://127.0.0.1:4173")),
+ noBrowser: Option.none(),
+ authToken: Option.some("flag-token"),
+ bootstrapFd: Option.none(),
+ autoBootstrapProjectFromCwd: Option.none(),
+ logWebSocketEvents: Option.none(),
+ },
+ Option.some("Debug"),
+ ).pipe(
+ Effect.provide(
+ Layer.mergeAll(
+ ConfigProvider.layer(
+ ConfigProvider.fromEnv({
+ env: {
+ T3CODE_MODE: "web",
+ T3CODE_BOOTSTRAP_FD: String(fd),
+ T3CODE_HOME: baseDir,
+ T3CODE_NO_BROWSER: "true",
+ T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD: "true",
+ T3CODE_LOG_WS_EVENTS: "true",
+ },
+ }),
+ ),
+ NetService.layer,
+ ),
+ ),
+ );
+
+ expect(resolved).toEqual({
+ logLevel: "Debug",
+ mode: "web",
+ port: 8788,
+ cwd: process.cwd(),
+ baseDir,
+ ...derivedPaths,
+ host: "127.0.0.1",
+ staticDir: undefined,
+ devUrl: new URL("http://127.0.0.1:4173"),
+ noBrowser: true,
+ authToken: "flag-token",
+ autoBootstrapProjectFromCwd: true,
+ logWebSocketEvents: true,
+ });
+ }),
+ );
+});
diff --git a/apps/server/src/cli.test.ts b/apps/server/src/cli.test.ts
new file mode 100644
index 000000000..fbbe26e6c
--- /dev/null
+++ b/apps/server/src/cli.test.ts
@@ -0,0 +1,37 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { NetService } from "@t3tools/shared/Net";
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as CliError from "effect/unstable/cli/CliError";
+import { Command } from "effect/unstable/cli";
+
+import { cli } from "./cli.ts";
+
+const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer);
+
+it.layer(NodeServices.layer)("cli log-level parsing", (it) => {
+ it.effect("accepts the built-in lowercase log-level flag values", () =>
+ Command.runWith(cli, { version: "0.0.0" })(["--log-level", "debug", "--version"]).pipe(
+ Effect.provide(CliRuntimeLayer),
+ ),
+ );
+
+ it.effect("rejects invalid log-level casing before launching the server", () =>
+ Effect.gen(function* () {
+ const error = yield* Command.runWith(cli, { version: "0.0.0" })([
+ "--log-level",
+ "Debug",
+ ]).pipe(Effect.provide(CliRuntimeLayer), Effect.flip);
+
+ if (!CliError.isCliError(error)) {
+ assert.fail(`Expected CliError, got ${String(error)}`);
+ }
+ if (error._tag !== "InvalidValue") {
+ assert.fail(`Expected InvalidValue, got ${error._tag}`);
+ }
+ assert.equal(error.option, "log-level");
+ assert.equal(error.value, "Debug");
+ }),
+ );
+});
diff --git a/apps/server/src/cli.ts b/apps/server/src/cli.ts
new file mode 100644
index 000000000..2f76d25b7
--- /dev/null
+++ b/apps/server/src/cli.ts
@@ -0,0 +1,292 @@
+import { NetService } from "@t3tools/shared/Net";
+import { Config, Effect, LogLevel, Option, Schema } from "effect";
+import { Command, Flag, GlobalFlag } from "effect/unstable/cli";
+
+import {
+ DEFAULT_PORT,
+ deriveServerPaths,
+ ensureServerDirectories,
+ resolveStaticDir,
+ ServerConfig,
+ RuntimeMode,
+ type ServerConfigShape,
+} from "./config";
+import { readBootstrapEnvelope } from "./bootstrap";
+import { resolveBaseDir } from "./os-jank";
+import { runServer } from "./server";
+
+const PortSchema = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 }));
+
+const BootstrapEnvelopeSchema = Schema.Struct({
+ mode: Schema.optional(RuntimeMode),
+ port: Schema.optional(PortSchema),
+ host: Schema.optional(Schema.String),
+ t3Home: Schema.optional(Schema.String),
+ devUrl: Schema.optional(Schema.URLFromString),
+ noBrowser: Schema.optional(Schema.Boolean),
+ authToken: Schema.optional(Schema.String),
+ autoBootstrapProjectFromCwd: Schema.optional(Schema.Boolean),
+ logWebSocketEvents: Schema.optional(Schema.Boolean),
+});
+
+const modeFlag = Flag.choice("mode", RuntimeMode.literals).pipe(
+ Flag.withDescription("Runtime mode. `desktop` keeps loopback defaults unless overridden."),
+ Flag.optional,
+);
+const portFlag = Flag.integer("port").pipe(
+ Flag.withSchema(PortSchema),
+ Flag.withDescription("Port for the HTTP/WebSocket server."),
+ Flag.optional,
+);
+const hostFlag = Flag.string("host").pipe(
+ Flag.withDescription("Host/interface to bind (for example 127.0.0.1, 0.0.0.0, or a Tailnet IP)."),
+ Flag.optional,
+);
+const baseDirFlag = Flag.string("base-dir").pipe(
+ Flag.withDescription("Base directory path (equivalent to T3CODE_HOME)."),
+ Flag.optional,
+);
+const devUrlFlag = Flag.string("dev-url").pipe(
+ Flag.withSchema(Schema.URLFromString),
+ Flag.withDescription("Dev web URL to proxy/redirect to (equivalent to VITE_DEV_SERVER_URL)."),
+ Flag.optional,
+);
+const noBrowserFlag = Flag.boolean("no-browser").pipe(
+ Flag.withDescription("Disable automatic browser opening."),
+ Flag.optional,
+);
+const authTokenFlag = Flag.string("auth-token").pipe(
+ Flag.withDescription("Auth token required for WebSocket connections."),
+ Flag.withAlias("token"),
+ Flag.optional,
+);
+const bootstrapFdFlag = Flag.integer("bootstrap-fd").pipe(
+ Flag.withSchema(Schema.Int),
+ Flag.withDescription("Read one-time bootstrap secrets from the given file descriptor."),
+ Flag.optional,
+);
+const autoBootstrapProjectFromCwdFlag = Flag.boolean("auto-bootstrap-project-from-cwd").pipe(
+ Flag.withDescription(
+ "Create a project for the current working directory on startup when missing.",
+ ),
+ Flag.optional,
+);
+const logWebSocketEventsFlag = Flag.boolean("log-websocket-events").pipe(
+ Flag.withDescription(
+ "Emit server-side logs for outbound WebSocket push traffic (equivalent to T3CODE_LOG_WS_EVENTS).",
+ ),
+ Flag.withAlias("log-ws-events"),
+ Flag.optional,
+);
+
+const EnvServerConfig = Config.all({
+ logLevel: Config.logLevel("T3CODE_LOG_LEVEL").pipe(Config.withDefault("Info")),
+ mode: Config.schema(RuntimeMode, "T3CODE_MODE").pipe(
+ Config.option,
+ Config.map(Option.getOrUndefined),
+ ),
+ port: Config.port("T3CODE_PORT").pipe(Config.option, Config.map(Option.getOrUndefined)),
+ host: Config.string("T3CODE_HOST").pipe(Config.option, Config.map(Option.getOrUndefined)),
+ t3Home: Config.string("T3CODE_HOME").pipe(Config.option, Config.map(Option.getOrUndefined)),
+ devUrl: Config.url("VITE_DEV_SERVER_URL").pipe(Config.option, Config.map(Option.getOrUndefined)),
+ noBrowser: Config.boolean("T3CODE_NO_BROWSER").pipe(
+ Config.option,
+ Config.map(Option.getOrUndefined),
+ ),
+ authToken: Config.string("T3CODE_AUTH_TOKEN").pipe(
+ Config.option,
+ Config.map(Option.getOrUndefined),
+ ),
+ bootstrapFd: Config.int("T3CODE_BOOTSTRAP_FD").pipe(
+ Config.option,
+ Config.map(Option.getOrUndefined),
+ ),
+ autoBootstrapProjectFromCwd: Config.boolean("T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD").pipe(
+ Config.option,
+ Config.map(Option.getOrUndefined),
+ ),
+ logWebSocketEvents: Config.boolean("T3CODE_LOG_WS_EVENTS").pipe(
+ Config.option,
+ Config.map(Option.getOrUndefined),
+ ),
+});
+
+interface CliServerFlags {
+ readonly mode: Option.Option<RuntimeMode>;
+ readonly port: Option.Option<number>;
+ readonly host: Option.Option<string>;
+ readonly baseDir: Option.Option<string>;
+ readonly devUrl: Option.Option<URL>;
+ readonly noBrowser: Option.Option<boolean>;
+ readonly authToken: Option.Option<string>;
+ readonly bootstrapFd: Option.Option<number>;
+ readonly autoBootstrapProjectFromCwd: Option.Option<boolean>;
+ readonly logWebSocketEvents: Option.Option<boolean>;
+}
+
+const resolveBooleanFlag = (flag: Option.Option<boolean>, envValue: boolean) =>
+ Option.getOrElse(Option.filter(flag, Boolean), () => envValue);
+
+const resolveOptionPrecedence = <Value>(
+ ...values: ReadonlyArray<Option.Option<Value>>
+): Option.Option<Value> => Option.firstSomeOf(values);
+
+export const resolveServerConfig = (
+ flags: CliServerFlags,
+ cliLogLevel: Option.Option<LogLevel.LogLevel>,
+) =>
+ Effect.gen(function* () {
+ const { findAvailablePort } = yield* NetService;
+ const env = yield* EnvServerConfig;
+ const bootstrapFd = Option.getOrUndefined(flags.bootstrapFd) ?? env.bootstrapFd;
+ const bootstrapEnvelope =
+ bootstrapFd !== undefined
+ ? yield* readBootstrapEnvelope(BootstrapEnvelopeSchema, bootstrapFd)
+ : Option.none();
+
+ const mode: RuntimeMode = Option.getOrElse(
+ resolveOptionPrecedence(
+ flags.mode,
+ Option.fromUndefinedOr(env.mode),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) => Option.fromUndefinedOr(bootstrap.mode)),
+ ),
+ () => "web",
+ );
+
+ const port = yield* Option.match(
+ resolveOptionPrecedence(
+ flags.port,
+ Option.fromUndefinedOr(env.port),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) => Option.fromUndefinedOr(bootstrap.port)),
+ ),
+ {
+ onSome: (value) => Effect.succeed(value),
+ onNone: () => {
+ if (mode === "desktop") {
+ return Effect.succeed(DEFAULT_PORT);
+ }
+ return findAvailablePort(DEFAULT_PORT);
+ },
+ },
+ );
+ const devUrl = Option.getOrElse(
+ resolveOptionPrecedence(
+ flags.devUrl,
+ Option.fromUndefinedOr(env.devUrl),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) => Option.fromUndefinedOr(bootstrap.devUrl)),
+ ),
+ () => undefined,
+ );
+ const baseDir = yield* resolveBaseDir(
+ Option.getOrUndefined(
+ resolveOptionPrecedence(
+ flags.baseDir,
+ Option.fromUndefinedOr(env.t3Home),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) =>
+ Option.fromUndefinedOr(bootstrap.t3Home),
+ ),
+ ),
+ ),
+ );
+ const derivedPaths = yield* deriveServerPaths(baseDir, devUrl);
+ yield* ensureServerDirectories(derivedPaths);
+ const noBrowser = resolveBooleanFlag(
+ flags.noBrowser,
+ Option.getOrElse(
+ resolveOptionPrecedence(
+ Option.fromUndefinedOr(env.noBrowser),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) =>
+ Option.fromUndefinedOr(bootstrap.noBrowser),
+ ),
+ ),
+ () => mode === "desktop",
+ ),
+ );
+ const authToken = Option.getOrUndefined(
+ resolveOptionPrecedence(
+ flags.authToken,
+ Option.fromUndefinedOr(env.authToken),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) =>
+ Option.fromUndefinedOr(bootstrap.authToken),
+ ),
+ ),
+ );
+ const autoBootstrapProjectFromCwd = resolveBooleanFlag(
+ flags.autoBootstrapProjectFromCwd,
+ Option.getOrElse(
+ resolveOptionPrecedence(
+ Option.fromUndefinedOr(env.autoBootstrapProjectFromCwd),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) =>
+ Option.fromUndefinedOr(bootstrap.autoBootstrapProjectFromCwd),
+ ),
+ ),
+ () => mode === "web",
+ ),
+ );
+ const logWebSocketEvents = resolveBooleanFlag(
+ flags.logWebSocketEvents,
+ Option.getOrElse(
+ resolveOptionPrecedence(
+ Option.fromUndefinedOr(env.logWebSocketEvents),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) =>
+ Option.fromUndefinedOr(bootstrap.logWebSocketEvents),
+ ),
+ ),
+ () => Boolean(devUrl),
+ ),
+ );
+ const staticDir = devUrl ? undefined : yield* resolveStaticDir();
+ const host = Option.getOrElse(
+ resolveOptionPrecedence(
+ flags.host,
+ Option.fromUndefinedOr(env.host),
+ Option.flatMap(bootstrapEnvelope, (bootstrap) => Option.fromUndefinedOr(bootstrap.host)),
+ ),
+ () => (mode === "desktop" ? "127.0.0.1" : undefined),
+ );
+ const logLevel = Option.getOrElse(cliLogLevel, () => env.logLevel);
+
+ const config: ServerConfigShape = {
+ logLevel,
+ mode,
+ port,
+ cwd: process.cwd(),
+ baseDir,
+ ...derivedPaths,
+ host,
+ staticDir,
+ devUrl,
+ noBrowser,
+ authToken,
+ autoBootstrapProjectFromCwd,
+ logWebSocketEvents,
+ };
+
+ return config;
+ });
+
+const commandFlags = {
+ mode: modeFlag,
+ port: portFlag,
+ host: hostFlag,
+ baseDir: baseDirFlag,
+ devUrl: devUrlFlag,
+ noBrowser: noBrowserFlag,
+ authToken: authTokenFlag,
+ bootstrapFd: bootstrapFdFlag,
+ autoBootstrapProjectFromCwd: autoBootstrapProjectFromCwdFlag,
+ logWebSocketEvents: logWebSocketEventsFlag,
+} as const;
+
+const rootCommand = Command.make("t3", commandFlags).pipe(
+ Command.withDescription("Run the T3 Code server."),
+ Command.withHandler((flags) =>
+ Effect.gen(function* () {
+ const logLevel = yield* GlobalFlag.LogLevel;
+ const config = yield* resolveServerConfig(flags, logLevel);
+ return yield* runServer.pipe(Effect.provideService(ServerConfig, config));
+ }),
+ ),
+);
+
+export const cli = rootCommand;
diff --git a/apps/server/src/config.ts b/apps/server/src/config.ts
index 29f82bccf..21cd6f315 100644
--- a/apps/server/src/config.ts
+++ b/apps/server/src/config.ts
@@ -6,11 +6,12 @@
*
* @module ServerConfig
*/
-import { Effect, FileSystem, Layer, Path, ServiceMap } from "effect";
+import { Effect, FileSystem, Layer, LogLevel, Path, Schema, ServiceMap } from "effect";
export const DEFAULT_PORT = 3773;
-export type RuntimeMode = "web" | "desktop";
+export const RuntimeMode = Schema.Literals(["web", "desktop"]);
+export type RuntimeMode = typeof RuntimeMode.Type;
/**
* ServerDerivedPaths - Derived paths from the base directory.
@@ -34,6 +35,7 @@ export interface ServerDerivedPaths {
* ServerConfigShape - Process/runtime configuration required by the server.
*/
export interface ServerConfigShape extends ServerDerivedPaths {
+ readonly logLevel: LogLevel.LogLevel;
readonly mode: RuntimeMode;
readonly port: number;
readonly host: string | undefined;
@@ -73,6 +75,26 @@ export const deriveServerPaths = Effect.fn(function* (
};
});
+export const ensureServerDirectories = Effect.fn(function* (derivedPaths: ServerDerivedPaths) {
+ const fs = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+
+ yield* Effect.all(
+ [
+ fs.makeDirectory(derivedPaths.stateDir, { recursive: true }),
+ fs.makeDirectory(derivedPaths.logsDir, { recursive: true }),
+ fs.makeDirectory(derivedPaths.providerLogsDir, { recursive: true }),
+ fs.makeDirectory(derivedPaths.terminalLogsDir, { recursive: true }),
+ fs.makeDirectory(derivedPaths.attachmentsDir, { recursive: true }),
+ fs.makeDirectory(derivedPaths.worktreesDir, { recursive: true }),
+ fs.makeDirectory(path.dirname(derivedPaths.keybindingsConfigPath), { recursive: true }),
+ fs.makeDirectory(path.dirname(derivedPaths.settingsPath), { recursive: true }),
+ fs.makeDirectory(path.dirname(derivedPaths.anonymousIdPath), { recursive: true }),
+ ],
+ { concurrency: "unbounded" },
+ );
+});
+
/**
* ServerConfig - Service tag for server runtime configuration.
*/
@@ -91,12 +113,10 @@ export class ServerConfig extends ServiceMap.Service<ServerConfig, ServerConfigS
? baseDirOrPrefix
: yield* fs.makeTempDirectoryScoped({ prefix: baseDirOrPrefix.prefix });
const derivedPaths = yield* deriveServerPaths(baseDir, devUrl);
-
- yield* fs.makeDirectory(derivedPaths.stateDir, { recursive: true });
- yield* fs.makeDirectory(derivedPaths.logsDir, { recursive: true });
- yield* fs.makeDirectory(derivedPaths.attachmentsDir, { recursive: true });
+ yield* ensureServerDirectories(derivedPaths);
return {
+ logLevel: "Error",
cwd,
baseDir,
...derivedPaths,
diff --git a/apps/server/src/git/Errors.ts b/apps/server/src/git/Errors.ts
deleted file mode 100644
index 15bf482f7..000000000
--- a/apps/server/src/git/Errors.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { Schema } from "effect";
-
-/**
- * GitCommandError - Git command execution failed.
- */
-export class GitCommandError extends Schema.TaggedErrorClass<GitCommandError>()("GitCommandError", {
- operation: Schema.String,
- command: Schema.String,
- cwd: Schema.String,
- detail: Schema.String,
- cause: Schema.optional(Schema.Defect),
-}) {
- override get message(): string {
- return `Git command failed in ${this.operation}: ${this.command} (${this.cwd}) - ${this.detail}`;
- }
-}
-
-/**
- * GitHubCliError - GitHub CLI execution or authentication failed.
- */
-export class GitHubCliError extends Schema.TaggedErrorClass<GitHubCliError>()("GitHubCliError", {
- operation: Schema.String,
- detail: Schema.String,
- cause: Schema.optional(Schema.Defect),
-}) {
- override get message(): string {
- return `GitHub CLI failed in ${this.operation}: ${this.detail}`;
- }
-}
-
-/**
- * TextGenerationError - Commit or PR text generation failed.
- */
-export class TextGenerationError extends Schema.TaggedErrorClass<TextGenerationError>()(
- "TextGenerationError",
- {
- operation: Schema.String,
- detail: Schema.String,
- cause: Schema.optional(Schema.Defect),
- },
-) {
- override get message(): string {
- return `Text generation failed in ${this.operation}: ${this.detail}`;
- }
-}
-
-/**
- * GitManagerError - Stacked Git workflow orchestration failed.
- */
-export class GitManagerError extends Schema.TaggedErrorClass<GitManagerError>()("GitManagerError", {
- operation: Schema.String,
- detail: Schema.String,
- cause: Schema.optional(Schema.Defect),
-}) {
- override get message(): string {
- return `Git manager failed in ${this.operation}: ${this.detail}`;
- }
-}
-
-/**
- * GitManagerServiceError - Errors emitted by stacked Git workflow orchestration.
- */
-export type GitManagerServiceError =
- | GitManagerError
- | GitCommandError
- | GitHubCliError
- | TextGenerationError;
diff --git a/apps/server/src/git/Layers/ClaudeTextGeneration.ts b/apps/server/src/git/Layers/ClaudeTextGeneration.ts
index 19ed40e65..7d620be3a 100644
--- a/apps/server/src/git/Layers/ClaudeTextGeneration.ts
+++ b/apps/server/src/git/Layers/ClaudeTextGeneration.ts
@@ -14,7 +14,7 @@ import { ClaudeModelSelection } from "@t3tools/contracts";
import { resolveApiModelId } from "@t3tools/shared/model";
import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shared/git";
-import { TextGenerationError } from "../Errors.ts";
+import { TextGenerationError } from "@t3tools/contracts";
import { type TextGenerationShape, TextGeneration } from "../Services/TextGeneration.ts";
import {
buildBranchNamePrompt,
diff --git a/apps/server/src/git/Layers/CodexTextGeneration.test.ts b/apps/server/src/git/Layers/CodexTextGeneration.test.ts
index 21a97eec9..a07505f02 100644
--- a/apps/server/src/git/Layers/CodexTextGeneration.test.ts
+++ b/apps/server/src/git/Layers/CodexTextGeneration.test.ts
@@ -5,7 +5,7 @@ import { expect } from "vitest";
import { ServerConfig } from "../../config.ts";
import { CodexTextGenerationLive } from "./CodexTextGeneration.ts";
-import { TextGenerationError } from "../Errors.ts";
+import { TextGenerationError } from "@t3tools/contracts";
import { TextGeneration } from "../Services/TextGeneration.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
diff --git a/apps/server/src/git/Layers/CodexTextGeneration.ts b/apps/server/src/git/Layers/CodexTextGeneration.ts
index 8f0556ee3..9bd838773 100644
--- a/apps/server/src/git/Layers/CodexTextGeneration.ts
+++ b/apps/server/src/git/Layers/CodexTextGeneration.ts
@@ -8,7 +8,7 @@ import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shar
import { resolveAttachmentPath } from "../../attachmentStore.ts";
import { ServerConfig } from "../../config.ts";
-import { TextGenerationError } from "../Errors.ts";
+import { TextGenerationError } from "@t3tools/contracts";
import {
type BranchNameGenerationInput,
type ThreadTitleGenerationResult,
diff --git a/apps/server/src/git/Layers/GitCore.test.ts b/apps/server/src/git/Layers/GitCore.test.ts
index 5c42e6e87..07892ec44 100644
--- a/apps/server/src/git/Layers/GitCore.test.ts
+++ b/apps/server/src/git/Layers/GitCore.test.ts
@@ -8,7 +8,7 @@ import { describe, expect, vi } from "vitest";
import { GitCoreLive, makeGitCore } from "./GitCore.ts";
import { GitCore, type GitCoreShape } from "../Services/GitCore.ts";
-import { GitCommandError } from "../Errors.ts";
+import { GitCommandError } from "@t3tools/contracts";
import { type ProcessRunResult, runProcess } from "../../processRunner.ts";
import { ServerConfig } from "../../config.ts";
diff --git a/apps/server/src/git/Layers/GitCore.ts b/apps/server/src/git/Layers/GitCore.ts
index 9ef11eecf..cbb2c6744 100644
--- a/apps/server/src/git/Layers/GitCore.ts
+++ b/apps/server/src/git/Layers/GitCore.ts
@@ -18,7 +18,7 @@ import {
} from "effect";
import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { GitCommandError } from "../Errors.ts";
+import { GitCommandError } from "@t3tools/contracts";
import {
GitCore,
type ExecuteGitProgress,
@@ -1941,8 +1941,9 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
});
// Refresh upstream refs in the background so checkout remains responsive.
- yield* Effect.forkScoped(
- refreshCheckedOutBranchUpstream(input.cwd).pipe(Effect.ignoreCause({ log: true })),
+ yield* refreshCheckedOutBranchUpstream(input.cwd).pipe(
+ Effect.ignoreCause({ log: true }),
+ Effect.forkDetach({ startImmediately: true }),
);
},
);
diff --git a/apps/server/src/git/Layers/GitHubCli.ts b/apps/server/src/git/Layers/GitHubCli.ts
index 80ce43659..76d7d30a4 100644
--- a/apps/server/src/git/Layers/GitHubCli.ts
+++ b/apps/server/src/git/Layers/GitHubCli.ts
@@ -2,7 +2,7 @@ import { Effect, Layer, Schema } from "effect";
import { PositiveInt, TrimmedNonEmptyString } from "@t3tools/contracts";
import { runProcess } from "../../processRunner";
-import { GitHubCliError } from "../Errors.ts";
+import { GitHubCliError } from "@t3tools/contracts";
import {
GitHubCli,
type GitHubRepositoryCloneUrls,
diff --git a/apps/server/src/git/Layers/GitManager.test.ts b/apps/server/src/git/Layers/GitManager.test.ts
index db82ea4c7..e05fc3087 100644
--- a/apps/server/src/git/Layers/GitManager.test.ts
+++ b/apps/server/src/git/Layers/GitManager.test.ts
@@ -8,7 +8,7 @@ import { Effect, FileSystem, Layer, PlatformError, Scope } from "effect";
import { expect } from "vitest";
import type { GitActionProgressEvent, ModelSelection } from "@t3tools/contracts";
-import { GitCommandError, GitHubCliError, TextGenerationError } from "../Errors.ts";
+import { GitCommandError, GitHubCliError, TextGenerationError } from "@t3tools/contracts";
import { type GitManagerShape } from "../Services/GitManager.ts";
import {
type GitHubCliShape,
diff --git a/apps/server/src/git/Layers/GitManager.ts b/apps/server/src/git/Layers/GitManager.ts
index dc082674b..f8445cf09 100644
--- a/apps/server/src/git/Layers/GitManager.ts
+++ b/apps/server/src/git/Layers/GitManager.ts
@@ -14,7 +14,7 @@ import {
sanitizeFeatureBranchName,
} from "@t3tools/shared/git";
-import { GitManagerError } from "../Errors.ts";
+import { GitManagerError } from "@t3tools/contracts";
import {
GitManager,
type GitActionProgressReporter,
@@ -25,7 +25,7 @@ import { GitCore } from "../Services/GitCore.ts";
import { GitHubCli } from "../Services/GitHubCli.ts";
import { TextGeneration } from "../Services/TextGeneration.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
-import type { GitManagerServiceError } from "../Errors.ts";
+import type { GitManagerServiceError } from "@t3tools/contracts";
const COMMIT_TIMEOUT_MS = 10 * 60_000;
const MAX_PROGRESS_TEXT_LENGTH = 500;
diff --git a/apps/server/src/git/Prompts.test.ts b/apps/server/src/git/Prompts.test.ts
index 7951e78b3..d8d079c0c 100644
--- a/apps/server/src/git/Prompts.test.ts
+++ b/apps/server/src/git/Prompts.test.ts
@@ -7,7 +7,7 @@ import {
buildThreadTitlePrompt,
} from "./Prompts.ts";
import { normalizeCliError, sanitizeThreadTitle } from "./Utils.ts";
-import { TextGenerationError } from "./Errors.ts";
+import { TextGenerationError } from "@t3tools/contracts";
describe("buildCommitMessagePrompt", () => {
it("includes staged patch and summary in the prompt", () => {
diff --git a/apps/server/src/git/Services/GitCore.ts b/apps/server/src/git/Services/GitCore.ts
index 3c30f1712..d7a28d176 100644
--- a/apps/server/src/git/Services/GitCore.ts
+++ b/apps/server/src/git/Services/GitCore.ts
@@ -22,7 +22,7 @@ import type {
GitStatusResult,
} from "@t3tools/contracts";
-import type { GitCommandError } from "../Errors.ts";
+import type { GitCommandError } from "@t3tools/contracts";
export interface ExecuteGitInput {
readonly operation: string;
diff --git a/apps/server/src/git/Services/GitHubCli.ts b/apps/server/src/git/Services/GitHubCli.ts
index f10339af4..38afdd5f9 100644
--- a/apps/server/src/git/Services/GitHubCli.ts
+++ b/apps/server/src/git/Services/GitHubCli.ts
@@ -9,7 +9,7 @@ import { ServiceMap } from "effect";
import type { Effect } from "effect";
import type { ProcessRunResult } from "../../processRunner";
-import type { GitHubCliError } from "../Errors.ts";
+import type { GitHubCliError } from "@t3tools/contracts";
export interface GitHubPullRequestSummary {
readonly number: number;
diff --git a/apps/server/src/git/Services/GitManager.ts b/apps/server/src/git/Services/GitManager.ts
index 2e83b78c3..a99e4d3bc 100644
--- a/apps/server/src/git/Services/GitManager.ts
+++ b/apps/server/src/git/Services/GitManager.ts
@@ -19,7 +19,7 @@ import {
} from "@t3tools/contracts";
import { ServiceMap } from "effect";
import type { Effect } from "effect";
-import type { GitManagerServiceError } from "../Errors.ts";
+import type { GitManagerServiceError } from "@t3tools/contracts";
export interface GitActionProgressReporter {
readonly publish: (event: GitActionProgressEvent) => Effect.Effect<void, never>;
diff --git a/apps/server/src/git/Services/TextGeneration.ts b/apps/server/src/git/Services/TextGeneration.ts
index 0df2fff62..f4354c7a9 100644
--- a/apps/server/src/git/Services/TextGeneration.ts
+++ b/apps/server/src/git/Services/TextGeneration.ts
@@ -10,7 +10,7 @@ import { ServiceMap } from "effect";
import type { Effect } from "effect";
import type { ChatAttachment, ModelSelection } from "@t3tools/contracts";
-import type { TextGenerationError } from "../Errors.ts";
+import type { TextGenerationError } from "@t3tools/contracts";
/** Providers that support git text generation (commit messages, PR content, branch names). */
export type TextGenerationProvider = "codex" | "claudeAgent";
diff --git a/apps/server/src/git/Utils.ts b/apps/server/src/git/Utils.ts
index 8f0321fd5..4a7931c74 100644
--- a/apps/server/src/git/Utils.ts
+++ b/apps/server/src/git/Utils.ts
@@ -5,7 +5,7 @@
*/
import { Schema } from "effect";
-import { TextGenerationError } from "./Errors.ts";
+import { TextGenerationError } from "@t3tools/contracts";
import { existsSync } from "node:fs";
import { join } from "node:path";
diff --git a/apps/server/src/http.ts b/apps/server/src/http.ts
new file mode 100644
index 000000000..cee08b4f9
--- /dev/null
+++ b/apps/server/src/http.ts
@@ -0,0 +1,197 @@
+import Mime from "@effect/platform-node/Mime";
+import { Effect, FileSystem, Option, Path } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+
+import {
+ ATTACHMENTS_ROUTE_PREFIX,
+ normalizeAttachmentRelativePath,
+ resolveAttachmentRelativePath,
+} from "./attachmentPaths";
+import { resolveAttachmentPathById } from "./attachmentStore";
+import { ServerConfig } from "./config";
+import { ProjectFaviconResolver } from "./project/Services/ProjectFaviconResolver";
+
+const PROJECT_FAVICON_CACHE_CONTROL = "public, max-age=3600";
+const FALLBACK_PROJECT_FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" fill="none" stroke="#6b728080" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" data-fallback="project-favicon"><path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-8l-2-2H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2Z"/></svg>`;
+
+export const attachmentsRouteLayer = HttpRouter.add(
+ "GET",
+ `${ATTACHMENTS_ROUTE_PREFIX}/*`,
+ Effect.gen(function* () {
+ const request = yield* HttpServerRequest.HttpServerRequest;
+ const url = HttpServerRequest.toURL(request);
+ if (Option.isNone(url)) {
+ return HttpServerResponse.text("Bad Request", { status: 400 });
+ }
+
+ const config = yield* ServerConfig;
+ const rawRelativePath = url.value.pathname.slice(ATTACHMENTS_ROUTE_PREFIX.length);
+ const normalizedRelativePath = normalizeAttachmentRelativePath(rawRelativePath);
+ if (!normalizedRelativePath) {
+ return HttpServerResponse.text("Invalid attachment path", { status: 400 });
+ }
+
+ const isIdLookup =
+ !normalizedRelativePath.includes("/") && !normalizedRelativePath.includes(".");
+ const filePath = isIdLookup
+ ? resolveAttachmentPathById({
+ attachmentsDir: config.attachmentsDir,
+ attachmentId: normalizedRelativePath,
+ })
+ : resolveAttachmentRelativePath({
+ attachmentsDir: config.attachmentsDir,
+ relativePath: normalizedRelativePath,
+ });
+ if (!filePath) {
+ return HttpServerResponse.text(isIdLookup ? "Not Found" : "Invalid attachment path", {
+ status: isIdLookup ? 404 : 400,
+ });
+ }
+
+ const fileSystem = yield* FileSystem.FileSystem;
+ const fileInfo = yield* fileSystem
+ .stat(filePath)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ if (!fileInfo || fileInfo.type !== "File") {
+ return HttpServerResponse.text("Not Found", { status: 404 });
+ }
+
+ return yield* HttpServerResponse.file(filePath, {
+ status: 200,
+ headers: {
+ "Cache-Control": "public, max-age=31536000, immutable",
+ },
+ }).pipe(
+ Effect.catch(() =>
+ Effect.succeed(HttpServerResponse.text("Internal Server Error", { status: 500 })),
+ ),
+ );
+ }),
+);
+
+export const projectFaviconRouteLayer = HttpRouter.add(
+ "GET",
+ "/api/project-favicon",
+ Effect.gen(function* () {
+ const request = yield* HttpServerRequest.HttpServerRequest;
+ const url = HttpServerRequest.toURL(request);
+ if (Option.isNone(url)) {
+ return HttpServerResponse.text("Bad Request", { status: 400 });
+ }
+
+ const projectCwd = url.value.searchParams.get("cwd");
+ if (!projectCwd) {
+ return HttpServerResponse.text("Missing cwd parameter", { status: 400 });
+ }
+
+ const faviconResolver = yield* ProjectFaviconResolver;
+ const faviconFilePath = yield* faviconResolver.resolvePath(projectCwd);
+ if (!faviconFilePath) {
+ return HttpServerResponse.text(FALLBACK_PROJECT_FAVICON_SVG, {
+ status: 200,
+ contentType: "image/svg+xml",
+ headers: {
+ "Cache-Control": PROJECT_FAVICON_CACHE_CONTROL,
+ },
+ });
+ }
+
+ return yield* HttpServerResponse.file(faviconFilePath, {
+ status: 200,
+ headers: {
+ "Cache-Control": PROJECT_FAVICON_CACHE_CONTROL,
+ },
+ }).pipe(
+ Effect.catch(() =>
+ Effect.succeed(HttpServerResponse.text("Internal Server Error", { status: 500 })),
+ ),
+ );
+ }),
+);
+
+export const staticAndDevRouteLayer = HttpRouter.add(
+ "GET",
+ "*",
+ Effect.gen(function* () {
+ const request = yield* HttpServerRequest.HttpServerRequest;
+ const url = HttpServerRequest.toURL(request);
+ if (Option.isNone(url)) {
+ return HttpServerResponse.text("Bad Request", { status: 400 });
+ }
+
+ const config = yield* ServerConfig;
+ if (config.devUrl) {
+ return HttpServerResponse.redirect(config.devUrl.href, { status: 302 });
+ }
+
+ if (!config.staticDir) {
+ return HttpServerResponse.text("No static directory configured and no dev URL set.", {
+ status: 503,
+ });
+ }
+
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const staticRoot = path.resolve(config.staticDir);
+ const staticRequestPath = url.value.pathname === "/" ? "/index.html" : url.value.pathname;
+ const rawStaticRelativePath = staticRequestPath.replace(/^[/\\]+/, "");
+ const hasRawLeadingParentSegment = rawStaticRelativePath.startsWith("..");
+ const staticRelativePath = path.normalize(rawStaticRelativePath).replace(/^[/\\]+/, "");
+ const hasPathTraversalSegment = staticRelativePath.startsWith("..");
+ if (
+ staticRelativePath.length === 0 ||
+ hasRawLeadingParentSegment ||
+ hasPathTraversalSegment ||
+ staticRelativePath.includes("\0")
+ ) {
+ return HttpServerResponse.text("Invalid static file path", { status: 400 });
+ }
+
+ const isWithinStaticRoot = (candidate: string) =>
+ candidate === staticRoot ||
+ candidate.startsWith(staticRoot.endsWith(path.sep) ? staticRoot : `${staticRoot}${path.sep}`);
+
+ let filePath = path.resolve(staticRoot, staticRelativePath);
+ if (!isWithinStaticRoot(filePath)) {
+ return HttpServerResponse.text("Invalid static file path", { status: 400 });
+ }
+
+ const ext = path.extname(filePath);
+ if (!ext) {
+ filePath = path.resolve(filePath, "index.html");
+ if (!isWithinStaticRoot(filePath)) {
+ return HttpServerResponse.text("Invalid static file path", { status: 400 });
+ }
+ }
+
+ const fileInfo = yield* fileSystem
+ .stat(filePath)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ if (!fileInfo || fileInfo.type !== "File") {
+ const indexPath = path.resolve(staticRoot, "index.html");
+ const indexData = yield* fileSystem
+ .readFile(indexPath)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ if (!indexData) {
+ return HttpServerResponse.text("Not Found", { status: 404 });
+ }
+ return HttpServerResponse.uint8Array(indexData, {
+ status: 200,
+ contentType: "text/html; charset=utf-8",
+ });
+ }
+
+ const contentType = Mime.getType(filePath) ?? "application/octet-stream";
+ const data = yield* fileSystem
+ .readFile(filePath)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ if (!data) {
+ return HttpServerResponse.text("Internal Server Error", { status: 500 });
+ }
+
+ return HttpServerResponse.uint8Array(data, {
+ status: 200,
+ contentType,
+ });
+ }),
+);
diff --git a/apps/server/src/index.ts b/apps/server/src/index.ts
deleted file mode 100644
index 363a07ee3..000000000
--- a/apps/server/src/index.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
-import * as NodeServices from "@effect/platform-node/NodeServices";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-
-import { CliConfig, t3Cli } from "./main";
-import { OpenLive } from "./open";
-import { Command } from "effect/unstable/cli";
-import { version } from "../package.json" with { type: "json" };
-import { ServerLive } from "./wsServer";
-import { NetService } from "@t3tools/shared/Net";
-import { FetchHttpClient } from "effect/unstable/http";
-
-const RuntimeLayer = Layer.empty.pipe(
- Layer.provideMerge(CliConfig.layer),
- Layer.provideMerge(ServerLive),
- Layer.provideMerge(OpenLive),
- Layer.provideMerge(NetService.layer),
- Layer.provideMerge(NodeServices.layer),
- Layer.provideMerge(FetchHttpClient.layer),
-);
-
-Command.run(t3Cli, { version }).pipe(Effect.provide(RuntimeLayer), NodeRuntime.runMain);
diff --git a/apps/server/src/keybindings.test.ts b/apps/server/src/keybindings.test.ts
index 9cf039414..8eda0ca85 100644
--- a/apps/server/src/keybindings.test.ts
+++ b/apps/server/src/keybindings.test.ts
@@ -8,13 +8,13 @@ import { ServerConfig } from "./config";
import {
DEFAULT_KEYBINDINGS,
Keybindings,
- KeybindingsConfigError,
KeybindingsLive,
ResolvedKeybindingFromConfig,
compileResolvedKeybindingRule,
compileResolvedKeybindingsConfig,
parseKeybindingShortcut,
} from "./keybindings";
+import { KeybindingsConfigError } from "@t3tools/contracts";
const KeybindingsConfigJson = Schema.fromJsonString(KeybindingsConfig);
const makeKeybindingsLayer = () => {
diff --git a/apps/server/src/keybindings.ts b/apps/server/src/keybindings.ts
index 176e0300a..086d795c0 100644
--- a/apps/server/src/keybindings.ts
+++ b/apps/server/src/keybindings.ts
@@ -9,6 +9,7 @@
import {
KeybindingRule,
KeybindingsConfig,
+ KeybindingsConfigError,
KeybindingShortcut,
KeybindingWhenNode,
MAX_KEYBINDINGS_COUNT,
@@ -46,19 +47,6 @@ import * as Semaphore from "effect/Semaphore";
import { ServerConfig } from "./config";
import { fromLenientJson } from "@t3tools/shared/schemaJson";
-export class KeybindingsConfigError extends Schema.TaggedErrorClass<KeybindingsConfigError>()(
- "KeybindingsConfigParseError",
- {
- configPath: Schema.String,
- detail: Schema.String,
- cause: Schema.optional(Schema.Defect),
- },
-) {
- override get message(): string {
- return `Unable to parse keybindings config at ${this.configPath}: ${this.detail}`;
- }
-}
-
type WhenToken =
| { type: "identifier"; value: string }
| { type: "not" }
diff --git a/apps/server/src/logger.ts b/apps/server/src/logger.ts
deleted file mode 100644
index b9d18569c..000000000
--- a/apps/server/src/logger.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import util from "node:util";
-
-type LogLevel = "info" | "warn" | "error" | "event";
-
-type LogContext = Record<string, unknown>;
-
-const ANSI = {
- reset: "\u001b[0m",
- dim: "\u001b[2m",
- cyan: "\u001b[36m",
- yellow: "\u001b[33m",
- red: "\u001b[31m",
- magenta: "\u001b[35m",
-} as const;
-
-const LEVEL_LABEL: Record<LogLevel, string> = {
- info: "INFO",
- warn: "WARN",
- error: "ERROR",
- event: "EVENT",
-};
-
-const LEVEL_COLOR: Record<LogLevel, string> = {
- info: ANSI.cyan,
- warn: ANSI.yellow,
- error: ANSI.red,
- event: ANSI.magenta,
-};
-
-function useColors() {
- return Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined;
-}
-
-function colorize(value: string, color: string, enabled: boolean) {
- return enabled ? `${color}${value}${ANSI.reset}` : value;
-}
-
-function timeStamp() {
- return new Date().toISOString().slice(11, 23);
-}
-
-function formatValue(value: unknown) {
- if (typeof value === "string") {
- return JSON.stringify(value);
- }
- if (
- typeof value === "number" ||
- typeof value === "boolean" ||
- value === null ||
- value === undefined
- ) {
- return String(value);
- }
- return util.inspect(value, {
- depth: 4,
- breakLength: Infinity,
- compact: true,
- maxArrayLength: 25,
- maxStringLength: 320,
- });
-}
-
-function formatContext(context: LogContext | undefined) {
- if (!context) return "";
- const entries = Object.entries(context).filter(([, value]) => value !== undefined);
- if (entries.length === 0) return "";
- return entries.map(([key, value]) => `${key}=${formatValue(value)}`).join(" ");
-}
-
-function write(level: LogLevel, scope: string, message: string, context?: LogContext) {
- const colorEnabled = useColors();
- const ts = colorize(timeStamp(), ANSI.dim, colorEnabled);
- const levelLabel = colorize(LEVEL_LABEL[level], LEVEL_COLOR[level], colorEnabled);
- const contextText = formatContext(context);
- const line = `${ts} ${levelLabel} [${scope}] ${message}${contextText ? ` ${contextText}` : ""}`;
-
- if (level === "warn") {
- console.warn(line);
- return;
- }
- if (level === "error") {
- console.error(line);
- return;
- }
- console.log(line);
-}
-
-export function createLogger(scope: string) {
- return {
- info(message: string, context?: LogContext) {
- write("info", scope, message, context);
- },
- warn(message: string, context?: LogContext) {
- write("warn", scope, message, context);
- },
- error(message: string, context?: LogContext) {
- write("error", scope, message, context);
- },
- event(message: string, context?: LogContext) {
- write("event", scope, message, context);
- },
- };
-}
diff --git a/apps/server/src/main.test.ts b/apps/server/src/main.test.ts
deleted file mode 100644
index 0d990a81c..000000000
--- a/apps/server/src/main.test.ts
+++ /dev/null
@@ -1,413 +0,0 @@
-import * as Http from "node:http";
-import * as NodeServices from "@effect/platform-node/NodeServices";
-import { assert, it, vi } from "@effect/vitest";
-import type { OrchestrationReadModel } from "@t3tools/contracts";
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Command from "effect/unstable/cli/Command";
-import { FetchHttpClient } from "effect/unstable/http";
-import { beforeEach } from "vitest";
-import { NetService } from "@t3tools/shared/Net";
-
-import { CliConfig, recordStartupHeartbeat, t3Cli, type CliConfigShape } from "./main";
-import { ServerConfig, type ServerConfigShape } from "./config";
-import { Open, type OpenShape } from "./open";
-import { ProjectionSnapshotQuery } from "./orchestration/Services/ProjectionSnapshotQuery";
-import { AnalyticsService } from "./telemetry/Services/AnalyticsService";
-import { Server, type ServerShape } from "./wsServer";
-import { ServerSettingsService } from "./serverSettings";
-
-const start = vi.fn(() => undefined);
-const stop = vi.fn(() => undefined);
-const fixPath = vi.fn(() => undefined);
-let resolvedConfig: ServerConfigShape | null = null;
-const serverStart = Effect.acquireRelease(
- Effect.gen(function* () {
- resolvedConfig = yield* ServerConfig;
- start();
- return {} as unknown as Http.Server;
- }),
- () => Effect.sync(() => stop()),
-);
-const findAvailablePort = vi.fn((preferred: number) => Effect.succeed(preferred));
-
-// Shared service layer used by this CLI test suite.
-const testLayer = Layer.mergeAll(
- Layer.succeed(CliConfig, {
- cwd: "/tmp/t3-test-workspace",
- fixPath: Effect.sync(fixPath),
- resolveStaticDir: Effect.undefined,
- } satisfies CliConfigShape),
- Layer.succeed(NetService, {
- canListenOnHost: () => Effect.succeed(true),
- isPortAvailableOnLoopback: () => Effect.succeed(true),
- reserveLoopbackPort: () => Effect.succeed(0),
- findAvailablePort,
- }),
- Layer.succeed(Server, {
- start: serverStart,
- stopSignal: Effect.void,
- } satisfies ServerShape),
- Layer.succeed(Open, {
- openBrowser: (_target: string) => Effect.void,
- openInEditor: () => Effect.void,
- } satisfies OpenShape),
- ServerSettingsService.layerTest(),
- AnalyticsService.layerTest,
- FetchHttpClient.layer,
- NodeServices.layer,
-);
-
-const runCli = (
- args: ReadonlyArray<string>,
- env: Record<string, string> = { T3CODE_NO_BROWSER: "true" },
-) => {
- return Command.runWith(t3Cli, { version: "0.0.0-test" })(args).pipe(
- Effect.provide(
- ConfigProvider.layer(
- ConfigProvider.fromEnv({
- env: {
- ...env,
- },
- }),
- ),
- ),
- );
-};
-
-beforeEach(() => {
- vi.clearAllMocks();
- resolvedConfig = null;
- start.mockImplementation(() => undefined);
- stop.mockImplementation(() => undefined);
- fixPath.mockImplementation(() => undefined);
- findAvailablePort.mockImplementation((preferred: number) => Effect.succeed(preferred));
-});
-
-it.layer(testLayer)("server CLI command", (it) => {
- it.effect("parses all CLI flags and wires scoped start/stop", () =>
- Effect.gen(function* () {
- yield* runCli([
- "--mode",
- "desktop",
- "--port",
- "4010",
- "--host",
- "0.0.0.0",
- "--home-dir",
- "/tmp/t3-cli-home",
- "--dev-url",
- "http://127.0.0.1:5173",
- "--no-browser",
- "--auth-token",
- "auth-secret",
- ]);
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.mode, "desktop");
- assert.equal(resolvedConfig?.port, 4010);
- assert.equal(resolvedConfig?.host, "0.0.0.0");
- assert.equal(resolvedConfig?.baseDir, "/tmp/t3-cli-home");
- assert.equal(resolvedConfig?.stateDir, "/tmp/t3-cli-home/dev");
- assert.equal(resolvedConfig?.devUrl?.toString(), "http://127.0.0.1:5173/");
- assert.equal(resolvedConfig?.noBrowser, true);
- assert.equal(resolvedConfig?.authToken, "auth-secret");
- assert.equal(resolvedConfig?.autoBootstrapProjectFromCwd, false);
- assert.equal(resolvedConfig?.logWebSocketEvents, true);
- assert.equal(stop.mock.calls.length, 1);
- }),
- );
-
- it.effect("supports --token as an alias for --auth-token", () =>
- Effect.gen(function* () {
- yield* runCli(["--token", "token-secret"]);
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.authToken, "token-secret");
- }),
- );
-
- it.effect("uses env fallbacks when flags are not provided", () =>
- Effect.gen(function* () {
- yield* runCli([], {
- T3CODE_MODE: "desktop",
- T3CODE_PORT: "4999",
- T3CODE_HOST: "100.88.10.4",
- T3CODE_HOME: "/tmp/t3-env-home",
- VITE_DEV_SERVER_URL: "http://localhost:5173",
- T3CODE_NO_BROWSER: "true",
- T3CODE_AUTH_TOKEN: "env-token",
- });
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.mode, "desktop");
- assert.equal(resolvedConfig?.port, 4999);
- assert.equal(resolvedConfig?.host, "100.88.10.4");
- assert.equal(resolvedConfig?.baseDir, "/tmp/t3-env-home");
- assert.equal(resolvedConfig?.stateDir, "/tmp/t3-env-home/dev");
- assert.equal(resolvedConfig?.devUrl?.toString(), "http://localhost:5173/");
- assert.equal(resolvedConfig?.noBrowser, true);
- assert.equal(resolvedConfig?.authToken, "env-token");
- assert.equal(resolvedConfig?.autoBootstrapProjectFromCwd, false);
- assert.equal(resolvedConfig?.logWebSocketEvents, true);
- assert.equal(findAvailablePort.mock.calls.length, 0);
- }),
- );
-
- const openBootstrapFd = Effect.fn(function* (payload: Record<string, unknown>) {
- const fs = yield* FileSystem.FileSystem;
- const filePath = yield* fs.makeTempFileScoped({ prefix: "t3-bootstrap-", suffix: ".ndjson" });
- yield* fs.writeFileString(filePath, `${JSON.stringify(payload)}\n`);
- const { fd } = yield* fs.open(filePath, { flag: "r" });
- return fd;
- });
-
- it.effect("recognizes bootstrap fd from environment config", () =>
- Effect.gen(function* () {
- const fd = yield* openBootstrapFd({ authToken: "bootstrap-token" });
-
- yield* runCli([], {
- T3CODE_MODE: "web",
- T3CODE_BOOTSTRAP_FD: String(fd),
- T3CODE_AUTH_TOKEN: "env-token",
- T3CODE_NO_BROWSER: "true",
- });
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.mode, "web");
- assert.equal(resolvedConfig?.authToken, "env-token");
- }),
- );
-
- it.effect("uses bootstrap envelope values as fallbacks when CLI and env are absent", () =>
- Effect.gen(function* () {
- const fd = yield* openBootstrapFd({
- mode: "desktop",
- port: 4888,
- host: "127.0.0.2",
- t3Home: "/tmp/t3-bootstrap-home",
- devUrl: "http://127.0.0.1:5173",
- noBrowser: true,
- authToken: "bootstrap-token",
- autoBootstrapProjectFromCwd: false,
- logWebSocketEvents: true,
- });
-
- yield* runCli([], {
- T3CODE_BOOTSTRAP_FD: String(fd),
- });
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.mode, "desktop");
- assert.equal(resolvedConfig?.port, 4888);
- assert.equal(resolvedConfig?.host, "127.0.0.2");
- assert.equal(resolvedConfig?.baseDir, "/tmp/t3-bootstrap-home");
- assert.equal(resolvedConfig?.stateDir, "/tmp/t3-bootstrap-home/dev");
- assert.equal(resolvedConfig?.devUrl?.toString(), "http://127.0.0.1:5173/");
- assert.equal(resolvedConfig?.noBrowser, true);
- assert.equal(resolvedConfig?.authToken, "bootstrap-token");
- assert.equal(resolvedConfig?.autoBootstrapProjectFromCwd, false);
- assert.equal(resolvedConfig?.logWebSocketEvents, true);
- }),
- );
-
- it.effect("applies CLI then env precedence over bootstrap envelope values", () =>
- Effect.gen(function* () {
- const fd = yield* openBootstrapFd({
- mode: "desktop",
- port: 4888,
- host: "127.0.0.2",
- t3Home: "/tmp/t3-bootstrap-home",
- devUrl: "http://127.0.0.1:5173",
- noBrowser: false,
- authToken: "bootstrap-token",
- autoBootstrapProjectFromCwd: false,
- logWebSocketEvents: false,
- });
-
- yield* runCli(["--port", "4999", "--host", "0.0.0.0", "--auth-token", "cli-token"], {
- T3CODE_MODE: "web",
- T3CODE_BOOTSTRAP_FD: String(fd),
- T3CODE_HOME: "/tmp/t3-env-home",
- T3CODE_NO_BROWSER: "true",
- T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD: "true",
- T3CODE_LOG_WS_EVENTS: "true",
- });
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.mode, "web");
- assert.equal(resolvedConfig?.port, 4999);
- assert.equal(resolvedConfig?.host, "0.0.0.0");
- assert.equal(resolvedConfig?.baseDir, "/tmp/t3-env-home");
- assert.equal(resolvedConfig?.devUrl?.toString(), "http://127.0.0.1:5173/");
- assert.equal(resolvedConfig?.noBrowser, true);
- assert.equal(resolvedConfig?.authToken, "cli-token");
- assert.equal(resolvedConfig?.autoBootstrapProjectFromCwd, true);
- assert.equal(resolvedConfig?.logWebSocketEvents, true);
- }),
- );
-
- it.effect("prefers --mode over T3CODE_MODE", () =>
- Effect.gen(function* () {
- findAvailablePort.mockImplementation((_preferred: number) => Effect.succeed(4666));
- yield* runCli(["--mode", "web"], {
- T3CODE_MODE: "desktop",
- T3CODE_NO_BROWSER: "true",
- });
-
- assert.deepStrictEqual(findAvailablePort.mock.calls, [[3773]]);
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.mode, "web");
- assert.equal(resolvedConfig?.port, 4666);
- assert.equal(resolvedConfig?.host, undefined);
- }),
- );
-
- it.effect("prefers --no-browser over T3CODE_NO_BROWSER", () =>
- Effect.gen(function* () {
- yield* runCli(["--no-browser"], {
- T3CODE_NO_BROWSER: "false",
- });
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.noBrowser, true);
- }),
- );
-
- it.effect("uses dynamic port discovery in web mode when port is omitted", () =>
- Effect.gen(function* () {
- findAvailablePort.mockImplementation((_preferred: number) => Effect.succeed(5444));
- yield* runCli([]);
-
- assert.deepStrictEqual(findAvailablePort.mock.calls, [[3773]]);
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.port, 5444);
- assert.equal(resolvedConfig?.mode, "web");
- }),
- );
-
- it.effect("uses fixed localhost defaults in desktop mode", () =>
- Effect.gen(function* () {
- yield* runCli([], {
- T3CODE_MODE: "desktop",
- T3CODE_NO_BROWSER: "true",
- });
-
- assert.equal(findAvailablePort.mock.calls.length, 0);
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.port, 3773);
- assert.equal(resolvedConfig?.host, "127.0.0.1");
- assert.equal(resolvedConfig?.mode, "desktop");
- }),
- );
-
- it.effect("allows overriding desktop host with --host", () =>
- Effect.gen(function* () {
- yield* runCli(["--host", "0.0.0.0"], {
- T3CODE_MODE: "desktop",
- T3CODE_NO_BROWSER: "true",
- });
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.mode, "desktop");
- assert.equal(resolvedConfig?.host, "0.0.0.0");
- }),
- );
-
- it.effect("supports CLI and env for bootstrap/log websocket toggles", () =>
- Effect.gen(function* () {
- yield* runCli(["--auto-bootstrap-project-from-cwd"], {
- T3CODE_MODE: "desktop",
- T3CODE_LOG_WS_EVENTS: "false",
- T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD: "false",
- T3CODE_NO_BROWSER: "true",
- });
-
- assert.equal(start.mock.calls.length, 1);
- assert.equal(resolvedConfig?.autoBootstrapProjectFromCwd, true);
- assert.equal(resolvedConfig?.logWebSocketEvents, false);
- }),
- );
-
- it.effect("hydrates PATH before server startup", () =>
- Effect.gen(function* () {
- yield* runCli([]);
-
- assert.equal(fixPath.mock.calls.length, 1);
- assert.equal(start.mock.calls.length, 1);
- const fixPathOrder = fixPath.mock.invocationCallOrder[0];
- const startOrder = start.mock.invocationCallOrder[0];
- if (typeof fixPathOrder !== "number" || typeof startOrder !== "number") {
- assert.fail("Expected fixPath and start to be called");
- }
- assert.isTrue(fixPathOrder < startOrder);
- }),
- );
-
- it.effect("records a startup heartbeat with thread/project counts", () =>
- Effect.gen(function* () {
- const recordTelemetry = vi.fn(
- (_event: string, _properties?: Readonly<Record<string, unknown>>) => Effect.void,
- );
- const getSnapshot = vi.fn(() =>
- Effect.succeed({
- snapshotSequence: 2,
- projects: [{} as OrchestrationReadModel["projects"][number]],
- threads: [
- {} as OrchestrationReadModel["threads"][number],
- {} as OrchestrationReadModel["threads"][number],
- ],
- updatedAt: new Date(1).toISOString(),
- } satisfies OrchestrationReadModel),
- );
-
- yield* recordStartupHeartbeat.pipe(
- Effect.provideService(ProjectionSnapshotQuery, {
- getSnapshot,
- }),
- Effect.provideService(AnalyticsService, {
- record: recordTelemetry,
- flush: Effect.void,
- }),
- );
-
- assert.deepEqual(recordTelemetry.mock.calls[0], [
- "server.boot.heartbeat",
- {
- threadCount: 2,
- projectCount: 1,
- },
- ]);
- }),
- );
-
- it.effect("does not start server for invalid --mode values", () =>
- Effect.gen(function* () {
- yield* runCli(["--mode", "invalid"]).pipe(Effect.catch(() => Effect.void));
-
- assert.equal(start.mock.calls.length, 0);
- assert.equal(stop.mock.calls.length, 0);
- }),
- );
-
- it.effect("does not start server for invalid --dev-url values", () =>
- Effect.gen(function* () {
- yield* runCli(["--dev-url", "not-a-url"]).pipe(Effect.catch(() => Effect.void));
-
- assert.equal(start.mock.calls.length, 0);
- assert.equal(stop.mock.calls.length, 0);
- }),
- );
-
- it.effect("does not start server for out-of-range --port values", () =>
- Effect.gen(function* () {
- yield* runCli(["--port", "70000"]).pipe(Effect.catch(() => Effect.void));
-
- // effect/unstable/cli renders help/errors for parse failures and returns success.
- assert.equal(start.mock.calls.length, 0);
- assert.equal(stop.mock.calls.length, 0);
- }),
- );
-});
diff --git a/apps/server/src/main.ts b/apps/server/src/main.ts
deleted file mode 100644
index 019783c25..000000000
--- a/apps/server/src/main.ts
+++ /dev/null
@@ -1,456 +0,0 @@
-/**
- * CliConfig - CLI/runtime bootstrap service definitions.
- *
- * Defines startup-only service contracts used while resolving process config
- * and constructing server runtime layers.
- *
- * @module CliConfig
- */
-import { Config, Data, Effect, FileSystem, Layer, Option, Path, Schema, ServiceMap } from "effect";
-import { Command, Flag } from "effect/unstable/cli";
-import { NetService } from "@t3tools/shared/Net";
-import {
- DEFAULT_PORT,
- deriveServerPaths,
- resolveStaticDir,
- ServerConfig,
- type RuntimeMode,
- type ServerConfigShape,
-} from "./config";
-import { fixPath, resolveBaseDir } from "./os-jank";
-import { Open } from "./open";
-import * as SqlitePersistence from "./persistence/Layers/Sqlite";
-import { makeServerProviderLayer, makeServerRuntimeServicesLayer } from "./serverLayers";
-import { ProjectionSnapshotQuery } from "./orchestration/Services/ProjectionSnapshotQuery";
-import { ProviderRegistryLive } from "./provider/Layers/ProviderRegistry";
-import { Server } from "./wsServer";
-import { ServerLoggerLive } from "./serverLogger";
-import { AnalyticsServiceLayerLive } from "./telemetry/Layers/AnalyticsService";
-import { AnalyticsService } from "./telemetry/Services/AnalyticsService";
-import { readBootstrapEnvelope } from "./bootstrap";
-import { ServerSettingsLive } from "./serverSettings";
-
-export class StartupError extends Data.TaggedError("StartupError")<{
- readonly message: string;
- readonly cause?: unknown;
-}> {}
-
-const PortSchema = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 }));
-
-const BootstrapEnvelopeSchema = Schema.Struct({
- mode: Schema.optional(Schema.String),
- port: Schema.optional(PortSchema),
- host: Schema.optional(Schema.String),
- t3Home: Schema.optional(Schema.String),
- devUrl: Schema.optional(Schema.URLFromString),
- noBrowser: Schema.optional(Schema.Boolean),
- authToken: Schema.optional(Schema.String),
- autoBootstrapProjectFromCwd: Schema.optional(Schema.Boolean),
- logWebSocketEvents: Schema.optional(Schema.Boolean),
-});
-
-interface CliInput {
- readonly mode: Option.Option<RuntimeMode>;
- readonly port: Option.Option<number>;
- readonly host: Option.Option<string>;
- readonly t3Home: Option.Option<string>;
- readonly devUrl: Option.Option<URL>;
- readonly noBrowser: Option.Option<boolean>;
- readonly authToken: Option.Option<string>;
- readonly bootstrapFd: Option.Option<number>;
- readonly autoBootstrapProjectFromCwd: Option.Option<boolean>;
- readonly logWebSocketEvents: Option.Option<boolean>;
-}
-
-/**
- * CliConfigShape - Startup helpers required while building server layers.
- */
-export interface CliConfigShape {
- /**
- * Current process working directory.
- */
- readonly cwd: string;
-
- /**
- * Apply OS-specific PATH normalization.
- */
- readonly fixPath: Effect.Effect<void>;
-
- /**
- * Resolve static web asset directory for server mode.
- */
- readonly resolveStaticDir: Effect.Effect<string | undefined>;
-}
-
-/**
- * CliConfig - Service tag for startup CLI/runtime helpers.
- */
-export class CliConfig extends ServiceMap.Service<CliConfig, CliConfigShape>()(
- "t3/main/CliConfig",
-) {
- static readonly layer = Layer.effect(
- CliConfig,
- Effect.gen(function* () {
- const fileSystem = yield* FileSystem.FileSystem;
- const path = yield* Path.Path;
- return {
- cwd: process.cwd(),
- fixPath: Effect.sync(fixPath),
- resolveStaticDir: resolveStaticDir().pipe(
- Effect.provideService(FileSystem.FileSystem, fileSystem),
- Effect.provideService(Path.Path, path),
- ),
- } satisfies CliConfigShape;
- }),
- );
-}
-
-const CliEnvConfig = Config.all({
- mode: Config.string("T3CODE_MODE").pipe(
- Config.option,
- Config.map(Option.map((value) => (value === "desktop" ? "desktop" : "web"))),
- Config.map(Option.getOrUndefined),
- ),
- port: Config.port("T3CODE_PORT").pipe(Config.option, Config.map(Option.getOrUndefined)),
- host: Config.string("T3CODE_HOST").pipe(Config.option, Config.map(Option.getOrUndefined)),
- t3Home: Config.string("T3CODE_HOME").pipe(Config.option, Config.map(Option.getOrUndefined)),
- devUrl: Config.url("VITE_DEV_SERVER_URL").pipe(Config.option, Config.map(Option.getOrUndefined)),
- noBrowser: Config.boolean("T3CODE_NO_BROWSER").pipe(
- Config.option,
- Config.map(Option.getOrUndefined),
- ),
- authToken: Config.string("T3CODE_AUTH_TOKEN").pipe(
- Config.option,
- Config.map(Option.getOrUndefined),
- ),
- bootstrapFd: Config.int("T3CODE_BOOTSTRAP_FD").pipe(
- Config.option,
- Config.map(Option.getOrUndefined),
- ),
- autoBootstrapProjectFromCwd: Config.boolean("T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD").pipe(
- Config.option,
- Config.map(Option.getOrUndefined),
- ),
- logWebSocketEvents: Config.boolean("T3CODE_LOG_WS_EVENTS").pipe(
- Config.option,
- Config.map(Option.getOrUndefined),
- ),
-});
-
-const resolveBooleanFlag = (flag: Option.Option<boolean>, envValue: boolean) =>
- Option.getOrElse(Option.filter(flag, Boolean), () => envValue);
-
-const resolveOptionPrecedence = <Value>(
- ...values: ReadonlyArray<Option.Option<Value>>
-): Option.Option<Value> => Option.firstSomeOf(values);
-
-const isValidPort = (value: number): boolean => value >= 1 && value <= 65_535;
-const isRuntimeMode = (value: string): value is RuntimeMode =>
- value === "web" || value === "desktop";
-
-const ServerConfigLive = (input: CliInput) =>
- Layer.effect(
- ServerConfig,
- Effect.gen(function* () {
- const cliConfig = yield* CliConfig;
- const { findAvailablePort } = yield* NetService;
- const env = yield* CliEnvConfig.asEffect().pipe(
- Effect.mapError(
- (cause) =>
- new StartupError({ message: "Failed to read environment configuration", cause }),
- ),
- );
-
- const bootstrapFd = Option.getOrUndefined(input.bootstrapFd) ?? env.bootstrapFd;
- const bootstrapEnvelope =
- bootstrapFd !== undefined
- ? yield* readBootstrapEnvelope(BootstrapEnvelopeSchema, bootstrapFd)
- : Option.none();
-
- const mode: RuntimeMode = Option.getOrElse(
- resolveOptionPrecedence(
- input.mode,
- Option.fromUndefinedOr(env.mode),
- Option.flatMap(bootstrapEnvelope, (bootstrap) =>
- Option.filter(Option.fromUndefinedOr(bootstrap.mode), isRuntimeMode),
- ),
- ),
- () => "web",
- );
- const port = yield* Option.match(
- resolveOptionPrecedence(
- input.port,
- Option.fromUndefinedOr(env.port),
- Option.flatMap(bootstrapEnvelope, (bootstrap) =>
- Option.filter(Option.fromUndefinedOr(bootstrap.port), isValidPort),
- ),
- ),
- {
- onSome: (value) => Effect.succeed(value),
- onNone: () => {
- if (mode === "desktop") {
- return Effect.succeed(DEFAULT_PORT);
- }
- return findAvailablePort(DEFAULT_PORT);
- },
- },
- );
-
- const devUrl = Option.getOrElse(
- resolveOptionPrecedence(
- input.devUrl,
- Option.fromUndefinedOr(env.devUrl),
- Option.flatMap(bootstrapEnvelope, (bootstrap) =>
- Option.fromUndefinedOr(bootstrap.devUrl),
- ),
- ),
- () => undefined,
- );
- const baseDir = yield* resolveBaseDir(
- Option.getOrUndefined(
- resolveOptionPrecedence(
- input.t3Home,
- Option.fromUndefinedOr(env.t3Home),
- Option.flatMap(bootstrapEnvelope, (bootstrap) =>
- Option.fromUndefinedOr(bootstrap.t3Home),
- ),
- ),
- ),
- );
- const derivedPaths = yield* deriveServerPaths(baseDir, devUrl);
- const noBrowser = resolveBooleanFlag(
- input.noBrowser,
- Option.getOrElse(
- resolveOptionPrecedence(
- Option.fromUndefinedOr(env.noBrowser),
- Option.flatMap(bootstrapEnvelope, (bootstrap) =>
- Option.fromUndefinedOr(bootstrap.noBrowser),
- ),
- ),
- () => mode === "desktop",
- ),
- );
- const authToken = resolveOptionPrecedence(
- input.authToken,
- Option.fromUndefinedOr(env.authToken),
- Option.flatMap(bootstrapEnvelope, (bootstrap) =>
- Option.fromUndefinedOr(bootstrap.authToken),
- ),
- );
- const autoBootstrapProjectFromCwd = resolveBooleanFlag(
- input.autoBootstrapProjectFromCwd,
- Option.getOrElse(
- resolveOptionPrecedence(
- Option.fromUndefinedOr(env.autoBootstrapProjectFromCwd),
- Option.flatMap(bootstrapEnvelope, (bootstrap) =>
- Option.fromUndefinedOr(bootstrap.autoBootstrapProjectFromCwd),
- ),
- ),
- () => mode === "web",
- ),
- );
- const logWebSocketEvents = resolveBooleanFlag(
- input.logWebSocketEvents,
- Option.getOrElse(
- resolveOptionPrecedence(
- Option.fromUndefinedOr(env.logWebSocketEvents),
- Option.flatMap(bootstrapEnvelope, (bootstrap) =>
- Option.fromUndefinedOr(bootstrap.logWebSocketEvents),
- ),
- ),
- () => Boolean(devUrl),
- ),
- );
- const staticDir = devUrl ? undefined : yield* cliConfig.resolveStaticDir;
- const host = Option.getOrElse(
- resolveOptionPrecedence(
- input.host,
- Option.fromUndefinedOr(env.host),
- Option.flatMap(bootstrapEnvelope, (bootstrap) => Option.fromUndefinedOr(bootstrap.host)),
- ),
- () => (mode === "desktop" ? "127.0.0.1" : undefined),
- );
-
- const config: ServerConfigShape = {
- mode,
- port,
- cwd: cliConfig.cwd,
- host,
- baseDir,
- ...derivedPaths,
- staticDir,
- devUrl,
- noBrowser,
- authToken: Option.getOrUndefined(authToken),
- autoBootstrapProjectFromCwd,
- logWebSocketEvents,
- } satisfies ServerConfigShape;
-
- return config;
- }),
- );
-
-const LayerLive = (input: CliInput) =>
- Layer.empty.pipe(
- Layer.provideMerge(makeServerRuntimeServicesLayer()),
- Layer.provideMerge(makeServerProviderLayer()),
- Layer.provideMerge(ProviderRegistryLive),
- Layer.provideMerge(SqlitePersistence.layerConfig),
- Layer.provideMerge(ServerLoggerLive),
- Layer.provideMerge(AnalyticsServiceLayerLive),
- Layer.provideMerge(ServerSettingsLive),
- Layer.provideMerge(ServerConfigLive(input)),
- );
-
-const isWildcardHost = (host: string | undefined): boolean =>
- host === "0.0.0.0" || host === "::" || host === "[::]";
-
-const formatHostForUrl = (host: string): string =>
- host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-
-export const recordStartupHeartbeat = Effect.gen(function* () {
- const analytics = yield* AnalyticsService;
- const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
-
- const { threadCount, projectCount } = yield* projectionSnapshotQuery.getSnapshot().pipe(
- Effect.map((snapshot) => ({
- threadCount: snapshot.threads.length,
- projectCount: snapshot.projects.length,
- })),
- Effect.catch((cause) =>
- Effect.logWarning("failed to gather startup snapshot for telemetry", { cause }).pipe(
- Effect.as({
- threadCount: 0,
- projectCount: 0,
- }),
- ),
- ),
- );
-
- yield* analytics.record("server.boot.heartbeat", {
- threadCount,
- projectCount,
- });
-});
-
-const makeServerRuntimeProgram = (input: CliInput) =>
- Effect.gen(function* () {
- const { start, stopSignal } = yield* Server;
- const openDeps = yield* Open;
-
- const config = yield* ServerConfig;
-
- if (!config.devUrl && !config.staticDir) {
- yield* Effect.logWarning(
- "web bundle missing and no VITE_DEV_SERVER_URL; web UI unavailable",
- {
- hint: "Run `bun run --cwd apps/web build` or set VITE_DEV_SERVER_URL for dev mode.",
- },
- );
- }
-
- yield* start;
- yield* Effect.forkChild(recordStartupHeartbeat);
-
- const localUrl = `http://localhost:${config.port}`;
- const bindUrl =
- config.host && !isWildcardHost(config.host)
- ? `http://${formatHostForUrl(config.host)}:${config.port}`
- : localUrl;
- const { authToken, devUrl, ...safeConfig } = config;
- yield* Effect.logInfo("T3 Code running", {
- ...safeConfig,
- devUrl: devUrl?.toString(),
- authEnabled: Boolean(authToken),
- });
-
- if (!config.noBrowser) {
- const target = config.devUrl?.toString() ?? bindUrl;
- yield* openDeps.openBrowser(target).pipe(
- Effect.catch(() =>
- Effect.logInfo("browser auto-open unavailable", {
- hint: `Open ${target} in your browser.`,
- }),
- ),
- );
- }
-
- return yield* stopSignal;
- }).pipe(Effect.provide(LayerLive(input)));
-
-const makeServerProgram = (input: CliInput) =>
- Effect.gen(function* () {
- const cliConfig = yield* CliConfig;
- yield* cliConfig.fixPath;
- return yield* makeServerRuntimeProgram(input);
- });
-
-/**
- * These flags mirrors the environment variables and the config shape.
- */
-
-const modeFlag = Flag.choice("mode", ["web", "desktop"]).pipe(
- Flag.withDescription("Runtime mode. `desktop` keeps loopback defaults unless overridden."),
- Flag.optional,
-);
-const portFlag = Flag.integer("port").pipe(
- Flag.withSchema(PortSchema),
- Flag.withDescription("Port for the HTTP/WebSocket server."),
- Flag.optional,
-);
-const hostFlag = Flag.string("host").pipe(
- Flag.withDescription("Host/interface to bind (for example 127.0.0.1, 0.0.0.0, or a Tailnet IP)."),
- Flag.optional,
-);
-const t3HomeFlag = Flag.string("home-dir").pipe(
- Flag.withDescription("Base directory for all T3 Code data (equivalent to T3CODE_HOME)."),
- Flag.optional,
-);
-const devUrlFlag = Flag.string("dev-url").pipe(
- Flag.withSchema(Schema.URLFromString),
- Flag.withDescription("Dev web URL to proxy/redirect to (equivalent to VITE_DEV_SERVER_URL)."),
- Flag.optional,
-);
-const noBrowserFlag = Flag.boolean("no-browser").pipe(
- Flag.withDescription("Disable automatic browser opening."),
- Flag.optional,
-);
-const authTokenFlag = Flag.string("auth-token").pipe(
- Flag.withDescription("Auth token required for WebSocket connections."),
- Flag.withAlias("token"),
- Flag.optional,
-);
-const bootstrapFdFlag = Flag.integer("bootstrap-fd").pipe(
- Flag.withSchema(Schema.Int),
- Flag.withDescription("Read one-time bootstrap secrets from the given file descriptor."),
- Flag.optional,
-);
-const autoBootstrapProjectFromCwdFlag = Flag.boolean("auto-bootstrap-project-from-cwd").pipe(
- Flag.withDescription(
- "Create a project for the current working directory on startup when missing.",
- ),
- Flag.optional,
-);
-const logWebSocketEventsFlag = Flag.boolean("log-websocket-events").pipe(
- Flag.withDescription(
- "Emit server-side logs for outbound WebSocket push traffic (equivalent to T3CODE_LOG_WS_EVENTS).",
- ),
- Flag.withAlias("log-ws-events"),
- Flag.optional,
-);
-
-export const t3Cli = Command.make("t3", {
- mode: modeFlag,
- port: portFlag,
- host: hostFlag,
- t3Home: t3HomeFlag,
- devUrl: devUrlFlag,
- noBrowser: noBrowserFlag,
- authToken: authTokenFlag,
- bootstrapFd: bootstrapFdFlag,
- autoBootstrapProjectFromCwd: autoBootstrapProjectFromCwdFlag,
- logWebSocketEvents: logWebSocketEventsFlag,
-}).pipe(
- Command.withDescription("Run the T3 Code server."),
- Command.withHandler((input) => Effect.scoped(makeServerProgram(input))),
-);
diff --git a/apps/server/src/open.ts b/apps/server/src/open.ts
index 3fbfd1653..212db36c0 100644
--- a/apps/server/src/open.ts
+++ b/apps/server/src/open.ts
@@ -10,17 +10,14 @@ import { spawn } from "node:child_process";
import { accessSync, constants, statSync } from "node:fs";
import { extname, join } from "node:path";
-import { EDITORS, type EditorId } from "@t3tools/contracts";
-import { ServiceMap, Schema, Effect, Layer } from "effect";
+import { EDITORS, OpenError, type EditorId } from "@t3tools/contracts";
+import { ServiceMap, Effect, Layer } from "effect";
// ==============================
// Definitions
// ==============================
-export class OpenError extends Schema.TaggedErrorClass<OpenError>()("OpenError", {
- message: Schema.String,
- cause: Schema.optional(Schema.Defect),
-}) {}
+export { OpenError };
export interface OpenInEditorInput {
readonly cwd: string;
diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
index 7c201af37..781a0025e 100644
--- a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
@@ -39,6 +39,7 @@ import {
import { checkpointRefForThreadTurn } from "../../checkpointing/Utils.ts";
import { ServerConfig } from "../../config.ts";
import { WorkspaceEntriesLive } from "../../workspace/Layers/WorkspaceEntries.ts";
+import { WorkspacePathsLive } from "../../workspace/Layers/WorkspacePaths.ts";
const asProjectId = (value: string): ProjectId => ProjectId.makeUnsafe(value);
const asTurnId = (value: string): TurnId => TurnId.makeUnsafe(value);
@@ -115,7 +116,7 @@ async function waitForThread(
checkpoints: ReadonlyArray<{ checkpointTurnCount: number }>;
activities: ReadonlyArray<{ kind: string }>;
}) => boolean,
- timeoutMs = 5000,
+ timeoutMs = 15_000,
) {
const deadline = Date.now() + timeoutMs;
const poll = async (): Promise<{
@@ -140,7 +141,7 @@ async function waitForThread(
async function waitForEvent(
engine: OrchestrationEngineShape,
predicate: (event: { type: string }) => boolean,
- timeoutMs = 5000,
+ timeoutMs = 15_000,
) {
const deadline = Date.now() + timeoutMs;
const poll = async () => {
@@ -191,7 +192,7 @@ function gitShowFileAtRef(cwd: string, ref: string, filePath: string): string {
return runGit(cwd, ["show", `${ref}:${filePath}`]);
}
-async function waitForGitRefExists(cwd: string, ref: string, timeoutMs = 5000) {
+async function waitForGitRefExists(cwd: string, ref: string, timeoutMs = 15_000) {
const deadline = Date.now() + timeoutMs;
const poll = async (): Promise<void> => {
if (gitRefExists(cwd, ref)) {
@@ -263,7 +264,8 @@ describe("CheckpointReactor", () => {
Layer.provideMerge(RuntimeReceiptBusLive),
Layer.provideMerge(Layer.succeed(ProviderService, provider.service)),
Layer.provideMerge(CheckpointStoreLive),
- Layer.provideMerge(WorkspaceEntriesLive),
+ Layer.provideMerge(WorkspaceEntriesLive.pipe(Layer.provide(WorkspacePathsLive))),
+ Layer.provideMerge(WorkspacePathsLive),
Layer.provideMerge(GitCoreLive),
Layer.provideMerge(ServerConfigLayer),
Layer.provideMerge(NodeServices.layer),
@@ -1007,18 +1009,7 @@ describe("CheckpointReactor", () => {
}),
);
- const deadline = Date.now() + 2000;
- const waitForRollbackCalls = async (): Promise<void> => {
- if (harness.provider.rollbackConversation.mock.calls.length >= 2) {
- return;
- }
- if (Date.now() >= deadline) {
- throw new Error("Timed out waiting for rollbackConversation calls.");
- }
- await new Promise((resolve) => setTimeout(resolve, 10));
- return waitForRollbackCalls();
- };
- await waitForRollbackCalls();
+ await harness.drain();
expect(harness.provider.rollbackConversation).toHaveBeenCalledTimes(2);
expect(harness.provider.rollbackConversation.mock.calls[0]?.[0]).toEqual({
diff --git a/apps/server/src/orchestration/Layers/OrchestrationEngine.ts b/apps/server/src/orchestration/Layers/OrchestrationEngine.ts
index 69b28b9d3..5c52379f4 100644
--- a/apps/server/src/orchestration/Layers/OrchestrationEngine.ts
+++ b/apps/server/src/orchestration/Layers/OrchestrationEngine.ts
@@ -205,7 +205,7 @@ const makeOrchestrationEngine = Effect.gen(function* () {
const worker = Effect.forever(Queue.take(commandQueue).pipe(Effect.flatMap(processEnvelope)));
yield* Effect.forkScoped(worker);
- yield* Effect.log("orchestration engine started").pipe(
+ yield* Effect.logDebug("orchestration engine started").pipe(
Effect.annotateLogs({ sequence: readModel.snapshotSequence }),
);
diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts
index f0f2ccabe..61de04ad0 100644
--- a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts
+++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts
@@ -3,7 +3,6 @@ import {
type ChatAttachment,
type OrchestrationEvent,
} from "@t3tools/contracts";
-import * as NodeServices from "@effect/platform-node/NodeServices";
import { Effect, FileSystem, Layer, Option, Path, Stream } from "effect";
import * as SqlClient from "effect/unstable/sql/SqlClient";
@@ -1271,7 +1270,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
Effect.provideService(ServerConfig, serverConfig),
Effect.asVoid,
Effect.tap(() =>
- Effect.log("orchestration projection pipeline bootstrapped").pipe(
+ Effect.logDebug("orchestration projection pipeline bootstrapped").pipe(
Effect.annotateLogs({ projectors: projectors.length }),
),
),
@@ -1291,7 +1290,6 @@ export const OrchestrationProjectionPipelineLive = Layer.effect(
OrchestrationProjectionPipeline,
makeOrchestrationProjectionPipeline(),
).pipe(
- Layer.provideMerge(NodeServices.layer),
Layer.provideMerge(ProjectionProjectRepositoryLive),
Layer.provideMerge(ProjectionThreadRepositoryLive),
Layer.provideMerge(ProjectionThreadMessageRepositoryLive),
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
index ed7037695..506d6d286 100644
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
@@ -17,7 +17,7 @@ import { Effect, Exit, Layer, ManagedRuntime, PubSub, Scope, Stream } from "effe
import { afterEach, describe, expect, it, vi } from "vitest";
import { deriveServerPaths, ServerConfig } from "../../config.ts";
-import { TextGenerationError } from "../../git/Errors.ts";
+import { TextGenerationError } from "@t3tools/contracts";
import { ProviderAdapterRequestError } from "../../provider/Errors.ts";
import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";
import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";
diff --git a/apps/server/src/orchestration/Normalizer.ts b/apps/server/src/orchestration/Normalizer.ts
new file mode 100644
index 000000000..69863b7f0
--- /dev/null
+++ b/apps/server/src/orchestration/Normalizer.ts
@@ -0,0 +1,121 @@
+import { Effect, FileSystem, Path } from "effect";
+import {
+ type ClientOrchestrationCommand,
+ type OrchestrationCommand,
+ OrchestrationDispatchCommandError,
+ PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
+} from "@t3tools/contracts";
+
+import { createAttachmentId, resolveAttachmentPath } from "../attachmentStore";
+import { ServerConfig } from "../config";
+import { parseBase64DataUrl } from "../imageMime";
+import { WorkspacePaths } from "../workspace/Services/WorkspacePaths";
+
+export const normalizeDispatchCommand = (command: ClientOrchestrationCommand) =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const serverConfig = yield* ServerConfig;
+ const workspacePaths = yield* WorkspacePaths;
+
+ const normalizeProjectWorkspaceRoot = (workspaceRoot: string) =>
+ workspacePaths.normalizeWorkspaceRoot(workspaceRoot).pipe(
+ Effect.mapError(
+ (cause) =>
+ new OrchestrationDispatchCommandError({
+ message: cause.message,
+ }),
+ ),
+ );
+
+ if (command.type === "project.create") {
+ return {
+ ...command,
+ workspaceRoot: yield* normalizeProjectWorkspaceRoot(command.workspaceRoot),
+ } satisfies OrchestrationCommand;
+ }
+
+ if (command.type === "project.meta.update" && command.workspaceRoot !== undefined) {
+ return {
+ ...command,
+ workspaceRoot: yield* normalizeProjectWorkspaceRoot(command.workspaceRoot),
+ } satisfies OrchestrationCommand;
+ }
+
+ if (command.type !== "thread.turn.start") {
+ return command as OrchestrationCommand;
+ }
+
+ const normalizedAttachments = yield* Effect.forEach(
+ command.message.attachments,
+ (attachment) =>
+ Effect.gen(function* () {
+ const parsed = parseBase64DataUrl(attachment.dataUrl);
+ if (!parsed || !parsed.mimeType.startsWith("image/")) {
+ return yield* new OrchestrationDispatchCommandError({
+ message: `Invalid image attachment payload for '${attachment.name}'.`,
+ });
+ }
+
+ const bytes = Buffer.from(parsed.base64, "base64");
+ if (bytes.byteLength === 0 || bytes.byteLength > PROVIDER_SEND_TURN_MAX_IMAGE_BYTES) {
+ return yield* new OrchestrationDispatchCommandError({
+ message: `Image attachment '${attachment.name}' is empty or too large.`,
+ });
+ }
+
+ const attachmentId = createAttachmentId(command.threadId);
+ if (!attachmentId) {
+ return yield* new OrchestrationDispatchCommandError({
+ message: "Failed to create a safe attachment id.",
+ });
+ }
+
+ const persistedAttachment = {
+ type: "image" as const,
+ id: attachmentId,
+ name: attachment.name,
+ mimeType: parsed.mimeType.toLowerCase(),
+ sizeBytes: bytes.byteLength,
+ };
+
+ const attachmentPath = resolveAttachmentPath({
+ attachmentsDir: serverConfig.attachmentsDir,
+ attachment: persistedAttachment,
+ });
+ if (!attachmentPath) {
+ return yield* new OrchestrationDispatchCommandError({
+ message: `Failed to resolve persisted path for '${attachment.name}'.`,
+ });
+ }
+
+ yield* fileSystem.makeDirectory(path.dirname(attachmentPath), { recursive: true }).pipe(
+ Effect.mapError(
+ () =>
+ new OrchestrationDispatchCommandError({
+ message: `Failed to create attachment directory for '${attachment.name}'.`,
+ }),
+ ),
+ );
+ yield* fileSystem.writeFile(attachmentPath, bytes).pipe(
+ Effect.mapError(
+ () =>
+ new OrchestrationDispatchCommandError({
+ message: `Failed to persist attachment '${attachment.name}'.`,
+ }),
+ ),
+ );
+
+ return persistedAttachment;
+ }),
+ { concurrency: 1 },
+ );
+
+ return {
+ ...command,
+ message: {
+ ...command.message,
+ attachments: normalizedAttachments,
+ },
+ } satisfies OrchestrationCommand;
+ });
diff --git a/apps/server/src/projectFaviconRoute.test.ts b/apps/server/src/projectFaviconRoute.test.ts
deleted file mode 100644
index 99b61aedc..000000000
--- a/apps/server/src/projectFaviconRoute.test.ts
+++ /dev/null
@@ -1,189 +0,0 @@
-import fs from "node:fs";
-import http from "node:http";
-import os from "node:os";
-import path from "node:path";
-
-import * as NodeServices from "@effect/platform-node/NodeServices";
-import { Effect } from "effect";
-import { afterEach, describe, expect, it } from "vitest";
-
-import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver.ts";
-import { tryHandleProjectFaviconRequest } from "./projectFaviconRoute";
-
-interface HttpResponse {
- statusCode: number;
- contentType: string | null;
- body: string;
-}
-
-const tempDirs: string[] = [];
-
-function makeTempDir(prefix: string): string {
- const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
- tempDirs.push(dir);
- return dir;
-}
-
-async function withRouteServer(run: (baseUrl: string) => Promise<void>): Promise<void> {
- const server = http.createServer((req, res) => {
- const url = new URL(req.url ?? "/", "http://127.0.0.1");
- void Effect.runPromise(
- tryHandleProjectFaviconRequest(url, res).pipe(
- Effect.provide(ProjectFaviconResolverLive),
- Effect.provide(NodeServices.layer),
- Effect.flatMap((handled) =>
- handled
- ? Effect.void
- : Effect.sync(() => {
- res.writeHead(404, { "Content-Type": "text/plain" });
- res.end("Not Found");
- }),
- ),
- ),
- ).catch(() => {
- if (!res.headersSent) {
- res.writeHead(500, { "Content-Type": "text/plain" });
- res.end("Internal Server Error");
- }
- });
- });
-
- await new Promise<void>((resolve, reject) => {
- server.listen(0, "127.0.0.1", (error?: Error) => {
- if (error) {
- reject(error);
- return;
- }
- resolve();
- });
- });
-
- const address = server.address();
- if (typeof address !== "object" || address === null) {
- throw new Error("Expected server address to be an object");
- }
- const baseUrl = `http://127.0.0.1:${address.port}`;
-
- try {
- await run(baseUrl);
- } finally {
- await new Promise<void>((resolve, reject) => {
- server.close((error?: Error) => {
- if (error) {
- reject(error);
- return;
- }
- resolve();
- });
- });
- }
-}
-
-async function request(baseUrl: string, pathname: string): Promise<HttpResponse> {
- const response = await fetch(`${baseUrl}${pathname}`);
- return {
- statusCode: response.status,
- contentType: response.headers.get("content-type"),
- body: await response.text(),
- };
-}
-
-describe("tryHandleProjectFaviconRequest", () => {
- afterEach(() => {
- for (const dir of tempDirs.splice(0, tempDirs.length)) {
- fs.rmSync(dir, { recursive: true, force: true });
- }
- });
-
- it("returns 400 when cwd is missing", async () => {
- await withRouteServer(async (baseUrl) => {
- const response = await request(baseUrl, "/api/project-favicon");
- expect(response.statusCode).toBe(400);
- expect(response.body).toBe("Missing cwd parameter");
- });
- });
-
- it("serves a well-known favicon file from the project root", async () => {
- const projectDir = makeTempDir("t3code-favicon-route-root-");
- fs.writeFileSync(path.join(projectDir, "favicon.svg"), "<svg>favicon</svg>", "utf8");
-
- await withRouteServer(async (baseUrl) => {
- const pathname = `/api/project-favicon?cwd=${encodeURIComponent(projectDir)}`;
- const response = await request(baseUrl, pathname);
- expect(response.statusCode).toBe(200);
- expect(response.contentType).toContain("image/svg+xml");
- expect(response.body).toBe("<svg>favicon</svg>");
- });
- });
-
- it("resolves icon href from source files when no well-known favicon exists", async () => {
- const projectDir = makeTempDir("t3code-favicon-route-source-");
- const iconPath = path.join(projectDir, "public", "brand", "logo.svg");
- fs.mkdirSync(path.dirname(iconPath), { recursive: true });
- fs.writeFileSync(
- path.join(projectDir, "index.html"),
- '<link rel="icon" href="/brand/logo.svg">',
- );
- fs.writeFileSync(iconPath, "<svg>brand</svg>", "utf8");
-
- await withRouteServer(async (baseUrl) => {
- const pathname = `/api/project-favicon?cwd=${encodeURIComponent(projectDir)}`;
- const response = await request(baseUrl, pathname);
- expect(response.statusCode).toBe(200);
- expect(response.contentType).toContain("image/svg+xml");
- expect(response.body).toBe("<svg>brand</svg>");
- });
- });
-
- it("resolves icon link when href appears before rel in HTML", async () => {
- const projectDir = makeTempDir("t3code-favicon-route-html-order-");
- const iconPath = path.join(projectDir, "public", "brand", "logo.svg");
- fs.mkdirSync(path.dirname(iconPath), { recursive: true });
- fs.writeFileSync(
- path.join(projectDir, "index.html"),
- '<link href="/brand/logo.svg" rel="icon">',
- );
- fs.writeFileSync(iconPath, "<svg>brand-html-order</svg>", "utf8");
-
- await withRouteServer(async (baseUrl) => {
- const pathname = `/api/project-favicon?cwd=${encodeURIComponent(projectDir)}`;
- const response = await request(baseUrl, pathname);
- expect(response.statusCode).toBe(200);
- expect(response.contentType).toContain("image/svg+xml");
- expect(response.body).toBe("<svg>brand-html-order</svg>");
- });
- });
-
- it("resolves object-style icon metadata when href appears before rel", async () => {
- const projectDir = makeTempDir("t3code-favicon-route-obj-order-");
- const iconPath = path.join(projectDir, "public", "brand", "obj.svg");
- fs.mkdirSync(path.dirname(iconPath), { recursive: true });
- fs.mkdirSync(path.join(projectDir, "src"), { recursive: true });
- fs.writeFileSync(
- path.join(projectDir, "src", "root.tsx"),
- 'const links = [{ href: "/brand/obj.svg", rel: "icon" }];',
- "utf8",
- );
- fs.writeFileSync(iconPath, "<svg>brand-obj-order</svg>", "utf8");
-
- await withRouteServer(async (baseUrl) => {
- const pathname = `/api/project-favicon?cwd=${encodeURIComponent(projectDir)}`;
- const response = await request(baseUrl, pathname);
- expect(response.statusCode).toBe(200);
- expect(response.contentType).toContain("image/svg+xml");
- expect(response.body).toBe("<svg>brand-obj-order</svg>");
- });
- });
-
- it("serves a fallback favicon when no icon exists", async () => {
- const projectDir = makeTempDir("t3code-favicon-route-fallback-");
-
- await withRouteServer(async (baseUrl) => {
- const pathname = `/api/project-favicon?cwd=${encodeURIComponent(projectDir)}`;
- const response = await request(baseUrl, pathname);
- expect(response.statusCode).toBe(200);
- expect(response.contentType).toContain("image/svg+xml");
- expect(response.body).toContain('data-fallback="project-favicon"');
- });
- });
-});
diff --git a/apps/server/src/projectFaviconRoute.ts b/apps/server/src/projectFaviconRoute.ts
deleted file mode 100644
index 56a9fc903..000000000
--- a/apps/server/src/projectFaviconRoute.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import http from "node:http";
-import path from "node:path";
-import { Effect, FileSystem } from "effect";
-
-import { ProjectFaviconResolver } from "./project/Services/ProjectFaviconResolver.ts";
-
-const FAVICON_MIME_TYPES: Record<string, string> = {
- ".png": "image/png",
- ".jpg": "image/jpeg",
- ".svg": "image/svg+xml",
- ".ico": "image/x-icon",
-};
-
-const FALLBACK_FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" fill="none" stroke="#6b728080" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" data-fallback="project-favicon"><path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-8l-2-2H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2Z"/></svg>`;
-
-export const tryHandleProjectFaviconRequest = Effect.fn("tryHandleProjectFaviconRequest")(
- function* (
- url: URL,
- res: http.ServerResponse,
- ): Effect.fn.Return<boolean, never, ProjectFaviconResolver | FileSystem.FileSystem> {
- const respond = (
- statusCode: number,
- headers: Record<string, string>,
- body: string | Uint8Array,
- ) => {
- res.writeHead(statusCode, headers);
- res.end(body);
- };
-
- if (url.pathname !== "/api/project-favicon") {
- return false;
- }
-
- const projectCwd = url.searchParams.get("cwd");
- if (!projectCwd) {
- respond(400, { "Content-Type": "text/plain" }, "Missing cwd parameter");
- return true;
- }
-
- const fileSystem = yield* FileSystem.FileSystem;
- const faviconResolver = yield* ProjectFaviconResolver;
- const resolvedPath = yield* faviconResolver.resolvePath(projectCwd);
-
- if (!resolvedPath) {
- respond(
- 200,
- {
- "Content-Type": "image/svg+xml",
- "Cache-Control": "public, max-age=3600",
- },
- FALLBACK_FAVICON_SVG,
- );
- return true;
- }
-
- const data = yield* fileSystem
- .readFile(resolvedPath)
- .pipe(Effect.catch(() => Effect.succeed(null)));
- if (!data) {
- respond(500, { "Content-Type": "text/plain" }, "Read error");
- return true;
- }
-
- const ext = path.extname(resolvedPath).toLowerCase();
- const contentType = FAVICON_MIME_TYPES[ext] ?? "application/octet-stream";
- respond(
- 200,
- {
- "Content-Type": contentType,
- "Cache-Control": "public, max-age=3600",
- },
- data,
- );
- return true;
- },
-);
diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.test.ts b/apps/server/src/provider/Layers/ClaudeAdapter.test.ts
index d064a8239..5a09d8b6b 100644
--- a/apps/server/src/provider/Layers/ClaudeAdapter.test.ts
+++ b/apps/server/src/provider/Layers/ClaudeAdapter.test.ts
@@ -208,6 +208,9 @@ async function readFirstPromptText(
if (next.done) {
return undefined;
}
+ if (typeof next.value.message.content === "string") {
+ return next.value.message.content;
+ }
const content = next.value.message.content[0];
if (!content || content.type !== "text") {
return undefined;
diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.ts b/apps/server/src/provider/Layers/ClaudeAdapter.ts
index 6b50bd4fb..d99e2ad20 100644
--- a/apps/server/src/provider/Layers/ClaudeAdapter.ts
+++ b/apps/server/src/provider/Layers/ClaudeAdapter.ts
@@ -533,7 +533,7 @@ function buildUserMessage(input: {
parent_tool_use_id: null,
message: {
role: "user",
- content: input.sdkContent,
+ content: input.sdkContent as unknown as SDKUserMessage["message"]["content"],
},
} as SDKUserMessage;
}
diff --git a/apps/server/src/provider/Layers/ClaudeProvider.ts b/apps/server/src/provider/Layers/ClaudeProvider.ts
index f2243ef1b..158a9ef25 100644
--- a/apps/server/src/provider/Layers/ClaudeProvider.ts
+++ b/apps/server/src/provider/Layers/ClaudeProvider.ts
@@ -24,7 +24,8 @@ import {
} from "../providerSnapshot";
import { makeManagedServerProvider } from "../makeManagedServerProvider";
import { ClaudeProvider } from "../Services/ClaudeProvider";
-import { ServerSettingsError, ServerSettingsService } from "../../serverSettings";
+import { ServerSettingsService } from "../../serverSettings";
+import { ServerSettingsError } from "@t3tools/contracts";
const PROVIDER = "claudeAgent" as const;
const BUILT_IN_MODELS: ReadonlyArray<ServerProviderModel> = [
diff --git a/apps/server/src/provider/Layers/CodexProvider.ts b/apps/server/src/provider/Layers/CodexProvider.ts
index 1fe98ea79..499d4c6ff 100644
--- a/apps/server/src/provider/Layers/CodexProvider.ts
+++ b/apps/server/src/provider/Layers/CodexProvider.ts
@@ -46,7 +46,8 @@ import {
} from "../codexAccount";
import { probeCodexAccount } from "../codexAppServer";
import { CodexProvider } from "../Services/CodexProvider";
-import { ServerSettingsError, ServerSettingsService } from "../../serverSettings";
+import { ServerSettingsService } from "../../serverSettings";
+import { ServerSettingsError } from "@t3tools/contracts";
const PROVIDER = "codex" as const;
const OPENAI_AUTH_PROVIDERS = new Set(["openai"]);
diff --git a/apps/server/src/provider/makeManagedServerProvider.ts b/apps/server/src/provider/makeManagedServerProvider.ts
index e519e82af..4c1d0878f 100644
--- a/apps/server/src/provider/makeManagedServerProvider.ts
+++ b/apps/server/src/provider/makeManagedServerProvider.ts
@@ -3,7 +3,7 @@ import { Duration, Effect, PubSub, Ref, Scope, Stream } from "effect";
import * as Semaphore from "effect/Semaphore";
import type { ServerProviderShape } from "./Services/ServerProvider";
-import { ServerSettingsError } from "../serverSettings";
+import { ServerSettingsError } from "@t3tools/contracts";
export function makeManagedServerProvider<Settings>(input: {
readonly getSettings: Effect.Effect<Settings>;
diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts
new file mode 100644
index 000000000..0e53eae43
--- /dev/null
+++ b/apps/server/src/server.test.ts
@@ -0,0 +1,1391 @@
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
+import * as NodeSocket from "@effect/platform-node/NodeSocket";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import {
+ CommandId,
+ DEFAULT_SERVER_SETTINGS,
+ GitCommandError,
+ KeybindingRule,
+ OpenError,
+ TerminalNotRunningError,
+ type OrchestrationEvent,
+ ORCHESTRATION_WS_METHODS,
+ ProjectId,
+ ResolvedKeybindingRule,
+ ThreadId,
+ WS_METHODS,
+ WsRpcGroup,
+ EditorId,
+} from "@t3tools/contracts";
+import { assert, it } from "@effect/vitest";
+import { assertFailure, assertInclude, assertTrue } from "@effect/vitest/utils";
+import { Effect, FileSystem, Layer, Path, Stream } from "effect";
+import { HttpClient, HttpRouter, HttpServer } from "effect/unstable/http";
+import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
+
+import type { ServerConfigShape } from "./config.ts";
+import { deriveServerPaths, ServerConfig } from "./config.ts";
+import { makeRoutesLayer } from "./server.ts";
+import { resolveAttachmentRelativePath } from "./attachmentPaths.ts";
+import {
+ CheckpointDiffQuery,
+ type CheckpointDiffQueryShape,
+} from "./checkpointing/Services/CheckpointDiffQuery.ts";
+import { GitCore, type GitCoreShape } from "./git/Services/GitCore.ts";
+import { GitManager, type GitManagerShape } from "./git/Services/GitManager.ts";
+import { Keybindings, type KeybindingsShape } from "./keybindings.ts";
+import { Open, type OpenShape } from "./open.ts";
+import {
+ OrchestrationEngineService,
+ type OrchestrationEngineShape,
+} from "./orchestration/Services/OrchestrationEngine.ts";
+import {
+ ProjectionSnapshotQuery,
+ type ProjectionSnapshotQueryShape,
+} from "./orchestration/Services/ProjectionSnapshotQuery.ts";
+import { PersistenceSqlError } from "./persistence/Errors.ts";
+import {
+ ProviderRegistry,
+ type ProviderRegistryShape,
+} from "./provider/Services/ProviderRegistry.ts";
+import { ServerLifecycleEvents, type ServerLifecycleEventsShape } from "./serverLifecycleEvents.ts";
+import { ServerRuntimeStartup, type ServerRuntimeStartupShape } from "./serverRuntimeStartup.ts";
+import { ServerSettingsService, type ServerSettingsShape } from "./serverSettings.ts";
+import { TerminalManager, type TerminalManagerShape } from "./terminal/Services/Manager.ts";
+import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver.ts";
+import { WorkspaceEntriesLive } from "./workspace/Layers/WorkspaceEntries.ts";
+import { WorkspaceFileSystemLive } from "./workspace/Layers/WorkspaceFileSystem.ts";
+import { WorkspacePathsLive } from "./workspace/Layers/WorkspacePaths.ts";
+
+const defaultProjectId = ProjectId.makeUnsafe("project-default");
+const defaultThreadId = ThreadId.makeUnsafe("thread-default");
+const defaultModelSelection = {
+ provider: "codex",
+ model: "gpt-5-codex",
+} as const;
+
+const makeDefaultOrchestrationReadModel = () => {
+ const now = new Date().toISOString();
+ return {
+ snapshotSequence: 0,
+ updatedAt: now,
+ projects: [
+ {
+ id: defaultProjectId,
+ title: "Default Project",
+ workspaceRoot: "/tmp/default-project",
+ defaultModelSelection,
+ scripts: [],
+ createdAt: now,
+ updatedAt: now,
+ deletedAt: null,
+ },
+ ],
+ threads: [
+ {
+ id: defaultThreadId,
+ projectId: defaultProjectId,
+ title: "Default Thread",
+ modelSelection: defaultModelSelection,
+ interactionMode: "default" as const,
+ runtimeMode: "full-access" as const,
+ branch: null,
+ worktreePath: null,
+ createdAt: now,
+ updatedAt: now,
+ archivedAt: null,
+ latestTurn: null,
+ messages: [],
+ session: null,
+ activities: [],
+ proposedPlans: [],
+ checkpoints: [],
+ deletedAt: null,
+ },
+ ],
+ };
+};
+
+const workspaceAndProjectServicesLayer = Layer.mergeAll(
+ WorkspacePathsLive,
+ WorkspaceEntriesLive.pipe(Layer.provide(WorkspacePathsLive)),
+ WorkspaceFileSystemLive.pipe(
+ Layer.provide(WorkspacePathsLive),
+ Layer.provide(WorkspaceEntriesLive.pipe(Layer.provide(WorkspacePathsLive))),
+ ),
+ ProjectFaviconResolverLive,
+);
+
+const buildAppUnderTest = (options?: {
+ config?: Partial<ServerConfigShape>;
+ layers?: {
+ keybindings?: Partial<KeybindingsShape>;
+ providerRegistry?: Partial<ProviderRegistryShape>;
+ serverSettings?: Partial<ServerSettingsShape>;
+ open?: Partial<OpenShape>;
+ gitCore?: Partial<GitCoreShape>;
+ gitManager?: Partial<GitManagerShape>;
+ terminalManager?: Partial<TerminalManagerShape>;
+ orchestrationEngine?: Partial<OrchestrationEngineShape>;
+ projectionSnapshotQuery?: Partial<ProjectionSnapshotQueryShape>;
+ checkpointDiffQuery?: Partial<CheckpointDiffQueryShape>;
+ serverLifecycleEvents?: Partial<ServerLifecycleEventsShape>;
+ serverRuntimeStartup?: Partial<ServerRuntimeStartupShape>;
+ };
+}) =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const tempBaseDir = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-router-test-" });
+ const baseDir = options?.config?.baseDir ?? tempBaseDir;
+ const devUrl = options?.config?.devUrl;
+ const derivedPaths = yield* deriveServerPaths(baseDir, devUrl);
+ const config = {
+ logLevel: "Info",
+ mode: "web",
+ port: 0,
+ host: "127.0.0.1",
+ cwd: process.cwd(),
+ baseDir,
+ ...derivedPaths,
+ staticDir: undefined,
+ devUrl,
+ noBrowser: true,
+ authToken: undefined,
+ autoBootstrapProjectFromCwd: false,
+ logWebSocketEvents: false,
+ ...options?.config,
+ } satisfies ServerConfigShape;
+ const layerConfig = Layer.succeed(ServerConfig, config);
+
+ const appLayer = HttpRouter.serve(makeRoutesLayer, {
+ disableListenLog: true,
+ disableLogger: true,
+ }).pipe(
+ Layer.provide(
+ Layer.mock(Keybindings)({
+ streamChanges: Stream.empty,
+ ...options?.layers?.keybindings,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(ProviderRegistry)({
+ getProviders: Effect.succeed([]),
+ refresh: () => Effect.succeed([]),
+ streamChanges: Stream.empty,
+ ...options?.layers?.providerRegistry,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(ServerSettingsService)({
+ start: Effect.void,
+ ready: Effect.void,
+ getSettings: Effect.succeed(DEFAULT_SERVER_SETTINGS),
+ updateSettings: () => Effect.succeed(DEFAULT_SERVER_SETTINGS),
+ streamChanges: Stream.empty,
+ ...options?.layers?.serverSettings,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(Open)({
+ ...options?.layers?.open,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(GitCore)({
+ ...options?.layers?.gitCore,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(GitManager)({
+ ...options?.layers?.gitManager,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(TerminalManager)({
+ ...options?.layers?.terminalManager,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(OrchestrationEngineService)({
+ getReadModel: () => Effect.succeed(makeDefaultOrchestrationReadModel()),
+ readEvents: () => Stream.empty,
+ dispatch: () => Effect.succeed({ sequence: 0 }),
+ streamDomainEvents: Stream.empty,
+ ...options?.layers?.orchestrationEngine,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(ProjectionSnapshotQuery)({
+ getSnapshot: () => Effect.succeed(makeDefaultOrchestrationReadModel()),
+ ...options?.layers?.projectionSnapshotQuery,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(CheckpointDiffQuery)({
+ getTurnDiff: () =>
+ Effect.succeed({
+ threadId: defaultThreadId,
+ fromTurnCount: 0,
+ toTurnCount: 0,
+ diff: "",
+ }),
+ getFullThreadDiff: () =>
+ Effect.succeed({
+ threadId: defaultThreadId,
+ fromTurnCount: 0,
+ toTurnCount: 0,
+ diff: "",
+ }),
+ ...options?.layers?.checkpointDiffQuery,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(ServerLifecycleEvents)({
+ publish: (event) => Effect.succeed({ ...(event as any), sequence: 1 }),
+ snapshot: Effect.succeed({ sequence: 0, events: [] }),
+ stream: Stream.empty,
+ ...options?.layers?.serverLifecycleEvents,
+ }),
+ ),
+ Layer.provide(
+ Layer.mock(ServerRuntimeStartup)({
+ awaitCommandReady: Effect.void,
+ markHttpListening: Effect.void,
+ enqueueCommand: (effect) => effect,
+ ...options?.layers?.serverRuntimeStartup,
+ }),
+ ),
+ Layer.provide(workspaceAndProjectServicesLayer),
+ Layer.provide(layerConfig),
+ );
+
+ yield* Layer.build(appLayer);
+ return config;
+ });
+
+const wsRpcProtocolLayer = (wsUrl: string) =>
+ RpcClient.layerProtocolSocket().pipe(
+ Layer.provide(NodeSocket.layerWebSocket(wsUrl)),
+ Layer.provide(RpcSerialization.layerJson),
+ );
+
+const makeWsRpcClient = RpcClient.make(WsRpcGroup);
+type WsRpcClient =
+ typeof makeWsRpcClient extends Effect.Effect<infer Client, any, any> ? Client : never;
+
+const withWsRpcClient = <A, E, R>(
+ wsUrl: string,
+ f: (client: WsRpcClient) => Effect.Effect<A, E, R>,
+) => makeWsRpcClient.pipe(Effect.flatMap(f), Effect.provide(wsRpcProtocolLayer(wsUrl)));
+
+const getHttpServerUrl = (pathname = "") =>
+ Effect.gen(function* () {
+ const server = yield* HttpServer.HttpServer;
+ const address = server.address as HttpServer.TcpAddress;
+ return `http://127.0.0.1:${address.port}${pathname}`;
+ });
+
+const getWsServerUrl = (pathname = "") =>
+ Effect.gen(function* () {
+ const server = yield* HttpServer.HttpServer;
+ const address = server.address as HttpServer.TcpAddress;
+ return `ws://127.0.0.1:${address.port}${pathname}`;
+ });
+
+it.layer(NodeServices.layer)("server router seam", (it) => {
+ it.effect("serves static index content for GET / when staticDir is configured", () =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const staticDir = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-router-static-" });
+ const indexPath = path.join(staticDir, "index.html");
+ yield* fileSystem.writeFileString(indexPath, "<html>router-static-ok</html>");
+
+ yield* buildAppUnderTest({ config: { staticDir } });
+
+ const response = yield* HttpClient.get("/");
+ assert.equal(response.status, 200);
+ assert.include(yield* response.text, "router-static-ok");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("redirects to dev URL when configured", () =>
+ Effect.gen(function* () {
+ yield* buildAppUnderTest({
+ config: { devUrl: new URL("http://127.0.0.1:5173") },
+ });
+
+ const url = yield* getHttpServerUrl("/foo/bar");
+ const response = yield* Effect.promise(() => fetch(url, { redirect: "manual" }));
+
+ assert.equal(response.status, 302);
+ assert.equal(response.headers.get("location"), "http://127.0.0.1:5173/");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("serves project favicon requests before the dev URL redirect", () =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const projectDir = yield* fileSystem.makeTempDirectoryScoped({
+ prefix: "t3-router-project-favicon-",
+ });
+ yield* fileSystem.writeFileString(
+ path.join(projectDir, "favicon.svg"),
+ "<svg>router-project-favicon</svg>",
+ );
+
+ yield* buildAppUnderTest({
+ config: { devUrl: new URL("http://127.0.0.1:5173") },
+ });
+
+ const response = yield* HttpClient.get(
+ `/api/project-favicon?cwd=${encodeURIComponent(projectDir)}`,
+ );
+
+ assert.equal(response.status, 200);
+ assert.equal(yield* response.text, "<svg>router-project-favicon</svg>");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("serves the fallback project favicon when no icon exists", () =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const projectDir = yield* fileSystem.makeTempDirectoryScoped({
+ prefix: "t3-router-project-favicon-fallback-",
+ });
+
+ yield* buildAppUnderTest({
+ config: { devUrl: new URL("http://127.0.0.1:5173") },
+ });
+
+ const response = yield* HttpClient.get(
+ `/api/project-favicon?cwd=${encodeURIComponent(projectDir)}`,
+ );
+
+ assert.equal(response.status, 200);
+ assert.include(yield* response.text, 'data-fallback="project-favicon"');
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("serves attachment files from state dir", () =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const attachmentId = "thread-11111111-1111-4111-8111-111111111111";
+
+ const config = yield* buildAppUnderTest();
+ const attachmentPath = resolveAttachmentRelativePath({
+ attachmentsDir: config.attachmentsDir,
+ relativePath: `${attachmentId}.bin`,
+ });
+ assert.isNotNull(attachmentPath, "Attachment path should be resolvable");
+
+ yield* fileSystem.makeDirectory(path.dirname(attachmentPath), { recursive: true });
+ yield* fileSystem.writeFileString(attachmentPath, "attachment-ok");
+
+ const response = yield* HttpClient.get(`/attachments/${attachmentId}`);
+ assert.equal(response.status, 200);
+ assert.equal(yield* response.text, "attachment-ok");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("serves attachment files for URL-encoded paths", () =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+
+ const config = yield* buildAppUnderTest();
+ const attachmentPath = resolveAttachmentRelativePath({
+ attachmentsDir: config.attachmentsDir,
+ relativePath: "thread%20folder/message%20folder/file%20name.png",
+ });
+ assert.isNotNull(attachmentPath, "Attachment path should be resolvable");
+
+ yield* fileSystem.makeDirectory(path.dirname(attachmentPath), { recursive: true });
+ yield* fileSystem.writeFileString(attachmentPath, "attachment-encoded-ok");
+
+ const response = yield* HttpClient.get(
+ "/attachments/thread%20folder/message%20folder/file%20name.png",
+ );
+ assert.equal(response.status, 200);
+ assert.equal(yield* response.text, "attachment-encoded-ok");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("returns 404 for missing attachment id lookups", () =>
+ Effect.gen(function* () {
+ yield* buildAppUnderTest();
+
+ const response = yield* HttpClient.get(
+ "/attachments/missing-11111111-1111-4111-8111-111111111111",
+ );
+ assert.equal(response.status, 404);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc server.upsertKeybinding", () =>
+ Effect.gen(function* () {
+ const rule: KeybindingRule = {
+ command: "terminal.toggle",
+ key: "ctrl+k",
+ };
+ const resolved: ResolvedKeybindingRule = {
+ command: "terminal.toggle",
+ shortcut: {
+ key: "k",
+ metaKey: false,
+ ctrlKey: true,
+ shiftKey: false,
+ altKey: false,
+ modKey: true,
+ },
+ };
+
+ yield* buildAppUnderTest({
+ layers: {
+ keybindings: {
+ upsertKeybindingRule: () => Effect.succeed([resolved]),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const response = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) => client[WS_METHODS.serverUpsertKeybinding](rule)),
+ );
+
+ assert.deepEqual(response.issues, []);
+ assert.deepEqual(response.keybindings, [resolved]);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("rejects websocket rpc handshake when auth token is missing", () =>
+ Effect.gen(function* () {
+ const fs = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const workspaceDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-ws-auth-required-" });
+ yield* fs.writeFileString(
+ path.join(workspaceDir, "needle-file.ts"),
+ "export const needle = 1;",
+ );
+
+ yield* buildAppUnderTest({
+ config: {
+ authToken: "secret-token",
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const result = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.projectsSearchEntries]({
+ cwd: workspaceDir,
+ query: "needle",
+ limit: 10,
+ }),
+ ).pipe(Effect.result),
+ );
+
+ assertTrue(result._tag === "Failure");
+ assertInclude(String(result.failure), "SocketOpenError");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("accepts websocket rpc handshake when auth token is provided", () =>
+ Effect.gen(function* () {
+ const fs = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const workspaceDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-ws-auth-ok-" });
+ yield* fs.writeFileString(
+ path.join(workspaceDir, "needle-file.ts"),
+ "export const needle = 1;",
+ );
+
+ yield* buildAppUnderTest({
+ config: {
+ authToken: "secret-token",
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws?token=secret-token");
+ const response = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.projectsSearchEntries]({
+ cwd: workspaceDir,
+ query: "needle",
+ limit: 10,
+ }),
+ ),
+ );
+
+ assert.isAtLeast(response.entries.length, 1);
+ assert.equal(response.truncated, false);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc subscribeServerConfig streams snapshot then update", () =>
+ Effect.gen(function* () {
+ const providers = [] as const;
+ const changeEvent = {
+ keybindings: [],
+ issues: [],
+ } as const;
+
+ yield* buildAppUnderTest({
+ layers: {
+ keybindings: {
+ loadConfigState: Effect.succeed({
+ keybindings: [],
+ issues: [],
+ }),
+ streamChanges: Stream.succeed(changeEvent),
+ },
+ providerRegistry: {
+ getProviders: Effect.succeed(providers),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const events = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.subscribeServerConfig]({}).pipe(Stream.take(2), Stream.runCollect),
+ ),
+ );
+
+ const [first, second] = Array.from(events);
+ assert.equal(first?.type, "snapshot");
+ if (first?.type === "snapshot") {
+ assert.equal(first.version, 1);
+ assert.deepEqual(first.config.keybindings, []);
+ assert.deepEqual(first.config.issues, []);
+ assert.deepEqual(first.config.providers, providers);
+ assert.deepEqual(first.config.settings, DEFAULT_SERVER_SETTINGS);
+ }
+ assert.deepEqual(second, {
+ version: 1,
+ type: "keybindingsUpdated",
+ payload: { issues: [] },
+ });
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc subscribeServerConfig emits provider status updates", () =>
+ Effect.gen(function* () {
+ const providers = [] as const;
+
+ yield* buildAppUnderTest({
+ layers: {
+ keybindings: {
+ loadConfigState: Effect.succeed({
+ keybindings: [],
+ issues: [],
+ }),
+ streamChanges: Stream.empty,
+ },
+ providerRegistry: {
+ getProviders: Effect.succeed([]),
+ streamChanges: Stream.succeed(providers),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const events = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.subscribeServerConfig]({}).pipe(Stream.take(2), Stream.runCollect),
+ ),
+ );
+
+ const [first, second] = Array.from(events);
+ assert.equal(first?.type, "snapshot");
+ assert.deepEqual(second, {
+ version: 1,
+ type: "providerStatuses",
+ payload: { providers },
+ });
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect(
+ "routes websocket rpc subscribeServerLifecycle replays snapshot and streams updates",
+ () =>
+ Effect.gen(function* () {
+ const lifecycleEvents = [
+ {
+ version: 1 as const,
+ sequence: 1,
+ type: "welcome" as const,
+ payload: {
+ cwd: "/tmp/project",
+ projectName: "project",
+ },
+ },
+ ] as const;
+ const liveEvents = Stream.make({
+ version: 1 as const,
+ sequence: 2,
+ type: "ready" as const,
+ payload: { at: new Date().toISOString() },
+ });
+
+ yield* buildAppUnderTest({
+ layers: {
+ serverLifecycleEvents: {
+ snapshot: Effect.succeed({
+ sequence: 1,
+ events: lifecycleEvents,
+ }),
+ stream: liveEvents,
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const events = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.subscribeServerLifecycle]({}).pipe(Stream.take(2), Stream.runCollect),
+ ),
+ );
+
+ const [first, second] = Array.from(events);
+ assert.equal(first?.type, "welcome");
+ assert.equal(first?.sequence, 1);
+ assert.equal(second?.type, "ready");
+ assert.equal(second?.sequence, 2);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc projects.searchEntries", () =>
+ Effect.gen(function* () {
+ const fs = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const workspaceDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-ws-project-search-" });
+ yield* fs.writeFileString(
+ path.join(workspaceDir, "needle-file.ts"),
+ "export const needle = 1;",
+ );
+
+ yield* buildAppUnderTest();
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const response = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.projectsSearchEntries]({
+ cwd: workspaceDir,
+ query: "needle",
+ limit: 10,
+ }),
+ ),
+ );
+
+ assert.isAtLeast(response.entries.length, 1);
+ assert.isTrue(response.entries.some((entry) => entry.path === "needle-file.ts"));
+ assert.equal(response.truncated, false);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc projects.searchEntries errors", () =>
+ Effect.gen(function* () {
+ yield* buildAppUnderTest();
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const result = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.projectsSearchEntries]({
+ cwd: "/definitely/not/a/real/workspace/path",
+ query: "needle",
+ limit: 10,
+ }),
+ ).pipe(Effect.result),
+ );
+
+ assertTrue(result._tag === "Failure");
+ assertTrue(result.failure._tag === "ProjectSearchEntriesError");
+ assertInclude(
+ result.failure.message,
+ "Workspace root does not exist: /definitely/not/a/real/workspace/path",
+ );
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc projects.writeFile", () =>
+ Effect.gen(function* () {
+ const fs = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const workspaceDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-ws-project-write-" });
+
+ yield* buildAppUnderTest();
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const response = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.projectsWriteFile]({
+ cwd: workspaceDir,
+ relativePath: "nested/created.txt",
+ contents: "written-by-rpc",
+ }),
+ ),
+ );
+
+ assert.equal(response.relativePath, "nested/created.txt");
+ const persisted = yield* fs.readFileString(path.join(workspaceDir, "nested", "created.txt"));
+ assert.equal(persisted, "written-by-rpc");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc projects.writeFile errors", () =>
+ Effect.gen(function* () {
+ const fs = yield* FileSystem.FileSystem;
+ const workspaceDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-ws-project-write-" });
+
+ yield* buildAppUnderTest();
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const result = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.projectsWriteFile]({
+ cwd: workspaceDir,
+ relativePath: "../escape.txt",
+ contents: "nope",
+ }),
+ ).pipe(Effect.result),
+ );
+
+ assertTrue(result._tag === "Failure");
+ assertTrue(result.failure._tag === "ProjectWriteFileError");
+ assert.equal(
+ result.failure.message,
+ "Workspace file path must stay within the project root.",
+ );
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc shell.openInEditor", () =>
+ Effect.gen(function* () {
+ let openedInput: { cwd: string; editor: EditorId } | null = null;
+ yield* buildAppUnderTest({
+ layers: {
+ open: {
+ openInEditor: (input) =>
+ Effect.sync(() => {
+ openedInput = input;
+ }),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.shellOpenInEditor]({
+ cwd: "/tmp/project",
+ editor: "cursor",
+ }),
+ ),
+ );
+
+ assert.deepEqual(openedInput, { cwd: "/tmp/project", editor: "cursor" });
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc shell.openInEditor errors", () =>
+ Effect.gen(function* () {
+ const openError = new OpenError({ message: "Editor command not found: cursor" });
+ yield* buildAppUnderTest({
+ layers: {
+ open: {
+ openInEditor: () => Effect.fail(openError),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const result = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.shellOpenInEditor]({
+ cwd: "/tmp/project",
+ editor: "cursor",
+ }),
+ ).pipe(Effect.result),
+ );
+
+ assertFailure(result, openError);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc git methods", () =>
+ Effect.gen(function* () {
+ yield* buildAppUnderTest({
+ layers: {
+ gitManager: {
+ status: () =>
+ Effect.succeed({
+ branch: "main",
+ hasWorkingTreeChanges: false,
+ workingTree: { files: [], insertions: 0, deletions: 0 },
+ hasUpstream: true,
+ aheadCount: 0,
+ behindCount: 0,
+ pr: null,
+ }),
+ runStackedAction: (input, options) =>
+ Effect.gen(function* () {
+ const result = {
+ action: "commit" as const,
+ branch: { status: "skipped_not_requested" as const },
+ commit: {
+ status: "created" as const,
+ commitSha: "abc123",
+ subject: "feat: demo",
+ },
+ push: { status: "skipped_not_requested" as const },
+ pr: { status: "skipped_not_requested" as const },
+ };
+
+ yield* (
+ options?.progressReporter?.publish({
+ actionId: options.actionId ?? input.actionId,
+ cwd: input.cwd,
+ action: input.action,
+ kind: "phase_started",
+ phase: "commit",
+ label: "Committing...",
+ }) ?? Effect.void
+ );
+
+ yield* (
+ options?.progressReporter?.publish({
+ actionId: options.actionId ?? input.actionId,
+ cwd: input.cwd,
+ action: input.action,
+ kind: "action_finished",
+ result,
+ }) ?? Effect.void
+ );
+
+ return result;
+ }),
+ resolvePullRequest: () =>
+ Effect.succeed({
+ pullRequest: {
+ number: 1,
+ title: "Demo PR",
+ url: "https://example.com/pr/1",
+ baseBranch: "main",
+ headBranch: "feature/demo",
+ state: "open",
+ },
+ }),
+ preparePullRequestThread: () =>
+ Effect.succeed({
+ pullRequest: {
+ number: 1,
+ title: "Demo PR",
+ url: "https://example.com/pr/1",
+ baseBranch: "main",
+ headBranch: "feature/demo",
+ state: "open",
+ },
+ branch: "feature/demo",
+ worktreePath: null,
+ }),
+ },
+ gitCore: {
+ pullCurrentBranch: () =>
+ Effect.succeed({
+ status: "pulled",
+ branch: "main",
+ upstreamBranch: "origin/main",
+ }),
+ listBranches: () =>
+ Effect.succeed({
+ branches: [
+ {
+ name: "main",
+ current: true,
+ isDefault: true,
+ worktreePath: null,
+ },
+ ],
+ isRepo: true,
+ hasOriginRemote: true,
+ }),
+ createWorktree: () =>
+ Effect.succeed({
+ worktree: { path: "/tmp/wt", branch: "feature/demo" },
+ }),
+ removeWorktree: () => Effect.void,
+ createBranch: () => Effect.void,
+ checkoutBranch: () => Effect.void,
+ initRepo: () => Effect.void,
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+
+ const status = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) => client[WS_METHODS.gitStatus]({ cwd: "/tmp/repo" })),
+ );
+ assert.equal(status.branch, "main");
+
+ const pull = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) => client[WS_METHODS.gitPull]({ cwd: "/tmp/repo" })),
+ );
+ assert.equal(pull.status, "pulled");
+
+ const stackedEvents = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitRunStackedAction]({
+ actionId: "action-1",
+ cwd: "/tmp/repo",
+ action: "commit",
+ }).pipe(
+ Stream.runCollect,
+ Effect.map((events) => Array.from(events)),
+ ),
+ ),
+ );
+ const lastStackedEvent = stackedEvents.at(-1);
+ assert.equal(lastStackedEvent?.kind, "action_finished");
+ if (lastStackedEvent?.kind === "action_finished") {
+ assert.equal(lastStackedEvent.result.action, "commit");
+ }
+
+ const resolvedPr = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitResolvePullRequest]({
+ cwd: "/tmp/repo",
+ reference: "1",
+ }),
+ ),
+ );
+ assert.equal(resolvedPr.pullRequest.number, 1);
+
+ const prepared = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitPreparePullRequestThread]({
+ cwd: "/tmp/repo",
+ reference: "1",
+ mode: "local",
+ }),
+ ),
+ );
+ assert.equal(prepared.branch, "feature/demo");
+
+ const branches = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitListBranches]({ cwd: "/tmp/repo" }),
+ ),
+ );
+ assert.equal(branches.branches[0]?.name, "main");
+
+ const worktree = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitCreateWorktree]({
+ cwd: "/tmp/repo",
+ branch: "main",
+ path: null,
+ }),
+ ),
+ );
+ assert.equal(worktree.worktree.branch, "feature/demo");
+
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitRemoveWorktree]({
+ cwd: "/tmp/repo",
+ path: "/tmp/wt",
+ }),
+ ),
+ );
+
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitCreateBranch]({
+ cwd: "/tmp/repo",
+ branch: "feature/new",
+ }),
+ ),
+ );
+
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitCheckout]({
+ cwd: "/tmp/repo",
+ branch: "main",
+ }),
+ ),
+ );
+
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.gitInit]({
+ cwd: "/tmp/repo",
+ }),
+ ),
+ );
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc git.pull errors", () =>
+ Effect.gen(function* () {
+ const gitError = new GitCommandError({
+ operation: "pull",
+ command: "git pull --ff-only",
+ cwd: "/tmp/repo",
+ detail: "upstream missing",
+ });
+ yield* buildAppUnderTest({
+ layers: {
+ gitCore: {
+ pullCurrentBranch: () => Effect.fail(gitError),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const result = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) => client[WS_METHODS.gitPull]({ cwd: "/tmp/repo" })).pipe(
+ Effect.result,
+ ),
+ );
+
+ assertFailure(result, gitError);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc orchestration methods", () =>
+ Effect.gen(function* () {
+ const now = new Date().toISOString();
+ const snapshot = {
+ snapshotSequence: 1,
+ updatedAt: now,
+ projects: [
+ {
+ id: ProjectId.makeUnsafe("project-a"),
+ title: "Project A",
+ workspaceRoot: "/tmp/project-a",
+ defaultModelSelection,
+ scripts: [],
+ createdAt: now,
+ updatedAt: now,
+ deletedAt: null,
+ },
+ ],
+ threads: [
+ {
+ id: ThreadId.makeUnsafe("thread-1"),
+ projectId: ProjectId.makeUnsafe("project-a"),
+ title: "Thread A",
+ modelSelection: defaultModelSelection,
+ interactionMode: "default" as const,
+ runtimeMode: "full-access" as const,
+ branch: null,
+ worktreePath: null,
+ createdAt: now,
+ updatedAt: now,
+ archivedAt: null,
+ latestTurn: null,
+ messages: [],
+ session: null,
+ activities: [],
+ proposedPlans: [],
+ checkpoints: [],
+ deletedAt: null,
+ },
+ ],
+ };
+
+ yield* buildAppUnderTest({
+ layers: {
+ projectionSnapshotQuery: {
+ getSnapshot: () => Effect.succeed(snapshot),
+ },
+ orchestrationEngine: {
+ dispatch: () => Effect.succeed({ sequence: 7 }),
+ readEvents: () => Stream.empty,
+ },
+ checkpointDiffQuery: {
+ getTurnDiff: () =>
+ Effect.succeed({
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ fromTurnCount: 0,
+ toTurnCount: 1,
+ diff: "turn-diff",
+ }),
+ getFullThreadDiff: () =>
+ Effect.succeed({
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ fromTurnCount: 0,
+ toTurnCount: 1,
+ diff: "full-diff",
+ }),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const snapshotResult = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) => client[ORCHESTRATION_WS_METHODS.getSnapshot]({})),
+ );
+ assert.equal(snapshotResult.snapshotSequence, 1);
+
+ const dispatchResult = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[ORCHESTRATION_WS_METHODS.dispatchCommand]({
+ type: "thread.session.stop",
+ commandId: CommandId.makeUnsafe("cmd-1"),
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ createdAt: now,
+ }),
+ ),
+ );
+ assert.equal(dispatchResult.sequence, 7);
+
+ const turnDiffResult = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[ORCHESTRATION_WS_METHODS.getTurnDiff]({
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ fromTurnCount: 0,
+ toTurnCount: 1,
+ }),
+ ),
+ );
+ assert.equal(turnDiffResult.diff, "turn-diff");
+
+ const fullDiffResult = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[ORCHESTRATION_WS_METHODS.getFullThreadDiff]({
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ toTurnCount: 1,
+ }),
+ ),
+ );
+ assert.equal(fullDiffResult.diff, "full-diff");
+
+ const replayResult = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[ORCHESTRATION_WS_METHODS.replayEvents]({
+ fromSequenceExclusive: 0,
+ }),
+ ),
+ );
+ assert.deepEqual(replayResult, []);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect(
+ "routes websocket rpc subscribeOrchestrationDomainEvents with replay/live overlap resilience",
+ () =>
+ Effect.gen(function* () {
+ const now = new Date().toISOString();
+ const threadId = ThreadId.makeUnsafe("thread-1");
+ let replayCursor: number | null = null;
+ const makeEvent = (sequence: number): OrchestrationEvent =>
+ ({
+ sequence,
+ eventId: `event-${sequence}`,
+ aggregateKind: "thread",
+ aggregateId: threadId,
+ occurredAt: now,
+ commandId: null,
+ causationEventId: null,
+ correlationId: null,
+ metadata: {},
+ type: "thread.reverted",
+ payload: {
+ threadId,
+ turnCount: sequence,
+ },
+ }) as OrchestrationEvent;
+
+ yield* buildAppUnderTest({
+ layers: {
+ orchestrationEngine: {
+ getReadModel: () =>
+ Effect.succeed({
+ ...makeDefaultOrchestrationReadModel(),
+ snapshotSequence: 1,
+ }),
+ readEvents: (fromSequenceExclusive) => {
+ replayCursor = fromSequenceExclusive;
+ return Stream.make(makeEvent(2), makeEvent(3));
+ },
+ streamDomainEvents: Stream.make(makeEvent(3), makeEvent(4)),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const events = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.subscribeOrchestrationDomainEvents]({}).pipe(
+ Stream.take(3),
+ Stream.runCollect,
+ ),
+ ),
+ );
+
+ assert.equal(replayCursor, 1);
+ assert.deepEqual(
+ Array.from(events).map((event) => event.sequence),
+ [2, 3, 4],
+ );
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc orchestration.getSnapshot errors", () =>
+ Effect.gen(function* () {
+ yield* buildAppUnderTest({
+ layers: {
+ projectionSnapshotQuery: {
+ getSnapshot: () =>
+ Effect.fail(
+ new PersistenceSqlError({
+ operation: "ProjectionSnapshotQuery.getSnapshot",
+ detail: "projection unavailable",
+ }),
+ ),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const result = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) => client[ORCHESTRATION_WS_METHODS.getSnapshot]({})).pipe(
+ Effect.result,
+ ),
+ );
+
+ assertTrue(result._tag === "Failure");
+ assertTrue(result.failure._tag === "OrchestrationGetSnapshotError");
+ assertInclude(result.failure.message, "Failed to load orchestration snapshot");
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc terminal methods", () =>
+ Effect.gen(function* () {
+ const snapshot = {
+ threadId: "thread-1",
+ terminalId: "default",
+ cwd: "/tmp/project",
+ status: "running" as const,
+ pid: 1234,
+ history: "",
+ exitCode: null,
+ exitSignal: null,
+ updatedAt: new Date().toISOString(),
+ };
+
+ yield* buildAppUnderTest({
+ layers: {
+ terminalManager: {
+ open: () => Effect.succeed(snapshot),
+ write: () => Effect.void,
+ resize: () => Effect.void,
+ clear: () => Effect.void,
+ restart: () => Effect.succeed(snapshot),
+ close: () => Effect.void,
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+
+ const opened = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.terminalOpen]({
+ threadId: "thread-1",
+ terminalId: "default",
+ cwd: "/tmp/project",
+ }),
+ ),
+ );
+ assert.equal(opened.terminalId, "default");
+
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.terminalWrite]({
+ threadId: "thread-1",
+ terminalId: "default",
+ data: "echo hi\n",
+ }),
+ ),
+ );
+
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.terminalResize]({
+ threadId: "thread-1",
+ terminalId: "default",
+ cols: 120,
+ rows: 40,
+ }),
+ ),
+ );
+
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.terminalClear]({
+ threadId: "thread-1",
+ terminalId: "default",
+ }),
+ ),
+ );
+
+ const restarted = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.terminalRestart]({
+ threadId: "thread-1",
+ terminalId: "default",
+ cwd: "/tmp/project",
+ cols: 120,
+ rows: 40,
+ }),
+ ),
+ );
+ assert.equal(restarted.terminalId, "default");
+
+ yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.terminalClose]({
+ threadId: "thread-1",
+ terminalId: "default",
+ }),
+ ),
+ );
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+
+ it.effect("routes websocket rpc terminal.write errors", () =>
+ Effect.gen(function* () {
+ const terminalError = new TerminalNotRunningError({
+ threadId: "thread-1",
+ terminalId: "default",
+ });
+ yield* buildAppUnderTest({
+ layers: {
+ terminalManager: {
+ write: () => Effect.fail(terminalError),
+ },
+ },
+ });
+
+ const wsUrl = yield* getWsServerUrl("/ws");
+ const result = yield* Effect.scoped(
+ withWsRpcClient(wsUrl, (client) =>
+ client[WS_METHODS.terminalWrite]({
+ threadId: "thread-1",
+ terminalId: "default",
+ data: "echo fail\n",
+ }),
+ ).pipe(Effect.result),
+ );
+
+ assertFailure(result, terminalError);
+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+ );
+});
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
new file mode 100644
index 000000000..40a8eb09b
--- /dev/null
+++ b/apps/server/src/server.ts
@@ -0,0 +1,234 @@
+import { Effect, Layer } from "effect";
+import { FetchHttpClient, HttpRouter, HttpServer } from "effect/unstable/http";
+
+import { ServerConfig } from "./config";
+import { attachmentsRouteLayer, projectFaviconRouteLayer, staticAndDevRouteLayer } from "./http";
+import { fixPath } from "./os-jank";
+import { websocketRpcRouteLayer } from "./ws";
+import { OpenLive } from "./open";
+import { layerConfig as SqlitePersistenceLayerLive } from "./persistence/Layers/Sqlite";
+import { ServerLifecycleEventsLive } from "./serverLifecycleEvents";
+import { AnalyticsServiceLayerLive } from "./telemetry/Layers/AnalyticsService";
+import { makeEventNdjsonLogger } from "./provider/Layers/EventNdjsonLogger";
+import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionDirectory";
+import { ProviderSessionRuntimeRepositoryLive } from "./persistence/Layers/ProviderSessionRuntime";
+import { makeCodexAdapterLive } from "./provider/Layers/CodexAdapter";
+import { makeClaudeAdapterLive } from "./provider/Layers/ClaudeAdapter";
+import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry";
+import { makeProviderServiceLive } from "./provider/Layers/ProviderService";
+import { OrchestrationEngineLive } from "./orchestration/Layers/OrchestrationEngine";
+import { OrchestrationProjectionPipelineLive } from "./orchestration/Layers/ProjectionPipeline";
+import { OrchestrationEventStoreLive } from "./persistence/Layers/OrchestrationEventStore";
+import { OrchestrationCommandReceiptRepositoryLive } from "./persistence/Layers/OrchestrationCommandReceipts";
+import { CheckpointDiffQueryLive } from "./checkpointing/Layers/CheckpointDiffQuery";
+import { OrchestrationProjectionSnapshotQueryLive } from "./orchestration/Layers/ProjectionSnapshotQuery";
+import { CheckpointStoreLive } from "./checkpointing/Layers/CheckpointStore";
+import { GitCoreLive } from "./git/Layers/GitCore";
+import { GitHubCliLive } from "./git/Layers/GitHubCli";
+import { RoutingTextGenerationLive } from "./git/Layers/RoutingTextGeneration";
+import { TerminalManagerLive } from "./terminal/Layers/Manager";
+import { GitManagerLive } from "./git/Layers/GitManager";
+import { KeybindingsLive } from "./keybindings";
+import { ServerLoggerLive } from "./serverLogger";
+import { ServerRuntimeStartup, ServerRuntimeStartupLive } from "./serverRuntimeStartup";
+import { OrchestrationReactorLive } from "./orchestration/Layers/OrchestrationReactor";
+import { RuntimeReceiptBusLive } from "./orchestration/Layers/RuntimeReceiptBus";
+import { ProviderRuntimeIngestionLive } from "./orchestration/Layers/ProviderRuntimeIngestion";
+import { ProviderCommandReactorLive } from "./orchestration/Layers/ProviderCommandReactor";
+import { CheckpointReactorLive } from "./orchestration/Layers/CheckpointReactor";
+import { ProviderRegistryLive } from "./provider/Layers/ProviderRegistry";
+import { ServerSettingsLive } from "./serverSettings";
+import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver";
+import { WorkspaceEntriesLive } from "./workspace/Layers/WorkspaceEntries";
+import { WorkspaceFileSystemLive } from "./workspace/Layers/WorkspaceFileSystem";
+import { WorkspacePathsLive } from "./workspace/Layers/WorkspacePaths";
+
+const PtyAdapterLive = Layer.unwrap(
+ Effect.gen(function* () {
+ if (typeof Bun !== "undefined") {
+ const BunPTY = yield* Effect.promise(() => import("./terminal/Layers/BunPTY"));
+ return BunPTY.layer;
+ } else {
+ const NodePTY = yield* Effect.promise(() => import("./terminal/Layers/NodePTY"));
+ return NodePTY.layer;
+ }
+ }),
+);
+
+const HttpServerLive = Layer.unwrap(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ if (typeof Bun !== "undefined") {
+ const BunHttpServer = yield* Effect.promise(
+ () => import("@effect/platform-bun/BunHttpServer"),
+ );
+ return BunHttpServer.layer({
+ port: config.port,
+ ...(config.host ? { hostname: config.host } : {}),
+ });
+ } else {
+ const [NodeHttpServer, NodeHttp] = yield* Effect.all([
+ Effect.promise(() => import("@effect/platform-node/NodeHttpServer")),
+ Effect.promise(() => import("node:http")),
+ ]);
+ return NodeHttpServer.layer(NodeHttp.createServer, {
+ host: config.host,
+ port: config.port,
+ });
+ }
+ }),
+);
+
+const PlatformServicesLive = Layer.unwrap(
+ Effect.gen(function* () {
+ if (typeof Bun !== "undefined") {
+ const { layer } = yield* Effect.promise(() => import("@effect/platform-bun/BunServices"));
+ return layer;
+ } else {
+ const { layer } = yield* Effect.promise(() => import("@effect/platform-node/NodeServices"));
+ return layer;
+ }
+ }),
+);
+
+const ReactorLayerLive = Layer.empty.pipe(
+ Layer.provideMerge(OrchestrationReactorLive),
+ Layer.provideMerge(ProviderRuntimeIngestionLive),
+ Layer.provideMerge(ProviderCommandReactorLive),
+ Layer.provideMerge(CheckpointReactorLive),
+ Layer.provideMerge(RuntimeReceiptBusLive),
+);
+
+const OrchestrationLayerLive = Layer.empty.pipe(
+ Layer.provideMerge(OrchestrationProjectionSnapshotQueryLive),
+ Layer.provideMerge(OrchestrationEngineLive),
+ Layer.provideMerge(OrchestrationProjectionPipelineLive),
+ Layer.provideMerge(OrchestrationEventStoreLive),
+ Layer.provideMerge(OrchestrationCommandReceiptRepositoryLive),
+);
+
+const CheckpointingLayerLive = Layer.empty.pipe(
+ Layer.provideMerge(CheckpointDiffQueryLive),
+ Layer.provideMerge(CheckpointStoreLive),
+);
+
+const ProviderLayerLive = Layer.unwrap(
+ Effect.gen(function* () {
+ const { providerEventLogPath } = yield* ServerConfig;
+ const nativeEventLogger = yield* makeEventNdjsonLogger(providerEventLogPath, {
+ stream: "native",
+ });
+ const canonicalEventLogger = yield* makeEventNdjsonLogger(providerEventLogPath, {
+ stream: "canonical",
+ });
+ const providerSessionDirectoryLayer = ProviderSessionDirectoryLive.pipe(
+ Layer.provide(ProviderSessionRuntimeRepositoryLive),
+ );
+ const codexAdapterLayer = makeCodexAdapterLive(
+ nativeEventLogger ? { nativeEventLogger } : undefined,
+ );
+ const claudeAdapterLayer = makeClaudeAdapterLive(
+ nativeEventLogger ? { nativeEventLogger } : undefined,
+ );
+ const adapterRegistryLayer = ProviderAdapterRegistryLive.pipe(
+ Layer.provide(codexAdapterLayer),
+ Layer.provide(claudeAdapterLayer),
+ Layer.provideMerge(providerSessionDirectoryLayer),
+ );
+ return makeProviderServiceLive(
+ canonicalEventLogger ? { canonicalEventLogger } : undefined,
+ ).pipe(Layer.provide(adapterRegistryLayer), Layer.provide(providerSessionDirectoryLayer));
+ }),
+);
+
+const PersistenceLayerLive = Layer.empty.pipe(Layer.provideMerge(SqlitePersistenceLayerLive));
+
+const GitLayerLive = Layer.empty.pipe(
+ Layer.provideMerge(
+ GitManagerLive.pipe(
+ Layer.provideMerge(GitCoreLive),
+ Layer.provideMerge(GitHubCliLive),
+ Layer.provideMerge(RoutingTextGenerationLive),
+ ),
+ ),
+ Layer.provideMerge(GitCoreLive),
+);
+
+const TerminalLayerLive = TerminalManagerLive.pipe(Layer.provide(PtyAdapterLive));
+
+const WorkspaceLayerLive = Layer.mergeAll(
+ WorkspacePathsLive,
+ WorkspaceEntriesLive.pipe(Layer.provide(WorkspacePathsLive)),
+ WorkspaceFileSystemLive.pipe(
+ Layer.provide(WorkspacePathsLive),
+ Layer.provide(WorkspaceEntriesLive.pipe(Layer.provide(WorkspacePathsLive))),
+ ),
+);
+
+const RuntimeServicesLive = Layer.empty.pipe(
+ Layer.provideMerge(ServerRuntimeStartupLive),
+ Layer.provideMerge(ReactorLayerLive),
+
+ // Core Services
+ Layer.provideMerge(CheckpointingLayerLive),
+ Layer.provideMerge(OrchestrationLayerLive),
+ Layer.provideMerge(ProviderLayerLive),
+ Layer.provideMerge(GitLayerLive),
+ Layer.provideMerge(TerminalLayerLive),
+ Layer.provideMerge(PersistenceLayerLive),
+ Layer.provideMerge(KeybindingsLive),
+ Layer.provideMerge(ProviderRegistryLive),
+ Layer.provideMerge(ServerSettingsLive),
+ Layer.provideMerge(WorkspaceLayerLive),
+ Layer.provideMerge(ProjectFaviconResolverLive),
+
+ // Misc.
+ Layer.provideMerge(AnalyticsServiceLayerLive),
+ Layer.provideMerge(OpenLive),
+ Layer.provideMerge(ServerLifecycleEventsLive),
+);
+
+export const makeRoutesLayer = Layer.mergeAll(
+ attachmentsRouteLayer,
+ projectFaviconRouteLayer,
+ staticAndDevRouteLayer,
+ websocketRpcRouteLayer,
+);
+
+export const makeServerLayer = Layer.unwrap(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+
+ fixPath();
+
+ const httpListeningLayer = Layer.effectDiscard(
+ Effect.gen(function* () {
+ yield* HttpServer.HttpServer;
+ const startup = yield* ServerRuntimeStartup;
+ yield* startup.markHttpListening;
+ }),
+ );
+
+ const serverApplicationLayer = Layer.mergeAll(
+ HttpRouter.serve(makeRoutesLayer, {
+ disableLogger: !config.logWebSocketEvents,
+ }),
+ httpListeningLayer,
+ );
+
+ return serverApplicationLayer.pipe(
+ Layer.provideMerge(RuntimeServicesLive),
+ Layer.provideMerge(HttpServerLive),
+ Layer.provide(ServerLoggerLive),
+ Layer.provideMerge(FetchHttpClient.layer),
+ Layer.provideMerge(PlatformServicesLive),
+ );
+ }),
+);
+
+// Important: Only `ServerConfig` should be provided by the CLI layer!!! Don't let other requirements leak into the launch layer.
+export const runServer = Layer.launch(makeServerLayer) satisfies Effect.Effect<
+ never,
+ any,
+ ServerConfig
+>;
diff --git a/apps/server/src/serverLayers.ts b/apps/server/src/serverLayers.ts
deleted file mode 100644
index f745d553a..000000000
--- a/apps/server/src/serverLayers.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-import * as NodeServices from "@effect/platform-node/NodeServices";
-import { Effect, FileSystem, Layer, Path } from "effect";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
-
-import { CheckpointDiffQueryLive } from "./checkpointing/Layers/CheckpointDiffQuery";
-import { CheckpointStoreLive } from "./checkpointing/Layers/CheckpointStore";
-import { ServerConfig } from "./config";
-import { OrchestrationCommandReceiptRepositoryLive } from "./persistence/Layers/OrchestrationCommandReceipts";
-import { OrchestrationEventStoreLive } from "./persistence/Layers/OrchestrationEventStore";
-import { ProviderSessionRuntimeRepositoryLive } from "./persistence/Layers/ProviderSessionRuntime";
-import { OrchestrationEngineLive } from "./orchestration/Layers/OrchestrationEngine";
-import { CheckpointReactorLive } from "./orchestration/Layers/CheckpointReactor";
-import { OrchestrationReactorLive } from "./orchestration/Layers/OrchestrationReactor";
-import { ProviderCommandReactorLive } from "./orchestration/Layers/ProviderCommandReactor";
-import { OrchestrationProjectionPipelineLive } from "./orchestration/Layers/ProjectionPipeline";
-import { OrchestrationProjectionSnapshotQueryLive } from "./orchestration/Layers/ProjectionSnapshotQuery";
-import { ProviderRuntimeIngestionLive } from "./orchestration/Layers/ProviderRuntimeIngestion";
-import { RuntimeReceiptBusLive } from "./orchestration/Layers/RuntimeReceiptBus";
-import { ProviderUnsupportedError } from "./provider/Errors";
-import { makeClaudeAdapterLive } from "./provider/Layers/ClaudeAdapter";
-import { makeCodexAdapterLive } from "./provider/Layers/CodexAdapter";
-import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry";
-import { makeProviderServiceLive } from "./provider/Layers/ProviderService";
-import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionDirectory";
-import { ProviderService } from "./provider/Services/ProviderService";
-import { makeEventNdjsonLogger } from "./provider/Layers/EventNdjsonLogger";
-import { ServerSettingsService } from "./serverSettings";
-
-import { TerminalManagerLive } from "./terminal/Layers/Manager";
-import { KeybindingsLive } from "./keybindings";
-import { GitManagerLive } from "./git/Layers/GitManager";
-import { GitCoreLive } from "./git/Layers/GitCore";
-import { GitHubCliLive } from "./git/Layers/GitHubCli";
-import { RoutingTextGenerationLive } from "./git/Layers/RoutingTextGeneration";
-import { PtyAdapter } from "./terminal/Services/PTY";
-import { AnalyticsService } from "./telemetry/Services/AnalyticsService";
-import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver.ts";
-import { WorkspaceEntriesLive } from "./workspace/Layers/WorkspaceEntries.ts";
-import { WorkspaceFileSystemLive } from "./workspace/Layers/WorkspaceFileSystem.ts";
-import { WorkspacePathsLive } from "./workspace/Layers/WorkspacePaths.ts";
-
-type RuntimePtyAdapterLoader = {
- layer: Layer.Layer<PtyAdapter, never, FileSystem.FileSystem | Path.Path>;
-};
-
-const runtimePtyAdapterLoaders = {
- bun: () => import("./terminal/Layers/BunPTY"),
- node: () => import("./terminal/Layers/NodePTY"),
-} satisfies Record<string, () => Promise<RuntimePtyAdapterLoader>>;
-
-const makeRuntimePtyAdapterLayer = () =>
- Effect.gen(function* () {
- const runtime = process.versions.bun !== undefined ? "bun" : "node";
- const loader = runtimePtyAdapterLoaders[runtime];
- const ptyAdapterModule = yield* Effect.promise<RuntimePtyAdapterLoader>(loader);
- return ptyAdapterModule.layer;
- }).pipe(Layer.unwrap);
-
-export function makeServerProviderLayer(): Layer.Layer<
- ProviderService,
- ProviderUnsupportedError,
- | SqlClient.SqlClient
- | ServerConfig
- | ServerSettingsService
- | FileSystem.FileSystem
- | AnalyticsService
-> {
- return Effect.gen(function* () {
- const { providerEventLogPath } = yield* ServerConfig;
- const nativeEventLogger = yield* makeEventNdjsonLogger(providerEventLogPath, {
- stream: "native",
- });
- const canonicalEventLogger = yield* makeEventNdjsonLogger(providerEventLogPath, {
- stream: "canonical",
- });
- const providerSessionDirectoryLayer = ProviderSessionDirectoryLive.pipe(
- Layer.provide(ProviderSessionRuntimeRepositoryLive),
- );
- const codexAdapterLayer = makeCodexAdapterLive(
- nativeEventLogger ? { nativeEventLogger } : undefined,
- );
- const claudeAdapterLayer = makeClaudeAdapterLive(
- nativeEventLogger ? { nativeEventLogger } : undefined,
- );
- const adapterRegistryLayer = ProviderAdapterRegistryLive.pipe(
- Layer.provide(codexAdapterLayer),
- Layer.provide(claudeAdapterLayer),
- Layer.provideMerge(providerSessionDirectoryLayer),
- );
- return makeProviderServiceLive(
- canonicalEventLogger ? { canonicalEventLogger } : undefined,
- ).pipe(Layer.provide(adapterRegistryLayer), Layer.provide(providerSessionDirectoryLayer));
- }).pipe(Layer.unwrap);
-}
-
-export function makeServerRuntimeServicesLayer() {
- const textGenerationLayer = RoutingTextGenerationLive;
- const gitCoreLayer = GitCoreLive;
- const checkpointStoreLayer = CheckpointStoreLive;
-
- const orchestrationLayer = OrchestrationEngineLive.pipe(
- Layer.provide(OrchestrationProjectionPipelineLive),
- Layer.provide(OrchestrationEventStoreLive),
- Layer.provide(OrchestrationCommandReceiptRepositoryLive),
- );
-
- const checkpointDiffQueryLayer = CheckpointDiffQueryLive.pipe(
- Layer.provideMerge(OrchestrationProjectionSnapshotQueryLive),
- Layer.provideMerge(checkpointStoreLayer),
- );
-
- const runtimeServicesLayer = Layer.mergeAll(
- orchestrationLayer,
- OrchestrationProjectionSnapshotQueryLive,
- checkpointStoreLayer,
- checkpointDiffQueryLayer,
- RuntimeReceiptBusLive,
- );
- const runtimeIngestionLayer = ProviderRuntimeIngestionLive.pipe(
- Layer.provideMerge(runtimeServicesLayer),
- );
- const providerCommandReactorLayer = ProviderCommandReactorLive.pipe(
- Layer.provideMerge(runtimeServicesLayer),
- Layer.provideMerge(textGenerationLayer),
- );
- const checkpointReactorLayer = CheckpointReactorLive.pipe(
- Layer.provideMerge(runtimeServicesLayer),
- Layer.provideMerge(WorkspaceEntriesLive),
- );
- const orchestrationReactorLayer = OrchestrationReactorLive.pipe(
- Layer.provideMerge(runtimeIngestionLayer),
- Layer.provideMerge(providerCommandReactorLayer),
- Layer.provideMerge(checkpointReactorLayer),
- );
-
- const terminalLayer = TerminalManagerLive.pipe(Layer.provide(makeRuntimePtyAdapterLayer()));
-
- const gitManagerLayer = GitManagerLive.pipe(
- Layer.provideMerge(GitHubCliLive),
- Layer.provideMerge(textGenerationLayer),
- );
-
- const workspacePathsLayer = WorkspacePathsLive;
- const workspaceEntriesLayer = WorkspaceEntriesLive;
- const workspaceFileSystemLayer = WorkspaceFileSystemLive.pipe(
- Layer.provide(workspacePathsLayer),
- Layer.provide(workspaceEntriesLayer),
- );
- const projectFaviconResolverLayer = ProjectFaviconResolverLive;
-
- return Layer.mergeAll(
- orchestrationReactorLayer,
- workspacePathsLayer,
- workspaceEntriesLayer,
- workspaceFileSystemLayer,
- projectFaviconResolverLayer,
- gitManagerLayer,
- terminalLayer,
- KeybindingsLive,
- ).pipe(Layer.provideMerge(gitCoreLayer), Layer.provideMerge(NodeServices.layer));
-}
diff --git a/apps/server/src/serverLifecycleEvents.test.ts b/apps/server/src/serverLifecycleEvents.test.ts
new file mode 100644
index 000000000..1cd8c25c0
--- /dev/null
+++ b/apps/server/src/serverLifecycleEvents.test.ts
@@ -0,0 +1,42 @@
+import { assert, it } from "@effect/vitest";
+import { assertTrue } from "@effect/vitest/utils";
+import { Effect, Option } from "effect";
+
+import { ServerLifecycleEvents, ServerLifecycleEventsLive } from "./serverLifecycleEvents.ts";
+
+it.effect(
+ "publishes lifecycle events without subscribers and snapshots the latest welcome/ready",
+ () =>
+ Effect.gen(function* () {
+ const lifecycleEvents = yield* ServerLifecycleEvents;
+
+ const welcome = yield* lifecycleEvents
+ .publish({
+ version: 1,
+ type: "welcome",
+ payload: {
+ cwd: "/tmp/project",
+ projectName: "project",
+ },
+ })
+ .pipe(Effect.timeoutOption("50 millis"));
+ assertTrue(Option.isSome(welcome));
+ assert.equal(welcome.value.sequence, 1);
+
+ const ready = yield* lifecycleEvents
+ .publish({
+ version: 1,
+ type: "ready",
+ payload: {
+ at: new Date().toISOString(),
+ },
+ })
+ .pipe(Effect.timeoutOption("50 millis"));
+ assertTrue(Option.isSome(ready));
+ assert.equal(ready.value.sequence, 2);
+
+ const snapshot = yield* lifecycleEvents.snapshot;
+ assert.equal(snapshot.sequence, 2);
+ assert.deepEqual(snapshot.events.map((event) => event.type).toSorted(), ["ready", "welcome"]);
+ }).pipe(Effect.provide(ServerLifecycleEventsLive)),
+);
diff --git a/apps/server/src/serverLifecycleEvents.ts b/apps/server/src/serverLifecycleEvents.ts
new file mode 100644
index 000000000..4808a19d7
--- /dev/null
+++ b/apps/server/src/serverLifecycleEvents.ts
@@ -0,0 +1,53 @@
+import type { ServerLifecycleStreamEvent } from "@t3tools/contracts";
+import { Effect, Layer, PubSub, Ref, ServiceMap, Stream } from "effect";
+
+type LifecycleEventInput =
+ | Omit<Extract<ServerLifecycleStreamEvent, { type: "welcome" }>, "sequence">
+ | Omit<Extract<ServerLifecycleStreamEvent, { type: "ready" }>, "sequence">;
+
+interface SnapshotState {
+ readonly sequence: number;
+ readonly events: ReadonlyArray<ServerLifecycleStreamEvent>;
+}
+
+export interface ServerLifecycleEventsShape {
+ readonly publish: (event: LifecycleEventInput) => Effect.Effect<ServerLifecycleStreamEvent>;
+ readonly snapshot: Effect.Effect<SnapshotState>;
+ readonly stream: Stream.Stream<ServerLifecycleStreamEvent>;
+}
+
+export class ServerLifecycleEvents extends ServiceMap.Service<
+ ServerLifecycleEvents,
+ ServerLifecycleEventsShape
+>()("t3/serverLifecycleEvents") {}
+
+export const ServerLifecycleEventsLive = Layer.effect(
+ ServerLifecycleEvents,
+ Effect.gen(function* () {
+ const pubsub = yield* PubSub.unbounded<ServerLifecycleStreamEvent>();
+ const state = yield* Ref.make<SnapshotState>({
+ sequence: 0,
+ events: [],
+ });
+
+ return {
+ publish: (event) =>
+ Ref.modify(state, (current) => {
+ const nextSequence = current.sequence + 1;
+ const nextEvent = {
+ ...event,
+ sequence: nextSequence,
+ } satisfies ServerLifecycleStreamEvent;
+ const nextEvents =
+ nextEvent.type === "welcome"
+ ? [nextEvent, ...current.events.filter((entry) => entry.type !== "welcome")]
+ : [nextEvent, ...current.events.filter((entry) => entry.type !== "ready")];
+ return [nextEvent, { sequence: nextSequence, events: nextEvents }] as const;
+ }).pipe(Effect.tap((event) => PubSub.publish(pubsub, event))),
+ snapshot: Ref.get(state),
+ get stream() {
+ return Stream.fromPubSub(pubsub);
+ },
+ } satisfies ServerLifecycleEventsShape;
+ }),
+);
diff --git a/apps/server/src/serverLogger.ts b/apps/server/src/serverLogger.ts
index 1b90babaa..aea53aacf 100644
--- a/apps/server/src/serverLogger.ts
+++ b/apps/server/src/serverLogger.ts
@@ -1,20 +1,16 @@
-import fs from "node:fs";
-
-import { Effect, Logger } from "effect";
-import * as Layer from "effect/Layer";
+import { Effect, Logger, References, Layer } from "effect";
import { ServerConfig } from "./config";
export const ServerLoggerLive = Effect.gen(function* () {
- const { logsDir, serverLogPath } = yield* ServerConfig;
-
- yield* Effect.sync(() => {
- fs.mkdirSync(logsDir, { recursive: true });
- });
+ const config = yield* ServerConfig;
+ const { serverLogPath } = config;
const fileLogger = Logger.formatSimple.pipe(Logger.toFile(serverLogPath));
-
- return Logger.layer([Logger.defaultLogger, fileLogger], {
+ const minimumLogLevelLayer = Layer.succeed(References.MinimumLogLevel, config.logLevel);
+ const loggerLayer = Logger.layer([Logger.consolePretty(), fileLogger], {
mergeWithExisting: false,
});
+
+ return Layer.mergeAll(loggerLayer, minimumLogLevelLayer);
}).pipe(Layer.unwrap);
diff --git a/apps/server/src/serverRuntimeStartup.test.ts b/apps/server/src/serverRuntimeStartup.test.ts
new file mode 100644
index 000000000..55700e348
--- /dev/null
+++ b/apps/server/src/serverRuntimeStartup.test.ts
@@ -0,0 +1,49 @@
+import { assert, it } from "@effect/vitest";
+import { Deferred, Effect, Fiber, Ref } from "effect";
+import { TestClock } from "effect/testing";
+
+import { makeCommandGate, ServerRuntimeStartupError } from "./serverRuntimeStartup.ts";
+
+it.effect("enqueueCommand waits for readiness and then drains queued work", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const executionCount = yield* Ref.make(0);
+ const commandGate = yield* makeCommandGate;
+
+ const queuedCommandFiber = yield* commandGate
+ .enqueueCommand(Ref.updateAndGet(executionCount, (count) => count + 1))
+ .pipe(Effect.forkScoped);
+
+ yield* TestClock.adjust("50 millis");
+ assert.equal(yield* Ref.get(executionCount), 0);
+
+ yield* commandGate.signalCommandReady;
+
+ const result = yield* Fiber.join(queuedCommandFiber);
+ assert.equal(result, 1);
+ assert.equal(yield* Ref.get(executionCount), 1);
+ }),
+ ),
+);
+
+it.effect("enqueueCommand fails queued work when readiness fails", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const commandGate = yield* makeCommandGate;
+ const failure = yield* Deferred.make<void, never>();
+
+ const queuedCommandFiber = yield* commandGate
+ .enqueueCommand(Deferred.await(failure).pipe(Effect.as("should-not-run")))
+ .pipe(Effect.forkScoped);
+
+ yield* commandGate.failCommandReady(
+ new ServerRuntimeStartupError({
+ message: "startup failed",
+ }),
+ );
+
+ const error = yield* Effect.flip(Fiber.join(queuedCommandFiber));
+ assert.equal(error.message, "startup failed");
+ }),
+ ),
+);
diff --git a/apps/server/src/serverRuntimeStartup.ts b/apps/server/src/serverRuntimeStartup.ts
new file mode 100644
index 000000000..2457f6ffe
--- /dev/null
+++ b/apps/server/src/serverRuntimeStartup.ts
@@ -0,0 +1,334 @@
+import {
+ CommandId,
+ DEFAULT_PROVIDER_INTERACTION_MODE,
+ type ModelSelection,
+ ProjectId,
+ ThreadId,
+} from "@t3tools/contracts";
+import { Data, Deferred, Effect, Exit, Layer, Path, Queue, Ref, Scope, ServiceMap } from "effect";
+
+import { ServerConfig } from "./config";
+import { Keybindings } from "./keybindings";
+import { Open } from "./open";
+import { OrchestrationEngineService } from "./orchestration/Services/OrchestrationEngine";
+import { ProjectionSnapshotQuery } from "./orchestration/Services/ProjectionSnapshotQuery";
+import { OrchestrationReactor } from "./orchestration/Services/OrchestrationReactor";
+import { ServerLifecycleEvents } from "./serverLifecycleEvents";
+import { ServerSettingsService } from "./serverSettings";
+import { AnalyticsService } from "./telemetry/Services/AnalyticsService";
+
+const isWildcardHost = (host: string | undefined): boolean =>
+ host === "0.0.0.0" || host === "::" || host === "[::]";
+
+const formatHostForUrl = (host: string): string =>
+ host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+
+export class ServerRuntimeStartupError extends Data.TaggedError("ServerRuntimeStartupError")<{
+ readonly message: string;
+ readonly cause?: unknown;
+}> {}
+
+export interface ServerRuntimeStartupShape {
+ readonly awaitCommandReady: Effect.Effect<void, ServerRuntimeStartupError>;
+ readonly markHttpListening: Effect.Effect<void>;
+ readonly enqueueCommand: <A, E>(
+ effect: Effect.Effect<A, E>,
+ ) => Effect.Effect<A, E | ServerRuntimeStartupError>;
+}
+
+export class ServerRuntimeStartup extends ServiceMap.Service<
+ ServerRuntimeStartup,
+ ServerRuntimeStartupShape
+>()("t3/serverRuntimeStartup") {}
+
+interface QueuedCommand {
+ readonly run: Effect.Effect<void, never>;
+}
+
+type CommandReadinessState = "pending" | "ready" | ServerRuntimeStartupError;
+
+interface CommandGate {
+ readonly awaitCommandReady: Effect.Effect<void, ServerRuntimeStartupError>;
+ readonly signalCommandReady: Effect.Effect<void>;
+ readonly failCommandReady: (error: ServerRuntimeStartupError) => Effect.Effect<void>;
+ readonly enqueueCommand: <A, E>(
+ effect: Effect.Effect<A, E>,
+ ) => Effect.Effect<A, E | ServerRuntimeStartupError>;
+}
+
+const settleQueuedCommand = <A, E>(deferred: Deferred.Deferred<A, E>, exit: Exit.Exit<A, E>) =>
+ Exit.isSuccess(exit)
+ ? Deferred.succeed(deferred, exit.value)
+ : Deferred.failCause(deferred, exit.cause);
+
+export const makeCommandGate = Effect.gen(function* () {
+ const commandReady = yield* Deferred.make<void, ServerRuntimeStartupError>();
+ const commandQueue = yield* Queue.unbounded<QueuedCommand>();
+ const commandReadinessState = yield* Ref.make<CommandReadinessState>("pending");
+
+ const commandWorker = Effect.forever(
+ Queue.take(commandQueue).pipe(Effect.flatMap((command) => command.run)),
+ );
+ yield* Effect.forkScoped(commandWorker);
+
+ return {
+ awaitCommandReady: Deferred.await(commandReady),
+ signalCommandReady: Effect.gen(function* () {
+ yield* Ref.set(commandReadinessState, "ready");
+ yield* Deferred.succeed(commandReady, undefined).pipe(Effect.orDie);
+ }),
+ failCommandReady: (error) =>
+ Effect.gen(function* () {
+ yield* Ref.set(commandReadinessState, error);
+ yield* Deferred.fail(commandReady, error).pipe(Effect.orDie);
+ }),
+ enqueueCommand: <A, E>(effect: Effect.Effect<A, E>) =>
+ Effect.gen(function* () {
+ const readinessState = yield* Ref.get(commandReadinessState);
+ if (readinessState === "ready") {
+ return yield* effect;
+ }
+ if (readinessState !== "pending") {
+ return yield* readinessState;
+ }
+
+ const result = yield* Deferred.make<A, E | ServerRuntimeStartupError>();
+ yield* Queue.offer(commandQueue, {
+ run: Deferred.await(commandReady).pipe(
+ Effect.flatMap(() => effect),
+ Effect.exit,
+ Effect.flatMap((exit) => settleQueuedCommand(result, exit)),
+ ),
+ });
+ return yield* Deferred.await(result);
+ }),
+ } satisfies CommandGate;
+});
+
+const recordStartupHeartbeat = Effect.gen(function* () {
+ const analytics = yield* AnalyticsService;
+ const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
+
+ const { threadCount, projectCount } = yield* projectionSnapshotQuery.getSnapshot().pipe(
+ Effect.map((snapshot) => ({
+ threadCount: snapshot.threads.length,
+ projectCount: snapshot.projects.length,
+ })),
+ Effect.catch((cause) =>
+ Effect.logWarning("failed to gather startup snapshot for telemetry", { cause }).pipe(
+ Effect.as({
+ threadCount: 0,
+ projectCount: 0,
+ }),
+ ),
+ ),
+ );
+
+ yield* analytics.record("server.boot.heartbeat", {
+ threadCount,
+ projectCount,
+ });
+});
+
+const autoBootstrapWelcome = Effect.gen(function* () {
+ const serverConfig = yield* ServerConfig;
+ const projectionReadModelQuery = yield* ProjectionSnapshotQuery;
+ const orchestrationEngine = yield* OrchestrationEngineService;
+ const path = yield* Path.Path;
+
+ let bootstrapProjectId: ProjectId | undefined;
+ let bootstrapThreadId: ThreadId | undefined;
+
+ if (serverConfig.autoBootstrapProjectFromCwd) {
+ yield* Effect.gen(function* () {
+ const snapshot = yield* projectionReadModelQuery.getSnapshot();
+ const existingProject = snapshot.projects.find(
+ (project) => project.workspaceRoot === serverConfig.cwd && project.deletedAt === null,
+ );
+ let nextProjectId: ProjectId;
+ let nextProjectDefaultModelSelection: ModelSelection;
+
+ if (!existingProject) {
+ const createdAt = new Date().toISOString();
+ nextProjectId = ProjectId.makeUnsafe(crypto.randomUUID());
+ const bootstrapProjectTitle = path.basename(serverConfig.cwd) || "project";
+ nextProjectDefaultModelSelection = {
+ provider: "codex",
+ model: "gpt-5-codex",
+ };
+ yield* orchestrationEngine.dispatch({
+ type: "project.create",
+ commandId: CommandId.makeUnsafe(crypto.randomUUID()),
+ projectId: nextProjectId,
+ title: bootstrapProjectTitle,
+ workspaceRoot: serverConfig.cwd,
+ defaultModelSelection: nextProjectDefaultModelSelection,
+ createdAt,
+ });
+ } else {
+ nextProjectId = existingProject.id;
+ nextProjectDefaultModelSelection = existingProject.defaultModelSelection ?? {
+ provider: "codex",
+ model: "gpt-5-codex",
+ };
+ }
+
+ const existingThread = snapshot.threads.find(
+ (thread) => thread.projectId === nextProjectId && thread.deletedAt === null,
+ );
+ if (!existingThread) {
+ const createdAt = new Date().toISOString();
+ const createdThreadId = ThreadId.makeUnsafe(crypto.randomUUID());
+ yield* orchestrationEngine.dispatch({
+ type: "thread.create",
+ commandId: CommandId.makeUnsafe(crypto.randomUUID()),
+ threadId: createdThreadId,
+ projectId: nextProjectId,
+ title: "New thread",
+ modelSelection: nextProjectDefaultModelSelection,
+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+ runtimeMode: "full-access",
+ branch: null,
+ worktreePath: null,
+ createdAt,
+ });
+ bootstrapProjectId = nextProjectId;
+ bootstrapThreadId = createdThreadId;
+ } else {
+ bootstrapProjectId = nextProjectId;
+ bootstrapThreadId = existingThread.id;
+ }
+ });
+ }
+
+ 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;
+});
+
+const maybeOpenBrowser = Effect.gen(function* () {
+ const serverConfig = yield* ServerConfig;
+ if (serverConfig.noBrowser) {
+ return;
+ }
+ const { openBrowser } = yield* Open;
+ const localUrl = `http://localhost:${serverConfig.port}`;
+ const bindUrl =
+ serverConfig.host && !isWildcardHost(serverConfig.host)
+ ? `http://${formatHostForUrl(serverConfig.host)}:${serverConfig.port}`
+ : localUrl;
+ const target = serverConfig.devUrl?.toString() ?? bindUrl;
+
+ yield* openBrowser(target).pipe(
+ Effect.catch(() =>
+ Effect.logInfo("browser auto-open unavailable", {
+ hint: `Open ${target} in your browser.`,
+ }),
+ ),
+ );
+});
+
+const makeServerRuntimeStartup = Effect.gen(function* () {
+ const keybindings = yield* Keybindings;
+ const orchestrationReactor = yield* OrchestrationReactor;
+ const lifecycleEvents = yield* ServerLifecycleEvents;
+ const serverSettings = yield* ServerSettingsService;
+
+ const commandGate = yield* makeCommandGate;
+ const httpListening = yield* Deferred.make<void>();
+ const reactorScope = yield* Scope.make("sequential");
+
+ yield* Effect.addFinalizer(() => Scope.close(reactorScope, Exit.void));
+
+ const startup = Effect.gen(function* () {
+ yield* Effect.logDebug("startup phase: starting keybindings runtime");
+ yield* keybindings.start.pipe(
+ Effect.catch((error) =>
+ Effect.logWarning("failed to start keybindings runtime", {
+ path: error.configPath,
+ detail: error.detail,
+ cause: error.cause,
+ }),
+ ),
+ Effect.forkScoped,
+ );
+
+ yield* Effect.logDebug("startup phase: starting server settings runtime");
+ yield* serverSettings.start.pipe(
+ Effect.catch((error) =>
+ Effect.logWarning("failed to start server settings runtime", {
+ path: error.settingsPath,
+ detail: error.detail,
+ cause: error.cause,
+ }),
+ ),
+ Effect.forkScoped,
+ );
+
+ yield* Effect.logDebug("startup phase: starting orchestration reactors");
+ yield* orchestrationReactor.start().pipe(Scope.provide(reactorScope));
+
+ yield* Effect.logDebug("startup phase: preparing welcome payload");
+ const welcome = yield* autoBootstrapWelcome;
+ yield* Effect.logDebug("startup phase: publishing welcome event", {
+ cwd: welcome.cwd,
+ projectName: welcome.projectName,
+ bootstrapProjectId: welcome.bootstrapProjectId,
+ bootstrapThreadId: welcome.bootstrapThreadId,
+ });
+ yield* lifecycleEvents.publish({
+ version: 1,
+ type: "welcome",
+ payload: welcome,
+ });
+ });
+
+ yield* Effect.forkScoped(
+ Effect.gen(function* () {
+ const startupExit = yield* Effect.exit(startup);
+ if (Exit.isFailure(startupExit)) {
+ const error = new ServerRuntimeStartupError({
+ message: "Server runtime startup failed before command readiness.",
+ cause: startupExit.cause,
+ });
+ yield* Effect.logError("server runtime startup failed", { cause: startupExit.cause });
+ yield* commandGate.failCommandReady(error);
+ return;
+ }
+
+ yield* Effect.logDebug("Accepting commands");
+ yield* commandGate.signalCommandReady;
+ yield* Effect.logDebug("startup phase: waiting for http listener");
+ yield* Deferred.await(httpListening);
+ yield* Effect.logDebug("startup phase: publishing ready event");
+ yield* lifecycleEvents.publish({
+ version: 1,
+ type: "ready",
+ payload: { at: new Date().toISOString() },
+ });
+
+ yield* Effect.logDebug("startup phase: recording startup heartbeat");
+ yield* recordStartupHeartbeat;
+ yield* Effect.logDebug("startup phase: browser open check");
+ yield* maybeOpenBrowser;
+ yield* Effect.logDebug("startup phase: complete");
+ }),
+ );
+
+ return {
+ awaitCommandReady: commandGate.awaitCommandReady,
+ markHttpListening: Deferred.succeed(httpListening, undefined),
+ enqueueCommand: commandGate.enqueueCommand,
+ } satisfies ServerRuntimeStartupShape;
+});
+
+export const ServerRuntimeStartupLive = Layer.effect(
+ ServerRuntimeStartup,
+ makeServerRuntimeStartup,
+);
diff --git a/apps/server/src/serverSettings.ts b/apps/server/src/serverSettings.ts
index a5b4345d5..79fdc29a8 100644
--- a/apps/server/src/serverSettings.ts
+++ b/apps/server/src/serverSettings.ts
@@ -16,6 +16,7 @@ import {
type ModelSelection,
type ProviderKind,
ServerSettings,
+ ServerSettingsError,
type ServerSettingsPatch,
} from "@t3tools/contracts";
import {
@@ -35,25 +36,13 @@ import {
Scope,
ServiceMap,
Stream,
+ Cause,
} from "effect";
import * as Semaphore from "effect/Semaphore";
import { ServerConfig } from "./config";
import { type DeepPartial, deepMerge } from "@t3tools/shared/Struct";
import { fromLenientJson } from "@t3tools/shared/schemaJson";
-export class ServerSettingsError extends Schema.TaggedErrorClass<ServerSettingsError>()(
- "ServerSettingsError",
- {
- settingsPath: Schema.String,
- detail: Schema.String,
- cause: Schema.optional(Schema.Defect),
- },
-) {
- override get message(): string {
- return `Server settings error at ${this.settingsPath}: ${this.detail}`;
- }
-}
-
export interface ServerSettingsShape {
/** Start the settings runtime and attach file watching. */
readonly start: Effect.Effect<void, ServerSettingsError>;
@@ -215,6 +204,7 @@ const makeServerSettings = Effect.gen(function* () {
if (decoded._tag === "Failure") {
yield* Effect.logWarning("failed to parse settings.json, using defaults", {
path: settingsPath,
+ issues: Cause.pretty(decoded.cause),
});
return DEFAULT_SERVER_SETTINGS;
}
diff --git a/apps/server/src/terminal/Services/Manager.ts b/apps/server/src/terminal/Services/Manager.ts
index 067cd5543..bdfbc85cc 100644
--- a/apps/server/src/terminal/Services/Manager.ts
+++ b/apps/server/src/terminal/Services/Manager.ts
@@ -10,85 +10,59 @@ import {
TerminalClearInput,
TerminalCloseInput,
TerminalEvent,
+ TerminalCwdError,
+ TerminalError,
+ TerminalHistoryError,
+ TerminalNotRunningError,
TerminalOpenInput,
TerminalResizeInput,
TerminalRestartInput,
TerminalSessionSnapshot,
+ TerminalSessionLookupError,
+ TerminalSessionStatus,
TerminalWriteInput,
} from "@t3tools/contracts";
-import { Effect, Schema, ServiceMap } from "effect";
+import { PtyProcess } from "./PTY";
+import { Effect, ServiceMap } from "effect";
-export class TerminalCwdError extends Schema.TaggedErrorClass<TerminalCwdError>()(
- "TerminalCwdError",
- {
- cwd: Schema.String,
- reason: Schema.Literals(["notFound", "notDirectory", "statFailed"]),
- cause: Schema.optional(Schema.Defect),
- },
-) {
- override get message() {
- if (this.reason === "notDirectory") {
- return `Terminal cwd is not a directory: ${this.cwd}`;
- }
- if (this.reason === "notFound") {
- return `Terminal cwd does not exist: ${this.cwd}`;
- }
- const causeMessage =
- this.cause && typeof this.cause === "object" && "message" in this.cause
- ? this.cause.message
- : undefined;
- return causeMessage
- ? `Failed to access terminal cwd: ${this.cwd} (${causeMessage})`
- : `Failed to access terminal cwd: ${this.cwd}`;
- }
-}
+export {
+ TerminalCwdError,
+ TerminalError,
+ TerminalHistoryError,
+ TerminalNotRunningError,
+ TerminalSessionLookupError,
+};
-export class TerminalHistoryError extends Schema.TaggedErrorClass<TerminalHistoryError>()(
- "TerminalHistoryError",
- {
- operation: Schema.Literals(["read", "truncate", "migrate"]),
- threadId: Schema.String,
- terminalId: Schema.String,
- cause: Schema.optional(Schema.Defect),
- },
-) {
- override get message() {
- return `Failed to ${this.operation} terminal history for thread: ${this.threadId}, terminal: ${this.terminalId}`;
- }
+export interface TerminalSessionState {
+ threadId: string;
+ terminalId: string;
+ cwd: string;
+ status: TerminalSessionStatus;
+ pid: number | null;
+ history: string;
+ pendingHistoryControlSequence: string;
+ exitCode: number | null;
+ exitSignal: number | null;
+ updatedAt: string;
+ cols: number;
+ rows: number;
+ process: PtyProcess | null;
+ unsubscribeData: (() => void) | null;
+ unsubscribeExit: (() => void) | null;
+ hasRunningSubprocess: boolean;
+ runtimeEnv: Record<string, string> | null;
}
-export class TerminalSessionLookupError extends Schema.TaggedErrorClass<TerminalSessionLookupError>()(
- "TerminalSessionLookupError",
- {
- threadId: Schema.String,
- terminalId: Schema.String,
- },
-) {
- override get message() {
- return `Unknown terminal thread: ${this.threadId}, terminal: ${this.terminalId}`;
- }
+export interface ShellCandidate {
+ shell: string;
+ args?: string[];
}
-export class TerminalNotRunningError extends Schema.TaggedErrorClass<TerminalNotRunningError>()(
- "TerminalNotRunningError",
- {
- threadId: Schema.String,
- terminalId: Schema.String,
- },
-) {
- override get message() {
- return `Terminal is not running for thread: ${this.threadId}, terminal: ${this.terminalId}`;
- }
+export interface TerminalStartInput extends TerminalOpenInput {
+ cols: number;
+ rows: number;
}
-export const TerminalError = Schema.Union([
- TerminalCwdError,
- TerminalHistoryError,
- TerminalSessionLookupError,
- TerminalNotRunningError,
-]);
-export type TerminalError = typeof TerminalError.Type;
-
/**
* TerminalManagerShape - Service API for terminal session lifecycle operations.
*/
diff --git a/apps/server/src/workspace/Layers/WorkspaceEntries.test.ts b/apps/server/src/workspace/Layers/WorkspaceEntries.test.ts
index 1d1eb4f0e..960cb69bf 100644
--- a/apps/server/src/workspace/Layers/WorkspaceEntries.test.ts
+++ b/apps/server/src/workspace/Layers/WorkspaceEntries.test.ts
@@ -9,9 +9,11 @@ import { GitCoreLive } from "../../git/Layers/GitCore.ts";
import { GitCore } from "../../git/Services/GitCore.ts";
import { WorkspaceEntries } from "../Services/WorkspaceEntries.ts";
import { WorkspaceEntriesLive } from "./WorkspaceEntries.ts";
+import { WorkspacePathsLive } from "./WorkspacePaths.ts";
const TestLayer = Layer.empty.pipe(
- Layer.provideMerge(WorkspaceEntriesLive),
+ Layer.provideMerge(WorkspaceEntriesLive.pipe(Layer.provide(WorkspacePathsLive))),
+ Layer.provideMerge(WorkspacePathsLive),
Layer.provideMerge(GitCoreLive),
Layer.provide(
ServerConfig.layerTest(process.cwd(), {
diff --git a/apps/server/src/workspace/Layers/WorkspaceEntries.ts b/apps/server/src/workspace/Layers/WorkspaceEntries.ts
index c64960593..12af8601c 100644
--- a/apps/server/src/workspace/Layers/WorkspaceEntries.ts
+++ b/apps/server/src/workspace/Layers/WorkspaceEntries.ts
@@ -11,6 +11,7 @@ import {
WorkspaceEntriesError,
type WorkspaceEntriesShape,
} from "../Services/WorkspaceEntries.ts";
+import { WorkspacePaths } from "../Services/WorkspacePaths.ts";
const WORKSPACE_CACHE_TTL_MS = 15_000;
const WORKSPACE_CACHE_MAX_KEYS = 4;
@@ -219,6 +220,7 @@ const processErrorDetail = (cause: unknown): string =>
export const makeWorkspaceEntries = Effect.gen(function* () {
const path = yield* Path.Path;
const gitOption = yield* Effect.serviceOption(GitCore);
+ const workspacePaths = yield* WorkspacePaths;
const isInsideGitWorkTree = (cwd: string): Effect.Effect<boolean> =>
Option.match(gitOption, {
@@ -435,15 +437,38 @@ export const makeWorkspaceEntries = Effect.gen(function* () {
Exit.isSuccess(exit) ? Duration.millis(WORKSPACE_CACHE_TTL_MS) : Duration.zero,
});
+ const normalizeWorkspaceRoot = Effect.fn("WorkspaceEntries.normalizeWorkspaceRoot")(function* (
+ cwd: string,
+ ): Effect.fn.Return<string, WorkspaceEntriesError> {
+ return yield* workspacePaths.normalizeWorkspaceRoot(cwd).pipe(
+ Effect.mapError(
+ (cause) =>
+ new WorkspaceEntriesError({
+ cwd,
+ operation: "workspaceEntries.normalizeWorkspaceRoot",
+ detail: cause.message,
+ cause,
+ }),
+ ),
+ );
+ });
+
const invalidate: WorkspaceEntriesShape["invalidate"] = Effect.fn("WorkspaceEntries.invalidate")(
function* (cwd) {
- return yield* Cache.invalidate(workspaceIndexCache, cwd);
+ const normalizedCwd = yield* normalizeWorkspaceRoot(cwd).pipe(
+ Effect.catch(() => Effect.succeed(cwd)),
+ );
+ yield* Cache.invalidate(workspaceIndexCache, cwd);
+ if (normalizedCwd !== cwd) {
+ yield* Cache.invalidate(workspaceIndexCache, normalizedCwd);
+ }
},
);
const search: WorkspaceEntriesShape["search"] = Effect.fn("WorkspaceEntries.search")(
function* (input) {
- return yield* Cache.get(workspaceIndexCache, input.cwd).pipe(
+ const normalizedCwd = yield* normalizeWorkspaceRoot(input.cwd);
+ return yield* Cache.get(workspaceIndexCache, normalizedCwd).pipe(
Effect.map((index) => {
const normalizedQuery = normalizeQuery(input.query);
const limit = Math.max(0, Math.floor(input.limit));
diff --git a/apps/server/src/workspace/Layers/WorkspaceFileSystem.test.ts b/apps/server/src/workspace/Layers/WorkspaceFileSystem.test.ts
index 9ea8835ba..fcfd13c91 100644
--- a/apps/server/src/workspace/Layers/WorkspaceFileSystem.test.ts
+++ b/apps/server/src/workspace/Layers/WorkspaceFileSystem.test.ts
@@ -12,12 +12,13 @@ import { WorkspacePathsLive } from "./WorkspacePaths.ts";
const ProjectLayer = WorkspaceFileSystemLive.pipe(
Layer.provide(WorkspacePathsLive),
- Layer.provide(WorkspaceEntriesLive),
+ Layer.provide(WorkspaceEntriesLive.pipe(Layer.provide(WorkspacePathsLive))),
);
const TestLayer = Layer.empty.pipe(
Layer.provideMerge(ProjectLayer),
- Layer.provideMerge(WorkspaceEntriesLive),
+ Layer.provideMerge(WorkspaceEntriesLive.pipe(Layer.provide(WorkspacePathsLive))),
+ Layer.provideMerge(WorkspacePathsLive),
Layer.provideMerge(GitCoreLive),
Layer.provide(
ServerConfig.layerTest(process.cwd(), {
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
new file mode 100644
index 000000000..cff7e26ef
--- /dev/null
+++ b/apps/server/src/ws.ts
@@ -0,0 +1,343 @@
+import { Effect, Layer, Option, Queue, Ref, Schema, Stream } from "effect";
+import {
+ type GitActionProgressEvent,
+ type GitManagerServiceError,
+ OrchestrationDispatchCommandError,
+ type OrchestrationEvent,
+ OrchestrationGetFullThreadDiffError,
+ OrchestrationGetSnapshotError,
+ OrchestrationGetTurnDiffError,
+ ORCHESTRATION_WS_METHODS,
+ ProjectSearchEntriesError,
+ ProjectWriteFileError,
+ OrchestrationReplayEventsError,
+ type TerminalEvent,
+ WS_METHODS,
+ WsRpcGroup,
+} from "@t3tools/contracts";
+import { clamp } from "effect/Number";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+
+import { CheckpointDiffQuery } from "./checkpointing/Services/CheckpointDiffQuery";
+import { ServerConfig } from "./config";
+import { GitCore } from "./git/Services/GitCore";
+import { GitManager } from "./git/Services/GitManager";
+import { Keybindings } from "./keybindings";
+import { Open, resolveAvailableEditors } from "./open";
+import { normalizeDispatchCommand } from "./orchestration/Normalizer";
+import { OrchestrationEngineService } from "./orchestration/Services/OrchestrationEngine";
+import { ProjectionSnapshotQuery } from "./orchestration/Services/ProjectionSnapshotQuery";
+import { ProviderRegistry } from "./provider/Services/ProviderRegistry";
+import { ServerLifecycleEvents } from "./serverLifecycleEvents";
+import { ServerRuntimeStartup } from "./serverRuntimeStartup";
+import { ServerSettingsService } from "./serverSettings";
+import { TerminalManager } from "./terminal/Services/Manager";
+import { WorkspaceEntries } from "./workspace/Services/WorkspaceEntries";
+import { WorkspaceFileSystem } from "./workspace/Services/WorkspaceFileSystem";
+import { WorkspacePathOutsideRootError } from "./workspace/Services/WorkspacePaths";
+
+const WsRpcLayer = WsRpcGroup.toLayer(
+ Effect.gen(function* () {
+ const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
+ const orchestrationEngine = yield* OrchestrationEngineService;
+ const checkpointDiffQuery = yield* CheckpointDiffQuery;
+ const keybindings = yield* Keybindings;
+ const open = yield* Open;
+ const gitManager = yield* GitManager;
+ const git = yield* GitCore;
+ const terminalManager = yield* TerminalManager;
+ const providerRegistry = yield* ProviderRegistry;
+ const config = yield* ServerConfig;
+ const lifecycleEvents = yield* ServerLifecycleEvents;
+ const serverSettings = yield* ServerSettingsService;
+ const startup = yield* ServerRuntimeStartup;
+ const workspaceEntries = yield* WorkspaceEntries;
+ const workspaceFileSystem = yield* WorkspaceFileSystem;
+
+ const loadServerConfig = Effect.gen(function* () {
+ const keybindingsConfig = yield* keybindings.loadConfigState;
+ const providers = yield* providerRegistry.getProviders;
+ const settings = yield* serverSettings.getSettings;
+
+ return {
+ cwd: config.cwd,
+ keybindingsConfigPath: config.keybindingsConfigPath,
+ keybindings: keybindingsConfig.keybindings,
+ issues: keybindingsConfig.issues,
+ providers,
+ availableEditors: resolveAvailableEditors(),
+ settings,
+ };
+ });
+
+ return WsRpcGroup.of({
+ [ORCHESTRATION_WS_METHODS.getSnapshot]: (_input) =>
+ projectionSnapshotQuery.getSnapshot().pipe(
+ Effect.mapError(
+ (cause) =>
+ new OrchestrationGetSnapshotError({
+ message: "Failed to load orchestration snapshot",
+ cause,
+ }),
+ ),
+ ),
+ [ORCHESTRATION_WS_METHODS.dispatchCommand]: (command) =>
+ Effect.gen(function* () {
+ const normalizedCommand = yield* normalizeDispatchCommand(command);
+ return yield* startup.enqueueCommand(orchestrationEngine.dispatch(normalizedCommand));
+ }).pipe(
+ Effect.mapError((cause) =>
+ Schema.is(OrchestrationDispatchCommandError)(cause)
+ ? cause
+ : new OrchestrationDispatchCommandError({
+ message: "Failed to dispatch orchestration command",
+ cause,
+ }),
+ ),
+ ),
+ [ORCHESTRATION_WS_METHODS.getTurnDiff]: (input) =>
+ checkpointDiffQuery.getTurnDiff(input).pipe(
+ Effect.mapError(
+ (cause) =>
+ new OrchestrationGetTurnDiffError({
+ message: "Failed to load turn diff",
+ cause,
+ }),
+ ),
+ ),
+ [ORCHESTRATION_WS_METHODS.getFullThreadDiff]: (input) =>
+ checkpointDiffQuery.getFullThreadDiff(input).pipe(
+ Effect.mapError(
+ (cause) =>
+ new OrchestrationGetFullThreadDiffError({
+ message: "Failed to load full thread diff",
+ cause,
+ }),
+ ),
+ ),
+ [ORCHESTRATION_WS_METHODS.replayEvents]: (input) =>
+ Stream.runCollect(
+ orchestrationEngine.readEvents(
+ clamp(input.fromSequenceExclusive, { maximum: Number.MAX_SAFE_INTEGER, minimum: 0 }),
+ ),
+ ).pipe(
+ Effect.map((events) => Array.from(events)),
+ Effect.mapError(
+ (cause) =>
+ new OrchestrationReplayEventsError({
+ message: "Failed to replay orchestration events",
+ cause,
+ }),
+ ),
+ ),
+ [WS_METHODS.subscribeOrchestrationDomainEvents]: (_input) =>
+ Stream.unwrap(
+ Effect.gen(function* () {
+ const snapshot = yield* orchestrationEngine.getReadModel();
+ const fromSequenceExclusive = snapshot.snapshotSequence;
+ const replayEvents: Array<OrchestrationEvent> = yield* Stream.runCollect(
+ orchestrationEngine.readEvents(fromSequenceExclusive),
+ ).pipe(
+ Effect.map((events) => Array.from(events)),
+ Effect.catch(() => Effect.succeed([] as Array<OrchestrationEvent>)),
+ );
+ const replayStream = Stream.fromIterable(replayEvents);
+ const source = Stream.merge(replayStream, orchestrationEngine.streamDomainEvents);
+ type SequenceState = {
+ readonly nextSequence: number;
+ readonly pendingBySequence: Map<number, OrchestrationEvent>;
+ };
+ const state = yield* Ref.make<SequenceState>({
+ nextSequence: fromSequenceExclusive + 1,
+ pendingBySequence: new Map<number, OrchestrationEvent>(),
+ });
+
+ return source.pipe(
+ Stream.mapEffect((event) =>
+ Ref.modify(
+ state,
+ ({
+ nextSequence,
+ pendingBySequence,
+ }): [Array<OrchestrationEvent>, SequenceState] => {
+ if (event.sequence < nextSequence || pendingBySequence.has(event.sequence)) {
+ return [[], { nextSequence, pendingBySequence }];
+ }
+
+ const updatedPending = new Map(pendingBySequence);
+ updatedPending.set(event.sequence, event);
+
+ const emit: Array<OrchestrationEvent> = [];
+ let expected = nextSequence;
+ for (;;) {
+ const expectedEvent = updatedPending.get(expected);
+ if (!expectedEvent) {
+ break;
+ }
+ emit.push(expectedEvent);
+ updatedPending.delete(expected);
+ expected += 1;
+ }
+
+ return [emit, { nextSequence: expected, pendingBySequence: updatedPending }];
+ },
+ ),
+ ),
+ Stream.flatMap((events) => Stream.fromIterable(events)),
+ );
+ }),
+ ),
+ [WS_METHODS.serverGetConfig]: (_input) => loadServerConfig,
+ [WS_METHODS.serverRefreshProviders]: (_input) =>
+ providerRegistry.refresh().pipe(Effect.map((providers) => ({ providers }))),
+ [WS_METHODS.serverUpsertKeybinding]: (rule) =>
+ Effect.gen(function* () {
+ const keybindingsConfig = yield* keybindings.upsertKeybindingRule(rule);
+ return { keybindings: keybindingsConfig, issues: [] };
+ }),
+ [WS_METHODS.serverGetSettings]: (_input) => serverSettings.getSettings,
+ [WS_METHODS.serverUpdateSettings]: ({ patch }) => serverSettings.updateSettings(patch),
+ [WS_METHODS.projectsSearchEntries]: (input) =>
+ workspaceEntries.search(input).pipe(
+ Effect.mapError(
+ (cause) =>
+ new ProjectSearchEntriesError({
+ message: `Failed to search workspace entries: ${cause.detail}`,
+ cause,
+ }),
+ ),
+ ),
+ [WS_METHODS.projectsWriteFile]: (input) =>
+ workspaceFileSystem.writeFile(input).pipe(
+ Effect.mapError((cause) => {
+ const message = Schema.is(WorkspacePathOutsideRootError)(cause)
+ ? "Workspace file path must stay within the project root."
+ : "Failed to write workspace file";
+ return new ProjectWriteFileError({
+ message,
+ cause,
+ });
+ }),
+ ),
+ [WS_METHODS.shellOpenInEditor]: (input) => open.openInEditor(input),
+ [WS_METHODS.gitStatus]: (input) => gitManager.status(input),
+ [WS_METHODS.gitPull]: (input) => git.pullCurrentBranch(input.cwd),
+ [WS_METHODS.gitRunStackedAction]: (input) =>
+ Stream.callback<GitActionProgressEvent, GitManagerServiceError>((queue) =>
+ gitManager
+ .runStackedAction(input, {
+ actionId: input.actionId,
+ progressReporter: {
+ publish: (event) => Queue.offer(queue, event).pipe(Effect.asVoid),
+ },
+ })
+ .pipe(
+ Effect.matchCauseEffect({
+ onFailure: (cause) => Queue.failCause(queue, cause),
+ onSuccess: () => Queue.end(queue).pipe(Effect.asVoid),
+ }),
+ ),
+ ),
+ [WS_METHODS.gitResolvePullRequest]: (input) => gitManager.resolvePullRequest(input),
+ [WS_METHODS.gitPreparePullRequestThread]: (input) =>
+ gitManager.preparePullRequestThread(input),
+ [WS_METHODS.gitListBranches]: (input) => git.listBranches(input),
+ [WS_METHODS.gitCreateWorktree]: (input) => git.createWorktree(input),
+ [WS_METHODS.gitRemoveWorktree]: (input) => git.removeWorktree(input),
+ [WS_METHODS.gitCreateBranch]: (input) => git.createBranch(input),
+ [WS_METHODS.gitCheckout]: (input) => Effect.scoped(git.checkoutBranch(input)),
+ [WS_METHODS.gitInit]: (input) => git.initRepo(input),
+ [WS_METHODS.terminalOpen]: (input) => terminalManager.open(input),
+ [WS_METHODS.terminalWrite]: (input) => terminalManager.write(input),
+ [WS_METHODS.terminalResize]: (input) => terminalManager.resize(input),
+ [WS_METHODS.terminalClear]: (input) => terminalManager.clear(input),
+ [WS_METHODS.terminalRestart]: (input) => terminalManager.restart(input),
+ [WS_METHODS.terminalClose]: (input) => terminalManager.close(input),
+ [WS_METHODS.subscribeTerminalEvents]: (_input) =>
+ Stream.callback<TerminalEvent>((queue) =>
+ Effect.acquireRelease(
+ terminalManager.subscribe((event) => Queue.offer(queue, event)),
+ (unsubscribe) => Effect.sync(unsubscribe),
+ ),
+ ),
+ [WS_METHODS.subscribeServerConfig]: (_input) =>
+ Stream.unwrap(
+ Effect.gen(function* () {
+ const keybindingsUpdates = keybindings.streamChanges.pipe(
+ Stream.map((event) => ({
+ version: 1 as const,
+ type: "keybindingsUpdated" as const,
+ payload: {
+ issues: event.issues,
+ },
+ })),
+ );
+ const providerStatuses = providerRegistry.streamChanges.pipe(
+ Stream.map((providers) => ({
+ version: 1 as const,
+ type: "providerStatuses" as const,
+ payload: { providers },
+ })),
+ );
+ const settingsUpdates = serverSettings.streamChanges.pipe(
+ Stream.map((settings) => ({
+ version: 1 as const,
+ type: "settingsUpdated" as const,
+ payload: { settings },
+ })),
+ );
+
+ return Stream.concat(
+ Stream.make({
+ version: 1 as const,
+ type: "snapshot" as const,
+ config: yield* loadServerConfig,
+ }),
+ Stream.merge(keybindingsUpdates, Stream.merge(providerStatuses, settingsUpdates)),
+ );
+ }),
+ ),
+ [WS_METHODS.subscribeServerLifecycle]: (_input) =>
+ Stream.unwrap(
+ Effect.gen(function* () {
+ const snapshot = yield* lifecycleEvents.snapshot;
+ const snapshotEvents = Array.from(snapshot.events).toSorted(
+ (left, right) => left.sequence - right.sequence,
+ );
+ const liveEvents = lifecycleEvents.stream.pipe(
+ Stream.filter((event) => event.sequence > snapshot.sequence),
+ );
+ return Stream.concat(Stream.fromIterable(snapshotEvents), liveEvents);
+ }),
+ ),
+ });
+ }),
+);
+
+export const websocketRpcRouteLayer = Layer.unwrap(
+ Effect.gen(function* () {
+ const rpcWebSocketHttpEffect = yield* RpcServer.toHttpEffectWebsocket(WsRpcGroup).pipe(
+ Effect.provide(Layer.mergeAll(WsRpcLayer, RpcSerialization.layerJson)),
+ );
+ return HttpRouter.add(
+ "GET",
+ "/ws",
+ Effect.gen(function* () {
+ const request = yield* HttpServerRequest.HttpServerRequest;
+ const config = yield* ServerConfig;
+ if (config.authToken) {
+ const url = HttpServerRequest.toURL(request);
+ if (Option.isNone(url)) {
+ return HttpServerResponse.text("Invalid WebSocket URL", { status: 400 });
+ }
+ const token = url.value.searchParams.get("token");
+ if (token !== config.authToken) {
+ return HttpServerResponse.text("Unauthorized WebSocket connection", { status: 401 });
+ }
+ }
+ return yield* rpcWebSocketHttpEffect;
+ }),
+ );
+ }),
+);
diff --git a/apps/server/src/wsServer.test.ts b/apps/server/src/wsServer.test.ts
deleted file mode 100644
index 4fa281d29..000000000
--- a/apps/server/src/wsServer.test.ts
+++ /dev/null
@@ -1,2069 +0,0 @@
-import * as Http from "node:http";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import * as NodeServices from "@effect/platform-node/NodeServices";
-import {
- Effect,
- Exit,
- Fiber,
- Layer,
- ManagedRuntime,
- PlatformError,
- PubSub,
- Scope,
- Stream,
-} from "effect";
-import { describe, expect, it, afterEach, vi } from "vitest";
-import { createServer } from "./wsServer";
-import WebSocket from "ws";
-import { deriveServerPaths, ServerConfig, type ServerConfigShape } from "./config";
-import { makeServerProviderLayer, makeServerRuntimeServicesLayer } from "./serverLayers";
-
-import {
- DEFAULT_TERMINAL_ID,
- DEFAULT_SERVER_SETTINGS,
- EDITORS,
- EventId,
- ORCHESTRATION_WS_CHANNELS,
- ORCHESTRATION_WS_METHODS,
- ProviderItemId,
- type ServerSettings,
- ThreadId,
- TurnId,
- WS_CHANNELS,
- WS_METHODS,
- type WebSocketResponse,
- type ProviderRuntimeEvent,
- type ServerProvider,
- type KeybindingsConfig,
- type ResolvedKeybindingsConfig,
- type WsPushChannel,
- type WsPushMessage,
- type WsPush,
-} from "@t3tools/contracts";
-import { compileResolvedKeybindingRule, DEFAULT_KEYBINDINGS } from "./keybindings";
-import type {
- TerminalClearInput,
- TerminalCloseInput,
- TerminalEvent,
- TerminalOpenInput,
- TerminalResizeInput,
- TerminalSessionSnapshot,
- TerminalWriteInput,
-} from "@t3tools/contracts";
-import { TerminalManager, type TerminalManagerShape } from "./terminal/Services/Manager";
-import { makeSqlitePersistenceLive, SqlitePersistenceMemory } from "./persistence/Layers/Sqlite";
-import { SqlClient, SqlError } from "effect/unstable/sql";
-import { ProviderService, type ProviderServiceShape } from "./provider/Services/ProviderService";
-import { ProviderRegistry, type ProviderRegistryShape } from "./provider/Services/ProviderRegistry";
-import { Open, type OpenShape } from "./open";
-import { GitManager, type GitManagerShape } from "./git/Services/GitManager.ts";
-import type { GitCoreShape } from "./git/Services/GitCore.ts";
-import { GitCore } from "./git/Services/GitCore.ts";
-import { GitCommandError, GitManagerError } from "./git/Errors.ts";
-import { MigrationError } from "@effect/sql-sqlite-bun/SqliteMigrator";
-import { AnalyticsService } from "./telemetry/Services/AnalyticsService.ts";
-import { ServerSettingsService } from "./serverSettings.ts";
-
-const asEventId = (value: string): EventId => EventId.makeUnsafe(value);
-const asProviderItemId = (value: string): ProviderItemId => ProviderItemId.makeUnsafe(value);
-const asThreadId = (value: string): ThreadId => ThreadId.makeUnsafe(value);
-const asTurnId = (value: string): TurnId => TurnId.makeUnsafe(value);
-
-const defaultOpenService: OpenShape = {
- openBrowser: () => Effect.void,
- openInEditor: () => Effect.void,
-};
-
-const defaultProviderStatuses: ReadonlyArray<ServerProvider> = [
- {
- provider: "codex",
- enabled: true,
- installed: true,
- version: "0.116.0",
- status: "ready",
- auth: { status: "authenticated" },
- checkedAt: "2026-01-01T00:00:00.000Z",
- models: [],
- },
-];
-
-const defaultProviderRegistryService: ProviderRegistryShape = {
- getProviders: Effect.succeed(defaultProviderStatuses),
- refresh: () => Effect.succeed(defaultProviderStatuses),
- streamChanges: Stream.empty,
-};
-
-const defaultServerSettings = DEFAULT_SERVER_SETTINGS;
-
-class MockTerminalManager implements TerminalManagerShape {
- private readonly sessions = new Map<string, TerminalSessionSnapshot>();
- private readonly eventPubSub = Effect.runSync(PubSub.unbounded<TerminalEvent>());
- private activeSubscriptions = 0;
-
- private key(threadId: string, terminalId: string): string {
- return `${threadId}\u0000${terminalId}`;
- }
-
- emitEvent(event: TerminalEvent): void {
- Effect.runSync(PubSub.publish(this.eventPubSub, event));
- }
-
- subscriptionCount(): number {
- return this.activeSubscriptions;
- }
-
- readonly open: TerminalManagerShape["open"] = (input: TerminalOpenInput) =>
- Effect.sync(() => {
- const now = new Date().toISOString();
- const terminalId = input.terminalId ?? DEFAULT_TERMINAL_ID;
- const snapshot: TerminalSessionSnapshot = {
- threadId: input.threadId,
- terminalId,
- cwd: input.cwd,
- status: "running",
- pid: 4242,
- history: "",
- exitCode: null,
- exitSignal: null,
- updatedAt: now,
- };
- this.sessions.set(this.key(input.threadId, terminalId), snapshot);
- queueMicrotask(() => {
- this.emitEvent({
- type: "started",
- threadId: input.threadId,
- terminalId,
- createdAt: now,
- snapshot,
- });
- });
- return snapshot;
- });
-
- readonly write: TerminalManagerShape["write"] = (input: TerminalWriteInput) =>
- Effect.sync(() => {
- const terminalId = input.terminalId ?? DEFAULT_TERMINAL_ID;
- const existing = this.sessions.get(this.key(input.threadId, terminalId));
- if (!existing) {
- throw new Error(`Unknown terminal thread: ${input.threadId}`);
- }
- queueMicrotask(() => {
- this.emitEvent({
- type: "output",
- threadId: input.threadId,
- terminalId,
- createdAt: new Date().toISOString(),
- data: input.data,
- });
- });
- });
-
- readonly resize: TerminalManagerShape["resize"] = (_input: TerminalResizeInput) => Effect.void;
-
- readonly clear: TerminalManagerShape["clear"] = (input: TerminalClearInput) =>
- Effect.sync(() => {
- const terminalId = input.terminalId ?? DEFAULT_TERMINAL_ID;
- queueMicrotask(() => {
- this.emitEvent({
- type: "cleared",
- threadId: input.threadId,
- terminalId,
- createdAt: new Date().toISOString(),
- });
- });
- });
-
- readonly restart: TerminalManagerShape["restart"] = (input: TerminalOpenInput) =>
- Effect.sync(() => {
- const now = new Date().toISOString();
- const terminalId = input.terminalId ?? DEFAULT_TERMINAL_ID;
- const snapshot: TerminalSessionSnapshot = {
- threadId: input.threadId,
- terminalId,
- cwd: input.cwd,
- status: "running",
- pid: 5252,
- history: "",
- exitCode: null,
- exitSignal: null,
- updatedAt: now,
- };
- this.sessions.set(this.key(input.threadId, terminalId), snapshot);
- queueMicrotask(() => {
- this.emitEvent({
- type: "restarted",
- threadId: input.threadId,
- terminalId,
- createdAt: now,
- snapshot,
- });
- });
- return snapshot;
- });
-
- readonly close: TerminalManagerShape["close"] = (input: TerminalCloseInput) =>
- Effect.sync(() => {
- if (input.terminalId) {
- this.sessions.delete(this.key(input.threadId, input.terminalId));
- return;
- }
- for (const key of this.sessions.keys()) {
- if (key.startsWith(`${input.threadId}\u0000`)) {
- this.sessions.delete(key);
- }
- }
- });
-
- readonly subscribe: TerminalManagerShape["subscribe"] = (listener) =>
- Effect.sync(() => {
- this.activeSubscriptions += 1;
- const fiber = Effect.runFork(
- Stream.runForEach(Stream.fromPubSub(this.eventPubSub), (event) => listener(event)),
- );
- return () => {
- this.activeSubscriptions -= 1;
- Effect.runFork(Fiber.interrupt(fiber).pipe(Effect.ignore));
- };
- });
-}
-
-// ---------------------------------------------------------------------------
-// WebSocket test harness
-//
-// Incoming messages are split into two channels:
-// - pushChannel: server push envelopes (type === "push")
-// - responseChannel: request/response envelopes (have an "id" field)
-//
-// This means sendRequest never has to skip push messages and waitForPush
-// never has to skip response messages, eliminating a class of ordering bugs.
-// ---------------------------------------------------------------------------
-
-interface MessageChannel<T> {
- queue: T[];
- waiters: Array<{
- resolve: (value: T) => void;
- reject: (error: Error) => void;
- timeoutId: ReturnType<typeof setTimeout> | null;
- }>;
-}
-
-interface SocketChannels {
- push: MessageChannel<WsPush>;
- response: MessageChannel<WebSocketResponse>;
-}
-
-const channelsBySocket = new WeakMap<WebSocket, SocketChannels>();
-
-function enqueue<T>(channel: MessageChannel<T>, item: T) {
- const waiter = channel.waiters.shift();
- if (waiter) {
- if (waiter.timeoutId !== null) clearTimeout(waiter.timeoutId);
- waiter.resolve(item);
- return;
- }
- channel.queue.push(item);
-}
-
-function dequeue<T>(channel: MessageChannel<T>, timeoutMs: number): Promise<T> {
- const queued = channel.queue.shift();
- if (queued !== undefined) {
- return Promise.resolve(queued);
- }
-
- return new Promise((resolve, reject) => {
- const waiter = {
- resolve,
- reject,
- timeoutId: setTimeout(() => {
- const index = channel.waiters.indexOf(waiter);
- if (index >= 0) channel.waiters.splice(index, 1);
- reject(new Error(`Timed out waiting for WebSocket message after ${timeoutMs}ms`));
- }, timeoutMs) as ReturnType<typeof setTimeout>,
- };
- channel.waiters.push(waiter);
- });
-}
-
-function isWsPushEnvelope(message: unknown): message is WsPush {
- if (typeof message !== "object" || message === null) return false;
- if (!("type" in message) || !("channel" in message)) return false;
- return (message as { type?: unknown }).type === "push";
-}
-
-function asWebSocketResponse(message: unknown): WebSocketResponse | null {
- if (typeof message !== "object" || message === null) return null;
- if (!("id" in message)) return null;
- const id = (message as { id?: unknown }).id;
- if (typeof id !== "string") return null;
- return message as WebSocketResponse;
-}
-
-function connectWsOnce(port: number, token?: string): Promise<WebSocket> {
- return new Promise((resolve, reject) => {
- const query = token ? `?token=${encodeURIComponent(token)}` : "";
- const ws = new WebSocket(`ws://127.0.0.1:${port}/${query}`);
- const channels: SocketChannels = {
- push: { queue: [], waiters: [] },
- response: { queue: [], waiters: [] },
- };
- channelsBySocket.set(ws, channels);
-
- ws.on("message", (raw) => {
- const parsed = JSON.parse(String(raw));
- if (isWsPushEnvelope(parsed)) {
- enqueue(channels.push, parsed);
- } else {
- const response = asWebSocketResponse(parsed);
- if (response) {
- enqueue(channels.response, response);
- }
- }
- });
-
- ws.once("open", () => resolve(ws));
- ws.once("error", () => reject(new Error("WebSocket connection failed")));
- });
-}
-
-async function connectWs(port: number, token?: string, attempts = 5): Promise<WebSocket> {
- let lastError: unknown = new Error("WebSocket connection failed");
-
- for (let attempt = 0; attempt < attempts; attempt += 1) {
- try {
- return await connectWsOnce(port, token);
- } catch (error) {
- lastError = error;
- if (attempt < attempts - 1) {
- await new Promise((resolve) => setTimeout(resolve, 25));
- }
- }
- }
-
- throw lastError;
-}
-
-/** Connect and wait for the server.welcome push. Returns [ws, welcomeData]. */
-async function connectAndAwaitWelcome(
- port: number,
- token?: string,
-): Promise<[WebSocket, WsPushMessage<typeof WS_CHANNELS.serverWelcome>]> {
- const ws = await connectWs(port, token);
- const welcome = await waitForPush(ws, WS_CHANNELS.serverWelcome);
- return [ws, welcome];
-}
-
-async function sendRequest(
- ws: WebSocket,
- method: string,
- params?: unknown,
-): Promise<WebSocketResponse> {
- const channels = channelsBySocket.get(ws);
- if (!channels) throw new Error("WebSocket not initialized");
-
- const id = crypto.randomUUID();
- const body =
- method === ORCHESTRATION_WS_METHODS.dispatchCommand
- ? { _tag: method, command: params }
- : params && typeof params === "object" && !Array.isArray(params)
- ? { _tag: method, ...(params as Record<string, unknown>) }
- : { _tag: method };
- ws.send(JSON.stringify({ id, body }));
-
- // Response channel only contains responses — no push filtering needed
- while (true) {
- const response = await dequeue(channels.response, 60_000);
- if (response.id === id || response.id === "unknown") {
- return response;
- }
- }
-}
-
-async function waitForPush<C extends WsPushChannel>(
- ws: WebSocket,
- channel: C,
- predicate?: (push: WsPushMessage<C>) => boolean,
- maxMessages = 120,
- idleTimeoutMs = 5_000,
-): Promise<WsPushMessage<C>> {
- const channels = channelsBySocket.get(ws);
- if (!channels) throw new Error("WebSocket not initialized");
-
- for (let remaining = maxMessages; remaining > 0; remaining--) {
- const push = await dequeue(channels.push, idleTimeoutMs);
- if (push.channel !== channel) continue;
- const typed = push as WsPushMessage<C>;
- if (!predicate || predicate(typed)) return typed;
- }
- throw new Error(`Timed out waiting for push on ${channel}`);
-}
-
-async function rewriteKeybindingsAndWaitForPush(
- ws: WebSocket,
- keybindingsPath: string,
- contents: string,
- predicate: (push: WsPushMessage<typeof WS_CHANNELS.serverConfigUpdated>) => boolean,
- attempts = 3,
-): Promise<WsPushMessage<typeof WS_CHANNELS.serverConfigUpdated>> {
- let lastError: unknown;
- for (let attempt = 0; attempt < attempts; attempt++) {
- fs.writeFileSync(keybindingsPath, contents, "utf8");
- try {
- return await waitForPush(ws, WS_CHANNELS.serverConfigUpdated, predicate, 20, 3_000);
- } catch (error) {
- lastError = error;
- }
- }
- throw lastError;
-}
-
-async function requestPath(
- port: number,
- requestPath: string,
-): Promise<{ statusCode: number; body: string }> {
- return new Promise((resolve, reject) => {
- const req = Http.request(
- {
- hostname: "127.0.0.1",
- port,
- path: requestPath,
- method: "GET",
- },
- (res) => {
- const chunks: Buffer[] = [];
- res.on("data", (chunk) => {
- chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
- });
- res.on("end", () => {
- resolve({
- statusCode: res.statusCode ?? 0,
- body: Buffer.concat(chunks).toString("utf8"),
- });
- });
- },
- );
- req.once("error", reject);
- req.end();
- });
-}
-
-function compileKeybindings(bindings: KeybindingsConfig): ResolvedKeybindingsConfig {
- const resolved: Array<ResolvedKeybindingsConfig[number]> = [];
- for (const binding of bindings) {
- const compiled = compileResolvedKeybindingRule(binding);
- if (!compiled) {
- throw new Error(`Unexpected invalid keybinding in test setup: ${binding.command}`);
- }
- resolved.push(compiled);
- }
- return resolved;
-}
-
-const DEFAULT_RESOLVED_KEYBINDINGS = compileKeybindings([...DEFAULT_KEYBINDINGS]);
-const VALID_EDITOR_IDS = new Set(EDITORS.map((editor) => editor.id));
-
-function expectAvailableEditors(value: unknown): void {
- expect(Array.isArray(value)).toBe(true);
- for (const editorId of value as unknown[]) {
- expect(typeof editorId).toBe("string");
- expect(VALID_EDITOR_IDS.has(editorId as (typeof EDITORS)[number]["id"])).toBe(true);
- }
-}
-
-function ensureParentDir(filePath: string): void {
- fs.mkdirSync(path.dirname(filePath), { recursive: true });
-}
-
-function deriveServerPathsSync(baseDir: string, devUrl: URL | undefined) {
- return Effect.runSync(
- deriveServerPaths(baseDir, devUrl).pipe(Effect.provide(NodeServices.layer)),
- );
-}
-
-describe("WebSocket Server", () => {
- let server: Http.Server | null = null;
- let serverScope: Scope.Closeable | null = null;
- let disposeServerRuntime: (() => Promise<void>) | null = null;
- const connections: WebSocket[] = [];
- const tempDirs: string[] = [];
-
- function makeTempDir(prefix: string): string {
- const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
- tempDirs.push(dir);
- return dir;
- }
-
- async function createTestServer(
- options: {
- persistenceLayer?: Layer.Layer<
- SqlClient.SqlClient,
- SqlError.SqlError | MigrationError | PlatformError.PlatformError
- >;
- cwd?: string;
- autoBootstrapProjectFromCwd?: boolean;
- logWebSocketEvents?: boolean;
- devUrl?: string;
- authToken?: string;
- baseDir?: string;
- staticDir?: string;
- providerLayer?: Layer.Layer<ProviderService, never>;
- providerRegistry?: ProviderRegistryShape;
- open?: OpenShape;
- gitManager?: GitManagerShape;
- gitCore?: Pick<GitCoreShape, "listBranches" | "initRepo" | "pullCurrentBranch">;
- terminalManager?: TerminalManagerShape;
- serverSettings?: Partial<ServerSettings>;
- } = {},
- ): Promise<Http.Server> {
- if (serverScope) {
- throw new Error("Test server is already running");
- }
-
- const baseDir = options.baseDir ?? makeTempDir("t3code-ws-base-");
- const devUrl = options.devUrl ? new URL(options.devUrl) : undefined;
- const derivedPaths = deriveServerPathsSync(baseDir, devUrl);
- const scope = await Effect.runPromise(Scope.make("sequential"));
- const persistenceLayer = options.persistenceLayer ?? SqlitePersistenceMemory;
- const providerLayer = options.providerLayer ?? makeServerProviderLayer();
- const providerRegistryLayer = Layer.succeed(
- ProviderRegistry,
- options.providerRegistry ?? defaultProviderRegistryService,
- );
- const openLayer = Layer.succeed(Open, options.open ?? defaultOpenService);
- const nodeServicesLayer = NodeServices.layer;
- const serverSettingsLayer = ServerSettingsService.layerTest(options.serverSettings);
- const serverSettingsRuntimeLayer = serverSettingsLayer.pipe(
- Layer.provideMerge(nodeServicesLayer),
- );
- const analyticsLayer = AnalyticsService.layerTest;
- const serverConfigLayer = Layer.succeed(ServerConfig, {
- mode: "web",
- port: 0,
- host: undefined,
- cwd: options.cwd ?? "/test/project",
- baseDir,
- ...derivedPaths,
- staticDir: options.staticDir,
- devUrl,
- noBrowser: true,
- authToken: options.authToken,
- autoBootstrapProjectFromCwd: options.autoBootstrapProjectFromCwd ?? false,
- logWebSocketEvents: options.logWebSocketEvents ?? Boolean(options.devUrl),
- } satisfies ServerConfigShape);
- const infrastructureLayer = providerLayer.pipe(Layer.provideMerge(persistenceLayer));
- const providerRuntimeLayer = infrastructureLayer.pipe(
- Layer.provideMerge(serverConfigLayer),
- Layer.provideMerge(serverSettingsRuntimeLayer),
- Layer.provideMerge(analyticsLayer),
- );
- const runtimeOverrides = Layer.mergeAll(
- options.gitManager ? Layer.succeed(GitManager, options.gitManager) : Layer.empty,
- options.gitCore
- ? Layer.succeed(GitCore, options.gitCore as unknown as GitCoreShape)
- : Layer.empty,
- options.terminalManager
- ? Layer.succeed(TerminalManager, options.terminalManager)
- : Layer.empty,
- );
-
- const runtimeLayer = Layer.merge(
- Layer.merge(
- makeServerRuntimeServicesLayer().pipe(
- Layer.provideMerge(providerRuntimeLayer),
- Layer.provideMerge(serverConfigLayer),
- Layer.provideMerge(serverSettingsRuntimeLayer),
- Layer.provideMerge(analyticsLayer),
- Layer.provideMerge(nodeServicesLayer),
- ),
- Layer.mergeAll(providerRuntimeLayer, serverSettingsRuntimeLayer, analyticsLayer),
- ),
- runtimeOverrides,
- );
- const dependenciesLayer = Layer.mergeAll(
- runtimeLayer,
- providerRegistryLayer,
- openLayer,
- serverConfigLayer,
- nodeServicesLayer,
- );
- const runtime = ManagedRuntime.make(dependenciesLayer);
- try {
- const httpServer = await runtime.runPromise(createServer().pipe(Scope.provide(scope)));
- disposeServerRuntime = () => runtime.dispose();
- serverScope = scope;
- return httpServer;
- } catch (error) {
- await runtime.dispose();
- await Effect.runPromise(Scope.close(scope, Exit.void));
- throw error;
- }
- }
-
- async function closeTestServer() {
- if (!serverScope && !disposeServerRuntime) return;
- const scope = serverScope;
- const disposeRuntime = disposeServerRuntime;
- serverScope = null;
- disposeServerRuntime = null;
- if (scope) {
- await Effect.runPromise(Scope.close(scope, Exit.void));
- }
- if (disposeRuntime) {
- await disposeRuntime();
- }
- }
-
- afterEach(async () => {
- for (const ws of connections) {
- ws.close();
- }
- connections.length = 0;
- await closeTestServer();
- server = null;
- for (const dir of tempDirs.splice(0, tempDirs.length)) {
- fs.rmSync(dir, { recursive: true, force: true });
- }
- vi.restoreAllMocks();
- });
-
- it("sends welcome message on connect", async () => {
- server = await createTestServer({ cwd: "/test/project" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const [ws, welcome] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- expect(welcome.type).toBe("push");
- expect(welcome.data).toEqual({
- cwd: "/test/project",
- projectName: "project",
- });
- });
-
- it("serves persisted attachments from stateDir", async () => {
- const baseDir = makeTempDir("t3code-state-attachments-");
- const { attachmentsDir } = deriveServerPathsSync(baseDir, undefined);
- const attachmentPath = path.join(attachmentsDir, "thread-a", "message-a", "0.png");
- fs.mkdirSync(path.dirname(attachmentPath), { recursive: true });
- fs.writeFileSync(attachmentPath, Buffer.from("hello-attachment"));
-
- server = await createTestServer({ cwd: "/test/project", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const response = await fetch(`http://127.0.0.1:${port}/attachments/thread-a/message-a/0.png`);
- expect(response.status).toBe(200);
- expect(response.headers.get("content-type")).toContain("image/png");
- const bytes = Buffer.from(await response.arrayBuffer());
- expect(bytes).toEqual(Buffer.from("hello-attachment"));
- });
-
- it("serves persisted attachments for URL-encoded paths", async () => {
- const baseDir = makeTempDir("t3code-state-attachments-encoded-");
- const { attachmentsDir } = deriveServerPathsSync(baseDir, undefined);
- const attachmentPath = path.join(
- attachmentsDir,
- "thread%20folder",
- "message%20folder",
- "file%20name.png",
- );
- fs.mkdirSync(path.dirname(attachmentPath), { recursive: true });
- fs.writeFileSync(attachmentPath, Buffer.from("hello-encoded-attachment"));
-
- server = await createTestServer({ cwd: "/test/project", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const response = await fetch(
- `http://127.0.0.1:${port}/attachments/thread%20folder/message%20folder/file%20name.png`,
- );
- expect(response.status).toBe(200);
- expect(response.headers.get("content-type")).toContain("image/png");
- const bytes = Buffer.from(await response.arrayBuffer());
- expect(bytes).toEqual(Buffer.from("hello-encoded-attachment"));
- });
-
- it("serves static index for root path", async () => {
- const baseDir = makeTempDir("t3code-state-static-root-");
- const staticDir = makeTempDir("t3code-static-root-");
- fs.writeFileSync(path.join(staticDir, "index.html"), "<h1>static-root</h1>", "utf8");
-
- server = await createTestServer({ cwd: "/test/project", baseDir, staticDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const response = await fetch(`http://127.0.0.1:${port}/`);
- expect(response.status).toBe(200);
- expect(await response.text()).toContain("static-root");
- });
-
- it("rejects static path traversal attempts", async () => {
- const baseDir = makeTempDir("t3code-state-static-traversal-");
- const staticDir = makeTempDir("t3code-static-traversal-");
- fs.writeFileSync(path.join(staticDir, "index.html"), "<h1>safe</h1>", "utf8");
-
- server = await createTestServer({ cwd: "/test/project", baseDir, staticDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const response = await requestPath(port, "/..%2f..%2fetc/passwd");
- expect(response.statusCode).toBe(400);
- expect(response.body).toBe("Invalid static file path");
- });
-
- it("bootstraps the cwd project on startup when enabled", async () => {
- server = await createTestServer({
- cwd: "/test/bootstrap-workspace",
- autoBootstrapProjectFromCwd: true,
- });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const [ws, welcome] = await connectAndAwaitWelcome(port);
- connections.push(ws);
- expect(welcome.data).toEqual(
- expect.objectContaining({
- cwd: "/test/bootstrap-workspace",
- projectName: "bootstrap-workspace",
- bootstrapProjectId: expect.any(String),
- bootstrapThreadId: expect.any(String),
- }),
- );
-
- const snapshotResponse = await sendRequest(ws, ORCHESTRATION_WS_METHODS.getSnapshot);
- expect(snapshotResponse.error).toBeUndefined();
- const snapshot = snapshotResponse.result as {
- projects: Array<{
- id: string;
- workspaceRoot: string;
- title: string;
- defaultModelSelection: {
- provider: string;
- model: string;
- } | null;
- }>;
- threads: Array<{
- id: string;
- projectId: string;
- title: string;
- modelSelection: {
- provider: string;
- model: string;
- };
- branch: string | null;
- worktreePath: string | null;
- }>;
- };
- const bootstrapProjectId = (welcome.data as { bootstrapProjectId?: string }).bootstrapProjectId;
- const bootstrapThreadId = (welcome.data as { bootstrapThreadId?: string }).bootstrapThreadId;
- expect(bootstrapProjectId).toBeDefined();
- expect(bootstrapThreadId).toBeDefined();
-
- expect(snapshot.projects).toEqual(
- expect.arrayContaining([
- expect.objectContaining({
- id: bootstrapProjectId,
- workspaceRoot: "/test/bootstrap-workspace",
- title: "bootstrap-workspace",
- defaultModelSelection: {
- provider: "codex",
- model: "gpt-5-codex",
- },
- }),
- ]),
- );
- expect(snapshot.threads).toEqual(
- expect.arrayContaining([
- expect.objectContaining({
- id: bootstrapThreadId,
- projectId: bootstrapProjectId,
- title: "New thread",
- modelSelection: {
- provider: "codex",
- model: "gpt-5-codex",
- },
- branch: null,
- worktreePath: null,
- }),
- ]),
- );
- });
-
- it("includes bootstrap ids in welcome when cwd project and thread already exist", async () => {
- const baseDir = makeTempDir("t3code-state-bootstrap-existing-");
- const { dbPath } = deriveServerPathsSync(baseDir, undefined);
- const persistenceLayer = makeSqlitePersistenceLive(dbPath).pipe(
- Layer.provide(NodeServices.layer),
- );
- const cwd = "/test/bootstrap-existing";
-
- server = await createTestServer({
- cwd,
- baseDir,
- persistenceLayer,
- autoBootstrapProjectFromCwd: true,
- });
- let addr = server.address();
- let port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const [firstWs, firstWelcome] = await connectAndAwaitWelcome(port);
- connections.push(firstWs);
- const firstBootstrapProjectId = (firstWelcome.data as { bootstrapProjectId?: string })
- .bootstrapProjectId;
- const firstBootstrapThreadId = (firstWelcome.data as { bootstrapThreadId?: string })
- .bootstrapThreadId;
- expect(firstBootstrapProjectId).toBeDefined();
- expect(firstBootstrapThreadId).toBeDefined();
-
- firstWs.close();
- await closeTestServer();
- server = null;
-
- server = await createTestServer({
- cwd,
- baseDir,
- persistenceLayer,
- autoBootstrapProjectFromCwd: true,
- });
- addr = server.address();
- port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const [secondWs, secondWelcome] = await connectAndAwaitWelcome(port);
- connections.push(secondWs);
- expect(secondWelcome.data).toEqual(
- expect.objectContaining({
- cwd,
- projectName: "bootstrap-existing",
- bootstrapProjectId: firstBootstrapProjectId,
- bootstrapThreadId: firstBootstrapThreadId,
- }),
- );
- });
-
- it("logs outbound websocket push events in dev mode", async () => {
- const logSpy = vi.spyOn(console, "log").mockImplementation(() => {
- // Keep test output clean while verifying websocket logs.
- });
-
- server = await createTestServer({
- cwd: "/test/project",
- devUrl: "http://localhost:5173",
- });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
- expect(port).toBeGreaterThan(0);
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- expect(
- logSpy.mock.calls.some(([message]) => {
- if (typeof message !== "string") return false;
- return (
- message.includes("[ws]") &&
- message.includes("outgoing push") &&
- message.includes(`channel="${WS_CHANNELS.serverWelcome}"`)
- );
- }),
- ).toBe(true);
- });
-
- it("responds to server.getConfig", async () => {
- const baseDir = makeTempDir("t3code-state-get-config-");
- const { keybindingsConfigPath: keybindingsPath } = deriveServerPathsSync(baseDir, undefined);
- ensureParentDir(keybindingsPath);
- fs.writeFileSync(keybindingsPath, "[]", "utf8");
-
- server = await createTestServer({ cwd: "/my/workspace", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.serverGetConfig);
- expect(response.error).toBeUndefined();
- expect(response.result).toEqual({
- cwd: "/my/workspace",
- keybindingsConfigPath: keybindingsPath,
- keybindings: DEFAULT_RESOLVED_KEYBINDINGS,
- issues: [],
- providers: defaultProviderStatuses,
- availableEditors: expect.any(Array),
- settings: defaultServerSettings,
- });
- expectAvailableEditors((response.result as { availableEditors: unknown }).availableEditors);
- });
-
- it("bootstraps default keybindings file when missing", async () => {
- const baseDir = makeTempDir("t3code-state-bootstrap-keybindings-");
- const { keybindingsConfigPath: keybindingsPath } = deriveServerPathsSync(baseDir, undefined);
- expect(fs.existsSync(keybindingsPath)).toBe(false);
-
- server = await createTestServer({ cwd: "/my/workspace", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.serverGetConfig);
- expect(response.error).toBeUndefined();
- expect(response.result).toEqual({
- cwd: "/my/workspace",
- keybindingsConfigPath: keybindingsPath,
- keybindings: DEFAULT_RESOLVED_KEYBINDINGS,
- issues: [],
- providers: defaultProviderStatuses,
- availableEditors: expect.any(Array),
- settings: defaultServerSettings,
- });
- expectAvailableEditors((response.result as { availableEditors: unknown }).availableEditors);
-
- const persistedConfig = JSON.parse(
- fs.readFileSync(keybindingsPath, "utf8"),
- ) as KeybindingsConfig;
- expect(persistedConfig).toEqual(DEFAULT_KEYBINDINGS);
- });
-
- it("falls back to defaults and reports malformed keybindings config issues", async () => {
- const baseDir = makeTempDir("t3code-state-malformed-keybindings-");
- const { keybindingsConfigPath: keybindingsPath } = deriveServerPathsSync(baseDir, undefined);
- ensureParentDir(keybindingsPath);
- fs.writeFileSync(keybindingsPath, "{ not-json", "utf8");
-
- server = await createTestServer({ cwd: "/my/workspace", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.serverGetConfig);
- expect(response.error).toBeUndefined();
- expect(response.result).toEqual({
- cwd: "/my/workspace",
- keybindingsConfigPath: keybindingsPath,
- keybindings: DEFAULT_RESOLVED_KEYBINDINGS,
- issues: [
- {
- kind: "keybindings.malformed-config",
- message: expect.stringContaining("expected JSON array"),
- },
- ],
- providers: defaultProviderStatuses,
- availableEditors: expect.any(Array),
- settings: defaultServerSettings,
- });
- expectAvailableEditors((response.result as { availableEditors: unknown }).availableEditors);
- expect(fs.readFileSync(keybindingsPath, "utf8")).toBe("{ not-json");
- });
-
- it("ignores invalid keybinding entries but keeps valid entries and reports issues", async () => {
- const baseDir = makeTempDir("t3code-state-partial-invalid-keybindings-");
- const { keybindingsConfigPath: keybindingsPath } = deriveServerPathsSync(baseDir, undefined);
- ensureParentDir(keybindingsPath);
- fs.writeFileSync(
- keybindingsPath,
- JSON.stringify([
- { key: "mod+j", command: "terminal.toggle" },
- { key: "mod+shift+d+o", command: "terminal.new" },
- { key: "mod+x", command: "not-a-real-command" },
- ]),
- "utf8",
- );
-
- server = await createTestServer({ cwd: "/my/workspace", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.serverGetConfig);
- expect(response.error).toBeUndefined();
- const result = response.result as {
- cwd: string;
- keybindingsConfigPath: string;
- keybindings: ResolvedKeybindingsConfig;
- issues: Array<{ kind: string; index?: number; message: string }>;
- providers: ReadonlyArray<ServerProvider>;
- availableEditors: unknown;
- };
- expect(result.cwd).toBe("/my/workspace");
- expect(result.keybindingsConfigPath).toBe(keybindingsPath);
- expect(result.issues).toEqual([
- {
- kind: "keybindings.invalid-entry",
- index: 1,
- message: expect.any(String),
- },
- {
- kind: "keybindings.invalid-entry",
- index: 2,
- message: expect.any(String),
- },
- ]);
- expect(result.keybindings).toHaveLength(DEFAULT_RESOLVED_KEYBINDINGS.length);
- expect(result.keybindings.some((entry) => entry.command === "terminal.toggle")).toBe(true);
- expect(result.keybindings.some((entry) => entry.command === "terminal.new")).toBe(true);
- expect(result.providers).toEqual(defaultProviderStatuses);
- expectAvailableEditors(result.availableEditors);
- });
-
- it("pushes server.configUpdated issues when keybindings file changes", async () => {
- const baseDir = makeTempDir("t3code-state-keybindings-watch-");
- const { keybindingsConfigPath: keybindingsPath } = deriveServerPathsSync(baseDir, undefined);
- ensureParentDir(keybindingsPath);
- fs.writeFileSync(keybindingsPath, "[]", "utf8");
-
- server = await createTestServer({ cwd: "/my/workspace", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const malformedPush = await rewriteKeybindingsAndWaitForPush(
- ws,
- keybindingsPath,
- "{ not-json",
- (push) =>
- Array.isArray(push.data.issues) &&
- Boolean(push.data.issues[0]) &&
- push.data.issues[0]!.kind === "keybindings.malformed-config",
- );
- expect(malformedPush.data).toEqual({
- issues: [{ kind: "keybindings.malformed-config", message: expect.any(String) }],
- });
-
- const successPush = await rewriteKeybindingsAndWaitForPush(
- ws,
- keybindingsPath,
- "[]",
- (push) => Array.isArray(push.data.issues) && push.data.issues.length === 0,
- );
- expect(successPush.data).toEqual({ issues: [] });
- });
-
- it("routes shell.openInEditor through the injected open service", async () => {
- const openCalls: Array<{ cwd: string; editor: string }> = [];
- const openService: OpenShape = {
- openBrowser: () => Effect.void,
- openInEditor: (input) => {
- openCalls.push({ cwd: input.cwd, editor: input.editor });
- return Effect.void;
- },
- };
-
- server = await createTestServer({ cwd: "/my/workspace", open: openService });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.shellOpenInEditor, {
- cwd: "/my/workspace",
- editor: "cursor",
- });
- expect(response.error).toBeUndefined();
- expect(openCalls).toEqual([{ cwd: "/my/workspace", editor: "cursor" }]);
- });
-
- it("reads keybindings from the configured state directory", async () => {
- const baseDir = makeTempDir("t3code-state-keybindings-");
- const { keybindingsConfigPath: keybindingsPath } = deriveServerPathsSync(baseDir, undefined);
- ensureParentDir(keybindingsPath);
- fs.writeFileSync(
- keybindingsPath,
- JSON.stringify([
- { key: "cmd+j", command: "terminal.toggle" },
- { key: "mod+d", command: "terminal.split", when: "terminalFocus" },
- { key: "mod+n", command: "terminal.new", when: "terminalFocus" },
- ]),
- "utf8",
- );
- server = await createTestServer({ cwd: "/my/workspace", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.serverGetConfig);
- expect(response.error).toBeUndefined();
- const persistedConfig = JSON.parse(
- fs.readFileSync(keybindingsPath, "utf8"),
- ) as KeybindingsConfig;
- expect(response.result).toEqual({
- cwd: "/my/workspace",
- keybindingsConfigPath: keybindingsPath,
- keybindings: compileKeybindings(persistedConfig),
- issues: [],
- providers: defaultProviderStatuses,
- availableEditors: expect.any(Array),
- settings: defaultServerSettings,
- });
- expectAvailableEditors((response.result as { availableEditors: unknown }).availableEditors);
- });
-
- it("upserts keybinding rules and updates cached server config", async () => {
- const baseDir = makeTempDir("t3code-state-upsert-keybinding-");
- const { keybindingsConfigPath: keybindingsPath } = deriveServerPathsSync(baseDir, undefined);
- ensureParentDir(keybindingsPath);
- fs.writeFileSync(
- keybindingsPath,
- JSON.stringify([{ key: "mod+j", command: "terminal.toggle" }]),
- "utf8",
- );
-
- server = await createTestServer({ cwd: "/my/workspace", baseDir });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const upsertResponse = await sendRequest(ws, WS_METHODS.serverUpsertKeybinding, {
- key: "mod+shift+r",
- command: "script.run-tests.run",
- });
- expect(upsertResponse.error).toBeUndefined();
- const persistedConfig = JSON.parse(
- fs.readFileSync(keybindingsPath, "utf8"),
- ) as KeybindingsConfig;
- const persistedCommands = new Set(persistedConfig.map((entry) => entry.command));
- for (const defaultRule of DEFAULT_KEYBINDINGS) {
- expect(persistedCommands.has(defaultRule.command)).toBe(true);
- }
- expect(persistedCommands.has("script.run-tests.run")).toBe(true);
- expect(upsertResponse.result).toEqual({
- keybindings: compileKeybindings(persistedConfig),
- issues: [],
- });
-
- const configResponse = await sendRequest(ws, WS_METHODS.serverGetConfig);
- expect(configResponse.error).toBeUndefined();
- expect(configResponse.result).toEqual({
- cwd: "/my/workspace",
- keybindingsConfigPath: keybindingsPath,
- keybindings: compileKeybindings(persistedConfig),
- issues: [],
- providers: defaultProviderStatuses,
- availableEditors: expect.any(Array),
- settings: defaultServerSettings,
- });
- expectAvailableEditors(
- (configResponse.result as { availableEditors: unknown }).availableEditors,
- );
- });
-
- it("returns error for unknown methods", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, "nonexistent.method");
- expect(response.error).toBeDefined();
- expect(response.error!.message).toContain("Invalid request format");
- });
-
- it("returns error when requesting turn diff for unknown thread", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, ORCHESTRATION_WS_METHODS.getTurnDiff, {
- threadId: "thread-missing",
- fromTurnCount: 1,
- toTurnCount: 2,
- });
- expect(response.result).toBeUndefined();
- expect(response.error?.message).toContain("Thread 'thread-missing' not found.");
- });
-
- it("returns error when requesting turn diff with an inverted range", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, ORCHESTRATION_WS_METHODS.getTurnDiff, {
- threadId: "thread-any",
- fromTurnCount: 2,
- toTurnCount: 1,
- });
- expect(response.result).toBeUndefined();
- expect(response.error?.message).toContain(
- "fromTurnCount must be less than or equal to toTurnCount",
- );
- });
-
- it("returns error when requesting full thread diff for unknown thread", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, ORCHESTRATION_WS_METHODS.getFullThreadDiff, {
- threadId: "thread-missing",
- toTurnCount: 2,
- });
- expect(response.result).toBeUndefined();
- expect(response.error?.message).toContain("Thread 'thread-missing' not found.");
- });
-
- it("returns retryable error when requested turn exceeds current checkpoint turn count", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const workspaceRoot = makeTempDir("t3code-ws-diff-project-");
- const createdAt = new Date().toISOString();
- const createProjectResponse = await sendRequest(ws, ORCHESTRATION_WS_METHODS.dispatchCommand, {
- type: "project.create",
- commandId: "cmd-diff-project-create",
- projectId: "project-diff",
- title: "Diff Project",
- workspaceRoot,
- defaultModelSelection: {
- provider: "codex",
- model: "gpt-5-codex",
- },
- createdAt,
- });
- expect(createProjectResponse.error).toBeUndefined();
- const createThreadResponse = await sendRequest(ws, ORCHESTRATION_WS_METHODS.dispatchCommand, {
- type: "thread.create",
- commandId: "cmd-diff-thread-create",
- threadId: "thread-diff",
- projectId: "project-diff",
- title: "Diff Thread",
- modelSelection: {
- provider: "codex",
- model: "gpt-5-codex",
- },
- runtimeMode: "full-access",
- interactionMode: "default",
- branch: null,
- worktreePath: null,
- createdAt,
- });
- expect(createThreadResponse.error).toBeUndefined();
-
- const response = await sendRequest(ws, ORCHESTRATION_WS_METHODS.getTurnDiff, {
- threadId: "thread-diff",
- fromTurnCount: 0,
- toTurnCount: 1,
- });
- expect(response.result).toBeUndefined();
- expect(response.error?.message).toContain("exceeds current turn count");
- });
-
- it("rejects project.create when the workspace root does not exist", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const missingWorkspaceRoot = path.join(makeTempDir("t3code-ws-project-missing-"), "missing");
- const response = await sendRequest(ws, ORCHESTRATION_WS_METHODS.dispatchCommand, {
- type: "project.create",
- commandId: "cmd-ws-project-create-missing",
- projectId: "project-missing",
- title: "Missing Project",
- workspaceRoot: missingWorkspaceRoot,
- defaultModelSelection: {
- provider: "codex",
- model: "gpt-5-codex",
- },
- createdAt: new Date().toISOString(),
- });
-
- expect(response.result).toBeUndefined();
- expect(response.error?.message).toContain("Workspace root does not exist:");
- });
-
- it("keeps orchestration domain push behavior for provider runtime events", async () => {
- const runtimeEventPubSub = Effect.runSync(PubSub.unbounded<ProviderRuntimeEvent>());
- const emitRuntimeEvent = (event: ProviderRuntimeEvent) => {
- Effect.runSync(PubSub.publish(runtimeEventPubSub, event));
- };
- const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never;
- const providerService: ProviderServiceShape = {
- startSession: (threadId) =>
- Effect.succeed({
- provider: "codex",
- status: "ready",
- runtimeMode: "full-access",
- threadId,
- createdAt: new Date().toISOString(),
- updatedAt: new Date().toISOString(),
- }),
- sendTurn: ({ threadId }) =>
- Effect.succeed({
- threadId,
- turnId: asTurnId("provider-turn-1"),
- }),
- interruptTurn: () => unsupported(),
- respondToRequest: () => unsupported(),
- respondToUserInput: () => unsupported(),
- stopSession: () => unsupported(),
- listSessions: () => Effect.succeed([]),
- getCapabilities: () => Effect.succeed({ sessionModelSwitch: "in-session" }),
- rollbackConversation: () => unsupported(),
- streamEvents: Stream.fromPubSub(runtimeEventPubSub),
- };
- const providerLayer = Layer.succeed(ProviderService, providerService);
-
- server = await createTestServer({
- cwd: "/test",
- providerLayer,
- serverSettings: { enableAssistantStreaming: true },
- });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const workspaceRoot = makeTempDir("t3code-ws-project-");
- const createdAt = new Date().toISOString();
- const createProjectResponse = await sendRequest(ws, ORCHESTRATION_WS_METHODS.dispatchCommand, {
- type: "project.create",
- commandId: "cmd-ws-project-create",
- projectId: "project-1",
- title: "WS Project",
- workspaceRoot,
- defaultModelSelection: {
- provider: "codex",
- model: "gpt-5-codex",
- },
- createdAt,
- });
- expect(createProjectResponse.error).toBeUndefined();
- const createThreadResponse = await sendRequest(ws, ORCHESTRATION_WS_METHODS.dispatchCommand, {
- type: "thread.create",
- commandId: "cmd-ws-runtime-thread-create",
- threadId: "thread-1",
- projectId: "project-1",
- title: "Thread 1",
- modelSelection: {
- provider: "codex",
- model: "gpt-5-codex",
- },
- runtimeMode: "full-access",
- interactionMode: "default",
- branch: null,
- worktreePath: null,
- createdAt,
- });
- expect(createThreadResponse.error).toBeUndefined();
-
- const startTurnResponse = await sendRequest(ws, ORCHESTRATION_WS_METHODS.dispatchCommand, {
- type: "thread.turn.start",
- commandId: "cmd-ws-runtime-turn-start",
- threadId: "thread-1",
- message: {
- messageId: "msg-ws-runtime-1",
- role: "user",
- text: "hello",
- attachments: [],
- },
- runtimeMode: "approval-required",
- interactionMode: "default",
- createdAt,
- });
- expect(startTurnResponse.error).toBeUndefined();
-
- await waitForPush(ws, ORCHESTRATION_WS_CHANNELS.domainEvent, (push) => {
- const event = push.data as { type?: string };
- return event.type === "thread.session-set";
- });
-
- emitRuntimeEvent({
- type: "content.delta",
- eventId: asEventId("evt-ws-runtime-message-delta"),
- provider: "codex",
- threadId: asThreadId("thread-1"),
- createdAt: new Date().toISOString(),
- turnId: asTurnId("turn-1"),
- itemId: asProviderItemId("item-1"),
- payload: {
- streamKind: "assistant_text",
- delta: "hello from runtime",
- },
- } as unknown as ProviderRuntimeEvent);
-
- const domainPush = await waitForPush(ws, ORCHESTRATION_WS_CHANNELS.domainEvent, (push) => {
- const event = push.data as { type?: string; payload?: { messageId?: string; text?: string } };
- return (
- event.type === "thread.message-sent" && event.payload?.messageId === "assistant:item-1"
- );
- });
-
- const domainEvent = domainPush.data as {
- type: string;
- payload: { messageId: string; text: string };
- };
- expect(domainEvent.type).toBe("thread.message-sent");
- expect(domainEvent.payload.messageId).toBe("assistant:item-1");
- expect(domainEvent.payload.text).toBe("hello from runtime");
- });
-
- it("routes terminal RPC methods and broadcasts terminal events", async () => {
- const cwd = makeTempDir("t3code-ws-terminal-cwd-");
- const terminalManager = new MockTerminalManager();
- server = await createTestServer({
- cwd: "/test",
- terminalManager,
- });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const open = await sendRequest(ws, WS_METHODS.terminalOpen, {
- threadId: "thread-1",
- cwd,
- cols: 100,
- rows: 24,
- });
- expect(open.error).toBeUndefined();
- expect((open.result as TerminalSessionSnapshot).threadId).toBe("thread-1");
- expect((open.result as TerminalSessionSnapshot).terminalId).toBe(DEFAULT_TERMINAL_ID);
-
- const write = await sendRequest(ws, WS_METHODS.terminalWrite, {
- threadId: "thread-1",
- data: "echo hello\n",
- });
- expect(write.error).toBeUndefined();
-
- const resize = await sendRequest(ws, WS_METHODS.terminalResize, {
- threadId: "thread-1",
- cols: 120,
- rows: 30,
- });
- expect(resize.error).toBeUndefined();
-
- const clear = await sendRequest(ws, WS_METHODS.terminalClear, {
- threadId: "thread-1",
- });
- expect(clear.error).toBeUndefined();
-
- const restart = await sendRequest(ws, WS_METHODS.terminalRestart, {
- threadId: "thread-1",
- cwd,
- cols: 120,
- rows: 30,
- });
- expect(restart.error).toBeUndefined();
-
- const close = await sendRequest(ws, WS_METHODS.terminalClose, {
- threadId: "thread-1",
- deleteHistory: true,
- });
- expect(close.error).toBeUndefined();
-
- const manualEvent: TerminalEvent = {
- type: "output",
- threadId: "thread-1",
- terminalId: DEFAULT_TERMINAL_ID,
- createdAt: new Date().toISOString(),
- data: "manual test output\n",
- };
- terminalManager.emitEvent(manualEvent);
-
- const push = await waitForPush(
- ws,
- WS_CHANNELS.terminalEvent,
- (candidate) => (candidate.data as TerminalEvent).type === "output",
- );
- expect(push.type).toBe("push");
- expect(push.channel).toBe(WS_CHANNELS.terminalEvent);
- });
-
- it("shuts down cleanly for injected terminal managers", async () => {
- const terminalManager = new MockTerminalManager();
- server = await createTestServer({
- cwd: "/test",
- terminalManager,
- });
-
- await closeTestServer();
- server = null;
-
- expect(() =>
- terminalManager.emitEvent({
- type: "output",
- threadId: "thread-1",
- terminalId: DEFAULT_TERMINAL_ID,
- createdAt: new Date().toISOString(),
- data: "after shutdown\n",
- }),
- ).not.toThrow();
- });
-
- it("returns validation errors for invalid terminal open params", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.terminalOpen, {
- threadId: "",
- cwd: "",
- cols: 1,
- rows: 1,
- });
- expect(response.error).toBeDefined();
- });
-
- it("handles invalid JSON gracefully", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- // Send garbage
- ws.send("not json at all");
-
- // Error response goes to the response channel
- const channels = channelsBySocket.get(ws)!;
- let response: WebSocketResponse | null = null;
- for (let attempt = 0; attempt < 5; attempt += 1) {
- const message = await dequeue(channels.response, 5_000);
- if (message.id === "unknown") {
- response = message;
- break;
- }
- if (message.error) {
- response = message;
- break;
- }
- }
- expect(response).toBeDefined();
- expect(response!.error).toBeDefined();
- expect(response!.error!.message).toContain("Invalid request format");
- });
-
- it("catches websocket message handler rejections and keeps the socket usable", async () => {
- const unhandledRejections: unknown[] = [];
- const onUnhandledRejection = (reason: unknown) => {
- unhandledRejections.push(reason);
- };
- process.on("unhandledRejection", onUnhandledRejection);
-
- const brokenOpenService: OpenShape = {
- openBrowser: () => Effect.void,
- openInEditor: () =>
- Effect.sync(() => BigInt(1)).pipe(Effect.map((result) => result as unknown as void)),
- };
-
- try {
- server = await createTestServer({ cwd: "/test", open: brokenOpenService });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- ws.send(
- JSON.stringify({
- id: "req-broken-open",
- body: {
- _tag: WS_METHODS.shellOpenInEditor,
- cwd: "/tmp",
- editor: "cursor",
- },
- }),
- );
-
- await new Promise((resolve) => setTimeout(resolve, 50));
- expect(unhandledRejections).toHaveLength(0);
-
- const workspace = makeTempDir("t3code-ws-handler-still-usable-");
- fs.writeFileSync(path.join(workspace, "file.txt"), "ok\n", "utf8");
- const response = await sendRequest(ws, WS_METHODS.projectsSearchEntries, {
- cwd: workspace,
- query: "file",
- limit: 5,
- });
- expect(response.error).toBeUndefined();
- expect(response.result).toEqual(
- expect.objectContaining({
- entries: expect.arrayContaining([
- expect.objectContaining({
- path: "file.txt",
- kind: "file",
- }),
- ]),
- }),
- );
- } finally {
- process.off("unhandledRejection", onUnhandledRejection);
- }
- });
-
- it("returns errors for removed projects CRUD methods", async () => {
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const listResponse = await sendRequest(ws, WS_METHODS.projectsList);
- expect(listResponse.result).toBeUndefined();
- expect(listResponse.error?.message).toContain("Invalid request format");
-
- const addResponse = await sendRequest(ws, WS_METHODS.projectsAdd, {
- cwd: "/tmp/project-a",
- });
- expect(addResponse.result).toBeUndefined();
- expect(addResponse.error?.message).toContain("Invalid request format");
-
- const removeResponse = await sendRequest(ws, WS_METHODS.projectsRemove, {
- id: "project-a",
- });
- expect(removeResponse.result).toBeUndefined();
- expect(removeResponse.error?.message).toContain("Invalid request format");
- });
-
- it("supports projects.searchEntries", async () => {
- const workspace = makeTempDir("t3code-ws-workspace-entries-");
- fs.mkdirSync(path.join(workspace, "src", "components"), { recursive: true });
- fs.writeFileSync(
- path.join(workspace, "src", "components", "Composer.tsx"),
- "export {};",
- "utf8",
- );
- fs.writeFileSync(path.join(workspace, "README.md"), "# test", "utf8");
- fs.mkdirSync(path.join(workspace, ".git"), { recursive: true });
- fs.writeFileSync(path.join(workspace, ".git", "HEAD"), "ref: refs/heads/main\n", "utf8");
-
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.projectsSearchEntries, {
- cwd: workspace,
- query: "comp",
- limit: 10,
- });
- expect(response.error).toBeUndefined();
- expect(response.result).toEqual({
- entries: expect.arrayContaining([
- expect.objectContaining({ path: "src/components", kind: "directory" }),
- expect.objectContaining({ path: "src/components/Composer.tsx", kind: "file" }),
- ]),
- truncated: false,
- });
- });
-
- it("supports projects.writeFile within the workspace root", async () => {
- const workspace = makeTempDir("t3code-ws-write-file-");
-
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.projectsWriteFile, {
- cwd: workspace,
- relativePath: "plans/effect-rpc.md",
- contents: "# Plan\n\n- step 1\n",
- });
-
- expect(response.error).toBeUndefined();
- expect(response.result).toEqual({
- relativePath: "plans/effect-rpc.md",
- });
- expect(fs.readFileSync(path.join(workspace, "plans", "effect-rpc.md"), "utf8")).toBe(
- "# Plan\n\n- step 1\n",
- );
- });
-
- it("invalidates workspace entry search cache after projects.writeFile", async () => {
- const workspace = makeTempDir("t3code-ws-write-file-invalidate-");
- fs.mkdirSync(path.join(workspace, "src"), { recursive: true });
- fs.writeFileSync(path.join(workspace, "src", "existing.ts"), "export {};\n", "utf8");
-
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const beforeWrite = await sendRequest(ws, WS_METHODS.projectsSearchEntries, {
- cwd: workspace,
- query: "rpc",
- limit: 10,
- });
- expect(beforeWrite.error).toBeUndefined();
- expect(beforeWrite.result).toEqual({
- entries: [],
- truncated: false,
- });
-
- const writeResponse = await sendRequest(ws, WS_METHODS.projectsWriteFile, {
- cwd: workspace,
- relativePath: "plans/effect-rpc.md",
- contents: "# Plan\n",
- });
- expect(writeResponse.error).toBeUndefined();
-
- const afterWrite = await sendRequest(ws, WS_METHODS.projectsSearchEntries, {
- cwd: workspace,
- query: "rpc",
- limit: 10,
- });
- expect(afterWrite.error).toBeUndefined();
- expect(afterWrite.result).toEqual({
- entries: expect.arrayContaining([
- expect.objectContaining({ path: "plans/effect-rpc.md", kind: "file" }),
- ]),
- truncated: false,
- });
- });
-
- it("rejects projects.writeFile paths outside the workspace root", async () => {
- const workspace = makeTempDir("t3code-ws-write-file-reject-");
-
- server = await createTestServer({ cwd: "/test" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.projectsWriteFile, {
- cwd: workspace,
- relativePath: "../escape.md",
- contents: "# no\n",
- });
-
- expect(response.result).toBeUndefined();
- expect(response.error?.message).toContain(
- "Workspace file path must be relative to the project root: ../escape.md",
- );
- expect(fs.existsSync(path.join(workspace, "..", "escape.md"))).toBe(false);
- });
-
- it("routes git core methods over websocket", async () => {
- const listBranches = vi.fn(() =>
- Effect.succeed({
- branches: [],
- isRepo: false,
- hasOriginRemote: false,
- }),
- );
- const initRepo = vi.fn(() => Effect.void);
- const pullCurrentBranch = vi.fn(() =>
- Effect.fail(
- new GitCommandError({
- operation: "GitCore.test.pullCurrentBranch",
- detail: "No upstream configured",
- command: "git pull",
- cwd: "/repo/path",
- }),
- ),
- );
-
- server = await createTestServer({
- cwd: "/test",
- gitCore: {
- listBranches,
- initRepo,
- pullCurrentBranch,
- },
- });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const listResponse = await sendRequest(ws, WS_METHODS.gitListBranches, { cwd: "/repo/path" });
- expect(listResponse.error).toBeUndefined();
- expect(listResponse.result).toEqual({ branches: [], isRepo: false, hasOriginRemote: false });
- expect(listBranches).toHaveBeenCalledWith({ cwd: "/repo/path" });
-
- const initResponse = await sendRequest(ws, WS_METHODS.gitInit, { cwd: "/repo/path" });
- expect(initResponse.error).toBeUndefined();
- expect(initRepo).toHaveBeenCalledWith({ cwd: "/repo/path" });
-
- const pullResponse = await sendRequest(ws, WS_METHODS.gitPull, { cwd: "/repo/path" });
- expect(pullResponse.result).toBeUndefined();
- expect(pullResponse.error?.message).toContain("No upstream configured");
- expect(pullCurrentBranch).toHaveBeenCalledWith("/repo/path");
- });
-
- it("supports git.status over websocket", async () => {
- const statusResult = {
- branch: "feature/test",
- hasWorkingTreeChanges: true,
- workingTree: {
- files: [{ path: "src/index.ts", insertions: 7, deletions: 2 }],
- insertions: 7,
- deletions: 2,
- },
- hasUpstream: false,
- aheadCount: 0,
- behindCount: 0,
- pr: null,
- };
-
- const status = vi.fn(() => Effect.succeed(statusResult));
- const runStackedAction = vi.fn(() => Effect.void as any);
- const resolvePullRequest = vi.fn(() => Effect.void as any);
- const preparePullRequestThread = vi.fn(() => Effect.void as any);
- const gitManager: GitManagerShape = {
- status,
- resolvePullRequest,
- preparePullRequestThread,
- runStackedAction,
- };
-
- server = await createTestServer({ cwd: "/test", gitManager });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.gitStatus, {
- cwd: "/test",
- });
- expect(response.error).toBeUndefined();
- expect(response.result).toEqual(statusResult);
- expect(status).toHaveBeenCalledWith({ cwd: "/test" });
- });
-
- it("supports git pull request routing over websocket", async () => {
- const resolvePullRequestResult = {
- pullRequest: {
- number: 42,
- title: "PR thread flow",
- url: "https://github.com/pingdotgg/codething-mvp/pull/42",
- baseBranch: "main",
- headBranch: "feature/pr-threads",
- state: "open" as const,
- },
- };
- const preparePullRequestThreadResult = {
- ...resolvePullRequestResult,
- branch: "feature/pr-threads",
- worktreePath: "/tmp/pr-threads",
- };
-
- const gitManager: GitManagerShape = {
- status: vi.fn(() => Effect.void as any),
- resolvePullRequest: vi.fn(() => Effect.succeed(resolvePullRequestResult)),
- preparePullRequestThread: vi.fn(() => Effect.succeed(preparePullRequestThreadResult)),
- runStackedAction: vi.fn(() => Effect.void as any),
- };
-
- server = await createTestServer({ cwd: "/test", gitManager });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const resolveResponse = await sendRequest(ws, WS_METHODS.gitResolvePullRequest, {
- cwd: "/test",
- reference: "#42",
- });
- expect(resolveResponse.error).toBeUndefined();
- expect(resolveResponse.result).toEqual(resolvePullRequestResult);
-
- const prepareResponse = await sendRequest(ws, WS_METHODS.gitPreparePullRequestThread, {
- cwd: "/test",
- reference: "42",
- mode: "worktree",
- });
- expect(prepareResponse.error).toBeUndefined();
- expect(prepareResponse.result).toEqual(preparePullRequestThreadResult);
- expect(gitManager.resolvePullRequest).toHaveBeenCalledWith({
- cwd: "/test",
- reference: "#42",
- });
- expect(gitManager.preparePullRequestThread).toHaveBeenCalledWith({
- cwd: "/test",
- reference: "42",
- mode: "worktree",
- });
- });
-
- it("returns errors from git.runStackedAction", async () => {
- const runStackedAction = vi.fn(() =>
- Effect.fail(
- new GitManagerError({
- operation: "GitManager.test.runStackedAction",
- detail: "Cannot push from detached HEAD.",
- }),
- ),
- );
- const gitManager: GitManagerShape = {
- status: vi.fn(() => Effect.void as any),
- resolvePullRequest: vi.fn(() => Effect.void as any),
- preparePullRequestThread: vi.fn(() => Effect.void as any),
- runStackedAction,
- };
-
- server = await createTestServer({ cwd: "/test", gitManager });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [ws] = await connectAndAwaitWelcome(port);
- connections.push(ws);
-
- const response = await sendRequest(ws, WS_METHODS.gitRunStackedAction, {
- actionId: "client-action-1",
- cwd: "/test",
- action: "commit_push",
- modelSelection: {
- provider: "codex",
- model: "gpt-5.4-mini",
- },
- });
- expect(response.result).toBeUndefined();
- expect(response.error?.message).toContain("detached HEAD");
- expect(runStackedAction).toHaveBeenCalledWith(
- {
- actionId: "client-action-1",
- cwd: "/test",
- action: "commit_push",
- },
- expect.objectContaining({
- actionId: "client-action-1",
- progressReporter: expect.any(Object),
- }),
- );
- });
-
- it("publishes git action progress only to the initiating websocket", async () => {
- const runStackedAction = vi.fn(
- (_input, options) =>
- options?.progressReporter
- ?.publish({
- actionId: options.actionId ?? "action-1",
- cwd: "/test",
- action: "commit",
- kind: "phase_started",
- phase: "commit",
- label: "Committing...",
- })
- .pipe(
- Effect.flatMap(() =>
- Effect.succeed({
- action: "commit" as const,
- branch: { status: "skipped_not_requested" as const },
- commit: {
- status: "created" as const,
- commitSha: "abc1234",
- subject: "Test commit",
- },
- push: { status: "skipped_not_requested" as const },
- pr: { status: "skipped_not_requested" as const },
- }),
- ),
- ) ?? Effect.void,
- );
- const gitManager: GitManagerShape = {
- status: vi.fn(() => Effect.void as any),
- resolvePullRequest: vi.fn(() => Effect.void as any),
- preparePullRequestThread: vi.fn(() => Effect.void as any),
- runStackedAction,
- };
-
- server = await createTestServer({ cwd: "/test", gitManager });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- const [initiatingWs] = await connectAndAwaitWelcome(port);
- const [otherWs] = await connectAndAwaitWelcome(port);
- connections.push(initiatingWs, otherWs);
-
- const responsePromise = sendRequest(initiatingWs, WS_METHODS.gitRunStackedAction, {
- actionId: "client-action-2",
- cwd: "/test",
- action: "commit",
- modelSelection: {
- provider: "codex",
- model: "gpt-5.4-mini",
- },
- });
- const progressPush = await waitForPush(initiatingWs, WS_CHANNELS.gitActionProgress);
-
- expect(progressPush.data).toEqual({
- actionId: "client-action-2",
- cwd: "/test",
- action: "commit",
- kind: "phase_started",
- phase: "commit",
- label: "Committing...",
- });
-
- await expect(
- waitForPush(otherWs, WS_CHANNELS.gitActionProgress, undefined, 10, 100),
- ).rejects.toThrow("Timed out waiting for WebSocket message after 100ms");
- await expect(responsePromise).resolves.toEqual(
- expect.objectContaining({
- result: expect.objectContaining({
- action: "commit",
- }),
- }),
- );
- });
-
- it("rejects websocket connections without a valid auth token", async () => {
- server = await createTestServer({ cwd: "/test", authToken: "secret-token" });
- const addr = server.address();
- const port = typeof addr === "object" && addr !== null ? addr.port : 0;
-
- await expect(connectWs(port)).rejects.toThrow("WebSocket connection failed");
-
- const [authorizedWs] = await connectAndAwaitWelcome(port, "secret-token");
- connections.push(authorizedWs);
- });
-});
diff --git a/apps/server/src/wsServer.ts b/apps/server/src/wsServer.ts
deleted file mode 100644
index b9fd7e58d..000000000
--- a/apps/server/src/wsServer.ts
+++ /dev/null
@@ -1,998 +0,0 @@
-/**
- * Server - HTTP/WebSocket server service interface.
- *
- * Owns startup and shutdown lifecycle of the HTTP server, static asset serving,
- * and WebSocket request routing.
- *
- * @module Server
- */
-import http from "node:http";
-import type { Duplex } from "node:stream";
-
-import Mime from "@effect/platform-node/Mime";
-import {
- CommandId,
- DEFAULT_PROVIDER_INTERACTION_MODE,
- type ClientOrchestrationCommand,
- type OrchestrationCommand,
- ORCHESTRATION_WS_CHANNELS,
- ORCHESTRATION_WS_METHODS,
- PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
- ProjectId,
- ThreadId,
- WS_CHANNELS,
- WS_METHODS,
- WebSocketRequest,
- type WsResponse as WsResponseMessage,
- WsResponse,
- type WsPushEnvelopeBase,
-} from "@t3tools/contracts";
-import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
-import {
- Cause,
- Effect,
- Exit,
- FileSystem,
- Layer,
- Path,
- Ref,
- Result,
- Schema,
- Scope,
- ServiceMap,
- Stream,
- Struct,
-} from "effect";
-import { WebSocketServer, type WebSocket } from "ws";
-
-import { createLogger } from "./logger";
-import { GitManager } from "./git/Services/GitManager.ts";
-import { TerminalManager } from "./terminal/Services/Manager.ts";
-import { Keybindings } from "./keybindings";
-import { ServerSettingsService } from "./serverSettings";
-import { OrchestrationEngineService } from "./orchestration/Services/OrchestrationEngine";
-import { ProjectionSnapshotQuery } from "./orchestration/Services/ProjectionSnapshotQuery";
-import { OrchestrationReactor } from "./orchestration/Services/OrchestrationReactor";
-import { ProviderService } from "./provider/Services/ProviderService";
-import { ProviderRegistry } from "./provider/Services/ProviderRegistry";
-import { CheckpointDiffQuery } from "./checkpointing/Services/CheckpointDiffQuery";
-import { clamp } from "effect/Number";
-import { Open, resolveAvailableEditors } from "./open";
-import { ServerConfig } from "./config";
-import { GitCore } from "./git/Services/GitCore.ts";
-import { tryHandleProjectFaviconRequest } from "./projectFaviconRoute";
-import {
- ATTACHMENTS_ROUTE_PREFIX,
- normalizeAttachmentRelativePath,
- resolveAttachmentRelativePath,
-} from "./attachmentPaths";
-
-import {
- createAttachmentId,
- resolveAttachmentPath,
- resolveAttachmentPathById,
-} from "./attachmentStore.ts";
-import { parseBase64DataUrl } from "./imageMime.ts";
-import { AnalyticsService } from "./telemetry/Services/AnalyticsService.ts";
-import { makeServerPushBus } from "./wsServer/pushBus.ts";
-import { makeServerReadiness } from "./wsServer/readiness.ts";
-import { decodeJsonResult, formatSchemaError } from "@t3tools/shared/schemaJson";
-import { ProjectFaviconResolver } from "./project/Services/ProjectFaviconResolver.ts";
-import { WorkspaceEntries } from "./workspace/Services/WorkspaceEntries.ts";
-import { WorkspaceFileSystem } from "./workspace/Services/WorkspaceFileSystem.ts";
-import { WorkspacePaths } from "./workspace/Services/WorkspacePaths.ts";
-
-/**
- * ServerShape - Service API for server lifecycle control.
- */
-export interface ServerShape {
- /**
- * Start HTTP and WebSocket listeners.
- */
- readonly start: Effect.Effect<
- http.Server,
- ServerLifecycleError,
- Scope.Scope | ServerRuntimeServices | ServerConfig | FileSystem.FileSystem | Path.Path
- >;
-
- /**
- * Wait for process shutdown signals.
- */
- readonly stopSignal: Effect.Effect<void, never>;
-}
-
-/**
- * Server - Service tag for HTTP/WebSocket lifecycle management.
- */
-export class Server extends ServiceMap.Service<Server, ServerShape>()("t3/wsServer/Server") {}
-
-const isServerNotRunningError = (error: Error): boolean => {
- const maybeCode = (error as NodeJS.ErrnoException).code;
- return (
- maybeCode === "ERR_SERVER_NOT_RUNNING" || error.message.toLowerCase().includes("not running")
- );
-};
-
-function rejectUpgrade(socket: Duplex, statusCode: number, message: string): void {
- socket.end(
- `HTTP/1.1 ${statusCode} ${statusCode === 401 ? "Unauthorized" : "Bad Request"}\r\n` +
- "Connection: close\r\n" +
- "Content-Type: text/plain\r\n" +
- `Content-Length: ${Buffer.byteLength(message)}\r\n` +
- "\r\n" +
- message,
- );
-}
-
-function websocketRawToString(raw: unknown): string | null {
- if (typeof raw === "string") {
- return raw;
- }
- if (raw instanceof Uint8Array) {
- return Buffer.from(raw).toString("utf8");
- }
- if (raw instanceof ArrayBuffer) {
- return Buffer.from(new Uint8Array(raw)).toString("utf8");
- }
- if (Array.isArray(raw)) {
- const chunks: string[] = [];
- for (const chunk of raw) {
- if (typeof chunk === "string") {
- chunks.push(chunk);
- continue;
- }
- if (chunk instanceof Uint8Array) {
- chunks.push(Buffer.from(chunk).toString("utf8"));
- continue;
- }
- if (chunk instanceof ArrayBuffer) {
- chunks.push(Buffer.from(new Uint8Array(chunk)).toString("utf8"));
- continue;
- }
- return null;
- }
- return chunks.join("");
- }
- return null;
-}
-
-function stripRequestTag<T extends { _tag: string }>(body: T) {
- return Struct.omit(body, ["_tag"]);
-}
-
-const encodeWsResponse = Schema.encodeEffect(Schema.fromJsonString(WsResponse));
-const decodeWebSocketRequest = decodeJsonResult(WebSocketRequest);
-
-export type ServerCoreRuntimeServices =
- | OrchestrationEngineService
- | ProjectionSnapshotQuery
- | CheckpointDiffQuery
- | OrchestrationReactor
- | ProviderService
- | ProviderRegistry;
-
-export type ServerRuntimeServices =
- | ServerCoreRuntimeServices
- | GitManager
- | GitCore
- | TerminalManager
- | Keybindings
- | ServerSettingsService
- | ProjectFaviconResolver
- | WorkspaceEntries
- | WorkspaceFileSystem
- | WorkspacePaths
- | Open
- | AnalyticsService;
-
-export class ServerLifecycleError extends Schema.TaggedErrorClass<ServerLifecycleError>()(
- "ServerLifecycleError",
- {
- operation: Schema.String,
- cause: Schema.optional(Schema.Defect),
- },
-) {}
-
-class RouteRequestError extends Schema.TaggedErrorClass<RouteRequestError>()("RouteRequestError", {
- message: Schema.String,
-}) {}
-
-export const createServer = Effect.fn(function* (): Effect.fn.Return<
- http.Server,
- ServerLifecycleError,
- Scope.Scope | ServerRuntimeServices | ServerConfig | FileSystem.FileSystem | Path.Path
-> {
- const serverConfig = yield* ServerConfig;
- const {
- port,
- cwd,
- keybindingsConfigPath,
- staticDir,
- devUrl,
- authToken,
- host,
- logWebSocketEvents,
- autoBootstrapProjectFromCwd,
- } = serverConfig;
- const availableEditors = resolveAvailableEditors();
-
- const runtimeServices = yield* Effect.services<
- ServerRuntimeServices | ServerConfig | FileSystem.FileSystem | Path.Path
- >();
- const runPromise = Effect.runPromiseWith(runtimeServices);
-
- const gitManager = yield* GitManager;
- const terminalManager = yield* TerminalManager;
- const keybindingsManager = yield* Keybindings;
- const serverSettingsManager = yield* ServerSettingsService;
- const providerRegistry = yield* ProviderRegistry;
- const git = yield* GitCore;
- const workspaceEntries = yield* WorkspaceEntries;
- const workspaceFileSystem = yield* WorkspaceFileSystem;
- const workspacePaths = yield* WorkspacePaths;
- const fileSystem = yield* FileSystem.FileSystem;
- const path = yield* Path.Path;
-
- yield* keybindingsManager.syncDefaultKeybindingsOnStartup.pipe(
- Effect.catch((error) =>
- Effect.logWarning("failed to sync keybindings defaults on startup", {
- path: error.configPath,
- detail: error.detail,
- cause: error.cause,
- }),
- ),
- );
-
- const providersRef = yield* Ref.make(yield* providerRegistry.getProviders);
-
- const clients = yield* Ref.make(new Set<WebSocket>());
- const logger = createLogger("ws");
- const readiness = yield* makeServerReadiness;
-
- function logOutgoingPush(push: WsPushEnvelopeBase, recipients: number) {
- if (!logWebSocketEvents) return;
- logger.event("outgoing push", {
- channel: push.channel,
- sequence: push.sequence,
- recipients,
- payload: push.data,
- });
- }
-
- const pushBus = yield* makeServerPushBus({
- clients,
- logOutgoingPush,
- });
- yield* readiness.markPushBusReady;
- yield* keybindingsManager.start.pipe(
- Effect.mapError(
- (cause) => new ServerLifecycleError({ operation: "keybindingsRuntimeStart", cause }),
- ),
- );
- yield* readiness.markKeybindingsReady;
- yield* serverSettingsManager.start.pipe(
- Effect.mapError(
- (cause) => new ServerLifecycleError({ operation: "serverSettingsRuntimeStart", cause }),
- ),
- );
-
- const normalizeDispatchCommand = Effect.fnUntraced(function* (input: {
- readonly command: ClientOrchestrationCommand;
- }) {
- if (input.command.type === "project.create") {
- return {
- ...input.command,
- workspaceRoot: yield* workspacePaths
- .normalizeWorkspaceRoot(input.command.workspaceRoot)
- .pipe(Effect.mapError((cause) => new RouteRequestError({ message: cause.message }))),
- } satisfies OrchestrationCommand;
- }
-
- if (input.command.type === "project.meta.update" && input.command.workspaceRoot !== undefined) {
- return {
- ...input.command,
- workspaceRoot: yield* workspacePaths
- .normalizeWorkspaceRoot(input.command.workspaceRoot)
- .pipe(Effect.mapError((cause) => new RouteRequestError({ message: cause.message }))),
- } satisfies OrchestrationCommand;
- }
-
- if (input.command.type !== "thread.turn.start") {
- return input.command as OrchestrationCommand;
- }
- const turnStartCommand = input.command;
-
- const normalizedAttachments = yield* Effect.forEach(
- turnStartCommand.message.attachments,
- (attachment) =>
- Effect.gen(function* () {
- const parsed = parseBase64DataUrl(attachment.dataUrl);
- if (!parsed || !parsed.mimeType.startsWith("image/")) {
- return yield* new RouteRequestError({
- message: `Invalid image attachment payload for '${attachment.name}'.`,
- });
- }
-
- const bytes = Buffer.from(parsed.base64, "base64");
- if (bytes.byteLength === 0 || bytes.byteLength > PROVIDER_SEND_TURN_MAX_IMAGE_BYTES) {
- return yield* new RouteRequestError({
- message: `Image attachment '${attachment.name}' is empty or too large.`,
- });
- }
-
- const attachmentId = createAttachmentId(turnStartCommand.threadId);
- if (!attachmentId) {
- return yield* new RouteRequestError({
- message: "Failed to create a safe attachment id.",
- });
- }
-
- const persistedAttachment = {
- type: "image" as const,
- id: attachmentId,
- name: attachment.name,
- mimeType: parsed.mimeType.toLowerCase(),
- sizeBytes: bytes.byteLength,
- };
-
- const attachmentPath = resolveAttachmentPath({
- attachmentsDir: serverConfig.attachmentsDir,
- attachment: persistedAttachment,
- });
- if (!attachmentPath) {
- return yield* new RouteRequestError({
- message: `Failed to resolve persisted path for '${attachment.name}'.`,
- });
- }
-
- yield* fileSystem.makeDirectory(path.dirname(attachmentPath), { recursive: true }).pipe(
- Effect.mapError(
- () =>
- new RouteRequestError({
- message: `Failed to create attachment directory for '${attachment.name}'.`,
- }),
- ),
- );
- yield* fileSystem.writeFile(attachmentPath, bytes).pipe(
- Effect.mapError(
- () =>
- new RouteRequestError({
- message: `Failed to persist attachment '${attachment.name}'.`,
- }),
- ),
- );
-
- return persistedAttachment;
- }),
- { concurrency: 1 },
- );
-
- return {
- ...turnStartCommand,
- message: {
- ...turnStartCommand.message,
- attachments: normalizedAttachments,
- },
- } satisfies OrchestrationCommand;
- });
-
- // HTTP server — serves static files or redirects to Vite dev server
- const httpServer = http.createServer((req, res) => {
- const respond = (
- statusCode: number,
- headers: Record<string, string>,
- body?: string | Uint8Array,
- ) => {
- res.writeHead(statusCode, headers);
- res.end(body);
- };
-
- void runPromise(
- Effect.gen(function* () {
- const url = new URL(req.url ?? "/", `http://localhost:${port}`);
- if (yield* tryHandleProjectFaviconRequest(url, res)) {
- return;
- }
-
- if (url.pathname.startsWith(ATTACHMENTS_ROUTE_PREFIX)) {
- const rawRelativePath = url.pathname.slice(ATTACHMENTS_ROUTE_PREFIX.length);
- const normalizedRelativePath = normalizeAttachmentRelativePath(rawRelativePath);
- if (!normalizedRelativePath) {
- respond(400, { "Content-Type": "text/plain" }, "Invalid attachment path");
- return;
- }
-
- const isIdLookup =
- !normalizedRelativePath.includes("/") && !normalizedRelativePath.includes(".");
- const filePath = isIdLookup
- ? resolveAttachmentPathById({
- attachmentsDir: serverConfig.attachmentsDir,
- attachmentId: normalizedRelativePath,
- })
- : resolveAttachmentRelativePath({
- attachmentsDir: serverConfig.attachmentsDir,
- relativePath: normalizedRelativePath,
- });
- if (!filePath) {
- respond(
- isIdLookup ? 404 : 400,
- { "Content-Type": "text/plain" },
- isIdLookup ? "Not Found" : "Invalid attachment path",
- );
- return;
- }
-
- const fileInfo = yield* fileSystem
- .stat(filePath)
- .pipe(Effect.catch(() => Effect.succeed(null)));
- if (!fileInfo || fileInfo.type !== "File") {
- respond(404, { "Content-Type": "text/plain" }, "Not Found");
- return;
- }
-
- const contentType = Mime.getType(filePath) ?? "application/octet-stream";
- res.writeHead(200, {
- "Content-Type": contentType,
- "Cache-Control": "public, max-age=31536000, immutable",
- });
- const streamExit = yield* Stream.runForEach(fileSystem.stream(filePath), (chunk) =>
- Effect.sync(() => {
- if (!res.destroyed) {
- res.write(chunk);
- }
- }),
- ).pipe(Effect.exit);
- if (Exit.isFailure(streamExit)) {
- if (!res.destroyed) {
- res.destroy();
- }
- return;
- }
- if (!res.writableEnded) {
- res.end();
- }
- return;
- }
-
- // In dev mode, redirect to Vite dev server
- if (devUrl) {
- respond(302, { Location: devUrl.href });
- return;
- }
-
- // Serve static files from the web app build
- if (!staticDir) {
- respond(
- 503,
- { "Content-Type": "text/plain" },
- "No static directory configured and no dev URL set.",
- );
- return;
- }
-
- const staticRoot = path.resolve(staticDir);
- const staticRequestPath = url.pathname === "/" ? "/index.html" : url.pathname;
- const rawStaticRelativePath = staticRequestPath.replace(/^[/\\]+/, "");
- const hasRawLeadingParentSegment = rawStaticRelativePath.startsWith("..");
- const staticRelativePath = path.normalize(rawStaticRelativePath).replace(/^[/\\]+/, "");
- const hasPathTraversalSegment = staticRelativePath.startsWith("..");
- if (
- staticRelativePath.length === 0 ||
- hasRawLeadingParentSegment ||
- hasPathTraversalSegment ||
- staticRelativePath.includes("\0")
- ) {
- respond(400, { "Content-Type": "text/plain" }, "Invalid static file path");
- return;
- }
-
- const isWithinStaticRoot = (candidate: string) =>
- candidate === staticRoot ||
- candidate.startsWith(
- staticRoot.endsWith(path.sep) ? staticRoot : `${staticRoot}${path.sep}`,
- );
-
- let filePath = path.resolve(staticRoot, staticRelativePath);
- if (!isWithinStaticRoot(filePath)) {
- respond(400, { "Content-Type": "text/plain" }, "Invalid static file path");
- return;
- }
-
- const ext = path.extname(filePath);
- if (!ext) {
- filePath = path.resolve(filePath, "index.html");
- if (!isWithinStaticRoot(filePath)) {
- respond(400, { "Content-Type": "text/plain" }, "Invalid static file path");
- return;
- }
- }
-
- const fileInfo = yield* fileSystem
- .stat(filePath)
- .pipe(Effect.catch(() => Effect.succeed(null)));
- if (!fileInfo || fileInfo.type !== "File") {
- const indexPath = path.resolve(staticRoot, "index.html");
- const indexData = yield* fileSystem
- .readFile(indexPath)
- .pipe(Effect.catch(() => Effect.succeed(null)));
- if (!indexData) {
- respond(404, { "Content-Type": "text/plain" }, "Not Found");
- return;
- }
- respond(200, { "Content-Type": "text/html; charset=utf-8" }, indexData);
- return;
- }
-
- const contentType = Mime.getType(filePath) ?? "application/octet-stream";
- const data = yield* fileSystem
- .readFile(filePath)
- .pipe(Effect.catch(() => Effect.succeed(null)));
- if (!data) {
- respond(500, { "Content-Type": "text/plain" }, "Internal Server Error");
- return;
- }
- respond(200, { "Content-Type": contentType }, data);
- }),
- ).catch(() => {
- if (!res.headersSent) {
- respond(500, { "Content-Type": "text/plain" }, "Internal Server Error");
- }
- });
- });
-
- // WebSocket server — upgrades from the HTTP server
- const wss = new WebSocketServer({ noServer: true });
-
- const closeWebSocketServer = Effect.callback<void, ServerLifecycleError>((resume) => {
- wss.close((error) => {
- if (error && !isServerNotRunningError(error)) {
- resume(
- Effect.fail(
- new ServerLifecycleError({ operation: "closeWebSocketServer", cause: error }),
- ),
- );
- } else {
- resume(Effect.void);
- }
- });
- });
-
- const closeAllClients = Ref.get(clients).pipe(
- Effect.flatMap(Effect.forEach((client) => Effect.sync(() => client.close()))),
- Effect.flatMap(() => Ref.set(clients, new Set())),
- );
-
- const listenOptions = host ? { host, port } : { port };
-
- const orchestrationEngine = yield* OrchestrationEngineService;
- const projectionReadModelQuery = yield* ProjectionSnapshotQuery;
- const checkpointDiffQuery = yield* CheckpointDiffQuery;
- const orchestrationReactor = yield* OrchestrationReactor;
- const { openInEditor } = yield* Open;
-
- const subscriptionsScope = yield* Scope.make("sequential");
- yield* Effect.addFinalizer(() => Scope.close(subscriptionsScope, Exit.void));
-
- yield* Stream.runForEach(orchestrationEngine.streamDomainEvents, (event) =>
- pushBus.publishAll(ORCHESTRATION_WS_CHANNELS.domainEvent, event),
- ).pipe(Effect.forkIn(subscriptionsScope));
-
- yield* Stream.runForEach(keybindingsManager.streamChanges, (event) =>
- pushBus.publishAll(WS_CHANNELS.serverConfigUpdated, {
- issues: event.issues,
- }),
- ).pipe(Effect.forkIn(subscriptionsScope));
-
- yield* Stream.runForEach(serverSettingsManager.streamChanges, (settings) =>
- pushBus.publishAll(WS_CHANNELS.serverConfigUpdated, {
- issues: [],
- settings,
- }),
- ).pipe(Effect.forkIn(subscriptionsScope));
-
- yield* Stream.runForEach(providerRegistry.streamChanges, (providers) =>
- Effect.gen(function* () {
- yield* Ref.set(providersRef, providers);
- yield* pushBus.publishAll(WS_CHANNELS.serverProvidersUpdated, {
- providers,
- });
- }),
- ).pipe(Effect.forkIn(subscriptionsScope));
-
- yield* Scope.provide(orchestrationReactor.start(), subscriptionsScope);
- yield* readiness.markOrchestrationSubscriptionsReady;
-
- let welcomeBootstrapProjectId: ProjectId | undefined;
- let welcomeBootstrapThreadId: ThreadId | undefined;
-
- if (autoBootstrapProjectFromCwd) {
- yield* Effect.gen(function* () {
- const snapshot = yield* projectionReadModelQuery.getSnapshot();
- const existingProject = snapshot.projects.find(
- (project) => project.workspaceRoot === cwd && project.deletedAt === null,
- );
- let bootstrapProjectId: ProjectId;
- let bootstrapProjectDefaultModelSelection;
-
- if (!existingProject) {
- const createdAt = new Date().toISOString();
- bootstrapProjectId = ProjectId.makeUnsafe(crypto.randomUUID());
- const bootstrapProjectTitle = path.basename(cwd) || "project";
- bootstrapProjectDefaultModelSelection = {
- provider: "codex" as const,
- model: "gpt-5-codex",
- };
- yield* orchestrationEngine.dispatch({
- type: "project.create",
- commandId: CommandId.makeUnsafe(crypto.randomUUID()),
- projectId: bootstrapProjectId,
- title: bootstrapProjectTitle,
- workspaceRoot: cwd,
- defaultModelSelection: bootstrapProjectDefaultModelSelection,
- createdAt,
- });
- } else {
- bootstrapProjectId = existingProject.id;
- bootstrapProjectDefaultModelSelection = existingProject.defaultModelSelection ?? {
- provider: "codex" as const,
- model: "gpt-5-codex",
- };
- }
-
- const existingThread = snapshot.threads.find(
- (thread) => thread.projectId === bootstrapProjectId && thread.deletedAt === null,
- );
- if (!existingThread) {
- const createdAt = new Date().toISOString();
- const threadId = ThreadId.makeUnsafe(crypto.randomUUID());
- yield* orchestrationEngine.dispatch({
- type: "thread.create",
- commandId: CommandId.makeUnsafe(crypto.randomUUID()),
- threadId,
- projectId: bootstrapProjectId,
- title: "New thread",
- modelSelection: bootstrapProjectDefaultModelSelection,
- interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
- runtimeMode: "full-access",
- branch: null,
- worktreePath: null,
- createdAt,
- });
- welcomeBootstrapProjectId = bootstrapProjectId;
- welcomeBootstrapThreadId = threadId;
- } else {
- welcomeBootstrapProjectId = bootstrapProjectId;
- welcomeBootstrapThreadId = existingThread.id;
- }
- }).pipe(
- Effect.mapError(
- (cause) => new ServerLifecycleError({ operation: "autoBootstrapProject", cause }),
- ),
- );
- }
-
- const unsubscribeTerminalEvents = yield* terminalManager.subscribe((event) =>
- pushBus.publishAll(WS_CHANNELS.terminalEvent, event),
- );
- yield* Scope.addFinalizer(subscriptionsScope, Effect.sync(unsubscribeTerminalEvents));
- yield* readiness.markTerminalSubscriptionsReady;
-
- yield* NodeHttpServer.make(() => httpServer, listenOptions).pipe(
- Effect.mapError((cause) => new ServerLifecycleError({ operation: "httpServerListen", cause })),
- );
- yield* readiness.markHttpListening;
-
- yield* Effect.addFinalizer(() =>
- Effect.all([closeAllClients, closeWebSocketServer.pipe(Effect.ignoreCause({ log: true }))]),
- );
-
- const routeRequest = Effect.fnUntraced(function* (ws: WebSocket, request: WebSocketRequest) {
- switch (request.body._tag) {
- case ORCHESTRATION_WS_METHODS.getSnapshot:
- return yield* projectionReadModelQuery.getSnapshot();
-
- case ORCHESTRATION_WS_METHODS.dispatchCommand: {
- const { command } = request.body;
- const normalizedCommand = yield* normalizeDispatchCommand({ command });
- return yield* orchestrationEngine.dispatch(normalizedCommand);
- }
-
- case ORCHESTRATION_WS_METHODS.getTurnDiff: {
- const body = stripRequestTag(request.body);
- return yield* checkpointDiffQuery.getTurnDiff(body);
- }
-
- case ORCHESTRATION_WS_METHODS.getFullThreadDiff: {
- const body = stripRequestTag(request.body);
- return yield* checkpointDiffQuery.getFullThreadDiff(body);
- }
-
- case ORCHESTRATION_WS_METHODS.replayEvents: {
- const { fromSequenceExclusive } = request.body;
- return yield* Stream.runCollect(
- orchestrationEngine.readEvents(
- clamp(fromSequenceExclusive, {
- maximum: Number.MAX_SAFE_INTEGER,
- minimum: 0,
- }),
- ),
- ).pipe(Effect.map((events) => Array.from(events)));
- }
-
- case WS_METHODS.projectsSearchEntries: {
- const body = stripRequestTag(request.body);
- return yield* workspaceEntries.search(body).pipe(
- Effect.mapError(
- (cause) =>
- new RouteRequestError({
- message: `Failed to search workspace entries: ${cause.detail}`,
- }),
- ),
- );
- }
-
- case WS_METHODS.projectsWriteFile: {
- const body = stripRequestTag(request.body);
- return yield* workspaceFileSystem.writeFile(body).pipe(
- Effect.mapError(
- (cause) =>
- new RouteRequestError({
- message: `Failed to write workspace file: ${cause.message}`,
- }),
- ),
- );
- }
-
- case WS_METHODS.shellOpenInEditor: {
- const body = stripRequestTag(request.body);
- return yield* openInEditor(body);
- }
-
- case WS_METHODS.gitStatus: {
- const body = stripRequestTag(request.body);
- return yield* gitManager.status(body);
- }
-
- case WS_METHODS.gitPull: {
- const body = stripRequestTag(request.body);
- return yield* git.pullCurrentBranch(body.cwd);
- }
-
- case WS_METHODS.gitRunStackedAction: {
- const body = stripRequestTag(request.body);
- return yield* gitManager.runStackedAction(body, {
- actionId: body.actionId,
- progressReporter: {
- publish: (event) =>
- pushBus.publishClient(ws, WS_CHANNELS.gitActionProgress, event).pipe(Effect.asVoid),
- },
- });
- }
-
- case WS_METHODS.gitResolvePullRequest: {
- const body = stripRequestTag(request.body);
- return yield* gitManager.resolvePullRequest(body);
- }
-
- case WS_METHODS.gitPreparePullRequestThread: {
- const body = stripRequestTag(request.body);
- return yield* gitManager.preparePullRequestThread(body);
- }
-
- case WS_METHODS.gitListBranches: {
- const body = stripRequestTag(request.body);
- return yield* git.listBranches(body);
- }
-
- case WS_METHODS.gitCreateWorktree: {
- const body = stripRequestTag(request.body);
- return yield* git.createWorktree(body);
- }
-
- case WS_METHODS.gitRemoveWorktree: {
- const body = stripRequestTag(request.body);
- return yield* git.removeWorktree(body);
- }
-
- case WS_METHODS.gitCreateBranch: {
- const body = stripRequestTag(request.body);
- return yield* git.createBranch(body);
- }
-
- case WS_METHODS.gitCheckout: {
- const body = stripRequestTag(request.body);
- return yield* Effect.scoped(git.checkoutBranch(body));
- }
-
- case WS_METHODS.gitInit: {
- const body = stripRequestTag(request.body);
- return yield* git.initRepo(body);
- }
-
- case WS_METHODS.terminalOpen: {
- const body = stripRequestTag(request.body);
- return yield* terminalManager.open(body);
- }
-
- case WS_METHODS.terminalWrite: {
- const body = stripRequestTag(request.body);
- return yield* terminalManager.write(body);
- }
-
- case WS_METHODS.terminalResize: {
- const body = stripRequestTag(request.body);
- return yield* terminalManager.resize(body);
- }
-
- case WS_METHODS.terminalClear: {
- const body = stripRequestTag(request.body);
- return yield* terminalManager.clear(body);
- }
-
- case WS_METHODS.terminalRestart: {
- const body = stripRequestTag(request.body);
- return yield* terminalManager.restart(body);
- }
-
- case WS_METHODS.terminalClose: {
- const body = stripRequestTag(request.body);
- return yield* terminalManager.close(body);
- }
-
- case WS_METHODS.serverGetConfig: {
- const keybindingsConfig = yield* keybindingsManager.loadConfigState;
- const settings = yield* serverSettingsManager.getSettings;
- const providers = yield* Ref.get(providersRef);
- return {
- cwd,
- keybindingsConfigPath,
- keybindings: keybindingsConfig.keybindings,
- issues: keybindingsConfig.issues,
- providers,
- availableEditors,
- settings,
- };
- }
-
- case WS_METHODS.serverRefreshProviders: {
- const providers = yield* providerRegistry.refresh();
- yield* Ref.set(providersRef, providers);
- return { providers };
- }
-
- case WS_METHODS.serverUpsertKeybinding: {
- const body = stripRequestTag(request.body);
- const keybindingsConfig = yield* keybindingsManager.upsertKeybindingRule(body);
- return { keybindings: keybindingsConfig, issues: [] };
- }
-
- case WS_METHODS.serverGetSettings: {
- return yield* serverSettingsManager.getSettings;
- }
-
- case WS_METHODS.serverUpdateSettings: {
- const body = stripRequestTag(request.body);
- return yield* serverSettingsManager.updateSettings(body.patch);
- }
-
- default: {
- const _exhaustiveCheck: never = request.body;
- return yield* new RouteRequestError({
- message: `Unknown method: ${String(_exhaustiveCheck)}`,
- });
- }
- }
- });
-
- const handleMessage = Effect.fnUntraced(function* (ws: WebSocket, raw: unknown) {
- const sendWsResponse = (response: WsResponseMessage) =>
- encodeWsResponse(response).pipe(
- Effect.tap((encodedResponse) => Effect.sync(() => ws.send(encodedResponse))),
- Effect.asVoid,
- );
-
- const messageText = websocketRawToString(raw);
- if (messageText === null) {
- return yield* sendWsResponse({
- id: "unknown",
- error: { message: "Invalid request format: Failed to read message" },
- });
- }
-
- const request = decodeWebSocketRequest(messageText);
- if (Result.isFailure(request)) {
- return yield* sendWsResponse({
- id: "unknown",
- error: { message: `Invalid request format: ${formatSchemaError(request.failure)}` },
- });
- }
-
- const result = yield* Effect.exit(routeRequest(ws, request.success));
- if (Exit.isFailure(result)) {
- return yield* sendWsResponse({
- id: request.success.id,
- error: { message: Cause.pretty(result.cause) },
- });
- }
-
- return yield* sendWsResponse({
- id: request.success.id,
- result: result.value,
- });
- });
-
- httpServer.on("upgrade", (request, socket, head) => {
- socket.on("error", () => {}); // Prevent unhandled `EPIPE`/`ECONNRESET` from crashing the process if the client disconnects mid-handshake
-
- if (authToken) {
- let providedToken: string | null = null;
- try {
- const url = new URL(request.url ?? "/", `http://localhost:${port}`);
- providedToken = url.searchParams.get("token");
- } catch {
- rejectUpgrade(socket, 400, "Invalid WebSocket URL");
- return;
- }
-
- if (providedToken !== authToken) {
- rejectUpgrade(socket, 401, "Unauthorized WebSocket connection");
- return;
- }
- }
-
- wss.handleUpgrade(request, socket, head, (ws) => {
- wss.emit("connection", ws, request);
- });
- });
-
- wss.on("connection", (ws) => {
- const segments = cwd.split(/[/\\]/).filter(Boolean);
- const projectName = segments[segments.length - 1] ?? "project";
-
- const welcomeData = {
- cwd,
- projectName,
- ...(welcomeBootstrapProjectId ? { bootstrapProjectId: welcomeBootstrapProjectId } : {}),
- ...(welcomeBootstrapThreadId ? { bootstrapThreadId: welcomeBootstrapThreadId } : {}),
- };
- // Send welcome before adding to broadcast set so publishAll calls
- // cannot reach this client before the welcome arrives.
- void runPromise(
- readiness.awaitServerReady.pipe(
- Effect.flatMap(() => pushBus.publishClient(ws, WS_CHANNELS.serverWelcome, welcomeData)),
- Effect.flatMap((delivered) =>
- delivered ? Ref.update(clients, (clients) => clients.add(ws)) : Effect.void,
- ),
- ),
- );
-
- ws.on("message", (raw) => {
- void runPromise(handleMessage(ws, raw).pipe(Effect.ignoreCause({ log: true })));
- });
-
- ws.on("close", () => {
- void runPromise(
- Ref.update(clients, (clients) => {
- clients.delete(ws);
- return clients;
- }),
- );
- });
-
- ws.on("error", () => {
- void runPromise(
- Ref.update(clients, (clients) => {
- clients.delete(ws);
- return clients;
- }),
- );
- });
- });
-
- return httpServer;
-});
-
-export const ServerLive = Layer.succeed(Server, {
- start: createServer(),
- stopSignal: Effect.never,
-} satisfies ServerShape);
diff --git a/apps/server/src/wsServer/pushBus.test.ts b/apps/server/src/wsServer/pushBus.test.ts
deleted file mode 100644
index 80e8be218..000000000
--- a/apps/server/src/wsServer/pushBus.test.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import type { WebSocket } from "ws";
-import { it } from "@effect/vitest";
-import { describe, expect } from "vitest";
-import { Effect, Ref } from "effect";
-import { WS_CHANNELS } from "@t3tools/contracts";
-
-import { makeServerPushBus } from "./pushBus";
-
-class MockWebSocket {
- static readonly OPEN = 1;
-
- readonly OPEN = MockWebSocket.OPEN;
- readyState = MockWebSocket.OPEN;
- readonly sent: string[] = [];
- private readonly waiters = new Set<() => void>();
-
- send(message: string) {
- this.sent.push(message);
- for (const waiter of this.waiters) {
- waiter();
- }
- }
-
- waitForSentCount(count: number): Promise<void> {
- if (this.sent.length >= count) {
- return Promise.resolve();
- }
-
- return new Promise((resolve) => {
- const check = () => {
- if (this.sent.length < count) {
- return;
- }
- this.waiters.delete(check);
- resolve();
- };
-
- this.waiters.add(check);
- });
- }
-}
-
-describe("makeServerPushBus", () => {
- it.live("waits for the welcome push before a new client joins broadcast delivery", () =>
- Effect.scoped(
- Effect.gen(function* () {
- const client = new MockWebSocket();
- const clients = yield* Ref.make(new Set<WebSocket>());
- const pushBus = yield* makeServerPushBus({
- clients,
- logOutgoingPush: () => {},
- });
-
- yield* pushBus.publishAll(WS_CHANNELS.serverConfigUpdated, {
- issues: [{ kind: "keybindings.malformed-config", message: "queued-before-connect" }],
- });
-
- const delivered = yield* pushBus.publishClient(
- client as unknown as WebSocket,
- WS_CHANNELS.serverWelcome,
- {
- cwd: "/tmp/project",
- projectName: "project",
- },
- );
- expect(delivered).toBe(true);
-
- yield* Ref.update(clients, (current) => current.add(client as unknown as WebSocket));
-
- yield* pushBus.publishAll(WS_CHANNELS.serverConfigUpdated, {
- issues: [],
- });
-
- yield* Effect.promise(() => client.waitForSentCount(2));
-
- const messages = client.sent.map(
- (message) => JSON.parse(message) as { channel: string; data: unknown },
- );
-
- expect(messages).toHaveLength(2);
- expect(messages[0]).toEqual({
- type: "push",
- sequence: 2,
- channel: WS_CHANNELS.serverWelcome,
- data: {
- cwd: "/tmp/project",
- projectName: "project",
- },
- });
- expect(messages[1]).toEqual({
- type: "push",
- sequence: 3,
- channel: WS_CHANNELS.serverConfigUpdated,
- data: {
- issues: [],
- },
- });
- }),
- ),
- );
-});
diff --git a/apps/server/src/wsServer/pushBus.ts b/apps/server/src/wsServer/pushBus.ts
deleted file mode 100644
index c2cd302f2..000000000
--- a/apps/server/src/wsServer/pushBus.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-import {
- WsPush,
- type WsPushChannel,
- type WsPushData,
- type WsPushEnvelopeBase,
-} from "@t3tools/contracts";
-import { Deferred, Effect, Queue, Ref, Schema } from "effect";
-import type { Scope } from "effect";
-import type { WebSocket } from "ws";
-
-type PushTarget =
- | { readonly kind: "all" }
- | { readonly kind: "client"; readonly client: WebSocket };
-
-interface PushJob<C extends WsPushChannel = WsPushChannel> {
- readonly channel: C;
- readonly data: WsPushData<C>;
- readonly target: PushTarget;
- readonly delivered: Deferred.Deferred<boolean> | null;
-}
-
-export interface ServerPushBus {
- readonly publishAll: <C extends WsPushChannel>(
- channel: C,
- data: WsPushData<C>,
- ) => Effect.Effect<void>;
- readonly publishClient: <C extends WsPushChannel>(
- client: WebSocket,
- channel: C,
- data: WsPushData<C>,
- ) => Effect.Effect<boolean>;
-}
-
-export const makeServerPushBus = (input: {
- readonly clients: Ref.Ref<Set<WebSocket>>;
- readonly logOutgoingPush: (push: WsPushEnvelopeBase, recipients: number) => void;
-}): Effect.Effect<ServerPushBus, never, Scope.Scope> =>
- Effect.gen(function* () {
- const nextSequence = yield* Ref.make(0);
- const queue = yield* Queue.unbounded<PushJob>();
- const encodePush = Schema.encodeUnknownEffect(Schema.fromJsonString(WsPush));
-
- const settleDelivery = (job: PushJob, delivered: boolean) =>
- job.delivered === null
- ? Effect.void
- : Deferred.succeed(job.delivered, delivered).pipe(Effect.orDie);
-
- const send = Effect.fnUntraced(function* (job: PushJob) {
- const sequence = yield* Ref.updateAndGet(nextSequence, (current) => current + 1);
- const push: WsPushEnvelopeBase = {
- type: "push",
- sequence,
- channel: job.channel,
- data: job.data,
- };
- const recipients =
- job.target.kind === "all" ? yield* Ref.get(input.clients) : new Set([job.target.client]);
-
- return yield* encodePush(push).pipe(
- Effect.map((message) => {
- let recipientCount = 0;
- for (const client of recipients) {
- if (client.readyState !== client.OPEN) {
- continue;
- }
- client.send(message);
- recipientCount += 1;
- }
-
- input.logOutgoingPush(push, recipientCount);
- return recipientCount > 0;
- }),
- );
- });
-
- yield* Effect.forkScoped(
- Effect.forever(
- Queue.take(queue).pipe(
- Effect.flatMap((job) =>
- send(job).pipe(
- Effect.tap((delivered) => settleDelivery(job, delivered)),
- Effect.tapCause(() => settleDelivery(job, false)),
- Effect.ignoreCause({ log: true }),
- ),
- ),
- ),
- ),
- );
-
- const publish =
- (target: PushTarget) =>
- <C extends WsPushChannel>(channel: C, data: WsPushData<C>) =>
- Queue.offer(queue, {
- channel,
- data,
- target,
- delivered: null,
- }).pipe(Effect.asVoid);
-
- return {
- publishAll: publish({ kind: "all" }),
- publishClient: (client, channel, data) =>
- Effect.gen(function* () {
- const delivered = yield* Deferred.make<boolean>();
- yield* Queue.offer(queue, {
- channel,
- data,
- target: { kind: "client", client },
- delivered,
- }).pipe(Effect.asVoid);
- return yield* Deferred.await(delivered);
- }),
- } satisfies ServerPushBus;
- });
diff --git a/apps/server/src/wsServer/readiness.ts b/apps/server/src/wsServer/readiness.ts
deleted file mode 100644
index 2a973a863..000000000
--- a/apps/server/src/wsServer/readiness.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { Deferred, Effect } from "effect";
-
-export interface ServerReadiness {
- readonly awaitServerReady: Effect.Effect<void>;
- readonly markHttpListening: Effect.Effect<void>;
- readonly markPushBusReady: Effect.Effect<void>;
- readonly markKeybindingsReady: Effect.Effect<void>;
- readonly markTerminalSubscriptionsReady: Effect.Effect<void>;
- readonly markOrchestrationSubscriptionsReady: Effect.Effect<void>;
-}
-
-export const makeServerReadiness = Effect.gen(function* () {
- const httpListening = yield* Deferred.make<void>();
- const pushBusReady = yield* Deferred.make<void>();
- const keybindingsReady = yield* Deferred.make<void>();
- const terminalSubscriptionsReady = yield* Deferred.make<void>();
- const orchestrationSubscriptionsReady = yield* Deferred.make<void>();
-
- const complete = (deferred: Deferred.Deferred<void>) =>
- Deferred.succeed(deferred, undefined).pipe(Effect.orDie);
-
- return {
- awaitServerReady: Effect.all([
- Deferred.await(httpListening),
- Deferred.await(pushBusReady),
- Deferred.await(keybindingsReady),
- Deferred.await(terminalSubscriptionsReady),
- Deferred.await(orchestrationSubscriptionsReady),
- ]).pipe(Effect.asVoid),
- markHttpListening: complete(httpListening),
- markPushBusReady: complete(pushBusReady),
- markKeybindingsReady: complete(keybindingsReady),
- markTerminalSubscriptionsReady: complete(terminalSubscriptionsReady),
- markOrchestrationSubscriptionsReady: complete(orchestrationSubscriptionsReady),
- } satisfies ServerReadiness;
-});
diff --git a/apps/server/tsdown.config.ts b/apps/server/tsdown.config.ts
index f89bc7d3d..f11dd3786 100644
--- a/apps/server/tsdown.config.ts
+++ b/apps/server/tsdown.config.ts
@@ -1,7 +1,7 @@
import { defineConfig } from "tsdown";
export default defineConfig({
- entry: ["src/index.ts"],
+ entry: ["src/bin.ts"],
format: ["esm", "cjs"],
checks: {
legacyCjs: false,
diff --git a/apps/server/vitest.config.ts b/apps/server/vitest.config.ts
index cb86636fb..1c5b2f0d3 100644
--- a/apps/server/vitest.config.ts
+++ b/apps/server/vitest.config.ts
@@ -6,8 +6,13 @@ export default mergeConfig(
baseConfig,
defineConfig({
test: {
- testTimeout: 15_000,
- hookTimeout: 15_000,
+ // The server suite exercises sqlite, git, temp worktrees, and orchestration
+ // runtimes heavily. Running files in parallel introduces load-sensitive flakes.
+ fileParallelism: false,
+ // Server integration tests exercise sqlite, git, and orchestration together.
+ // Under package-wide parallel runs they regularly exceed the default 15s budget.
+ testTimeout: 60_000,
+ hookTimeout: 60_000,
},
}),
);
diff --git a/apps/web/package.json b/apps/web/package.json
index bd0fb9e0a..499943c3f 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -19,6 +19,7 @@
"@dnd-kit/modifiers": "^9.0.0",
"@dnd-kit/sortable": "^10.0.0",
"@dnd-kit/utilities": "^3.2.2",
+ "@effect/atom-react": "catalog:",
"@formkit/auto-animate": "^0.9.0",
"@lexical/react": "^0.41.0",
"@pierre/diffs": "^1.1.0-beta.16",
diff --git a/apps/web/src/components/ChatView.browser.tsx b/apps/web/src/components/ChatView.browser.tsx
index e6dcc4f63..33b9b6285 100644
--- a/apps/web/src/components/ChatView.browser.tsx
+++ b/apps/web/src/components/ChatView.browser.tsx
@@ -4,16 +4,14 @@ import "../index.css";
import {
EventId,
ORCHESTRATION_WS_METHODS,
- ORCHESTRATION_WS_CHANNELS,
type MessageId,
type OrchestrationEvent,
type OrchestrationReadModel,
type ProjectId,
type ServerConfig,
+ type ServerLifecycleWelcomePayload,
type ThreadId,
type TurnId,
- type WsWelcomePayload,
- WS_CHANNELS,
WS_METHODS,
OrchestrationSessionStatus,
DEFAULT_SERVER_SETTINGS,
@@ -32,8 +30,10 @@ import {
removeInlineTerminalContextPlaceholder,
} from "../lib/terminalContext";
import { isMacPlatform } from "../lib/utils";
+import { __resetNativeApiForTests } from "../nativeApi";
import { getRouter } from "../router";
import { useStore } from "../store";
+import { BrowserWsRpcHarness, type NormalizedWsRpcRequestBody } from "../../test/wsRpcHarness";
import { estimateTimelineMessageHeight } from "./timelineHeight";
import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
@@ -44,25 +44,16 @@ const NOW_ISO = "2026-03-04T12:00:00.000Z";
const BASE_TIME_MS = Date.parse(NOW_ISO);
const ATTACHMENT_SVG = "<svg xmlns='http://www.w3.org/2000/svg' width='120' height='300'></svg>";
-interface WsRequestEnvelope {
- id: string;
- body: {
- _tag: string;
- [key: string]: unknown;
- };
-}
-
interface TestFixture {
snapshot: OrchestrationReadModel;
serverConfig: ServerConfig;
- welcome: WsWelcomePayload;
+ welcome: ServerLifecycleWelcomePayload;
}
let fixture: TestFixture;
-const wsRequests: WsRequestEnvelope["body"][] = [];
-let customWsRpcResolver: ((body: WsRequestEnvelope["body"]) => unknown | undefined) | null = null;
-let wsClient: { send: (message: string) => void } | null = null;
-let pushSequence = 1;
+const rpcHarness = new BrowserWsRpcHarness();
+const wsRequests = rpcHarness.requests;
+let customWsRpcResolver: ((body: NormalizedWsRpcRequestBody) => unknown | undefined) | null = null;
const wsLink = ws.link(/ws(s)?:\/\/.*/);
interface ViewportSpec {
@@ -388,32 +379,20 @@ function createThreadCreatedEvent(threadId: ThreadId, sequence: number): Orchest
}
function sendOrchestrationDomainEvent(event: OrchestrationEvent): void {
- if (!wsClient) {
- throw new Error("WebSocket client not connected");
- }
- wsClient.send(
- JSON.stringify({
- type: "push",
- sequence: pushSequence++,
- channel: ORCHESTRATION_WS_CHANNELS.domainEvent,
- data: event,
- }),
- );
+ rpcHarness.emitStreamValue(WS_METHODS.subscribeOrchestrationDomainEvents, event);
}
-async function waitForWsClient(): Promise<{ send: (message: string) => void }> {
- let client: { send: (message: string) => void } | null = null;
+async function waitForWsClient(): Promise<void> {
await vi.waitFor(
() => {
- client = wsClient;
- expect(client).toBeTruthy();
+ expect(
+ wsRequests.some(
+ (request) => request._tag === WS_METHODS.subscribeOrchestrationDomainEvents,
+ ),
+ ).toBe(true);
},
{ timeout: 8_000, interval: 16 },
);
- if (!client) {
- throw new Error("WebSocket client not connected");
- }
- return client;
}
async function promoteDraftThreadViaDomainEvent(threadId: ThreadId): Promise<void> {
@@ -637,7 +616,7 @@ function createSnapshotWithPlanFollowUpPrompt(): OrchestrationReadModel {
};
}
-function resolveWsRpc(body: WsRequestEnvelope["body"]): unknown {
+function resolveWsRpc(body: NormalizedWsRpcRequestBody): unknown {
const customResult = customWsRpcResolver?.(body);
if (customResult !== undefined) {
return customResult;
@@ -684,6 +663,9 @@ function resolveWsRpc(body: WsRequestEnvelope["body"]): unknown {
truncated: false,
};
}
+ if (tag === WS_METHODS.shellOpenInEditor) {
+ return null;
+ }
if (tag === WS_METHODS.terminalOpen) {
return {
threadId: typeof body.threadId === "string" ? body.threadId : THREAD_ID,
@@ -702,34 +684,11 @@ function resolveWsRpc(body: WsRequestEnvelope["body"]): unknown {
const worker = setupWorker(
wsLink.addEventListener("connection", ({ client }) => {
- wsClient = client;
- pushSequence = 1;
- client.send(
- JSON.stringify({
- type: "push",
- sequence: pushSequence++,
- channel: WS_CHANNELS.serverWelcome,
- data: fixture.welcome,
- }),
- );
+ void rpcHarness.connect(client);
client.addEventListener("message", (event) => {
const rawData = event.data;
if (typeof rawData !== "string") return;
- let request: WsRequestEnvelope;
- try {
- request = JSON.parse(rawData) as WsRequestEnvelope;
- } catch {
- return;
- }
- const method = request.body?._tag;
- if (typeof method !== "string") return;
- wsRequests.push(request.body);
- client.send(
- JSON.stringify({
- id: request.id,
- result: resolveWsRpc(request.body),
- }),
- );
+ void rpcHarness.onMessage(rawData);
});
}),
http.get("*/attachments/:attachmentId", () =>
@@ -903,7 +862,9 @@ async function waitForInteractionModeButton(
async function waitForServerConfigToApply(): Promise<void> {
await vi.waitFor(
() => {
- expect(wsRequests.some((request) => request._tag === WS_METHODS.serverGetConfig)).toBe(true);
+ expect(wsRequests.some((request) => request._tag === WS_METHODS.subscribeServerConfig)).toBe(
+ true,
+ );
},
{ timeout: 8_000, interval: 16 },
);
@@ -1041,7 +1002,7 @@ async function mountChatView(options: {
viewport: ViewportSpec;
snapshot: OrchestrationReadModel;
configureFixture?: (fixture: TestFixture) => void;
- resolveRpc?: (body: WsRequestEnvelope["body"]) => unknown | undefined;
+ resolveRpc?: (body: NormalizedWsRpcRequestBody) => unknown | undefined;
}): Promise<MountedChatView> {
fixture = buildFixture(options.snapshot);
options.configureFixture?.(fixture);
@@ -1129,10 +1090,37 @@ describe("ChatView timeline estimator parity (full app)", () => {
});
afterAll(async () => {
+ await rpcHarness.disconnect();
await worker.stop();
});
beforeEach(async () => {
+ await rpcHarness.reset({
+ resolveUnary: resolveWsRpc,
+ getInitialStreamValues: (request) => {
+ if (request._tag === WS_METHODS.subscribeServerLifecycle) {
+ return [
+ {
+ version: 1,
+ sequence: 1,
+ type: "welcome",
+ payload: fixture.welcome,
+ },
+ ];
+ }
+ if (request._tag === WS_METHODS.subscribeServerConfig) {
+ return [
+ {
+ version: 1,
+ type: "snapshot",
+ config: fixture.serverConfig,
+ },
+ ];
+ }
+ return [];
+ },
+ });
+ __resetNativeApiForTests();
await setViewport(DEFAULT_VIEWPORT);
localStorage.clear();
document.body.innerHTML = "";
@@ -1342,6 +1330,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
});
try {
+ await waitForServerConfigToApply();
const openButton = await waitForElement(
() =>
Array.from(document.querySelectorAll("button")).find(
@@ -1349,6 +1338,9 @@ describe("ChatView timeline estimator parity (full app)", () => {
) as HTMLButtonElement | null,
"Unable to find Open button.",
);
+ await vi.waitFor(() => {
+ expect(openButton.disabled).toBe(false);
+ });
openButton.click();
await vi.waitFor(
@@ -1384,6 +1376,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
});
try {
+ await waitForServerConfigToApply();
const openButton = await waitForElement(
() =>
Array.from(document.querySelectorAll("button")).find(
@@ -1391,6 +1384,9 @@ describe("ChatView timeline estimator parity (full app)", () => {
) as HTMLButtonElement | null,
"Unable to find Open button.",
);
+ await vi.waitFor(() => {
+ expect(openButton.disabled).toBe(false);
+ });
openButton.click();
await vi.waitFor(
@@ -1426,6 +1422,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
});
try {
+ await waitForServerConfigToApply();
const menuButton = await waitForElement(
() => document.querySelector('button[aria-label="Copy options"]'),
"Unable to find Open picker button.",
@@ -1474,7 +1471,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
});
it("falls back to the first installed editor when the stored favorite is unavailable", async () => {
- localStorage.setItem("t3code:last-editor", "vscodium");
+ localStorage.setItem("t3code:last-editor", JSON.stringify("vscodium"));
setDraftThreadWithoutWorktree();
const mounted = await mountChatView({
@@ -1489,6 +1486,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
});
try {
+ await waitForServerConfigToApply();
const openButton = await waitForElement(
() =>
Array.from(document.querySelectorAll("button")).find(
@@ -1496,6 +1494,9 @@ describe("ChatView timeline estimator parity (full app)", () => {
) as HTMLButtonElement | null,
"Unable to find Open button.",
);
+ await vi.waitFor(() => {
+ expect(openButton.disabled).toBe(false);
+ });
openButton.click();
await vi.waitFor(
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index bb792ac83..76133712d 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -11,11 +11,9 @@ import {
type ProviderApprovalDecision,
PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
- type ResolvedKeybindingsConfig,
type ServerProvider,
type ThreadId,
type TurnId,
- type EditorId,
type KeybindingCommand,
OrchestrationThreadActivity,
ProviderInteractionMode,
@@ -30,7 +28,6 @@ import { useDebouncedValue } from "@tanstack/react-pacer";
import { useNavigate, useSearch } from "@tanstack/react-router";
import { gitBranchesQueryOptions, gitCreateWorktreeMutationOptions } from "~/lib/gitReactQuery";
import { projectSearchEntriesQueryOptions } from "~/lib/projectReactQuery";
-import { serverConfigQueryOptions, serverQueryKeys } from "~/lib/serverReactQuery";
import { isElectron } from "../env";
import { parseDiffRouteSearch, stripDiffSearchParams } from "../diffRouteSearch";
import {
@@ -195,15 +192,18 @@ import {
waitForStartedServerThread,
} from "./ChatView.logic";
import { useLocalStorage } from "~/hooks/useLocalStorage";
+import {
+ useServerAvailableEditors,
+ useServerConfig,
+ useServerKeybindings,
+} from "~/rpc/serverState";
const ATTACHMENT_PREVIEW_HANDOFF_TTL_MS = 5000;
const IMAGE_SIZE_LIMIT_LABEL = `${Math.round(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES / (1024 * 1024))}MB`;
const IMAGE_ONLY_BOOTSTRAP_PROMPT =
"[User attached one or more images without additional text. Respond using the conversation context and the attached image(s).]";
const EMPTY_ACTIVITIES: OrchestrationThreadActivity[] = [];
-const EMPTY_KEYBINDINGS: ResolvedKeybindingsConfig = [];
const EMPTY_PROJECT_ENTRIES: ProjectEntry[] = [];
-const EMPTY_AVAILABLE_EDITORS: EditorId[] = [];
const EMPTY_PROVIDERS: ServerProvider[] = [];
const EMPTY_PENDING_USER_INPUT_ANSWERS: Record<string, PendingUserInputDraftAnswer> = {};
@@ -794,8 +794,8 @@ export default function ChatView({ threadId }: ChatViewProps) {
const lockedProvider: ProviderKind | null = hasThreadStarted
? (sessionProvider ?? threadProvider ?? selectedProviderByThreadId ?? null)
: null;
- const serverConfigQuery = useQuery(serverConfigQueryOptions());
- const providerStatuses = serverConfigQuery.data?.providers ?? EMPTY_PROVIDERS;
+ const serverConfig = useServerConfig();
+ const providerStatuses = serverConfig?.providers ?? EMPTY_PROVIDERS;
const unlockedSelectedProvider = resolveSelectableProvider(
providerStatuses,
selectedProviderByThreadId ?? threadProvider ?? "codex",
@@ -1202,8 +1202,8 @@ export default function ChatView({ threadId }: ChatViewProps) {
);
const effectivePathQuery = pathTriggerQuery.length > 0 ? debouncedPathQuery : "";
const branchesQuery = useQuery(gitBranchesQueryOptions(gitCwd));
- const keybindings = serverConfigQuery.data?.keybindings ?? EMPTY_KEYBINDINGS;
- const availableEditors = serverConfigQuery.data?.availableEditors ?? EMPTY_AVAILABLE_EDITORS;
+ const keybindings = useServerKeybindings();
+ const availableEditors = useServerAvailableEditors();
const modelOptionsByProvider = useMemo(
() => ({
codex: providerStatuses.find((provider) => provider.provider === "codex")?.models ?? [],
@@ -1698,10 +1698,9 @@ export default function ChatView({ threadId }: ChatViewProps) {
if (isElectron && keybindingRule) {
await api.server.upsertKeybinding(keybindingRule);
- await queryClient.invalidateQueries({ queryKey: serverQueryKeys.all });
}
},
- [queryClient],
+ [],
);
const saveProjectScript = useCallback(
async (input: NewProjectScriptInput) => {
diff --git a/apps/web/src/components/GitActionsControl.tsx b/apps/web/src/components/GitActionsControl.tsx
index 1593a151d..638470962 100644
--- a/apps/web/src/components/GitActionsControl.tsx
+++ b/apps/web/src/components/GitActionsControl.tsx
@@ -294,74 +294,6 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
})
: null;
- useEffect(() => {
- const api = readNativeApi();
- if (!api) {
- return;
- }
-
- const applyProgressEvent = (event: GitActionProgressEvent) => {
- const progress = activeGitActionProgressRef.current;
- if (!progress) {
- return;
- }
- if (gitCwd && event.cwd !== gitCwd) {
- return;
- }
- if (progress.actionId !== event.actionId) {
- return;
- }
-
- const now = Date.now();
- switch (event.kind) {
- case "action_started":
- progress.phaseStartedAtMs = now;
- progress.hookStartedAtMs = null;
- progress.hookName = null;
- progress.lastOutputLine = null;
- break;
- case "phase_started":
- progress.title = event.label;
- progress.currentPhaseLabel = event.label;
- progress.phaseStartedAtMs = now;
- progress.hookStartedAtMs = null;
- progress.hookName = null;
- progress.lastOutputLine = null;
- break;
- case "hook_started":
- progress.title = `Running ${event.hookName}...`;
- progress.hookName = event.hookName;
- progress.hookStartedAtMs = now;
- progress.lastOutputLine = null;
- break;
- case "hook_output":
- progress.lastOutputLine = event.text;
- break;
- case "hook_finished":
- progress.title = progress.currentPhaseLabel ?? "Committing...";
- progress.hookName = null;
- progress.hookStartedAtMs = null;
- progress.lastOutputLine = null;
- break;
- case "action_finished":
- // Don't clear timestamps here — the HTTP response handler (line 496)
- // sets activeGitActionProgressRef to null and shows the success toast.
- // Clearing timestamps early causes the "Running for Xs" description
- // to disappear before the success state renders, leaving a bare
- // "Pushing..." toast in the gap between the WS event and HTTP response.
- return;
- case "action_failed":
- // Same reasoning as action_finished — let the HTTP error handler
- // manage the final toast state to avoid a flash of bare title.
- return;
- }
-
- updateActiveProgressToast();
- };
-
- return api.git.onActionProgress(applyProgressEvent);
- }, [gitCwd, updateActiveProgressToast]);
-
useEffect(() => {
const interval = window.setInterval(() => {
if (!activeGitActionProgressRef.current) {
@@ -483,12 +415,69 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
});
}
+ const applyProgressEvent = (event: GitActionProgressEvent) => {
+ const progress = activeGitActionProgressRef.current;
+ if (!progress) {
+ return;
+ }
+ if (gitCwd && event.cwd !== gitCwd) {
+ return;
+ }
+ if (progress.actionId !== event.actionId) {
+ return;
+ }
+
+ const now = Date.now();
+ switch (event.kind) {
+ case "action_started":
+ progress.phaseStartedAtMs = now;
+ progress.hookStartedAtMs = null;
+ progress.hookName = null;
+ progress.lastOutputLine = null;
+ break;
+ case "phase_started":
+ progress.title = event.label;
+ progress.currentPhaseLabel = event.label;
+ progress.phaseStartedAtMs = now;
+ progress.hookStartedAtMs = null;
+ progress.hookName = null;
+ progress.lastOutputLine = null;
+ break;
+ case "hook_started":
+ progress.title = `Running ${event.hookName}...`;
+ progress.hookName = event.hookName;
+ progress.hookStartedAtMs = now;
+ progress.lastOutputLine = null;
+ break;
+ case "hook_output":
+ progress.lastOutputLine = event.text;
+ break;
+ case "hook_finished":
+ progress.title = progress.currentPhaseLabel ?? "Committing...";
+ progress.hookName = null;
+ progress.hookStartedAtMs = null;
+ progress.lastOutputLine = null;
+ break;
+ case "action_finished":
+ // Let the resolved mutation update the toast so we keep the
+ // elapsed description visible until the final success state renders.
+ return;
+ case "action_failed":
+ // Let the rejected mutation publish the error toast to avoid a
+ // transient intermediate state before the final failure message.
+ return;
+ }
+
+ updateActiveProgressToast();
+ };
+
const promise = runImmediateGitActionMutation.mutateAsync({
actionId,
action,
...(commitMessage ? { commitMessage } : {}),
...(featureBranch ? { featureBranch } : {}),
...(filePaths ? { filePaths } : {}),
+ onProgress: applyProgressEvent,
});
try {
diff --git a/apps/web/src/components/KeybindingsToast.browser.tsx b/apps/web/src/components/KeybindingsToast.browser.tsx
index 224bd2f88..9581e72cd 100644
--- a/apps/web/src/components/KeybindingsToast.browser.tsx
+++ b/apps/web/src/components/KeybindingsToast.browser.tsx
@@ -6,9 +6,8 @@ import {
type OrchestrationReadModel,
type ProjectId,
type ServerConfig,
+ type ServerLifecycleWelcomePayload,
type ThreadId,
- type WsWelcomePayload,
- WS_CHANNELS,
WS_METHODS,
} from "@t3tools/contracts";
import { RouterProvider, createMemoryHistory } from "@tanstack/react-router";
@@ -18,8 +17,10 @@ import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi }
import { render } from "vitest-browser-react";
import { useComposerDraftStore } from "../composerDraftStore";
+import { __resetNativeApiForTests } from "../nativeApi";
import { getRouter } from "../router";
import { useStore } from "../store";
+import { BrowserWsRpcHarness } from "../../test/wsRpcHarness";
const THREAD_ID = "thread-kb-toast-test" as ThreadId;
const PROJECT_ID = "project-1" as ProjectId;
@@ -28,12 +29,11 @@ const NOW_ISO = "2026-03-04T12:00:00.000Z";
interface TestFixture {
snapshot: OrchestrationReadModel;
serverConfig: ServerConfig;
- welcome: WsWelcomePayload;
+ welcome: ServerLifecycleWelcomePayload;
}
let fixture: TestFixture;
-let wsClient: { send: (data: string) => void } | null = null;
-let pushSequence = 1;
+const rpcHarness = new BrowserWsRpcHarness();
const wsLink = ws.link(/ws(s)?:\/\/.*/);
@@ -179,52 +179,23 @@ function resolveWsRpc(tag: string): unknown {
const worker = setupWorker(
wsLink.addEventListener("connection", ({ client }) => {
- wsClient = client;
- pushSequence = 1;
- client.send(
- JSON.stringify({
- type: "push",
- sequence: pushSequence++,
- channel: WS_CHANNELS.serverWelcome,
- data: fixture.welcome,
- }),
- );
+ void rpcHarness.connect(client);
client.addEventListener("message", (event) => {
const rawData = event.data;
if (typeof rawData !== "string") return;
- let request: { id: string; body: { _tag: string; [key: string]: unknown } };
- try {
- request = JSON.parse(rawData);
- } catch {
- return;
- }
- const method = request.body?._tag;
- if (typeof method !== "string") return;
- client.send(
- JSON.stringify({
- id: request.id,
- result: resolveWsRpc(method),
- }),
- );
+ void rpcHarness.onMessage(rawData);
});
}),
http.get("*/attachments/:attachmentId", () => new HttpResponse(null, { status: 204 })),
http.get("*/api/project-favicon", () => new HttpResponse(null, { status: 204 })),
);
-function sendServerConfigUpdatedPush(issues: Array<{ kind: string; message: string }>) {
- if (!wsClient) throw new Error("WebSocket client not connected");
- wsClient.send(
- JSON.stringify({
- type: "push",
- sequence: pushSequence++,
- channel: WS_CHANNELS.serverConfigUpdated,
- data: {
- issues,
- providers: fixture.serverConfig.providers,
- },
- }),
- );
+function sendServerConfigUpdatedPush(issues: ServerConfig["issues"]) {
+ rpcHarness.emitStreamValue(WS_METHODS.subscribeServerConfig, {
+ version: 1,
+ type: "keybindingsUpdated",
+ payload: { issues },
+ });
}
function queryToastTitles(): string[] {
@@ -308,13 +279,39 @@ describe("Keybindings update toast", () => {
});
afterAll(async () => {
+ await rpcHarness.disconnect();
await worker.stop();
});
- beforeEach(() => {
+ beforeEach(async () => {
+ await rpcHarness.reset({
+ resolveUnary: (request) => resolveWsRpc(request._tag),
+ getInitialStreamValues: (request) => {
+ if (request._tag === WS_METHODS.subscribeServerLifecycle) {
+ return [
+ {
+ version: 1,
+ sequence: 1,
+ type: "welcome",
+ payload: fixture.welcome,
+ },
+ ];
+ }
+ if (request._tag === WS_METHODS.subscribeServerConfig) {
+ return [
+ {
+ version: 1,
+ type: "snapshot",
+ config: fixture.serverConfig,
+ },
+ ];
+ }
+ return [];
+ },
+ });
+ __resetNativeApiForTests();
localStorage.clear();
document.body.innerHTML = "";
- pushSequence = 1;
useComposerDraftStore.setState({
draftsByThreadId: {},
draftThreadsByThreadId: {},
diff --git a/apps/web/src/components/ProjectFavicon.tsx b/apps/web/src/components/ProjectFavicon.tsx
index bc0118120..58426f50b 100644
--- a/apps/web/src/components/ProjectFavicon.tsx
+++ b/apps/web/src/components/ProjectFavicon.tsx
@@ -1,30 +1,15 @@
import { FolderIcon } from "lucide-react";
import { useState } from "react";
-
-function getServerHttpOrigin(): string {
- const bridgeUrl = window.desktopBridge?.getWsUrl();
- const envUrl = import.meta.env.VITE_WS_URL as string | undefined;
- const wsUrl =
- bridgeUrl && bridgeUrl.length > 0
- ? bridgeUrl
- : envUrl && envUrl.length > 0
- ? envUrl
- : `${window.location.protocol === "https:" ? "wss" : "ws"}://${window.location.hostname}:${window.location.port}`;
- // Parse to extract just the origin, dropping path/query (e.g. ?token=…)
- const httpUrl = wsUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
- try {
- return new URL(httpUrl).origin;
- } catch {
- return httpUrl;
- }
-}
-
-const serverHttpOrigin = getServerHttpOrigin();
+import { resolveServerUrl } from "~/lib/utils";
const loadedProjectFaviconSrcs = new Set<string>();
export function ProjectFavicon({ cwd, className }: { cwd: string; className?: string }) {
- const src = `${serverHttpOrigin}/api/project-favicon?cwd=${encodeURIComponent(cwd)}`;
+ const src = resolveServerUrl({
+ protocol: "http",
+ pathname: "/api/project-favicon",
+ searchParams: { cwd },
+ });
const [status, setStatus] = useState<"loading" | "loaded" | "error">(() =>
loadedProjectFaviconSrcs.has(src) ? "loaded" : "loading",
);
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index efa512428..c819ce81c 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -43,9 +43,8 @@ import {
ProjectId,
ThreadId,
type GitStatusResult,
- type ResolvedKeybindingsConfig,
} from "@t3tools/contracts";
-import { useQueries, useQuery } from "@tanstack/react-query";
+import { useQueries } from "@tanstack/react-query";
import { useLocation, useNavigate, useParams } from "@tanstack/react-router";
import {
type SidebarProjectSortOrder,
@@ -67,7 +66,6 @@ import {
} from "../keybindings";
import { derivePendingApprovals, derivePendingUserInputs } from "../session-logic";
import { gitStatusQueryOptions } from "../lib/gitReactQuery";
-import { serverConfigQueryOptions } from "../lib/serverReactQuery";
import { readNativeApi } from "../nativeApi";
import { useComposerDraftStore } from "../composerDraftStore";
import { useHandleNewThread } from "../hooks/useHandleNewThread";
@@ -125,9 +123,8 @@ import {
import { SidebarUpdatePill } from "./sidebar/SidebarUpdatePill";
import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";
import { useSettings, useUpdateSettings } from "~/hooks/useSettings";
+import { useServerKeybindings } from "../rpc/serverState";
import type { Project, Thread } from "../types";
-
-const EMPTY_KEYBINDINGS: ResolvedKeybindingsConfig = [];
const THREAD_PREVIEW_LIMIT = 6;
const SIDEBAR_SORT_LABELS: Record<SidebarProjectSortOrder, string> = {
updated_at: "Last user message",
@@ -469,10 +466,7 @@ export default function Sidebar() {
strict: false,
select: (params) => (params.threadId ? ThreadId.makeUnsafe(params.threadId) : null),
});
- const { data: keybindings = EMPTY_KEYBINDINGS } = useQuery({
- ...serverConfigQueryOptions(),
- select: (config) => config.keybindings,
- });
+ const keybindings = useServerKeybindings();
const [addingProject, setAddingProject] = useState(false);
const [newCwd, setNewCwd] = useState("");
const [isPickingFolder, setIsPickingFolder] = useState(false);
diff --git a/apps/web/src/components/settings/SettingsPanels.tsx b/apps/web/src/components/settings/SettingsPanels.tsx
index b7fde0c5f..e3e620030 100644
--- a/apps/web/src/components/settings/SettingsPanels.tsx
+++ b/apps/web/src/components/settings/SettingsPanels.tsx
@@ -9,7 +9,7 @@ import {
Undo2Icon,
XIcon,
} from "lucide-react";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useQueryClient } from "@tanstack/react-query";
import { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from "react";
import {
PROVIDER_DISPLAY_NAMES,
@@ -40,7 +40,6 @@ import {
setDesktopUpdateStateQueryData,
useDesktopUpdateState,
} from "../../lib/desktopUpdateReactQuery";
-import { serverConfigQueryOptions, serverQueryKeys } from "../../lib/serverReactQuery";
import {
MAX_CUSTOM_MODEL_LENGTH,
getCustomModelOptionsByProvider,
@@ -59,6 +58,11 @@ import { Switch } from "../ui/switch";
import { toastManager } from "../ui/toast";
import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
import { ProjectFavicon } from "../ProjectFavicon";
+import {
+ useServerAvailableEditors,
+ useServerKeybindingsConfigPath,
+ useServerProviders,
+} from "../../rpc/serverState";
const THEME_OPTIONS = [
{
@@ -81,8 +85,6 @@ const TIMESTAMP_FORMAT_LABELS = {
"24-hour": "24-hour",
} as const;
-const EMPTY_SERVER_PROVIDERS: ReadonlyArray<ServerProvider> = [];
-
type InstallProviderSettings = {
provider: ProviderKind;
title: string;
@@ -516,7 +518,6 @@ export function GeneralSettingsPanel() {
const { theme, setTheme } = useTheme();
const settings = useSettings();
const { updateSettings } = useUpdateSettings();
- const serverConfigQuery = useQuery(serverConfigQueryOptions());
const [isOpeningKeybindings, setIsOpeningKeybindings] = useState(false);
const [openKeybindingsError, setOpenKeybindingsError] = useState<string | null>(null);
const [openProviderDetails, setOpenProviderDetails] = useState<Record<ProviderKind, boolean>>({
@@ -542,7 +543,6 @@ export function GeneralSettingsPanel() {
>({});
const [isRefreshingProviders, setIsRefreshingProviders] = useState(false);
const refreshingRef = useRef(false);
- const queryClient = useQueryClient();
const modelListRefs = useRef<Partial<Record<ProviderKind, HTMLDivElement | null>>>({});
const refreshProviders = useCallback(() => {
if (refreshingRef.current) return;
@@ -550,7 +550,6 @@ export function GeneralSettingsPanel() {
setIsRefreshingProviders(true);
void ensureNativeApi()
.server.refreshProviders()
- .then(() => queryClient.invalidateQueries({ queryKey: serverQueryKeys.config() }))
.catch((error: unknown) => {
console.warn("Failed to refresh providers", error);
})
@@ -558,11 +557,11 @@ export function GeneralSettingsPanel() {
refreshingRef.current = false;
setIsRefreshingProviders(false);
});
- }, [queryClient]);
+ }, []);
- const keybindingsConfigPath = serverConfigQuery.data?.keybindingsConfigPath ?? null;
- const availableEditors = serverConfigQuery.data?.availableEditors;
- const serverProviders = serverConfigQuery.data?.providers ?? EMPTY_SERVER_PROVIDERS;
+ const keybindingsConfigPath = useServerKeybindingsConfigPath();
+ const availableEditors = useServerAvailableEditors();
+ const serverProviders = useServerProviders();
const codexHomePath = settings.providers.codex.homePath;
const textGenerationModelSelection = resolveAppModelSelectionState(settings, serverProviders);
diff --git a/apps/web/src/hooks/useSettings.ts b/apps/web/src/hooks/useSettings.ts
index 3f804bc48..f6b43f9a7 100644
--- a/apps/web/src/hooks/useSettings.ts
+++ b/apps/web/src/hooks/useSettings.ts
@@ -10,15 +10,12 @@
* store.
*/
import { useCallback, useMemo } from "react";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
import {
ServerSettings,
ServerSettingsPatch,
- ServerConfig,
ModelSelection,
ThreadEnvMode,
} from "@t3tools/contracts";
-import { DEFAULT_SERVER_SETTINGS } from "@t3tools/contracts";
import {
type ClientSettings,
ClientSettingsSchema,
@@ -29,13 +26,13 @@ import {
TimestampFormat,
UnifiedSettings,
} from "@t3tools/contracts/settings";
-import { serverConfigQueryOptions, serverQueryKeys } from "~/lib/serverReactQuery";
import { ensureNativeApi } from "~/nativeApi";
import { useLocalStorage } from "./useLocalStorage";
import { normalizeCustomModelSlugs } from "~/modelSelection";
import { Predicate, Schema, Struct } from "effect";
import { DeepMutable } from "effect/Types";
import { deepMerge } from "@t3tools/shared/Struct";
+import { applySettingsUpdated, getServerConfig, useServerSettings } from "~/rpc/serverState";
const CLIENT_SETTINGS_STORAGE_KEY = "t3code:client-settings:v1";
const OLD_SETTINGS_KEY = "t3code:app-settings:v1";
@@ -73,7 +70,7 @@ function splitPatch(patch: Partial<UnifiedSettings>): {
export function useSettings<T extends UnifiedSettings = UnifiedSettings>(
selector?: (s: UnifiedSettings) => T,
): T {
- const { data: serverConfig } = useQuery(serverConfigQueryOptions());
+ const serverSettings = useServerSettings();
const [clientSettings] = useLocalStorage(
CLIENT_SETTINGS_STORAGE_KEY,
DEFAULT_CLIENT_SETTINGS,
@@ -82,10 +79,10 @@ export function useSettings<T extends UnifiedSettings = UnifiedSettings>(
const merged = useMemo<UnifiedSettings>(
() => ({
- ...(serverConfig?.settings ?? DEFAULT_SERVER_SETTINGS),
+ ...serverSettings,
...clientSettings,
}),
- [serverConfig?.settings, clientSettings],
+ [clientSettings, serverSettings],
);
return useMemo(() => (selector ? selector(merged) : (merged as T)), [merged, selector]);
@@ -94,11 +91,10 @@ export function useSettings<T extends UnifiedSettings = UnifiedSettings>(
/**
* Returns an updater that routes each key to the correct backing store.
*
- * Server keys are optimistically patched in the React Query cache, then
+ * Server keys are optimistically patched in atom-backed server state, then
* persisted via RPC. Client keys go straight to localStorage.
*/
export function useUpdateSettings() {
- const queryClient = useQueryClient();
const [, setClientSettings] = useLocalStorage(
CLIENT_SETTINGS_STORAGE_KEY,
DEFAULT_CLIENT_SETTINGS,
@@ -110,14 +106,10 @@ export function useUpdateSettings() {
const { serverPatch, clientPatch } = splitPatch(patch);
if (Object.keys(serverPatch).length > 0) {
- // Optimistic update of the React Query cache
- queryClient.setQueryData<ServerConfig>(serverQueryKeys.config(), (old) => {
- if (!old) return old;
- return {
- ...old,
- settings: deepMerge(old.settings, serverPatch),
- };
- });
+ const currentServerConfig = getServerConfig();
+ if (currentServerConfig) {
+ applySettingsUpdated(deepMerge(currentServerConfig.settings, serverPatch));
+ }
// Fire-and-forget RPC — push will reconcile on success
void ensureNativeApi().server.updateSettings(serverPatch);
}
@@ -126,7 +118,7 @@ export function useUpdateSettings() {
setClientSettings((prev) => ({ ...prev, ...clientPatch }));
}
},
- [queryClient, setClientSettings],
+ [setClientSettings],
);
const resetSettings = useCallback(() => {
diff --git a/apps/web/src/lib/gitReactQuery.ts b/apps/web/src/lib/gitReactQuery.ts
index cfa2c72f7..d68e40025 100644
--- a/apps/web/src/lib/gitReactQuery.ts
+++ b/apps/web/src/lib/gitReactQuery.ts
@@ -1,6 +1,7 @@
-import { type GitStackedAction } from "@t3tools/contracts";
+import { type GitActionProgressEvent, type GitStackedAction } from "@t3tools/contracts";
import { mutationOptions, queryOptions, type QueryClient } from "@tanstack/react-query";
import { ensureNativeApi } from "../nativeApi";
+import { getWsRpcClient } from "../wsRpcClient";
const GIT_STATUS_STALE_TIME_MS = 5_000;
const GIT_STATUS_REFETCH_INTERVAL_MS = 15_000;
@@ -121,23 +122,27 @@ export function gitRunStackedActionMutationOptions(input: {
commitMessage,
featureBranch,
filePaths,
+ onProgress,
}: {
actionId: string;
action: GitStackedAction;
commitMessage?: string;
featureBranch?: boolean;
filePaths?: string[];
+ onProgress?: (event: GitActionProgressEvent) => void;
}) => {
- const api = ensureNativeApi();
if (!input.cwd) throw new Error("Git action is unavailable.");
- return api.git.runStackedAction({
- actionId,
- cwd: input.cwd,
- action,
- ...(commitMessage ? { commitMessage } : {}),
- ...(featureBranch ? { featureBranch } : {}),
- ...(filePaths ? { filePaths } : {}),
- });
+ return getWsRpcClient().git.runStackedAction(
+ {
+ actionId,
+ cwd: input.cwd,
+ action,
+ ...(commitMessage ? { commitMessage } : {}),
+ ...(featureBranch ? { featureBranch } : {}),
+ ...(filePaths ? { filePaths } : {}),
+ },
+ ...(onProgress ? [{ onProgress }] : []),
+ );
},
onSettled: async () => {
await invalidateGitQueries(input.queryClient);
diff --git a/apps/web/src/lib/serverReactQuery.ts b/apps/web/src/lib/serverReactQuery.ts
deleted file mode 100644
index 37029a3a3..000000000
--- a/apps/web/src/lib/serverReactQuery.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { queryOptions } from "@tanstack/react-query";
-import { ensureNativeApi } from "~/nativeApi";
-
-export const serverQueryKeys = {
- all: ["server"] as const,
- config: () => ["server", "config"] as const,
-};
-
-/**
- * Server config query options.
- *
- * `staleTime` is kept short so that push-driven `invalidateQueries` calls in
- * the EventRouter always trigger a refetch, and so the query re-fetches when
- * the component re-mounts (e.g. navigating away from settings and back).
- */
-export function serverConfigQueryOptions() {
- return queryOptions({
- queryKey: serverQueryKeys.config(),
- queryFn: async () => {
- const api = ensureNativeApi();
- return api.server.getConfig();
- },
- });
-}
diff --git a/apps/web/src/lib/utils.ts b/apps/web/src/lib/utils.ts
index b5834606b..e48f81546 100644
--- a/apps/web/src/lib/utils.ts
+++ b/apps/web/src/lib/utils.ts
@@ -1,4 +1,5 @@
import { CommandId, MessageId, ProjectId, ThreadId } from "@t3tools/contracts";
+import { String, Predicate } from "effect";
import { type CxOptions, cx } from "class-variance-authority";
import { twMerge } from "tailwind-merge";
import * as Random from "effect/Random";
@@ -34,3 +35,41 @@ export const newProjectId = (): ProjectId => ProjectId.makeUnsafe(randomUUID());
export const newThreadId = (): ThreadId => ThreadId.makeUnsafe(randomUUID());
export const newMessageId = (): MessageId => MessageId.makeUnsafe(randomUUID());
+
+const isNonEmptyString = Predicate.compose(Predicate.isString, String.isNonEmpty);
+const firstNonEmptyString = (...values: unknown[]): string => {
+ for (const value of values) {
+ if (isNonEmptyString(value)) {
+ return value;
+ }
+ }
+ throw new Error("No non-empty string provided");
+};
+
+export const resolveServerUrl = (options?: {
+ url?: string | undefined;
+ protocol?: "http" | "https" | "ws" | "wss" | undefined;
+ pathname?: string | undefined;
+ searchParams?: Record<string, string> | undefined;
+}): string => {
+ const rawUrl = firstNonEmptyString(
+ options?.url,
+ window.desktopBridge?.getWsUrl(),
+ import.meta.env.VITE_WS_URL,
+ window.location.origin,
+ );
+
+ const parsedUrl = new URL(rawUrl);
+ if (options?.protocol) {
+ parsedUrl.protocol = options.protocol;
+ }
+ if (options?.pathname) {
+ parsedUrl.pathname = options.pathname;
+ } else {
+ parsedUrl.pathname = "/";
+ }
+ if (options?.searchParams) {
+ parsedUrl.search = new URLSearchParams(options.searchParams).toString();
+ }
+ return parsedUrl.toString();
+};
diff --git a/apps/web/src/nativeApi.ts b/apps/web/src/nativeApi.ts
index 40443f67e..9f528b634 100644
--- a/apps/web/src/nativeApi.ts
+++ b/apps/web/src/nativeApi.ts
@@ -1,6 +1,6 @@
import type { NativeApi } from "@t3tools/contracts";
-import { createWsNativeApi } from "./wsNativeApi";
+import { __resetWsNativeApiForTests, createWsNativeApi } from "./wsNativeApi";
let cachedApi: NativeApi | undefined;
@@ -24,3 +24,8 @@ export function ensureNativeApi(): NativeApi {
}
return api;
}
+
+export function __resetNativeApiForTests() {
+ cachedApi = undefined;
+ __resetWsNativeApiForTests();
+}
diff --git a/apps/web/src/router.ts b/apps/web/src/router.ts
index 16b78e69d..84beaf9fc 100644
--- a/apps/web/src/router.ts
+++ b/apps/web/src/router.ts
@@ -2,6 +2,7 @@ import { createElement } from "react";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { createRouter, RouterHistory } from "@tanstack/react-router";
+import { AppAtomRegistryProvider } from "./rpc/atomRegistry";
import { routeTree } from "./routeTree.gen";
export function getRouter(history: RouterHistory) {
@@ -13,7 +14,12 @@ export function getRouter(history: RouterHistory) {
context: {
queryClient,
},
- Wrap: ({ children }) => createElement(QueryClientProvider, { client: queryClient }, children),
+ Wrap: ({ children }) =>
+ createElement(
+ QueryClientProvider,
+ { client: queryClient },
+ createElement(AppAtomRegistryProvider, undefined, children),
+ ),
});
}
diff --git a/apps/web/src/routes/__root.tsx b/apps/web/src/routes/__root.tsx
index 4765b0a8e..368c595a4 100644
--- a/apps/web/src/routes/__root.tsx
+++ b/apps/web/src/routes/__root.tsx
@@ -1,12 +1,16 @@
-import { OrchestrationEvent, ThreadId } from "@t3tools/contracts";
+import {
+ OrchestrationEvent,
+ ThreadId,
+ type ServerLifecycleWelcomePayload,
+} from "@t3tools/contracts";
import {
Outlet,
createRootRouteWithContext,
type ErrorComponentProps,
useNavigate,
- useRouterState,
+ useLocation,
} from "@tanstack/react-router";
-import { useEffect, useRef } from "react";
+import { useEffect, useEffectEvent, useRef } from "react";
import { QueryClient, useQueryClient } from "@tanstack/react-query";
import { Throttler } from "@tanstack/react-pacer";
@@ -15,8 +19,14 @@ import { AppSidebarLayout } from "../components/AppSidebarLayout";
import { Button } from "../components/ui/button";
import { AnchoredToastProvider, ToastProvider, toastManager } from "../components/ui/toast";
import { resolveAndPersistPreferredEditor } from "../editorPreferences";
-import { serverConfigQueryOptions, serverQueryKeys } from "../lib/serverReactQuery";
import { readNativeApi } from "../nativeApi";
+import {
+ type ServerConfigUpdateSource,
+ useServerConfig,
+ useServerConfigUpdatedSubscription,
+ useServerWelcomeSubscription,
+} from "../rpc/serverState";
+import { ServerStateBootstrap } from "../rpc/serverStateBootstrap";
import {
clearPromotedDraftThread,
clearPromotedDraftThreads,
@@ -26,7 +36,6 @@ import { useStore } from "../store";
import { useUiStateStore } from "../uiStateStore";
import { useTerminalStateStore } from "../terminalStateStore";
import { terminalRunningSubprocessFromEvent } from "../terminalActivity";
-import { onServerConfigUpdated, onServerProvidersUpdated, onServerWelcome } from "../wsNativeApi";
import { migrateLocalSettingsToServer } from "../hooks/useSettings";
import { providerQueryKeys } from "../lib/providerReactQuery";
import { projectQueryKeys } from "../lib/projectReactQuery";
@@ -58,15 +67,18 @@ function RootRouteView() {
}
return (
- <ToastProvider>
- <AnchoredToastProvider>
- <EventRouter />
- <DesktopProjectBootstrap />
- <AppSidebarLayout>
- <Outlet />
- </AppSidebarLayout>
- </AnchoredToastProvider>
- </ToastProvider>
+ <>
+ <ServerStateBootstrap />
+ <ToastProvider>
+ <AnchoredToastProvider>
+ <EventRouter />
+ <DesktopProjectBootstrap />
+ <AppSidebarLayout>
+ <Outlet />
+ </AppSidebarLayout>
+ </AnchoredToastProvider>
+ </ToastProvider>
+ </>
);
}
@@ -154,16 +166,107 @@ function EventRouter() {
);
const queryClient = useQueryClient();
const navigate = useNavigate();
- const pathname = useRouterState({ select: (state) => state.location.pathname });
+ const pathname = useLocation({ select: (loc) => loc.pathname });
const pathnameRef = useRef(pathname);
const handledBootstrapThreadIdRef = useRef<string | null>(null);
+ const handledConfigReplayRef = useRef(false);
+ const disposedRef = useRef(false);
+ const bootstrapFromSnapshotRef = useRef<() => Promise<void>>(async () => undefined);
+ const serverConfig = useServerConfig();
pathnameRef.current = pathname;
+ const handleWelcome = useEffectEvent((payload: ServerLifecycleWelcomePayload) => {
+ migrateLocalSettingsToServer();
+ void (async () => {
+ await bootstrapFromSnapshotRef.current();
+ if (disposedRef.current) {
+ return;
+ }
+
+ if (!payload.bootstrapProjectId || !payload.bootstrapThreadId) {
+ return;
+ }
+ setProjectExpanded(payload.bootstrapProjectId, true);
+
+ if (pathnameRef.current !== "/") {
+ return;
+ }
+ if (handledBootstrapThreadIdRef.current === payload.bootstrapThreadId) {
+ return;
+ }
+ await navigate({
+ to: "/$threadId",
+ params: { threadId: payload.bootstrapThreadId },
+ replace: true,
+ });
+ handledBootstrapThreadIdRef.current = payload.bootstrapThreadId;
+ })().catch(() => undefined);
+ });
+
+ const handleServerConfigUpdated = useEffectEvent(
+ ({
+ payload,
+ source,
+ }: {
+ readonly payload: import("@t3tools/contracts").ServerConfigUpdatedPayload;
+ readonly source: ServerConfigUpdateSource;
+ }) => {
+ const isReplay = !handledConfigReplayRef.current;
+ handledConfigReplayRef.current = true;
+ if (isReplay || source !== "keybindingsUpdated") {
+ return;
+ }
+
+ const issue = payload.issues.find((entry) => entry.kind.startsWith("keybindings."));
+ if (!issue) {
+ toastManager.add({
+ type: "success",
+ title: "Keybindings updated",
+ description: "Keybindings configuration reloaded successfully.",
+ });
+ return;
+ }
+
+ toastManager.add({
+ type: "warning",
+ title: "Invalid keybindings configuration",
+ description: issue.message,
+ actionProps: {
+ children: "Open keybindings.json",
+ onClick: () => {
+ const api = readNativeApi();
+ if (!api) {
+ return;
+ }
+
+ void Promise.resolve(serverConfig ?? api.server.getConfig())
+ .then((config) => {
+ const editor = resolveAndPersistPreferredEditor(config.availableEditors);
+ if (!editor) {
+ throw new Error("No available editors found.");
+ }
+ return api.shell.openInEditor(config.keybindingsConfigPath, editor);
+ })
+ .catch((error) => {
+ toastManager.add({
+ type: "error",
+ title: "Unable to open keybindings file",
+ description:
+ error instanceof Error ? error.message : "Unknown error opening file.",
+ });
+ });
+ },
+ },
+ });
+ },
+ );
+
useEffect(() => {
const api = readNativeApi();
if (!api) return;
let disposed = false;
+ disposedRef.current = false;
const recovery = createOrchestrationRecoveryCoordinator();
let needsProviderInvalidation = false;
@@ -299,11 +402,11 @@ function EventRouter() {
const bootstrapFromSnapshot = async (): Promise<void> => {
await runSnapshotRecovery("bootstrap");
};
+ bootstrapFromSnapshotRef.current = bootstrapFromSnapshot;
const fallbackToSnapshotRecovery = async (): Promise<void> => {
await runSnapshotRecovery("replay-failed");
};
-
const unsubDomainEvent = api.orchestration.onDomainEvent((event) => {
const action = recovery.classifyDomainEvent(event.sequence);
if (action === "apply") {
@@ -327,98 +430,13 @@ function EventRouter() {
hasRunningSubprocess,
);
});
- const unsubWelcome = onServerWelcome((payload) => {
- // Migrate old localStorage settings to server on first connect
- migrateLocalSettingsToServer();
- void (async () => {
- await bootstrapFromSnapshot();
- if (disposed) {
- return;
- }
-
- if (!payload.bootstrapProjectId || !payload.bootstrapThreadId) {
- return;
- }
- setProjectExpanded(payload.bootstrapProjectId, true);
-
- if (pathnameRef.current !== "/") {
- return;
- }
- if (handledBootstrapThreadIdRef.current === payload.bootstrapThreadId) {
- return;
- }
- await navigate({
- to: "/$threadId",
- params: { threadId: payload.bootstrapThreadId },
- replace: true,
- });
- handledBootstrapThreadIdRef.current = payload.bootstrapThreadId;
- })().catch(() => undefined);
- });
- // onServerConfigUpdated replays the latest cached value synchronously
- // during subscribe. Skip the toast for that replay so effect re-runs
- // don't produce duplicate toasts.
- let subscribed = false;
- const unsubServerConfigUpdated = onServerConfigUpdated((payload) => {
- // Invalidate the config query so active observers refetch fresh data.
- void queryClient.invalidateQueries({ queryKey: serverQueryKeys.config() });
-
- if (!subscribed) return;
-
- // Only show keybindings toasts for keybindings changes (no settings in payload)
- if (payload.settings) return;
-
- const issue = payload.issues.find((entry) => entry.kind.startsWith("keybindings."));
- if (!issue) {
- toastManager.add({
- type: "success",
- title: "Keybindings updated",
- description: "Keybindings configuration reloaded successfully.",
- });
- return;
- }
-
- toastManager.add({
- type: "warning",
- title: "Invalid keybindings configuration",
- description: issue.message,
- actionProps: {
- children: "Open keybindings.json",
- onClick: () => {
- void queryClient
- .ensureQueryData(serverConfigQueryOptions())
- .then((config) => {
- const editor = resolveAndPersistPreferredEditor(config.availableEditors);
- if (!editor) {
- throw new Error("No available editors found.");
- }
- return api.shell.openInEditor(config.keybindingsConfigPath, editor);
- })
- .catch((error) => {
- toastManager.add({
- type: "error",
- title: "Unable to open keybindings file",
- description:
- error instanceof Error ? error.message : "Unknown error opening file.",
- });
- });
- },
- },
- });
- });
- const unsubProvidersUpdated = onServerProvidersUpdated(() => {
- void queryClient.invalidateQueries({ queryKey: serverQueryKeys.config() });
- });
- subscribed = true;
return () => {
disposed = true;
+ disposedRef.current = true;
needsProviderInvalidation = false;
queryInvalidationThrottler.cancel();
unsubDomainEvent();
unsubTerminalEvent();
- unsubWelcome();
- unsubServerConfigUpdated();
- unsubProvidersUpdated();
};
}, [
applyOrchestrationEvents,
@@ -433,6 +451,9 @@ function EventRouter() {
syncThreads,
]);
+ useServerWelcomeSubscription(handleWelcome);
+ useServerConfigUpdatedSubscription(handleServerConfigUpdated);
+
return null;
}
diff --git a/apps/web/src/routes/_chat.tsx b/apps/web/src/routes/_chat.tsx
index 245ed9c57..1ce840a01 100644
--- a/apps/web/src/routes/_chat.tsx
+++ b/apps/web/src/routes/_chat.tsx
@@ -1,26 +1,21 @@
-import { type ResolvedKeybindingsConfig } from "@t3tools/contracts";
-import { useQuery } from "@tanstack/react-query";
import { Outlet, createFileRoute } from "@tanstack/react-router";
import { useEffect } from "react";
import { useHandleNewThread } from "../hooks/useHandleNewThread";
import { isTerminalFocused } from "../lib/terminalFocus";
-import { serverConfigQueryOptions } from "../lib/serverReactQuery";
import { resolveShortcutCommand } from "../keybindings";
import { selectThreadTerminalState, useTerminalStateStore } from "../terminalStateStore";
import { useThreadSelectionStore } from "../threadSelectionStore";
import { resolveSidebarNewThreadEnvMode } from "~/components/Sidebar.logic";
import { useSettings } from "~/hooks/useSettings";
-
-const EMPTY_KEYBINDINGS: ResolvedKeybindingsConfig = [];
+import { useServerKeybindings } from "~/rpc/serverState";
function ChatRouteGlobalShortcuts() {
const clearSelection = useThreadSelectionStore((state) => state.clearSelection);
const selectedThreadIdsSize = useThreadSelectionStore((state) => state.selectedThreadIds.size);
const { activeDraftThread, activeThread, defaultProjectId, handleNewThread, routeThreadId } =
useHandleNewThread();
- const serverConfigQuery = useQuery(serverConfigQueryOptions());
- const keybindings = serverConfigQuery.data?.keybindings ?? EMPTY_KEYBINDINGS;
+ const keybindings = useServerKeybindings();
const terminalOpen = useTerminalStateStore((state) =>
routeThreadId
? selectThreadTerminalState(state.terminalStateByThreadId, routeThreadId).terminalOpen
diff --git a/apps/web/src/rpc/atomRegistry.tsx b/apps/web/src/rpc/atomRegistry.tsx
new file mode 100644
index 000000000..89385c9a7
--- /dev/null
+++ b/apps/web/src/rpc/atomRegistry.tsx
@@ -0,0 +1,14 @@
+import { RegistryContext } from "@effect/atom-react";
+import { AtomRegistry } from "effect/unstable/reactivity";
+import type { ReactNode } from "react";
+
+export let appAtomRegistry = AtomRegistry.make();
+
+export function AppAtomRegistryProvider({ children }: { readonly children: ReactNode }) {
+ return <RegistryContext.Provider value={appAtomRegistry}>{children}</RegistryContext.Provider>;
+}
+
+export function resetAppAtomRegistryForTests() {
+ appAtomRegistry.dispose();
+ appAtomRegistry = AtomRegistry.make();
+}
diff --git a/apps/web/src/rpc/client.test.ts b/apps/web/src/rpc/client.test.ts
new file mode 100644
index 000000000..c19b85dd3
--- /dev/null
+++ b/apps/web/src/rpc/client.test.ts
@@ -0,0 +1,231 @@
+import { DEFAULT_SERVER_SETTINGS, WS_METHODS } from "@t3tools/contracts";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AsyncResult, AtomRegistry } from "effect/unstable/reactivity";
+
+import { __resetWsRpcAtomClientForTests, runRpc, WsRpcAtomClient } from "./client";
+
+type WsEventType = "open" | "message" | "close" | "error";
+type WsEvent = { code?: number; data?: unknown; reason?: string; type?: string };
+type WsListener = (event?: WsEvent) => void;
+
+const sockets: MockWebSocket[] = [];
+
+class MockWebSocket {
+ static readonly CONNECTING = 0;
+ static readonly OPEN = 1;
+ static readonly CLOSING = 2;
+ static readonly CLOSED = 3;
+
+ readyState = MockWebSocket.CONNECTING;
+ readonly sent: string[] = [];
+ readonly url: string;
+ private readonly listeners = new Map<WsEventType, Set<WsListener>>();
+
+ constructor(url: string) {
+ this.url = url;
+ sockets.push(this);
+ }
+
+ addEventListener(type: WsEventType, listener: WsListener) {
+ const listeners = this.listeners.get(type) ?? new Set<WsListener>();
+ listeners.add(listener);
+ this.listeners.set(type, listeners);
+ }
+
+ removeEventListener(type: WsEventType, listener: WsListener) {
+ this.listeners.get(type)?.delete(listener);
+ }
+
+ send(data: string) {
+ this.sent.push(data);
+ }
+
+ close(code = 1000, reason = "") {
+ this.readyState = MockWebSocket.CLOSED;
+ this.emit("close", { code, reason, type: "close" });
+ }
+
+ open() {
+ this.readyState = MockWebSocket.OPEN;
+ this.emit("open", { type: "open" });
+ }
+
+ serverMessage(data: unknown) {
+ this.emit("message", { data, type: "message" });
+ }
+
+ private emit(type: WsEventType, event?: WsEvent) {
+ const listeners = this.listeners.get(type);
+ if (!listeners) {
+ return;
+ }
+ for (const listener of listeners) {
+ listener(event);
+ }
+ }
+}
+
+const originalWebSocket = globalThis.WebSocket;
+
+function getSocket(): MockWebSocket {
+ const socket = sockets.at(-1);
+ if (!socket) {
+ throw new Error("Expected a websocket instance");
+ }
+ return socket;
+}
+
+async function waitFor(assertion: () => void, timeoutMs = 1_000): Promise<void> {
+ const startedAt = Date.now();
+ for (;;) {
+ try {
+ assertion();
+ return;
+ } catch (error) {
+ if (Date.now() - startedAt >= timeoutMs) {
+ throw error;
+ }
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ }
+ }
+}
+
+beforeEach(() => {
+ sockets.length = 0;
+
+ Object.defineProperty(globalThis, "window", {
+ configurable: true,
+ value: {
+ location: {
+ hostname: "localhost",
+ origin: "http://localhost:3020",
+ port: "3020",
+ protocol: "ws:",
+ },
+ desktopBridge: undefined,
+ },
+ });
+
+ globalThis.WebSocket = MockWebSocket as unknown as typeof WebSocket;
+});
+
+afterEach(() => {
+ __resetWsRpcAtomClientForTests();
+ globalThis.WebSocket = originalWebSocket;
+ vi.restoreAllMocks();
+});
+
+describe("WsRpcAtomClient", () => {
+ it("runs unary requests through the AtomRpc service", async () => {
+ const expectedSettings = {
+ ...DEFAULT_SERVER_SETTINGS,
+ enableAssistantStreaming: true,
+ defaultThreadEnvMode: "worktree" as const,
+ textGenerationModelSelection: {
+ provider: "codex" as const,
+ model: "gpt-5.4",
+ },
+ providers: {
+ codex: {
+ ...DEFAULT_SERVER_SETTINGS.providers.codex,
+ homePath: "/tmp/codex-home",
+ },
+ claudeAgent: {
+ ...DEFAULT_SERVER_SETTINGS.providers.claudeAgent,
+ enabled: false,
+ },
+ },
+ };
+ const requestPromise = runRpc((client) => client(WS_METHODS.serverGetSettings, {}));
+
+ await waitFor(() => {
+ expect(sockets).toHaveLength(1);
+ });
+
+ const socket = getSocket();
+ socket.open();
+
+ await waitFor(() => {
+ expect(socket.sent).toHaveLength(1);
+ });
+
+ const requestMessage = JSON.parse(socket.sent[0] ?? "{}") as { id: string; tag: string };
+ expect(requestMessage.tag).toBe(WS_METHODS.serverGetSettings);
+
+ socket.serverMessage(
+ JSON.stringify({
+ _tag: "Exit",
+ requestId: requestMessage.id,
+ exit: {
+ _tag: "Success",
+ value: expectedSettings,
+ },
+ }),
+ );
+
+ await expect(requestPromise).resolves.toEqual(expectedSettings);
+ });
+
+ it("exposes atom-backed query state for unary RPC methods", async () => {
+ const expectedSettings = {
+ ...DEFAULT_SERVER_SETTINGS,
+ enableAssistantStreaming: true,
+ defaultThreadEnvMode: "worktree" as const,
+ textGenerationModelSelection: {
+ provider: "codex" as const,
+ model: "gpt-5.4",
+ },
+ providers: {
+ codex: {
+ ...DEFAULT_SERVER_SETTINGS.providers.codex,
+ homePath: "/tmp/codex-home",
+ },
+ claudeAgent: {
+ ...DEFAULT_SERVER_SETTINGS.providers.claudeAgent,
+ enabled: false,
+ },
+ },
+ };
+ const registry = AtomRegistry.make();
+ const query = WsRpcAtomClient.query(WS_METHODS.serverGetSettings, {});
+ const release = registry.mount(query);
+
+ await waitFor(() => {
+ expect(sockets).toHaveLength(1);
+ });
+
+ const socket = getSocket();
+ socket.open();
+
+ await waitFor(() => {
+ expect(socket.sent).toHaveLength(1);
+ });
+
+ const requestMessage = JSON.parse(socket.sent[0] ?? "{}") as { id: string; tag: string };
+ expect(requestMessage.tag).toBe(WS_METHODS.serverGetSettings);
+ expect(registry.get(query)._tag).toBe("Initial");
+
+ socket.serverMessage(
+ JSON.stringify({
+ _tag: "Exit",
+ requestId: requestMessage.id,
+ exit: {
+ _tag: "Success",
+ value: expectedSettings,
+ },
+ }),
+ );
+
+ await waitFor(() => {
+ const result = registry.get(query);
+ expect(AsyncResult.isSuccess(result)).toBe(true);
+ if (!AsyncResult.isSuccess(result)) {
+ return;
+ }
+ expect(result.value).toEqual(expectedSettings);
+ });
+
+ release();
+ registry.dispose();
+ });
+});
diff --git a/apps/web/src/rpc/client.ts b/apps/web/src/rpc/client.ts
new file mode 100644
index 000000000..117f7c0aa
--- /dev/null
+++ b/apps/web/src/rpc/client.ts
@@ -0,0 +1,33 @@
+import { WsRpcGroup } from "@t3tools/contracts";
+import { Effect, Layer, ManagedRuntime } from "effect";
+import { AtomRpc } from "effect/unstable/reactivity";
+
+import { createWsRpcProtocolLayer } from "./protocol";
+
+export class WsRpcAtomClient extends AtomRpc.Service<WsRpcAtomClient>()("WsRpcAtomClient", {
+ group: WsRpcGroup,
+ protocol: Layer.suspend(() => createWsRpcProtocolLayer()),
+}) {}
+
+let sharedRuntime: ManagedRuntime.ManagedRuntime<WsRpcAtomClient, never> | null = null;
+
+function getRuntime() {
+ if (sharedRuntime !== null) {
+ return sharedRuntime;
+ }
+
+ sharedRuntime = ManagedRuntime.make(WsRpcAtomClient.layer);
+ return sharedRuntime;
+}
+
+export function runRpc<TSuccess, TError = never>(
+ execute: (client: typeof WsRpcAtomClient.Service) => Effect.Effect<TSuccess, TError, never>,
+): Promise<TSuccess> {
+ return getRuntime().runPromise(WsRpcAtomClient.use(execute));
+}
+
+export async function __resetWsRpcAtomClientForTests() {
+ const runtime = sharedRuntime;
+ sharedRuntime = null;
+ await runtime?.dispose();
+}
diff --git a/apps/web/src/rpc/protocol.ts b/apps/web/src/rpc/protocol.ts
new file mode 100644
index 000000000..38012e507
--- /dev/null
+++ b/apps/web/src/rpc/protocol.ts
@@ -0,0 +1,27 @@
+import { WsRpcGroup } from "@t3tools/contracts";
+import { Effect, Layer } from "effect";
+import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
+import * as Socket from "effect/unstable/socket/Socket";
+
+import { resolveServerUrl } from "../lib/utils";
+
+export const makeWsRpcProtocolClient = RpcClient.make(WsRpcGroup);
+
+type RpcClientFactory = typeof makeWsRpcProtocolClient;
+export type WsRpcProtocolClient =
+ RpcClientFactory extends Effect.Effect<infer Client, any, any> ? Client : never;
+
+export function createWsRpcProtocolLayer(url?: string) {
+ const resolvedUrl = resolveServerUrl({
+ url,
+ protocol: window.location.protocol === "https:" ? "wss" : "ws",
+ pathname: "/ws",
+ });
+ const socketLayer = Socket.layerWebSocket(resolvedUrl).pipe(
+ Layer.provide(Socket.layerWebSocketConstructorGlobal),
+ );
+
+ return RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(
+ Layer.provide(Layer.mergeAll(socketLayer, RpcSerialization.layerJson)),
+ );
+}
diff --git a/apps/web/src/rpc/serverState.test.ts b/apps/web/src/rpc/serverState.test.ts
new file mode 100644
index 000000000..8da5846fe
--- /dev/null
+++ b/apps/web/src/rpc/serverState.test.ts
@@ -0,0 +1,311 @@
+import {
+ DEFAULT_SERVER_SETTINGS,
+ ProjectId,
+ ThreadId,
+ type ServerConfig,
+ type ServerConfigStreamEvent,
+ type ServerLifecycleStreamEvent,
+ type ServerProvider,
+} from "@t3tools/contracts";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+ getServerConfig,
+ onProvidersUpdated,
+ onServerConfigUpdated,
+ onWelcome,
+ resetServerStateForTests,
+ startServerStateSync,
+} from "./serverState";
+
+function registerListener<T>(listeners: Set<(event: T) => void>, listener: (event: T) => void) {
+ listeners.add(listener);
+ return () => {
+ listeners.delete(listener);
+ };
+}
+
+function createDeferredPromise<T>() {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((nextResolve) => {
+ resolve = nextResolve;
+ });
+
+ return { promise, resolve };
+}
+
+const lifecycleListeners = new Set<(event: ServerLifecycleStreamEvent) => void>();
+const configListeners = new Set<(event: ServerConfigStreamEvent) => void>();
+
+const defaultProviders: ReadonlyArray<ServerProvider> = [
+ {
+ provider: "codex",
+ enabled: true,
+ installed: true,
+ version: "0.116.0",
+ status: "ready",
+ auth: { status: "authenticated" },
+ checkedAt: "2026-01-01T00:00:00.000Z",
+ models: [],
+ },
+];
+
+const baseServerConfig: ServerConfig = {
+ cwd: "/tmp/workspace",
+ keybindingsConfigPath: "/tmp/workspace/.config/keybindings.json",
+ keybindings: [],
+ issues: [],
+ providers: defaultProviders,
+ availableEditors: ["cursor"],
+ settings: DEFAULT_SERVER_SETTINGS,
+};
+
+const serverApi = {
+ getConfig: vi.fn<() => Promise<ServerConfig>>(),
+ subscribeConfig: vi.fn((listener: (event: ServerConfigStreamEvent) => void) =>
+ registerListener(configListeners, listener),
+ ),
+ subscribeLifecycle: vi.fn((listener: (event: ServerLifecycleStreamEvent) => void) =>
+ registerListener(lifecycleListeners, listener),
+ ),
+};
+
+function emitLifecycleEvent(event: ServerLifecycleStreamEvent) {
+ for (const listener of lifecycleListeners) {
+ listener(event);
+ }
+}
+
+function emitServerConfigEvent(event: ServerConfigStreamEvent) {
+ for (const listener of configListeners) {
+ listener(event);
+ }
+}
+
+async function waitFor(assertion: () => void, timeoutMs = 1_000): Promise<void> {
+ const startedAt = Date.now();
+ for (;;) {
+ try {
+ assertion();
+ return;
+ } catch (error) {
+ if (Date.now() - startedAt >= timeoutMs) {
+ throw error;
+ }
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ }
+ }
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ lifecycleListeners.clear();
+ configListeners.clear();
+ resetServerStateForTests();
+});
+
+afterEach(() => {
+ resetServerStateForTests();
+});
+
+describe("serverState", () => {
+ it("bootstraps the server config snapshot and replays it to late subscribers", async () => {
+ serverApi.getConfig.mockResolvedValueOnce(baseServerConfig);
+
+ const configListener = vi.fn();
+ const stop = startServerStateSync(serverApi);
+ const unsubscribe = onServerConfigUpdated(configListener);
+
+ await waitFor(() => {
+ expect(getServerConfig()).toEqual(baseServerConfig);
+ });
+
+ expect(serverApi.subscribeConfig).toHaveBeenCalledOnce();
+ expect(serverApi.subscribeLifecycle).toHaveBeenCalledOnce();
+ expect(serverApi.getConfig).toHaveBeenCalledOnce();
+ expect(configListener).toHaveBeenCalledWith(
+ {
+ issues: [],
+ providers: defaultProviders,
+ settings: DEFAULT_SERVER_SETTINGS,
+ },
+ "snapshot",
+ );
+
+ const lateListener = vi.fn();
+ const unsubscribeLate = onServerConfigUpdated(lateListener);
+ expect(lateListener).toHaveBeenCalledWith(
+ {
+ issues: [],
+ providers: defaultProviders,
+ settings: DEFAULT_SERVER_SETTINGS,
+ },
+ "snapshot",
+ );
+
+ unsubscribeLate();
+ unsubscribe();
+ stop();
+ });
+
+ it("keeps the streamed snapshot when it arrives before the fallback fetch resolves", async () => {
+ const deferred = createDeferredPromise<ServerConfig>();
+ serverApi.getConfig.mockReturnValueOnce(deferred.promise);
+ const stop = startServerStateSync(serverApi);
+
+ const streamedConfig: ServerConfig = {
+ ...baseServerConfig,
+ cwd: "/tmp/from-stream",
+ };
+
+ emitServerConfigEvent({
+ version: 1,
+ type: "snapshot",
+ config: streamedConfig,
+ });
+
+ await waitFor(() => {
+ expect(getServerConfig()).toEqual(streamedConfig);
+ });
+
+ deferred.resolve(baseServerConfig);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+
+ expect(getServerConfig()).toEqual(streamedConfig);
+ stop();
+ });
+
+ it("replays welcome events to late subscribers", async () => {
+ serverApi.getConfig.mockResolvedValueOnce(baseServerConfig);
+ const stop = startServerStateSync(serverApi);
+
+ const listener = vi.fn();
+ const unsubscribe = onWelcome(listener);
+
+ emitLifecycleEvent({
+ version: 1,
+ sequence: 1,
+ type: "welcome",
+ payload: {
+ cwd: "/tmp/workspace",
+ projectName: "t3-code",
+ bootstrapProjectId: ProjectId.makeUnsafe("project-1"),
+ bootstrapThreadId: ThreadId.makeUnsafe("thread-1"),
+ },
+ });
+
+ expect(listener).toHaveBeenCalledWith({
+ cwd: "/tmp/workspace",
+ projectName: "t3-code",
+ bootstrapProjectId: ProjectId.makeUnsafe("project-1"),
+ bootstrapThreadId: ThreadId.makeUnsafe("thread-1"),
+ });
+
+ const lateListener = vi.fn();
+ const unsubscribeLate = onWelcome(lateListener);
+ expect(lateListener).toHaveBeenCalledWith({
+ cwd: "/tmp/workspace",
+ projectName: "t3-code",
+ bootstrapProjectId: ProjectId.makeUnsafe("project-1"),
+ bootstrapThreadId: ThreadId.makeUnsafe("thread-1"),
+ });
+
+ unsubscribeLate();
+ unsubscribe();
+ stop();
+ });
+
+ it("merges provider, settings, and keybinding updates into the cached config", async () => {
+ serverApi.getConfig.mockResolvedValueOnce(baseServerConfig);
+ const configListener = vi.fn();
+ const providersListener = vi.fn();
+ const stop = startServerStateSync(serverApi);
+ const unsubscribeConfig = onServerConfigUpdated(configListener);
+ const unsubscribeProviders = onProvidersUpdated(providersListener);
+
+ await waitFor(() => {
+ expect(getServerConfig()).toEqual(baseServerConfig);
+ });
+
+ const nextProviders: ReadonlyArray<ServerProvider> = [
+ {
+ ...defaultProviders[0]!,
+ status: "warning",
+ checkedAt: "2026-01-02T00:00:00.000Z",
+ message: "rate limited",
+ },
+ ];
+
+ emitServerConfigEvent({
+ version: 1,
+ type: "keybindingsUpdated",
+ payload: {
+ issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
+ },
+ });
+ emitServerConfigEvent({
+ version: 1,
+ type: "providerStatuses",
+ payload: {
+ providers: nextProviders,
+ },
+ });
+ emitServerConfigEvent({
+ version: 1,
+ type: "settingsUpdated",
+ payload: {
+ settings: {
+ ...DEFAULT_SERVER_SETTINGS,
+ enableAssistantStreaming: true,
+ },
+ },
+ });
+
+ await waitFor(() => {
+ expect(getServerConfig()).toEqual({
+ ...baseServerConfig,
+ issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
+ providers: nextProviders,
+ settings: {
+ ...DEFAULT_SERVER_SETTINGS,
+ enableAssistantStreaming: true,
+ },
+ });
+ });
+
+ expect(providersListener).toHaveBeenLastCalledWith({ providers: nextProviders });
+ expect(configListener).toHaveBeenNthCalledWith(
+ 2,
+ {
+ issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
+ providers: defaultProviders,
+ settings: DEFAULT_SERVER_SETTINGS,
+ },
+ "keybindingsUpdated",
+ );
+ expect(configListener).toHaveBeenNthCalledWith(
+ 3,
+ {
+ issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
+ providers: nextProviders,
+ settings: DEFAULT_SERVER_SETTINGS,
+ },
+ "providerStatuses",
+ );
+ expect(configListener).toHaveBeenLastCalledWith(
+ {
+ issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
+ providers: nextProviders,
+ settings: {
+ ...DEFAULT_SERVER_SETTINGS,
+ enableAssistantStreaming: true,
+ },
+ },
+ "settingsUpdated",
+ );
+
+ unsubscribeProviders();
+ unsubscribeConfig();
+ stop();
+ });
+});
diff --git a/apps/web/src/rpc/serverState.ts b/apps/web/src/rpc/serverState.ts
new file mode 100644
index 000000000..ba4dcba17
--- /dev/null
+++ b/apps/web/src/rpc/serverState.ts
@@ -0,0 +1,280 @@
+import { useAtomSubscribe, useAtomValue } from "@effect/atom-react";
+import {
+ DEFAULT_SERVER_SETTINGS,
+ type EditorId,
+ type ServerConfig,
+ type ServerConfigStreamEvent,
+ type ServerConfigUpdatedPayload,
+ type ServerLifecycleWelcomePayload,
+ type ServerProvider,
+ type ServerProviderUpdatedPayload,
+ type ServerSettings,
+} from "@t3tools/contracts";
+import { Atom } from "effect/unstable/reactivity";
+
+import type { WsRpcClient } from "../wsRpcClient";
+import { appAtomRegistry, resetAppAtomRegistryForTests } from "./atomRegistry";
+
+export type ServerConfigUpdateSource = ServerConfigStreamEvent["type"];
+
+export interface ServerConfigUpdatedNotification {
+ readonly payload: ServerConfigUpdatedPayload;
+ readonly source: ServerConfigUpdateSource;
+}
+
+type ServerStateClient = Pick<
+ WsRpcClient["server"],
+ "getConfig" | "subscribeConfig" | "subscribeLifecycle"
+>;
+
+function makeStateAtom<A>(label: string, initialValue: A) {
+ return Atom.make(initialValue).pipe(Atom.keepAlive, Atom.withLabel(label));
+}
+
+function toServerConfigUpdatedPayload(config: ServerConfig): ServerConfigUpdatedPayload {
+ return {
+ issues: config.issues,
+ providers: config.providers,
+ settings: config.settings,
+ };
+}
+
+const EMPTY_AVAILABLE_EDITORS: ReadonlyArray<EditorId> = [];
+const EMPTY_KEYBINDINGS: ServerConfig["keybindings"] = [];
+const EMPTY_SERVER_PROVIDERS: ReadonlyArray<ServerProvider> = [];
+
+const selectAvailableEditors = (config: ServerConfig | null): ReadonlyArray<EditorId> =>
+ config?.availableEditors ?? EMPTY_AVAILABLE_EDITORS;
+const selectKeybindings = (config: ServerConfig | null) => config?.keybindings ?? EMPTY_KEYBINDINGS;
+const selectKeybindingsConfigPath = (config: ServerConfig | null) =>
+ config?.keybindingsConfigPath ?? null;
+const selectProviders = (config: ServerConfig | null) =>
+ config?.providers ?? EMPTY_SERVER_PROVIDERS;
+const selectSettings = (config: ServerConfig | null): ServerSettings =>
+ config?.settings ?? DEFAULT_SERVER_SETTINGS;
+
+export const welcomeAtom = makeStateAtom<ServerLifecycleWelcomePayload | null>(
+ "server-welcome",
+ null,
+);
+export const serverConfigAtom = makeStateAtom<ServerConfig | null>("server-config", null);
+export const serverConfigUpdatedAtom = makeStateAtom<ServerConfigUpdatedNotification | null>(
+ "server-config-updated",
+ null,
+);
+export const providersUpdatedAtom = makeStateAtom<ServerProviderUpdatedPayload | null>(
+ "server-providers-updated",
+ null,
+);
+
+export function getServerConfig(): ServerConfig | null {
+ return appAtomRegistry.get(serverConfigAtom);
+}
+
+export function setServerConfigSnapshot(config: ServerConfig): void {
+ resolveServerConfig(config);
+ emitProvidersUpdated({ providers: config.providers });
+ emitServerConfigUpdated(toServerConfigUpdatedPayload(config), "snapshot");
+}
+
+export function applyServerConfigEvent(event: ServerConfigStreamEvent): void {
+ switch (event.type) {
+ case "snapshot": {
+ setServerConfigSnapshot(event.config);
+ return;
+ }
+ case "keybindingsUpdated": {
+ const latestServerConfig = getServerConfig();
+ if (!latestServerConfig) {
+ return;
+ }
+ const nextConfig = {
+ ...latestServerConfig,
+ issues: event.payload.issues,
+ } satisfies ServerConfig;
+ resolveServerConfig(nextConfig);
+ emitServerConfigUpdated(toServerConfigUpdatedPayload(nextConfig), event.type);
+ return;
+ }
+ case "providerStatuses": {
+ applyProvidersUpdated(event.payload);
+ return;
+ }
+ case "settingsUpdated": {
+ applySettingsUpdated(event.payload.settings);
+ return;
+ }
+ }
+}
+
+export function applyProvidersUpdated(payload: ServerProviderUpdatedPayload): void {
+ const latestServerConfig = getServerConfig();
+ emitProvidersUpdated(payload);
+
+ if (!latestServerConfig) {
+ return;
+ }
+
+ const nextConfig = {
+ ...latestServerConfig,
+ providers: payload.providers,
+ } satisfies ServerConfig;
+ resolveServerConfig(nextConfig);
+ emitServerConfigUpdated(toServerConfigUpdatedPayload(nextConfig), "providerStatuses");
+}
+
+export function applySettingsUpdated(settings: ServerSettings): void {
+ const latestServerConfig = getServerConfig();
+ if (!latestServerConfig) {
+ return;
+ }
+
+ const nextConfig = {
+ ...latestServerConfig,
+ settings,
+ } satisfies ServerConfig;
+ resolveServerConfig(nextConfig);
+ emitServerConfigUpdated(toServerConfigUpdatedPayload(nextConfig), "settingsUpdated");
+}
+
+export function emitWelcome(payload: ServerLifecycleWelcomePayload): void {
+ appAtomRegistry.set(welcomeAtom, payload);
+}
+
+export function onWelcome(listener: (payload: ServerLifecycleWelcomePayload) => void): () => void {
+ return subscribeLatest(welcomeAtom, listener);
+}
+
+export function onServerConfigUpdated(
+ listener: (payload: ServerConfigUpdatedPayload, source: ServerConfigUpdateSource) => void,
+): () => void {
+ return subscribeLatest(serverConfigUpdatedAtom, (notification) => {
+ listener(notification.payload, notification.source);
+ });
+}
+
+export function onProvidersUpdated(
+ listener: (payload: ServerProviderUpdatedPayload) => void,
+): () => void {
+ return subscribeLatest(providersUpdatedAtom, listener);
+}
+
+export function startServerStateSync(client: ServerStateClient): () => void {
+ let disposed = false;
+ const cleanups = [
+ client.subscribeLifecycle((event) => {
+ if (event.type === "welcome") {
+ emitWelcome(event.payload);
+ }
+ }),
+ client.subscribeConfig((event) => {
+ applyServerConfigEvent(event);
+ }),
+ ];
+
+ if (getServerConfig() === null) {
+ void client
+ .getConfig()
+ .then((config) => {
+ if (disposed || getServerConfig() !== null) {
+ return;
+ }
+ setServerConfigSnapshot(config);
+ })
+ .catch(() => undefined);
+ }
+
+ return () => {
+ disposed = true;
+ for (const cleanup of cleanups) {
+ cleanup();
+ }
+ };
+}
+
+export function resetServerStateForTests() {
+ resetAppAtomRegistryForTests();
+}
+
+function resolveServerConfig(config: ServerConfig): void {
+ appAtomRegistry.set(serverConfigAtom, config);
+}
+
+function emitProvidersUpdated(payload: ServerProviderUpdatedPayload): void {
+ appAtomRegistry.set(providersUpdatedAtom, payload);
+}
+
+function emitServerConfigUpdated(
+ payload: ServerConfigUpdatedPayload,
+ source: ServerConfigUpdateSource,
+): void {
+ appAtomRegistry.set(serverConfigUpdatedAtom, { payload, source });
+}
+
+function subscribeLatest<A>(
+ atom: Atom.Atom<A | null>,
+ listener: (value: NonNullable<A>) => void,
+): () => void {
+ return appAtomRegistry.subscribe(
+ atom,
+ (value) => {
+ if (value === null) {
+ return;
+ }
+ listener(value as NonNullable<A>);
+ },
+ { immediate: true },
+ );
+}
+
+function useLatestAtomSubscription<A>(
+ atom: Atom.Atom<A | null>,
+ listener: (value: NonNullable<A>) => void,
+) {
+ useAtomSubscribe(
+ atom,
+ (value) => {
+ if (value === null) {
+ return;
+ }
+ listener(value as NonNullable<A>);
+ },
+ { immediate: true },
+ );
+}
+
+export function useServerConfig(): ServerConfig | null {
+ return useAtomValue(serverConfigAtom);
+}
+
+export function useServerSettings(): ServerSettings {
+ return useAtomValue(serverConfigAtom, selectSettings);
+}
+
+export function useServerProviders(): ReadonlyArray<ServerProvider> {
+ return useAtomValue(serverConfigAtom, selectProviders);
+}
+
+export function useServerKeybindings(): ServerConfig["keybindings"] {
+ return useAtomValue(serverConfigAtom, selectKeybindings);
+}
+
+export function useServerAvailableEditors(): ReadonlyArray<EditorId> {
+ return useAtomValue(serverConfigAtom, selectAvailableEditors);
+}
+
+export function useServerKeybindingsConfigPath(): string | null {
+ return useAtomValue(serverConfigAtom, selectKeybindingsConfigPath);
+}
+
+export function useServerWelcomeSubscription(
+ listener: (payload: ServerLifecycleWelcomePayload) => void,
+): void {
+ useLatestAtomSubscription(welcomeAtom, listener);
+}
+
+export function useServerConfigUpdatedSubscription(
+ listener: (notification: ServerConfigUpdatedNotification) => void,
+): void {
+ useLatestAtomSubscription(serverConfigUpdatedAtom, listener);
+}
diff --git a/apps/web/src/rpc/serverStateBootstrap.tsx b/apps/web/src/rpc/serverStateBootstrap.tsx
new file mode 100644
index 000000000..c5c5c12ea
--- /dev/null
+++ b/apps/web/src/rpc/serverStateBootstrap.tsx
@@ -0,0 +1,10 @@
+import { useEffect } from "react";
+
+import { getWsRpcClient } from "../wsRpcClient";
+import { startServerStateSync } from "./serverState";
+
+export function ServerStateBootstrap() {
+ useEffect(() => startServerStateSync(getWsRpcClient().server), []);
+
+ return null;
+}
diff --git a/apps/web/src/wsNativeApi.test.ts b/apps/web/src/wsNativeApi.test.ts
index be53eefd9..c9bcc7ffd 100644
--- a/apps/web/src/wsNativeApi.test.ts
+++ b/apps/web/src/wsNativeApi.test.ts
@@ -1,23 +1,19 @@
import {
CommandId,
- type ContextMenuItem,
+ DEFAULT_SERVER_SETTINGS,
+ type DesktopBridge,
EventId,
- ORCHESTRATION_WS_CHANNELS,
- ORCHESTRATION_WS_METHODS,
- type OrchestrationEvent,
ProjectId,
- ThreadId,
- type WsPushChannel,
- type WsPushData,
- type WsPushMessage,
- WS_CHANNELS,
- WS_METHODS,
- type WsPush,
+ type OrchestrationEvent,
+ type ServerConfig,
type ServerProvider,
+ type TerminalEvent,
+ ThreadId,
} from "@t3tools/contracts";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const requestMock = vi.fn<(...args: Array<unknown>) => Promise<unknown>>();
+import type { ContextMenuItem } from "@t3tools/contracts";
+
const showContextMenuFallbackMock =
vi.fn<
<T extends string>(
@@ -25,39 +21,75 @@ const showContextMenuFallbackMock =
position?: { x: number; y: number },
) => Promise<T | null>
>();
-const channelListeners = new Map<string, Set<(message: WsPush) => void>>();
-const latestPushByChannel = new Map<string, WsPush>();
-const subscribeMock = vi.fn<
- (
- channel: string,
- listener: (message: WsPush) => void,
- options?: { replayLatest?: boolean },
- ) => () => void
->((channel, listener, options) => {
- const listeners = channelListeners.get(channel) ?? new Set<(message: WsPush) => void>();
+
+function registerListener<T>(listeners: Set<(event: T) => void>, listener: (event: T) => void) {
listeners.add(listener);
- channelListeners.set(channel, listeners);
- const latest = latestPushByChannel.get(channel);
- if (latest && options?.replayLatest) {
- listener(latest);
- }
return () => {
listeners.delete(listener);
- if (listeners.size === 0) {
- channelListeners.delete(channel);
- }
};
-});
+}
-vi.mock("./wsTransport", () => {
+const terminalEventListeners = new Set<(event: TerminalEvent) => void>();
+const orchestrationEventListeners = new Set<(event: OrchestrationEvent) => void>();
+
+const rpcClientMock = {
+ dispose: vi.fn(),
+ terminal: {
+ open: vi.fn(),
+ write: vi.fn(),
+ resize: vi.fn(),
+ clear: vi.fn(),
+ restart: vi.fn(),
+ close: vi.fn(),
+ onEvent: vi.fn((listener: (event: TerminalEvent) => void) =>
+ registerListener(terminalEventListeners, listener),
+ ),
+ },
+ projects: {
+ searchEntries: vi.fn(),
+ writeFile: vi.fn(),
+ },
+ shell: {
+ openInEditor: vi.fn(),
+ },
+ git: {
+ pull: vi.fn(),
+ status: vi.fn(),
+ runStackedAction: vi.fn(),
+ listBranches: vi.fn(),
+ createWorktree: vi.fn(),
+ removeWorktree: vi.fn(),
+ createBranch: vi.fn(),
+ checkout: vi.fn(),
+ init: vi.fn(),
+ resolvePullRequest: vi.fn(),
+ preparePullRequestThread: vi.fn(),
+ },
+ server: {
+ getConfig: vi.fn(),
+ refreshProviders: vi.fn(),
+ upsertKeybinding: vi.fn(),
+ getSettings: vi.fn(),
+ updateSettings: vi.fn(),
+ subscribeConfig: vi.fn(),
+ subscribeLifecycle: vi.fn(),
+ },
+ orchestration: {
+ getSnapshot: vi.fn(),
+ dispatchCommand: vi.fn(),
+ getTurnDiff: vi.fn(),
+ getFullThreadDiff: vi.fn(),
+ replayEvents: vi.fn(),
+ onDomainEvent: vi.fn((listener: (event: OrchestrationEvent) => void) =>
+ registerListener(orchestrationEventListeners, listener),
+ ),
+ },
+};
+
+vi.mock("./wsRpcClient", () => {
return {
- WsTransport: class MockWsTransport {
- request = requestMock;
- subscribe = subscribeMock;
- getLatestPush(channel: string) {
- return latestPushByChannel.get(channel) ?? null;
- }
- },
+ getWsRpcClient: () => rpcClientMock,
+ __resetWsRpcClientForTests: vi.fn(),
};
});
@@ -65,20 +97,9 @@ vi.mock("./contextMenuFallback", () => ({
showContextMenuFallback: showContextMenuFallbackMock,
}));
-let nextPushSequence = 1;
-
-function emitPush<C extends WsPushChannel>(channel: C, data: WsPushData<C>): void {
- const listeners = channelListeners.get(channel);
- const message = {
- type: "push" as const,
- sequence: nextPushSequence++,
- channel,
- data,
- } as WsPushMessage<C>;
- latestPushByChannel.set(channel, message);
- if (!listeners) return;
+function emitEvent<T>(listeners: Set<(event: T) => void>, event: T) {
for (const listener of listeners) {
- listener(message);
+ listener(event);
}
}
@@ -92,6 +113,32 @@ function getWindowForTest(): Window & typeof globalThis & { desktopBridge?: unkn
return testGlobal.window;
}
+function makeDesktopBridge(overrides: Partial<DesktopBridge> = {}): DesktopBridge {
+ return {
+ getWsUrl: () => null,
+ pickFolder: async () => null,
+ confirm: async () => true,
+ setTheme: async () => undefined,
+ showContextMenu: async () => null,
+ openExternal: async () => true,
+ onMenuAction: () => () => undefined,
+ getUpdateState: async () => {
+ throw new Error("getUpdateState not implemented in test");
+ },
+ checkForUpdate: async () => {
+ throw new Error("checkForUpdate not implemented in test");
+ },
+ downloadUpdate: async () => {
+ throw new Error("downloadUpdate not implemented in test");
+ },
+ installUpdate: async () => {
+ throw new Error("installUpdate not implemented in test");
+ },
+ onUpdateState: () => () => undefined,
+ ...overrides,
+ };
+}
+
const defaultProviders: ReadonlyArray<ServerProvider> = [
{
provider: "codex",
@@ -105,14 +152,22 @@ const defaultProviders: ReadonlyArray<ServerProvider> = [
},
];
+const baseServerConfig: ServerConfig = {
+ cwd: "/tmp/workspace",
+ keybindingsConfigPath: "/tmp/workspace/.config/keybindings.json",
+ keybindings: [],
+ issues: [],
+ providers: defaultProviders,
+ availableEditors: ["cursor"],
+ settings: DEFAULT_SERVER_SETTINGS,
+};
+
beforeEach(() => {
vi.resetModules();
- requestMock.mockReset();
+ vi.clearAllMocks();
showContextMenuFallbackMock.mockReset();
- subscribeMock.mockClear();
- channelListeners.clear();
- latestPushByChannel.clear();
- nextPushSequence = 1;
+ terminalEventListeners.clear();
+ orchestrationEventListeners.clear();
Reflect.deleteProperty(getWindowForTest(), "desktopBridge");
});
@@ -121,149 +176,27 @@ afterEach(() => {
});
describe("wsNativeApi", () => {
- it("delivers and caches valid server.welcome payloads", async () => {
- const { createWsNativeApi, onServerWelcome } = await import("./wsNativeApi");
-
- createWsNativeApi();
- const listener = vi.fn();
- onServerWelcome(listener);
-
- const payload = { cwd: "/tmp/workspace", projectName: "t3-code" };
- emitPush(WS_CHANNELS.serverWelcome, payload);
-
- expect(listener).toHaveBeenCalledTimes(1);
- expect(listener).toHaveBeenCalledWith(expect.objectContaining(payload));
-
- const lateListener = vi.fn();
- onServerWelcome(lateListener);
-
- expect(lateListener).toHaveBeenCalledTimes(1);
- expect(lateListener).toHaveBeenCalledWith(expect.objectContaining(payload));
- });
-
- it("preserves bootstrap ids from server.welcome payloads", async () => {
- const { createWsNativeApi, onServerWelcome } = await import("./wsNativeApi");
-
- createWsNativeApi();
- const listener = vi.fn();
- onServerWelcome(listener);
-
- emitPush(WS_CHANNELS.serverWelcome, {
- cwd: "/tmp/workspace",
- projectName: "t3-code",
- bootstrapProjectId: ProjectId.makeUnsafe("project-1"),
- bootstrapThreadId: ThreadId.makeUnsafe("thread-1"),
- });
-
- expect(listener).toHaveBeenCalledTimes(1);
- expect(listener).toHaveBeenCalledWith(
- expect.objectContaining({
- cwd: "/tmp/workspace",
- projectName: "t3-code",
- bootstrapProjectId: "project-1",
- bootstrapThreadId: "thread-1",
- }),
- );
- });
-
- it("delivers successive server.welcome payloads to active listeners", async () => {
- const { createWsNativeApi, onServerWelcome } = await import("./wsNativeApi");
-
- createWsNativeApi();
- const listener = vi.fn();
- onServerWelcome(listener);
-
- emitPush(WS_CHANNELS.serverWelcome, { cwd: "/tmp/one", projectName: "one" });
- emitPush(WS_CHANNELS.serverWelcome, { cwd: "/tmp/workspace", projectName: "t3-code" });
-
- expect(listener).toHaveBeenCalledTimes(2);
- expect(listener).toHaveBeenLastCalledWith(
- expect.objectContaining({
- cwd: "/tmp/workspace",
- projectName: "t3-code",
- }),
- );
- });
-
- it("delivers and caches valid server.configUpdated payloads", async () => {
- const { createWsNativeApi, onServerConfigUpdated } = await import("./wsNativeApi");
-
- createWsNativeApi();
- const listener = vi.fn();
- onServerConfigUpdated(listener);
-
- const payload = {
- issues: [
- {
- kind: "keybindings.invalid-entry",
- index: 1,
- message: "Entry at index 1 is invalid.",
- },
- ],
- } as const;
- emitPush(WS_CHANNELS.serverConfigUpdated, payload);
-
- expect(listener).toHaveBeenCalledTimes(1);
- expect(listener).toHaveBeenCalledWith(payload);
-
- const lateListener = vi.fn();
- onServerConfigUpdated(lateListener);
- expect(lateListener).toHaveBeenCalledTimes(1);
- expect(lateListener).toHaveBeenCalledWith(payload);
- });
-
- it("delivers successive server.configUpdated payloads to active listeners", async () => {
- const { createWsNativeApi, onServerConfigUpdated } = await import("./wsNativeApi");
-
- createWsNativeApi();
- const listener = vi.fn();
- onServerConfigUpdated(listener);
-
- emitPush(WS_CHANNELS.serverConfigUpdated, {
- issues: [{ kind: "keybindings.malformed-config", message: "bad json" }],
- });
- emitPush(WS_CHANNELS.serverConfigUpdated, {
- issues: [],
- });
-
- expect(listener).toHaveBeenCalledTimes(2);
- expect(listener).toHaveBeenLastCalledWith({
- issues: [],
- });
- });
-
- it("delivers and caches valid server.providersUpdated payloads", async () => {
- const { createWsNativeApi, onServerProvidersUpdated } = await import("./wsNativeApi");
-
- createWsNativeApi();
- const listener = vi.fn();
- onServerProvidersUpdated(listener);
-
- const payload = {
- providers: defaultProviders,
- } as const;
- emitPush(WS_CHANNELS.serverProvidersUpdated, payload);
+ it("forwards server config fetches directly to the RPC client", async () => {
+ rpcClientMock.server.getConfig.mockResolvedValue(baseServerConfig);
+ const { createWsNativeApi } = await import("./wsNativeApi");
- expect(listener).toHaveBeenCalledTimes(1);
- expect(listener).toHaveBeenCalledWith(payload);
+ const api = createWsNativeApi();
- const lateListener = vi.fn();
- onServerProvidersUpdated(lateListener);
- expect(lateListener).toHaveBeenCalledTimes(1);
- expect(lateListener).toHaveBeenCalledWith(payload);
+ await expect(api.server.getConfig()).resolves.toEqual(baseServerConfig);
+ expect(rpcClientMock.server.getConfig).toHaveBeenCalledWith();
+ expect(rpcClientMock.server.subscribeConfig).not.toHaveBeenCalled();
+ expect(rpcClientMock.server.subscribeLifecycle).not.toHaveBeenCalled();
});
- it("forwards valid terminal and orchestration events", async () => {
+ it("forwards terminal and orchestration stream events", async () => {
const { createWsNativeApi } = await import("./wsNativeApi");
const api = createWsNativeApi();
const onTerminalEvent = vi.fn();
const onDomainEvent = vi.fn();
- const onActionProgress = vi.fn();
api.terminal.onEvent(onTerminalEvent);
api.orchestration.onDomainEvent(onDomainEvent);
- api.git.onActionProgress(onActionProgress);
const terminalEvent = {
threadId: "thread-1",
@@ -272,7 +205,7 @@ describe("wsNativeApi", () => {
type: "output",
data: "hello",
} as const;
- emitPush(WS_CHANNELS.terminalEvent, terminalEvent);
+ emitEvent(terminalEventListeners, terminalEvent);
const orchestrationEvent = {
sequence: 1,
@@ -289,39 +222,23 @@ describe("wsNativeApi", () => {
projectId: ProjectId.makeUnsafe("project-1"),
title: "Project",
workspaceRoot: "/tmp/workspace",
- defaultModelSelection: null,
+ defaultModelSelection: {
+ provider: "codex",
+ model: "gpt-5-codex",
+ },
scripts: [],
createdAt: "2026-02-24T00:00:00.000Z",
updatedAt: "2026-02-24T00:00:00.000Z",
},
} satisfies Extract<OrchestrationEvent, { type: "project.created" }>;
- emitPush(ORCHESTRATION_WS_CHANNELS.domainEvent, orchestrationEvent);
- emitPush(WS_CHANNELS.gitActionProgress, {
- actionId: "action-1",
- cwd: "/repo",
- action: "commit",
- kind: "phase_started",
- phase: "commit",
- label: "Committing...",
- });
+ emitEvent(orchestrationEventListeners, orchestrationEvent);
- expect(onTerminalEvent).toHaveBeenCalledTimes(1);
expect(onTerminalEvent).toHaveBeenCalledWith(terminalEvent);
- expect(onDomainEvent).toHaveBeenCalledTimes(1);
expect(onDomainEvent).toHaveBeenCalledWith(orchestrationEvent);
- expect(onActionProgress).toHaveBeenCalledTimes(1);
- expect(onActionProgress).toHaveBeenCalledWith({
- actionId: "action-1",
- cwd: "/repo",
- action: "commit",
- kind: "phase_started",
- phase: "commit",
- label: "Committing...",
- });
});
- it("wraps orchestration dispatch commands in the command envelope", async () => {
- requestMock.mockResolvedValue(undefined);
+ it("sends orchestration dispatch commands as the direct RPC payload", async () => {
+ rpcClientMock.orchestration.dispatchCommand.mockResolvedValue({ sequence: 1 });
const { createWsNativeApi } = await import("./wsNativeApi");
const api = createWsNativeApi();
@@ -339,13 +256,11 @@ describe("wsNativeApi", () => {
} as const;
await api.orchestration.dispatchCommand(command);
- expect(requestMock).toHaveBeenCalledWith(ORCHESTRATION_WS_METHODS.dispatchCommand, {
- command,
- });
+ expect(rpcClientMock.orchestration.dispatchCommand).toHaveBeenCalledWith(command);
});
- it("forwards workspace file writes to the websocket project method", async () => {
- requestMock.mockResolvedValue({ relativePath: "plan.md" });
+ it("forwards workspace file writes to the project RPC", async () => {
+ rpcClientMock.projects.writeFile.mockResolvedValue({ relativePath: "plan.md" });
const { createWsNativeApi } = await import("./wsNativeApi");
const api = createWsNativeApi();
@@ -355,100 +270,83 @@ describe("wsNativeApi", () => {
contents: "# Plan\n",
});
- expect(requestMock).toHaveBeenCalledWith(WS_METHODS.projectsWriteFile, {
+ expect(rpcClientMock.projects.writeFile).toHaveBeenCalledWith({
cwd: "/tmp/project",
relativePath: "plan.md",
contents: "# Plan\n",
});
});
- it("uses no client timeout for git.runStackedAction", async () => {
- requestMock.mockResolvedValue({
- action: "commit",
- branch: { status: "skipped_not_requested" },
- commit: { status: "created", commitSha: "abc1234", subject: "Test" },
- push: { status: "skipped_not_requested" },
- pr: { status: "skipped_not_requested" },
- });
+ it("forwards full-thread diff requests to the orchestration RPC", async () => {
+ rpcClientMock.orchestration.getFullThreadDiff.mockResolvedValue({ diff: "patch" });
const { createWsNativeApi } = await import("./wsNativeApi");
const api = createWsNativeApi();
- await api.git.runStackedAction({
- actionId: "action-1",
- cwd: "/repo",
- action: "commit",
+ await api.orchestration.getFullThreadDiff({
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ toTurnCount: 1,
});
- expect(requestMock).toHaveBeenCalledWith(
- WS_METHODS.gitRunStackedAction,
+ expect(rpcClientMock.orchestration.getFullThreadDiff).toHaveBeenCalledWith({
+ threadId: "thread-1",
+ toTurnCount: 1,
+ });
+ });
+
+ it("forwards provider refreshes directly to the RPC client", async () => {
+ const nextProviders: ReadonlyArray<ServerProvider> = [
{
- actionId: "action-1",
- cwd: "/repo",
- action: "commit",
+ ...defaultProviders[0]!,
+ checkedAt: "2026-01-03T00:00:00.000Z",
},
- { timeoutMs: null },
- );
+ ];
+ rpcClientMock.server.refreshProviders.mockResolvedValue({ providers: nextProviders });
+ const { createWsNativeApi } = await import("./wsNativeApi");
+
+ const api = createWsNativeApi();
+
+ await expect(api.server.refreshProviders()).resolves.toEqual({ providers: nextProviders });
+ expect(rpcClientMock.server.refreshProviders).toHaveBeenCalledWith();
});
- it("forwards full-thread diff requests to the orchestration websocket method", async () => {
- requestMock.mockResolvedValue({ diff: "patch" });
+ it("forwards server settings updates directly to the RPC client", async () => {
+ const nextSettings = {
+ ...DEFAULT_SERVER_SETTINGS,
+ enableAssistantStreaming: true,
+ };
+ rpcClientMock.server.updateSettings.mockResolvedValue(nextSettings);
const { createWsNativeApi } = await import("./wsNativeApi");
const api = createWsNativeApi();
- await api.orchestration.getFullThreadDiff({
- threadId: ThreadId.makeUnsafe("thread-1"),
- toTurnCount: 1,
- });
- expect(requestMock).toHaveBeenCalledWith(ORCHESTRATION_WS_METHODS.getFullThreadDiff, {
- threadId: "thread-1",
- toTurnCount: 1,
+ await expect(api.server.updateSettings({ enableAssistantStreaming: true })).resolves.toEqual(
+ nextSettings,
+ );
+ expect(rpcClientMock.server.updateSettings).toHaveBeenCalledWith({
+ enableAssistantStreaming: true,
});
});
- it("forwards context menu metadata to desktop bridge", async () => {
+ it("forwards context menu metadata to the desktop bridge", async () => {
const showContextMenu = vi.fn().mockResolvedValue("delete");
- Object.defineProperty(getWindowForTest(), "desktopBridge", {
- configurable: true,
- writable: true,
- value: {
- showContextMenu,
- },
- });
+ getWindowForTest().desktopBridge = makeDesktopBridge({ showContextMenu });
const { createWsNativeApi } = await import("./wsNativeApi");
const api = createWsNativeApi();
- await api.contextMenu.show(
- [
- { id: "rename", label: "Rename thread" },
- { id: "delete", label: "Delete", destructive: true },
- ],
- { x: 200, y: 300 },
- );
+ const items = [{ id: "delete", label: "Delete" }] as const;
- expect(showContextMenu).toHaveBeenCalledWith(
- [
- { id: "rename", label: "Rename thread" },
- { id: "delete", label: "Delete", destructive: true },
- ],
- { x: 200, y: 300 },
- );
+ await expect(api.contextMenu.show(items)).resolves.toBe("delete");
+ expect(showContextMenu).toHaveBeenCalledWith(items, undefined);
});
- it("uses fallback context menu when desktop bridge is unavailable", async () => {
- showContextMenuFallbackMock.mockResolvedValue("delete");
- Reflect.deleteProperty(getWindowForTest(), "desktopBridge");
-
+ it("falls back to the browser context menu helper when the desktop bridge is missing", async () => {
+ showContextMenuFallbackMock.mockResolvedValue("rename");
const { createWsNativeApi } = await import("./wsNativeApi");
+
const api = createWsNativeApi();
- await api.contextMenu.show([{ id: "delete", label: "Delete", destructive: true }], {
- x: 20,
- y: 30,
- });
+ const items = [{ id: "rename", label: "Rename" }] as const;
- expect(showContextMenuFallbackMock).toHaveBeenCalledWith(
- [{ id: "delete", label: "Delete", destructive: true }],
- { x: 20, y: 30 },
- );
+ await expect(api.contextMenu.show(items, { x: 4, y: 5 })).resolves.toBe("rename");
+ expect(showContextMenuFallbackMock).toHaveBeenCalledWith(items, { x: 4, y: 5 });
});
});
diff --git a/apps/web/src/wsNativeApi.ts b/apps/web/src/wsNativeApi.ts
index 7024ffdb4..31160dfa1 100644
--- a/apps/web/src/wsNativeApi.ts
+++ b/apps/web/src/wsNativeApi.ts
@@ -1,136 +1,23 @@
-import {
- type GitActionProgressEvent,
- ORCHESTRATION_WS_CHANNELS,
- ORCHESTRATION_WS_METHODS,
- type ContextMenuItem,
- type NativeApi,
- ServerConfigUpdatedPayload,
- ServerProviderUpdatedPayload,
- WS_CHANNELS,
- WS_METHODS,
- type WsWelcomePayload,
-} from "@t3tools/contracts";
+import { type ContextMenuItem, type NativeApi } from "@t3tools/contracts";
import { showContextMenuFallback } from "./contextMenuFallback";
-import { WsTransport } from "./wsTransport";
+import { resetServerStateForTests } from "./rpc/serverState";
+import { __resetWsRpcClientForTests, getWsRpcClient } from "./wsRpcClient";
-let instance: { api: NativeApi; transport: WsTransport } | null = null;
-const welcomeListeners = new Set<(payload: WsWelcomePayload) => void>();
-const serverConfigUpdatedListeners = new Set<(payload: ServerConfigUpdatedPayload) => void>();
-const providersUpdatedListeners = new Set<(payload: ServerProviderUpdatedPayload) => void>();
-const gitActionProgressListeners = new Set<(payload: GitActionProgressEvent) => void>();
+let instance: { api: NativeApi } | null = null;
-/**
- * Subscribe to the server welcome message. If a welcome was already received
- * before this call, the listener fires synchronously with the cached payload.
- * This avoids the race between WebSocket connect and React effect registration.
- */
-export function onServerWelcome(listener: (payload: WsWelcomePayload) => void): () => void {
- welcomeListeners.add(listener);
-
- const latestWelcome = instance?.transport.getLatestPush(WS_CHANNELS.serverWelcome)?.data ?? null;
- if (latestWelcome) {
- try {
- listener(latestWelcome);
- } catch {
- // Swallow listener errors
- }
- }
-
- return () => {
- welcomeListeners.delete(listener);
- };
-}
-
-/**
- * Subscribe to server config update events. Replays the latest update for
- * late subscribers to avoid missing config validation feedback.
- */
-export function onServerConfigUpdated(
- listener: (payload: ServerConfigUpdatedPayload) => void,
-): () => void {
- serverConfigUpdatedListeners.add(listener);
-
- const latestConfig =
- instance?.transport.getLatestPush(WS_CHANNELS.serverConfigUpdated)?.data ?? null;
- if (latestConfig) {
- try {
- listener(latestConfig);
- } catch {
- // Swallow listener errors
- }
- }
-
- return () => {
- serverConfigUpdatedListeners.delete(listener);
- };
-}
-
-export function onServerProvidersUpdated(
- listener: (payload: ServerProviderUpdatedPayload) => void,
-): () => void {
- providersUpdatedListeners.add(listener);
-
- const latestProviders =
- instance?.transport.getLatestPush(WS_CHANNELS.serverProvidersUpdated)?.data ?? null;
- if (latestProviders) {
- try {
- listener(latestProviders);
- } catch {
- // Swallow listener errors
- }
- }
-
- return () => {
- providersUpdatedListeners.delete(listener);
- };
+export function __resetWsNativeApiForTests() {
+ instance = null;
+ __resetWsRpcClientForTests();
+ resetServerStateForTests();
}
export function createWsNativeApi(): NativeApi {
- if (instance) return instance.api;
-
- const transport = new WsTransport();
+ if (instance) {
+ return instance.api;
+ }
- transport.subscribe(WS_CHANNELS.serverWelcome, (message) => {
- const payload = message.data;
- for (const listener of welcomeListeners) {
- try {
- listener(payload);
- } catch {
- // Swallow listener errors
- }
- }
- });
- transport.subscribe(WS_CHANNELS.serverConfigUpdated, (message) => {
- const payload = message.data;
- for (const listener of serverConfigUpdatedListeners) {
- try {
- listener(payload);
- } catch {
- // Swallow listener errors
- }
- }
- });
- transport.subscribe(WS_CHANNELS.serverProvidersUpdated, (message) => {
- const payload = message.data;
- for (const listener of providersUpdatedListeners) {
- try {
- listener(payload);
- } catch {
- // Swallow listener errors
- }
- }
- });
- transport.subscribe(WS_CHANNELS.gitActionProgress, (message) => {
- const payload = message.data;
- for (const listener of gitActionProgressListeners) {
- try {
- listener(payload);
- } catch {
- // Swallow listener errors
- }
- }
- });
+ const rpcClient = getWsRpcClient();
const api: NativeApi = {
dialogs: {
@@ -146,22 +33,20 @@ export function createWsNativeApi(): NativeApi {
},
},
terminal: {
- open: (input) => transport.request(WS_METHODS.terminalOpen, input),
- write: (input) => transport.request(WS_METHODS.terminalWrite, input),
- resize: (input) => transport.request(WS_METHODS.terminalResize, input),
- clear: (input) => transport.request(WS_METHODS.terminalClear, input),
- restart: (input) => transport.request(WS_METHODS.terminalRestart, input),
- close: (input) => transport.request(WS_METHODS.terminalClose, input),
- onEvent: (callback) =>
- transport.subscribe(WS_CHANNELS.terminalEvent, (message) => callback(message.data)),
+ open: (input) => rpcClient.terminal.open(input as never),
+ write: (input) => rpcClient.terminal.write(input as never),
+ resize: (input) => rpcClient.terminal.resize(input as never),
+ clear: (input) => rpcClient.terminal.clear(input as never),
+ restart: (input) => rpcClient.terminal.restart(input as never),
+ close: (input) => rpcClient.terminal.close(input as never),
+ onEvent: (callback) => rpcClient.terminal.onEvent(callback),
},
projects: {
- searchEntries: (input) => transport.request(WS_METHODS.projectsSearchEntries, input),
- writeFile: (input) => transport.request(WS_METHODS.projectsWriteFile, input),
+ searchEntries: rpcClient.projects.searchEntries,
+ writeFile: rpcClient.projects.writeFile,
},
shell: {
- openInEditor: (cwd, editor) =>
- transport.request(WS_METHODS.shellOpenInEditor, { cwd, editor }),
+ openInEditor: (cwd, editor) => rpcClient.shell.openInEditor({ cwd, editor }),
openExternal: async (url) => {
if (window.desktopBridge) {
const opened = await window.desktopBridge.openExternal(url);
@@ -171,31 +56,20 @@ export function createWsNativeApi(): NativeApi {
return;
}
- // Some mobile browsers can return null here even when the tab opens.
- // Avoid false negatives and let the browser handle popup policy.
window.open(url, "_blank", "noopener,noreferrer");
},
},
git: {
- pull: (input) => transport.request(WS_METHODS.gitPull, input),
- status: (input) => transport.request(WS_METHODS.gitStatus, input),
- runStackedAction: (input) =>
- transport.request(WS_METHODS.gitRunStackedAction, input, { timeoutMs: null }),
- listBranches: (input) => transport.request(WS_METHODS.gitListBranches, input),
- createWorktree: (input) => transport.request(WS_METHODS.gitCreateWorktree, input),
- removeWorktree: (input) => transport.request(WS_METHODS.gitRemoveWorktree, input),
- createBranch: (input) => transport.request(WS_METHODS.gitCreateBranch, input),
- checkout: (input) => transport.request(WS_METHODS.gitCheckout, input),
- init: (input) => transport.request(WS_METHODS.gitInit, input),
- resolvePullRequest: (input) => transport.request(WS_METHODS.gitResolvePullRequest, input),
- preparePullRequestThread: (input) =>
- transport.request(WS_METHODS.gitPreparePullRequestThread, input),
- onActionProgress: (callback) => {
- gitActionProgressListeners.add(callback);
- return () => {
- gitActionProgressListeners.delete(callback);
- };
- },
+ pull: rpcClient.git.pull,
+ status: rpcClient.git.status,
+ listBranches: rpcClient.git.listBranches,
+ createWorktree: rpcClient.git.createWorktree,
+ removeWorktree: rpcClient.git.removeWorktree,
+ createBranch: rpcClient.git.createBranch,
+ checkout: rpcClient.git.checkout,
+ init: rpcClient.git.init,
+ resolvePullRequest: rpcClient.git.resolvePullRequest,
+ preparePullRequestThread: rpcClient.git.preparePullRequestThread,
},
contextMenu: {
show: async <T extends string>(
@@ -209,28 +83,25 @@ export function createWsNativeApi(): NativeApi {
},
},
server: {
- getConfig: () => transport.request(WS_METHODS.serverGetConfig),
- refreshProviders: () => transport.request(WS_METHODS.serverRefreshProviders),
- upsertKeybinding: (input) => transport.request(WS_METHODS.serverUpsertKeybinding, input),
- getSettings: () => transport.request(WS_METHODS.serverGetSettings),
- updateSettings: (patch) => transport.request(WS_METHODS.serverUpdateSettings, { patch }),
+ getConfig: rpcClient.server.getConfig,
+ refreshProviders: rpcClient.server.refreshProviders,
+ upsertKeybinding: rpcClient.server.upsertKeybinding,
+ getSettings: rpcClient.server.getSettings,
+ updateSettings: rpcClient.server.updateSettings,
},
orchestration: {
- getSnapshot: () => transport.request(ORCHESTRATION_WS_METHODS.getSnapshot),
- dispatchCommand: (command) =>
- transport.request(ORCHESTRATION_WS_METHODS.dispatchCommand, { command }),
- getTurnDiff: (input) => transport.request(ORCHESTRATION_WS_METHODS.getTurnDiff, input),
- getFullThreadDiff: (input) =>
- transport.request(ORCHESTRATION_WS_METHODS.getFullThreadDiff, input),
+ getSnapshot: rpcClient.orchestration.getSnapshot,
+ dispatchCommand: rpcClient.orchestration.dispatchCommand,
+ getTurnDiff: rpcClient.orchestration.getTurnDiff,
+ getFullThreadDiff: rpcClient.orchestration.getFullThreadDiff,
replayEvents: (fromSequenceExclusive) =>
- transport.request(ORCHESTRATION_WS_METHODS.replayEvents, { fromSequenceExclusive }),
- onDomainEvent: (callback) =>
- transport.subscribe(ORCHESTRATION_WS_CHANNELS.domainEvent, (message) =>
- callback(message.data),
- ),
+ rpcClient.orchestration
+ .replayEvents({ fromSequenceExclusive })
+ .then((events) => [...events]),
+ onDomainEvent: (callback) => rpcClient.orchestration.onDomainEvent(callback),
},
};
- instance = { api, transport };
+ instance = { api };
return api;
}
diff --git a/apps/web/src/wsRpcClient.ts b/apps/web/src/wsRpcClient.ts
new file mode 100644
index 000000000..60f51ba70
--- /dev/null
+++ b/apps/web/src/wsRpcClient.ts
@@ -0,0 +1,207 @@
+import {
+ type GitActionProgressEvent,
+ type GitRunStackedActionInput,
+ type GitRunStackedActionResult,
+ type NativeApi,
+ ORCHESTRATION_WS_METHODS,
+ type ServerSettingsPatch,
+ WS_METHODS,
+} from "@t3tools/contracts";
+import { Effect, Stream } from "effect";
+
+import { type WsRpcProtocolClient } from "./rpc/protocol";
+import { WsTransport } from "./wsTransport";
+
+type RpcTag = keyof WsRpcProtocolClient & string;
+type RpcMethod<TTag extends RpcTag> = WsRpcProtocolClient[TTag];
+type RpcInput<TTag extends RpcTag> = Parameters<RpcMethod<TTag>>[0];
+
+type RpcUnaryMethod<TTag extends RpcTag> =
+ RpcMethod<TTag> extends (input: any, options?: any) => Effect.Effect<infer TSuccess, any, any>
+ ? (input: RpcInput<TTag>) => Promise<TSuccess>
+ : never;
+
+type RpcUnaryNoArgMethod<TTag extends RpcTag> =
+ RpcMethod<TTag> extends (input: any, options?: any) => Effect.Effect<infer TSuccess, any, any>
+ ? () => Promise<TSuccess>
+ : never;
+
+type RpcStreamMethod<TTag extends RpcTag> =
+ RpcMethod<TTag> extends (input: any, options?: any) => Stream.Stream<infer TEvent, any, any>
+ ? (listener: (event: TEvent) => void) => () => void
+ : never;
+
+interface GitRunStackedActionOptions {
+ readonly onProgress?: (event: GitActionProgressEvent) => void;
+}
+
+export interface WsRpcClient {
+ readonly dispose: () => Promise<void>;
+ readonly terminal: {
+ readonly open: RpcUnaryMethod<typeof WS_METHODS.terminalOpen>;
+ readonly write: RpcUnaryMethod<typeof WS_METHODS.terminalWrite>;
+ readonly resize: RpcUnaryMethod<typeof WS_METHODS.terminalResize>;
+ readonly clear: RpcUnaryMethod<typeof WS_METHODS.terminalClear>;
+ readonly restart: RpcUnaryMethod<typeof WS_METHODS.terminalRestart>;
+ readonly close: RpcUnaryMethod<typeof WS_METHODS.terminalClose>;
+ readonly onEvent: RpcStreamMethod<typeof WS_METHODS.subscribeTerminalEvents>;
+ };
+ readonly projects: {
+ readonly searchEntries: RpcUnaryMethod<typeof WS_METHODS.projectsSearchEntries>;
+ readonly writeFile: RpcUnaryMethod<typeof WS_METHODS.projectsWriteFile>;
+ };
+ readonly shell: {
+ readonly openInEditor: (input: {
+ readonly cwd: Parameters<NativeApi["shell"]["openInEditor"]>[0];
+ readonly editor: Parameters<NativeApi["shell"]["openInEditor"]>[1];
+ }) => ReturnType<NativeApi["shell"]["openInEditor"]>;
+ };
+ readonly git: {
+ readonly pull: RpcUnaryMethod<typeof WS_METHODS.gitPull>;
+ readonly status: RpcUnaryMethod<typeof WS_METHODS.gitStatus>;
+ readonly runStackedAction: (
+ input: GitRunStackedActionInput,
+ options?: GitRunStackedActionOptions,
+ ) => Promise<GitRunStackedActionResult>;
+ readonly listBranches: RpcUnaryMethod<typeof WS_METHODS.gitListBranches>;
+ readonly createWorktree: RpcUnaryMethod<typeof WS_METHODS.gitCreateWorktree>;
+ readonly removeWorktree: RpcUnaryMethod<typeof WS_METHODS.gitRemoveWorktree>;
+ readonly createBranch: RpcUnaryMethod<typeof WS_METHODS.gitCreateBranch>;
+ readonly checkout: RpcUnaryMethod<typeof WS_METHODS.gitCheckout>;
+ readonly init: RpcUnaryMethod<typeof WS_METHODS.gitInit>;
+ readonly resolvePullRequest: RpcUnaryMethod<typeof WS_METHODS.gitResolvePullRequest>;
+ readonly preparePullRequestThread: RpcUnaryMethod<
+ typeof WS_METHODS.gitPreparePullRequestThread
+ >;
+ };
+ readonly server: {
+ readonly getConfig: RpcUnaryNoArgMethod<typeof WS_METHODS.serverGetConfig>;
+ readonly refreshProviders: RpcUnaryNoArgMethod<typeof WS_METHODS.serverRefreshProviders>;
+ readonly upsertKeybinding: RpcUnaryMethod<typeof WS_METHODS.serverUpsertKeybinding>;
+ readonly getSettings: RpcUnaryNoArgMethod<typeof WS_METHODS.serverGetSettings>;
+ readonly updateSettings: (
+ patch: ServerSettingsPatch,
+ ) => ReturnType<RpcUnaryMethod<typeof WS_METHODS.serverUpdateSettings>>;
+ readonly subscribeConfig: RpcStreamMethod<typeof WS_METHODS.subscribeServerConfig>;
+ readonly subscribeLifecycle: RpcStreamMethod<typeof WS_METHODS.subscribeServerLifecycle>;
+ };
+ readonly orchestration: {
+ readonly getSnapshot: RpcUnaryNoArgMethod<typeof ORCHESTRATION_WS_METHODS.getSnapshot>;
+ readonly dispatchCommand: RpcUnaryMethod<typeof ORCHESTRATION_WS_METHODS.dispatchCommand>;
+ readonly getTurnDiff: RpcUnaryMethod<typeof ORCHESTRATION_WS_METHODS.getTurnDiff>;
+ readonly getFullThreadDiff: RpcUnaryMethod<typeof ORCHESTRATION_WS_METHODS.getFullThreadDiff>;
+ readonly replayEvents: RpcUnaryMethod<typeof ORCHESTRATION_WS_METHODS.replayEvents>;
+ readonly onDomainEvent: RpcStreamMethod<typeof WS_METHODS.subscribeOrchestrationDomainEvents>;
+ };
+}
+
+let sharedWsRpcClient: WsRpcClient | null = null;
+
+export function getWsRpcClient(): WsRpcClient {
+ if (sharedWsRpcClient) {
+ return sharedWsRpcClient;
+ }
+ sharedWsRpcClient = createWsRpcClient();
+ return sharedWsRpcClient;
+}
+
+export async function __resetWsRpcClientForTests() {
+ await sharedWsRpcClient?.dispose();
+ sharedWsRpcClient = null;
+}
+
+export function createWsRpcClient(transport = new WsTransport()): WsRpcClient {
+ return {
+ dispose: () => transport.dispose(),
+ terminal: {
+ open: (input) => transport.request((client) => client[WS_METHODS.terminalOpen](input)),
+ write: (input) => transport.request((client) => client[WS_METHODS.terminalWrite](input)),
+ resize: (input) => transport.request((client) => client[WS_METHODS.terminalResize](input)),
+ clear: (input) => transport.request((client) => client[WS_METHODS.terminalClear](input)),
+ restart: (input) => transport.request((client) => client[WS_METHODS.terminalRestart](input)),
+ close: (input) => transport.request((client) => client[WS_METHODS.terminalClose](input)),
+ onEvent: (listener) =>
+ transport.subscribe((client) => client[WS_METHODS.subscribeTerminalEvents]({}), listener),
+ },
+ projects: {
+ searchEntries: (input) =>
+ transport.request((client) => client[WS_METHODS.projectsSearchEntries](input)),
+ writeFile: (input) =>
+ transport.request((client) => client[WS_METHODS.projectsWriteFile](input)),
+ },
+ shell: {
+ openInEditor: (input) =>
+ transport.request((client) => client[WS_METHODS.shellOpenInEditor](input)),
+ },
+ git: {
+ pull: (input) => transport.request((client) => client[WS_METHODS.gitPull](input)),
+ status: (input) => transport.request((client) => client[WS_METHODS.gitStatus](input)),
+ runStackedAction: async (input, options) => {
+ let result: GitRunStackedActionResult | null = null;
+
+ await transport.requestStream(
+ (client) => client[WS_METHODS.gitRunStackedAction](input),
+ (event) => {
+ options?.onProgress?.(event);
+ if (event.kind === "action_finished") {
+ result = event.result;
+ }
+ },
+ );
+
+ if (result) {
+ return result;
+ }
+
+ throw new Error("Git action stream completed without a final result.");
+ },
+ listBranches: (input) =>
+ transport.request((client) => client[WS_METHODS.gitListBranches](input)),
+ createWorktree: (input) =>
+ transport.request((client) => client[WS_METHODS.gitCreateWorktree](input)),
+ removeWorktree: (input) =>
+ transport.request((client) => client[WS_METHODS.gitRemoveWorktree](input)),
+ createBranch: (input) =>
+ transport.request((client) => client[WS_METHODS.gitCreateBranch](input)),
+ checkout: (input) => transport.request((client) => client[WS_METHODS.gitCheckout](input)),
+ init: (input) => transport.request((client) => client[WS_METHODS.gitInit](input)),
+ resolvePullRequest: (input) =>
+ transport.request((client) => client[WS_METHODS.gitResolvePullRequest](input)),
+ preparePullRequestThread: (input) =>
+ transport.request((client) => client[WS_METHODS.gitPreparePullRequestThread](input)),
+ },
+ server: {
+ getConfig: () => transport.request((client) => client[WS_METHODS.serverGetConfig]({})),
+ refreshProviders: () =>
+ transport.request((client) => client[WS_METHODS.serverRefreshProviders]({})),
+ upsertKeybinding: (input) =>
+ transport.request((client) => client[WS_METHODS.serverUpsertKeybinding](input)),
+ getSettings: () => transport.request((client) => client[WS_METHODS.serverGetSettings]({})),
+ updateSettings: (patch) =>
+ transport.request((client) => client[WS_METHODS.serverUpdateSettings]({ patch })),
+ subscribeConfig: (listener) =>
+ transport.subscribe((client) => client[WS_METHODS.subscribeServerConfig]({}), listener),
+ subscribeLifecycle: (listener) =>
+ transport.subscribe((client) => client[WS_METHODS.subscribeServerLifecycle]({}), listener),
+ },
+ orchestration: {
+ getSnapshot: () =>
+ transport.request((client) => client[ORCHESTRATION_WS_METHODS.getSnapshot]({})),
+ dispatchCommand: (input) =>
+ transport.request((client) => client[ORCHESTRATION_WS_METHODS.dispatchCommand](input)),
+ getTurnDiff: (input) =>
+ transport.request((client) => client[ORCHESTRATION_WS_METHODS.getTurnDiff](input)),
+ getFullThreadDiff: (input) =>
+ transport.request((client) => client[ORCHESTRATION_WS_METHODS.getFullThreadDiff](input)),
+ replayEvents: (input) =>
+ transport
+ .request((client) => client[ORCHESTRATION_WS_METHODS.replayEvents](input))
+ .then((events) => [...events]),
+ onDomainEvent: (listener) =>
+ transport.subscribe(
+ (client) => client[WS_METHODS.subscribeOrchestrationDomainEvents]({}),
+ listener,
+ ),
+ },
+ };
+}
diff --git a/apps/web/src/wsTransport.test.ts b/apps/web/src/wsTransport.test.ts
index c9b963286..2f64f2a69 100644
--- a/apps/web/src/wsTransport.test.ts
+++ b/apps/web/src/wsTransport.test.ts
@@ -1,10 +1,11 @@
-import { WS_CHANNELS } from "@t3tools/contracts";
+import { WS_METHODS } from "@t3tools/contracts";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { WsTransport } from "./wsTransport";
type WsEventType = "open" | "message" | "close" | "error";
-type WsListener = (event?: { data?: unknown }) => void;
+type WsEvent = { code?: number; data?: unknown; reason?: string; type?: string };
+type WsListener = (event?: WsEvent) => void;
const sockets: MockWebSocket[] = [];
@@ -16,9 +17,11 @@ class MockWebSocket {
readyState = MockWebSocket.CONNECTING;
readonly sent: string[] = [];
+ readonly url: string;
private readonly listeners = new Map<WsEventType, Set<WsListener>>();
- constructor(_url: string) {
+ constructor(url: string) {
+ this.url = url;
sockets.push(this);
}
@@ -28,25 +31,29 @@ class MockWebSocket {
this.listeners.set(type, listeners);
}
+ removeEventListener(type: WsEventType, listener: WsListener) {
+ this.listeners.get(type)?.delete(listener);
+ }
+
send(data: string) {
this.sent.push(data);
}
- close() {
+ close(code = 1000, reason = "") {
this.readyState = MockWebSocket.CLOSED;
- this.emit("close");
+ this.emit("close", { code, reason, type: "close" });
}
open() {
this.readyState = MockWebSocket.OPEN;
- this.emit("open");
+ this.emit("open", { type: "open" });
}
serverMessage(data: unknown) {
- this.emit("message", { data });
+ this.emit("message", { data, type: "message" });
}
- private emit(type: WsEventType, event?: { data?: unknown }) {
+ private emit(type: WsEventType, event?: WsEvent) {
const listeners = this.listeners.get(type);
if (!listeners) return;
for (const listener of listeners) {
@@ -65,13 +72,33 @@ function getSocket(): MockWebSocket {
return socket;
}
+async function waitFor(assertion: () => void, timeoutMs = 1_000): Promise<void> {
+ const startedAt = Date.now();
+ for (;;) {
+ try {
+ assertion();
+ return;
+ } catch (error) {
+ if (Date.now() - startedAt >= timeoutMs) {
+ throw error;
+ }
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ }
+ }
+}
+
beforeEach(() => {
sockets.length = 0;
Object.defineProperty(globalThis, "window", {
configurable: true,
value: {
- location: { hostname: "localhost", port: "3020" },
+ location: {
+ origin: "http://localhost:3020",
+ hostname: "localhost",
+ port: "3020",
+ protocol: "http:",
+ },
desktopBridge: undefined,
},
});
@@ -85,172 +112,332 @@ afterEach(() => {
});
describe("WsTransport", () => {
- it("routes valid push envelopes to channel listeners", () => {
+ it("normalizes root websocket urls to /ws and preserves query params", async () => {
+ const transport = new WsTransport("ws://localhost:3020/?token=secret-token");
+
+ await waitFor(() => {
+ expect(sockets).toHaveLength(1);
+ });
+
+ expect(getSocket().url).toBe("ws://localhost:3020/ws?token=secret-token");
+ await transport.dispose();
+ });
+
+ it("uses wss when falling back to an https page origin", async () => {
+ Object.assign(window.location, {
+ origin: "https://app.example.com",
+ hostname: "app.example.com",
+ port: "",
+ protocol: "https:",
+ });
+
+ const transport = new WsTransport();
+
+ await waitFor(() => {
+ expect(sockets).toHaveLength(1);
+ });
+
+ expect(getSocket().url).toBe("wss://app.example.com/ws");
+ await transport.dispose();
+ });
+
+ it("sends unary RPC requests and resolves successful exits", async () => {
const transport = new WsTransport("ws://localhost:3020");
+
+ const requestPromise = transport.request((client) =>
+ client[WS_METHODS.serverUpsertKeybinding]({
+ command: "terminal.toggle",
+ key: "ctrl+k",
+ }),
+ );
+
+ await waitFor(() => {
+ expect(sockets).toHaveLength(1);
+ });
+
const socket = getSocket();
socket.open();
- const listener = vi.fn();
- transport.subscribe(WS_CHANNELS.serverConfigUpdated, listener);
+ await waitFor(() => {
+ expect(socket.sent).toHaveLength(1);
+ });
+
+ const requestMessage = JSON.parse(socket.sent[0] ?? "{}") as {
+ _tag: string;
+ id: string;
+ payload: unknown;
+ tag: string;
+ };
+ expect(requestMessage).toMatchObject({
+ _tag: "Request",
+ tag: WS_METHODS.serverUpsertKeybinding,
+ payload: {
+ command: "terminal.toggle",
+ key: "ctrl+k",
+ },
+ });
socket.serverMessage(
JSON.stringify({
- type: "push",
- sequence: 1,
- channel: WS_CHANNELS.serverConfigUpdated,
- data: { issues: [] },
+ _tag: "Exit",
+ requestId: requestMessage.id,
+ exit: {
+ _tag: "Success",
+ value: {
+ keybindings: [],
+ issues: [],
+ },
+ },
}),
);
- expect(listener).toHaveBeenCalledTimes(1);
- expect(listener).toHaveBeenCalledWith({
- type: "push",
- sequence: 1,
- channel: WS_CHANNELS.serverConfigUpdated,
- data: { issues: [] },
+ await expect(requestPromise).resolves.toEqual({
+ keybindings: [],
+ issues: [],
});
- transport.dispose();
+ await transport.dispose();
});
- it("resolves pending requests for valid response envelopes", async () => {
+ it("delivers stream chunks to subscribers", async () => {
const transport = new WsTransport("ws://localhost:3020");
+ const listener = vi.fn();
+
+ const unsubscribe = transport.subscribe(
+ (client) => client[WS_METHODS.subscribeServerLifecycle]({}),
+ listener,
+ );
+ await waitFor(() => {
+ expect(sockets).toHaveLength(1);
+ });
+
const socket = getSocket();
socket.open();
- const requestPromise = transport.request("projects.list");
- const sent = socket.sent.at(-1);
- if (!sent) {
- throw new Error("Expected request envelope to be sent");
- }
+ await waitFor(() => {
+ expect(socket.sent).toHaveLength(1);
+ });
+
+ const requestMessage = JSON.parse(socket.sent[0] ?? "{}") as { id: string; tag: string };
+ expect(requestMessage.tag).toBe(WS_METHODS.subscribeServerLifecycle);
+
+ const welcomeEvent = {
+ version: 1,
+ sequence: 1,
+ type: "welcome",
+ payload: {
+ cwd: "/tmp/workspace",
+ projectName: "workspace",
+ },
+ };
- const requestEnvelope = JSON.parse(sent) as { id: string };
socket.serverMessage(
JSON.stringify({
- id: requestEnvelope.id,
- result: { projects: [] },
+ _tag: "Chunk",
+ requestId: requestMessage.id,
+ values: [welcomeEvent],
}),
);
- await expect(requestPromise).resolves.toEqual({ projects: [] });
+ await waitFor(() => {
+ expect(listener).toHaveBeenCalledWith(welcomeEvent);
+ });
- transport.dispose();
+ unsubscribe();
+ await transport.dispose();
});
- it("drops malformed envelopes without crashing transport", () => {
- const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+ it("re-subscribes stream listeners after the stream exits", async () => {
const transport = new WsTransport("ws://localhost:3020");
+ const listener = vi.fn();
+
+ const unsubscribe = transport.subscribe(
+ (client) => client[WS_METHODS.subscribeServerLifecycle]({}),
+ listener,
+ );
+ await waitFor(() => {
+ expect(sockets).toHaveLength(1);
+ });
+
const socket = getSocket();
socket.open();
- const listener = vi.fn();
- transport.subscribe(WS_CHANNELS.serverConfigUpdated, listener);
+ await waitFor(() => {
+ expect(socket.sent).toHaveLength(1);
+ });
- socket.serverMessage("{ invalid-json");
+ const firstRequest = JSON.parse(socket.sent[0] ?? "{}") as { id: string };
socket.serverMessage(
JSON.stringify({
- type: "push",
- sequence: 2,
- channel: 42,
- data: { bad: true },
+ _tag: "Chunk",
+ requestId: firstRequest.id,
+ values: [
+ {
+ version: 1,
+ sequence: 1,
+ type: "welcome",
+ payload: {
+ cwd: "/tmp/one",
+ projectName: "one",
+ },
+ },
+ ],
}),
);
socket.serverMessage(
JSON.stringify({
- type: "push",
- sequence: 3,
- channel: WS_CHANNELS.serverConfigUpdated,
- data: { issues: [] },
+ _tag: "Exit",
+ requestId: firstRequest.id,
+ exit: {
+ _tag: "Success",
+ value: null,
+ },
}),
);
- expect(listener).toHaveBeenCalledTimes(1);
- expect(listener).toHaveBeenCalledWith({
- type: "push",
- sequence: 3,
- channel: WS_CHANNELS.serverConfigUpdated,
- data: { issues: [] },
+ await waitFor(() => {
+ const nextRequest = socket.sent
+ .map((message) => JSON.parse(message) as { _tag?: string; id?: string })
+ .find((message) => message._tag === "Request" && message.id !== firstRequest.id);
+ expect(nextRequest).toBeDefined();
});
- expect(warnSpy).toHaveBeenCalledTimes(2);
- expect(warnSpy).toHaveBeenNthCalledWith(
- 1,
- "Dropped inbound WebSocket envelope",
- expect.stringMatching(/^SyntaxError:/),
- );
- expect(warnSpy).toHaveBeenNthCalledWith(
- 2,
- "Dropped inbound WebSocket envelope",
- expect.stringContaining('Expected "server.configUpdated"'),
- );
-
- transport.dispose();
- });
- it("queues requests until the websocket opens", async () => {
- const transport = new WsTransport("ws://localhost:3020");
- const socket = getSocket();
-
- const requestPromise = transport.request("projects.list");
- expect(socket.sent).toHaveLength(0);
-
- socket.open();
- expect(socket.sent).toHaveLength(1);
- const requestEnvelope = JSON.parse(socket.sent[0] ?? "{}") as { id: string };
+ const secondRequest = socket.sent
+ .map((message) => JSON.parse(message) as { _tag?: string; id?: string; tag?: string })
+ .find(
+ (message): message is { _tag: "Request"; id: string; tag: string } =>
+ message._tag === "Request" && message.id !== firstRequest.id,
+ );
+ if (!secondRequest) {
+ throw new Error("Expected a resubscribe request");
+ }
+ expect(secondRequest.tag).toBe(WS_METHODS.subscribeServerLifecycle);
+ expect(secondRequest.id).not.toBe(firstRequest.id);
+
+ const secondEvent = {
+ version: 1,
+ sequence: 2,
+ type: "welcome",
+ payload: {
+ cwd: "/tmp/two",
+ projectName: "two",
+ },
+ };
socket.serverMessage(
JSON.stringify({
- id: requestEnvelope.id,
- result: { projects: [] },
+ _tag: "Chunk",
+ requestId: secondRequest.id,
+ values: [secondEvent],
}),
);
- await expect(requestPromise).resolves.toEqual({ projects: [] });
- transport.dispose();
+ await waitFor(() => {
+ expect(listener).toHaveBeenLastCalledWith(secondEvent);
+ });
+
+ unsubscribe();
+ await transport.dispose();
});
- it("does not create a timeout for requests with timeoutMs null", async () => {
- const timeoutSpy = vi.spyOn(globalThis, "setTimeout");
+ it("streams finite request events without re-subscribing", async () => {
const transport = new WsTransport("ws://localhost:3020");
+ const listener = vi.fn();
+
+ await waitFor(() => {
+ expect(sockets).toHaveLength(1);
+ });
const socket = getSocket();
socket.open();
- const requestPromise = transport.request(
- "git.runStackedAction",
- { cwd: "/repo" },
- { timeoutMs: null },
+ const requestPromise = transport.requestStream(
+ (client) =>
+ client[WS_METHODS.gitRunStackedAction]({
+ actionId: "action-1",
+ cwd: "/repo",
+ action: "commit",
+ }),
+ listener,
);
- const sent = socket.sent.at(-1);
- if (!sent) {
- throw new Error("Expected request envelope to be sent");
- }
- const requestEnvelope = JSON.parse(sent) as { id: string };
+
+ await waitFor(() => {
+ expect(socket.sent).toHaveLength(1);
+ });
+
+ const requestMessage = JSON.parse(socket.sent[0] ?? "{}") as { id: string };
+ const progressEvent = {
+ actionId: "action-1",
+ cwd: "/repo",
+ action: "commit",
+ kind: "phase_started",
+ phase: "commit",
+ label: "Committing...",
+ } as const;
socket.serverMessage(
JSON.stringify({
- id: requestEnvelope.id,
- result: { ok: true },
+ _tag: "Chunk",
+ requestId: requestMessage.id,
+ values: [progressEvent],
+ }),
+ );
+ socket.serverMessage(
+ JSON.stringify({
+ _tag: "Exit",
+ requestId: requestMessage.id,
+ exit: {
+ _tag: "Success",
+ value: null,
+ },
}),
);
- await expect(requestPromise).resolves.toEqual({ ok: true });
- expect(timeoutSpy.mock.calls.some(([callback]) => typeof callback === "function")).toBe(false);
-
- transport.dispose();
+ await expect(requestPromise).resolves.toBeUndefined();
+ expect(listener).toHaveBeenCalledWith(progressEvent);
+ expect(
+ socket.sent.filter((message) => {
+ const parsed = JSON.parse(message) as { _tag?: string; tag?: string };
+ return parsed._tag === "Request" && parsed.tag === WS_METHODS.gitRunStackedAction;
+ }),
+ ).toHaveLength(1);
+ await transport.dispose();
});
- it("rejects pending requests when the websocket closes", async () => {
- const transport = new WsTransport("ws://localhost:3020");
- const socket = getSocket();
- socket.open();
+ it("closes the client scope on the transport runtime before disposing the runtime", async () => {
+ const callOrder: string[] = [];
+ let resolveClose!: () => void;
+ const closePromise = new Promise<void>((resolve) => {
+ resolveClose = resolve;
+ });
- const requestPromise = transport.request(
- "git.runStackedAction",
- { cwd: "/repo" },
- { timeoutMs: null },
- );
+ const runtime = {
+ runPromise: vi.fn(async () => {
+ callOrder.push("close:start");
+ await closePromise;
+ callOrder.push("close:done");
+ return undefined;
+ }),
+ dispose: vi.fn(async () => {
+ callOrder.push("runtime:dispose");
+ }),
+ };
+ const transport = {
+ disposed: false,
+ clientScope: {} as never,
+ runtime,
+ } as unknown as WsTransport;
+
+ WsTransport.prototype.dispose.call(transport);
+
+ expect(runtime.runPromise).toHaveBeenCalledTimes(1);
+ expect(runtime.dispose).not.toHaveBeenCalled();
+ expect((transport as unknown as { disposed: boolean }).disposed).toBe(true);
- socket.close();
+ resolveClose();
+
+ await waitFor(() => {
+ expect(runtime.dispose).toHaveBeenCalledTimes(1);
+ });
- await expect(requestPromise).rejects.toThrow("WebSocket connection closed.");
- transport.dispose();
+ expect(callOrder).toEqual(["close:start", "close:done", "runtime:dispose"]);
});
});
diff --git a/apps/web/src/wsTransport.ts b/apps/web/src/wsTransport.ts
index 12c9a6d95..70042261d 100644
--- a/apps/web/src/wsTransport.ts
+++ b/apps/web/src/wsTransport.ts
@@ -1,309 +1,131 @@
-import {
- type WsPush,
- type WsPushChannel,
- type WsPushMessage,
- WebSocketResponse,
- type WsResponse as WsResponseMessage,
- WsResponse as WsResponseSchema,
-} from "@t3tools/contracts";
-import { decodeUnknownJsonResult, formatSchemaError } from "@t3tools/shared/schemaJson";
-import { Result, Schema } from "effect";
-
-type PushListener<C extends WsPushChannel> = (message: WsPushMessage<C>) => void;
+import { Duration, Effect, Exit, ManagedRuntime, Option, Scope, Stream } from "effect";
-interface PendingRequest {
- resolve: (result: unknown) => void;
- reject: (error: Error) => void;
- timeout: ReturnType<typeof setTimeout> | null;
-}
+import {
+ createWsRpcProtocolLayer,
+ makeWsRpcProtocolClient,
+ type WsRpcProtocolClient,
+} from "./rpc/protocol";
+import { RpcClient } from "effect/unstable/rpc";
interface SubscribeOptions {
- readonly replayLatest?: boolean;
+ readonly retryDelay?: Duration.Input;
}
interface RequestOptions {
- readonly timeoutMs?: number | null;
+ readonly timeout?: Option.Option<Duration.Input>;
}
-type TransportState = "connecting" | "open" | "reconnecting" | "closed" | "disposed";
-
-const REQUEST_TIMEOUT_MS = 60_000;
-const RECONNECT_DELAYS_MS = [500, 1_000, 2_000, 4_000, 8_000];
-const decodeWsResponse = decodeUnknownJsonResult(WsResponseSchema);
-const isWebSocketResponseEnvelope = Schema.is(WebSocketResponse);
-
-const isWsPushMessage = (value: WsResponseMessage): value is WsPush =>
- "type" in value && value.type === "push";
+const DEFAULT_SUBSCRIPTION_RETRY_DELAY_MS = Duration.millis(250);
-interface WsRequestEnvelope {
- id: string;
- body: {
- _tag: string;
- [key: string]: unknown;
- };
-}
-
-function asError(value: unknown, fallback: string): Error {
- if (value instanceof Error) {
- return value;
+function formatErrorMessage(error: unknown): string {
+ if (error instanceof Error && error.message.trim().length > 0) {
+ return error.message;
}
- return new Error(fallback);
+ return String(error);
}
export class WsTransport {
- private ws: WebSocket | null = null;
- private nextId = 1;
- private readonly pending = new Map<string, PendingRequest>();
- private readonly listeners = new Map<string, Set<(message: WsPush) => void>>();
- private readonly latestPushByChannel = new Map<string, WsPush>();
- private readonly outboundQueue: string[] = [];
- private reconnectAttempt = 0;
- private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+ private readonly runtime: ManagedRuntime.ManagedRuntime<RpcClient.Protocol, never>;
+ private readonly clientScope: Scope.Closeable;
+ private readonly clientPromise: Promise<WsRpcProtocolClient>;
private disposed = false;
- private state: TransportState = "connecting";
- private readonly url: string;
constructor(url?: string) {
- const bridgeUrl = window.desktopBridge?.getWsUrl();
- const envUrl = import.meta.env.VITE_WS_URL as string | undefined;
- this.url =
- url ??
- (bridgeUrl && bridgeUrl.length > 0
- ? bridgeUrl
- : envUrl && envUrl.length > 0
- ? envUrl
- : `${window.location.protocol === "https:" ? "wss" : "ws"}://${window.location.hostname}:${window.location.port}`);
- this.connect();
+ this.runtime = ManagedRuntime.make(createWsRpcProtocolLayer(url));
+ this.clientScope = this.runtime.runSync(Scope.make());
+ this.clientPromise = this.runtime.runPromise(
+ Scope.provide(this.clientScope)(makeWsRpcProtocolClient),
+ );
}
- async request<T = unknown>(
- method: string,
- params?: unknown,
- options?: RequestOptions,
- ): Promise<T> {
- if (typeof method !== "string" || method.length === 0) {
- throw new Error("Request method is required");
- }
-
- const id = String(this.nextId++);
- const body = params != null ? { ...params, _tag: method } : { _tag: method };
- const message: WsRequestEnvelope = { id, body };
- const encoded = JSON.stringify(message);
-
- return new Promise<T>((resolve, reject) => {
- const timeoutMs = options?.timeoutMs === undefined ? REQUEST_TIMEOUT_MS : options.timeoutMs;
- const timeout =
- timeoutMs === null
- ? null
- : setTimeout(() => {
- this.pending.delete(id);
- reject(new Error(`Request timed out: ${method}`));
- }, timeoutMs);
-
- this.pending.set(id, {
- resolve: resolve as (result: unknown) => void,
- reject,
- timeout,
- });
-
- this.send(encoded);
- });
- }
-
- subscribe<C extends WsPushChannel>(
- channel: C,
- listener: PushListener<C>,
- options?: SubscribeOptions,
- ): () => void {
- let channelListeners = this.listeners.get(channel);
- if (!channelListeners) {
- channelListeners = new Set<(message: WsPush) => void>();
- this.listeners.set(channel, channelListeners);
- }
-
- const wrappedListener = (message: WsPush) => {
- listener(message as WsPushMessage<C>);
- };
- channelListeners.add(wrappedListener);
-
- if (options?.replayLatest) {
- const latest = this.latestPushByChannel.get(channel);
- if (latest) {
- wrappedListener(latest);
- }
- }
-
- return () => {
- channelListeners?.delete(wrappedListener);
- if (channelListeners?.size === 0) {
- this.listeners.delete(channel);
- }
- };
- }
-
- getLatestPush<C extends WsPushChannel>(channel: C): WsPushMessage<C> | null {
- const latest = this.latestPushByChannel.get(channel);
- return latest ? (latest as WsPushMessage<C>) : null;
- }
-
- getState(): TransportState {
- return this.state;
- }
-
- dispose() {
- this.disposed = true;
- this.state = "disposed";
- if (this.reconnectTimer !== null) {
- clearTimeout(this.reconnectTimer);
- this.reconnectTimer = null;
- }
- for (const pending of this.pending.values()) {
- if (pending.timeout !== null) {
- clearTimeout(pending.timeout);
- }
- pending.reject(new Error("Transport disposed"));
- }
- this.pending.clear();
- this.outboundQueue.length = 0;
- this.ws?.close();
- this.ws = null;
- }
-
- private connect() {
+ async request<TSuccess>(
+ execute: (client: WsRpcProtocolClient) => Effect.Effect<TSuccess, Error, never>,
+ _options?: RequestOptions,
+ ): Promise<TSuccess> {
if (this.disposed) {
- return;
+ throw new Error("Transport disposed");
}
- this.state = this.reconnectAttempt > 0 ? "reconnecting" : "connecting";
- const ws = new WebSocket(this.url);
-
- ws.addEventListener("open", () => {
- this.ws = ws;
- this.state = "open";
- this.reconnectAttempt = 0;
- this.flushQueue();
- });
-
- ws.addEventListener("message", (event) => {
- this.handleMessage(event.data);
- });
-
- ws.addEventListener("close", () => {
- if (this.ws === ws) {
- this.ws = null;
- this.outboundQueue.length = 0;
- for (const [id, pending] of this.pending.entries()) {
- if (pending.timeout !== null) {
- clearTimeout(pending.timeout);
- }
- this.pending.delete(id);
- pending.reject(new Error("WebSocket connection closed."));
- }
- }
- if (this.disposed) {
- this.state = "disposed";
- return;
- }
- this.state = "closed";
- this.scheduleReconnect();
- });
-
- ws.addEventListener("error", (event) => {
- // Log WebSocket errors for debugging (close event will follow)
- console.warn("WebSocket connection error", { type: event.type, url: this.url });
- });
+ const client = await this.clientPromise;
+ return await this.runtime.runPromise(Effect.suspend(() => execute(client)));
}
- private handleMessage(raw: unknown) {
- const result = decodeWsResponse(raw);
- if (Result.isFailure(result)) {
- console.warn("Dropped inbound WebSocket envelope", formatSchemaError(result.failure));
- return;
+ async requestStream<TValue>(
+ connect: (client: WsRpcProtocolClient) => Stream.Stream<TValue, Error, never>,
+ listener: (value: TValue) => void,
+ ): Promise<void> {
+ if (this.disposed) {
+ throw new Error("Transport disposed");
}
- const message = result.success;
- if (isWsPushMessage(message)) {
- this.latestPushByChannel.set(message.channel, message);
- const channelListeners = this.listeners.get(message.channel);
- if (channelListeners) {
- for (const listener of channelListeners) {
+ const client = await this.clientPromise;
+ await this.runtime.runPromise(
+ Stream.runForEach(connect(client), (value) =>
+ Effect.sync(() => {
try {
- listener(message);
+ listener(value);
} catch {
- // Swallow listener errors
+ // Swallow listener errors so the stream can finish cleanly.
}
- }
- }
- return;
- }
-
- if (!isWebSocketResponseEnvelope(message)) {
- return;
- }
-
- const pending = this.pending.get(message.id);
- if (!pending) {
- return;
- }
-
- if (pending.timeout !== null) {
- clearTimeout(pending.timeout);
- }
- this.pending.delete(message.id);
-
- if (message.error) {
- pending.reject(new Error(message.error.message));
- return;
- }
-
- pending.resolve(message.result);
+ }),
+ ),
+ );
}
- private send(encodedMessage: string) {
+ subscribe<TValue>(
+ connect: (client: WsRpcProtocolClient) => Stream.Stream<TValue, Error, never>,
+ listener: (value: TValue) => void,
+ options?: SubscribeOptions,
+ ): () => void {
if (this.disposed) {
- return;
- }
-
- this.outboundQueue.push(encodedMessage);
- try {
- this.flushQueue();
- } catch {
- // Swallow: flushQueue has queued the message for retry on reconnect
- }
- }
-
- private flushQueue() {
- if (this.ws?.readyState !== WebSocket.OPEN) {
- return;
- }
+ return () => undefined;
+ }
+
+ let active = true;
+ const retryDelayMs = options?.retryDelay ?? DEFAULT_SUBSCRIPTION_RETRY_DELAY_MS;
+ const cancel = this.runtime.runCallback(
+ Effect.promise(() => this.clientPromise).pipe(
+ Effect.flatMap((client) =>
+ Stream.runForEach(connect(client), (value) =>
+ Effect.sync(() => {
+ if (!active) {
+ return;
+ }
+ try {
+ listener(value);
+ } catch {
+ // Swallow listener errors so the stream stays live.
+ }
+ }),
+ ),
+ ),
+ Effect.catch((error) => {
+ if (!active || this.disposed) {
+ return Effect.interrupt;
+ }
+ return Effect.sync(() => {
+ console.warn("WebSocket RPC subscription disconnected", {
+ error: formatErrorMessage(error),
+ });
+ }).pipe(Effect.andThen(Effect.sleep(retryDelayMs)));
+ }),
+ Effect.forever,
+ ),
+ );
- while (this.outboundQueue.length > 0) {
- const message = this.outboundQueue.shift();
- if (!message) {
- continue;
- }
- try {
- this.ws.send(message);
- } catch (error) {
- this.outboundQueue.unshift(message);
- throw asError(error, "Failed to send WebSocket request.");
- }
- }
+ return () => {
+ active = false;
+ cancel();
+ };
}
- private scheduleReconnect() {
- if (this.disposed || this.reconnectTimer !== null) {
+ async dispose() {
+ if (this.disposed) {
return;
}
-
- const delay =
- RECONNECT_DELAYS_MS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)] ??
- RECONNECT_DELAYS_MS[0]!;
-
- this.reconnectAttempt += 1;
- this.reconnectTimer = setTimeout(() => {
- this.reconnectTimer = null;
- this.connect();
- }, delay);
+ this.disposed = true;
+ await this.runtime.runPromise(Scope.close(this.clientScope, Exit.void)).finally(() => {
+ this.runtime.dispose();
+ });
}
}
diff --git a/apps/web/test/wsRpcHarness.ts b/apps/web/test/wsRpcHarness.ts
new file mode 100644
index 000000000..dcb6dc725
--- /dev/null
+++ b/apps/web/test/wsRpcHarness.ts
@@ -0,0 +1,169 @@
+import { Effect, Exit, PubSub, Scope, Stream } from "effect";
+import { WS_METHODS, WsRpcGroup } from "@t3tools/contracts";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+
+type RpcServerInstance = RpcServer.RpcServer<any>;
+
+type BrowserWsClient = {
+ send: (data: string) => void;
+};
+
+export type NormalizedWsRpcRequestBody = {
+ _tag: string;
+ [key: string]: unknown;
+};
+
+type UnaryResolverResult = unknown | Promise<unknown>;
+
+interface BrowserWsRpcHarnessOptions {
+ readonly resolveUnary?: (request: NormalizedWsRpcRequestBody) => UnaryResolverResult;
+ readonly getInitialStreamValues?: (
+ request: NormalizedWsRpcRequestBody,
+ ) => ReadonlyArray<unknown> | undefined;
+}
+
+const STREAM_METHODS = new Set<string>([
+ WS_METHODS.gitRunStackedAction,
+ WS_METHODS.subscribeOrchestrationDomainEvents,
+ WS_METHODS.subscribeTerminalEvents,
+ WS_METHODS.subscribeServerConfig,
+ WS_METHODS.subscribeServerLifecycle,
+]);
+
+const ALL_RPC_METHODS = Array.from(WsRpcGroup.requests.keys());
+
+function normalizeRequest(tag: string, payload: unknown): NormalizedWsRpcRequestBody {
+ if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+ return {
+ _tag: tag,
+ ...(payload as Record<string, unknown>),
+ };
+ }
+ return { _tag: tag, payload };
+}
+
+function asEffect(result: UnaryResolverResult): Effect.Effect<unknown> {
+ if (result instanceof Promise) {
+ return Effect.promise(() => result);
+ }
+ return Effect.succeed(result);
+}
+
+export class BrowserWsRpcHarness {
+ readonly requests: Array<NormalizedWsRpcRequestBody> = [];
+
+ private readonly parser = RpcSerialization.json.makeUnsafe();
+ private client: BrowserWsClient | null = null;
+ private scope: Scope.Closeable | null = null;
+ private serverReady: Promise<RpcServerInstance> | null = null;
+ private resolveUnary: NonNullable<BrowserWsRpcHarnessOptions["resolveUnary"]> = () => ({});
+ private getInitialStreamValues: NonNullable<
+ BrowserWsRpcHarnessOptions["getInitialStreamValues"]
+ > = () => [];
+ private streamPubSubs = new Map<string, PubSub.PubSub<unknown>>();
+
+ async reset(options?: BrowserWsRpcHarnessOptions): Promise<void> {
+ await this.disconnect();
+ this.requests.length = 0;
+ this.resolveUnary = options?.resolveUnary ?? (() => ({}));
+ this.getInitialStreamValues = options?.getInitialStreamValues ?? (() => []);
+ this.initializeStreamPubSubs();
+ }
+
+ connect(client: BrowserWsClient): void {
+ if (this.scope) {
+ void Effect.runPromise(Scope.close(this.scope, Exit.void)).catch(() => undefined);
+ }
+ if (this.streamPubSubs.size === 0) {
+ this.initializeStreamPubSubs();
+ }
+ this.client = client;
+ this.scope = Effect.runSync(Scope.make());
+ this.serverReady = Effect.runPromise(
+ Scope.provide(this.scope)(
+ RpcServer.makeNoSerialization(WsRpcGroup, this.makeServerOptions()),
+ ).pipe(Effect.provide(this.makeLayer())),
+ ) as Promise<RpcServerInstance>;
+ }
+
+ async disconnect(): Promise<void> {
+ if (this.scope) {
+ await Effect.runPromise(Scope.close(this.scope, Exit.void)).catch(() => undefined);
+ this.scope = null;
+ }
+ for (const pubsub of this.streamPubSubs.values()) {
+ Effect.runSync(PubSub.shutdown(pubsub));
+ }
+ this.streamPubSubs.clear();
+ this.serverReady = null;
+ this.client = null;
+ }
+
+ private initializeStreamPubSubs(): void {
+ this.streamPubSubs = new Map(
+ Array.from(STREAM_METHODS, (method) => [method, Effect.runSync(PubSub.unbounded<unknown>())]),
+ );
+ }
+
+ async onMessage(rawData: string): Promise<void> {
+ const server = await this.serverReady;
+ if (!server) {
+ throw new Error("RPC test server is not connected");
+ }
+ const messages = this.parser.decode(rawData);
+ for (const message of messages) {
+ await Effect.runPromise(server.write(0, message as never));
+ }
+ }
+
+ emitStreamValue(method: string, value: unknown): void {
+ const pubsub = this.streamPubSubs.get(method);
+ if (!pubsub) {
+ throw new Error(`No stream registered for ${method}`);
+ }
+ Effect.runSync(PubSub.publish(pubsub, value));
+ }
+
+ private makeLayer() {
+ const handlers: Record<string, (payload: unknown) => unknown> = {};
+ for (const method of ALL_RPC_METHODS) {
+ handlers[method] = STREAM_METHODS.has(method)
+ ? (payload) => this.handleStream(method, payload)
+ : (payload) => this.handleUnary(method, payload);
+ }
+ return WsRpcGroup.toLayer(handlers as never);
+ }
+
+ private makeServerOptions() {
+ return {
+ onFromServer: (response: unknown) =>
+ Effect.sync(() => {
+ if (!this.client) {
+ return;
+ }
+ const encoded = this.parser.encode(response);
+ if (typeof encoded === "string") {
+ this.client.send(encoded);
+ }
+ }),
+ };
+ }
+
+ private handleUnary(method: string, payload: unknown) {
+ const request = normalizeRequest(method, payload);
+ this.requests.push(request);
+ return asEffect(this.resolveUnary(request));
+ }
+
+ private handleStream(method: string, payload: unknown) {
+ const request = normalizeRequest(method, payload);
+ this.requests.push(request);
+ const pubsub = this.streamPubSubs.get(method);
+ if (!pubsub) {
+ throw new Error(`No stream registered for ${method}`);
+ }
+ return Stream.fromIterable(this.getInitialStreamValues(request) ?? []).pipe(
+ Stream.concat(Stream.fromPubSub(pubsub)),
+ );
+ }
+}
diff --git a/apps/web/tsconfig.json b/apps/web/tsconfig.json
index a500ba56c..178f4bcba 100644
--- a/apps/web/tsconfig.json
+++ b/apps/web/tsconfig.json
@@ -21,5 +21,5 @@
}
]
},
- "include": ["src", "vite.config.ts"]
+ "include": ["src", "vite.config.ts", "test"]
}
diff --git a/bun.lock b/bun.lock
index ee56cd52d..af243cf4e 100644
--- a/bun.lock
+++ b/bun.lock
@@ -44,17 +44,17 @@
"name": "t3",
"version": "0.0.15",
"bin": {
- "t3": "./dist/index.mjs",
+ "t3": "./dist/bin.mjs",
},
"dependencies": {
"@anthropic-ai/claude-agent-sdk": "^0.2.77",
+ "@effect/platform-bun": "catalog:",
"@effect/platform-node": "catalog:",
"@effect/sql-sqlite-bun": "catalog:",
"@pierre/diffs": "^1.1.0-beta.16",
"effect": "catalog:",
"node-pty": "^1.1.0",
"open": "^10.1.0",
- "ws": "^8.18.0",
},
"devDependencies": {
"@effect/language-service": "catalog:",
@@ -64,7 +64,6 @@
"@t3tools/web": "workspace:*",
"@types/bun": "catalog:",
"@types/node": "catalog:",
- "@types/ws": "^8.5.13",
"tsdown": "catalog:",
"typescript": "catalog:",
"vitest": "catalog:",
@@ -79,6 +78,7 @@
"@dnd-kit/modifiers": "^9.0.0",
"@dnd-kit/sortable": "^10.0.0",
"@dnd-kit/utilities": "^3.2.2",
+ "@effect/atom-react": "catalog:",
"@formkit/auto-animate": "^0.9.0",
"@lexical/react": "^0.41.0",
"@pierre/diffs": "^1.1.0-beta.16",
@@ -175,7 +175,9 @@
"vite": "^8.0.0",
},
"catalog": {
+ "@effect/atom-react": "4.0.0-beta.43",
"@effect/language-service": "0.84.2",
+ "@effect/platform-bun": "4.0.0-beta.43",
"@effect/platform-node": "4.0.0-beta.43",
"@effect/sql-sqlite-bun": "4.0.0-beta.43",
"@effect/vitest": "4.0.0-beta.43",
@@ -267,8 +269,12 @@
"@dnd-kit/utilities": ["@dnd-kit/[email protected]", "", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "react": ">=16.8.0" } }, "sha512-+MKAJEOfaBe5SmV6t34p80MMKhjvUz0vRrvVJbPT0WElzaOJ/1xs+D+KDv+tD/NE5ujfrChEcshd4fLn0wpiqg=="],
+ "@effect/atom-react": ["@effect/[email protected]", "", { "peerDependencies": { "effect": "^4.0.0-beta.43", "react": "^19.2.4", "scheduler": "*" } }, "sha512-xSrRbGXuo4d0g4ph66TQST1GNSjtQZrZj8V7OiAQFuzMYcZ0kwRIPUUFwOBtbWHK43/zNENdNWOnlXh/iYM1dw=="],
+
"@effect/language-service": ["@effect/[email protected]", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-l04qNxpiA8rY5yXWckRPJ7Mk5MNerXuNymSFf+IdflfI5i8jgL1bpBNLuP6ijg7wgjdHc/KmTnCj2kT0SCntuA=="],
+ "@effect/platform-bun": ["@effect/[email protected]", "", { "dependencies": { "@effect/platform-node-shared": "^4.0.0-beta.43" }, "peerDependencies": { "effect": "^4.0.0-beta.43" } }, "sha512-nMZ9JsD6CzJNQ+5pDUFbPw7PSZdQdTQ092MbYrocVtvlf6qEFU/hji3ITvRIOX7eabyQ8AUyp55qFPQUeq+GIA=="],
+
"@effect/platform-node": ["@effect/[email protected]", "", { "dependencies": { "@effect/platform-node-shared": "^4.0.0-beta.43", "mime": "^4.1.0", "undici": "^7.24.0" }, "peerDependencies": { "effect": "^4.0.0-beta.43", "ioredis": "^5.7.0" } }, "sha512-Uq6E1rjaIpjHauzjwoB2HzAg3battYt2Boy8XO50GoHiWCXKE6WapYZ0/AnaBx5v5qg2sOfqpuiLsUf9ZgxOkA=="],
"@effect/platform-node-shared": ["@effect/[email protected]", "", { "dependencies": { "@types/ws": "^8.18.1", "ws": "^8.19.0" }, "peerDependencies": { "effect": "^4.0.0-beta.43" } }, "sha512-A9q0GEb61pYcQ06Dr6gXj1nKlDI3KHsar1sk3qb1ZY+kVSR64tBAylI8zGon23KY+NPtTUj/sEIToB7jc3Qt5w=="],
diff --git a/package.json b/package.json
index aad78f7d4..a26a359c0 100644
--- a/package.json
+++ b/package.json
@@ -9,6 +9,8 @@
],
"catalog": {
"effect": "4.0.0-beta.43",
+ "@effect/atom-react": "4.0.0-beta.43",
+ "@effect/platform-bun": "4.0.0-beta.43",
"@effect/platform-node": "4.0.0-beta.43",
"@effect/sql-sqlite-bun": "4.0.0-beta.43",
"@effect/vitest": "4.0.0-beta.43",
diff --git a/packages/contracts/src/editor.ts b/packages/contracts/src/editor.ts
index 0bb8eb8f5..60ff5908c 100644
--- a/packages/contracts/src/editor.ts
+++ b/packages/contracts/src/editor.ts
@@ -24,3 +24,8 @@ export const OpenInEditorInput = Schema.Struct({
editor: EditorId,
});
export type OpenInEditorInput = typeof OpenInEditorInput.Type;
+
+export class OpenError extends Schema.TaggedErrorClass<OpenError>()("OpenError", {
+ message: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+}) {}
diff --git a/packages/contracts/src/git.ts b/packages/contracts/src/git.ts
index f8b65abf2..65504fabc 100644
--- a/packages/contracts/src/git.ts
+++ b/packages/contracts/src/git.ts
@@ -223,6 +223,60 @@ export const GitPullResult = Schema.Struct({
});
export type GitPullResult = typeof GitPullResult.Type;
+// RPC / domain errors
+export class GitCommandError extends Schema.TaggedErrorClass<GitCommandError>()("GitCommandError", {
+ operation: Schema.String,
+ command: Schema.String,
+ cwd: Schema.String,
+ detail: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+}) {
+ override get message(): string {
+ return `Git command failed in ${this.operation}: ${this.command} (${this.cwd}) - ${this.detail}`;
+ }
+}
+
+export class GitHubCliError extends Schema.TaggedErrorClass<GitHubCliError>()("GitHubCliError", {
+ operation: Schema.String,
+ detail: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+}) {
+ override get message(): string {
+ return `GitHub CLI failed in ${this.operation}: ${this.detail}`;
+ }
+}
+
+export class TextGenerationError extends Schema.TaggedErrorClass<TextGenerationError>()(
+ "TextGenerationError",
+ {
+ operation: Schema.String,
+ detail: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {
+ override get message(): string {
+ return `Text generation failed in ${this.operation}: ${this.detail}`;
+ }
+}
+
+export class GitManagerError extends Schema.TaggedErrorClass<GitManagerError>()("GitManagerError", {
+ operation: Schema.String,
+ detail: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+}) {
+ override get message(): string {
+ return `Git manager failed in ${this.operation}: ${this.detail}`;
+ }
+}
+
+export const GitManagerServiceError = Schema.Union([
+ GitManagerError,
+ GitCommandError,
+ GitHubCliError,
+ TextGenerationError,
+]);
+export type GitManagerServiceError = typeof GitManagerServiceError.Type;
+
const GitActionProgressBase = Schema.Struct({
actionId: TrimmedNonEmptyStringSchema,
cwd: TrimmedNonEmptyStringSchema,
diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts
index 248b3a04f..c60856bbe 100644
--- a/packages/contracts/src/index.ts
+++ b/packages/contracts/src/index.ts
@@ -4,7 +4,6 @@ export * from "./terminal";
export * from "./provider";
export * from "./providerRuntime";
export * from "./model";
-export * from "./ws";
export * from "./keybindings";
export * from "./server";
export * from "./settings";
@@ -12,3 +11,4 @@ export * from "./git";
export * from "./orchestration";
export * from "./editor";
export * from "./project";
+export * from "./rpc";
diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts
index e8b1c4627..3114f6f5b 100644
--- a/packages/contracts/src/ipc.ts
+++ b/packages/contracts/src/ipc.ts
@@ -1,6 +1,5 @@
import type {
GitCheckoutInput,
- GitActionProgressEvent,
GitCreateBranchInput,
GitPreparePullRequestThreadInput,
GitPreparePullRequestThreadResult,
@@ -14,8 +13,6 @@ import type {
GitPullResult,
GitRemoveWorktreeInput,
GitResolvePullRequestResult,
- GitRunStackedActionInput,
- GitRunStackedActionResult,
GitStatusInput,
GitStatusResult,
} from "./git";
@@ -161,8 +158,6 @@ export interface NativeApi {
// Stacked action API
pull: (input: GitPullInput) => Promise<GitPullResult>;
status: (input: GitStatusInput) => Promise<GitStatusResult>;
- runStackedAction: (input: GitRunStackedActionInput) => Promise<GitRunStackedActionResult>;
- onActionProgress: (callback: (event: GitActionProgressEvent) => void) => () => void;
};
contextMenu: {
show: <T extends string>(
diff --git a/packages/contracts/src/keybindings.ts b/packages/contracts/src/keybindings.ts
index 067cba880..b08fff867 100644
--- a/packages/contracts/src/keybindings.ts
+++ b/packages/contracts/src/keybindings.ts
@@ -85,24 +85,27 @@ export const KeybindingShortcut = Schema.Struct({
});
export type KeybindingShortcut = typeof KeybindingShortcut.Type;
-export const KeybindingWhenNode: Schema.Schema<KeybindingWhenNode> = Schema.Union([
+const KeybindingWhenNodeRef = Schema.suspend(
+ (): Schema.Codec<KeybindingWhenNode> => KeybindingWhenNode,
+);
+export const KeybindingWhenNode = Schema.Union([
Schema.Struct({
type: Schema.Literal("identifier"),
name: Schema.NonEmptyString,
}),
Schema.Struct({
type: Schema.Literal("not"),
- node: Schema.suspend((): Schema.Schema<KeybindingWhenNode> => KeybindingWhenNode),
+ node: KeybindingWhenNodeRef,
}),
Schema.Struct({
type: Schema.Literal("and"),
- left: Schema.suspend((): Schema.Schema<KeybindingWhenNode> => KeybindingWhenNode),
- right: Schema.suspend((): Schema.Schema<KeybindingWhenNode> => KeybindingWhenNode),
+ left: KeybindingWhenNodeRef,
+ right: KeybindingWhenNodeRef,
}),
Schema.Struct({
type: Schema.Literal("or"),
- left: Schema.suspend((): Schema.Schema<KeybindingWhenNode> => KeybindingWhenNode),
- right: Schema.suspend((): Schema.Schema<KeybindingWhenNode> => KeybindingWhenNode),
+ left: KeybindingWhenNodeRef,
+ right: KeybindingWhenNodeRef,
}),
]);
export type KeybindingWhenNode =
@@ -122,3 +125,16 @@ export const ResolvedKeybindingsConfig = Schema.Array(ResolvedKeybindingRule).ch
Schema.isMaxLength(MAX_KEYBINDINGS_COUNT),
);
export type ResolvedKeybindingsConfig = typeof ResolvedKeybindingsConfig.Type;
+
+export class KeybindingsConfigError extends Schema.TaggedErrorClass<KeybindingsConfigError>()(
+ "KeybindingsConfigParseError",
+ {
+ configPath: Schema.String,
+ detail: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {
+ override get message(): string {
+ return `Unable to parse keybindings config at ${this.configPath}: ${this.detail}`;
+ }
+}
diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.ts
index a780a55c7..bd7e374f3 100644
--- a/packages/contracts/src/orchestration.ts
+++ b/packages/contracts/src/orchestration.ts
@@ -23,10 +23,6 @@ export const ORCHESTRATION_WS_METHODS = {
replayEvents: "orchestration.replayEvents",
} as const;
-export const ORCHESTRATION_WS_CHANNELS = {
- domainEvent: "orchestration.domainEvent",
-} as const;
-
export const ProviderKind = Schema.Literals(["codex", "claudeAgent"]);
export type ProviderKind = typeof ProviderKind.Type;
export const ProviderApprovalPolicy = Schema.Literals([
@@ -1037,3 +1033,43 @@ export const OrchestrationRpcSchemas = {
output: OrchestrationReplayEventsResult,
},
} as const;
+
+export class OrchestrationGetSnapshotError extends Schema.TaggedErrorClass<OrchestrationGetSnapshotError>()(
+ "OrchestrationGetSnapshotError",
+ {
+ message: TrimmedNonEmptyString,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
+
+export class OrchestrationDispatchCommandError extends Schema.TaggedErrorClass<OrchestrationDispatchCommandError>()(
+ "OrchestrationDispatchCommandError",
+ {
+ message: TrimmedNonEmptyString,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
+
+export class OrchestrationGetTurnDiffError extends Schema.TaggedErrorClass<OrchestrationGetTurnDiffError>()(
+ "OrchestrationGetTurnDiffError",
+ {
+ message: TrimmedNonEmptyString,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
+
+export class OrchestrationGetFullThreadDiffError extends Schema.TaggedErrorClass<OrchestrationGetFullThreadDiffError>()(
+ "OrchestrationGetFullThreadDiffError",
+ {
+ message: TrimmedNonEmptyString,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
+
+export class OrchestrationReplayEventsError extends Schema.TaggedErrorClass<OrchestrationReplayEventsError>()(
+ "OrchestrationReplayEventsError",
+ {
+ message: TrimmedNonEmptyString,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
diff --git a/packages/contracts/src/project.ts b/packages/contracts/src/project.ts
index 090325330..2851120d1 100644
--- a/packages/contracts/src/project.ts
+++ b/packages/contracts/src/project.ts
@@ -26,6 +26,14 @@ export const ProjectSearchEntriesResult = Schema.Struct({
});
export type ProjectSearchEntriesResult = typeof ProjectSearchEntriesResult.Type;
+export class ProjectSearchEntriesError extends Schema.TaggedErrorClass<ProjectSearchEntriesError>()(
+ "ProjectSearchEntriesError",
+ {
+ message: TrimmedNonEmptyString,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
+
export const ProjectWriteFileInput = Schema.Struct({
cwd: TrimmedNonEmptyString,
relativePath: TrimmedNonEmptyString.check(Schema.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
@@ -37,3 +45,11 @@ export const ProjectWriteFileResult = Schema.Struct({
relativePath: TrimmedNonEmptyString,
});
export type ProjectWriteFileResult = typeof ProjectWriteFileResult.Type;
+
+export class ProjectWriteFileError extends Schema.TaggedErrorClass<ProjectWriteFileError>()(
+ "ProjectWriteFileError",
+ {
+ message: TrimmedNonEmptyString,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
new file mode 100644
index 000000000..34968e66e
--- /dev/null
+++ b/packages/contracts/src/rpc.ts
@@ -0,0 +1,359 @@
+import { Schema } from "effect";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+
+import { OpenError, OpenInEditorInput } from "./editor";
+import {
+ GitActionProgressEvent,
+ GitCheckoutInput,
+ GitCommandError,
+ GitCreateBranchInput,
+ GitCreateWorktreeInput,
+ GitCreateWorktreeResult,
+ GitInitInput,
+ GitListBranchesInput,
+ GitListBranchesResult,
+ GitManagerServiceError,
+ GitPreparePullRequestThreadInput,
+ GitPreparePullRequestThreadResult,
+ GitPullInput,
+ GitPullRequestRefInput,
+ GitPullResult,
+ GitRemoveWorktreeInput,
+ GitResolvePullRequestResult,
+ GitRunStackedActionInput,
+ GitStatusInput,
+ GitStatusResult,
+} from "./git";
+import { KeybindingsConfigError } from "./keybindings";
+import {
+ ClientOrchestrationCommand,
+ OrchestrationEvent,
+ ORCHESTRATION_WS_METHODS,
+ OrchestrationDispatchCommandError,
+ OrchestrationGetFullThreadDiffError,
+ OrchestrationGetFullThreadDiffInput,
+ OrchestrationGetSnapshotError,
+ OrchestrationGetSnapshotInput,
+ OrchestrationGetTurnDiffError,
+ OrchestrationGetTurnDiffInput,
+ OrchestrationReplayEventsError,
+ OrchestrationReplayEventsInput,
+ OrchestrationRpcSchemas,
+} from "./orchestration";
+import {
+ ProjectSearchEntriesError,
+ ProjectSearchEntriesInput,
+ ProjectSearchEntriesResult,
+ ProjectWriteFileError,
+ ProjectWriteFileInput,
+ ProjectWriteFileResult,
+} from "./project";
+import {
+ TerminalClearInput,
+ TerminalCloseInput,
+ TerminalError,
+ TerminalEvent,
+ TerminalOpenInput,
+ TerminalResizeInput,
+ TerminalRestartInput,
+ TerminalSessionSnapshot,
+ TerminalWriteInput,
+} from "./terminal";
+import {
+ ServerConfigStreamEvent,
+ ServerConfig,
+ ServerLifecycleStreamEvent,
+ ServerProviderUpdatedPayload,
+ ServerUpsertKeybindingInput,
+ ServerUpsertKeybindingResult,
+} from "./server";
+import { ServerSettings, ServerSettingsError, ServerSettingsPatch } from "./settings";
+
+export const WS_METHODS = {
+ // Project registry methods
+ projectsList: "projects.list",
+ projectsAdd: "projects.add",
+ projectsRemove: "projects.remove",
+ projectsSearchEntries: "projects.searchEntries",
+ projectsWriteFile: "projects.writeFile",
+
+ // Shell methods
+ shellOpenInEditor: "shell.openInEditor",
+
+ // Git methods
+ gitPull: "git.pull",
+ gitStatus: "git.status",
+ gitRunStackedAction: "git.runStackedAction",
+ gitListBranches: "git.listBranches",
+ gitCreateWorktree: "git.createWorktree",
+ gitRemoveWorktree: "git.removeWorktree",
+ gitCreateBranch: "git.createBranch",
+ gitCheckout: "git.checkout",
+ gitInit: "git.init",
+ gitResolvePullRequest: "git.resolvePullRequest",
+ gitPreparePullRequestThread: "git.preparePullRequestThread",
+
+ // Terminal methods
+ terminalOpen: "terminal.open",
+ terminalWrite: "terminal.write",
+ terminalResize: "terminal.resize",
+ terminalClear: "terminal.clear",
+ terminalRestart: "terminal.restart",
+ terminalClose: "terminal.close",
+
+ // Server meta
+ serverGetConfig: "server.getConfig",
+ serverRefreshProviders: "server.refreshProviders",
+ serverUpsertKeybinding: "server.upsertKeybinding",
+ serverGetSettings: "server.getSettings",
+ serverUpdateSettings: "server.updateSettings",
+
+ // Streaming subscriptions
+ subscribeOrchestrationDomainEvents: "subscribeOrchestrationDomainEvents",
+ subscribeTerminalEvents: "subscribeTerminalEvents",
+ subscribeServerConfig: "subscribeServerConfig",
+ subscribeServerLifecycle: "subscribeServerLifecycle",
+} as const;
+
+export const WsServerUpsertKeybindingRpc = Rpc.make(WS_METHODS.serverUpsertKeybinding, {
+ payload: ServerUpsertKeybindingInput,
+ success: ServerUpsertKeybindingResult,
+ error: KeybindingsConfigError,
+});
+
+export const WsServerGetConfigRpc = Rpc.make(WS_METHODS.serverGetConfig, {
+ payload: Schema.Struct({}),
+ success: ServerConfig,
+ error: Schema.Union([KeybindingsConfigError, ServerSettingsError]),
+});
+
+export const WsServerRefreshProvidersRpc = Rpc.make(WS_METHODS.serverRefreshProviders, {
+ payload: Schema.Struct({}),
+ success: ServerProviderUpdatedPayload,
+});
+
+export const WsServerGetSettingsRpc = Rpc.make(WS_METHODS.serverGetSettings, {
+ payload: Schema.Struct({}),
+ success: ServerSettings,
+ error: ServerSettingsError,
+});
+
+export const WsServerUpdateSettingsRpc = Rpc.make(WS_METHODS.serverUpdateSettings, {
+ payload: Schema.Struct({ patch: ServerSettingsPatch }),
+ success: ServerSettings,
+ error: ServerSettingsError,
+});
+
+export const WsProjectsSearchEntriesRpc = Rpc.make(WS_METHODS.projectsSearchEntries, {
+ payload: ProjectSearchEntriesInput,
+ success: ProjectSearchEntriesResult,
+ error: ProjectSearchEntriesError,
+});
+
+export const WsProjectsWriteFileRpc = Rpc.make(WS_METHODS.projectsWriteFile, {
+ payload: ProjectWriteFileInput,
+ success: ProjectWriteFileResult,
+ error: ProjectWriteFileError,
+});
+
+export const WsShellOpenInEditorRpc = Rpc.make(WS_METHODS.shellOpenInEditor, {
+ payload: OpenInEditorInput,
+ error: OpenError,
+});
+
+export const WsGitStatusRpc = Rpc.make(WS_METHODS.gitStatus, {
+ payload: GitStatusInput,
+ success: GitStatusResult,
+ error: GitManagerServiceError,
+});
+
+export const WsGitPullRpc = Rpc.make(WS_METHODS.gitPull, {
+ payload: GitPullInput,
+ success: GitPullResult,
+ error: GitCommandError,
+});
+
+export const WsGitRunStackedActionRpc = Rpc.make(WS_METHODS.gitRunStackedAction, {
+ payload: GitRunStackedActionInput,
+ success: GitActionProgressEvent,
+ error: GitManagerServiceError,
+ stream: true,
+});
+
+export const WsGitResolvePullRequestRpc = Rpc.make(WS_METHODS.gitResolvePullRequest, {
+ payload: GitPullRequestRefInput,
+ success: GitResolvePullRequestResult,
+ error: GitManagerServiceError,
+});
+
+export const WsGitPreparePullRequestThreadRpc = Rpc.make(WS_METHODS.gitPreparePullRequestThread, {
+ payload: GitPreparePullRequestThreadInput,
+ success: GitPreparePullRequestThreadResult,
+ error: GitManagerServiceError,
+});
+
+export const WsGitListBranchesRpc = Rpc.make(WS_METHODS.gitListBranches, {
+ payload: GitListBranchesInput,
+ success: GitListBranchesResult,
+ error: GitCommandError,
+});
+
+export const WsGitCreateWorktreeRpc = Rpc.make(WS_METHODS.gitCreateWorktree, {
+ payload: GitCreateWorktreeInput,
+ success: GitCreateWorktreeResult,
+ error: GitCommandError,
+});
+
+export const WsGitRemoveWorktreeRpc = Rpc.make(WS_METHODS.gitRemoveWorktree, {
+ payload: GitRemoveWorktreeInput,
+ error: GitCommandError,
+});
+
+export const WsGitCreateBranchRpc = Rpc.make(WS_METHODS.gitCreateBranch, {
+ payload: GitCreateBranchInput,
+ error: GitCommandError,
+});
+
+export const WsGitCheckoutRpc = Rpc.make(WS_METHODS.gitCheckout, {
+ payload: GitCheckoutInput,
+ error: GitCommandError,
+});
+
+export const WsGitInitRpc = Rpc.make(WS_METHODS.gitInit, {
+ payload: GitInitInput,
+ error: GitCommandError,
+});
+
+export const WsTerminalOpenRpc = Rpc.make(WS_METHODS.terminalOpen, {
+ payload: TerminalOpenInput,
+ success: TerminalSessionSnapshot,
+ error: TerminalError,
+});
+
+export const WsTerminalWriteRpc = Rpc.make(WS_METHODS.terminalWrite, {
+ payload: TerminalWriteInput,
+ error: TerminalError,
+});
+
+export const WsTerminalResizeRpc = Rpc.make(WS_METHODS.terminalResize, {
+ payload: TerminalResizeInput,
+ error: TerminalError,
+});
+
+export const WsTerminalClearRpc = Rpc.make(WS_METHODS.terminalClear, {
+ payload: TerminalClearInput,
+ error: TerminalError,
+});
+
+export const WsTerminalRestartRpc = Rpc.make(WS_METHODS.terminalRestart, {
+ payload: TerminalRestartInput,
+ success: TerminalSessionSnapshot,
+ error: TerminalError,
+});
+
+export const WsTerminalCloseRpc = Rpc.make(WS_METHODS.terminalClose, {
+ payload: TerminalCloseInput,
+ error: TerminalError,
+});
+
+export const WsOrchestrationGetSnapshotRpc = Rpc.make(ORCHESTRATION_WS_METHODS.getSnapshot, {
+ payload: OrchestrationGetSnapshotInput,
+ success: OrchestrationRpcSchemas.getSnapshot.output,
+ error: OrchestrationGetSnapshotError,
+});
+
+export const WsOrchestrationDispatchCommandRpc = Rpc.make(
+ ORCHESTRATION_WS_METHODS.dispatchCommand,
+ {
+ payload: ClientOrchestrationCommand,
+ success: OrchestrationRpcSchemas.dispatchCommand.output,
+ error: OrchestrationDispatchCommandError,
+ },
+);
+
+export const WsOrchestrationGetTurnDiffRpc = Rpc.make(ORCHESTRATION_WS_METHODS.getTurnDiff, {
+ payload: OrchestrationGetTurnDiffInput,
+ success: OrchestrationRpcSchemas.getTurnDiff.output,
+ error: OrchestrationGetTurnDiffError,
+});
+
+export const WsOrchestrationGetFullThreadDiffRpc = Rpc.make(
+ ORCHESTRATION_WS_METHODS.getFullThreadDiff,
+ {
+ payload: OrchestrationGetFullThreadDiffInput,
+ success: OrchestrationRpcSchemas.getFullThreadDiff.output,
+ error: OrchestrationGetFullThreadDiffError,
+ },
+);
+
+export const WsOrchestrationReplayEventsRpc = Rpc.make(ORCHESTRATION_WS_METHODS.replayEvents, {
+ payload: OrchestrationReplayEventsInput,
+ success: OrchestrationRpcSchemas.replayEvents.output,
+ error: OrchestrationReplayEventsError,
+});
+
+export const WsSubscribeOrchestrationDomainEventsRpc = Rpc.make(
+ WS_METHODS.subscribeOrchestrationDomainEvents,
+ {
+ payload: Schema.Struct({}),
+ success: OrchestrationEvent,
+ stream: true,
+ },
+);
+
+export const WsSubscribeTerminalEventsRpc = Rpc.make(WS_METHODS.subscribeTerminalEvents, {
+ payload: Schema.Struct({}),
+ success: TerminalEvent,
+ stream: true,
+});
+
+export const WsSubscribeServerConfigRpc = Rpc.make(WS_METHODS.subscribeServerConfig, {
+ payload: Schema.Struct({}),
+ success: ServerConfigStreamEvent,
+ error: Schema.Union([KeybindingsConfigError, ServerSettingsError]),
+ stream: true,
+});
+
+export const WsSubscribeServerLifecycleRpc = Rpc.make(WS_METHODS.subscribeServerLifecycle, {
+ payload: Schema.Struct({}),
+ success: ServerLifecycleStreamEvent,
+ stream: true,
+});
+
+export const WsRpcGroup = RpcGroup.make(
+ WsServerGetConfigRpc,
+ WsServerRefreshProvidersRpc,
+ WsServerUpsertKeybindingRpc,
+ WsServerGetSettingsRpc,
+ WsServerUpdateSettingsRpc,
+ WsProjectsSearchEntriesRpc,
+ WsProjectsWriteFileRpc,
+ WsShellOpenInEditorRpc,
+ WsGitStatusRpc,
+ WsGitPullRpc,
+ WsGitRunStackedActionRpc,
+ WsGitResolvePullRequestRpc,
+ WsGitPreparePullRequestThreadRpc,
+ WsGitListBranchesRpc,
+ WsGitCreateWorktreeRpc,
+ WsGitRemoveWorktreeRpc,
+ WsGitCreateBranchRpc,
+ WsGitCheckoutRpc,
+ WsGitInitRpc,
+ WsTerminalOpenRpc,
+ WsTerminalWriteRpc,
+ WsTerminalResizeRpc,
+ WsTerminalClearRpc,
+ WsTerminalRestartRpc,
+ WsTerminalCloseRpc,
+ WsSubscribeOrchestrationDomainEventsRpc,
+ WsSubscribeTerminalEventsRpc,
+ WsSubscribeServerConfigRpc,
+ WsSubscribeServerLifecycleRpc,
+ WsOrchestrationGetSnapshotRpc,
+ WsOrchestrationDispatchCommandRpc,
+ WsOrchestrationGetTurnDiffRpc,
+ WsOrchestrationGetFullThreadDiffRpc,
+ WsOrchestrationReplayEventsRpc,
+);
diff --git a/packages/contracts/src/server.ts b/packages/contracts/src/server.ts
index 08910c3ec..d4038deb3 100644
--- a/packages/contracts/src/server.ts
+++ b/packages/contracts/src/server.ts
@@ -1,5 +1,11 @@
import { Schema } from "effect";
-import { IsoDateTime, TrimmedNonEmptyString } from "./baseSchemas";
+import {
+ IsoDateTime,
+ NonNegativeInt,
+ ProjectId,
+ ThreadId,
+ TrimmedNonEmptyString,
+} from "./baseSchemas";
import { KeybindingRule, ResolvedKeybindingsConfig } from "./keybindings";
import { EditorId } from "./editor";
import { ModelCapabilities } from "./model";
@@ -63,7 +69,8 @@ export const ServerProvider = Schema.Struct({
});
export type ServerProvider = typeof ServerProvider.Type;
-const ServerProviders = Schema.Array(ServerProvider);
+export const ServerProviders = Schema.Array(ServerProvider);
+export type ServerProviders = typeof ServerProviders.Type;
export const ServerConfig = Schema.Struct({
cwd: TrimmedNonEmptyString,
@@ -87,10 +94,101 @@ export type ServerUpsertKeybindingResult = typeof ServerUpsertKeybindingResult.T
export const ServerConfigUpdatedPayload = Schema.Struct({
issues: ServerConfigIssues,
+ providers: ServerProviders,
settings: Schema.optional(ServerSettings),
});
export type ServerConfigUpdatedPayload = typeof ServerConfigUpdatedPayload.Type;
+export const ServerConfigKeybindingsUpdatedPayload = Schema.Struct({
+ issues: ServerConfigIssues,
+});
+export type ServerConfigKeybindingsUpdatedPayload =
+ typeof ServerConfigKeybindingsUpdatedPayload.Type;
+
+export const ServerConfigProviderStatusesPayload = Schema.Struct({
+ providers: ServerProviders,
+});
+export type ServerConfigProviderStatusesPayload = typeof ServerConfigProviderStatusesPayload.Type;
+
+export const ServerConfigSettingsUpdatedPayload = Schema.Struct({
+ settings: ServerSettings,
+});
+export type ServerConfigSettingsUpdatedPayload = typeof ServerConfigSettingsUpdatedPayload.Type;
+
+export const ServerConfigStreamSnapshotEvent = Schema.Struct({
+ version: Schema.Literal(1),
+ type: Schema.Literal("snapshot"),
+ config: ServerConfig,
+});
+export type ServerConfigStreamSnapshotEvent = typeof ServerConfigStreamSnapshotEvent.Type;
+
+export const ServerConfigStreamKeybindingsUpdatedEvent = Schema.Struct({
+ version: Schema.Literal(1),
+ type: Schema.Literal("keybindingsUpdated"),
+ payload: ServerConfigKeybindingsUpdatedPayload,
+});
+export type ServerConfigStreamKeybindingsUpdatedEvent =
+ typeof ServerConfigStreamKeybindingsUpdatedEvent.Type;
+
+export const ServerConfigStreamProviderStatusesEvent = Schema.Struct({
+ version: Schema.Literal(1),
+ type: Schema.Literal("providerStatuses"),
+ payload: ServerConfigProviderStatusesPayload,
+});
+export type ServerConfigStreamProviderStatusesEvent =
+ typeof ServerConfigStreamProviderStatusesEvent.Type;
+
+export const ServerConfigStreamSettingsUpdatedEvent = Schema.Struct({
+ version: Schema.Literal(1),
+ type: Schema.Literal("settingsUpdated"),
+ payload: ServerConfigSettingsUpdatedPayload,
+});
+export type ServerConfigStreamSettingsUpdatedEvent =
+ typeof ServerConfigStreamSettingsUpdatedEvent.Type;
+
+export const ServerConfigStreamEvent = Schema.Union([
+ ServerConfigStreamSnapshotEvent,
+ ServerConfigStreamKeybindingsUpdatedEvent,
+ ServerConfigStreamProviderStatusesEvent,
+ ServerConfigStreamSettingsUpdatedEvent,
+]);
+export type ServerConfigStreamEvent = typeof ServerConfigStreamEvent.Type;
+
+export const ServerLifecycleReadyPayload = Schema.Struct({
+ at: IsoDateTime,
+});
+export type ServerLifecycleReadyPayload = typeof ServerLifecycleReadyPayload.Type;
+
+export const ServerLifecycleWelcomePayload = Schema.Struct({
+ cwd: TrimmedNonEmptyString,
+ projectName: TrimmedNonEmptyString,
+ bootstrapProjectId: Schema.optional(ProjectId),
+ bootstrapThreadId: Schema.optional(ThreadId),
+});
+export type ServerLifecycleWelcomePayload = typeof ServerLifecycleWelcomePayload.Type;
+
+export const ServerLifecycleStreamWelcomeEvent = Schema.Struct({
+ version: Schema.Literal(1),
+ sequence: NonNegativeInt,
+ type: Schema.Literal("welcome"),
+ payload: ServerLifecycleWelcomePayload,
+});
+export type ServerLifecycleStreamWelcomeEvent = typeof ServerLifecycleStreamWelcomeEvent.Type;
+
+export const ServerLifecycleStreamReadyEvent = Schema.Struct({
+ version: Schema.Literal(1),
+ sequence: NonNegativeInt,
+ type: Schema.Literal("ready"),
+ payload: ServerLifecycleReadyPayload,
+});
+export type ServerLifecycleStreamReadyEvent = typeof ServerLifecycleStreamReadyEvent.Type;
+
+export const ServerLifecycleStreamEvent = Schema.Union([
+ ServerLifecycleStreamWelcomeEvent,
+ ServerLifecycleStreamReadyEvent,
+]);
+export type ServerLifecycleStreamEvent = typeof ServerLifecycleStreamEvent.Type;
+
export const ServerProviderUpdatedPayload = Schema.Struct({
providers: ServerProviders,
});
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index 51fe683f9..c28b566da 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -93,6 +93,19 @@ export type ServerSettings = typeof ServerSettings.Type;
export const DEFAULT_SERVER_SETTINGS: ServerSettings = Schema.decodeSync(ServerSettings)({});
+export class ServerSettingsError extends Schema.TaggedErrorClass<ServerSettingsError>()(
+ "ServerSettingsError",
+ {
+ settingsPath: Schema.String,
+ detail: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {
+ override get message(): string {
+ return `Server settings error at ${this.settingsPath}: ${this.detail}`;
+ }
+}
+
// ── Unified type ─────────────────────────────────────────────────────
export type UnifiedSettings = ServerSettings & ClientSettings;
diff --git a/packages/contracts/src/terminal.ts b/packages/contracts/src/terminal.ts
index f9729da66..4344706bc 100644
--- a/packages/contracts/src/terminal.ts
+++ b/packages/contracts/src/terminal.ts
@@ -149,3 +149,74 @@ export const TerminalEvent = Schema.Union([
TerminalActivityEvent,
]);
export type TerminalEvent = typeof TerminalEvent.Type;
+
+export class TerminalCwdError extends Schema.TaggedErrorClass<TerminalCwdError>()(
+ "TerminalCwdError",
+ {
+ cwd: Schema.String,
+ reason: Schema.Literals(["notFound", "notDirectory", "statFailed"]),
+ cause: Schema.optional(Schema.Defect),
+ },
+) {
+ override get message() {
+ if (this.reason === "notDirectory") {
+ return `Terminal cwd is not a directory: ${this.cwd}`;
+ }
+ if (this.reason === "notFound") {
+ return `Terminal cwd does not exist: ${this.cwd}`;
+ }
+ const causeMessage =
+ this.cause && typeof this.cause === "object" && "message" in this.cause
+ ? this.cause.message
+ : undefined;
+ return causeMessage
+ ? `Failed to access terminal cwd: ${this.cwd} (${causeMessage})`
+ : `Failed to access terminal cwd: ${this.cwd}`;
+ }
+}
+
+export class TerminalHistoryError extends Schema.TaggedErrorClass<TerminalHistoryError>()(
+ "TerminalHistoryError",
+ {
+ operation: Schema.Literals(["read", "truncate", "migrate"]),
+ threadId: Schema.String,
+ terminalId: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {
+ override get message() {
+ return `Failed to ${this.operation} terminal history for thread: ${this.threadId}, terminal: ${this.terminalId}`;
+ }
+}
+
+export class TerminalSessionLookupError extends Schema.TaggedErrorClass<TerminalSessionLookupError>()(
+ "TerminalSessionLookupError",
+ {
+ threadId: Schema.String,
+ terminalId: Schema.String,
+ },
+) {
+ override get message() {
+ return `Unknown terminal thread: ${this.threadId}, terminal: ${this.terminalId}`;
+ }
+}
+
+export class TerminalNotRunningError extends Schema.TaggedErrorClass<TerminalNotRunningError>()(
+ "TerminalNotRunningError",
+ {
+ threadId: Schema.String,
+ terminalId: Schema.String,
+ },
+) {
+ override get message() {
+ return `Terminal is not running for thread: ${this.threadId}, terminal: ${this.terminalId}`;
+ }
+}
+
+export const TerminalError = Schema.Union([
+ TerminalCwdError,
+ TerminalHistoryError,
+ TerminalSessionLookupError,
+ TerminalNotRunningError,
+]);
+export type TerminalError = typeof TerminalError.Type;
diff --git a/packages/contracts/src/ws.test.ts b/packages/contracts/src/ws.test.ts
deleted file mode 100644
index 0d8d4dbec..000000000
--- a/packages/contracts/src/ws.test.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-import { assert, it } from "@effect/vitest";
-import { Effect, Schema } from "effect";
-
-import { ORCHESTRATION_WS_CHANNELS, ORCHESTRATION_WS_METHODS } from "./orchestration";
-import { WebSocketRequest, WsResponse, WS_CHANNELS, WS_METHODS } from "./ws";
-
-const decodeWebSocketRequest = Schema.decodeUnknownEffect(WebSocketRequest);
-const decodeWsResponse = Schema.decodeUnknownEffect(WsResponse);
-
-it.effect("accepts getTurnDiff requests when fromTurnCount <= toTurnCount", () =>
- Effect.gen(function* () {
- const parsed = yield* decodeWebSocketRequest({
- id: "req-1",
- body: {
- _tag: ORCHESTRATION_WS_METHODS.getTurnDiff,
- threadId: "thread-1",
- fromTurnCount: 1,
- toTurnCount: 2,
- },
- });
- assert.strictEqual(parsed.body._tag, ORCHESTRATION_WS_METHODS.getTurnDiff);
- }),
-);
-
-it.effect("rejects getTurnDiff requests when fromTurnCount > toTurnCount", () =>
- Effect.gen(function* () {
- const result = yield* Effect.exit(
- decodeWebSocketRequest({
- id: "req-1",
- body: {
- _tag: ORCHESTRATION_WS_METHODS.getTurnDiff,
- threadId: "thread-1",
- fromTurnCount: 3,
- toTurnCount: 2,
- },
- }),
- );
- assert.strictEqual(result._tag, "Failure");
- }),
-);
-
-it.effect("trims websocket request id and nested orchestration ids", () =>
- Effect.gen(function* () {
- const parsed = yield* decodeWebSocketRequest({
- id: " req-1 ",
- body: {
- _tag: ORCHESTRATION_WS_METHODS.getTurnDiff,
- threadId: " thread-1 ",
- fromTurnCount: 0,
- toTurnCount: 0,
- },
- });
- assert.strictEqual(parsed.id, "req-1");
- assert.strictEqual(parsed.body._tag, ORCHESTRATION_WS_METHODS.getTurnDiff);
- if (parsed.body._tag === ORCHESTRATION_WS_METHODS.getTurnDiff) {
- assert.strictEqual(parsed.body.threadId, "thread-1");
- }
- }),
-);
-
-it.effect("accepts git.preparePullRequestThread requests", () =>
- Effect.gen(function* () {
- const parsed = yield* decodeWebSocketRequest({
- id: "req-pr-1",
- body: {
- _tag: WS_METHODS.gitPreparePullRequestThread,
- cwd: "/repo",
- reference: "#42",
- mode: "worktree",
- },
- });
- assert.strictEqual(parsed.body._tag, WS_METHODS.gitPreparePullRequestThread);
- }),
-);
-
-it.effect("accepts typed websocket push envelopes with sequence", () =>
- Effect.gen(function* () {
- const parsed = yield* decodeWsResponse({
- type: "push",
- sequence: 1,
- channel: WS_CHANNELS.serverWelcome,
- data: {
- cwd: "/tmp/workspace",
- projectName: "workspace",
- },
- });
-
- if (!("type" in parsed) || parsed.type !== "push") {
- assert.fail("expected websocket response to decode as a push envelope");
- }
-
- assert.strictEqual(parsed.type, "push");
- assert.strictEqual(parsed.sequence, 1);
- assert.strictEqual(parsed.channel, WS_CHANNELS.serverWelcome);
- }),
-);
-
-it.effect("accepts git.actionProgress push envelopes", () =>
- Effect.gen(function* () {
- const parsed = yield* decodeWsResponse({
- type: "push",
- sequence: 3,
- channel: WS_CHANNELS.gitActionProgress,
- data: {
- actionId: "action-1",
- cwd: "/repo",
- action: "commit",
- kind: "phase_started",
- phase: "commit",
- label: "Committing...",
- },
- });
-
- if (!("type" in parsed) || parsed.type !== "push") {
- assert.fail("expected websocket response to decode as a push envelope");
- }
-
- assert.strictEqual(parsed.channel, WS_CHANNELS.gitActionProgress);
- }),
-);
-
-it.effect("accepts server.providersUpdated push envelopes", () =>
- Effect.gen(function* () {
- const parsed = yield* decodeWsResponse({
- type: "push",
- sequence: 4,
- channel: WS_CHANNELS.serverProvidersUpdated,
- data: {
- providers: [],
- },
- });
-
- if (!("type" in parsed) || parsed.type !== "push") {
- assert.fail("expected websocket response to decode as a push envelope");
- }
-
- assert.strictEqual(parsed.channel, WS_CHANNELS.serverProvidersUpdated);
- }),
-);
-
-it.effect("rejects push envelopes when channel payload does not match the channel schema", () =>
- Effect.gen(function* () {
- const result = yield* Effect.exit(
- decodeWsResponse({
- type: "push",
- sequence: 2,
- channel: ORCHESTRATION_WS_CHANNELS.domainEvent,
- data: {
- cwd: "/tmp/workspace",
- projectName: "workspace",
- },
- }),
- );
-
- assert.strictEqual(result._tag, "Failure");
- }),
-);
diff --git a/packages/contracts/src/ws.ts b/packages/contracts/src/ws.ts
deleted file mode 100644
index 2bcc37f7c..000000000
--- a/packages/contracts/src/ws.ts
+++ /dev/null
@@ -1,257 +0,0 @@
-import { Schema, Struct } from "effect";
-import { NonNegativeInt, ProjectId, ThreadId, TrimmedNonEmptyString } from "./baseSchemas";
-
-import {
- ClientOrchestrationCommand,
- OrchestrationEvent,
- ORCHESTRATION_WS_CHANNELS,
- OrchestrationGetFullThreadDiffInput,
- ORCHESTRATION_WS_METHODS,
- OrchestrationGetSnapshotInput,
- OrchestrationGetTurnDiffInput,
- OrchestrationReplayEventsInput,
-} from "./orchestration";
-import {
- GitActionProgressEvent,
- GitCheckoutInput,
- GitCreateBranchInput,
- GitPreparePullRequestThreadInput,
- GitCreateWorktreeInput,
- GitInitInput,
- GitListBranchesInput,
- GitPullInput,
- GitPullRequestRefInput,
- GitRemoveWorktreeInput,
- GitRunStackedActionInput,
- GitStatusInput,
-} from "./git";
-import {
- TerminalClearInput,
- TerminalCloseInput,
- TerminalEvent,
- TerminalOpenInput,
- TerminalResizeInput,
- TerminalRestartInput,
- TerminalWriteInput,
-} from "./terminal";
-import { KeybindingRule } from "./keybindings";
-import { ProjectSearchEntriesInput, ProjectWriteFileInput } from "./project";
-import { OpenInEditorInput } from "./editor";
-import { ServerConfigUpdatedPayload, ServerProviderUpdatedPayload } from "./server";
-import { ServerSettingsPatch } from "./settings";
-
-// ── WebSocket RPC Method Names ───────────────────────────────────────
-
-export const WS_METHODS = {
- // Project registry methods
- projectsList: "projects.list",
- projectsAdd: "projects.add",
- projectsRemove: "projects.remove",
- projectsSearchEntries: "projects.searchEntries",
- projectsWriteFile: "projects.writeFile",
-
- // Shell methods
- shellOpenInEditor: "shell.openInEditor",
-
- // Git methods
- gitPull: "git.pull",
- gitStatus: "git.status",
- gitRunStackedAction: "git.runStackedAction",
- gitListBranches: "git.listBranches",
- gitCreateWorktree: "git.createWorktree",
- gitRemoveWorktree: "git.removeWorktree",
- gitCreateBranch: "git.createBranch",
- gitCheckout: "git.checkout",
- gitInit: "git.init",
- gitResolvePullRequest: "git.resolvePullRequest",
- gitPreparePullRequestThread: "git.preparePullRequestThread",
-
- // Terminal methods
- terminalOpen: "terminal.open",
- terminalWrite: "terminal.write",
- terminalResize: "terminal.resize",
- terminalClear: "terminal.clear",
- terminalRestart: "terminal.restart",
- terminalClose: "terminal.close",
-
- // Server meta
- serverGetConfig: "server.getConfig",
- serverRefreshProviders: "server.refreshProviders",
- serverUpsertKeybinding: "server.upsertKeybinding",
- serverGetSettings: "server.getSettings",
- serverUpdateSettings: "server.updateSettings",
-} as const;
-
-// ── Push Event Channels ──────────────────────────────────────────────
-
-export const WS_CHANNELS = {
- gitActionProgress: "git.actionProgress",
- terminalEvent: "terminal.event",
- serverWelcome: "server.welcome",
- serverConfigUpdated: "server.configUpdated",
- serverProvidersUpdated: "server.providersUpdated",
-} as const;
-
-// -- Tagged Union of all request body schemas ─────────────────────────
-
-const tagRequestBody = <const Tag extends string, const Fields extends Schema.Struct.Fields>(
- tag: Tag,
- schema: Schema.Struct<Fields>,
-) =>
- schema.mapFields(
- Struct.assign({ _tag: Schema.tag(tag) }),
- // PreserveChecks is safe here. No existing schema should have checks depending on the tag
- { unsafePreserveChecks: true },
- );
-
-const WebSocketRequestBody = Schema.Union([
- // Orchestration methods
- tagRequestBody(
- ORCHESTRATION_WS_METHODS.dispatchCommand,
- Schema.Struct({ command: ClientOrchestrationCommand }),
- ),
- tagRequestBody(ORCHESTRATION_WS_METHODS.getSnapshot, OrchestrationGetSnapshotInput),
- tagRequestBody(ORCHESTRATION_WS_METHODS.getTurnDiff, OrchestrationGetTurnDiffInput),
- tagRequestBody(ORCHESTRATION_WS_METHODS.getFullThreadDiff, OrchestrationGetFullThreadDiffInput),
- tagRequestBody(ORCHESTRATION_WS_METHODS.replayEvents, OrchestrationReplayEventsInput),
-
- // Project Search
- tagRequestBody(WS_METHODS.projectsSearchEntries, ProjectSearchEntriesInput),
- tagRequestBody(WS_METHODS.projectsWriteFile, ProjectWriteFileInput),
-
- // Shell methods
- tagRequestBody(WS_METHODS.shellOpenInEditor, OpenInEditorInput),
-
- // Git methods
- tagRequestBody(WS_METHODS.gitPull, GitPullInput),
- tagRequestBody(WS_METHODS.gitStatus, GitStatusInput),
- tagRequestBody(WS_METHODS.gitRunStackedAction, GitRunStackedActionInput),
- tagRequestBody(WS_METHODS.gitListBranches, GitListBranchesInput),
- tagRequestBody(WS_METHODS.gitCreateWorktree, GitCreateWorktreeInput),
- tagRequestBody(WS_METHODS.gitRemoveWorktree, GitRemoveWorktreeInput),
- tagRequestBody(WS_METHODS.gitCreateBranch, GitCreateBranchInput),
- tagRequestBody(WS_METHODS.gitCheckout, GitCheckoutInput),
- tagRequestBody(WS_METHODS.gitInit, GitInitInput),
- tagRequestBody(WS_METHODS.gitResolvePullRequest, GitPullRequestRefInput),
- tagRequestBody(WS_METHODS.gitPreparePullRequestThread, GitPreparePullRequestThreadInput),
-
- // Terminal methods
- tagRequestBody(WS_METHODS.terminalOpen, TerminalOpenInput),
- tagRequestBody(WS_METHODS.terminalWrite, TerminalWriteInput),
- tagRequestBody(WS_METHODS.terminalResize, TerminalResizeInput),
- tagRequestBody(WS_METHODS.terminalClear, TerminalClearInput),
- tagRequestBody(WS_METHODS.terminalRestart, TerminalRestartInput),
- tagRequestBody(WS_METHODS.terminalClose, TerminalCloseInput),
-
- // Server meta
- tagRequestBody(WS_METHODS.serverGetConfig, Schema.Struct({})),
- tagRequestBody(WS_METHODS.serverRefreshProviders, Schema.Struct({})),
- tagRequestBody(WS_METHODS.serverUpsertKeybinding, KeybindingRule),
- tagRequestBody(WS_METHODS.serverGetSettings, Schema.Struct({})),
- tagRequestBody(WS_METHODS.serverUpdateSettings, Schema.Struct({ patch: ServerSettingsPatch })),
-]);
-
-export const WebSocketRequest = Schema.Struct({
- id: TrimmedNonEmptyString,
- body: WebSocketRequestBody,
-});
-export type WebSocketRequest = typeof WebSocketRequest.Type;
-
-export const WebSocketResponse = Schema.Struct({
- id: TrimmedNonEmptyString,
- result: Schema.optional(Schema.Unknown),
- error: Schema.optional(
- Schema.Struct({
- message: Schema.String,
- }),
- ),
-});
-export type WebSocketResponse = typeof WebSocketResponse.Type;
-
-export const WsPushSequence = NonNegativeInt;
-export type WsPushSequence = typeof WsPushSequence.Type;
-
-export const WsWelcomePayload = Schema.Struct({
- cwd: TrimmedNonEmptyString,
- projectName: TrimmedNonEmptyString,
- bootstrapProjectId: Schema.optional(ProjectId),
- bootstrapThreadId: Schema.optional(ThreadId),
-});
-export type WsWelcomePayload = typeof WsWelcomePayload.Type;
-
-export interface WsPushPayloadByChannel {
- readonly [WS_CHANNELS.serverWelcome]: WsWelcomePayload;
- readonly [WS_CHANNELS.serverConfigUpdated]: typeof ServerConfigUpdatedPayload.Type;
- readonly [WS_CHANNELS.serverProvidersUpdated]: typeof ServerProviderUpdatedPayload.Type;
- readonly [WS_CHANNELS.gitActionProgress]: typeof GitActionProgressEvent.Type;
- readonly [WS_CHANNELS.terminalEvent]: typeof TerminalEvent.Type;
- readonly [ORCHESTRATION_WS_CHANNELS.domainEvent]: OrchestrationEvent;
-}
-
-export type WsPushChannel = keyof WsPushPayloadByChannel;
-export type WsPushData<C extends WsPushChannel> = WsPushPayloadByChannel[C];
-
-const makeWsPushSchema = <const Channel extends string, Payload extends Schema.Schema<any>>(
- channel: Channel,
- payload: Payload,
-) =>
- Schema.Struct({
- type: Schema.Literal("push"),
- sequence: WsPushSequence,
- channel: Schema.Literal(channel),
- data: payload,
- });
-
-export const WsPushServerWelcome = makeWsPushSchema(WS_CHANNELS.serverWelcome, WsWelcomePayload);
-export const WsPushServerConfigUpdated = makeWsPushSchema(
- WS_CHANNELS.serverConfigUpdated,
- ServerConfigUpdatedPayload,
-);
-export const WsPushServerProvidersUpdated = makeWsPushSchema(
- WS_CHANNELS.serverProvidersUpdated,
- ServerProviderUpdatedPayload,
-);
-export const WsPushGitActionProgress = makeWsPushSchema(
- WS_CHANNELS.gitActionProgress,
- GitActionProgressEvent,
-);
-export const WsPushTerminalEvent = makeWsPushSchema(WS_CHANNELS.terminalEvent, TerminalEvent);
-export const WsPushOrchestrationDomainEvent = makeWsPushSchema(
- ORCHESTRATION_WS_CHANNELS.domainEvent,
- OrchestrationEvent,
-);
-
-export const WsPushChannelSchema = Schema.Literals([
- WS_CHANNELS.gitActionProgress,
- WS_CHANNELS.serverWelcome,
- WS_CHANNELS.serverConfigUpdated,
- WS_CHANNELS.serverProvidersUpdated,
- WS_CHANNELS.terminalEvent,
- ORCHESTRATION_WS_CHANNELS.domainEvent,
-]);
-export type WsPushChannelSchema = typeof WsPushChannelSchema.Type;
-
-export const WsPush = Schema.Union([
- WsPushServerWelcome,
- WsPushServerConfigUpdated,
- WsPushServerProvidersUpdated,
- WsPushGitActionProgress,
- WsPushTerminalEvent,
- WsPushOrchestrationDomainEvent,
-]);
-export type WsPush = typeof WsPush.Type;
-
-export type WsPushMessage<C extends WsPushChannel> = Extract<WsPush, { channel: C }>;
-
-export const WsPushEnvelopeBase = Schema.Struct({
- type: Schema.Literal("push"),
- sequence: WsPushSequence,
- channel: WsPushChannelSchema,
- data: Schema.Unknown,
-});
-export type WsPushEnvelopeBase = typeof WsPushEnvelopeBase.Type;
-
-// ── Union of all server → client messages ─────────────────────────────
-
-export const WsResponse = Schema.Union([WebSocketResponse, WsPush]);
-export type WsResponse = typeof WsResponse.Type;