sailfork / t3code-github / apps/ mobile/ src/ features/ terminal/ terminalMenu.ts

import { type KnownTerminalSession } from "@t3tools/client-runtime/state/terminal";
import { DEFAULT_TERMINAL_ID, type ProjectScript } from "@t3tools/contracts";
import { nextTerminalId, resolveTerminalSessionLabel } from "@t3tools/shared/terminalLabels";
import * as Arr from "effect/Array";
import * as Order from "effect/Order";

export { resolveTerminalSessionLabel } from "@t3tools/shared/terminalLabels";

export interface TerminalMenuSession {
  readonly terminalId: string;
  readonly cwd: string | null;
  readonly status: "starting" | "running" | "exited" | "error" | "closed";
  readonly hasRunningSubprocess: boolean;
  readonly displayLabel: string;
  readonly updatedAt: string | null;
}

const terminalMenuSessionOrder = Order.make<TerminalMenuSession>((left, right) => {
  const comparison = left.terminalId.localeCompare(right.terminalId, undefined, { numeric: true });
  if (comparison === 0) {
    return 0;
  }
  return comparison < 0 ? -1 : 1;
});

export function basename(input: string | null): string | null {
  if (!input) {
    return null;
  }

  const normalized = input.replace(/\/+$/, "");
  if (normalized.length === 0) {
    return "/";
  }

  const segments = normalized.split("/");
  return segments[segments.length - 1] ?? normalized;
}

export function getTerminalStatusLabel(input: {
  readonly status: TerminalMenuSession["status"];
  readonly hasRunningSubprocess?: boolean;
}): string {
  if (input.status === "running") {
    return input.hasRunningSubprocess ? "Task running" : "Ready";
  }
  if (input.status === "starting") {
    return "Starting";
  }
  if (input.status === "exited") {
    return "Exited";
  }
  if (input.status === "error") {
    return "Error";
  }

  return "Not started";
}

/** Count the mounted terminal before sessions load, or new-terminal navigation may replace it with itself. */
export function nextOpenTerminalId(input: {
  readonly listedTerminalIds: ReadonlyArray<string>;
  readonly activeRouteTerminalId?: string | null;
  readonly uniqueSuffix?: string;
}): string {
  const listed = input.listedTerminalIds.filter((id) => id.trim().length > 0);
  const routeId = input.activeRouteTerminalId?.trim() ? input.activeRouteTerminalId : null;

  if (!routeId || listed.includes(routeId)) {
    return nextTerminalId(listed, input.uniqueSuffix);
  }

  return nextTerminalId([...listed, routeId], input.uniqueSuffix);
}

export function buildTerminalMenuSessions(input: {
  readonly knownSessions: ReadonlyArray<KnownTerminalSession>;
  readonly workspaceRoot: string | null;
  readonly currentSession?: TerminalMenuSession | null;
}): ReadonlyArray<TerminalMenuSession> {
  const sessionsById = new Map<string, TerminalMenuSession>();

  for (const session of input.knownSessions) {
    if (
      session.state.status !== "running" &&
      session.state.status !== "starting" &&
      session.target.terminalId !== input.currentSession?.terminalId
    ) {
      continue;
    }

    sessionsById.set(session.target.terminalId, {
      terminalId: session.target.terminalId,
      cwd: session.state.summary?.cwd ?? input.workspaceRoot,
      status: session.state.status,
      hasRunningSubprocess: session.state.hasRunningSubprocess,
      displayLabel: resolveTerminalSessionLabel(session.target.terminalId, session.state.summary),
      updatedAt: session.state.updatedAt,
    });
  }

  if (input.currentSession && !sessionsById.has(input.currentSession.terminalId)) {
    sessionsById.set(input.currentSession.terminalId, input.currentSession);
  }

  return Arr.sort(sessionsById.values(), terminalMenuSessionOrder);
}

/** Returns null when no other live session remains; dismiss the terminal UI. */
export function previousLiveTerminalId(input: {
  readonly sessions: ReadonlyArray<TerminalMenuSession>;
  readonly exitedTerminalId: string;
}): string | null {
  const live = Arr.sort(
    input.sessions.filter(
      (session) =>
        session.terminalId !== input.exitedTerminalId &&
        (session.status === "running" || session.status === "starting"),
    ),
    terminalMenuSessionOrder,
  );
  if (live.length === 0) {
    return null;
  }

  const below = live.filter(
    (session) =>
      session.terminalId.localeCompare(input.exitedTerminalId, undefined, { numeric: true }) < 0,
  );
  return (below[below.length - 1] ?? live[0])?.terminalId ?? null;
}

export function resolveProjectScriptTerminalId(input: {
  readonly existingTerminalIds: ReadonlyArray<string>;
  readonly hasRunningTerminal: boolean;
  readonly uniqueSuffix?: string;
}): string {
  if (!input.hasRunningTerminal && input.uniqueSuffix === undefined) {
    return DEFAULT_TERMINAL_ID;
  }

  return nextTerminalId(input.existingTerminalIds, input.uniqueSuffix);
}

export function projectScriptMenuIcon(icon: ProjectScript["icon"]) {
  if (icon === "test") return "flask";
  if (icon === "lint") return "checklist";
  if (icon === "configure") return "wrench.and.screwdriver";
  if (icon === "build") return "hammer";
  if (icon === "debug") return "ladybug";
  return "play";
}