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 * as NodeCrypto from "node:crypto";import { HostProcessEnvironment, HostProcessPlatform } from "@t3tools/shared/hostProcess"; import {  type DeviceServiceState,  AuthAccessTokenType,  AuthStandardClientScopes,  AuthEnvironmentBootstrapTokenType,  AuthTokenExchangeGrantType,  CommandId,  DEFAULT_SERVER_SETTINGS,  type DpopFailureReason,  EnvironmentId,  EventId,  GitCommandError,  KeybindingRule,  MessageId,  ExternalLauncherCommandNotFoundError,  OrchestrationShellSnapshot,  type OrchestrationShellStreamItem,  OrchestrationThreadDetailSnapshot,  type OrchestrationThreadStreamItem,  type OrchestrationThreadActivity,  type OrchestrationThreadShell,  TerminalNotRunningError,  type OrchestrationCommand,  type OrchestrationEvent,  ORCHESTRATION_WS_METHODS,  type PreviewEvent,  ProjectId,  type ProviderAuthState,  ProviderDriverKind,  ProviderInstanceId,  type ProviderInstallState,  ProviderSetupError,  ResolvedKeybindingRule,  type ServerLifecycleStreamEvent,  ThreadId,  TurnId,  UsageLimitSourceId,  WS_METHODS,  WsRpcGroup,  EditorId,} from "@t3tools/contracts";import {  computeDpopAccessTokenHash,  computeDpopJwkThumbprint,  type DpopPublicJwk,} from "@t3tools/shared/dpop";import { RELAY_HEALTH_REQUEST_TYP, RELAY_MINT_REQUEST_TYP } from "@t3tools/shared/relayJwt";import * as RelayClient from "@t3tools/shared/relayClient";import { assert, it } from "@effect/vitest";import { assertFailure, assertInclude, assertTrue } from "@effect/vitest/utils";import * as Clock from "effect/Clock";import * as Config from "effect/Config";import * as Deferred from "effect/Deferred";import * as DateTime from "effect/DateTime";import * as Duration from "effect/Duration";import * as Effect from "effect/Effect";import * as FileSystem from "effect/FileSystem";import * as Fiber from "effect/Fiber";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as Path from "effect/Path";import * as PubSub from "effect/PubSub";import * as Ref from "effect/Ref";import * as Queue from "effect/Queue";import * as Schema from "effect/Schema";import * as Stream from "effect/Stream";import * as TestClock from "effect/testing/TestClock";import * as Tracer from "effect/Tracer";import { ChildProcessSpawner } from "effect/unstable/process";import {  FetchHttpClient,  HttpBody,  HttpClient,  HttpClientRequest,  HttpClientResponse,  HttpRouter,  HttpServer,} from "effect/unstable/http";import { OtlpSerialization, OtlpTracer } from "effect/unstable/observability";import { RpcClient, RpcSerialization } from "effect/unstable/rpc";import * as Socket from "effect/unstable/socket/Socket";import { vi } from "vite-plus/test"; const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z");const decodeTransferThreadSnapshot = Schema.decodeUnknownEffect(  Schema.fromJsonString(OrchestrationThreadDetailSnapshot),);const decodeTransferShellSnapshot = Schema.decodeUnknownEffect(  Schema.fromJsonString(OrchestrationShellSnapshot),);const encodeTestJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); import * as BackgroundPolicy from "./background/BackgroundPolicy.ts";import * as ServerConfig from "./config.ts";import * as DeviceService from "./device/DeviceService.ts";import { HTTP_ROUTER_CONFIG, makeRoutesLayer } from "./server.ts";import {  isThreadDetailEvent,  resolveAvailableEditorsForConfig,  resolveFileManagerRevealKindForConfig,} from "./ws.ts";import * as CheckpointDiffQuery from "./checkpointing/CheckpointDiffQuery.ts";import * as GitManager from "./git/GitManager.ts";import * as EnvironmentTheme from "./environmentTheme.ts";import * as UsageLimitSources from "./usage/UsageLimitSources.ts";import * as Keybindings from "./keybindings.ts";import * as ExternalLauncher from "./process/externalLauncher.ts";import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts";import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";import {  OrchestrationListenerCallbackError,  OrchestrationThreadSettleBlockedError,} from "./orchestration/Errors.ts";import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";import { ThreadDeletionReactor } from "./orchestration/Services/ThreadDeletionReactor.ts";import * as PullRequestSyncReactor from "./orchestration/PullRequestSyncReactor.ts";import { SqlitePersistenceMemory } from "./persistence/Layers/Sqlite.ts";import { OrchestrationEventStoreLive } from "./persistence/Layers/OrchestrationEventStore.ts";import { OrchestrationEventStore } from "./persistence/Services/OrchestrationEventStore.ts";import { PersistenceSqlError } from "./persistence/Errors.ts";import * as ProviderRegistry from "./provider/Services/ProviderRegistry.ts";import * as ProviderService from "./provider/Services/ProviderService.ts";import { ProviderAuthService } from "./provider/Services/ProviderAuthService.ts";import { ProviderInstanceRegistry } from "./provider/Services/ProviderInstanceRegistry.ts";import {  AntigravityInstallation,  AntigravityInstallationError,} from "./provider/AntigravityInstallation.ts";import type { ProviderInstance } from "./provider/ProviderDriver.ts";import * as ProviderSessionDirectory from "./provider/Services/ProviderSessionDirectory.ts";import { ProviderAdapterRequestError } from "./provider/Errors.ts";import { makeManualOnlyProviderMaintenanceCapabilities } from "./provider/providerMaintenance.ts";import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts";import * as ServerSettings from "./serverSettings.ts";import * as TerminalManager from "./terminal/Manager.ts";import * as PreviewManager from "./preview/Manager.ts";import * as PortScanner from "./preview/PortScanner.ts";import * as BrowserTraceCollector from "./observability/BrowserTraceCollector.ts";import * as NativeAppIconResolver from "./assets/NativeAppIconResolver.ts";import * as ProjectFaviconResolver from "./project/ProjectFaviconResolver.ts";import * as T3ProjectFileLoader from "./project/T3ProjectFileLoader.ts";import * as ProjectSetupScriptRunner from "./project/ProjectSetupScriptRunner.ts";import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts";import * as ServerEnvironment from "./environment/ServerEnvironment.ts";import * as WorkspaceEntries from "./workspace/WorkspaceEntries.ts";import * as WorkspaceFileSystem from "./workspace/WorkspaceFileSystem.ts";import * as WorkspacePaths from "./workspace/WorkspacePaths.ts";import * as GitVcsDriver from "./vcs/GitVcsDriver.ts";import * as VcsDriver from "./vcs/VcsDriver.ts";import * as VcsStatusBroadcaster from "./vcs/VcsStatusBroadcaster.ts";import * as VcsDriverRegistry from "./vcs/VcsDriverRegistry.ts";import * as VcsProvisioningService from "./vcs/VcsProvisioningService.ts";import * as VcsProcess from "./vcs/VcsProcess.ts";import * as GitWorkflowService from "./git/GitWorkflowService.ts";import * as ReviewService from "./review/ReviewService.ts";import * as SourceControlRepositoryService from "./sourceControl/SourceControlRepositoryService.ts";import * as ServerSecretStore from "./auth/ServerSecretStore.ts";import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";import * as PairingGrantStore from "./auth/PairingGrantStore.ts";import * as CloudManagedEndpointRuntime from "./cloud/ManagedEndpointRuntime.ts";import * as CloudCliTokenManager from "./cloud/CliTokenManager.ts";import * as ProcessDiagnostics from "./diagnostics/ProcessDiagnostics.ts";import * as HostResources from "./resourceTelemetry/HostResources.ts";import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts";import * as TraceDiagnostics from "./diagnostics/TraceDiagnostics.ts";import * as DesktopTelemetryReceiver from "./resourceTelemetry/DesktopTelemetryReceiver.ts";import * as NativeTelemetryClient from "./resourceTelemetry/NativeTelemetryClient.ts";import * as ResourceAttribution from "./resourceTelemetry/ResourceAttribution.ts";import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts";import * as UsageService from "./usage/UsageService.ts";import * as AnalyticsService from "./telemetry/AnalyticsService.ts";import * as Data from "effect/Data"; import { makeOrchestrationIntegrationHarness } from "../integration/OrchestrationEngineHarness.integration.ts";import {  measureHttpGet,  openMeasuredWsClient,  transferDelta,} from "../integration/NetworkTransferMeasurement.integration.ts";import { makeSqlStatementCounter } from "../integration/SqlStatementCounter.integration.ts";import {  awaitSubscriptionSynchronized,  collectQueueUntil,  expectedMeasuredAssistantText,  queueMeasuredTransferTurn,  seedTransferBudgetHistory,  subscribeShellItems,  subscribeThreadItems,  TRANSFER_HISTORY_TURN_COUNT,  TRANSFER_MEASURED_TURN_CREATED_AT,  TRANSFER_MEASURED_TURN_INDEX,  TRANSFER_THREAD_ID,  transferModelSelection,  waitForTurnQuiesced,} from "../integration/TransferBudgetScenario.integration.ts";import {  formatTransferBudgetReport,  formatTransferBudgetResult,  type TransferBudgetRun,  transferBudgetViolations,} from "../integration/TransferBudgetReport.integration.ts";import { symlinksSupported } from "@t3tools/shared/testing/symlinks"; const defaultProjectId = ProjectId.make("project-default");const defaultThreadId = ThreadId.make("thread-default");const defaultDesktopBootstrapToken = "test-desktop-bootstrap-token";const defaultModelSelection = {  instanceId: ProviderInstanceId.make("codex"),  model: "gpt-5-codex",} as const; const providerSetupInstanceId = ProviderInstanceId.make("antigravity-custom-profile");const providerSetupDriver = ProviderDriverKind.make("antigravity");const providerSetupInstallState: ProviderInstallState = {  driver: providerSetupDriver,  operationId: "install-operation",  phase: "downloading",  downloadedBytes: 128,  totalBytes: 256,  version: "test-release",  installedVersion: null,  canRemove: false,  message: null,};const providerSetupAuthState: ProviderAuthState = {  instanceId: providerSetupInstanceId,  phase: "idle",  flowId: null,  authorizationUrl: null,  expiresAt: null,  message: null,};const providerSetupInstance: ProviderInstance = {  instanceId: providerSetupInstanceId,  driverKind: providerSetupDriver,  enabled: false,  displayName: "Google account",  continuationIdentity: {    driverKind: providerSetupDriver,    continuationKey: providerSetupInstanceId,  },  get adapter(): never {    throw new Error("Provider setup must not start a chat session.");  },  get snapshot(): never {    throw new Error("Installation routing must not probe the provider.");  },  get textGeneration(): never {    throw new Error("Provider setup must not generate text.");  },}; const makeLiveToolActivityEvent = (  sequence: number,  kind: "tool.updated" | "tool.completed" = "tool.updated",  options: {    readonly toolCallId?: string;    readonly title?: string;    readonly path?: string;  } = {},): Extract<OrchestrationEvent, { type: "thread.activity-appended" }> => {  const { toolCallId = "call-edit", title = "Editing app.ts", path = "src/app.ts" } = options;  const activity: OrchestrationThreadActivity = {    id: EventId.make(`activity-${sequence}`),    tone: "tool",    kind,    summary: title,    payload: {      itemType: "file_change",      title,      data: { toolCallId, path },    },    turnId: TurnId.make("turn-edit"),    createdAt: "2026-01-01T00:00:01.000Z",  };  return {    sequence,    eventId: EventId.make(`event-tool-${sequence}`),    aggregateKind: "thread",    aggregateId: defaultThreadId,    occurredAt: "2026-01-01T00:00:01.000Z",    commandId: null,    causationEventId: null,    correlationId: null,    metadata: {},    type: "thread.activity-appended",    payload: { threadId: defaultThreadId, activity },  };};const testEnvironmentDescriptor = {  environmentId: EnvironmentId.make("environment-test"),  label: "Test environment",  platform: {    os: "darwin" as const,    arch: "arm64" as const,  },  serverVersion: "0.0.0-test",  capabilities: {    repositoryIdentity: true,  },};const makeDefaultOrchestrationReadModel = () => {  const now = "2026-01-01T00:00:00.000Z";  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,        pullRequests: [],        createdAt: now,        updatedAt: now,        archivedAt: null,        settledOverride: null,        settledAt: null,        latestTurn: null,        messages: [],        session: null,        activities: [],        proposedPlans: [],        checkpoints: [],        deletedAt: null,      },    ],  };}; const makeDefaultOrchestrationThreadShell = (  overrides: Partial<OrchestrationThreadShell> = {},): OrchestrationThreadShell => {  const now = "2026-01-01T00:00:00.000Z";  return {    id: defaultThreadId,    projectId: defaultProjectId,    title: "Default Thread",    modelSelection: defaultModelSelection,    runtimeMode: "full-access",    interactionMode: "default",    branch: null,    worktreePath: null,    pullRequests: [],    latestTurn: null,    createdAt: now,    updatedAt: now,    archivedAt: null,    settledOverride: null,    settledAt: null,    session: null,    latestUserMessageAt: null,    hasPendingApprovals: false,    hasPendingUserInput: false,    hasActionableProposedPlan: false,    ...overrides,  };}; const browserOtlpTracingLayer = Layer.mergeAll(  FetchHttpClient.layer,  OtlpSerialization.layerJson,  Layer.succeed(HttpClient.TracerDisabledWhen, () => true),); const makeAuthTestLayer = () =>  EnvironmentAuth.layer.pipe(    Layer.provideMerge(SqlitePersistenceMemory),    Layer.provide(ServerSecretStore.layer),    Layer.provide(      Layer.mock(ServerEnvironment.ServerEnvironmentIdentity)({        getEnvironmentId: Effect.succeed(testEnvironmentDescriptor.environmentId),      }),    ),  ); const makeBrowserOtlpPayload = (spanName: string) =>  Effect.gen(function* () {    const collector = yield* Effect.acquireRelease(      Effect.promise(async () => {        const NodeHttp = await import("node:http");         return await new Promise<{          readonly close: () => Promise<void>;          readonly firstRequest: Promise<{            readonly body: string;            readonly contentType: string | null;          }>;          readonly url: string;        }>((resolve, reject) => {          let resolveFirstRequest:            | ((request: { readonly body: string; readonly contentType: string | null }) => void)            | undefined;          const firstRequest = new Promise<{            readonly body: string;            readonly contentType: string | null;          }>((resolveRequest) => {            resolveFirstRequest = resolveRequest;          });           const server = NodeHttp.createServer((request, response) => {            const chunks: Buffer[] = [];            request.on("data", (chunk) => {              chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));            });            request.on("end", () => {              resolveFirstRequest?.({                body: Buffer.concat(chunks).toString("utf8"),                contentType: request.headers["content-type"] ?? null,              });              resolveFirstRequest = undefined;              response.statusCode = 204;              response.end();            });          });           server.on("error", reject);          server.listen(0, "127.0.0.1", () => {            const address = server.address();            if (!address || typeof address === "string") {              reject(new Error("Expected TCP collector address"));              return;            }             resolve({              url: `http://127.0.0.1:${address.port}/v1/traces`,              firstRequest,              close: () =>                new Promise<void>((resolveClose, rejectClose) => {                  server.close((error) => {                    if (error) {                      rejectClose(error);                      return;                    }                    resolveClose();                  });                }),            });          });        });      }),      ({ close }) => Effect.promise(close),    );     // The exporter's batch fiber is forked while the layer builds and ticks on    // a wall-clock interval, so the whole tracer runs on the live clock.    yield* Layer.build(      OtlpTracer.layer({        url: collector.url,        exportInterval: "10 millis",        resource: {          serviceName: "t3-web",          attributes: {            "service.runtime": "t3-web",            "service.mode": "browser",            "service.version": "test",          },        },      }).pipe(Layer.provide(browserOtlpTracingLayer)),    ).pipe(      Effect.flatMap((tracing) =>        Effect.void.pipe(Effect.withSpan(spanName), Effect.provideContext(tracing)),      ),      TestClock.withLive,    );     const request = yield* Effect.raceFirst(      Effect.promise(() => collector.firstRequest).pipe(Effect.orDie),      Effect.sleep(Duration.seconds(1)).pipe(        Effect.andThen(Effect.die(new Error("Timed out waiting for OTLP trace export"))),      ),    );    // @effect-diagnostics-next-line preferSchemaOverJson:off    return JSON.parse(request.body) as OtlpTracer.TraceData;  }); 

Lines 1–500 of 11720. Load more