systemview 1.20.0 → 1.21.0

package/cli/connectService.js

@@ -1,80 +1,172 @@
-const fs = require("fs");
-const path = require("path");
-const { HttpClient } = require("systemlynx");
-const { createCookieClient } = require("./cookieClient");
-const Client = createCookieClient();
+const { HttpClient, createClient } = require("systemlynx");
+const { createCookieHttpClient } = require("./cookieClient");
+const cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
 const log = require("./logger");
 
-async function probeService(url) {
-  const connectionData = await HttpClient.request({ url });
-  if (!connectionData.SystemLynxService) {
-    throw new Error(`No SystemLynx service found at ${url}`);
-  }
-  const client = Client.createService(connectionData);
-  const connection = await client.Plugin.getConnection();
-  return connection; // { projectCode, serviceId, system, specList }
-}
-
-function readManifest(manifestFile) {
-  if (!fs.existsSync(manifestFile)) return null;
+async function getUiSvc(uiUrl) {
   try {
-    return JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+    const { SystemView } = await Client.loadService(`${uiUrl}/systemview/api`);
+    return SystemView;
   } catch {
     return null;
   }
 }
 
-function writeManifest(manifestFile, connection) {
-  const manifest = readManifest(manifestFile) || { projectCode: connection.projectCode, services: [] };
-  if (!manifest.services) manifest.services = [];
-  const entry = { serviceId: connection.serviceId, system: connection.system, specList: connection.specList };
-  const idx = manifest.services.findIndex((s) => s.serviceId === connection.serviceId);
-  if (idx > -1) manifest.services[idx] = entry;
-  else manifest.services.push(entry);
-  manifest.projectCode = connection.projectCode;
-  fs.writeFileSync(manifestFile, JSON.stringify(manifest, null, 2));
+async function notifyUi(uiSvc, project) {
+  if (!uiSvc) return;
+  try {
+    await uiSvc.connect(project);
+  } catch {}
+}
+
+function serviceIdFromRoute(route) {
+  const segments = (route || "").split("/").filter(Boolean);
+  return [...segments].reverse().find((s) => s.toLowerCase() !== "api") || "Service";
 }
 
-module.exports = async function connectService(serviceId, url, { manifest: manifestPath } = {}) {
-  const manifestFile = manifestPath || path.join(process.cwd(), "systemview.manifest.json");
+function printSummary(entries) {
+  console.log("");
+  entries.forEach(({ projectCode, serviceId, url }) => {
+    log.plain(`  ${projectCode} › ${serviceId}${url ? "  " + url : ""}`);
+  });
+  console.log("");
+}
 
-  if (!url) {
-    // Re-probe all services already in the manifest
-    const manifest = readManifest(manifestFile);
-    if (!manifest || !manifest.services || !manifest.services.length) {
-      log.warn("No manifest found. Use: systemview connect <serviceId> <url>");
+module.exports = async function connectService(target, { useManifest, force, connectedUrls, uiUrl } = {}) {
+  const uiSvc = await getUiSvc(uiUrl);
+
+  // connect (no args) — connect to every service stored in UI
+  if (!target) {
+    if (!uiSvc) {
+      log.warn("SystemView UI not running. Start it first or provide a URL.");
+      return;
+    }
+    const projects = await uiSvc.getProjects();
+    const all = Object.entries(projects).flatMap(([pc, svcs]) =>
+      svcs.map((s) => ({ projectCode: pc, ...s }))
+    );
+    if (!all.length) {
+      log.warn("No services in UI store. Use: systemview connect <url>");
       return;
     }
-    log.info(`Re-probing ${manifest.services.length} service(s)...`);
-    for (const { serviceId: id, system } of manifest.services) {
+    log.info(`Connecting to ${all.length} stored service(s)...`);
+    const summary = [];
+    for (const { projectCode, serviceId, connectionData, serviceUrl } of all) {
+      const url = serviceUrl || (connectionData && connectionData.serviceUrl);
+      if (!url) continue;
       try {
-        const connection = await probeService(system.connectionData.serviceUrl);
-        writeManifest(manifestFile, connection);
-        log.success(`${id} updated`);
+        if (force) {
+          await Client.loadService(url);
+        } else {
+          Client.createService(connectionData);
+        }
+        connectedUrls.add(url);
+        log.success(`${projectCode} › ${serviceId}`);
+        summary.push({ projectCode, serviceId, url });
       } catch (err) {
-        log.error(`${id} failed: ${err.message}`);
+        log.error(`${serviceId} failed: ${err.message}`);
       }
     }
-    printManifestSummary(readManifest(manifestFile));
+    printSummary(summary);
     return;
   }
 
-  log.info(`Connecting to ${serviceId || "service"} @ ${url}...`);
+  const isUrl = /^https?:\/\//i.test(target);
+
+  // connect <projectCode> — look up from UI store
+  if (!isUrl) {
+    if (!uiSvc) {
+      log.warn("SystemView UI not running. Cannot look up project by code.");
+      return;
+    }
+    const services = await uiSvc.getServices(target);
+    if (!services || !services.length) {
+      log.warn(`No services found for project: ${target}`);
+      return;
+    }
+    log.info(`Connecting to ${services.length} service(s) for ${target}...`);
+    const summary = [];
+    for (const { serviceId, system } of services) {
+      const { serviceUrl } = system.connectionData;
+      try {
+        if (force) {
+          await Client.loadService(serviceUrl);
+        } else {
+          Client.createService(system.connectionData);
+        }
+        connectedUrls.add(serviceUrl);
+        log.success(`${target} › ${serviceId}`);
+        summary.push({ projectCode: target, serviceId, url: serviceUrl });
+      } catch (err) {
+        log.error(`${serviceId} failed: ${err.message}`);
+      }
+    }
+    printSummary(summary);
+    return;
+  }
+
+  // connect <url> [--manifest]
+  log.info(`Connecting to ${target}...`);
   try {
-    const connection = await probeService(url);
-    writeManifest(manifestFile, connection);
-    printManifestSummary(readManifest(manifestFile));
+    if (useManifest) {
+      const svc = await Client.loadService(target);
+      let manifest = null;
+      try { manifest = await svc.Plugin.getManifest(); } catch {}
+      if (manifest && manifest.services && manifest.services.length) {
+        log.info(`Plugin manifest found: ${manifest.projectCode} (${manifest.services.length} service(s))`);
+        const summary = [];
+        for (const service of manifest.services) {
+          try {
+            Client.createService(service.system.connectionData);
+            connectedUrls.add(service.system.connectionData.serviceUrl);
+            await notifyUi(uiSvc, {
+              system: service.system,
+              projectCode: manifest.projectCode,
+              serviceId: service.serviceId,
+              specList: service.specList || { tests: [], docs: [] },
+            });
+            log.success(`${manifest.projectCode} › ${service.serviceId}`);
+            summary.push({ projectCode: manifest.projectCode, serviceId: service.serviceId, url: service.system.connectionData.serviceUrl });
+          } catch (err) {
+            log.error(`${service.serviceId} failed: ${err.message}`);
+          }
+        }
+        printSummary(summary);
+      } else {
+        log.warn("No plugin manifest found. Storing as connected-services.");
+        const connectionData = await HttpClient.request({ url: target });
+        const serviceId = serviceIdFromRoute(connectionData.route);
+        const project = {
+          system: { connectionData },
+          projectCode: "connected-services",
+          serviceId,
+          specList: { tests: [], docs: [] },
+        };
+        Client.createService(connectionData);
+        connectedUrls.add(target);
+        await notifyUi(uiSvc, project);
+        printSummary([{ projectCode: "connected-services", serviceId, url: target }]);
+      }
+    } else {
+      const connectionData = await HttpClient.request({ url: target });
+      if (!connectionData || !connectionData.SystemLynxService) {
+        throw new Error("No SystemLynx service found at " + target);
+      }
+      const serviceId = serviceIdFromRoute(connectionData.route);
+      const project = {
+        system: { connectionData },
+        projectCode: "connected-services",
+        serviceId,
+        specList: { tests: [], docs: [] },
+      };
+      Client.createService(connectionData);
+      connectedUrls.add(target);
+      await notifyUi(uiSvc, project);
+      log.success(`connected-services › ${serviceId}`);
+      printSummary([{ projectCode: "connected-services", serviceId, url: target }]);
+    }
   } catch (err) {
     log.error(`Connection failed: ${err.message}`);
   }
 };
-
-function printManifestSummary(manifest) {
-  if (!manifest) return;
-  log.plain(`\n  Project: ${manifest.projectCode}`);
-  log.plain(`  Services:`);
-  (manifest.services || []).forEach(({ serviceId, system }) => {
-    log.plain(`    - ${serviceId} @ ${system.connectionData.serviceUrl}`);
-  });
-  log.plain("");
-}

package/cli/cookieClient.js

@@ -87,7 +87,4 @@ function createCookieHttpClient(extraHeaders = {}) {
   };
 }
 
-module.exports = {
-  createCookieHttpClient,
-  createCookieClient: (extraHeaders = {}) => createClient(createCookieHttpClient(extraHeaders)),
-};
+module.exports = { createCookieHttpClient };

package/cli/index.js

@@ -13,17 +13,39 @@ const listTests = require("./listTests");
 const appIsRunning = require("./appIsRunning");
 const openBrowser = require("./openBrowser");
 const connectService = require("./connectService");
+const manifestCommands = require("./manifest");
 const probe = require("./probe");
-const { HttpClient } = require("systemlynx");
-const { createCookieClient } = require("./cookieClient");
+const logsCommand = require("./logs");
+const { HttpClient, createClient } = require("systemlynx");
+const { createCookieHttpClient } = require("./cookieClient");
+const cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
 
 const DEFAULT_PORT = 3000;
 const VERSION = require("../package.json").version;
+const UI_URL = `http://localhost:${DEFAULT_PORT}`;
+
+const MANIFEST_FILE = flags.manifest || path.join(process.cwd(), "systemview.manifest.json");
+const connectedUrls = new Set();
+
+function loadManifest() {
+  if (!fs.existsSync(MANIFEST_FILE)) return;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(MANIFEST_FILE, "utf8"));
+    const services = manifest.services || [manifest];
+    for (const { system } of services) {
+      if (system && system.connectionData) {
+        Client.createService(system.connectionData);
+        connectedUrls.add(system.connectionData.serviceUrl);
+      }
+    }
+  } catch {}
+}
 
 async function startApp() {
   const port = isNaN(input[1]) ? DEFAULT_PORT : Number(input[1]);
   try {
-    await launchApp(port, { interactive: true });
+    await launchApp(port, { interactive: true, connectedUrls });
   } catch (error) {
     log.error("Launch failed: " + error.message);
   }
@@ -32,13 +54,11 @@ async function startApp() {
 async function startTest() {
   const project_code = input[1];
   const namespace = input[2];
-  const url = `http://localhost:${DEFAULT_PORT}`;
   try {
     await launchApp(DEFAULT_PORT);
-    const exitCode = await runTests(url, project_code, namespace, {
+    const exitCode = await runTests(UI_URL, project_code, namespace, {
       json: flags.json,
       verbose: flags.verbose,
-      manifest: flags.manifest,
       headers: flags.headers,
       bail: flags.bail,
       dryRun: flags.dryRun,
@@ -56,41 +76,34 @@ async function startTest() {
 async function list() {
   const project_code = input[1];
   const namespace = input[2];
-  const url = `http://localhost:${DEFAULT_PORT}`;
-  const api = `${url}/systemview/api`;
+  const api = `${UI_URL}/systemview/api`;
   if (!(await appIsRunning(api))) {
     await launchApp(DEFAULT_PORT);
   }
-  await listTests(url, project_code, namespace, { manifest: flags.manifest, verbose: flags.verbose });
+  await listTests(UI_URL, project_code, namespace, {
+    connectedUrls,
+    verbose: flags.verbose,
+  });
   process.exit(0);
 }
 
 async function open() {
   const project_code = input[1];
   const namespace = input[2];
-  const ui = `http://localhost:${DEFAULT_PORT}`;
-  const api = `${ui}/systemview/api`;
+  const api = `${UI_URL}/systemview/api`;
   if (!(await appIsRunning(api))) {
     await launchApp(DEFAULT_PORT);
   }
 
   let connectedServices = [];
   if (namespace && project_code) {
-    const manifestFile = flags.manifest || path.join(process.cwd(), "systemview.manifest.json");
-    if (fs.existsSync(manifestFile)) {
-      try {
-        const raw = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
-        connectedServices = raw.services ? raw.services : [raw];
-      } catch {}
-    } else {
-      try {
-        const { SystemView } = await createCookieClient().loadService(api);
-        connectedServices = (await SystemView.getServices(project_code)) || [];
-      } catch {}
-    }
+    try {
+      const { SystemView } = await Client.loadService(api);
+      connectedServices = (await SystemView.getServices(project_code)) || [];
+    } catch {}
   }
 
-  openBrowser(ui, project_code, namespace, connectedServices);
+  openBrowser(UI_URL, project_code, namespace, connectedServices);
   process.exit(0);
 }
 
@@ -121,13 +134,17 @@ async function quitApp() {
 }
 
 (async () => {
+  if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
   init();
+  loadManifest();
+
   const command = input[0];
 
-  if (process.argv.includes("--version")) {
-    console.log(VERSION);
-    process.exit(0);
-  } else if (command === "open") {
+  if (command === "open") {
     await open();
   } else if (command === "list") {
     await list();
@@ -138,15 +155,54 @@ async function quitApp() {
   } else if (["exit", "q", "shutdown", "stop"].includes(command)) {
     await quitApp();
   } else if (command === "connect") {
-    await connectService(input[1], input[2], { manifest: flags.manifest });
+    const useManifest = process.argv.includes("--manifest");
+    await connectService(input[1], {
+      useManifest,
+      force: flags.force,
+      connectedUrls,
+      uiUrl: UI_URL,
+    });
+    process.exit(0);
+  } else if (command === "disconnect") {
+    await manifestCommands.disconnect(input[1], input[2], {
+      connectedUrls,
+      uiUrl: UI_URL,
+    });
+    process.exit(0);
+  } else if (command === "manifest") {
+    const sub = input[1];
+    if (sub === "save") {
+      log.warn("manifest save requires an interactive session. Run: systemview start");
+    } else if (sub === "clean") {
+      await manifestCommands.clean(MANIFEST_FILE);
+    } else {
+      log.warn("Usage: systemview manifest <save|clean>");
+    }
     process.exit(0);
   } else if (command === "probe") {
+    await launchApp(DEFAULT_PORT);
     const exitCode = await probe(input[1], input[2], {
       json: flags.json,
       manifest: flags.manifest,
       headers: flags.headers,
+      uiUrl: UI_URL,
     });
     process.exit(exitCode || 0);
+  } else if (command === "logs") {
+    await launchApp(DEFAULT_PORT);
+    await logsCommand(input[1], input[2], {
+      uiUrl: UI_URL,
+      level: flags.level,
+      limit: flags.limit,
+      clear: flags.clear,
+      json: flags.json,
+      current: flags.current,
+      verbose: flags.verbose,
+      filter: flags.filter,
+      or: flags.or,
+      include: flags.include,
+    });
+    process.exit(0);
   } else {
     await startApp();
   }

package/cli/launchApp.js

@@ -3,7 +3,7 @@ const appIsRunning = require("./appIsRunning");
 const launchSystemView = require("../api");
 const startLineReader = require("./startLineReader");
 
-module.exports = async function launchApp(port, { interactive = false } = {}) {
+module.exports = async function launchApp(port, { interactive = false, connectedUrls = new Set() } = {}) {
   const ui = `http://localhost:${port}`;
   const api = `${ui}/systemview/api`;
 
@@ -15,17 +15,18 @@ module.exports = async function launchApp(port, { interactive = false } = {}) {
 
   if (await appIsRunning(api)) {
     if (interactive) {
-      log.info("SystemView is running from another terminal");
+      log.info(`SystemView already running on port ${port} — attaching.`);
       logConnection();
+      return startLineReader(ui, { connectedUrls });
     }
     return;
   }
 
-  if (interactive) log.info("Launching...");
+  if (interactive) log.info(`Launching on port ${port}...`);
   await launchSystemView(port);
   logConnection();
 
   if (interactive) {
-    return startLineReader(ui);
+    return startLineReader(ui, { connectedUrls });
   }
 };

package/cli/listTests.js

@@ -1,19 +1,20 @@
-const fs = require("fs");
-const path = require("path");
-const { createCookieClient } = require("./cookieClient");
+const { createClient } = require("systemlynx");
+const { createCookieHttpClient } = require("./cookieClient");
 const log = require("./logger");
 const chalk = require("chalk");
 
-module.exports = async function listTests(url, project_code, namespace, { manifest: manifestPath, verbose = false } = {}) {
+const cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
+
+module.exports = async function listTests(url, project_code, namespace, { connectedUrls = new Set(), verbose = false } = {}) {
   const api = `${url}/systemview/api`;
-  const Client = createCookieClient();
 
   if (!project_code) {
-    await listAllProjects(api, Client, verbose);
+    await listAllProjects(api, Client, verbose, connectedUrls);
     return;
   }
 
-  const connectedServices = await loadServices(api, project_code, manifestPath, Client);
+  const connectedServices = await loadServices(api, project_code, Client);
   if (!connectedServices.length) {
     log.warn("No connected services found for project: " + project_code);
     return;
@@ -30,7 +31,7 @@ module.exports = async function listTests(url, project_code, namespace, { manife
 
     let testList = [];
     try {
-      const svc = createCookieClient().createService(system.connectionData);
+      const svc = Client.createService(system.connectionData);
       testList = await svc.Plugin.getTests();
     } catch {
       console.log(`${servicePrefix}${chalk.dim(serviceId)}  ${chalk.dim("(could not load tests)")}`);
@@ -93,7 +94,7 @@ module.exports = async function listTests(url, project_code, namespace, { manife
   console.log("");
 };
 
-async function listAllProjects(api, Client, verbose = false) {
+async function listAllProjects(api, Client, verbose = false, connectedUrls = new Set()) {
   let projects;
   try {
     const { SystemView } = await Client.loadService(api);
@@ -120,9 +121,11 @@ async function listAllProjects(api, Client, verbose = false) {
       const isLastService = si === services.length - 1;
       const servicePrefix = isLastService ? "  └── " : "  ├── ";
       const childPad = isLastService ? "       " : "  │    ";
+      const connected = connectedUrls.has(serviceUrl);
+      const connectedMark = connected ? chalk.green(" ●") : chalk.dim(" ○");
 
       if (verbose && connectionData && connectionData.modules) {
-        console.log(`${servicePrefix}${chalk.bold(serviceId)}   ${chalk.dim(serviceUrl)}`);
+        console.log(`${servicePrefix}${chalk.bold(serviceId)}${connectedMark}   ${chalk.dim(serviceUrl)}`);
         const mods = connectionData.modules.filter((m) => m.name !== "Plugin");
         mods.forEach((mod, mi) => {
           const isLastMod = mi === mods.length - 1;
@@ -137,7 +140,7 @@ async function listAllProjects(api, Client, verbose = false) {
           });
         });
       } else {
-        console.log(`${servicePrefix}${serviceId}   ${chalk.dim(serviceUrl)}`);
+        console.log(`${servicePrefix}${serviceId}${connectedMark}   ${chalk.dim(serviceUrl)}`);
       }
     });
     if (pi < codes.length - 1) console.log("");
@@ -145,14 +148,7 @@ async function listAllProjects(api, Client, verbose = false) {
   console.log("");
 }
 
-async function loadServices(api, project_code, manifestPath, Client) {
-  const manifestFile = manifestPath || path.join(process.cwd(), "systemview.manifest.json");
-  if (fs.existsSync(manifestFile)) {
-    try {
-      const raw = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
-      return raw.services ? raw.services : [raw];
-    } catch {}
-  }
+async function loadServices(api, project_code, Client) {
   try {
     const { SystemView } = await Client.loadService(api);
     return (await SystemView.getServices(project_code)) || [];