[Init] Initial commit - NetMesh terminal manager

domain/telnetDeepLink.test.ts

@@ -0,0 +1,274 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import type { Host } from "./models";
+import {
+  buildTelnetDeepLinkConnectionHost,
+  buildTelnetDeepLinkEphemeralHostFromSaved,
+  buildTelnetDeepLinkHostDraft,
+  buildTelnetDeepLinkOpenHost,
+  findTelnetDeepLinkHost,
+  materializeTelnetDeepLinkMatchHost,
+  parseTelnetDeepLink,
+  shouldHandleTelnetDeepLink,
+} from "./telnetDeepLink";
+
+const host = (overrides: Partial<Host>): Host => ({
+  id: overrides.id || "host-1",
+  label: overrides.label || "Example",
+  hostname: overrides.hostname || "example.com",
+  username: overrides.username ?? "",
+  port: overrides.port,
+  group: "",
+  tags: [],
+  os: "linux",
+  protocol: overrides.protocol ?? "telnet",
+  ...overrides,
+});
+
+test("parseTelnetDeepLink accepts host and port", () => {
+  assert.deepEqual(parseTelnetDeepLink("telnet://router.example.com:2001"), {
+    rawUrl: "telnet://router.example.com:2001",
+    hostname: "router.example.com",
+    port: 2001,
+  });
+});
+
+test("parseTelnetDeepLink accepts credentials and IPv6 hosts", () => {
+  assert.deepEqual(parseTelnetDeepLink("telnet://admin:p%40ss@[2001:db8::10]:2323"), {
+    rawUrl: "telnet://admin:p%40ss@[2001:db8::10]:2323",
+    username: "admin",
+    password: "p@ss",
+    hostname: "2001:db8::10",
+    port: 2323,
+  });
+});
+
+test("parseTelnetDeepLink rejects unsupported or incomplete links", () => {
+  assert.equal(parseTelnetDeepLink("ssh://example.com"), null);
+  assert.equal(parseTelnetDeepLink("telnet://"), null);
+  assert.equal(parseTelnetDeepLink("telnet://example.com:99999"), null);
+});
+
+test("shouldHandleTelnetDeepLink respects the shared deep link setting", () => {
+  assert.equal(shouldHandleTelnetDeepLink("telnet://example.com:23", true), true);
+  assert.equal(shouldHandleTelnetDeepLink("telnet://example.com:23", false), false);
+  assert.equal(shouldHandleTelnetDeepLink("https://example.com", true), false);
+});
+
+test("findTelnetDeepLinkHost matches saved telnet hosts by hostname and port", () => {
+  const hosts = [
+    host({ id: "wrong-port", hostname: "example.com", port: 23 }),
+    host({ id: "match", hostname: "example.com", port: 2001 }),
+    host({ id: "ssh", hostname: "example.com", port: 2001, protocol: "ssh" }),
+  ];
+
+  const match = findTelnetDeepLinkHost(hosts, parseTelnetDeepLink("telnet://example.com:2001")!);
+
+  assert.equal(match?.id, "match");
+});
+
+test("findTelnetDeepLinkHost treats omitted ports as the telnet default", () => {
+  const hosts = [
+    host({ id: "custom-port", hostname: "example.com", port: 2323 }),
+    host({ id: "default-port", hostname: "example.com" }),
+  ];
+
+  const match = findTelnetDeepLinkHost(hosts, parseTelnetDeepLink("telnet://example.com")!);
+
+  assert.equal(match?.id, "default-port");
+});
+
+test("findTelnetDeepLinkHost avoids ambiguous saved hosts", () => {
+  const hosts = [
+    host({ id: "one", hostname: "example.com", port: 23 }),
+    host({ id: "two", hostname: "example.com", telnetEnabled: true, protocol: "ssh", telnetPort: 23 }),
+  ];
+
+  const match = findTelnetDeepLinkHost(hosts, parseTelnetDeepLink("telnet://example.com")!);
+
+  assert.equal(match, null);
+});
+
+test("findTelnetDeepLinkHost can ignore URL username for one-time credential links", () => {
+  const hosts = [
+    host({
+      id: "saved",
+      hostname: "example.com",
+      port: 23,
+      telnetUsername: "vault-user",
+    }),
+  ];
+
+  const strictMatch = findTelnetDeepLinkHost(
+    hosts,
+    parseTelnetDeepLink("telnet://link-user:link-password@example.com")!,
+  );
+  const credentialMatch = findTelnetDeepLinkHost(
+    hosts,
+    parseTelnetDeepLink("telnet://link-user:link-password@example.com")!,
+    { ignoreTargetUsername: true },
+  );
+
+  assert.equal(strictMatch, null);
+  assert.equal(credentialMatch?.id, "saved");
+});
+
+test("buildTelnetDeepLinkConnectionHost forces a saved host to open with telnet", () => {
+  const savedHost = host({
+    id: "saved",
+    hostname: "example.com",
+    protocol: "ssh",
+    telnetEnabled: true,
+    telnetPort: 2323,
+    moshEnabled: true,
+    etEnabled: true,
+  });
+
+  const connectionHost = buildTelnetDeepLinkConnectionHost(savedHost);
+
+  assert.equal(connectionHost.protocol, "telnet");
+  assert.equal(connectionHost.telnetEnabled, true);
+  assert.equal(connectionHost.telnetPort, 2323);
+  assert.equal(connectionHost.moshEnabled, false);
+  assert.equal(connectionHost.etEnabled, false);
+});
+
+test("buildTelnetDeepLinkConnectionHost uses the telnet default for ssh hosts with telnet enabled", () => {
+  const savedHost = host({
+    id: "saved",
+    hostname: "example.com",
+    protocol: "ssh",
+    port: 22,
+    telnetEnabled: true,
+  });
+
+  const connectionHost = buildTelnetDeepLinkConnectionHost(savedHost);
+
+  assert.equal(connectionHost.protocol, "telnet");
+  assert.equal(connectionHost.port, 23);
+  assert.equal(connectionHost.telnetPort, 23);
+});
+
+test("buildTelnetDeepLinkEphemeralHostFromSaved keeps saved settings but uses URL credentials", () => {
+  const savedHost = host({
+    id: "saved",
+    label: "Saved",
+    hostname: "example.com",
+    username: "vault-user",
+    port: 22,
+    protocol: "ssh",
+    telnetEnabled: true,
+    telnetUsername: "vault-telnet-user",
+    telnetPassword: "vault-password",
+    telnetIdentityId: "identity-1",
+    proxyProfileId: "proxy-1",
+    charset: "gb18030",
+    group: "network",
+  });
+
+  const ephemeral = buildTelnetDeepLinkEphemeralHostFromSaved(
+    savedHost,
+    parseTelnetDeepLink("telnet://link-user:link-password@example.com")!,
+    { id: "ephemeral-id", now: 789 },
+  );
+
+  assert.equal(ephemeral.id, "ephemeral-id");
+  assert.equal(ephemeral.ephemeral, true);
+  assert.equal(ephemeral.protocol, "telnet");
+  assert.equal(ephemeral.telnetEnabled, true);
+  assert.equal(ephemeral.telnetPort, 23);
+  assert.equal(ephemeral.username, "link-user");
+  assert.equal(ephemeral.telnetUsername, "link-user");
+  assert.equal(ephemeral.telnetPassword, "link-password");
+  assert.equal(ephemeral.telnetIdentityId, undefined);
+  assert.equal(ephemeral.savePassword, false);
+  assert.equal(ephemeral.group, "");
+  assert.equal(ephemeral.proxyProfileId, "proxy-1");
+  assert.equal(ephemeral.charset, "gb18030");
+});
+
+test("buildTelnetDeepLinkHostDraft prepares an ephemeral telnet host", () => {
+  const draft = buildTelnetDeepLinkHostDraft(
+    parseTelnetDeepLink("telnet://admin:secret@example.com:2323")!,
+    { id: "new-id", now: 123 },
+  );
+
+  assert.deepEqual(draft, {
+    id: "new-id",
+    label: "admin@example.com",
+    hostname: "example.com",
+    username: "admin",
+    port: 2323,
+    group: "",
+    tags: [],
+    os: "linux",
+    protocol: "telnet",
+    telnetEnabled: true,
+    telnetPort: 2323,
+    telnetUsername: "admin",
+    telnetPassword: "secret",
+    savePassword: false,
+    ephemeral: true,
+    moshEnabled: false,
+    etEnabled: false,
+    createdAt: 123,
+  });
+});
+
+test("materializeTelnetDeepLinkMatchHost makes telnet identity usernames matchable", () => {
+  const savedHost = host({
+    id: "saved",
+    hostname: "example.com",
+    username: "",
+    protocol: "ssh",
+    telnetEnabled: true,
+    telnetIdentityId: "identity-1",
+  });
+
+  const materialized = materializeTelnetDeepLinkMatchHost(savedHost, [
+    { id: "identity-1", username: "identity-user" },
+  ]);
+  const match = findTelnetDeepLinkHost(
+    [materialized],
+    parseTelnetDeepLink("telnet://identity-user@example.com")!,
+  );
+
+  assert.equal(match?.id, "saved");
+});
+
+test("buildTelnetDeepLinkOpenHost falls back to a draft host when no saved host matches", () => {
+  const openHost = buildTelnetDeepLinkOpenHost(
+    [],
+    parseTelnetDeepLink("telnet://missing.example.com:2001")!,
+    { id: "draft-id", now: 456 },
+  );
+
+  assert.equal(openHost.id, "draft-id");
+  assert.equal(openHost.hostname, "missing.example.com");
+  assert.equal(openHost.port, 2001);
+  assert.equal(openHost.protocol, "telnet");
+  assert.equal(openHost.telnetEnabled, true);
+  assert.equal(openHost.ephemeral, true);
+});
+
+test("buildTelnetDeepLinkOpenHost keeps URL password instead of strict matching a saved host", () => {
+  const openHost = buildTelnetDeepLinkOpenHost(
+    [
+      host({
+        id: "saved-alice",
+        hostname: "example.com",
+        port: 23,
+        telnetUsername: "alice",
+        telnetPassword: "saved-password",
+      }),
+    ],
+    parseTelnetDeepLink("telnet://alice:new-password@example.com")!,
+    { id: "draft-id", now: 456 },
+  );
+
+  assert.equal(openHost.id, "draft-id");
+  assert.equal(openHost.username, "alice");
+  assert.equal(openHost.telnetUsername, "alice");
+  assert.equal(openHost.telnetPassword, "new-password");
+  assert.equal(openHost.ephemeral, true);
+});