Add ACP Registry installer and settings page

Bundles a snapshot of the Agent Client Protocol registry and exposes a
Zed-style installer at Settings → ACP Registry. Users can browse,
search, install, and remove 31 ACP-conforming coding agents (everything
upstream except the four overlapping with first-party drivers:
claude-acp, cursor, opencode, codex-acp).

- Bundled snapshot in packages/contracts/src/registry/ refreshed by a
  new bun run sync:acp-registry script.
- Installer in apps/server/src/acpRegistry/ supports binary (download +
  extract + chmod), npx (bunx), and uvx distribution channels with
  per-platform target resolution.
- Install state persists to ServerSettings.acpRegistryInstalls; cache
  lives under <baseDir>/acp-agents/<id>/<version>/.
- Three new RPC methods (acpRegistry.list/install/uninstall) wired
  through WsRpcGroup, LocalApi, and WsRpcClient.
- See docs/providers/acp-registry.md for the user-facing guide.

The generic ACP adapter that would let installed agents appear in the
chat provider picker is intentionally a follow-up — the installer and
UI scaffolding land first so that adapter can layer on top without
further protocol/UI changes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: LivioGama

AGENTS.md

@@ -45,6 +45,16 @@ Docs:
 
 - Codex App Server docs: https://developers.openai.com/codex/sdk/#app-server
 
+## ACP Registry
+
+In addition to the four bespoke providers (Codex, Claude, Cursor, OpenCode),
+T3 Code bundles a snapshot of the
+[Agent Client Protocol registry](https://agentclientprotocol.com/get-started/registry)
+and exposes a Zed-style installer at **Settings → ACP Registry**. See
+[docs/providers/acp-registry.md](./docs/providers/acp-registry.md) for the
+install pipeline, distribution channels, and how to refresh the bundled
+snapshot (`bun run sync:acp-registry`).
+
 ## Reference Repos
 
 - Open-source Codex repo: https://github.com/openai/codex

apps/server/src/acpRegistry/AcpRegistryService.ts

@@ -0,0 +1,171 @@
+/**
+ * AcpRegistryService — Effect service exposing install/uninstall/list
+ * operations for the bundled ACP registry. RPC handlers (see `ws.ts`) call
+ * into this; the underlying logic lives in the framework-agnostic
+ * `installer.ts` module.
+ *
+ * The service is responsible for:
+ *   - Listing each bundled entry with rolled-up install status for the UI.
+ *   - Driving install/uninstall, including settings persistence via the
+ *     `ServerSettingsService`.
+ *
+ * @module acpRegistry/AcpRegistryService
+ */
+import {
+  ACP_REGISTRY,
+  acpRegistryEntryById,
+  type AcpRegistryEntry,
+  type AcpRegistryEntryWithStatus,
+  type AcpRegistryInstallState,
+  type AcpRegistryInstallStatus,
+  AcpRegistryError,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { ServerConfig } from "../config.ts";
+import { ServerSettingsService } from "../serverSettings.ts";
+
+import { availableChannels, installAgent, uninstallAgent } from "./installer.ts";
+import { resolveCurrentPlatform } from "./platform.ts";
+
+export interface AcpRegistryServiceShape {
+  readonly list: () => Effect.Effect<ReadonlyArray<AcpRegistryEntryWithStatus>, AcpRegistryError>;
+  readonly install: (agentId: string) => Effect.Effect<AcpRegistryInstallState, AcpRegistryError>;
+  readonly uninstall: (agentId: string) => Effect.Effect<void, AcpRegistryError>;
+}
+
+function rollupStatus(
+  entry: AcpRegistryEntry,
+  installed: AcpRegistryInstallState | undefined,
+  channels: ReadonlyArray<ReturnType<typeof availableChannels>[number]>,
+): AcpRegistryInstallStatus {
+  if (channels.length === 0) return "unsupported";
+  if (!installed) return "not_installed";
+  if (installed.version !== entry.version) return "update_available";
+  return "installed";
+}
+
+export class AcpRegistryService extends Context.Service<
+  AcpRegistryService,
+  AcpRegistryServiceShape
+>()("t3/acpRegistry/AcpRegistryService") {}
+
+export const layer: Layer.Layer<AcpRegistryService, never, ServerConfig | ServerSettingsService> =
+  Layer.effect(
+    AcpRegistryService,
+    Effect.gen(function* () {
+      const config = yield* ServerConfig;
+      const settingsService = yield* ServerSettingsService;
+      const platform = resolveCurrentPlatform();
+      const cacheRoot = config.acpRegistryCacheDir;
+
+      const readInstalls = (): Effect.Effect<
+        Readonly<Record<string, AcpRegistryInstallState>>,
+        AcpRegistryError
+      > =>
+        settingsService.getSettings.pipe(
+          Effect.map((s) => s.acpRegistryInstalls),
+          Effect.mapError(
+            (cause) =>
+              new AcpRegistryError({
+                detail: "Failed to read server settings",
+                cause,
+              }),
+          ),
+        );
+
+      const writeInstalls = (
+        next: Readonly<Record<string, AcpRegistryInstallState>>,
+      ): Effect.Effect<void, AcpRegistryError> =>
+        settingsService.updateSettings({ acpRegistryInstalls: next }).pipe(
+          Effect.asVoid,
+          Effect.mapError(
+            (cause) =>
+              new AcpRegistryError({
+                detail: "Failed to persist server settings",
+                cause,
+              }),
+          ),
+        );
+
+      const service: AcpRegistryServiceShape = {
+        list: () =>
+          Effect.gen(function* () {
+            const installs = yield* readInstalls();
+            return ACP_REGISTRY.map((entry) => {
+              const channels = availableChannels(entry, platform);
+              const installed = installs[entry.id];
+              return {
+                entry,
+                availableChannels: channels,
+                status: rollupStatus(entry, installed, channels),
+                ...(installed ? { installed } : {}),
+              } satisfies AcpRegistryEntryWithStatus;
+            });
+          }),
+
+        install: (agentId) =>
+          Effect.gen(function* () {
+            const entry = acpRegistryEntryById(agentId);
+            if (!entry) {
+              return yield* new AcpRegistryError({
+                agentId,
+                detail: "Unknown ACP registry agent.",
+              });
+            }
+            const result = yield* Effect.tryPromise({
+              try: () => installAgent(entry, { cacheRoot }),
+              catch: (cause) => {
+                if (
+                  cause &&
+                  typeof cause === "object" &&
+                  "_tag" in cause &&
+                  cause._tag === "AcpRegistryError"
+                ) {
+                  return cause as AcpRegistryError;
+                }
+                return new AcpRegistryError({
+                  agentId,
+                  detail:
+                    cause instanceof Error ? cause.message : `Install failed: ${String(cause)}`,
+                  cause,
+                });
+              },
+            });
+            const installs = yield* readInstalls();
+            yield* writeInstalls({ ...installs, [agentId]: result.state });
+            return result.state;
+          }),
+
+        uninstall: (agentId) =>
+          Effect.gen(function* () {
+            const entry = acpRegistryEntryById(agentId);
+            if (!entry) {
+              return yield* new AcpRegistryError({
+                agentId,
+                detail: "Unknown ACP registry agent.",
+              });
+            }
+            yield* Effect.tryPromise({
+              try: () => uninstallAgent(entry, cacheRoot),
+              catch: (cause) =>
+                new AcpRegistryError({
+                  agentId,
+                  detail:
+                    cause instanceof Error ? cause.message : `Uninstall failed: ${String(cause)}`,
+                  cause,
+                }),
+            });
+            const installs = yield* readInstalls();
+            if (agentId in installs) {
+              const { [agentId]: _removed, ...rest } = installs;
+              yield* writeInstalls(rest);
+            }
+          }),
+      };
+
+      return service;
+    }),
+  );