systemview 1.16.9 → 1.17.0

package/cli/connectService.js

@@ -0,0 +1,78 @@
+const fs = require("fs");
+const path = require("path");
+const { HttpClient, Client } = require("systemlynx");
+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;
+  try {
+    return JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+  } 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));
+}
+
+module.exports = async function connectService(serviceId, url, { manifest: manifestPath } = {}) {
+  const manifestFile = manifestPath || path.join(process.cwd(), "systemview.manifest.json");
+
+  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>");
+      return;
+    }
+    log.info(`Re-probing ${manifest.services.length} service(s)...`);
+    for (const { serviceId: id, system } of manifest.services) {
+      try {
+        const connection = await probeService(system.connectionData.serviceUrl);
+        writeManifest(manifestFile, connection);
+        log.success(`${id} updated`);
+      } catch (err) {
+        log.error(`${id} failed: ${err.message}`);
+      }
+    }
+    printManifestSummary(readManifest(manifestFile));
+    return;
+  }
+
+  log.info(`Connecting to ${serviceId || "service"} @ ${url}...`);
+  try {
+    const connection = await probeService(url);
+    writeManifest(manifestFile, connection);
+    printManifestSummary(readManifest(manifestFile));
+  } 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/index.js

@@ -1,53 +1,44 @@
 #!/usr/bin/env node
 
-/**
- * SystemView
- * A documentation and testing suite for SystemLynx
- *
- * @author Odion Edwards <none>
- */
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-const openBrowser = require("./openBrowser");
-const init = require("./utils/init");
-const cli = require("./utils/cli");
-const log = require("./utils/log");
 
+const { input, flags, showHelp } = require("./utils/cli");
+const init = require("./utils/init");
+const log = require("./logger");
 const launchApp = require("./launchApp");
 const runTests = require("./runTests");
 const appIsRunning = require("./appIsRunning");
+const openBrowser = require("./openBrowser");
+const connectService = require("./connectService");
+const probe = require("./probe");
 const { HttpClient } = require("systemlynx");
 
-const input = cli.input;
-const flags = cli.flags;
-const { clear, debug } = flags;
 const DEFAULT_PORT = 3000;
 
 async function startApp() {
-  const port = isNaN(input[1]) ? DEFAULT_PORT : input[1];
-
+  const port = isNaN(input[1]) ? DEFAULT_PORT : Number(input[1]);
   try {
-    await launchApp(port);
+    await launchApp(port, { interactive: true });
   } catch (error) {
-    log("Launch failed:" + error.message, "error");
-    console.log(error);
+    log.error("Launch failed: " + error.message);
   }
 }
 
 async function startTest() {
+  const project_code = input[1];
+  const namespace = input[2];
   const url = `http://localhost:${DEFAULT_PORT}`;
-  input.shift();
   try {
-    const lineReader = await launchApp(DEFAULT_PORT);
-    setTimeout(async () => {
-      await runTests(url, ...input);
-      if (lineReader) {
-        lineReader.prompt();
-      } else {
-        process.exit(0);
-      }
-    }, 0);
+    await launchApp(DEFAULT_PORT);
+    const exitCode = await runTests(url, project_code, namespace, {
+      json: flags.json,
+      verbose: flags.verbose,
+      manifest: flags.manifest,
+    });
+    process.exit(exitCode);
   } catch (error) {
-    console.error("Error executing tests:", error.message);
+    log.error("Error executing tests: " + error.message);
+    process.exit(1);
   }
 }
 
@@ -56,56 +47,58 @@ async function open() {
   const namespace = input[2];
   const ui = `http://localhost:${DEFAULT_PORT}`;
   const api = `${ui}/systemview/api`;
-  if (await appIsRunning(api)) {
-    openBrowser(ui, project_code, namespace);
-    process.exit(0);
-  } else {
+  if (!(await appIsRunning(api))) {
     await launchApp(DEFAULT_PORT);
-    openBrowser(ui, project_code, namespace);
   }
+  openBrowser(ui, project_code, namespace);
+  process.exit(0);
 }
+
 async function quitApp() {
-  const port = isNaN(input[1]) ? DEFAULT_PORT : input[1];
+  const port = isNaN(input[1]) ? DEFAULT_PORT : Number(input[1]);
   const api = `http://localhost:${port}/systemview/api`;
 
   if (await appIsRunning(api)) {
-    log("SystemView is running from another terminal", "info", "info");
-    log("Attempting remote shutdown...", "info", "info");
-
+    log.info("Attempting remote shutdown...");
     const url = `${api}/SystemView/shutdown`;
-    const method = "put";
-    HttpClient.request({ url, method })
-      .then(() => console.log("SystemView shutdown successful!"))
-      .catch(async (error) => {
-        if (await appIsRunning(api)) {
-          log("Remote shutdown failed!", "error", "error");
-          console.error(error);
-        } else {
-          console.log("SystemView shutdown successful!");
-        }
-      });
+    try {
+      await HttpClient.request({ url, method: "put" });
+      log.success("SystemView shutdown successful!");
+      process.exit(0);
+    } catch (error) {
+      if (!(await appIsRunning(api))) {
+        log.success("SystemView shutdown successful!");
+        process.exit(0);
+      } else {
+        log.error("Remote shutdown failed!");
+        process.exit(1);
+      }
+    }
   } else {
-    log(`SystemView instance not found @${api}`, "warning", "warning");
-    console.log("Please include the port if default port is not being used:");
-    log("systemview shutdown 4000", "info", "example");
+    log.warn(`No SystemView instance found @ ${api}`);
+    process.exit(0);
   }
 }
 
 (async () => {
-  init({ clear });
-  if (input[0] === "open") {
-    open();
-  } else if (input.includes(`help`)) {
-    cli.showHelp(0);
-  } else if (input.includes("test")) {
-    startTest();
-  } else if (["exit", "q", "shutdown", "stop"].includes(input[0])) {
-    quitApp();
-  } else if (input[0] === "start") {
-    startApp();
+  init();
+  const command = input[0];
+
+  if (command === "open") {
+    await open();
+  } else if (command === "help" || input.includes("help")) {
+    showHelp();
+  } else if (command === "test") {
+    await startTest();
+  } else if (["exit", "q", "shutdown", "stop"].includes(command)) {
+    await quitApp();
+  } else if (command === "connect") {
+    await connectService(input[1], input[2], { manifest: flags.manifest });
+    process.exit(0);
+  } else if (command === "probe") {
+    const exitCode = await probe(input[1], input[2], { json: flags.json, manifest: flags.manifest });
+    process.exit(exitCode || 0);
   } else {
     await startApp();
   }
-  cli.input = [];
-  debug && log(flags);
 })();

package/cli/launchApp.js

@@ -1,24 +1,31 @@
-const log = require("./utils/log");
+const log = require("./logger");
 const appIsRunning = require("./appIsRunning");
 const launchSystemView = require("../api");
 const startLineReader = require("./startLineReader");
 
-module.exports = async function launchApp(port) {
+module.exports = async function launchApp(port, { interactive = false } = {}) {
   const ui = `http://localhost:${port}`;
   const api = `${ui}/systemview/api`;
+
   function logConnection() {
-    log("connected!", "success");
-    console.log(`SystemView UI running @${ui}`);
-    console.log(`SystemView API running @${api}\n`);
+    log.success("connected!");
+    console.log(`  SystemView UI  → ${ui}`);
+    console.log(`  SystemView API → ${api}\n`);
   }
 
   if (await appIsRunning(api)) {
-    log("SystemView is running from another terminal", "info", "info");
-    logConnection();
-  } else {
-    log("Launching...");
-    await launchSystemView(port);
-    logConnection();
+    if (interactive) {
+      log.info("SystemView is running from another terminal");
+      logConnection();
+    }
+    return;
+  }
+
+  if (interactive) log.info("Launching...");
+  await launchSystemView(port);
+  logConnection();
+
+  if (interactive) {
     return startLineReader(ui);
   }
 };

package/cli/logger.js

@@ -0,0 +1,9 @@
+const chalk = require("chalk");
+
+module.exports = {
+  info:    (msg) => console.log(chalk.blue("  ℹ  ") + msg),
+  success: (msg) => console.log(chalk.green("  ✔  ") + msg),
+  warn:    (msg) => console.log(chalk.yellow("  ⚠  ") + msg),
+  error:   (msg) => console.error(chalk.red("  ✖  ") + msg),
+  plain:   (msg) => console.log(msg),
+};

package/cli/probe.js

@@ -0,0 +1,71 @@
+const fs = require("fs");
+const path = require("path");
+const { Client } = require("systemlynx");
+const log = require("./logger");
+
+module.exports = async function probe(namespace, argsStr, { json = false, manifest: manifestPath } = {}) {
+  if (!namespace) {
+    log.error("Usage: systemview probe <ServiceId.Module.method> [args]");
+    return 1;
+  }
+
+  const parts = namespace.split(".");
+  if (parts.length !== 3) {
+    log.error("Namespace must be in format: ServiceId.Module.method");
+    return 1;
+  }
+
+  const [serviceId, moduleName, methodName] = parts;
+
+  let args = [];
+  if (argsStr) {
+    try {
+      const parsed = JSON.parse(argsStr);
+      args = Array.isArray(parsed) ? parsed : [parsed];
+    } catch {
+      args = [argsStr];
+    }
+  }
+
+  const manifestFile = manifestPath || path.join(process.cwd(), "systemview.manifest.json");
+  if (!fs.existsSync(manifestFile)) {
+    log.error(`No manifest found at ${manifestFile}. Run: systemview connect <serviceId> <url>`);
+    return 1;
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+  } catch (err) {
+    log.error(`Failed to read manifest: ${err.message}`);
+    return 1;
+  }
+
+  const services = manifest.services || [manifest];
+  const service = services.find((s) => s.serviceId === serviceId);
+  if (!service) {
+    log.error(`Service "${serviceId}" not found in manifest`);
+    return 1;
+  }
+
+  if (!json) log.info(`${serviceId}.${moduleName}.${methodName}(${argsStr || ""})`);
+
+  try {
+    const client = Client.createService(service.system.connectionData);
+    const result = await client[moduleName][methodName](...args);
+    if (json) {
+      process.stdout.write(JSON.stringify({ serviceId, moduleName, methodName, args, result }, null, 2) + "\n");
+    } else {
+      log.success("result:");
+      console.log(JSON.stringify(result, null, 2));
+    }
+    return 0;
+  } catch (err) {
+    if (json) {
+      process.stdout.write(JSON.stringify({ serviceId, moduleName, methodName, args, error: err.message }, null, 2) + "\n");
+    } else {
+      log.error(err.message);
+    }
+    return 1;
+  }
+};