@tikoci/rosetta 0.3.0 → 0.4.0

package/src/query.test.ts

@@ -87,13 +87,15 @@ beforeAll(() => {
      license_level, operating_system, ram, ram_mb, storage, storage_mb,
      poe_in, poe_out, wireless_24_chains, wireless_5_chains,
      eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
-     eth_multigig, usb_ports, sim_slots, msrp_usd)
+     eth_multigig, usb_ports, sim_slots, msrp_usd,
+     product_url, block_diagram_url)
     VALUES
     ('hAP ax3', 'C53UiG+5HPaxD2HPaxD', 'ARM 64bit', 'IPQ-6010', 4, 'auto (864 - 1800) MHz',
      4, 'RouterOS v7', '1 GB', 1024, '128 MB', 128,
      '802.3af/at', NULL, 2, 2,
      NULL, 4, 1, NULL, NULL,
-     NULL, 1, NULL, 139.00)`);
+     NULL, 1, NULL, 139.00,
+     'https://mikrotik.com/product/hap_ax3', 'https://cdn.mikrotik.com/web-assets/product_files/hap_ax3_123.png')`);
 
   db.run(`INSERT INTO devices
     (product_name, product_code, architecture, cpu, cpu_cores, cpu_frequency,
@@ -161,6 +163,17 @@ beforeAll(() => {
      NULL, 13, NULL, NULL, NULL,
      NULL, NULL, NULL, 369.00)`);
 
+  // Device test results fixtures (hAP ax3 = id 1)
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ethernet', 'Routing', '25 ip filter rules', 512, 755.9, 3096.2)`);
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ethernet', 'Routing', 'none (fast path)', 512, 2332.0, 9551.9)`);
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ipsec', 'Single tunnel', 'AES-128-CBC + SHA1', 1400, 120.9, 1354.1)`);
+
   // Page 3: a "large" page with sections for TOC testing
   // Text is ~200 chars to keep fixture small, but we'll use max_length=50 to trigger truncation
   db.run(`INSERT INTO pages
@@ -783,6 +796,37 @@ describe("searchDevices", () => {
     const res = searchDevices("");
     expect(res.results).toHaveLength(0);
   });
+
+  test("exact match includes test_results", () => {
+    const res = searchDevices("hAP ax3");
+    expect(res.mode).toBe("exact");
+    expect(res.results).toHaveLength(1);
+    const dev = res.results[0];
+    expect(dev.test_results).toBeDefined();
+    expect(dev.test_results!.length).toBe(3);
+    expect(dev.test_results!.some((t) => t.test_type === "ethernet")).toBe(true);
+    expect(dev.test_results!.some((t) => t.test_type === "ipsec")).toBe(true);
+  });
+
+  test("LIKE match with ≤5 results includes test_results", () => {
+    const res = searchDevices("RB1100");
+    expect(res.mode).toBe("like");
+    expect(res.results.length).toBeLessThanOrEqual(5);
+    // RB1100 devices have no test results, but the field should still be populated (empty array)
+    expect(res.results.every((d) => Array.isArray(d.test_results))).toBe(true);
+  });
+
+  test("exact match includes product_url and block_diagram_url", () => {
+    const res = searchDevices("hAP ax3");
+    expect(res.results[0].product_url).toBe("https://mikrotik.com/product/hap_ax3");
+    expect(res.results[0].block_diagram_url).toContain("cdn.mikrotik.com");
+  });
+
+  test("devices without product_url return null", () => {
+    const res = searchDevices("CCR2216-1G-12XS-2XQ");
+    expect(res.results[0].product_url).toBeNull();
+    expect(res.results[0].block_diagram_url).toBeNull();
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -943,7 +987,7 @@ describe("schema", () => {
     const expected = [
       "pages", "properties", "callouts", "sections",
       "commands", "command_versions", "ros_versions",
-      "devices", "changelogs", "schema_migrations",
+      "devices", "device_test_results", "changelogs", "schema_migrations",
     ];
     for (const table of expected) {
       expect(names).toContain(table);

package/src/query.ts

@@ -669,6 +669,15 @@ export function browseCommandsAtVersion(
 
 // ── Device lookup and search ──
 
+export type DeviceTestResult = {
+  test_type: string;
+  mode: string;
+  configuration: string;
+  packet_size: number;
+  throughput_kpps: number | null;
+  throughput_mbps: number | null;
+};
+
 export type DeviceResult = {
   id: number;
   product_name: string;
@@ -698,6 +707,9 @@ export type DeviceResult = {
   usb_ports: number | null;
   sim_slots: number | null;
   msrp_usd: number | null;
+  product_url: string | null;
+  block_diagram_url: string | null;
+  test_results?: DeviceTestResult[];
 };
 
 export type DeviceFilters = {
@@ -715,9 +727,29 @@ const DEVICE_SELECT = `SELECT id, product_name, product_code, architecture, cpu,
     ram, ram_mb, storage, storage_mb, dimensions, poe_in, poe_out,
     max_power_w, wireless_24_chains, wireless_5_chains,
     eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
-    eth_multigig, usb_ports, sim_slots, msrp_usd
+    eth_multigig, usb_ports, sim_slots, msrp_usd,
+    product_url, block_diagram_url
   FROM devices`;
 
+/** Get test results for a device by ID. */
+function getDeviceTestResults(deviceId: number): DeviceTestResult[] {
+  return db.prepare(
+    `SELECT test_type, mode, configuration, packet_size,
+            throughput_kpps, throughput_mbps
+     FROM device_test_results
+     WHERE device_id = ?
+     ORDER BY test_type, mode, configuration, packet_size DESC`
+  ).all(deviceId) as DeviceTestResult[];
+}
+
+/** Attach test results to device results (for single/exact lookups). */
+function attachTestResults(devices: DeviceResult[]): DeviceResult[] {
+  for (const dev of devices) {
+    dev.test_results = getDeviceTestResults(dev.id);
+  }
+  return devices;
+}
+
 /** Build FTS5 query for devices — appends prefix '*' to every term.
  *  Model numbers like "RB1100" need prefix matching to find "RB1100AHx4".
  *  No compound term handling (not relevant for device names). */
@@ -739,7 +771,7 @@ export function searchDevices(
       .prepare(`${DEVICE_SELECT} WHERE product_name = ? COLLATE NOCASE OR product_code = ? COLLATE NOCASE`)
       .all(query, query) as DeviceResult[];
     if (exact.length > 0) {
-      return { results: exact, mode: "exact", total: exact.length };
+      return { results: attachTestResults(exact), mode: "exact", total: exact.length };
     }
   }
 
@@ -760,6 +792,8 @@ export function searchDevices(
       const likeSql = `${DEVICE_SELECT} d WHERE ${likeConditions.join(" AND ")} ORDER BY d.product_name LIMIT ?`;
       const likeResults = db.prepare(likeSql).all(...likeParams, limit) as DeviceResult[];
       if (likeResults.length > 0) {
+        // Attach test results for small result sets (likely specific device lookups)
+        if (likeResults.length <= 5) attachTestResults(likeResults);
         return { results: likeResults, mode: "like", total: likeResults.length };
       }
     }
@@ -807,7 +841,8 @@ export function searchDevices(
           d.ram, d.ram_mb, d.storage, d.storage_mb, d.dimensions, d.poe_in, d.poe_out,
           d.max_power_w, d.wireless_24_chains, d.wireless_5_chains,
           d.eth_fast, d.eth_gigabit, d.eth_2500, d.sfp_ports, d.sfp_plus_ports,
-          d.eth_multigig, d.usb_ports, d.sim_slots, d.msrp_usd
+          d.eth_multigig, d.usb_ports, d.sim_slots, d.msrp_usd,
+          d.product_url, d.block_diagram_url
         FROM devices_fts fts
         JOIN devices d ON d.id = fts.rowid
         WHERE devices_fts MATCH ?${filterWhere}

package/src/release.test.ts

@@ -238,6 +238,7 @@ describe("release.yml", () => {
     expect(src).toContain("extract-properties.ts");
     expect(src).toContain("extract-commands.ts");
     expect(src).toContain("extract-devices.ts");
+    expect(src).toContain("extract-test-results.ts");
     expect(src).toContain("extract-changelogs.ts");
     expect(src).toContain("link-commands.ts");
   });
@@ -280,3 +281,108 @@ describe("CLI flags", () => {
     expect(src).toContain("--setup");
   });
 });
+
+// ---------------------------------------------------------------------------
+// HTTP transport structural checks — catch per-session breakage at build time
+// ---------------------------------------------------------------------------
+
+describe("HTTP transport structure", () => {
+  const src = readText("src/mcp.ts");
+
+  test("uses per-session transport routing (not single shared transport)", () => {
+    // The single-transport pattern was: `await server.connect(httpTransport)` at module level
+    // followed by `httpTransport.handleRequest(req)`. The per-session pattern has a
+    // transports Map and creates transport/server per session.
+    expect(src).toContain("new Map");
+    expect(src).toContain("transports.set");
+    expect(src).toContain("transports.get");
+  });
+
+  test("creates new McpServer per session, not one shared instance", () => {
+    // createServer() factory must exist and be called per-session
+    expect(src).toContain("function createServer()");
+    expect(src).toContain("createServer()");
+  });
+
+  test("checks isInitializeRequest before creating transport", () => {
+    expect(src).toContain("isInitializeRequest");
+  });
+
+  test("registers onsessioninitialized callback", () => {
+    expect(src).toContain("onsessioninitialized");
+  });
+
+  test("cleans up transport on close", () => {
+    expect(src).toContain("transport.onclose");
+    expect(src).toContain("transports.delete");
+  });
+
+  test("passes parsedBody to handleRequest after consuming body", () => {
+    // Once we req.json() for isInitializeRequest check, the body is consumed.
+    // Must pass parsedBody so the transport doesn't try to re-parse.
+    expect(src).toContain("parsedBody");
+  });
+
+  test("handles missing session ID on non-initialize requests", () => {
+    expect(src).toContain("No valid session ID provided");
+  });
+
+  test("handles invalid session ID with 404", () => {
+    expect(src).toContain("Session not found");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Container / entrypoint checks
+// ---------------------------------------------------------------------------
+
+describe("container entrypoint", () => {
+  test("entrypoint script exists", () => {
+    expect(existsSync(path.join(ROOT, "scripts/container-entrypoint.sh"))).toBe(true);
+  });
+
+  test("defaults to --http mode", () => {
+    const src = readText("scripts/container-entrypoint.sh");
+    expect(src).toContain("--http");
+  });
+
+  test("defaults to 0.0.0.0 host binding", () => {
+    const src = readText("scripts/container-entrypoint.sh");
+    expect(src).toContain("0.0.0.0");
+  });
+
+  test("supports TLS via env vars", () => {
+    const src = readText("scripts/container-entrypoint.sh");
+    expect(src).toContain("TLS_CERT_PATH");
+    expect(src).toContain("TLS_KEY_PATH");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Dockerfile structure
+// ---------------------------------------------------------------------------
+
+describe("Dockerfile.release", () => {
+  test("copies entrypoint script", () => {
+    const src = readText("Dockerfile.release");
+    expect(src).toContain("container-entrypoint.sh");
+    expect(src).toContain("ENTRYPOINT");
+  });
+
+  test("copies database into image", () => {
+    const src = readText("Dockerfile.release");
+    expect(src).toContain("ros-help.db");
+  });
+
+  test("exposes port 8080", () => {
+    const src = readText("Dockerfile.release");
+    expect(src).toContain("EXPOSE 8080");
+  });
+
+  test("injects build constants", () => {
+    const src = readText("Dockerfile.release");
+    expect(src).toContain("IS_COMPILED");
+    expect(src).toContain("VERSION");
+    expect(src).toContain("REPO_URL");
+  });
+});

package/src/setup.ts

@@ -65,6 +65,7 @@ export async function runSetup(force = false) {
   const dbPath = resolveDbPath(import.meta.dirname);
 
   console.log(`rosetta ${RELEASE_VERSION}`);
+  console.log(`  ${link("https://github.com/tikoci/rosetta")}`);
   console.log();
 
   // ── Download DB if needed ──
@@ -301,8 +302,29 @@ function printHttpConfig(startCmd: string) {
   console.log("  For LAN access, replace localhost with the server's IP address.");
   console.log("  Use a reverse proxy (nginx, caddy) for production HTTPS.");
   console.log();
+
+  printMikroTikConfig();
+}
+
+/** Format a clickable terminal hyperlink using OSC 8 escape sequences. */
+function link(url: string, display?: string): string {
+  return `\x1b]8;;${url}\x07${display ?? url}\x1b]8;;\x07`;
 }
 
+function printMikroTikConfig() {
+  console.log("─".repeat(60));
+  console.log("MikroTik /app container (RouterOS 7.22+, x86 or ARM64):");
+  console.log("─".repeat(60));
+  console.log();
+  console.log("  Run directly on your MikroTik router — any MCP client on");
+  console.log("  the network can connect to the URL shown in the router UI.");
+  console.log();
+  console.log("  Requires: container package + device-mode enabled.");
+  console.log(`  See: ${link("https://github.com/tikoci/rosetta#install-on-mikrotik-app", "README — Install on MikroTik")}`);
+  console.log();
+}
+
+
 // Run directly
 if (import.meta.main) {
   const force = process.argv.includes("--force");