[Init] Initial commit - NetMesh terminal manager

domain/portForwardingAgentOps.ts

@@ -0,0 +1,147 @@
+import type { Host, PortForwardingRule } from './models';
+import { getNextVaultOrder } from './vaultOrder';
+
+type Result<T> = { ok: true; value: T } | { ok: false; error: string };
+type NewRuleValues = { id: string; now: number };
+
+export const hasPortForwardingConnectionChanged = (
+  existing: PortForwardingRule,
+  updated: PortForwardingRule,
+): boolean => (
+  existing.type !== updated.type
+  || existing.localPort !== updated.localPort
+  || existing.remoteHost !== updated.remoteHost
+  || existing.remotePort !== updated.remotePort
+  || existing.bindAddress !== updated.bindAddress
+  || existing.hostId !== updated.hostId
+);
+
+const parsePort = (value: unknown, name: string): Result<number> => {
+  const parsed = typeof value === 'number' ? value : Number(String(value ?? ''));
+  return Number.isInteger(parsed) && parsed >= 1 && parsed <= 65535
+    ? { ok: true, value: parsed }
+    : { ok: false, error: `${name} must be an integer between 1 and 65535.` };
+};
+
+export const validatePortForwardingHost = (
+  hosts: Host[],
+  hostId: string | undefined,
+): Result<Host> => {
+  const host = hosts.find((candidate) => candidate.id === hostId);
+  if (!hostId || !host) {
+    return { ok: false, error: `Host "${hostId || ''}" was not found.` };
+  }
+  if (host.protocol && host.protocol !== 'ssh') {
+    return { ok: false, error: `Host "${hostId}" does not support port forwarding.` };
+  }
+  return { ok: true, value: host };
+};
+
+function buildRule(
+  source: Record<string, unknown>,
+  hosts: Host[],
+  existing?: PortForwardingRule,
+  newRule?: NewRuleValues,
+): Result<PortForwardingRule> {
+  const type = source.type === undefined ? existing?.type : String(source.type).trim();
+  if (type !== 'local' && type !== 'remote' && type !== 'dynamic') {
+    return { ok: false, error: 'type must be local, remote, or dynamic.' };
+  }
+  const localPort = parsePort(source.localPort ?? existing?.localPort, 'localPort');
+  if ('error' in localPort) return { ok: false, error: localPort.error };
+  const hostId = source.hostId === undefined ? existing?.hostId : String(source.hostId).trim();
+  const validatedHost = validatePortForwardingHost(hosts, hostId);
+  if (!validatedHost.ok) return validatedHost;
+  const remoteHost = source.remoteHost === undefined ? existing?.remoteHost : String(source.remoteHost).trim();
+  let remotePort: number | undefined;
+  if (type !== 'dynamic') {
+    if (!remoteHost) return { ok: false, error: 'remoteHost is required for local and remote forwarding.' };
+    const parsedRemotePort = parsePort(source.remotePort ?? existing?.remotePort, 'remotePort');
+    if ('error' in parsedRemotePort) return { ok: false, error: parsedRemotePort.error };
+    remotePort = parsedRemotePort.value;
+  }
+  if (!existing && !newRule) return { ok: false, error: 'New rule id and timestamp are required.' };
+  let autoStart = existing?.autoStart ?? false;
+  if (source.autoStart !== undefined) {
+    if (typeof source.autoStart === 'boolean') autoStart = source.autoStart;
+    else {
+      const normalized = String(source.autoStart).trim().toLowerCase();
+      if (['true', '1', 'yes'].includes(normalized)) autoStart = true;
+      else if (['false', '0', 'no'].includes(normalized)) autoStart = false;
+      else return { ok: false, error: 'autoStart must be true or false.' };
+    }
+  }
+  return {
+    ok: true,
+    value: {
+      id: existing?.id ?? newRule!.id,
+      label: String(source.label ?? existing?.label ?? `${type} ${localPort.value}`).trim() || `${type} ${localPort.value}`,
+      type,
+      localPort: localPort.value,
+      bindAddress: String(source.bindAddress ?? existing?.bindAddress ?? '127.0.0.1').trim() || '127.0.0.1',
+      ...(type === 'dynamic' ? {} : { remoteHost, remotePort }),
+      hostId,
+      autoStart,
+      status: existing?.status ?? 'inactive',
+      error: existing?.error,
+      lastUsedAt: existing?.lastUsedAt,
+      createdAt: existing?.createdAt ?? newRule!.now,
+      order: existing?.order,
+    },
+  };
+}
+
+export function createPortForwardingRule(
+  rules: PortForwardingRule[],
+  hosts: Host[],
+  source: Record<string, unknown>,
+  newRule: NewRuleValues,
+): Result<{ rules: PortForwardingRule[]; rule: PortForwardingRule }> {
+  const built = buildRule(source, hosts, undefined, newRule);
+  if ('error' in built) return { ok: false, error: built.error };
+  const rule = { ...built.value, order: getNextVaultOrder(rules) };
+  return { ok: true, value: { rules: [...rules, rule], rule } };
+}
+
+export function updatePortForwardingRule(
+  rules: PortForwardingRule[],
+  hosts: Host[],
+  ruleId: string,
+  source: Record<string, unknown>,
+): Result<{ rules: PortForwardingRule[]; rule: PortForwardingRule }> {
+  const existing = rules.find((rule) => rule.id === ruleId);
+  if (!existing) return { ok: false, error: `Port forwarding rule "${ruleId}" was not found.` };
+  const built = buildRule(source, hosts, existing);
+  if ('error' in built) return { ok: false, error: built.error };
+  const connectionChanged = hasPortForwardingConnectionChanged(existing, built.value);
+  const updatedRule = connectionChanged
+    ? { ...built.value, status: 'inactive' as const, error: undefined }
+    : built.value;
+  return {
+    ok: true,
+    value: { rules: rules.map((rule) => rule.id === ruleId ? updatedRule : rule), rule: updatedRule },
+  };
+}
+
+export function duplicatePortForwardingRule(
+  rules: PortForwardingRule[],
+  hosts: Host[],
+  ruleId: string,
+  newRule: NewRuleValues,
+): Result<{ rules: PortForwardingRule[]; rule: PortForwardingRule }> {
+  const existing = rules.find((rule) => rule.id === ruleId);
+  if (!existing) return { ok: false, error: `Port forwarding rule "${ruleId}" was not found.` };
+  const validated = buildRule({}, hosts, existing);
+  if ('error' in validated) return { ok: false, error: validated.error };
+  const rule: PortForwardingRule = {
+    ...validated.value,
+    id: newRule.id,
+    label: `${existing.label} (Copy)`,
+    status: 'inactive',
+    error: undefined,
+    lastUsedAt: undefined,
+    createdAt: newRule.now,
+    order: getNextVaultOrder(rules),
+  };
+  return { ok: true, value: { rules: [...rules, rule], rule } };
+}