Auto-detect and surface spawned agent servers

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -40,6 +40,7 @@ import { ProviderSessionDirectoryLive } from "../src/provider/Layers/ProviderSes
 import { ServerSettingsService } from "../src/serverSettings.ts";
 import { makeProviderServiceLive } from "../src/provider/Layers/ProviderService.ts";
 import { makeCodexAdapter } from "../src/provider/Layers/CodexAdapter.ts";
+import { DetectedServersIngress } from "../src/detectedServers/Layers/DetectedServersIngress.ts";
 import {
   NoOpProviderEventLoggers,
   ProviderEventLoggers,
@@ -284,6 +285,12 @@ export const makeOrchestrationIntegrationHarness = (
       Layer.provideMerge(ServerConfig.layerTest(workspaceDir, rootDir)),
       Layer.provideMerge(NodeServices.layer),
       Layer.provideMerge(providerSessionDirectoryLayer),
+      Layer.provideMerge(
+        Layer.succeed(DetectedServersIngress, {
+          trackAgentCommand: () => Effect.succeed({ feed: () => {}, end: () => {} }),
+          trackPty: () => Effect.succeed({ feed: () => {}, feedCommand: () => {}, end: () => {} }),
+        }),
+      ),
     );
     const providerEventLoggersLayer = Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers);
     const providerLayer = useRealCodex

apps/server/integration/detectedServersCodex.integration.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "vitest";
+import { Effect, Layer, Duration } from "effect";
+import {
+  DetectedServerRegistryLive,
+  DetectedServerRegistry,
+} from "../src/detectedServers/Services/DetectedServerRegistry.ts";
+import { SocketProbeLive } from "../src/detectedServers/Layers/SocketProbeLive.ts";
+import { LivenessHeartbeatLive } from "../src/detectedServers/Layers/LivenessHeartbeat.ts";
+import {
+  DetectedServersIngress,
+  DetectedServersIngressLive,
+} from "../src/detectedServers/Layers/DetectedServersIngress.ts";
+
+describe("DetectedServers / Codex synthetic", () => {
+  it("transitions predicted → candidate on Vite-shaped outputDelta", async () => {
+    const depsLayer = Layer.mergeAll(
+      DetectedServerRegistryLive,
+      SocketProbeLive,
+      LivenessHeartbeatLive,
+    );
+    const testLayer = Layer.mergeAll(
+      depsLayer,
+      DetectedServersIngressLive.pipe(Layer.provide(depsLayer)),
+    );
+
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const ingress = yield* DetectedServersIngress;
+        const registry = yield* DetectedServerRegistry;
+        const tracker = yield* ingress.trackAgentCommand(
+          {
+            threadId: "thread-1",
+            turnId: "turn-1",
+            itemId: "item-1",
+            argv: ["vite"],
+            cwd: "/tmp",
+          },
+          "codex",
+          undefined,
+        );
+        tracker.feed("  ➜  Local:   http://localhost:5173/\n");
+        // Poll until the sniffer callback registers the candidate (bounded wait).
+        let current = yield* registry.getCurrent("thread-1");
+        for (let attempt = 0; attempt < 50 && current[0]?.status !== "candidate"; attempt += 1) {
+          yield* Effect.sleep(Duration.millis(50));
+          current = yield* registry.getCurrent("thread-1");
+        }
+        expect(current).toHaveLength(1);
+        expect(current[0]!.status).toBe("candidate");
+        expect(current[0]!.url).toBe("http://localhost:5173/");
+        expect(current[0]!.framework).toBe("vite");
+      }).pipe(Effect.provide(testLayer)),
+    );
+  });
+});

apps/server/integration/detectedServersPty.integration.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { Effect, Layer, Duration } from "effect";
+import { spawn } from "node:child_process";
+import {
+  DetectedServerRegistryLive,
+  DetectedServerRegistry,
+} from "../src/detectedServers/Services/DetectedServerRegistry.ts";
+import { SocketProbeLive } from "../src/detectedServers/Layers/SocketProbeLive.ts";
+import { LivenessHeartbeatLive } from "../src/detectedServers/Layers/LivenessHeartbeat.ts";
+import {
+  DetectedServersIngress,
+  DetectedServersIngressLive,
+} from "../src/detectedServers/Layers/DetectedServersIngress.ts";
+
+describe("DetectedServers / PTY real server", () => {
+  it.skipIf(process.platform === "win32")(
+    "transitions predicted → candidate → confirmed → live for a real Node http server",
+    async () => {
+      const child = spawn(
+        process.execPath,
+        [
+          "-e",
+          `const http = require("node:http"); const s = http.createServer((req, res) => res.end("ok")); s.listen(0, "127.0.0.1", () => { console.log("Server listening on port " + s.address().port); });`,
+        ],
+        { stdio: ["ignore", "pipe", "pipe"] },
+      );
+
+      try {
+        const depsLayer = Layer.mergeAll(
+          DetectedServerRegistryLive,
+          SocketProbeLive,
+          LivenessHeartbeatLive,
+        );
+        const testLayer = Layer.mergeAll(
+          depsLayer,
+          DetectedServersIngressLive.pipe(Layer.provide(depsLayer)),
+        );
+
+        await Effect.runPromise(
+          Effect.gen(function* () {
+            const ingress = yield* DetectedServersIngress;
+            const registry = yield* DetectedServerRegistry;
+
+            const tracker = yield* ingress.trackPty(
+              {
+                threadId: "thread-1",
+                terminalId: "terminal-1",
+                pid: child.pid!,
+                argv: ["npm", "run", "dev"],
+                cwd: "/tmp",
+              },
+              { scripts: { dev: "vite" } },
+            );
+
+            child.stdout!.on("data", (d: Buffer) => tracker.feed(d.toString("utf8")));
+
+            // Poll for live with timeout (up to ~15 seconds)
+            let server = null;
+            for (let i = 0; i < 150; i += 1) {
+              yield* Effect.sleep(Duration.millis(100));
+              const current = yield* registry.getCurrent("thread-1");
+              if (current[0]?.status === "live") {
+                server = current[0];
+                break;
+              }
+            }
+            expect(server).not.toBeNull();
+            expect(server!.status).toBe("live");
+            expect(server!.port).toBeGreaterThan(0);
+            expect(server!.terminalId).toBe("terminal-1");
+          }).pipe(Effect.provide(testLayer)),
+        );
+      } finally {
+        child.kill();
+      }
+    },
+    20_000,
+  );
+});

apps/server/package.json

@@ -34,6 +34,7 @@
     "effect": "catalog:",
     "node-pty": "^1.1.0",
     "open": "^10.1.0",
+    "pidtree": "^0.6.0",
     "sharp": "^0.34.5"
   },
   "devDependencies": {

apps/server/src/detectedServers/ArgvHinter.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import { hintFromArgv } from "./Layers/ArgvHinter.ts";
+
+describe("ArgvHinter.hintFromArgv", () => {
+  const cases: ReadonlyArray<{
+    name: string;
+    argv: string[];
+    expected: { framework: string; isLikelyServer: boolean };
+  }> = [
+    { name: "vite", argv: ["vite"], expected: { framework: "vite", isLikelyServer: true } },
+    {
+      name: "next dev",
+      argv: ["next", "dev"],
+      expected: { framework: "next", isLikelyServer: true },
+    },
+    {
+      name: "nuxt dev",
+      argv: ["nuxt", "dev"],
+      expected: { framework: "nuxt", isLikelyServer: true },
+    },
+    {
+      name: "astro dev",
+      argv: ["astro", "dev"],
+      expected: { framework: "astro", isLikelyServer: true },
+    },
+    {
+      name: "remix dev",
+      argv: ["remix", "dev"],
+      expected: { framework: "remix", isLikelyServer: true },
+    },
+    {
+      name: "wrangler dev",
+      argv: ["wrangler", "dev"],
+      expected: { framework: "wrangler", isLikelyServer: true },
+    },
+    {
+      name: "vitest --ui",
+      argv: ["vitest", "--ui"],
+      expected: { framework: "vitest-ui", isLikelyServer: true },
+    },
+    {
+      name: "storybook dev",
+      argv: ["storybook", "dev"],
+      expected: { framework: "storybook", isLikelyServer: true },
+    },
+    {
+      name: "vite build",
+      argv: ["vite", "build"],
+      expected: { framework: "vite", isLikelyServer: false },
+    },
+    {
+      name: "vitest run",
+      argv: ["vitest", "run"],
+      expected: { framework: "unknown", isLikelyServer: false },
+    },
+    { name: "tsc", argv: ["tsc"], expected: { framework: "unknown", isLikelyServer: false } },
+    { name: "eslint", argv: ["eslint"], expected: { framework: "unknown", isLikelyServer: false } },
+    {
+      name: "unknown serve",
+      argv: ["foo", "serve"],
+      expected: { framework: "unknown", isLikelyServer: true },
+    },
+  ];
+
+  for (const c of cases) {
+    it(`hints ${c.name}`, () => {
+      const got = hintFromArgv(c.argv, undefined);
+      expect(got).toEqual(c.expected);
+    });
+  }
+
+  it("re-scans package.json scripts.dev for indirect invocations", () => {
+    const got = hintFromArgv(["npm", "run", "dev"], { scripts: { dev: "vite" } });
+    expect(got).toEqual({ framework: "vite", isLikelyServer: true });
+  });
+
+  it("treats npm run build as build, not server", () => {
+    const got = hintFromArgv(["npm", "run", "build"], { scripts: { build: "vite build" } });
+    expect(got).toEqual({ framework: "vite", isLikelyServer: false });
+  });
+
+  // Regression tests: prefix-match false positives
+  it("does NOT match next for a binary named snextflix", () => {
+    const got = hintFromArgv(["snextflix"], undefined);
+    expect(got).toEqual({ framework: "unknown", isLikelyServer: false });
+  });
+
+  it("does NOT match remix for a binary named myremix", () => {
+    const got = hintFromArgv(["myremix"], undefined);
+    expect(got).toEqual({ framework: "unknown", isLikelyServer: false });
+  });
+
+  it("matches vite when invoked via a full node_modules path", () => {
+    const got = hintFromArgv(["./node_modules/.bin/vite"], undefined);
+    expect(got).toEqual({ framework: "vite", isLikelyServer: true });
+  });
+});