terminal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86// Workspace-scoped terminal selection is independent of the views and kernel effects.
// The state layer gives each activation its own session cache and creation guards.
import * as Context from "effect/Context";
import * as Layer from "effect/Layer";
import * as z from "zod";
import type { EffectClient } from "convergence/effect";
import type * as Fiber from "effect/Fiber";
import type { Terminal, ViewHandle, Workspace } from "convergence";
import type { Tabs } from "../tabs/contract.ts";

export interface State {
  terminals: readonly Terminal[];
  activeByWorkspace: Record<string, string | null>;
  paths: Record<string, string>;
  menu: string | null;
  renaming: string | null;
  creating: Set<string>;
  ready: boolean;
  flyOut?: ViewHandle;
  rail?: ViewHandle;
  // The convergence/tabs client while its provider runs, the tab it last
  // announced, and the fiber following it.
  tabs: EffectClient<typeof Tabs> | undefined;
  activeTab: { kind: string; path: unknown } | null;
  follow: Fiber.Fiber<void> | undefined;
}

export interface State {
  terminals: readonly Terminal[];
  activeByWorkspace: Record<string, string | null>;
  paths: Record<string, string>;
  menu: string | null;
  renaming: string | null;
  creating: Set<string>;
  ready: boolean;
  flyOut?: ViewHandle;
  rail?: ViewHandle;
}

export class TerminalState extends Context.Service<TerminalState, State>()("terminal/State") {
  static readonly layer = Layer.sync(TerminalState, () => ({
    terminals: [],
    activeByWorkspace: {},
    paths: {},
    menu: null,
    renaming: null,
    creating: new Set<string>(),
    ready: false,
    tabs: undefined,
    activeTab: null,
    follow: undefined,
  }));
}

export function forWorkspace(terminals: readonly Terminal[], workspaceId: string | null | undefined): Terminal[] {
  return terminals.filter((terminal) => terminal.workspaceId === workspaceId);
}

export function activeTerminal(
  state: Pick<State, "terminals" | "activeByWorkspace">,
  workspaceId: string | undefined,
): Terminal | null {
  const mine = forWorkspace(state.terminals, workspaceId);
  return (
    mine.find((terminal) => terminal.id === state.activeByWorkspace[String(workspaceId)]) ??
    mine[mine.length - 1] ??
    null
  );
}

export function nextTerminal(terminals: readonly Terminal[], terminal: Terminal): Terminal | null {
  const mine = forWorkspace(terminals, terminal.workspaceId);
  const index = mine.findIndex((session) => session.id === terminal.id);
  return mine[index + 1] ?? mine[index - 1] ?? null;
}

// The detail pane owns the payload; this plugin only compares its identity and tests its truthiness.
const tab = z.object({ kind: z.string(), path: z.unknown().optional() });
export function terminalInPane(active: unknown): unknown {
  const parsed = tab.safeParse(active);
  return parsed.success && parsed.data.kind === "terminal" ? parsed.data.path : null;
}

export function pathsByWorkspace(workspaces: readonly Workspace[]): Record<string, string> {
  return Object.fromEntries(workspaces.map((workspace) => [workspace.id, workspace.path]));
}