@isothrum/editor 0.0.0-stage → 0.1.0

package/src/lib/tool/gns3-cables.ts

@@ -0,0 +1,81 @@
+import { nextPort } from "./cables";
+import { lanRect, within } from "./geometry";
+import { centerOf, isLan, uid, type CableEdge, type LabNode, type LanNode, type MachineNode, type Side } from "./model";
+
+/** A GNS3 project's links as cables: machine to machine, or machine to the LAN its switch became. */
+
+export interface Gns3Wiring {
+  links: [string, string][];
+  /** The machines and the LANs, by GNS3 node id. */
+  machines: Map<string, MachineNode>;
+  lanOf: Map<string, LanNode>;
+  /** Every node of the lab so far (the LANs among them). */
+  nodes: LabNode[];
+  /** A GNS3 LAN's size: which side of it faces a machine goes by its proportions. */
+  lanSize: { w: number; h: number };
+}
+
+const machineSide = (m: MachineNode, other: LabNode) => {
+  if (m.data.icon === "router" || m.data.icon === "shield") return "port";
+  return centerOf(other).y < centerOf(m).y ? "top" : "bottom";
+};
+
+function lanSide(w: Gns3Wiring, lan: LanNode, m: MachineNode): Side {
+  const d = { x: centerOf(m).x - centerOf(lan).x, y: centerOf(m).y - centerOf(lan).y };
+  if (Math.abs(d.x) / w.lanSize.w > Math.abs(d.y) / w.lanSize.h) return d.x < 0 ? "left" : "right";
+  return d.y < 0 ? "top" : "bottom";
+}
+
+function machineCable(a: MachineNode, b: MachineNode, edges: CableEdge[]): CableEdge {
+  return {
+    id: uid("c"),
+    type: "cable",
+    source: a.id,
+    sourceHandle: machineSide(a, b),
+    target: b.id,
+    targetHandle: machineSide(b, a),
+    data: { aPort: nextPort(a.id, edges), bPort: nextPort(b.id, edges) },
+  };
+}
+
+function lanCable(w: Gns3Wiring, m: MachineNode, lan: LanNode, edges: CableEdge[]): CableEdge {
+  return {
+    id: uid("c"),
+    type: "cable",
+    source: m.id,
+    sourceHandle: machineSide(m, lan),
+    target: lan.id,
+    targetHandle: lanSide(w, lan, m),
+    data: { aPort: nextPort(m.id, edges), bPort: "" },
+  };
+}
+
+/**
+ * A LAN drawn over a machine it isn't cabled to would put that machine on it: its area is hidden
+ * (its label and cables stay).
+ */
+function hideCovering(w: Gns3Wiring, linked: Set<string>): void {
+  for (const lan of w.nodes.filter(isLan)) {
+    const covers = [...w.machines.values()].some((m) => within(lanRect(lan), centerOf(m)) && !linked.has(`${m.id}/${lan.id}`));
+    if (covers) lan.data = { ...lan.data, hidden: true };
+  }
+}
+
+/** The cables of the project's links (each machine–LAN pair once); hides the LANs that would mislead. */
+export function gns3Cables(w: Gns3Wiring): CableEdge[] {
+  const edges: CableEdge[] = [];
+  const linked = new Set<string>();
+  for (const [a, b] of w.links) {
+    const ma = w.machines.get(a);
+    const mb = w.machines.get(b);
+    const lan = w.lanOf.get(b) ?? w.lanOf.get(a);
+    const m = ma ?? mb;
+    if (ma && mb) edges.push(machineCable(ma, mb, edges));
+    else if (m && lan && !linked.has(`${m.id}/${lan.id}`)) {
+      linked.add(`${m.id}/${lan.id}`);
+      edges.push(lanCable(w, m, lan, edges));
+    }
+  }
+  hideCovering(w, linked);
+  return edges;
+}

package/src/lib/tool/gns3-import.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, test } from "vitest";
+import { fromGns3 } from "./gns3-import";
+import type { Gns3Text } from "./gns3-parts";
+import { nodeName, type LabNode, type MachineData } from "./model";
+
+const text: Gns3Text = {
+  notGns3: "not gns3",
+  noTopology: "no topology",
+  cisco: (node, kind) => `cisco ${node} ${kind}`,
+  firewall: (node) => `firewall ${node}`,
+  noEquivalent: (node, type) => `skipped ${node} ${type}`,
+  noNodes: "no nodes",
+};
+
+/** A GNS3 node: its id, type and name, at the origin unless `extra` says otherwise. */
+const g3 = (node_id: string, node_type: string, name: string = node_id, extra: object = {}) => ({ node_id, node_type, name, x: 0, y: 0, ...extra });
+/** A .gns3 project of `nodes` and two-ended `links`. */
+const project = (nodes: object[], links: string[][] = [], more: object = {}) =>
+  JSON.stringify({ name: "My GNS3 Lab", type: "topology", topology: { nodes, links: links.map((ends) => ({ nodes: ends.map((node_id) => ({ node_id })) })), ...more } });
+const open = (nodes: object[], links: string[][] = [], more: object = {}) => fromGns3(project(nodes, links, more), text);
+const names = (nodes: LabNode[]) => nodes.map(nodeName);
+/** The machine named `name`'s data. */
+const machineData = (nodes: LabNode[], name: string): MachineData | undefined => nodes.find((n) => n.type === "machine" && n.data.name === name)?.data as MachineData | undefined;
+
+describe("what isn't a GNS3 project", () => {
+  test("a file that isn't JSON", () => {
+    expect(() => fromGns3("not json", text)).toThrow("not gns3");
+  });
+
+  test("JSON with no topology", () => {
+    expect(() => fromGns3(JSON.stringify({ name: "x" }), text)).toThrow("no topology");
+  });
+
+  test("a project with no nodes opens empty, with a warning", () => {
+    expect(open([])).toEqual({ lab: { name: "my-gns3-lab", nodes: [], edges: [] }, warnings: ["no nodes"] });
+  });
+});
+
+describe("switches become LANs", () => {
+  test("a switch is a LAN without the internet, the machines cabled to it on its edge", () => {
+    const { lab } = open([g3("s1", "ethernet_switch", "Switch1"), g3("d1", "docker", "web", { x: 100, y: 100, properties: { image: "nginx:latest" } })], [["s1", "d1"]]);
+    expect(lab.nodes[0]).toMatchObject({ type: "lan", data: { name: "switch1", cidr: "10.10.1.0/24", internet: false } });
+    expect(lab.edges).toEqual([expect.objectContaining({ source: lab.nodes[1].id, target: lab.nodes[0].id, data: { aPort: "eth0", bPort: "" } })]);
+  });
+
+  test("switches cabled together are one LAN, named after the first; a NAT on it gives it the internet", () => {
+    const { lab } = open([g3("nat", "nat", "NAT1"), g3("s1", "ethernet_switch", "Switch1"), g3("s2", "ethernet_hub", "Switch 2"), g3("s3", "ethernet_switch")], [["s1", "s2"], ["nat", "s1"]]);
+    expect(lab.nodes.map((n) => n.type === "lan" && [n.data.name, n.data.cidr, n.data.internet])).toEqual([
+      ["switch1", "10.10.1.0/24", true],
+      ["s3", "10.10.2.0/24", false],
+    ]);
+  });
+
+  test("an Open vSwitch container is a switch too", () => {
+    expect(open([g3("o", "docker", "OpenvSwitch", { properties: { image: "gns3/openvswitch" } })]).lab.nodes[0].type).toBe("lan");
+  });
+});
+
+describe("what each node becomes", () => {
+  test("Cisco routers become automatic routers, with a warning that their configuration stays behind", () => {
+    const { lab, warnings } = open([g3("r1", "dynamips", "R1"), g3("r2", "iou", "R_2")]);
+    expect(names(lab.nodes)).toEqual(["r1", "r-2"]);
+    expect(machineData(lab.nodes, "r1")).toMatchObject({ kind: "router", icon: "router" });
+    expect(warnings).toEqual(["cisco R1 Dynamips", "cisco R_2 IOU"]);
+  });
+
+  test("a router appliance becomes an automatic router, silently", () => {
+    const { lab, warnings } = open([g3("v", "qemu", "edge", { properties: { hda_disk_image: "vyos.img" } })]);
+    expect(machineData(lab.nodes, "edge")).toMatchObject({ kind: "router", icon: "router" });
+    expect(warnings).toEqual([]);
+  });
+
+  test("a firewall becomes an automatic router with a shield, with a warning", () => {
+    const { lab, warnings } = open([g3("f", "qemu", "pfSense", { properties: { hda_disk_image: "pfsense.qcow2" } })]);
+    expect(machineData(lab.nodes, "pfsense")).toMatchObject({ kind: "router", icon: "shield" });
+    expect(warnings).toEqual(["firewall pfSense"]);
+  });
+
+  test("QEMU, VirtualBox and VMware nodes become VMs, the OS guessed, each with its provisioning script", () => {
+    const nodes = [
+      g3("q", "qemu", "Win10", { properties: { hda_disk_image: "win10.qcow2" } }),
+      g3("v", "virtualbox", "srv", { properties: { vmname: "Ubuntu 20.04" } }),
+      g3("w", "vmware", "kali linux"),
+    ];
+    const { lab } = open(nodes);
+    expect(lab.nodes.map((n) => n.type === "machine" && [n.data.name, n.data.kind, n.data.os, n.data.provision])).toEqual([
+      ["win10", "vm", "windows@10", "provision/win10.ps1"],
+      ["srv", "vm", "ubuntu@20.04", "provision/srv.sh"],
+      ["kali-linux", "vm", "kali@rolling", "provision/kali-linux.sh"],
+    ]);
+  });
+
+  test("VPCS becomes a small Alpine container, and a Docker node without an image runs Alpine", () => {
+    const { lab } = open([g3("p", "vpcs", "PC1"), g3("d", "docker", "box", { properties: {} })]);
+    expect(machineData(lab.nodes, "pc1")).toMatchObject({ kind: "container", icon: "laptop", image: "alpine:3.20" });
+    expect(machineData(lab.nodes, "box")).toMatchObject({ kind: "container", icon: "container", image: "alpine:3.20" });
+  });
+
+  test("a node with no equivalent is left out, with a warning", () => {
+    expect(open([g3("x", "cloud_unknown", "Thing")])).toMatchObject({ lab: { nodes: [] }, warnings: ["skipped Thing cloud_unknown"] });
+  });
+});

package/src/lib/tool/gns3-import.ts

@@ -0,0 +1,198 @@
+/**
+ * Opening a GNS3 project (.gns3, the JSON GNS3 saves) as a lab. GNS3 draws switches as boxes
+ * that machines plug into; here they become LANs, the machines cabled to their edge. Docker
+ * nodes keep their image, QEMU/VirtualBox/VMware nodes become VMs (the OS guessed from the
+ * image), VPCS becomes a small container, Cisco routers (Dynamips, IOU) automatic routers, a NAT
+ * or cloud gives its LAN the internet, and text drawings become notes. What can't come across
+ * (an IOS configuration, a node type with no equivalent) is reported, not silently dropped.
+ */
+
+import { migrateEdges } from "./cables";
+import { gns3Cables } from "./gns3-cables";
+import { drawingNote, guessOs, type G3Drawing, type Gns3Text } from "./gns3-parts";
+import { LAN_BEHAVIOR, MACHINE_H, MACHINE_W, cleanName, uid, type Draft, type LabNode, type LanNode, type MachineData, type MachineNode, type NoteNode } from "./model";
+
+interface G3Node {
+  node_id: string;
+  name?: string;
+  node_type?: string;
+  x?: number;
+  y?: number;
+  properties?: Record<string, unknown>;
+}
+interface G3Link {
+  nodes?: { node_id: string }[];
+}
+interface G3Project {
+  name?: string;
+  type?: string;
+  topology?: { nodes?: G3Node[]; links?: G3Link[]; drawings?: G3Drawing[] };
+}
+
+/** GNS3 places small icons; Isothrum's machines are about twice as big, so positions spread out. */
+const SCALE = 2;
+const LAN_W = 260;
+const LAN_H = 160;
+
+const SWITCHES = new Set(["ethernet_switch", "ethernet_hub", "atm_switch", "frame_relay_switch"]);
+const INTERNET = new Set(["nat", "cloud"]);
+const CISCO = new Set(["dynamips", "iou"]);
+const VMS = new Set(["qemu", "virtualbox", "vmware"]);
+
+/** Appliances recognised by their image or name: network devices rather than hosts. */
+const ROUTER_HINT = /vyos|csr|vios|xrv|routeros|mikrotik|frr|cisco|juniper|vsrx|vmx|veos|arista|nokia|sros|openwrt/i;
+const FIREWALL_HINT = /fortigate|pfsense|opnsense|asav|paloalto|pan-os|checkpoint|sophos/i;
+const SWITCH_HINT = /openvswitch|ovs|cumulus|nxos|iosvl2|vios_l2/i;
+
+const str = (v: unknown) => (typeof v === "string" ? v : "");
+
+/** What a GNS3 node becomes: part of a LAN (a switch, or the internet), or a machine. */
+function kindOf(n: G3Node): "switch" | "internet" | "machine" {
+  const t = n.node_type ?? "";
+  const look = `${n.name ?? ""} ${str(n.properties?.image)} ${str(n.properties?.hda_disk_image)}`;
+  if (SWITCHES.has(t) || ((t === "docker" || VMS.has(t)) && SWITCH_HINT.test(look))) return "switch";
+  if (INTERNET.has(t)) return "internet";
+  return "machine";
+}
+
+/** An import in progress: the project's nodes, the lab's nodes so far, the names taken. */
+interface Import {
+  g3nodes: G3Node[];
+  links: [string, string][];
+  nodes: LabNode[];
+  names: Set<string>;
+  warnings: string[];
+  text: Gns3Text;
+}
+
+/** The project's nodes and its two-ended links, or why the file isn't a GNS3 project. */
+function parse(source: string, text: Gns3Text): { project: G3Project; g3nodes: G3Node[]; links: [string, string][] } {
+  let project: G3Project;
+  try {
+    project = JSON.parse(source) as G3Project;
+  } catch {
+    throw new Error(text.notGns3);
+  }
+  const g3nodes = project.topology?.nodes;
+  if (!Array.isArray(g3nodes)) throw new Error(text.noTopology);
+  const links = (project.topology?.links ?? [])
+    .map((l) => (l.nodes ?? []).map((e) => e.node_id))
+    .flatMap((ends): [string, string][] => (ends.length === 2 ? [[ends[0], ends[1]]] : []));
+  return { project, g3nodes, links };
+}
+
+/** A free name from GNS3's (spaces and underscores as dashes), `-2`, `-3`… when it is taken. */
+function nameFor(imp: Import, raw: string, fallback: string): string {
+  const base = cleanName(raw.replace(/[\s_]+/g, "-")).replace(/^-+|-+$/g, "") || fallback;
+  let name = base;
+  for (let i = 2; imp.names.has(name); i++) name = `${base}-${String(i)}`;
+  imp.names.add(name);
+  return name;
+}
+
+const center = (n: G3Node) => ({ x: (n.x ?? 0) * SCALE + 30, y: (n.y ?? 0) * SCALE + 30 });
+
+/** Switches cabled together are one LAN; a NAT or cloud cabled to a switch gives it the internet. */
+function switchGroups(imp: Import): (id: string) => string | null {
+  const parent = new Map<string, string>();
+  const find = (id: string): string => {
+    const up = parent.get(id);
+    return up === undefined || up === id ? id : find(up);
+  };
+  for (const n of imp.g3nodes) if (kindOf(n) !== "machine") parent.set(n.node_id, n.node_id);
+  for (const [a, b] of imp.links) if (parent.has(a) && parent.has(b)) parent.set(find(a), find(b));
+  return (id) => (parent.has(id) ? find(id) : null);
+}
+
+/** One LAN per group of switches (and NAT/cloud), where its first member was. */
+function importLans(imp: Import): Map<string, LanNode> {
+  const groupOf = switchGroups(imp);
+  const lanOf = new Map<string, LanNode>();
+  let third = 1;
+  for (const n of imp.g3nodes) {
+    const root = groupOf(n.node_id);
+    if (root === null) continue;
+    let lan = lanOf.get(root);
+    if (!lan) {
+      const members = imp.g3nodes.filter((m) => groupOf(m.node_id) === root);
+      const first = members.find((m) => kindOf(m) === "switch") ?? members[0];
+      const c = center(first);
+      const data = { name: nameFor(imp, first.name ?? "", "lan"), cidr: `10.10.${String(third++)}.0/24`, internet: members.some((m) => kindOf(m) === "internet") };
+      lan = { ...LAN_BEHAVIOR, id: uid("l"), type: "lan", position: { x: c.x - LAN_W / 2, y: c.y - LAN_H / 2 }, width: LAN_W, height: LAN_H, data };
+      imp.nodes.push(lan);
+    }
+    lanOf.set(n.node_id, lan);
+    lanOf.set(root, lan);
+  }
+  return lanOf;
+}
+
+/** What a GNS3 machine becomes, or null (with a warning) when nothing here matches it. */
+function machineData(imp: Import, n: G3Node): Omit<MachineData, "name"> | null {
+  const t = n.node_type ?? "";
+  const p = n.properties ?? {};
+  const look = `${n.name ?? ""} ${str(p.image)} ${str(p.hda_disk_image)} ${str(p.vmname)}`;
+  const base = { image: "", os: "", provision: "", ports: "", access: false };
+  if (CISCO.has(t) || ROUTER_HINT.test(look)) {
+    if (CISCO.has(t)) imp.warnings.push(imp.text.cisco(n.name ?? n.node_id, t === "iou" ? "IOU" : "Dynamips"));
+    return { ...base, kind: "router", icon: "router" };
+  }
+  if (FIREWALL_HINT.test(look)) {
+    imp.warnings.push(imp.text.firewall(n.name ?? n.node_id));
+    return { ...base, kind: "router", icon: "shield" };
+  }
+  if (t === "docker") return { ...base, kind: "container", icon: "container", image: str(p.image) || "alpine:3.20" };
+  if (t === "vpcs" || t === "traceng") return { ...base, kind: "container", icon: "laptop", image: "alpine:3.20" };
+  if (VMS.has(t)) return { ...base, kind: "vm", icon: "monitor", os: guessOs(look) };
+  imp.warnings.push(imp.text.noEquivalent(n.name ?? n.node_id, t));
+  return null;
+}
+
+/** The machines, where GNS3 had them, by GNS3 node id. */
+function importMachines(imp: Import): Map<string, MachineNode> {
+  const machines = new Map<string, MachineNode>();
+  for (const n of imp.g3nodes) {
+    if (kindOf(n) !== "machine") continue;
+    let data = machineData(imp, n);
+    if (!data) continue;
+    const name = nameFor(imp, n.name ?? "", data.kind === "router" ? "router" : "machine");
+    if (data.kind === "vm") data = { ...data, provision: `provision/${name}.${data.os.startsWith("windows") ? "ps1" : "sh"}` };
+    const c = center(n);
+    const m: MachineNode = { id: uid("m"), type: "machine", position: { x: c.x - MACHINE_W / 2, y: c.y - MACHINE_H / 2 }, data: { ...data, name } };
+    machines.set(n.node_id, m);
+    imp.nodes.push(m);
+  }
+  return machines;
+}
+
+/** The project's text drawings, as notes. */
+function importNotes(imp: Import, drawings: G3Drawing[]): void {
+  for (const d of drawings) {
+    const note = drawingNote(d, SCALE);
+    if (!note) continue;
+    const n: NoteNode = {
+      id: uid("n"),
+      type: "note",
+      position: { x: (d.x ?? 0) * SCALE, y: (d.y ?? 0) * SCALE },
+      width: note.w,
+      height: note.h,
+      data: { text: note.text, shape: note.shape, color: "yellow" },
+    };
+    imp.nodes.push(n);
+  }
+}
+
+/** `text`: the editor's words for what goes wrong (warnings and errors are shown as they are). */
+export function fromGns3(source: string, text: Gns3Text): { lab: Draft; warnings: string[] } {
+  const { project, g3nodes, links } = parse(source, text);
+  const imp: Import = { g3nodes, links, nodes: [], names: new Set(), warnings: [], text };
+  const lanOf = importLans(imp);
+  const machines = importMachines(imp);
+  const edges = gns3Cables({ links, machines, lanOf, nodes: imp.nodes, lanSize: { w: LAN_W, h: LAN_H } });
+  importNotes(imp, project.topology?.drawings ?? []);
+  // LANs first, so they stay under the machines.
+  const ordered = [...imp.nodes.filter((n) => n.type === "lan"), ...imp.nodes.filter((n) => n.type !== "lan")];
+  const lab: Draft = { name: cleanName((project.name ?? "").replace(/[\s_]+/g, "-")) || "gns3-lab", nodes: ordered, edges: migrateEdges(edges, ordered) };
+  if (!g3nodes.length) imp.warnings.push(text.noNodes);
+  return { lab, warnings: imp.warnings };
+}

package/src/lib/tool/gns3-layout.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "vitest";
+import { fromGns3 } from "./gns3-import";
+import type { Gns3Text } from "./gns3-parts";
+import { MACHINE_H, MACHINE_W, nodeName } from "./model";
+
+const text: Gns3Text = { notGns3: "", noTopology: "", cisco: () => "", firewall: () => "", noEquivalent: () => "", noNodes: "" };
+const docker = (node_id: string, name: string, x = 0, y = 0) => ({ node_id, node_type: "docker", name, x, y, properties: { image: "alpine" } });
+const sw = (node_id: string) => ({ node_id, node_type: "ethernet_switch", name: node_id, x: 0, y: 0 });
+/** A project's lab: its nodes, links (by GNS3 id) and drawings. */
+const labOf = (nodes: object[], links: string[][] = [], drawings: object[] = [], name?: string) =>
+  fromGns3(JSON.stringify({ name, topology: { nodes, links: links.map((ends) => ({ nodes: ends.map((node_id) => ({ node_id })) })), drawings } }), text).lab;
+
+describe("names", () => {
+  test("spaces and underscores become dashes, and a taken name gets -2, -3", () => {
+    expect(labOf([docker("a", "web"), docker("b", "web"), docker("c", "My_Box 1")]).nodes.map(nodeName)).toEqual(["web", "web-2", "my-box-1"]);
+  });
+
+  test("a nameless machine is called machine", () => {
+    expect(labOf([docker("a", "")]).nodes.map(nodeName)).toEqual(["machine"]);
+  });
+
+  test("the lab is named after the project, or gns3-lab", () => {
+    expect([labOf([], [], [], "a_b c").name, labOf([]).name]).toEqual(["a-b-c", "gns3-lab"]);
+  });
+});
+
+describe("where things go", () => {
+  test("positions spread out twice as far as GNS3's", () => {
+    expect(labOf([docker("a", "web", 100, 50)]).nodes[0].position).toEqual({ x: 230 - MACHINE_W / 2, y: 130 - MACHINE_H / 2 });
+  });
+
+  test("LANs come first, so they are drawn under the machines", () => {
+    expect(labOf([docker("a", "web"), sw("s1")]).nodes.map((n) => n.type)).toEqual(["lan", "machine"]);
+  });
+
+  test("a LAN drawn over a machine it isn't cabled to is hidden", () => {
+    const lan = labOf([sw("s1"), docker("a", "web", 0, 10)]).nodes[0];
+    expect(lan.type === "lan" && lan.data.hidden).toBe(true);
+  });
+
+  test("text drawings become notes, scaled; empty ones are left out", () => {
+    const drawings = [{ x: 10, y: 20, svg: '<svg width="100" height="40"><text>Hello</text></svg>' }, { svg: "<svg></svg>" }];
+    expect(labOf([], [], drawings).nodes).toEqual([
+      expect.objectContaining({ type: "note", position: { x: 20, y: 40 }, width: 200, height: 80, data: { text: "Hello", shape: "text", color: "yellow" } }),
+    ]);
+  });
+});
+
+describe("links", () => {
+  test("a link between two machines is a cable between them, each end on its next free port", () => {
+    const lab = labOf([docker("a", "web"), docker("b", "db"), docker("c", "cache")], [["a", "b"], ["a", "c"]]);
+    expect(lab.edges.map((e) => e.data)).toEqual([
+      { aPort: "eth0", bPort: "eth0" },
+      { aPort: "eth1", bPort: "eth0" },
+    ]);
+  });
+
+  test("a machine linked twice to one LAN gets one cable, and a link with one end none", () => {
+    const lab = labOf([sw("s1"), docker("a", "web", 300, 300)], [["s1", "a"], ["a", "s1"], ["a"]]);
+    expect(lab.edges).toHaveLength(1);
+  });
+});

package/src/lib/tool/gns3-parts.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "vitest";
+import { drawingNote, guessOs } from "./gns3-parts";
+
+describe("guessOs", () => {
+  test("reads a Linux distribution and its version from the image's name", () => {
+    const names = ["kali linux", "Rocky", "alma", "centos", "fedora", "ubuntu 20.04", "ubuntu 24", "ubuntu", "debian 11", "debian 13", "debian"];
+    expect(names.map(guessOs)).toEqual([
+      "kali@rolling",
+      "rocky@9",
+      "alma@9",
+      "centos@7",
+      "fedora@42",
+      "ubuntu@20.04",
+      "ubuntu@24.04",
+      "ubuntu@22.04",
+      "debian@11",
+      "debian@13",
+      "debian@12",
+    ]);
+  });
+
+  test("reads Windows desktops and servers, Server 2022 by default", () => {
+    const names = ["windows-11.img", "Win10", "Windows Server 2016", "win 2019", "win 2025", "windows"];
+    expect(names.map(guessOs)).toEqual(["windows@11", "windows@10", "windows-server@2016", "windows-server@2019", "windows-server@2025", "windows-server@2022"]);
+  });
+
+  test("guesses Debian 12 when nothing says otherwise", () => {
+    expect(guessOs("my appliance")).toBe("debian@12");
+  });
+});
+
+describe("drawingNote", () => {
+  test("takes an SVG drawing's text, without markup and with entities decoded, one line per text element", () => {
+    const svg = '<svg width="100" height="40"><text font="x">Hello &amp; <b>bye</b></text><text>a &lt;b&gt;</text></svg>';
+    expect(drawingNote({ svg }, 2)).toEqual({ text: "Hello & bye\na <b>", shape: "text", w: 200, h: 80 });
+  });
+
+  test("keeps an ellipse or a box, sized by the drawing within bounds", () => {
+    expect(drawingNote({ svg: '<svg width="300" height="300"><ellipse/></svg>' }, 2)).toEqual({ text: "", shape: "ellipse", w: 600, h: 400 });
+    expect(drawingNote({ svg: "<svg><rect/></svg>" }, 2)).toEqual({ text: "", shape: "rect", w: 120, h: 50 });
+  });
+
+  test("is nothing for a drawing with no text and no shape", () => {
+    expect(drawingNote({ svg: "<svg></svg>" }, 2)).toBeNull();
+    expect(drawingNote({}, 2)).toBeNull();
+  });
+});

package/src/lib/tool/gns3-parts.ts

@@ -0,0 +1,68 @@
+import type { NoteShape } from "./model";
+import { DEFAULT_OS } from "./os";
+
+/** Pieces of a GNS3 import that read one thing: an OS from an image name, a note from a drawing. */
+
+/** The editor's words for what a GNS3 import can't carry over (see the editor's text). */
+export interface Gns3Text {
+  notGns3: string;
+  noTopology: string;
+  cisco: (node: string, kind: string) => string;
+  firewall: (node: string) => string;
+  noEquivalent: (node: string, type: string) => string;
+  noNodes: string;
+}
+
+export interface G3Drawing {
+  x?: number;
+  y?: number;
+  svg?: string;
+}
+
+function windowsOs(t: string): string {
+  if (t.includes("11")) return "windows@11";
+  if (t.includes("10") && !t.includes("server")) return "windows@10";
+  if (t.includes("2016")) return "windows-server@2016";
+  if (t.includes("2019")) return "windows-server@2019";
+  if (t.includes("2025")) return "windows-server@2025";
+  return "windows-server@2022";
+}
+
+/** Linux distributions by a word in the image's name, each with its version guess. */
+const DISTROS: [word: string, os: (t: string) => string][] = [
+  ["kali", () => "kali@rolling"],
+  ["ubuntu", (t) => (t.includes("20.04") ? "ubuntu@20.04" : t.includes("24") ? "ubuntu@24.04" : "ubuntu@22.04")],
+  ["rocky", () => "rocky@9"],
+  ["alma", () => "alma@9"],
+  ["centos", () => "centos@7"],
+  ["fedora", () => "fedora@42"],
+  ["alpine", () => "alpine@3.19"],
+  ["debian", (t) => (t.includes("11") ? "debian@11" : t.includes("13") ? "debian@13" : DEFAULT_OS)],
+];
+
+/** The Isoloom OS a VM's image or name suggests (Debian 12 when nothing does). */
+export function guessOs(text: string): string {
+  const t = text.toLowerCase();
+  if (t.includes("win")) return windowsOs(t);
+  const distro = DISTROS.find(([word]) => t.includes(word));
+  return distro ? distro[1](t) : DEFAULT_OS;
+}
+
+/** The text in an SVG drawing's <text> elements, one line each. */
+function svgText(svg: string): string {
+  return [...svg.matchAll(/<text[^>]*>([\s\S]*?)<\/text>/g)]
+    .map((m) => m[1].replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").trim())
+    .filter(Boolean)
+    .join("\n");
+}
+
+/** The text of an SVG drawing, and its shape and size (scaled by `scale`). */
+export function drawingNote(d: G3Drawing, scale: number): { text: string; shape: NoteShape; w: number; h: number } | null {
+  const svg = d.svg ?? "";
+  const text = svgText(svg);
+  const shape: NoteShape = svg.includes("<ellipse") ? "ellipse" : svg.includes("<rect") ? "rect" : "text";
+  if (!text && shape === "text") return null;
+  const w = Number(/width="([\d.]+)"/.exec(svg)?.[1] ?? 0);
+  const h = Number(/height="([\d.]+)"/.exec(svg)?.[1] ?? 0);
+  return { text, shape, w: Math.max(120, Math.min(600, w * scale)) || 200, h: Math.max(50, Math.min(400, h * scale)) || 90 };
+}

package/src/lib/tool/issues.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "vitest";
+import { canvasIssues } from "./issues";
+import { issueText, lan, machine, note, switchNode } from "@/test/lab";
+
+describe("canvasIssues", () => {
+  test("finds nothing on a lab with distinct names and agreeing blocks", () => {
+    expect(canvasIssues([machine("web"), lan("office"), switchNode("sw1"), note("n")], issueText)).toEqual([]);
+  });
+
+  test("a VLAN with two blocks on two switches", () => {
+    const other = switchNode("sw2", { vlans: [{ id: 10, cidr: "10.10.99.0/24" }] });
+    expect(canvasIssues([switchNode("sw1"), other], issueText)).toEqual(["vlan10: 10.10.10.0/24 vs 10.10.99.0/24 on sw2"]);
+  });
+
+  test("a LAN area named like a VLAN with another block than its switches", () => {
+    expect(canvasIssues([switchNode("sw1"), lan("l", { name: "vlan20", cidr: "10.10.2.0/24" })], issueText)).toEqual([
+      "area vlan20: 10.10.2.0/24 vs 10.10.20.0/24",
+    ]);
+  });
+
+  test("a machine, a LAN or a switch without a name", () => {
+    const nodes = [machine("m", { name: "" }), lan("l", { name: "" }), switchNode("s", { name: "" })];
+    expect(canvasIssues(nodes, issueText)).toEqual(["unnamed machine", "unnamed lan", "unnamed switch"]);
+  });
+
+  test("each port entry Isoloom couldn't take, by machine", () => {
+    const nodes = [machine("web", { ports: "80, http, 53/udp, 70000" }), machine("db", { ports: "5432" })];
+    expect(canvasIssues(nodes, issueText)).toEqual(["web: port http", "web: port 70000"]);
+  });
+
+  test("the same name twice, per kind of node", () => {
+    const nodes = [machine("a", { name: "web" }), machine("b", { name: "web" }), lan("c", { name: "web" }), lan("d", { name: "x" }), lan("e", { name: "x" })];
+    expect(canvasIssues(nodes, issueText)).toEqual(["two machines web", "two lans x"]);
+  });
+});

package/src/lib/tool/issues.ts

@@ -0,0 +1,60 @@
+import { isLan, isMachine, isSwitch, type LabNode } from "./model";
+import { readPorts } from "./ports";
+import { vlanName } from "./vlans";
+
+/** The editor's words for what the canvas finds wrong (see the editor's text). */
+export interface IssueText {
+  vlanBlocks: (vlan: string, block: string, other: string, sw: string) => string;
+  areaBlock: (lan: string, block: string, switches: string) => string;
+  noName: Record<"machine" | "lan" | "switch", string>;
+  sameName: Record<"machine" | "lan" | "switch", (name: string) => string>;
+  /** A ports field entry Isoloom couldn't take: the machine and the entry. */
+  badPort: (machine: string, entry: string) => string;
+}
+
+/** One VLAN, one block: every switch (and a LAN area of that name) must agree on it. */
+function blockIssues(nodes: LabNode[], text: IssueText): string[] {
+  const issues: string[] = [];
+  const blocks = new Map<string, string>();
+  for (const sw of nodes.filter(isSwitch)) {
+    for (const v of sw.data.vlans) {
+      const name = vlanName(v.id);
+      const seen = blocks.get(name);
+      if (seen && seen !== v.cidr) issues.push(text.vlanBlocks(name, seen, v.cidr, sw.data.name));
+      blocks.set(name, v.cidr);
+    }
+  }
+  for (const l of nodes.filter(isLan)) {
+    const seen = blocks.get(l.data.name);
+    if (seen && seen !== l.data.cidr) issues.push(text.areaBlock(l.data.name, l.data.cidr, seen));
+  }
+  return issues;
+}
+
+/** Names Isoloom would reject (none) or merge (the same twice), per kind of node. */
+function nameIssues(nodes: LabNode[], text: IssueText): string[] {
+  const issues: string[] = [];
+  for (const [what, list] of [
+    ["machine", nodes.filter(isMachine)],
+    ["lan", nodes.filter(isLan)],
+    ["switch", nodes.filter(isSwitch)],
+  ] as const) {
+    const seen = new Set<string>();
+    for (const n of list) {
+      if (!n.data.name) issues.push(text.noName[what]);
+      else if (seen.has(n.data.name)) issues.push(text.sameName[what](n.data.name));
+      seen.add(n.data.name);
+    }
+  }
+  return issues;
+}
+
+/** Port entries Isoloom couldn't take (not a port, or not one of its protocols): left out of the topology, so said here. */
+function portIssues(nodes: LabNode[], text: IssueText): string[] {
+  return nodes.filter(isMachine).flatMap((m) => readPorts(m.data.ports).bad.map((entry) => text.badPort(m.data.name, entry)));
+}
+
+/** What the canvas can tell before the engine runs: names Isoloom would reject or merge, ports it couldn't take. */
+export function canvasIssues(nodes: LabNode[], text: IssueText): string[] {
+  return [...blockIssues(nodes, text), ...nameIssues(nodes, text), ...portIssues(nodes, text)];
+}