import * as Cause from "effect/Cause";import * as Context from "effect/Context";import * as Duration from "effect/Duration";import * as Effect from "effect/Effect";import * as Exit from "effect/Exit";import * as Fiber from "effect/Fiber";import * as FileSystem from "effect/FileSystem";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as PlatformError from "effect/PlatformError";import * as Ref from "effect/Ref";import * as Result from "effect/Result";import * as Schedule from "effect/Schedule";import * as Schema from "effect/Schema";import * as Semaphore from "effect/Semaphore";import * as Scope from "effect/Scope";import * as Stream from "effect/Stream";import * as HttpClient from "effect/unstable/http/HttpClient";import * as ChildProcess from "effect/unstable/process/ChildProcess";import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; import {  DesktopBackendBootstrap,  type DesktopBackendBootstrap as DesktopBackendBootstrapValue,} from "@t3tools/contracts"; import * as DesktopBackendConfiguration from "./DesktopBackendConfiguration.ts";import * as DesktopObservability from "../app/DesktopObservability.ts";import * as DesktopState from "../app/DesktopState.ts";import * as DesktopWindow from "../window/DesktopWindow.ts"; const INITIAL_RESTART_DELAY = Duration.millis(500);const MAX_RESTART_DELAY = Duration.seconds(10);const DEFAULT_BACKEND_READINESS_TIMEOUT = Duration.minutes(1);const DEFAULT_BACKEND_READINESS_INTERVAL = Duration.millis(100);const DEFAULT_BACKEND_READINESS_REQUEST_TIMEOUT = Duration.seconds(1);const DEFAULT_BACKEND_TERMINATE_GRACE = Duration.seconds(2);const BACKEND_READINESS_PATH = "/.well-known/t3/environment"; type BackendProcessLayerServices = ChildProcessSpawner.ChildProcessSpawner | HttpClient.HttpClient; type BackendProcessRunRequirements = BackendProcessLayerServices | Scope.Scope; export type BackendProcessOutputStream = "stdout" | "stderr"; export interface DesktopBackendStartConfig {  readonly executablePath: string;  readonly entryPath: string;  readonly cwd: string;  readonly env: Record<string, string | undefined>;  readonly bootstrap: DesktopBackendBootstrapValue;  readonly httpBaseUrl: URL;  readonly captureOutput: boolean;} interface BackendProcessExit {  readonly code: Option.Option<number>;  readonly reason: string;  readonly result: Result.Result<ChildProcessSpawner.ExitCode, PlatformError.PlatformError>;} export class BackendTimeoutError extends Schema.TaggedErrorClass<BackendTimeoutError>()(  "BackendTimeoutError",  {    url: Schema.URL,  },) {  override get message(): string {    return `Timed out waiting for backend readiness at ${this.url.href}.`;  }} class BackendProcessBootstrapEncodeError extends Schema.TaggedErrorClass<BackendProcessBootstrapEncodeError>()(  "BackendProcessBootstrapEncodeError",  {    detail: Schema.String,    cause: Schema.Defect(),  },) {  override get message(): string {    return `Failed to encode desktop backend bootstrap payload: ${this.detail}`;  }} class BackendProcessSpawnError extends Schema.TaggedErrorClass<BackendProcessSpawnError>()(  "BackendProcessSpawnError",  {    detail: Schema.String,    cause: Schema.Defect(),  },) {  override get message(): string {    return `Failed to spawn desktop backend process: ${this.detail}`;  }} type BackendProcessError = BackendProcessBootstrapEncodeError | BackendProcessSpawnError; interface RunBackendProcessOptions extends DesktopBackendStartConfig {  readonly readinessTimeout?: Duration.Duration;  readonly onStarted?: (pid: number) => Effect.Effect<void>;  readonly onReady?: () => Effect.Effect<void>;  readonly onReadinessFailure?: (error: BackendTimeoutError) => Effect.Effect<void>;  readonly onOutput?: (    streamName: BackendProcessOutputStream,    chunk: Uint8Array,  ) => Effect.Effect<void>;} export interface DesktopBackendSnapshot {  readonly desiredRunning: boolean;  readonly ready: boolean;  readonly activePid: Option.Option<number>;  readonly restartAttempt: number;  readonly restartScheduled: boolean;} export class DesktopBackendManager extends Context.Service<  DesktopBackendManager,  {    readonly start: Effect.Effect<void>;    readonly stop: (options?: { readonly timeout?: Duration.Duration }) => Effect.Effect<void>;    readonly currentConfig: Effect.Effect<Option.Option<DesktopBackendStartConfig>>;    readonly snapshot: Effect.Effect<DesktopBackendSnapshot>;  }>()("@t3tools/desktop/backend/DesktopBackendManager") {} const { logWarning: logBackendManagerWarning, logError: logBackendManagerError } =  DesktopObservability.makeComponentLogger("desktop-backend-manager"); interface ActiveBackendRun {  readonly id: number;  readonly scope: Scope.Closeable;  readonly fiber: Option.Option<Fiber.Fiber<void, never>>;  readonly pid: Option.Option<number>;} interface BackendManagerState {  readonly desiredRunning: boolean;  readonly ready: boolean;  readonly config: Option.Option<DesktopBackendStartConfig>;  readonly active: Option.Option<ActiveBackendRun>;  readonly restartAttempt: number;  readonly restartFiber: Option.Option<Fiber.Fiber<void, never>>;  readonly nextRunId: number;} const initialState: BackendManagerState = {  desiredRunning: false,  ready: false,  config: Option.none(),  active: Option.none(),  restartAttempt: 0,  restartFiber: Option.none(),  nextRunId: 1,}; const activePid = (active: Option.Option<ActiveBackendRun>): Option.Option<number> =>  Option.flatMap(active, (run) => run.pid); const withActiveRun =  (runId: number, f: (run: ActiveBackendRun) => ActiveBackendRun) =>  (state: BackendManagerState): BackendManagerState => ({    ...state,    active: Option.map(state.active, (run) => (run.id === runId ? f(run) : run)),  }); const calculateRestartDelay = (attempt: number): Duration.Duration =>  Duration.min(Duration.times(INITIAL_RESTART_DELAY, 2 ** attempt), MAX_RESTART_DELAY); const closeRun = (  run: ActiveBackendRun,  options?: { readonly timeout?: Duration.Duration },): Effect.Effect<void> => {  const waitForFiber = Option.match(run.fiber, {    onNone: () => Effect.void,    onSome: (fiber) => Fiber.await(fiber).pipe(Effect.asVoid),  });  const close = Scope.close(run.scope, Exit.void).pipe(Effect.andThen(waitForFiber));   return (    options?.timeout ? close.pipe(Effect.timeoutOption(options.timeout), Effect.asVoid) : close  ).pipe(Effect.ignore);}; const waitForHttpReady = Effect.fn("desktop.backendManager.waitForHttpReady")(function* (  baseUrl: URL,  timeout: Duration.Duration,): Effect.fn.Return<void, BackendTimeoutError, HttpClient.HttpClient> {  const readinessUrl = new URL(BACKEND_READINESS_PATH, baseUrl);  const client = (yield* HttpClient.HttpClient).pipe(    HttpClient.filterStatusOk,    HttpClient.transformResponse(Effect.timeout(DEFAULT_BACKEND_READINESS_REQUEST_TIMEOUT)),    HttpClient.retry(Schedule.spaced(DEFAULT_BACKEND_READINESS_INTERVAL)),  );   yield* client.get(readinessUrl).pipe(    Effect.asVoid,    Effect.timeout(timeout),    Effect.mapError(() => new BackendTimeoutError({ url: readinessUrl })),  );}); function describeProcessExit(  result: Result.Result<ChildProcessSpawner.ExitCode, PlatformError.PlatformError>,): BackendProcessExit {  if (Result.isSuccess(result)) {    return {      code: Option.some(result.success),      reason: `code=${result.success}`,      result,    };  }   return {    code: Option.none(),    reason: result.failure.message,    result,  };} function drainBackendOutput(  streamName: BackendProcessOutputStream,  stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>,  onOutput: (streamName: BackendProcessOutputStream, chunk: Uint8Array) => Effect.Effect<void>,): Effect.Effect<void> {  return stream.pipe(    Stream.runForEach((chunk) => onOutput(streamName, chunk)),    Effect.ignore,  );} const encodeBootstrapJson = Schema.encodeEffect(Schema.fromJsonString(DesktopBackendBootstrap)); const runBackendProcess = Effect.fn("runBackendProcess")(function* (  options: RunBackendProcessOptions,): Effect.fn.Return<BackendProcessExit, BackendProcessError, BackendProcessRunRequirements> {  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;  const bootstrapJson = yield* encodeBootstrapJson(options.bootstrap).pipe(    Effect.mapError(      (cause) =>        new BackendProcessBootstrapEncodeError({          detail: cause.message,          cause,        }),    ),  );  const onOutput = options.onOutput ?? (() => Effect.void);  const command = ChildProcess.make(    options.executablePath,    [options.entryPath, "--bootstrap-fd", "3"],    {      cwd: options.cwd,      env: options.env,      extendEnv: true,      // In Electron main, process.execPath points to the Electron binary.      // Run the child in Node mode so this backend process does not become a GUI app instance.      stdin: "ignore",      stdout: options.captureOutput ? "pipe" : "inherit",      stderr: options.captureOutput ? "pipe" : "inherit",      killSignal: "SIGTERM",      forceKillAfter: DEFAULT_BACKEND_TERMINATE_GRACE,      additionalFds: {        fd3: {          type: "input",          stream: Stream.encodeText(Stream.make(`${bootstrapJson}\n`)),        },      },    },  );   const handle = yield* spawner.spawn(command).pipe(    Effect.mapError(      (cause) =>        new BackendProcessSpawnError({          detail: cause.message,          cause,        }),    ),  );   yield* options.onStarted?.(handle.pid) ?? Effect.void;  if (options.captureOutput) {    yield* drainBackendOutput("stdout", handle.stdout, onOutput).pipe(Effect.forkScoped);    yield* drainBackendOutput("stderr", handle.stderr, onOutput).pipe(Effect.forkScoped);  }  yield* waitForHttpReady(    options.httpBaseUrl,    options.readinessTimeout ?? DEFAULT_BACKEND_READINESS_TIMEOUT,  ).pipe(    Effect.tap(() => options.onReady?.() ?? Effect.void),    Effect.catch((error) => options.onReadinessFailure?.(error) ?? Effect.void),    Effect.forkScoped,  );   return describeProcessExit(yield* Effect.result(handle.exitCode));}); export const make = Effect.gen(function* () {  const parentScope = yield* Scope.Scope;  const fileSystem = yield* FileSystem.FileSystem;  const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;  const backendOutputLog = yield* DesktopObservability.DesktopBackendOutputLog;  const desktopState = yield* DesktopState.DesktopState;  const desktopWindow = yield* DesktopWindow.DesktopWindow;  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;  const httpClient = yield* HttpClient.HttpClient;  const state = yield* Ref.make(initialState);  const mutex = yield* Semaphore.make(1);   const updateActiveRun = (runId: number, f: (run: ActiveBackendRun) => ActiveBackendRun) =>    Ref.update(state, withActiveRun(runId, f));   const snapshot = Ref.get(state).pipe(    Effect.map(      (current): DesktopBackendSnapshot => ({        desiredRunning: current.desiredRunning,        ready: current.ready,        activePid: activePid(current.active),        restartAttempt: current.restartAttempt,        restartScheduled: Option.isSome(current.restartFiber),      }),    ),  );  const currentConfig = Ref.get(state).pipe(Effect.map((current) => current.config));   const cancelRestart = Effect.gen(function* () {    const restartFiber = yield* Ref.modify(state, (current) => [      current.restartFiber,      {        ...current,        restartFiber: Option.none(),      },    ]);     yield* Option.match(restartFiber, {      onNone: () => Effect.void,      onSome: (fiber) => Fiber.interrupt(fiber).pipe(Effect.asVoid),    });  });   const start: Effect.Effect<void> = Effect.suspend(() =>    mutex.withPermits(1)(      Effect.gen(function* () {        const current = yield* Ref.get(state);        if (Option.isSome(current.active)) {          return;        }         yield* Ref.set(desktopState.backendReady, false);        const config = yield* configuration.resolve.pipe(          Effect.tapError((error) =>            logBackendManagerError("failed to generate desktop backend configuration", {              cause: error.message,            }),          ),          Effect.option,        );        if (Option.isNone(config)) {          return;        }        const entryExists = yield* fileSystem          .exists(config.value.entryPath)          .pipe(Effect.orElseSucceed(() => false));         yield* cancelRestart;        yield* Ref.update(state, (latest) => ({          ...latest,          desiredRunning: true,          ready: false,          config: Option.some(config.value),        }));         if (!entryExists) {          yield* scheduleRestart(`missing server entry at ${config.value.entryPath}`);          return;        }         const runScope = yield* Scope.make("sequential");        const runId = yield* Ref.modify(state, (latest) => [          latest.nextRunId,          {            ...latest,            active: Option.some({              id: latest.nextRunId,              scope: runScope,              fiber: Option.none(),              pid: Option.none(),            } satisfies ActiveBackendRun),            nextRunId: latest.nextRunId + 1,          },        ]);         const finalizeRun = Effect.fn("desktop.backendManager.finalizeRun")(function* (          reason: string,        ) {          yield* mutex.withPermits(1)(            Effect.gen(function* () {              const { isCurrentRun, nextState, pid } = yield* Ref.modify(                state,                (                  latest,                ): readonly [                  {                    readonly isCurrentRun: boolean;                    readonly nextState: BackendManagerState;                    readonly pid: Option.Option<number>;                  },                  BackendManagerState,                ] => {                  const currentRun = Option.getOrUndefined(latest.active);                  if (currentRun?.id !== runId) {                    return [                      {                        isCurrentRun: false,                        nextState: latest,                        pid: Option.none<number>(),                      },                      latest,                    ] as const;                  }                   const next = {                    ...latest,                    active: Option.none<ActiveBackendRun>(),                    ready: false,                  };                  return [                    {                      isCurrentRun: true,                      nextState: next,                      pid: currentRun.pid,                    },                    next,                  ] as const;                },              );               if (isCurrentRun) {                if (Option.isSome(pid)) {                  yield* backendOutputLog.writeSessionBoundary({                    phase: "END",                    details: `pid=${pid.value} ${reason}`,                  });                }                yield* Ref.set(desktopState.backendReady, false);              }               if (isCurrentRun && nextState.desiredRunning) {                yield* scheduleRestart(reason);              }            }),          );        });         const program = runBackendProcess({          ...config.value,          onStarted: Effect.fn("desktop.backendManager.onStarted")(function* (pid) {            yield* updateActiveRun(runId, (run) => ({              ...run,              pid: Option.some(pid),            }));            yield* backendOutputLog.writeSessionBoundary({              phase: "START",              details: `pid=${pid} port=${config.value.bootstrap.port} cwd=${config.value.cwd}`,            });          }),          onReady: Effect.fn("desktop.backendManager.onReady")(function* () {            const isCurrentRun = yield* Ref.modify(state, (latest) => {              const activeRun = Option.getOrUndefined(latest.active);              if (activeRun?.id !== runId) {                return [false, latest] as const;              }               return [                true,                {                  ...latest,                  restartAttempt: 0,                  ready: true,                },              ] as const;            });            if (!isCurrentRun) {              return;            }             yield* Ref.set(desktopState.backendReady, true);            yield* desktopWindow.handleBackendReady.pipe(              Effect.catch((error) =>                logBackendManagerError("failed to open main window after backend readiness", {                  message: error.message,                }),              ),            );          }),          onReadinessFailure: (error) =>            logBackendManagerWarning("backend readiness check failed during bootstrap", {              error: error.message,            }),

Lines 1–500 of 625. Load more