@tonyclaw/agent-inspector 3.0.44 → 3.0.45

package/src/proxy/runtimeShutdown.ts

@@ -1,10 +1,19 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import {
+  parseManagedInstanceShutdownMessage,
+  readManagedInstanceLaunch,
+} from "../lib/managedInstance";
 import { closeLogFinalizerWorkers, forceCloseLogFinalizerWorkers } from "./logFinalizer";
 import { flushIndex } from "./logIndex";
 import { flushApplicationLog, flushLogBuffer } from "./logger";
 import { flushAllRawStreamCaptures } from "./rawStreamCapture";
 import { setRuntimeShuttingDown } from "./runtimeHealth";
 import { stopRuntimeAdmission, waitForRuntimeTrafficDrain } from "./runtimeAdmission";
-import { createShutdownCoordinator, createShutdownSignalHandler } from "./shutdownCoordinator";
+import {
+  createShutdownCoordinator,
+  createShutdownSignalHandler,
+  type ShutdownResult,
+} from "./shutdownCoordinator";
 import { destroyAllSessionProcesses } from "./sessionProcess";
 import { flushSessionTasks } from "./sessionRuntime";
 import { closeSqliteLogIndex } from "./sqliteLogIndex";
@@ -62,9 +71,72 @@ const runtimeShutdownCoordinator = createShutdownCoordinator(
 );
 
 let signalHandlersInstalled = false;
+let managedInstanceHandlersInstalled = false;
+
+export type ManagedRuntimeShutdownController = {
+  handleDisconnect: () => void;
+  handleMessage: (message: unknown) => void;
+};
+
+type ManagedRuntimeShutdownControllerOptions = {
+  controlToken: string;
+  shutdown: () => Promise<ShutdownResult>;
+  exit: (code: number) => void;
+};
+
+function managedControlTokensMatch(received: string, expected: string): boolean {
+  if (received.length === 0 || expected.length === 0) return false;
+  const receivedDigest = createHash("sha256").update(received).digest();
+  const expectedDigest = createHash("sha256").update(expected).digest();
+  return timingSafeEqual(receivedDigest, expectedDigest);
+}
+
+export function createManagedRuntimeShutdownController(
+  options: ManagedRuntimeShutdownControllerOptions,
+): ManagedRuntimeShutdownController {
+  let shutdownRequested = false;
+  const requestShutdown = (): void => {
+    if (shutdownRequested) return;
+    shutdownRequested = true;
+    void options.shutdown().then(
+      (result) => options.exit(result.forced ? 1 : 0),
+      () => options.exit(1),
+    );
+  };
+  return {
+    handleDisconnect: requestShutdown,
+    handleMessage: (message) => {
+      const parsed = parseManagedInstanceShutdownMessage(message);
+      if (
+        parsed === null ||
+        !managedControlTokensMatch(parsed.controlToken, options.controlToken)
+      ) {
+        return;
+      }
+      requestShutdown();
+    },
+  };
+}
+
+/** Install lifecycle cleanup for the private supervisor/runtime IPC channel. */
+export function installRuntimeManagedInstanceShutdownHandlers(): void {
+  if (managedInstanceHandlersInstalled) return;
+  const launchResult = readManagedInstanceLaunch(process.env);
+  if (launchResult.kind !== "managed") return;
+  managedInstanceHandlersInstalled = true;
+  const controller = createManagedRuntimeShutdownController({
+    controlToken: launchResult.launch.controlToken,
+    shutdown: async () => await runtimeShutdownCoordinator.shutdown("manual"),
+    exit: (code) => process.exit(code),
+  });
+  process.on("message", controller.handleMessage);
+  process.once("disconnect", controller.handleDisconnect);
+  if (process.connected === false) process.nextTick(controller.handleDisconnect);
+}
 
 /** Install once in the server runtime; the CLI supervisor owns its own public-ingress signals. */
 export function installRuntimeShutdownSignalHandlers(): void {
+  installRuntimeManagedInstanceShutdownHandlers();
   if (signalHandlersInstalled) return;
   signalHandlersInstalled = true;
   const handleSignal = createShutdownSignalHandler(runtimeShutdownCoordinator, (result) => {

package/src/proxy/sessionInfo.ts

@@ -1,5 +1,6 @@
 import type { SessionInfo, SessionLogSummary, SessionTokenUsage } from "../lib/sessionInfoContract";
-import { getConfiguredBasePath, withBasePath } from "../lib/basePath";
+import { withBasePath } from "../lib/basePath";
+import { getPublicBasePath } from "../lib/publicBasePathContext";
 import { getSessionPath } from "../lib/sessionUrl";
 import type { CapturedLog } from "./schemas";
 import type { SessionSnapshot } from "./sessionSupervisor";
@@ -106,14 +107,14 @@ function buildAbsoluteUrl(baseUrl: string, path: string): string {
 
 function buildApiPath(sessionId: string): string {
   return buildRelativePath(
-    withBasePath("/api/sessions", getConfiguredBasePath(process.env)),
+    withBasePath("/api/sessions", getPublicBasePath()),
     new URLSearchParams({ sessionId }),
   );
 }
 
 function buildCompactLogsPath(sessionId: string): string {
   return buildRelativePath(
-    withBasePath("/api/logs", getConfiguredBasePath(process.env)),
+    withBasePath("/api/logs", getPublicBasePath()),
     new URLSearchParams({ compact: "1", sessionId }),
   );
 }
@@ -211,7 +212,7 @@ export function buildSessionInfo(input: BuildSessionInfoInput): SessionInfo {
   const queuedTasks = input.snapshot?.queuedTasks ?? 0;
   const runningTasks = input.snapshot?.runningTasks ?? 0;
   const lastTaskError = normalizeString(input.snapshot?.lastTaskError);
-  const inspectorPath = getSessionPath(input.sessionId, getConfiguredBasePath(process.env));
+  const inspectorPath = getSessionPath(input.sessionId, getPublicBasePath());
   const apiPath = buildApiPath(input.sessionId);
   const compactLogsPath = buildCompactLogsPath(input.sessionId);
   const latestLogs = summaries.slice(0, latestLogLimit).map((summary, index) => ({

package/src/routes/api/-instances.ts

@@ -0,0 +1,109 @@
+import { type z } from "zod";
+import type { InstanceLifecycleError, InstanceLifecycleResult } from "../../cli/instance";
+import {
+  type InstancePublicErrorCode,
+  INSTANCE_API_SCHEMA_VERSION,
+  instanceErrorOutput,
+} from "../../lib/instanceContract";
+import { readManagedInstanceLaunch } from "../../lib/managedInstance";
+
+const NO_STORE_HEADERS = { "cache-control": "no-store" };
+
+type ParsedBody<T> = { ok: true; value: T } | { ok: false; response: Response };
+
+function errorStatus(code: InstancePublicErrorCode): number {
+  switch (code) {
+    case "argument_invalid":
+    case "data_dir_invalid":
+    case "name_invalid":
+    case "port_invalid":
+    case "record_invalid":
+      return 400;
+    case "instance_not_found":
+      return 404;
+    case "config_mismatch":
+    case "data_dir_conflict":
+    case "identity_mismatch":
+    case "port_conflict":
+    case "self_lifecycle_unsupported":
+      return 409;
+    case "lock_not_owned":
+    case "lock_timeout":
+      return 423;
+    case "launch_failed":
+    case "launch_unavailable":
+    case "port_exhausted":
+    case "registry_io":
+    case "restart_failed_degraded":
+    case "restart_failed_rolled_back":
+    case "shutdown_failed":
+      return 503;
+  }
+}
+
+export function instanceErrorResponse(error: InstanceLifecycleError): Response {
+  return Response.json(instanceErrorOutput(error), {
+    status: errorStatus(error.code),
+    headers: NO_STORE_HEADERS,
+  });
+}
+
+export function instanceResultResponse<T>(
+  result: InstanceLifecycleResult<T>,
+  successStatus = 200,
+): Response {
+  return result.kind === "error"
+    ? instanceErrorResponse(result.error)
+    : Response.json(result.value, { status: successStatus, headers: NO_STORE_HEADERS });
+}
+
+export async function parseInstanceBody<T extends z.ZodType>(
+  request: Request,
+  schema: T,
+): Promise<ParsedBody<z.output<T>>> {
+  let value: unknown;
+  try {
+    const text = await request.text();
+    value = text.trim().length === 0 ? {} : JSON.parse(text);
+  } catch {
+    return {
+      ok: false,
+      response: instanceErrorResponse({
+        code: "argument_invalid",
+        message: "Request body must be valid JSON.",
+        retryable: false,
+      }),
+    };
+  }
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      response: instanceErrorResponse({
+        code: "argument_invalid",
+        message: `Invalid instance request: ${parsed.error.issues[0]?.message ?? "invalid body"}`,
+        retryable: false,
+      }),
+    };
+  }
+  return { ok: true, value: parsed.data };
+}
+
+export function selfLifecycleError(rawName: string): InstanceLifecycleError | null {
+  const current = readManagedInstanceLaunch(process.env);
+  return current.kind === "managed" && current.launch.name.toLowerCase() === rawName.toLowerCase()
+    ? {
+        code: "self_lifecycle_unsupported",
+        message:
+          "A managed runtime cannot stop or restart itself through its own REST/MCP transport; use the CLI or a different controller instance.",
+        retryable: false,
+      }
+    : null;
+}
+
+export function instanceListResponse(instances: readonly unknown[]): Response {
+  return Response.json(
+    { schemaVersion: INSTANCE_API_SCHEMA_VERSION, instances },
+    { headers: NO_STORE_HEADERS },
+  );
+}

package/src/routes/api/instances.$name.connection.ts

@@ -0,0 +1,12 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { getNamedInstanceConnection } from "../../cli/instance";
+import { instanceResultResponse } from "./-instances";
+
+export const Route = createFileRoute("/api/instances/$name/connection")({
+  server: {
+    handlers: {
+      GET: async ({ params }: { params: { name: string } }) =>
+        instanceResultResponse(await getNamedInstanceConnection(params.name)),
+    },
+  },
+});

package/src/routes/api/instances.$name.restart.ts

@@ -0,0 +1,23 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { restartNamedInstance } from "../../cli/instance";
+import { InstanceStartRequestSchema } from "../../lib/instanceContract";
+import {
+  instanceErrorResponse,
+  instanceResultResponse,
+  parseInstanceBody,
+  selfLifecycleError,
+} from "./-instances";
+
+export const Route = createFileRoute("/api/instances/$name/restart")({
+  server: {
+    handlers: {
+      POST: async ({ params, request }: { params: { name: string }; request: Request }) => {
+        const body = await parseInstanceBody(request, InstanceStartRequestSchema);
+        if (!body.ok) return body.response;
+        const selfError = selfLifecycleError(params.name);
+        if (selfError !== null) return instanceErrorResponse(selfError);
+        return instanceResultResponse(await restartNamedInstance(params.name, body.value));
+      },
+    },
+  },
+});

package/src/routes/api/instances.$name.start.ts

@@ -0,0 +1,18 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { startNamedInstance } from "../../cli/instance";
+import { InstanceStartRequestSchema } from "../../lib/instanceContract";
+import { instanceResultResponse, parseInstanceBody } from "./-instances";
+
+export const Route = createFileRoute("/api/instances/$name/start")({
+  server: {
+    handlers: {
+      POST: async ({ params, request }: { params: { name: string }; request: Request }) => {
+        const body = await parseInstanceBody(request, InstanceStartRequestSchema);
+        if (!body.ok) return body.response;
+        const result = await startNamedInstance(params.name, body.value);
+        const status = result.kind === "success" && result.value.outcome === "created" ? 201 : 200;
+        return instanceResultResponse(result, status);
+      },
+    },
+  },
+});

package/src/routes/api/instances.$name.stop.ts

@@ -0,0 +1,23 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { stopNamedInstance } from "../../cli/instance";
+import { InstanceEmptyRequestSchema } from "../../lib/instanceContract";
+import {
+  instanceErrorResponse,
+  instanceResultResponse,
+  parseInstanceBody,
+  selfLifecycleError,
+} from "./-instances";
+
+export const Route = createFileRoute("/api/instances/$name/stop")({
+  server: {
+    handlers: {
+      POST: async ({ params, request }: { params: { name: string }; request: Request }) => {
+        const body = await parseInstanceBody(request, InstanceEmptyRequestSchema);
+        if (!body.ok) return body.response;
+        const selfError = selfLifecycleError(params.name);
+        if (selfError !== null) return instanceErrorResponse(selfError);
+        return instanceResultResponse(await stopNamedInstance(params.name));
+      },
+    },
+  },
+});

package/src/routes/api/instances.$name.ts

@@ -0,0 +1,12 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { getNamedInstance } from "../../cli/instance";
+import { instanceResultResponse } from "./-instances";
+
+export const Route = createFileRoute("/api/instances/$name")({
+  server: {
+    handlers: {
+      GET: async ({ params }: { params: { name: string } }) =>
+        instanceResultResponse(await getNamedInstance(params.name)),
+    },
+  },
+});

package/src/routes/api/instances.ts

@@ -0,0 +1,16 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { listNamedInstances } from "../../cli/instance";
+import { instanceListResponse, instanceResultResponse } from "./-instances";
+
+export const Route = createFileRoute("/api/instances")({
+  server: {
+    handlers: {
+      GET: async () => {
+        const result = await listNamedInstances();
+        return result.kind === "error"
+          ? instanceResultResponse(result)
+          : instanceListResponse(result.value);
+      },
+    },
+  },
+});

package/src/start.ts

@@ -0,0 +1,10 @@
+import { createMiddleware, createStart } from "@tanstack/react-start";
+
+const publicBasePathMiddleware = createMiddleware().server(async ({ next, request }) => {
+  const { runWithRequestPublicBasePath } = await import("./lib/publicBasePathContext");
+  return runWithRequestPublicBasePath(request, () => next());
+});
+
+export const startInstance = createStart(() => ({
+  requestMiddleware: [publicBasePathMiddleware],
+}));

package/.output/server/_ssr/start-HYkvq4Ni.mjs

@@ -1,4 +0,0 @@
-const startInstance = void 0;
-export {
-  startInstance
-};

package/.output/server/_tanstack-start-manifest_v-B2chR8ef.mjs

@@ -1,4 +0,0 @@
-const tsrStartManifest = () => ({ routes: { __root__: { filePath: "C:/Users/claw/workspace/agent-inspector/src/routes/__root.tsx", children: ["/", "/livez", "/readyz", "/api/alerts", "/api/config", "/api/groups", "/api/health", "/api/logs", "/api/mcp", "/api/models", "/api/pi-agent", "/api/providers", "/api/runs", "/api/sessions", "/proxy/$", "/session/$sessionId", "/api/ecosystem/packages", "/api/ecosystem/tasks", "/api/knowledge/candidates", "/api/knowledge/project-context", "/api/knowledge/search", "/api/ecosystem/recipes/$recipeId/run", "/api/knowledge/sessions/$sessionId/candidates"], preloads: ["/assets/index-C6qZwYlR.js"], scripts: [{ attrs: { type: "module", async: true, src: "/assets/index-C6qZwYlR.js" } }] }, "/": { filePath: "C:/Users/claw/workspace/agent-inspector/src/routes/index.tsx", children: void 0, preloads: ["/assets/index-B2eoeT-Z.js", "/assets/index-CX7_rf7o.js", "/assets/ProxyViewerContainer-BhpIgfBi.js"] }, "/session/$sessionId": { filePath: "C:/Users/claw/workspace/agent-inspector/src/routes/session/$sessionId.tsx", children: void 0, preloads: ["/assets/_sessionId-CDhRgzf6.js", "/assets/_sessionId-mw3aA8Bp.js", "/assets/ProxyViewerContainer-BhpIgfBi.js"] } } });
-export {
-  tsrStartManifest
-};