@codemation/next-host 0.0.1

package/src/features/workflows/lib/realtime/realtimeApi.ts

@@ -0,0 +1,78 @@
+import type { CredentialTypeDefinition } from "@codemation/core/browser";
+import type {
+  CredentialInstanceDto,
+  CredentialInstanceWithSecretsDto,
+  WorkflowCredentialHealthDto,
+} from "@codemation/host-src/application/contracts/CredentialContractsRegistry";
+import {
+  withUserAccountLoginMethodsDefaults,
+  type UserAccountDto,
+} from "@codemation/host-src/application/contracts/userDirectoryContracts.types";
+import type { WorkflowDto, WorkflowSummary } from "@codemation/host-src/application/contracts/WorkflowViewContracts";
+import { ApiPaths } from "@codemation/host-src/presentation/http/ApiPaths";
+
+import { codemationApiClient } from "../../../../api/CodemationApiClient";
+
+import type { PersistedRunState, RunSummary, WorkflowDebuggerOverlayState } from "./realtimeDomainTypes";
+
+export async function fetchWorkflows(): Promise<ReadonlyArray<WorkflowSummary>> {
+  return await codemationApiClient.getJson<ReadonlyArray<WorkflowSummary>>(ApiPaths.workflows());
+}
+
+export async function fetchWorkflow(workflowId: string): Promise<WorkflowDto> {
+  return await codemationApiClient.getJson<WorkflowDto>(ApiPaths.workflow(workflowId));
+}
+
+export async function patchWorkflowActivation(
+  workflowId: string,
+  active: boolean,
+): Promise<Readonly<{ active: boolean }>> {
+  return await codemationApiClient.patchJson<Readonly<{ active: boolean }>>(ApiPaths.workflowActivation(workflowId), {
+    active,
+  });
+}
+
+export async function fetchWorkflowRuns(workflowId: string): Promise<ReadonlyArray<RunSummary>> {
+  return await codemationApiClient.getJson<ReadonlyArray<RunSummary>>(ApiPaths.workflowRuns(workflowId));
+}
+
+export async function fetchWorkflowDebuggerOverlay(workflowId: string): Promise<WorkflowDebuggerOverlayState> {
+  return await codemationApiClient.getJson<WorkflowDebuggerOverlayState>(ApiPaths.workflowDebuggerOverlay(workflowId));
+}
+
+export async function fetchRun(
+  runId: string,
+  options?: Readonly<{ signal?: AbortSignal }>,
+): Promise<PersistedRunState> {
+  const init: RequestInit | undefined = options?.signal ? { signal: options.signal } : undefined;
+  return await codemationApiClient.getJson<PersistedRunState>(ApiPaths.runState(runId), init);
+}
+
+export async function fetchCredentialTypes(): Promise<ReadonlyArray<CredentialTypeDefinition>> {
+  return await codemationApiClient.getJson<ReadonlyArray<CredentialTypeDefinition>>(ApiPaths.credentialTypes());
+}
+
+export async function fetchCredentialFieldEnvStatus(): Promise<Readonly<Record<string, boolean>>> {
+  return await codemationApiClient.getJson<Readonly<Record<string, boolean>>>(ApiPaths.credentialsEnvStatus());
+}
+
+export async function fetchCredentialInstances(): Promise<ReadonlyArray<CredentialInstanceDto>> {
+  return await codemationApiClient.getJson<ReadonlyArray<CredentialInstanceDto>>(ApiPaths.credentialInstances());
+}
+
+export async function fetchCredentialInstanceWithSecrets(
+  instanceId: string,
+): Promise<CredentialInstanceWithSecretsDto> {
+  return await codemationApiClient.getJson<CredentialInstanceWithSecretsDto>(
+    ApiPaths.credentialInstance(instanceId, true),
+  );
+}
+
+export async function fetchWorkflowCredentialHealth(workflowId: string): Promise<WorkflowCredentialHealthDto> {
+  return await codemationApiClient.getJson<WorkflowCredentialHealthDto>(ApiPaths.workflowCredentialHealth(workflowId));
+}
+
+export async function fetchUserAccounts(): Promise<ReadonlyArray<UserAccountDto>> {
+  const rows = await codemationApiClient.getJson<ReadonlyArray<UserAccountDto>>(ApiPaths.users());
+  return rows.map((u) => withUserAccountLoginMethodsDefaults(u));
+}

package/src/features/workflows/lib/realtime/realtimeClientBridge.ts

@@ -0,0 +1,52 @@
+import type { WorkflowEvent } from "./realtimeDomainTypes";
+
+export type RealtimeServerMessage =
+  | Readonly<{ kind: "ready" }>
+  | Readonly<{ kind: "subscribed"; roomId: string }>
+  | Readonly<{ kind: "unsubscribed"; roomId: string }>
+  | Readonly<{ kind: "workflowChanged"; workflowId: string }>
+  | Readonly<{ kind: "devBuildStarted"; workflowId: string; buildVersion?: string }>
+  | Readonly<{ kind: "devBuildCompleted"; workflowId: string; buildVersion: string }>
+  | Readonly<{ kind: "devBuildFailed"; workflowId: string; message: string }>
+  | Readonly<{ kind: "event"; event: WorkflowEvent }>
+  | Readonly<{ kind: "error"; message: string }>;
+
+export type RealtimeClientMessage =
+  | Readonly<{ kind: "subscribe"; roomId: string }>
+  | Readonly<{ kind: "unsubscribe"; roomId: string }>;
+
+export const minimumRealtimeActiveVisibilityMs = 300;
+
+export const persistentRealtimeDisconnectWarningDelayMs = 5000;
+
+export type RetainWorkflowSubscription = (workflowId: string) => () => void;
+
+export type RealtimeBridgeState = {
+  retainWorkflowSubscription: RetainWorkflowSubscription | null;
+  listeners: Set<() => void>;
+};
+
+type RealtimeBridgeGlobal = typeof globalThis & {
+  __codemationRealtimeBridge__?: RealtimeBridgeState;
+};
+
+export const RealtimeReadyState = {
+  UNINSTANTIATED: -1,
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3,
+} as const;
+
+export type RealtimeReadyValue = (typeof RealtimeReadyState)[keyof typeof RealtimeReadyState];
+
+export function getRealtimeBridge(): RealtimeBridgeState {
+  const realtimeGlobal = globalThis as RealtimeBridgeGlobal;
+  if (!realtimeGlobal.__codemationRealtimeBridge__) {
+    realtimeGlobal.__codemationRealtimeBridge__ = {
+      retainWorkflowSubscription: null,
+      listeners: new Set(),
+    };
+  }
+  return realtimeGlobal.__codemationRealtimeBridge__;
+}

package/src/features/workflows/lib/realtime/realtimeDomainTypes.ts

@@ -0,0 +1,191 @@
+import type { Item as WorkflowItem, JsonValue } from "@codemation/core/browser";
+import type { WorkflowDto } from "@codemation/host-src/application/contracts/WorkflowViewContracts";
+
+export type Item = WorkflowItem;
+export type Items = ReadonlyArray<Item>;
+
+export type RunExecutionOptions = Readonly<{
+  localOnly?: boolean;
+  webhook?: boolean;
+  mode?: "manual" | "debug";
+  sourceWorkflowId?: string;
+  sourceRunId?: string;
+  derivedFromRunId?: string;
+  isMutable?: boolean;
+}>;
+
+export type PersistedWorkflowConnection = Readonly<{
+  parentNodeId: string;
+  connectionName: string;
+  childNodeIds: ReadonlyArray<string>;
+}>;
+
+export type PersistedWorkflowSnapshot = Readonly<{
+  id: string;
+  name: string;
+  workflowErrorHandlerConfigured?: boolean;
+  connections?: ReadonlyArray<PersistedWorkflowConnection>;
+  nodes: ReadonlyArray<
+    Readonly<{
+      id: string;
+      kind: string;
+      name?: string;
+      nodeTokenId: string;
+      configTokenId: string;
+      tokenName?: string;
+      configTokenName?: string;
+      config: unknown;
+    }>
+  >;
+  edges: WorkflowDto["edges"];
+}>;
+
+export type PersistedMutableNodeState = Readonly<{
+  pinnedOutputsByPort?: Readonly<Record<string, Items>>;
+  lastDebugInput?: Items;
+}>;
+
+export type PersistedMutableRunState = Readonly<{
+  nodesById: Readonly<Record<string, PersistedMutableNodeState>>;
+}>;
+
+export type ParentExecutionRef = Readonly<{ runId: string; workflowId: string; nodeId: string }>;
+
+export type RunSummary = Readonly<{
+  runId: string;
+  workflowId: string;
+  startedAt: string;
+  status: string;
+  finishedAt?: string;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+}>;
+
+export type NodeExecutionSnapshot = Readonly<{
+  runId: string;
+  workflowId: string;
+  nodeId: string;
+  activationId?: string;
+  parent?: ParentExecutionRef;
+  status: "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
+  usedPinnedOutput?: boolean;
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+  updatedAt: string;
+  inputsByPort?: Readonly<Record<string, Items>>;
+  outputs?: Readonly<Record<string, Items>>;
+  error?: Readonly<{ message: string; name?: string; stack?: string }>;
+}>;
+
+/** One LLM/tool invocation under an agent; mirrors core {@link ConnectionInvocationRecord}. */
+export type ConnectionInvocationRecord = Readonly<{
+  invocationId: string;
+  runId: string;
+  workflowId: string;
+  connectionNodeId: string;
+  parentAgentNodeId: string;
+  parentAgentActivationId: string;
+  status: NodeExecutionSnapshot["status"];
+  managedInput?: JsonValue;
+  managedOutput?: JsonValue;
+  error?: NodeExecutionSnapshot["error"];
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+  updatedAt: string;
+}>;
+
+export type PendingNodeExecution = Readonly<{
+  runId: string;
+  activationId: string;
+  workflowId: string;
+  nodeId: string;
+  itemsIn: number;
+  inputsByPort: Readonly<Record<string, Items>>;
+  receiptId: string;
+  queue?: string;
+  batchId?: string;
+  enqueuedAt: string;
+}>;
+
+export type PersistedRunState = Readonly<{
+  runId: string;
+  workflowId: string;
+  startedAt: string;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  workflowSnapshot?: PersistedWorkflowSnapshot;
+  mutableState?: PersistedMutableRunState;
+  status: "running" | "pending" | "completed" | "failed";
+  pending?: PendingNodeExecution;
+  queue: ReadonlyArray<unknown>;
+  outputsByNode: Readonly<Record<string, Readonly<Record<string, Items>>>>;
+  nodeSnapshotsByNodeId: Readonly<Record<string, NodeExecutionSnapshot>>;
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+}>;
+
+export type RunCurrentState = Readonly<{
+  outputsByNode: PersistedRunState["outputsByNode"];
+  nodeSnapshotsByNodeId: PersistedRunState["nodeSnapshotsByNodeId"];
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+  mutableState?: PersistedMutableRunState;
+}>;
+
+export type WorkflowDebuggerOverlayState = Readonly<{
+  workflowId: string;
+  updatedAt: string;
+  copiedFromRunId?: string;
+  currentState: RunCurrentState;
+}>;
+
+export type WorkflowDevBuildState = Readonly<{
+  state: "idle" | "building" | "failed";
+  updatedAt: string;
+  buildVersion?: string;
+  message?: string;
+  awaitingWorkflowRefreshAt?: string;
+}>;
+
+export type WorkflowEvent =
+  | Readonly<{ kind: "runCreated"; runId: string; workflowId: string; parent?: ParentExecutionRef; at: string }>
+  | Readonly<{
+      kind: "runSaved";
+      runId: string;
+      workflowId: string;
+      parent?: ParentExecutionRef;
+      at: string;
+      state: PersistedRunState;
+    }>
+  | Readonly<{
+      kind: "nodeQueued";
+      runId: string;
+      workflowId: string;
+      parent?: ParentExecutionRef;
+      at: string;
+      snapshot: NodeExecutionSnapshot;
+    }>
+  | Readonly<{
+      kind: "nodeStarted";
+      runId: string;
+      workflowId: string;
+      parent?: ParentExecutionRef;
+      at: string;
+      snapshot: NodeExecutionSnapshot;
+    }>
+  | Readonly<{
+      kind: "nodeCompleted";
+      runId: string;
+      workflowId: string;
+      parent?: ParentExecutionRef;
+      at: string;
+      snapshot: NodeExecutionSnapshot;
+    }>
+  | Readonly<{
+      kind: "nodeFailed";
+      runId: string;
+      workflowId: string;
+      parent?: ParentExecutionRef;
+      at: string;
+      snapshot: NodeExecutionSnapshot;
+    }>;

package/src/features/workflows/lib/realtime/realtimeQueryKeys.ts

@@ -0,0 +1,15 @@
+export const workflowsQueryKey = ["workflows"] as const;
+export const workflowQueryKey = (workflowId: string) => ["workflow", workflowId] as const;
+export const workflowRunsQueryKey = (workflowId: string) => ["workflow-runs", workflowId] as const;
+export const workflowDebuggerOverlayQueryKey = (workflowId: string) =>
+  ["workflow-debugger-overlay", workflowId] as const;
+export const workflowDevBuildStateQueryKey = (workflowId: string) => ["workflow-dev-build-state", workflowId] as const;
+export const runQueryKey = (runId: string) => ["run", runId] as const;
+export const credentialTypesQueryKey = ["credential-types"] as const;
+export const credentialFieldEnvStatusQueryKey = ["credential-field-env-status"] as const;
+export const credentialInstancesQueryKey = ["credential-instances"] as const;
+export const credentialInstanceWithSecretsQueryKey = (instanceId: string) =>
+  ["credential-instance-with-secrets", instanceId] as const;
+export const workflowCredentialHealthQueryKey = (workflowId: string) =>
+  ["workflow-credential-health", workflowId] as const;
+export const userAccountsQueryKey = ["user-accounts"] as const;

package/src/features/workflows/lib/realtime/realtimeRunMutations.ts

@@ -0,0 +1,167 @@
+import type { QueryClient } from "@tanstack/react-query";
+
+import { RunFinishedAtFactory } from "@codemation/core/browser";
+
+import type { Items, PersistedRunState, RunSummary, WorkflowEvent } from "./realtimeDomainTypes";
+import { runQueryKey, workflowRunsQueryKey } from "./realtimeQueryKeys";
+
+function countItems(inputsByPort: Readonly<Record<string, Items>> | undefined): number {
+  return Object.values(inputsByPort ?? {}).reduce((sum, items) => sum + items.length, 0);
+}
+
+function createInitialRunState(event: Extract<WorkflowEvent, { kind: "runCreated" }>): PersistedRunState {
+  return {
+    runId: event.runId,
+    workflowId: event.workflowId,
+    startedAt: event.at,
+    parent: event.parent,
+    executionOptions: undefined,
+    workflowSnapshot: undefined,
+    mutableState: undefined,
+    status: "running",
+    pending: undefined,
+    queue: [],
+    outputsByNode: {},
+    nodeSnapshotsByNodeId: {},
+  };
+}
+
+function toRunSummary(state: PersistedRunState): RunSummary {
+  return {
+    runId: state.runId,
+    workflowId: state.workflowId,
+    startedAt: state.startedAt,
+    status: state.status,
+    finishedAt: RunFinishedAtFactory.resolveIso(state),
+    parent: state.parent,
+    executionOptions: state.executionOptions,
+  };
+}
+
+function mergeRunSummaryList(
+  existing: ReadonlyArray<RunSummary> | undefined,
+  summary: RunSummary,
+): ReadonlyArray<RunSummary> {
+  const current = [...(existing ?? [])];
+  const index = current.findIndex((entry) => entry.runId === summary.runId);
+  if (index >= 0) current[index] = summary;
+  else current.unshift(summary);
+  current.sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+  return current;
+}
+
+export function reduceWorkflowEventIntoPersistedRunState(
+  current: PersistedRunState | undefined,
+  event: WorkflowEvent,
+): PersistedRunState {
+  if (event.kind === "runCreated") {
+    return createInitialRunState(event);
+  }
+  if (event.kind === "runSaved") {
+    return event.state;
+  }
+  return mergeSnapshotIntoRunState(
+    current,
+    event as Extract<WorkflowEvent, { kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed" }>,
+  );
+}
+
+function mergeSnapshotIntoRunState(
+  current: PersistedRunState | undefined,
+  event: Extract<WorkflowEvent, { kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed" }>,
+): PersistedRunState {
+  const base =
+    current ??
+    ({
+      runId: event.runId,
+      workflowId: event.workflowId,
+      startedAt: event.at,
+      parent: event.parent,
+      executionOptions: undefined,
+      workflowSnapshot: undefined,
+      mutableState: undefined,
+      status: event.kind === "nodeFailed" ? "failed" : "pending",
+      pending: undefined,
+      queue: [],
+      outputsByNode: {},
+      nodeSnapshotsByNodeId: {},
+    } satisfies PersistedRunState);
+
+  const nextNodeSnapshots = {
+    ...(base.nodeSnapshotsByNodeId ?? {}),
+    [event.snapshot.nodeId]: event.snapshot,
+  };
+  const nextOutputsByNode =
+    event.snapshot.outputs === undefined
+      ? base.outputsByNode
+      : {
+          ...(base.outputsByNode ?? {}),
+          [event.snapshot.nodeId]: event.snapshot.outputs,
+        };
+
+  const nextPending =
+    event.kind === "nodeQueued" || event.kind === "nodeStarted"
+      ? {
+          runId: event.runId,
+          activationId: event.snapshot.activationId ?? `live_${event.snapshot.nodeId}`,
+          workflowId: event.workflowId,
+          nodeId: event.snapshot.nodeId,
+          itemsIn: countItems(event.snapshot.inputsByPort),
+          inputsByPort: event.snapshot.inputsByPort ?? {},
+          receiptId: "live",
+          enqueuedAt: event.snapshot.queuedAt ?? event.at,
+        }
+      : base.pending?.nodeId === event.snapshot.nodeId
+        ? undefined
+        : base.pending;
+  const hasActiveSnapshots = Object.values(nextNodeSnapshots).some(
+    (snapshot) => snapshot.status === "queued" || snapshot.status === "running",
+  );
+  const nextStatus =
+    event.kind === "nodeFailed"
+      ? "failed"
+      : event.kind === "nodeCompleted" && !nextPending && !hasActiveSnapshots
+        ? "completed"
+        : event.kind === "nodeCompleted"
+          ? base.status
+          : "pending";
+
+  return {
+    ...base,
+    parent: base.parent ?? event.parent,
+    status: nextStatus,
+    pending: nextPending,
+    outputsByNode: nextOutputsByNode,
+    nodeSnapshotsByNodeId: nextNodeSnapshots,
+  };
+}
+
+export function applyWorkflowEvent(queryClient: QueryClient, event: WorkflowEvent): void {
+  const key = runQueryKey(event.runId);
+  const runsKey = workflowRunsQueryKey(event.workflowId);
+
+  if (event.kind === "runCreated") {
+    const next = reduceWorkflowEventIntoPersistedRunState(undefined, event);
+    queryClient.setQueryData(key, next);
+    queryClient.setQueryData(runsKey, (existing: ReadonlyArray<RunSummary> | undefined) =>
+      mergeRunSummaryList(existing, toRunSummary(next)),
+    );
+    return;
+  }
+
+  if (event.kind === "runSaved") {
+    const next = reduceWorkflowEventIntoPersistedRunState(undefined, event);
+    queryClient.setQueryData(key, next);
+    queryClient.setQueryData(runsKey, (existing: ReadonlyArray<RunSummary> | undefined) =>
+      mergeRunSummaryList(existing, toRunSummary(next)),
+    );
+    return;
+  }
+
+  const current = queryClient.getQueryData<PersistedRunState>(key);
+  const nextRunState = reduceWorkflowEventIntoPersistedRunState(current, event);
+  queryClient.setQueryData(key, nextRunState);
+  queryClient.setQueryData(runsKey, (existing: ReadonlyArray<RunSummary> | undefined) =>
+    mergeRunSummaryList(existing, toRunSummary(nextRunState)),
+  );
+}

package/src/features/workflows/lib/realtime/workflowTypes.ts

@@ -0,0 +1,5 @@
+export type {
+  WorkflowDto,
+  WorkflowEdgeDto,
+  WorkflowNodeDto,
+} from "@codemation/host-src/application/contracts/WorkflowViewContracts";