Unify launch env resolution on the server + introduce project/worktree/thread env vars

apps/mobile/src/features/threads/ThreadRouteScreen.tsx

@@ -4,7 +4,7 @@ import * as Arr from "effect/Array";
 import * as Option from "effect/Option";
 import { pipe } from "effect/Function";
 import { EnvironmentId, type ProjectScript } from "@t3tools/contracts";
-import { projectScriptCwd, projectScriptRuntimeEnv } from "@t3tools/shared/projectScripts";
+import { projectScriptCwd } from "@t3tools/shared/projectScripts";
 import { Pressable, ScrollView, Text as RNText, View, useColorScheme } from "react-native";
 import { useThemeColor } from "../../lib/useThemeColor";
 import { useVcsStatus } from "../../state/use-vcs-status";
@@ -198,10 +198,6 @@ export function ThreadRouteScreen() {
         project: { cwd: selectedThreadProject.workspaceRoot },
         worktreePath: preferredWorktreePath,
       });
-      const env = projectScriptRuntimeEnv({
-        project: { cwd: selectedThreadProject.workspaceRoot },
-        worktreePath: preferredWorktreePath,
-      });
       stagePendingTerminalLaunch({
         target: {
           environmentId: selectedThread.environmentId,
@@ -211,7 +207,6 @@ export function ThreadRouteScreen() {
         launch: {
           cwd,
           worktreePath: preferredWorktreePath,
-          env,
           initialInput: `${script.command}\r`,
         },
       });

apps/mobile/src/state/use-terminal-session.ts

@@ -9,14 +9,9 @@ import {
   terminalSessionStateAtom,
   type TerminalSessionTarget,
   type TerminalSessionState,
+  type TerminalAttachSessionInput,
 } from "@t3tools/client-runtime";
-import type {
-  EnvironmentId,
-  TerminalAttachInput,
-  TerminalAttachStreamEvent,
-  TerminalMetadataStreamEvent,
-  TerminalSessionSnapshot,
-} from "@t3tools/contracts";
+import type { EnvironmentId, TerminalMetadataStreamEvent } from "@t3tools/contracts";
 import { useMemo } from "react";
 
 import { appAtomRegistry } from "./atom-registry";
@@ -39,13 +34,11 @@ export function subscribeTerminalMetadata(input: {
   return terminalSessionManager.subscribeMetadata(input);
 }
 
-export function attachTerminalSession(input: {
-  readonly environmentId: EnvironmentId;
-  readonly client: Parameters<typeof terminalSessionManager.attach>[0]["client"];
-  readonly terminal: TerminalAttachInput;
-  readonly onSnapshot?: (snapshot: TerminalSessionSnapshot) => void;
-  readonly onEvent?: (event: TerminalAttachStreamEvent) => void;
-}) {
+export function attachTerminalSession(
+  input: TerminalAttachSessionInput & {
+    readonly environmentId: EnvironmentId;
+  },
+) {
   return terminalSessionManager.attach({
     environmentId: input.environmentId,
     client: input.client,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -37,6 +37,7 @@ import { makeAdapterRegistryMock } from "../src/provider/testUtils/providerAdapt
 import { ProviderAdapterRegistry } from "../src/provider/Services/ProviderAdapterRegistry.ts";
 import { makeProviderRegistryLayer } from "../src/provider/testUtils/providerRegistryMock.ts";
 import { ProviderSessionDirectoryLive } from "../src/provider/Layers/ProviderSessionDirectory.ts";
+import { LaunchEnvLive } from "../src/launchEnv/Layers/LaunchEnvLive.ts";
 import { ServerSettingsService } from "../src/serverSettings.ts";
 import { makeProviderServiceLive } from "../src/provider/Layers/ProviderService.ts";
 import { makeCodexAdapter } from "../src/provider/Layers/CodexAdapter.ts";
@@ -259,12 +260,16 @@ export const makeOrchestrationIntegrationHarness = (
 
     const persistenceLayer = makeSqlitePersistenceLive(dbPath);
     const orchestrationLayer = OrchestrationEngineLive.pipe(
+      Layer.provide(OrchestrationProjectionSnapshotQueryLive),
       Layer.provide(OrchestrationProjectionPipelineLive),
       Layer.provide(OrchestrationEventStoreLive),
       Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+      Layer.provide(RepositoryIdentityResolverLive),
+      Layer.provide(persistenceLayer),
     );
     const providerSessionDirectoryLayer = ProviderSessionDirectoryLive.pipe(
       Layer.provide(ProviderSessionRuntimeRepositoryLive),
+      Layer.provide(persistenceLayer),
     );
     const realCodexRegistry = Layer.effect(
       ProviderAdapterRegistry,
@@ -297,12 +302,15 @@ export const makeOrchestrationIntegrationHarness = (
     const providerRegistryLayer = makeProviderRegistryLayer();
 
     const checkpointStoreLayer = CheckpointStoreLive.pipe(Layer.provide(VcsDriverRegistry.layer));
-    const projectionSnapshotQueryLayer = OrchestrationProjectionSnapshotQueryLive;
+    const projectionSnapshotQueryLayer = OrchestrationProjectionSnapshotQueryLive.pipe(
+      Layer.provide(RepositoryIdentityResolverLive),
+      Layer.provide(persistenceLayer),
+    );
     const runtimeServicesLayer = Layer.mergeAll(
       projectionSnapshotQueryLayer,
-      orchestrationLayer.pipe(Layer.provide(projectionSnapshotQueryLayer)),
-      ProjectionCheckpointRepositoryLive,
-      ProjectionPendingApprovalRepositoryLive,
+      orchestrationLayer,
+      ProjectionCheckpointRepositoryLive.pipe(Layer.provide(persistenceLayer)),
+      ProjectionPendingApprovalRepositoryLive.pipe(Layer.provide(persistenceLayer)),
       checkpointStoreLayer,
       providerLayer,
       RuntimeReceiptBusTest,
@@ -374,14 +382,20 @@ export const makeOrchestrationIntegrationHarness = (
         }),
       ),
     );
+    const serverConfigLayer = ServerConfig.layerTest(workspaceDir, rootDir);
     const layer = Layer.empty.pipe(
       Layer.provideMerge(runtimeServicesLayer),
       Layer.provideMerge(orchestrationReactorLayer),
       Layer.provideMerge(providerRegistryLayer),
-      Layer.provide(persistenceLayer),
-      Layer.provideMerge(RepositoryIdentityResolverLive),
       Layer.provideMerge(ServerSettingsService.layerTest()),
-      Layer.provideMerge(ServerConfig.layerTest(workspaceDir, rootDir)),
+      Layer.provideMerge(serverConfigLayer),
+      Layer.provide(persistenceLayer),
+      Layer.provideMerge(
+        LaunchEnvLive.pipe(
+          Layer.provide(serverConfigLayer),
+          Layer.provide(projectionSnapshotQueryLayer),
+        ),
+      ),
       Layer.provideMerge(NodeServices.layer),
     );
 

apps/server/src/launchEnv/Layers/LaunchEnvLive.ts

@@ -0,0 +1,116 @@
+import { ThreadId } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+
+import { ServerConfig } from "../../config.ts";
+import { ProjectionSnapshotQuery } from "../../orchestration/Services/ProjectionSnapshotQuery.ts";
+import { LaunchEnv, type LaunchEnvShape } from "../Services/LaunchEnv.ts";
+import { mergeResolvedLaunchEnv } from "../launchEnvUtils.ts";
+import {
+  LaunchEnvProjectLookupError,
+  LaunchEnvThreadLookupError,
+} from "../Services/LaunchEnvErrors.ts";
+
+export const makeLaunchEnv = Effect.fn("makeLaunchEnv")(function* () {
+  const serverConfig = yield* ServerConfig;
+  const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
+
+  const resolve: LaunchEnvShape["resolve"] = (input) =>
+    Effect.succeed(
+      mergeResolvedLaunchEnv({
+        t3Home: serverConfig.baseDir,
+        ...(input.extraEnv !== undefined ? { extraEnv: input.extraEnv } : {}),
+        context: {
+          projectRoot: input.projectRoot,
+          projectId: String(input.projectId),
+          threadId: String(input.threadId),
+          worktreePath: input.worktreePath ?? undefined,
+        },
+      }),
+    );
+
+  const resolveForThread: LaunchEnvShape["resolveForThread"] = Effect.fn(
+    "LaunchEnv.resolveForThread",
+  )(function* (input) {
+    const threadOption = yield* projectionSnapshotQuery
+      .getThreadShellById(ThreadId.make(input.threadId))
+      .pipe(
+        Effect.mapError(
+          (cause) =>
+            new LaunchEnvThreadLookupError({
+              threadId: input.threadId,
+              terminalId: input.terminalId,
+              cause,
+            }),
+        ),
+      );
+
+    const { projectId, worktreePath } = yield* Option.match(threadOption, {
+      onSome: (thread) =>
+        Effect.succeed({
+          projectId: thread.projectId,
+          worktreePath: input.worktreePath !== undefined ? input.worktreePath : thread.worktreePath,
+        }),
+      onNone: () => {
+        if (input.projectId === undefined) {
+          return Effect.fail(
+            new LaunchEnvThreadLookupError({
+              threadId: input.threadId,
+              terminalId: input.terminalId,
+            }),
+          );
+        }
+
+        return Effect.succeed({
+          projectId: input.projectId,
+          ...(input.worktreePath !== undefined ? { worktreePath: input.worktreePath } : {}),
+        });
+      },
+    });
+
+    const projectOption = yield* projectionSnapshotQuery.getProjectShellById(projectId).pipe(
+      Effect.mapError(
+        (cause) =>
+          new LaunchEnvProjectLookupError({
+            projectId: String(projectId),
+            reason: "statFailed",
+            cause,
+          }),
+      ),
+    );
+
+    const project = yield* Option.match(projectOption, {
+      onSome: Effect.succeed,
+      onNone: () =>
+        Effect.fail(
+          new LaunchEnvProjectLookupError({
+            projectId: String(projectId),
+            reason: "notFound",
+          }),
+        ),
+    });
+
+    const env: Record<string, string> = yield* resolve({
+      ...(input.extraEnv !== undefined ? { extraEnv: input.extraEnv } : {}),
+      projectRoot: project.workspaceRoot,
+      projectId: project.id,
+      threadId: input.threadId,
+      ...(worktreePath !== undefined ? { worktreePath } : {}),
+    });
+
+    const result = {
+      projectId,
+      worktreePath,
+      env,
+    };
+    return result;
+  });
+
+  return {
+    resolve,
+    resolveForThread,
+  } satisfies LaunchEnvShape;
+});
+
+export const LaunchEnvLive = Layer.effect(LaunchEnv, makeLaunchEnv());