@tonyclaw/agent-inspector 3.1.32 → 4.0.2

package/src/cli/onboardTarget.ts

@@ -1,228 +0,0 @@
-import { appendBasePathToOrigin, getConfiguredBasePath } from "../lib/basePath.js";
-import { normalizeBrowserRuntimeBaseUrl } from "../lib/browserRuntimeContract.js";
-import { getInstancesRoot, readInstanceRecord, validateInstanceName } from "./instanceRegistry.js";
-import { urlForHost } from "./networkHints.js";
-
-const DEFAULT_PORT = 9527;
-const DEFAULT_ORIGIN = `http://localhost:${String(DEFAULT_PORT)}`;
-const AGENT_INSPECTOR_PUBLIC_ORIGIN_ENV = "AGENT_INSPECTOR_PUBLIC_ORIGIN";
-const MCP_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
-
-type OnboardTargetEnv = Readonly<Record<string, string | undefined>>;
-
-export type OnboardTargetKind = "default" | "instance" | "base-url";
-
-export type OnboardTarget = {
-  kind: OnboardTargetKind;
-  instanceName: string | null;
-  mcpName: string;
-  port: number;
-  uiUrl: string | null;
-  controlBaseUrl: string;
-  agentBaseUrl: string;
-  /** @deprecated Compatibility alias for controlBaseUrl. */
-  baseUrl: string;
-  apiUrl: string;
-  healthUrl: string;
-  anthropicProxyUrl: string;
-  openAiProxyUrl: string;
-  mcpUrl: string;
-};
-
-export type OnboardTargetOptions = {
-  instanceName: string | null;
-  baseUrl: string | null;
-  controlBaseUrl?: string | null;
-  agentBaseUrl?: string | null;
-  uiUrl?: string | null;
-  mcpName: string | null;
-};
-
-export type OnboardTargetResult =
-  | { ok: true; target: OnboardTarget }
-  | { ok: false; message: string };
-
-function targetFromSurfaces(
-  kind: OnboardTargetKind,
-  instanceName: string | null,
-  mcpName: string,
-  port: number,
-  controlBaseUrl: string,
-  agentBaseUrl: string,
-  uiUrl: string | null,
-): OnboardTarget {
-  return {
-    kind,
-    instanceName,
-    mcpName,
-    port,
-    uiUrl,
-    controlBaseUrl,
-    agentBaseUrl,
-    baseUrl: controlBaseUrl,
-    apiUrl: `${controlBaseUrl}/api`,
-    healthUrl: `${controlBaseUrl}/api/health`,
-    anthropicProxyUrl: `${agentBaseUrl}/proxy`,
-    openAiProxyUrl: `${agentBaseUrl}/proxy/v1`,
-    mcpUrl: `${agentBaseUrl}/api/mcp`,
-  };
-}
-
-function validateMcpName(rawName: string): string | null {
-  const name = rawName.trim();
-  return name === rawName && MCP_NAME_PATTERN.test(name) ? name : null;
-}
-
-function normalizeExplicitBaseUrl(rawBaseUrl: string): { baseUrl: string; port: number } | null {
-  const baseUrl = normalizeBrowserRuntimeBaseUrl(rawBaseUrl);
-  if (baseUrl === null) return null;
-  try {
-    const parsed = new URL(baseUrl);
-    const defaultPort = parsed.protocol === "https:" ? 443 : 80;
-    const port = parsed.port === "" ? defaultPort : Number(parsed.port);
-    return Number.isInteger(port) && port >= 1 && port <= 65_535 ? { baseUrl, port } : null;
-  } catch {
-    return null;
-  }
-}
-
-function normalizePublicOrigin(rawOrigin: string): string | null {
-  if (rawOrigin.trim() !== rawOrigin) return null;
-  try {
-    const parsed = new URL(rawOrigin);
-    if (
-      (parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
-      parsed.username.length > 0 ||
-      parsed.password.length > 0 ||
-      parsed.pathname !== "/" ||
-      parsed.search.length > 0 ||
-      parsed.hash.length > 0
-    ) {
-      return null;
-    }
-    return parsed.origin;
-  } catch {
-    return null;
-  }
-}
-
-export function resolveOnboardTarget(
-  options: OnboardTargetOptions,
-  env: OnboardTargetEnv = process.env,
-): OnboardTargetResult {
-  const hasExplicitSurface =
-    options.baseUrl !== null ||
-    (options.controlBaseUrl !== null && options.controlBaseUrl !== undefined) ||
-    (options.agentBaseUrl !== null && options.agentBaseUrl !== undefined) ||
-    options.uiUrl !== undefined;
-  if (options.instanceName !== null && hasExplicitSurface) {
-    return {
-      ok: false,
-      message:
-        "--instance and explicit --base-url/--control-base-url/--agent-base-url/--ui-url options are mutually exclusive",
-    };
-  }
-
-  const explicitMcpName = options.mcpName === null ? null : validateMcpName(options.mcpName);
-  if (options.mcpName !== null && explicitMcpName === null) {
-    return {
-      ok: false,
-      message:
-        "--mcp-name must be 1-128 letters, digits, dots, hyphens, or underscores and start with a letter or digit",
-    };
-  }
-
-  if (hasExplicitSurface) {
-    const sharedRaw = options.baseUrl;
-    const controlRaw = options.controlBaseUrl ?? sharedRaw ?? options.agentBaseUrl;
-    const agentRaw = options.agentBaseUrl ?? sharedRaw ?? options.controlBaseUrl;
-    const control =
-      controlRaw === null || controlRaw === undefined ? null : normalizeExplicitBaseUrl(controlRaw);
-    const agent =
-      agentRaw === null || agentRaw === undefined ? null : normalizeExplicitBaseUrl(agentRaw);
-    const ui =
-      options.uiUrl === undefined || options.uiUrl === null
-        ? null
-        : normalizeExplicitBaseUrl(options.uiUrl);
-    if (
-      control === null ||
-      agent === null ||
-      (options.uiUrl !== undefined && options.uiUrl !== null && ui === null)
-    ) {
-      return {
-        ok: false,
-        message:
-          "Explicit UI, control, and agent Base URLs must be credential-free HTTP(S) URLs without a query or fragment",
-      };
-    }
-    return {
-      ok: true,
-      target: targetFromSurfaces(
-        "base-url",
-        null,
-        explicitMcpName ?? "agent-inspector",
-        control.port,
-        control.baseUrl,
-        agent.baseUrl,
-        ui?.baseUrl ?? null,
-      ),
-    };
-  }
-
-  if (options.instanceName !== null) {
-    const validatedName = validateInstanceName(options.instanceName);
-    if (validatedName.kind === "error") {
-      return { ok: false, message: validatedName.error.message };
-    }
-    const record = readInstanceRecord(getInstancesRoot(env), validatedName.value);
-    if (record.kind === "error") {
-      return { ok: false, message: record.error.message };
-    }
-    if (record.value === null) {
-      return {
-        ok: false,
-        message: `Named instance ${validatedName.value} does not exist`,
-      };
-    }
-    const origin = urlForHost(record.value.publicPort, record.value.host);
-    const baseUrl = appendBasePathToOrigin(origin, "/", record.value.basePath);
-    return {
-      ok: true,
-      target: targetFromSurfaces(
-        "instance",
-        record.value.name,
-        explicitMcpName ?? `agent-inspector-${record.value.name}`,
-        record.value.publicPort,
-        baseUrl,
-        baseUrl,
-        record.value.uiEnabled ? baseUrl : null,
-      ),
-    };
-  }
-
-  const configuredPublicOrigin = env[AGENT_INSPECTOR_PUBLIC_ORIGIN_ENV];
-  const publicOrigin =
-    configuredPublicOrigin === undefined
-      ? DEFAULT_ORIGIN
-      : normalizePublicOrigin(configuredPublicOrigin);
-  if (publicOrigin === null) {
-    return {
-      ok: false,
-      message:
-        "AGENT_INSPECTOR_PUBLIC_ORIGIN must be an exact credential-free HTTP(S) origin without a path, query, or fragment",
-    };
-  }
-  const baseUrl = appendBasePathToOrigin(publicOrigin, "/", getConfiguredBasePath(env));
-  return {
-    ok: true,
-    target: targetFromSurfaces(
-      "default",
-      null,
-      explicitMcpName ?? "agent-inspector",
-      DEFAULT_PORT,
-      baseUrl,
-      baseUrl,
-      env["AGENT_INSPECTOR_BACKEND_ONLY"] === "1" ? null : baseUrl,
-    ),
-  };
-}

package/src/cli/rustBackendPackage.ts

@@ -1,458 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { Buffer } from "node:buffer";
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { z } from "zod";
-
-export const RUST_BACKEND_IDENTITY_FLAG = "--agent-inspector-package-identity";
-export const RUST_BACKEND_CLI_PROTOCOL = "agent-inspector-cli-backend-v1";
-export const RUST_BACKEND_IDENTITY_TIMEOUT_MS = 2_000;
-
-export type RustBackendLibc = "glibc" | "musl" | "unknown" | "not-applicable";
-
-export type RustBackendTarget = {
-  packageName: string;
-  target: string;
-  binary: string;
-  os: "win32" | "linux" | "darwin";
-  cpu: "x64" | "arm64";
-  libc: "glibc" | null;
-};
-
-export type RustBackendPackageErrorCode =
-  | "binary_invalid"
-  | "binary_missing"
-  | "hash_mismatch"
-  | "identity_failed"
-  | "identity_mismatch"
-  | "manifest_invalid"
-  | "package_invalid"
-  | "package_missing"
-  | "target_mismatch"
-  | "unsupported_platform"
-  | "version_mismatch";
-
-export type RustBackendPackageError = {
-  code: RustBackendPackageErrorCode;
-  message: string;
-};
-
-export type RustBackendPackageResolution =
-  | {
-      kind: "success";
-      value: {
-        command: string;
-        args: readonly string[];
-        packageName: string;
-        packageVersion: string;
-        target: string;
-        sha256: string;
-      };
-    }
-  | { kind: "error"; error: RustBackendPackageError };
-
-export type RustBackendTargetResolution =
-  | { kind: "success"; value: RustBackendTarget }
-  | { kind: "error"; error: RustBackendPackageError };
-
-export type PreferredBackendImplementation = "typescript" | "rust";
-
-const RustBackendIdentitySchema = z
-  .object({
-    schemaVersion: z.literal(1),
-    name: z.literal("agent-inspector-backend"),
-    packageVersion: z.string().min(1),
-    target: z.string().min(1),
-    binary: z.string().min(1),
-    cliProtocol: z.literal(RUST_BACKEND_CLI_PROTOCOL),
-    productionReady: z.literal(true),
-    capabilities: z
-      .object({
-        nodeProtectedIngress: z.literal(true),
-        basePath: z.literal(true),
-        namedInstances: z.literal(true),
-        gracefulShutdown: z.literal(true),
-      })
-      .strict(),
-  })
-  .strict();
-
-export type RustBackendIdentity = z.infer<typeof RustBackendIdentitySchema>;
-
-const RustBackendPackageJsonSchema = z
-  .object({
-    name: z.string().min(1),
-    version: z.string().min(1),
-    os: z.array(z.string()).min(1),
-    cpu: z.array(z.string()).min(1),
-    libc: z.array(z.string()).optional(),
-    agentInspectorRustBackend: z
-      .object({
-        schemaVersion: z.literal(1),
-        target: z.string().min(1),
-        binary: z.string().min(1),
-        manifest: z.string().min(1),
-        identityFlag: z.literal(RUST_BACKEND_IDENTITY_FLAG),
-        cliProtocol: z.literal(RUST_BACKEND_CLI_PROTOCOL),
-      })
-      .strict(),
-  })
-  .passthrough();
-
-const RustBackendBinaryManifestSchema = z
-  .object({
-    schemaVersion: z.literal(1),
-    packageName: z.string().min(1),
-    packageVersion: z.string().min(1),
-    target: z.string().min(1),
-    binary: z.string().min(1),
-    sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-    identity: RustBackendIdentitySchema,
-  })
-  .strict();
-
-type IdentityProbeResult =
-  | { kind: "success"; value: RustBackendIdentity }
-  | { kind: "error"; message: string };
-
-export type ResolveRustBackendPackageOptions = {
-  rootVersion: string;
-  platform?: string;
-  arch?: string;
-  libc?: RustBackendLibc;
-  resolvePackageJson?: (specifier: string) => string;
-  identityProbe?: (binaryPath: string, identityFlag: string) => IdentityProbeResult;
-};
-
-function packageFailure(
-  code: RustBackendPackageErrorCode,
-  message: string,
-): RustBackendPackageResolution {
-  return { kind: "error", error: { code, message } };
-}
-
-function targetFailure(message: string): RustBackendTargetResolution {
-  return { kind: "error", error: { code: "unsupported_platform", message } };
-}
-
-function detectLinuxLibc(): RustBackendLibc {
-  if (process.platform !== "linux") return "not-applicable";
-  const report = process.report.getReport();
-  const header = objectProperty(report, "header");
-  const glibcVersion = objectProperty(header, "glibcVersionRuntime");
-  if (typeof glibcVersion === "string" && glibcVersion.length > 0) {
-    return "glibc";
-  }
-  const sharedObjects = objectProperty(report, "sharedObjects");
-  return Array.isArray(sharedObjects) &&
-    sharedObjects.some((path) => typeof path === "string" && path.toLowerCase().includes("musl"))
-    ? "musl"
-    : "unknown";
-}
-
-function objectProperty(value: unknown, name: string): unknown {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
-  return Object.getOwnPropertyDescriptor(value, name)?.value;
-}
-
-export function resolveRustBackendTarget(
-  platform: string = process.platform,
-  arch: string = process.arch,
-  libc: RustBackendLibc = platform === "linux" ? detectLinuxLibc() : "not-applicable",
-): RustBackendTargetResolution {
-  switch (platform) {
-    case "win32":
-      return arch === "x64"
-        ? {
-            kind: "success",
-            value: {
-              packageName: "@tonyclaw/agent-inspector-backend-win32-x64-msvc",
-              target: "x86_64-pc-windows-msvc",
-              binary: "bin/agent-inspector-backend.exe",
-              os: "win32",
-              cpu: "x64",
-              libc: null,
-            },
-          }
-        : targetFailure(`Rust backend packages do not support Windows ${arch}.`);
-    case "linux":
-      if (arch !== "x64")
-        return targetFailure(`Rust backend packages do not support Linux ${arch}.`);
-      if (libc !== "glibc") {
-        return targetFailure(
-          `The Linux Rust backend package requires glibc; detected ${libc}. No binary was started.`,
-        );
-      }
-      return {
-        kind: "success",
-        value: {
-          packageName: "@tonyclaw/agent-inspector-backend-linux-x64-gnu",
-          target: "x86_64-unknown-linux-gnu",
-          binary: "bin/agent-inspector-backend",
-          os: "linux",
-          cpu: "x64",
-          libc: "glibc",
-        },
-      };
-    case "darwin":
-      return arch === "arm64"
-        ? {
-            kind: "success",
-            value: {
-              packageName: "@tonyclaw/agent-inspector-backend-darwin-arm64",
-              target: "aarch64-apple-darwin",
-              binary: "bin/agent-inspector-backend",
-              os: "darwin",
-              cpu: "arm64",
-              libc: null,
-            },
-          }
-        : targetFailure(`Rust backend packages do not support macOS ${arch}.`);
-    default:
-      return targetFailure(`Rust backend packages do not support ${platform} ${arch}.`);
-  }
-}
-
-function readJson(path: string): { kind: "success"; value: unknown } | { kind: "error" } {
-  try {
-    const value: unknown = JSON.parse(readFileSync(path, "utf8"));
-    return { kind: "success", value };
-  } catch {
-    return { kind: "error" };
-  }
-}
-
-function isConfinedPath(root: string, candidate: string): boolean {
-  const child = relative(root, candidate);
-  return child.length > 0 && !child.startsWith("..") && !isAbsolute(child);
-}
-
-function identitiesMatch(left: RustBackendIdentity, right: RustBackendIdentity): boolean {
-  return (
-    left.schemaVersion === right.schemaVersion &&
-    left.name === right.name &&
-    left.packageVersion === right.packageVersion &&
-    left.target === right.target &&
-    left.binary === right.binary &&
-    left.cliProtocol === right.cliProtocol &&
-    left.productionReady === right.productionReady &&
-    left.capabilities.nodeProtectedIngress === right.capabilities.nodeProtectedIngress &&
-    left.capabilities.basePath === right.capabilities.basePath &&
-    left.capabilities.namedInstances === right.capabilities.namedInstances &&
-    left.capabilities.gracefulShutdown === right.capabilities.gracefulShutdown
-  );
-}
-
-function probeBinaryIdentity(binaryPath: string, identityFlag: string): IdentityProbeResult {
-  const result = spawnSync(binaryPath, [identityFlag], {
-    encoding: "utf8",
-    windowsHide: true,
-    timeout: RUST_BACKEND_IDENTITY_TIMEOUT_MS,
-    maxBuffer: 64 * 1024,
-  });
-  if (result.error !== undefined) {
-    return { kind: "error", message: result.error.message };
-  }
-  if (result.status !== 0) {
-    return {
-      kind: "error",
-      message: `identity command exited with status ${String(result.status)}`,
-    };
-  }
-  let raw: unknown;
-  try {
-    raw = JSON.parse(result.stdout);
-  } catch {
-    return { kind: "error", message: "identity command did not return JSON" };
-  }
-  const parsed = RustBackendIdentitySchema.safeParse(raw);
-  return parsed.success
-    ? { kind: "success", value: parsed.data }
-    : { kind: "error", message: "identity command returned an unsupported contract" };
-}
-
-const packageRequire = createRequire(import.meta.url);
-
-function defaultResolvePackageJson(specifier: string): string {
-  try {
-    return packageRequire.resolve(specifier);
-  } catch {
-    const suffix = "/package.json";
-    const packageName = specifier.endsWith(suffix) ? specifier.slice(0, -suffix.length) : "";
-    const directoryName = packageName.split("/").at(-1);
-    if (directoryName !== undefined && directoryName.length > 0) {
-      const localPackageJson = resolve(
-        dirname(fileURLToPath(import.meta.url)),
-        "../packages",
-        directoryName,
-        "package.json",
-      );
-      if (existsSync(localPackageJson)) return localPackageJson;
-    }
-    return packageRequire.resolve(specifier);
-  }
-}
-
-export function resolveRustBackendPackage(
-  options: ResolveRustBackendPackageOptions,
-): RustBackendPackageResolution {
-  const target = resolveRustBackendTarget(options.platform, options.arch, options.libc);
-  if (target.kind === "error") return { kind: "error", error: target.error };
-
-  const packageJsonSpecifier = `${target.value.packageName}/package.json`;
-  let packageJsonPath: string;
-  try {
-    packageJsonPath = (options.resolvePackageJson ?? defaultResolvePackageJson)(
-      packageJsonSpecifier,
-    );
-  } catch {
-    return packageFailure(
-      "package_missing",
-      `Rust backend ${target.value.target} was requested, but optional package ${target.value.packageName}@${options.rootVersion} is not installed. Reinstall without omitting optional dependencies; no TypeScript fallback was used.`,
-    );
-  }
-
-  const rawPackage = readJson(packageJsonPath);
-  if (rawPackage.kind === "error") {
-    return packageFailure("package_invalid", `Cannot read ${packageJsonSpecifier}.`);
-  }
-  const packageJson = RustBackendPackageJsonSchema.safeParse(rawPackage.value);
-  if (!packageJson.success) {
-    return packageFailure(
-      "package_invalid",
-      `Package ${target.value.packageName} does not contain the Rust backend package contract.`,
-    );
-  }
-  if (
-    packageJson.data.name !== target.value.packageName ||
-    packageJson.data.version !== options.rootVersion
-  ) {
-    return packageFailure(
-      "version_mismatch",
-      `Rust backend package must exactly match @tonyclaw/agent-inspector@${options.rootVersion}; found ${packageJson.data.name}@${packageJson.data.version}.`,
-    );
-  }
-
-  const metadata = packageJson.data.agentInspectorRustBackend;
-  const expectedLibc = target.value.libc === null ? undefined : [target.value.libc];
-  if (
-    metadata.target !== target.value.target ||
-    metadata.binary !== target.value.binary ||
-    metadata.manifest !== "binary-manifest.json" ||
-    packageJson.data.os.length !== 1 ||
-    packageJson.data.os[0] !== target.value.os ||
-    packageJson.data.cpu.length !== 1 ||
-    packageJson.data.cpu[0] !== target.value.cpu ||
-    JSON.stringify(packageJson.data.libc) !== JSON.stringify(expectedLibc)
-  ) {
-    return packageFailure(
-      "target_mismatch",
-      `Package ${target.value.packageName} does not match target ${target.value.target}.`,
-    );
-  }
-
-  const packageRoot = dirname(packageJsonPath);
-  const manifestPath = resolve(packageRoot, metadata.manifest);
-  const binaryPath = resolve(packageRoot, metadata.binary);
-  if (!isConfinedPath(packageRoot, manifestPath) || !isConfinedPath(packageRoot, binaryPath)) {
-    return packageFailure(
-      "package_invalid",
-      `Package ${target.value.packageName} contains an unsafe artifact path.`,
-    );
-  }
-
-  const rawManifest = readJson(manifestPath);
-  if (rawManifest.kind === "error") {
-    return packageFailure(
-      "manifest_invalid",
-      `Rust backend package ${target.value.packageName} is incomplete: binary-manifest.json is missing or invalid.`,
-    );
-  }
-  const manifest = RustBackendBinaryManifestSchema.safeParse(rawManifest.value);
-  if (!manifest.success) {
-    return packageFailure(
-      "manifest_invalid",
-      `Rust backend package ${target.value.packageName} has an invalid target manifest.`,
-    );
-  }
-  if (
-    manifest.data.packageName !== target.value.packageName ||
-    manifest.data.packageVersion !== options.rootVersion ||
-    manifest.data.identity.packageVersion !== options.rootVersion
-  ) {
-    return packageFailure(
-      "version_mismatch",
-      `Rust backend manifest must exactly match @tonyclaw/agent-inspector@${options.rootVersion}.`,
-    );
-  }
-  if (
-    manifest.data.target !== target.value.target ||
-    manifest.data.binary !== target.value.binary ||
-    manifest.data.identity.target !== target.value.target ||
-    manifest.data.identity.binary !== target.value.binary
-  ) {
-    return packageFailure(
-      "target_mismatch",
-      `Rust backend manifest identity does not match target ${target.value.target}.`,
-    );
-  }
-
-  let binaryBytes: Buffer;
-  try {
-    const stats = statSync(binaryPath);
-    if (!stats.isFile()) {
-      return packageFailure("binary_invalid", `Rust backend artifact is not a regular file.`);
-    }
-    if (target.value.os !== "win32" && (stats.mode & 0o111) === 0) {
-      return packageFailure("binary_invalid", `Rust backend artifact is not executable.`);
-    }
-    binaryBytes = readFileSync(binaryPath);
-  } catch {
-    return packageFailure(
-      "binary_missing",
-      `Rust backend binary ${target.value.binary} is missing from ${target.value.packageName}.`,
-    );
-  }
-  const sha256 = createHash("sha256").update(binaryBytes).digest("hex");
-  if (sha256 !== manifest.data.sha256) {
-    return packageFailure(
-      "hash_mismatch",
-      `Rust backend binary integrity check failed for ${target.value.packageName}; no binary was started.`,
-    );
-  }
-
-  const probed = (options.identityProbe ?? probeBinaryIdentity)(binaryPath, metadata.identityFlag);
-  if (probed.kind === "error") {
-    return packageFailure(
-      "identity_failed",
-      `Rust backend binary did not pass the production identity gate: ${probed.message}. No TypeScript fallback was used.`,
-    );
-  }
-  if (!identitiesMatch(probed.value, manifest.data.identity)) {
-    return packageFailure(
-      "identity_mismatch",
-      `Rust backend binary identity differs from its signed package manifest; no binary was started.`,
-    );
-  }
-
-  return {
-    kind: "success",
-    value: {
-      command: binaryPath,
-      args: [],
-      packageName: target.value.packageName,
-      packageVersion: options.rootVersion,
-      target: target.value.target,
-      sha256,
-    },
-  };
-}
-
-export function resolvePreferredBackendImplementation(
-  options: ResolveRustBackendPackageOptions,
-): PreferredBackendImplementation {
-  return resolveRustBackendPackage(options).kind === "success" ? "rust" : "typescript";
-}

package/src/cli/startupOutput.ts

@@ -1,16 +0,0 @@
-export type ServerOutputFilterContext = {
-  enableIdentityProxy: boolean;
-  publicPort: number;
-  upstreamPort: number;
-};
-
-export function shouldSuppressServerOutputLine(
-  line: string,
-  context: ServerOutputFilterContext,
-): boolean {
-  if (!context.enableIdentityProxy) return false;
-  if (context.publicPort === context.upstreamPort) return false;
-
-  const lowerLine = line.toLowerCase();
-  return lowerLine.includes("listening on") && lowerLine.includes(`:${context.upstreamPort}`);
-}