sailfork / t3code-github / packages/ client-runtime/ src/ state/ vcsAction.ts

import {
  EnvironmentId,
  type EnvironmentId as EnvironmentIdType,
  GitActionProgressPhase,
  type GitActionProgressEvent,
  type GitRunStackedActionInput,
  type GitRunStackedActionResult,
  GitStackedAction,
  type ThreadId,
  type ProjectId,
  WS_METHODS,
} from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import { AsyncResult, Atom, type AtomRegistry } from "effect/reactivity";

import type { EnvironmentRegistry } from "../connection/registry.ts";
import * as Persistence from "../platform/persistence.ts";
import { runStreamGuarded, RpcPermissionGuard } from "../rpc/client.ts";
import {
  createRuntimeCommand,
  runStreamInEnvironment,
  type AtomCommand,
  type AtomCommandResult,
} from "./runtime.ts";
import { createCommandPermissions } from "./commandPermissions.ts";
import { vcsCommandScheduler } from "./vcsCommandScheduler.ts";
import { invalidateCachedVcsRefs } from "./vcsRefInvalidation.ts";

export const VcsActionOperation = Schema.Literals([
  "refresh_status",
  "run_change_request",
  "pull",
  "switch_ref",
  "create_ref",
  "create_worktree",
  "init",
  "publish_repository",
  "prepare_pull_request_thread",
]);
export type VcsActionOperation = typeof VcsActionOperation.Type;

export interface VcsActionState {
  readonly isRunning: boolean;
  readonly operation: VcsActionOperation | null;
  readonly actionId: string | null;
  readonly action: GitStackedAction | null;
  readonly currentLabel: string | null;
  readonly currentPhaseLabel: string | null;
  readonly hookName: string | null;
  readonly lastOutputLine: string | null;
  readonly phaseStartedAtMs: number | null;
  readonly hookStartedAtMs: number | null;
  readonly error: string | null;
}

export interface VcsActionTarget {
  readonly environmentId: EnvironmentIdType | null;
  readonly cwd: string | null;
}

export interface ResolvedVcsActionTarget {
  readonly environmentId: EnvironmentIdType;
  readonly cwd: string;
}

export interface BeginVcsActionInput {
  readonly operation: VcsActionOperation;
  readonly label: string;
  readonly actionId?: string;
}

export interface RunVcsStackedActionInput {
  readonly actionId: string;
  readonly action: GitStackedAction;
  readonly commitMessage?: string;
  readonly featureBranch?: boolean;
  readonly filePaths?: ReadonlyArray<string>;
  readonly threadId?: ThreadId;
  readonly projectId?: ProjectId;
  readonly onProgress?: (event: GitActionProgressEvent) => void;
}

export class VcsActionUnavailableError extends Schema.TaggedError<VcsActionUnavailableError>()(
  "VcsActionUnavailableError",
  {
    operation: VcsActionOperation,
    environmentId: Schema.NullOr(EnvironmentId),
    cwd: Schema.NullOr(Schema.String),
  },
) {
  override get message(): string {
    return `Source control operation '${this.operation.replaceAll("_", " ")}' is unavailable.`;
  }
}

export class VcsActionRemoteFailureError extends Schema.TaggedError<VcsActionRemoteFailureError>()(
  "VcsActionRemoteFailureError",
  {
    actionId: Schema.String,
    transportActionId: Schema.String,
    action: GitStackedAction,
    environmentId: EnvironmentId,
    cwd: Schema.String,
    phase: Schema.NullOr(GitActionProgressPhase),
    remoteMessageLength: Schema.Number,
  },
) {
  override get message(): string {
    const phase = this.phase === null ? "execution" : this.phase;
    return `Source control action '${this.action}' failed during ${phase}.`;
  }
}

export class VcsActionMissingTerminalEventError extends Schema.TaggedError<VcsActionMissingTerminalEventError>()(
  "VcsActionMissingTerminalEventError",
  {
    actionId: Schema.String,
    transportActionId: Schema.String,
    action: GitStackedAction,
    environmentId: EnvironmentId,
    cwd: Schema.String,
  },
) {
  override get message(): string {
    return `Source control action '${this.action}' ended without a terminal result.`;
  }
}

export class VcsActionTargetKeyParseError extends Schema.TaggedError<VcsActionTargetKeyParseError>()(
  "VcsActionTargetKeyParseError",
  {
    keyLength: Schema.Number,
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `Invalid source control action target key (${this.keyLength} characters).`;
  }
}

export const VcsActionExecutionError = Schema.Union([
  VcsActionRemoteFailureError,
  VcsActionMissingTerminalEventError,
]);
export type VcsActionExecutionError = typeof VcsActionExecutionError.Type;

export const EMPTY_VCS_ACTION_STATE = Object.freeze<VcsActionState>({
  isRunning: false,
  operation: null,
  actionId: null,
  action: null,
  currentLabel: null,
  currentPhaseLabel: null,
  hookName: null,
  lastOutputLine: null,
  phaseStartedAtMs: null,
  hookStartedAtMs: null,
  error: null,
});

const nowMs = (): number => DateTime.toEpochMillis(DateTime.nowUnsafe());
let nextLocalActionId = 0;
const decodeVcsActionTargetKey = Schema.decodeUnknownSync(
  Schema.Tuple([EnvironmentId, Schema.String]),
);

const vcsActionStateAtom = Atom.family((key: string) => {
  return Atom.make(EMPTY_VCS_ACTION_STATE).pipe(
    Atom.keepAlive,
    Atom.withLabel(`vcs-action:${key}`),
  );
});

const EMPTY_VCS_ACTION_ATOM = Atom.make(EMPTY_VCS_ACTION_STATE).pipe(
  Atom.keepAlive,
  Atom.withLabel("vcs-action:null"),
);

function getVcsActionTargetKey(target: VcsActionTarget): string | null {
  if (target.environmentId === null || target.cwd === null) {
    return null;
  }
  return JSON.stringify([target.environmentId, target.cwd]);
}

export function parseVcsActionTargetKey(key: string): ResolvedVcsActionTarget {
  try {
    const [environmentId, cwd] = decodeVcsActionTargetKey(JSON.parse(key));
    return { environmentId, cwd };
  } catch (cause) {
    throw new VcsActionTargetKeyParseError({ keyLength: key.length, cause });
  }
}

function getVcsActionStateAtom(target: VcsActionTarget) {
  const key = getVcsActionTargetKey(target);
  return key === null ? EMPTY_VCS_ACTION_ATOM : vcsActionStateAtom(key);
}

function createLocalActionId(): string {
  nextLocalActionId += 1;
  return `local-vcs-action:${nextLocalActionId}`;
}

export function beginVcsActionState(
  input: BeginVcsActionInput,
): VcsActionState & { readonly actionId: string } {
  const actionId = input.actionId ?? createLocalActionId();
  const startedAt = nowMs();
  return {
    ...EMPTY_VCS_ACTION_STATE,
    isRunning: true,
    operation: input.operation,
    actionId,
    currentLabel: input.label,
    currentPhaseLabel: input.label,
    phaseStartedAtMs: startedAt,
  };
}

function failVcsActionState(
  operation: VcsActionOperation,
  actionId: string,
  error: unknown,
): VcsActionState {
  return {
    ...EMPTY_VCS_ACTION_STATE,
    operation,
    actionId,
    error: error instanceof Error ? error.message : "Source control action failed.",
  };
}

export function createVcsActionTransportId(
  target: ResolvedVcsActionTarget,
  actionId: string,
): string {
  const targetKey = JSON.stringify([target.environmentId, target.cwd]);
  return `${targetKey.length}:${targetKey}${actionId}`;
}

export function normalizeVcsActionProgressEvent(
  target: ResolvedVcsActionTarget,
  transportActionId: string,
  actionId: string,
  event: GitActionProgressEvent,
): GitActionProgressEvent | null {
  if (event.actionId !== transportActionId || event.cwd !== target.cwd) {
    return null;
  }
  return {
    ...event,
    actionId,
  };
}

export function consumeVcsActionProgress<E, R>(
  stream: Stream.Stream<GitActionProgressEvent, E, R>,
  input: {
    readonly target: ResolvedVcsActionTarget;
    readonly transportActionId: string;
    readonly actionId: string;
    readonly action: GitStackedAction;
    readonly onProgress: (event: GitActionProgressEvent) => Effect.Effect<void>;
  },
): Effect.Effect<GitRunStackedActionResult, E | VcsActionExecutionError, R> {
  return Effect.suspend(() => {
    let terminalEvent: GitActionProgressEvent | null = null;
    return stream.pipe(
      Stream.runForEach((event) => {
        const normalized = normalizeVcsActionProgressEvent(
          input.target,
          input.transportActionId,
          input.actionId,
          event,
        );
        if (normalized === null) {
          return Effect.void;
        }
        if (normalized.kind === "action_finished" || normalized.kind === "action_failed") {
          terminalEvent = normalized;
        }
        return input.onProgress(normalized);
      }),
      Effect.flatMap(() => {
        if (terminalEvent?.kind === "action_finished") {
          return Effect.succeed(terminalEvent.result);
        }
        if (terminalEvent?.kind === "action_failed") {
          return Effect.fail<VcsActionExecutionError>(
            new VcsActionRemoteFailureError({
              actionId: input.actionId,
              transportActionId: input.transportActionId,
              action: terminalEvent.action,
              environmentId: input.target.environmentId,
              cwd: input.target.cwd,
              phase: terminalEvent.phase,
              remoteMessageLength: terminalEvent.message.length,
            }),
          );
        }
        return Effect.fail<VcsActionExecutionError>(
          new VcsActionMissingTerminalEventError({
            actionId: input.actionId,
            transportActionId: input.transportActionId,
            action: input.action,
            environmentId: input.target.environmentId,
            cwd: input.target.cwd,
          }),
        );
      }),
    );
  });
}

export function applyVcsActionProgressEvent(
  current: VcsActionState,
  event: GitActionProgressEvent,
): VcsActionState {
  if (current.actionId !== event.actionId) {
    return current;
  }
  const now = nowMs();

  switch (event.kind) {
    case "action_started":
      return {
        ...current,
        isRunning: true,
        actionId: event.actionId,
        action: event.action,
        operation: "run_change_request",
        phaseStartedAtMs: now,
        hookStartedAtMs: null,
        hookName: null,
        lastOutputLine: null,
        error: null,
      };
    case "phase_started":
      return {
        ...current,
        isRunning: true,
        actionId: event.actionId,
        action: event.action,
        operation: "run_change_request",
        currentLabel: event.label,
        currentPhaseLabel: event.label,
        phaseStartedAtMs: now,
        hookStartedAtMs: null,
        hookName: null,
        lastOutputLine: null,
        error: null,
      };
    case "hook_started":
      return {
        ...current,
        isRunning: true,
        actionId: event.actionId,
        action: event.action,
        operation: "run_change_request",
        currentLabel: `Running ${event.hookName}...`,
        hookName: event.hookName,
        hookStartedAtMs: now,
        lastOutputLine: null,
        error: null,
      };
    case "hook_output":
      return {
        ...current,
        isRunning: true,
        actionId: event.actionId,
        action: event.action,
        operation: "run_change_request",
        lastOutputLine: event.text,
        error: null,
      };
    case "hook_finished":
      return {
        ...current,
        isRunning: true,
        actionId: event.actionId,
        action: event.action,
        operation: "run_change_request",
        currentLabel: current.currentPhaseLabel,
        hookName: null,
        hookStartedAtMs: null,
        lastOutputLine: null,
        error: null,
      };
    case "action_finished":
      return {
        ...current,
        isRunning: true,
        actionId: event.actionId,
        action: event.action,
        operation: "run_change_request",
        error: null,
      };
    case "action_failed":
      return {
        ...current,
        isRunning: true,
        actionId: event.actionId,
        action: event.action,
        operation: "run_change_request",
        error: event.message,
      };
  }
}

export function createVcsActionManager<R, E>(
  runtime: Atom.AtomRuntime<EnvironmentRegistry | Persistence.EnvironmentCacheStore | R, E>,
) {
  const runStackedActionCommands = new Map<
    string,
    AtomCommand<RunVcsStackedActionInput, GitRunStackedActionResult, unknown>
  >();
  const getRunStackedActionCommand = (requestedTarget: VcsActionTarget) => {
    const targetKey = getVcsActionTargetKey(requestedTarget);
    const commandKey =
      targetKey ??
      JSON.stringify([
        "vcs-action-target:unavailable",
        requestedTarget.environmentId,
        requestedTarget.cwd,
      ]);
    const existing = runStackedActionCommands.get(commandKey);
    if (existing !== undefined) {
      return existing;
    }
    const target = targetKey === null ? null : parseVcsActionTargetKey(targetKey);
    const stateAtom = targetKey === null ? EMPTY_VCS_ACTION_ATOM : vcsActionStateAtom(targetKey);
    const command = createRuntimeCommand<
      EnvironmentRegistry | Persistence.EnvironmentCacheStore | R,
      E,
      RunVcsStackedActionInput,
      GitRunStackedActionResult,
      unknown
    >(runtime, {
      label: `vcs-action:run-stacked:${commandKey}`,
      scheduler: vcsCommandScheduler,
      concurrency: { mode: "serial", key: () => commandKey },
      execute: Effect.fn("VcsAction.runStackedAction")(function* (
        input: RunVcsStackedActionInput,
        registry,
      ) {
        if (target === null) {
          return yield* new VcsActionUnavailableError({
            operation: "run_change_request",
            environmentId: requestedTarget.environmentId,
            cwd: requestedTarget.cwd,
          });
        }
        const transportActionId = createVcsActionTransportId(target, input.actionId);
        registry.set(
          stateAtom,
          beginVcsActionState({
            operation: "run_change_request",
            label: "Running source control action",
            actionId: input.actionId,
          }),
        );

        const rpcInput: GitRunStackedActionInput = {
          actionId: transportActionId,
          cwd: target.cwd,
          action: input.action,
          ...(input.commitMessage ? { commitMessage: input.commitMessage } : {}),
          ...(input.featureBranch ? { featureBranch: true } : {}),
          ...(input.filePaths?.length ? { filePaths: [...input.filePaths] } : {}),
          ...(input.threadId !== undefined ? { threadId: input.threadId } : {}),
          ...(input.projectId !== undefined ? { projectId: input.projectId } : {}),
        };
        const clearOwnedState = Effect.sync(() => {
          const current = registry.get(stateAtom);
          if (current.actionId === input.actionId) {
            registry.set(stateAtom, EMPTY_VCS_ACTION_STATE);
          }
        });
        return yield* consumeVcsActionProgress(
          runStreamInEnvironment(
            target.environmentId,
            runStreamGuarded(WS_METHODS.gitRunStackedAction, rpcInput),
          ),
          {
            target,
            transportActionId,
            actionId: input.actionId,
            action: input.action,
            onProgress: (event) =>
              Effect.sync(() => {
                const current = registry.get(stateAtom);
                if (current.actionId !== input.actionId) {
                  return;
                }
                registry.set(stateAtom, applyVcsActionProgressEvent(current, event));
                if (input.onProgress !== undefined) {
                  try {
                    input.onProgress(event);
                  } catch {}
                }
              }),
          },
        ).pipe(
          Effect.provideService(RpcPermissionGuard, {
            authorize: (id, method, payload) =>
              createCommandPermissions(runtime, method).authorize(registry, id, payload),
          }),
          Effect.ensuring(invalidateCachedVcsRefs(registry, target)),
          Effect.tap(() => clearOwnedState),
          Effect.tapError((error) =>
            Effect.sync(() => {
              const current = registry.get(stateAtom);
              if (current.actionId === input.actionId && current.isRunning) {
                registry.set(
                  stateAtom,
                  failVcsActionState("run_change_request", input.actionId, error),
                );
              }
            }),
          ),
          Effect.onInterrupt(() => clearOwnedState),
        );
      }),
    });
    runStackedActionCommands.set(commandKey, command);
    return command;
  };

  const setState = (
    registry: AtomRegistry.AtomRegistry,
    target: VcsActionTarget,
    update: (current: VcsActionState) => VcsActionState,
  ): void => {
    const key = getVcsActionTargetKey(target);
    if (key === null) {
      return;
    }
    const stateAtom = vcsActionStateAtom(key);
    registry.set(stateAtom, update(registry.get(stateAtom)));
  };

  return {
    stateAtom: getVcsActionStateAtom,
    runStackedAction: (target: VcsActionTarget) => getRunStackedActionCommand(target),
    track: async <A, E>(
      registry: AtomRegistry.AtomRegistry,
      target: VcsActionTarget,
      input: BeginVcsActionInput,
      action: () => Promise<AtomCommandResult<A, E>>,
    ): Promise<AtomCommandResult<A, E | VcsActionUnavailableError>> => {
      const key = getVcsActionTargetKey(target);
      if (key === null) {
        return AsyncResult.failure<never, VcsActionUnavailableError>(
          Cause.fail(
            new VcsActionUnavailableError({
              operation: input.operation,
              environmentId: target.environmentId,
              cwd: target.cwd,
            }),
          ),
        );
      }
      const stateAtom = vcsActionStateAtom(key);
      const next = beginVcsActionState(input);
      registry.set(stateAtom, next);
      const result = await action();
      const current = registry.get(stateAtom);
      if (current.actionId !== next.actionId) {
        return result;
      }
      if (AsyncResult.isSuccess(result) || Cause.hasInterruptsOnly(result.cause)) {
        registry.set(stateAtom, EMPTY_VCS_ACTION_STATE);
      } else {
        if (registry.get(stateAtom).actionId === next.actionId) {
          registry.set(
            stateAtom,
            failVcsActionState(input.operation, next.actionId, Cause.squash(result.cause)),
          );
        }
      }
      return result;
    },
    resetError: (
      registry: AtomRegistry.AtomRegistry,
      target: VcsActionTarget,
      operation: VcsActionOperation,
    ): void => {
      setState(registry, target, (current) =>
        !current.isRunning && current.operation === operation ? EMPTY_VCS_ACTION_STATE : current,
      );
    },
  };
}