[Init] Initial commit - NetMesh terminal manager

domain/hostConnectScripts.ts

@@ -0,0 +1,456 @@
+import type { Host, Snippet } from './models';
+import { isScriptSnippet } from './snippetScript.ts';
+import {
+  getScriptsLinkedToHost,
+  linkHostToScript,
+  snippetTargetsHostExplicitly,
+  snippetTargetsHostGroup,
+  unlinkHostFromScripts,
+} from './snippetTargets.ts';
+import { sortByVaultOrder } from './vaultOrder.ts';
+
+function isOnConnectScript(snippet: Snippet): boolean {
+  return isScriptSnippet(snippet) && snippet.trigger === 'onConnect' && Boolean(snippet.id);
+}
+
+function scriptById(snippets: Snippet[], scriptId: string): Snippet | undefined {
+  return snippets.find((snippet) => snippet.id === scriptId && isScriptSnippet(snippet));
+}
+
+function pruneConnectScriptIds(ids: string[], snippets: Snippet[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const id of ids) {
+    if (!id || seen.has(id)) continue;
+    const snippet = scriptById(snippets, id);
+    if (!snippet || !isOnConnectScript(snippet)) continue;
+    seen.add(id);
+    result.push(id);
+  }
+  return result;
+}
+
+/**
+ * Draft/edit queue prune: keep any existing script IDs.
+ * Host save promotes non-onConnect scripts via prepareSnippetForHostConnectQueue.
+ */
+function pruneEditableConnectScriptIds(ids: string[], snippets: Snippet[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const id of ids) {
+    if (!id || seen.has(id)) continue;
+    const snippet = scriptById(snippets, id);
+    if (!snippet) continue;
+    seen.add(id);
+    result.push(id);
+  }
+  return result;
+}
+
+/** Global onConnect scripts (targetsAllHosts), sorted by vault order. */
+export function getGlobalConnectScripts(snippets: Snippet[]): Snippet[] {
+  return sortByVaultOrder(
+    snippets.filter(
+      (snippet) => isOnConnectScript(snippet) && Boolean(snippet.targetsAllHosts),
+    ),
+  );
+}
+
+/** Derive initial connectScriptIds from legacy host + snippet bindings. */
+export function migrateHostConnectScriptIds(host: Host, snippets: Snippet[]): string[] {
+  const ordered: string[] = [];
+  const seen = new Set<string>();
+
+  const push = (scriptId?: string) => {
+    if (!scriptId || seen.has(scriptId)) return;
+    const snippet = scriptById(snippets, scriptId);
+    if (!snippet || !isOnConnectScript(snippet)) return;
+    if (!snippetTargetsHostExplicitly(snippet, host.id) && !snippet.targetsAllHosts) return;
+    seen.add(scriptId);
+    ordered.push(scriptId);
+  };
+
+  push(host.loginScriptId);
+
+  for (const snippet of getScriptsLinkedToHost(snippets, host.id)) {
+    if (snippet.trigger === 'onConnect') {
+      push(snippet.id);
+    }
+  }
+
+  for (const snippet of sortByVaultOrder(snippets)) {
+    if (!isOnConnectScript(snippet)) continue;
+    if (snippet.targetsAllHosts) continue;
+    if (!snippetTargetsHostExplicitly(snippet, host.id)) continue;
+    push(snippet.id);
+  }
+
+  return ordered;
+}
+
+/** Effective ordered script IDs for a host (lazy migrate + prune). */
+export function getHostConnectScriptIds(host: Host, snippets: Snippet[]): string[] {
+  if (host.connectScriptIds !== undefined) {
+    return pruneConnectScriptIds(host.connectScriptIds, snippets);
+  }
+  return migrateHostConnectScriptIds(host, snippets);
+}
+
+/**
+ * Host-details draft queue: includes scripts pending promote-to-onConnect on save.
+ * Runtime connect still uses getHostConnectScriptIds (onConnect only).
+ */
+export function getEditableHostConnectScriptIds(host: Host, snippets: Snippet[]): string[] {
+  if (host.connectScriptIds !== undefined) {
+    return pruneEditableConnectScriptIds(host.connectScriptIds, snippets);
+  }
+  return migrateHostConnectScriptIds(host, snippets);
+}
+
+export function ensureHostConnectScriptIds(host: Host, snippets: Snippet[]): Host {
+  if (host.connectScriptIds !== undefined) {
+    const pruned = pruneEditableConnectScriptIds(host.connectScriptIds, snippets);
+    if (pruned.length === host.connectScriptIds.length
+      && pruned.every((id, index) => id === host.connectScriptIds![index])) {
+      return host;
+    }
+    return { ...host, connectScriptIds: pruned };
+  }
+  const migrated = migrateHostConnectScriptIds(host, snippets);
+  return migrated.length > 0 ? { ...host, connectScriptIds: migrated } : host;
+}
+
+/** True when host references connect scripts that are not present in snippets yet. */
+export function hasUnresolvedConnectScriptBindings(host: Host, snippets: Snippet[]): boolean {
+  const candidateIds = new Set<string>();
+  if (host.loginScriptId) candidateIds.add(host.loginScriptId);
+  for (const id of host.connectScriptIds ?? []) {
+    if (id) candidateIds.add(id);
+  }
+  for (const id of candidateIds) {
+    if (!snippets.some((snippet) => snippet.id === id)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Group-scoped onConnect scripts inherited dynamically from the host's current group. */
+export function getGroupConnectScriptsForHost(host: Host, snippets: Snippet[]): Snippet[] {
+  return sortByVaultOrder(
+    snippets.filter(
+      (snippet) => isOnConnectScript(snippet)
+        && !snippet.targetsAllHosts
+        && snippetTargetsHostGroup(snippet, host),
+    ),
+  );
+}
+
+/** Resolve full onConnect run list: global, group-inherited, then host queue. */
+export function resolveConnectScriptsForHost(host: Host, snippets: Snippet[]): Snippet[] {
+  const hostIds = getHostConnectScriptIds(host, snippets);
+  const hostIdSet = new Set(hostIds);
+  const globals = getGlobalConnectScripts(snippets).filter(
+    (snippet) => snippet.id && !hostIdSet.has(snippet.id),
+  );
+  const inheritedIds = new Set(globals.map((snippet) => snippet.id));
+  const groupScripts = getGroupConnectScriptsForHost(host, snippets).filter(
+    (snippet) => snippet.id && !hostIdSet.has(snippet.id) && !inheritedIds.has(snippet.id),
+  );
+  const hostScripts = hostIds
+    .map((id) => scriptById(snippets, id))
+    .filter((snippet): snippet is Snippet => Boolean(snippet));
+  return [...globals, ...groupScripts, ...hostScripts];
+}
+
+/**
+ * Whether connecting this host can run automation that depends on the initial
+ * login output. Missing referenced scripts still count: vault hydration or a
+ * later sync may restore them after the terminal has already started.
+ */
+export function hasHostConnectAutomation(host: Host, snippets: Snippet[]): boolean {
+  return hasUnresolvedConnectScriptBindings(host, snippets)
+    || resolveConnectScriptsForHost(host, snippets).length > 0;
+}
+
+export function shouldUseFreshSshConnectionForAutomation(options: {
+  host: Host;
+  snippets: Snippet[];
+  vaultInitialized: boolean;
+  hasPendingScript?: boolean;
+  connectAutomationConsumed?: boolean;
+}): boolean {
+  return options.hasPendingScript === true
+    || (
+      options.connectAutomationConsumed !== true
+      && (
+        !options.vaultInitialized
+        || hasHostConnectAutomation(options.host, options.snippets)
+      )
+    );
+}
+
+/**
+ * Mark the current connection's automation decision as final once the vault
+ * has hydrated, even when it hydrated to an empty script list. This prevents a
+ * later sync from starting a newly arrived global script against a connection
+ * whose initial login output may already have been skipped.
+ */
+export function shouldMarkConnectAutomationConsumed(options: {
+  allConnectScriptsDone: boolean;
+  vaultInitialized: boolean;
+  hasUnresolvedBindings: boolean;
+}): boolean {
+  return options.allConnectScriptsDone
+    && options.vaultInitialized
+    && !options.hasUnresolvedBindings;
+}
+
+export function appendHostConnectScript(host: Host, scriptId: string, snippets: Snippet[]): Host {
+  const snippet = scriptById(snippets, scriptId);
+  if (!snippet) return host;
+  const current = getEditableHostConnectScriptIds(host, snippets);
+  if (current.includes(scriptId)) {
+    return { ...host, connectScriptIds: current };
+  }
+  return { ...host, connectScriptIds: [...current, scriptId] };
+}
+
+export function removeHostConnectScript(host: Host, scriptId: string, snippets: Snippet[]): Host {
+  const current = getEditableHostConnectScriptIds(host, snippets);
+  const next = current.filter((id) => id !== scriptId);
+  return { ...host, connectScriptIds: next };
+}
+
+export function reorderHostConnectScript(
+  host: Host,
+  draggedScriptId: string,
+  targetScriptId: string,
+  position: 'before' | 'after',
+  snippets: Snippet[],
+): Host {
+  if (draggedScriptId === targetScriptId) return host;
+  const current = [...getEditableHostConnectScriptIds(host, snippets)];
+  const fromIndex = current.indexOf(draggedScriptId);
+  const targetIndex = current.indexOf(targetScriptId);
+  if (fromIndex === -1 || targetIndex === -1) return host;
+
+  current.splice(fromIndex, 1);
+  let insertIndex = current.indexOf(targetScriptId);
+  if (insertIndex === -1) return host;
+  if (position === 'after') insertIndex += 1;
+  current.splice(insertIndex, 0, draggedScriptId);
+  return { ...host, connectScriptIds: current };
+}
+
+export function prepareSnippetForHostConnectQueue(snippet: Snippet, hostId: string): Snippet {
+  if (!isScriptSnippet(snippet)) return snippet;
+  if (snippet.targetsAllHosts) {
+    return snippet.trigger === 'onConnect'
+      ? snippet
+      : { ...snippet, trigger: 'onConnect' };
+  }
+  return {
+    ...linkHostToScript(snippet, hostId),
+    trigger: 'onConnect',
+  };
+}
+
+function connectQueueSnippetNeedsPromote(snippet: Snippet, hostId: string): boolean {
+  if (!isScriptSnippet(snippet)) return false;
+  if (snippet.trigger !== 'onConnect') return true;
+  if (snippet.targetsAllHosts) return false;
+  return !snippetTargetsHostExplicitly(snippet, hostId);
+}
+
+function snippetTargetsEqual(left: Snippet, right: Snippet): boolean {
+  if (Boolean(left.targetsAllHosts) !== Boolean(right.targetsAllHosts)) return false;
+  const leftTargets = left.targets ?? [];
+  const rightTargets = right.targets ?? [];
+  if (leftTargets.length !== rightTargets.length) return false;
+  if (!leftTargets.every((id, index) => id === rightTargets[index])) return false;
+  const leftGroups = left.targetGroups ?? [];
+  const rightGroups = right.targetGroups ?? [];
+  if (leftGroups.length !== rightGroups.length) return false;
+  return leftGroups.every((path, index) => path === rightGroups[index]);
+}
+
+/**
+ * After promoting a script to onConnect, ensure every remaining target host with an
+ * explicit connectScriptIds queue includes it. Hosts without an explicit queue still
+ * pick the script up via migrateHostConnectScriptIds.
+ */
+export function ensureTargetHostsHaveConnectScript(
+  hosts: Host[],
+  snippet: Snippet,
+  snippets: Snippet[],
+  excludeHostId?: string,
+): Host[] {
+  if (!snippet.id || !isScriptSnippet(snippet) || snippet.trigger !== 'onConnect') return hosts;
+  if (snippet.targetsAllHosts) return hosts;
+  const targetIds = new Set(snippet.targets ?? []);
+  if (targetIds.size === 0) return hosts;
+
+  let changed = false;
+  const nextHosts = hosts.map((host) => {
+    if (host.id === excludeHostId) return host;
+    if (!targetIds.has(host.id)) return host;
+    if (host.connectScriptIds === undefined) return host;
+    const updated = appendHostConnectScript(host, snippet.id!, snippets);
+    if (updated !== host) changed = true;
+    return updated;
+  });
+  return changed ? nextHosts : hosts;
+}
+
+export type SyncHostConnectQueueSaveOptions = {
+  /** Snippets snapshot from when the host editor opened (detect concurrent demotion). */
+  baselineSnippets?: Snippet[];
+  /** When provided, promote also syncs other hosts that remain in targets. */
+  hosts?: Host[];
+};
+
+/**
+ * Sync script metadata when saving a host connect queue.
+ * Promotes draft/manual queue entries, preserves global onConnect scripts,
+ * drops concurrently demoted entries, and optionally syncs peer host queues.
+ */
+export function syncSnippetsForHostConnectQueueSave(
+  snippets: Snippet[],
+  hostId: string,
+  previousQueueIds: string[],
+  nextQueueIds: string[],
+  options: SyncHostConnectQueueSaveOptions = {},
+): {
+  snippets: Snippet[];
+  hosts: Host[];
+  connectScriptIds: string[];
+  changed: boolean;
+} {
+  const previousSet = new Set(previousQueueIds);
+  const baseline = options.baselineSnippets ?? snippets;
+  let nextSnippets = snippets;
+  let nextHosts = options.hosts ?? [];
+  let changed = false;
+  const retainedIds: string[] = [];
+  const demotedDropIds = new Set<string>();
+
+  for (const scriptId of nextQueueIds) {
+    const item = nextSnippets.find((entry) => entry.id === scriptId && isScriptSnippet(entry));
+    if (!item) continue;
+
+    if (!connectQueueSnippetNeedsPromote(item, hostId)) {
+      retainedIds.push(scriptId);
+      continue;
+    }
+
+    const newlyAdded = !previousSet.has(scriptId);
+    const baselineItem = baseline.find((entry) => entry.id === scriptId);
+    const baselineTrigger = baselineItem && isScriptSnippet(baselineItem)
+      ? baselineItem.trigger
+      : undefined;
+    if (!newlyAdded && baselineTrigger === 'onConnect' && item.trigger !== 'onConnect') {
+      // Concurrent demotion while the editor stayed open: keep demotion, drop stale queue id.
+      demotedDropIds.add(scriptId);
+      continue;
+    }
+    if (
+      !newlyAdded
+      && baselineItem
+      && isScriptSnippet(baselineItem)
+      && (Boolean(baselineItem.targetsAllHosts) || snippetTargetsHostExplicitly(baselineItem, hostId))
+      && !(Boolean(item.targetsAllHosts) || snippetTargetsHostExplicitly(item, hostId))
+    ) {
+      // Concurrent target removal for this host: do not re-link on save.
+      demotedDropIds.add(scriptId);
+      continue;
+    }
+    if (
+      !newlyAdded
+      && baselineTrigger
+      && baselineTrigger !== 'onConnect'
+      && item.trigger !== baselineTrigger
+    ) {
+      // Concurrent non-onConnect trigger edit (e.g. manual -> onOutput): do not overwrite.
+      demotedDropIds.add(scriptId);
+      continue;
+    }
+
+    const prepared = prepareSnippetForHostConnectQueue(item, hostId);
+    if (
+      prepared.trigger !== item.trigger
+      || !snippetTargetsEqual(prepared, item)
+    ) {
+      nextSnippets = nextSnippets.map((entry) => (entry.id === scriptId ? prepared : entry));
+      changed = true;
+      if (options.hosts) {
+        const syncedHosts = ensureTargetHostsHaveConnectScript(
+          nextHosts,
+          prepared,
+          nextSnippets,
+          hostId,
+        );
+        if (syncedHosts !== nextHosts) {
+          nextHosts = syncedHosts;
+          changed = true;
+        }
+      }
+    }
+    retainedIds.push(scriptId);
+  }
+
+  for (const scriptId of previousQueueIds) {
+    if (retainedIds.includes(scriptId)) continue;
+    if (demotedDropIds.has(scriptId)) continue;
+    const unlinked = unlinkHostFromScripts(nextSnippets, hostId, scriptId);
+    if (unlinked !== nextSnippets) {
+      nextSnippets = unlinked;
+      changed = true;
+    }
+  }
+
+  if (
+    retainedIds.length !== nextQueueIds.length
+    || retainedIds.some((id, index) => id !== nextQueueIds[index])
+  ) {
+    changed = true;
+  }
+
+  return {
+    snippets: nextSnippets,
+    hosts: nextHosts,
+    connectScriptIds: retainedIds,
+    changed,
+  };
+}
+
+export function syncHostsForSnippetTargetChange(
+  hosts: Host[],
+  snippet: Snippet,
+  prevTargetIds: string[] | undefined,
+  snippets: Snippet[],
+): Host[] {
+  if (!isScriptSnippet(snippet) || snippet.trigger !== 'onConnect' || !snippet.id) {
+    return hosts;
+  }
+  if (snippet.targetsAllHosts) {
+    return hosts.map((host) => removeHostConnectScript(host, snippet.id!, snippets));
+  }
+
+  const prev = new Set(prevTargetIds ?? []);
+  const next = new Set(snippet.targets ?? []);
+  const added = [...next].filter((id) => !prev.has(id));
+  const removed = [...prev].filter((id) => !next.has(id));
+  if (added.length === 0 && removed.length === 0) return hosts;
+
+  return hosts.map((host) => {
+    let updated = host;
+    if (added.includes(host.id)) {
+      updated = appendHostConnectScript(updated, snippet.id!, snippets);
+    }
+    if (removed.includes(host.id)) {
+      updated = removeHostConnectScript(updated, snippet.id!, snippets);
+    }
+    return updated;
+  });
+}