systemview 1.20.1 → 2.0.0

package/cli/connectService.js

@@ -1,8 +1,9 @@
 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) {

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

@@ -14,8 +14,11 @@ const appIsRunning = require("./appIsRunning");
 const openBrowser = require("./openBrowser");
 const connectService = require("./connectService");
 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;
@@ -84,7 +87,7 @@ async function open() {
       } catch {}
     } else {
       try {
-        const { SystemView } = await createCookieClient().loadService(api);
+        const { SystemView } = await Client.loadService(api);
         connectedServices = (await SystemView.getServices(project_code)) || [];
       } catch {}
     }
@@ -149,6 +152,23 @@ async function quitApp() {
       headers: flags.headers,
     });
     process.exit(exitCode || 0);
+  } else if (command === "logs") {
+    const url = `http://localhost:${DEFAULT_PORT}`;
+    const api = `${url}/systemview/api`;
+    if (!(await appIsRunning(api))) {
+      await launchApp(DEFAULT_PORT);
+    }
+    await logsCommand(url, input[1], input[2], {
+      level: flags.level,
+      limit: flags.limit,
+      clear: flags.clear,
+      json: flags.json,
+      follow: command === "follow" || flags.follow,
+      verbose: flags.verbose,
+      filter: flags.filter,
+      or: flags.or,
+    });
+    process.exit(0);
   } else {
     await startApp();
   }

package/cli/launchApp.js

@@ -17,6 +17,7 @@ module.exports = async function launchApp(port, { interactive = false } = {}) {
     if (interactive) {
       log.info("SystemView is running from another terminal");
       logConnection();
+      return startLineReader(ui);
     }
     return;
   }

package/cli/listTests.js

@@ -1,12 +1,15 @@
 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");
 
+const cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
+
 module.exports = async function listTests(url, project_code, namespace, { manifest: manifestPath, verbose = false } = {}) {
   const api = `${url}/systemview/api`;
-  const Client = createCookieClient();
 
   if (!project_code) {
     await listAllProjects(api, Client, verbose);
@@ -30,7 +33,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)")}`);

package/cli/logs.js

@@ -0,0 +1,219 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const log = require("./logger");
+const { createClient } = require("systemlynx");
+const { createCookieHttpClient } = require("./cookieClient");
+const cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
+
+const LEVEL_COLOR = {
+  trace: (s) => chalk.dim(s),
+  info: (s) => chalk.white(s),
+  warn: (s) => chalk.yellow(s),
+  error: (s) => chalk.red(s),
+  debug: (s) => chalk.blue(s),
+};
+
+function colorLevel(level) {
+  const fn = LEVEL_COLOR[level] || ((s) => s);
+  return fn((level || "info").padEnd(5));
+}
+
+const SKIP_KEYS = new Set([
+  "timestamp",
+  "projectCode",
+  "serviceId",
+  "moduleMethod",
+  "traceId",
+  "level",
+  "message",
+  "duration",
+]);
+
+function formatRow(entry, verbose) {
+  const d = new Date(entry.timestamp);
+  const time =
+    d.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" }) +
+    " " +
+    d.toLocaleTimeString("en-US", { hour12: false });
+  const project = entry.projectCode || "—";
+  const service = entry.serviceId || "—";
+  const method = entry.moduleMethod || "—";
+  const level = colorLevel(entry.level);
+  const msg = entry.message || "";
+  const dur = entry.duration != null ? chalk.dim(` ${entry.duration}ms`) : "";
+  const traceId = chalk.dim(entry.traceId || "—");
+  const main = `  ${chalk.dim(time)}  ${chalk.cyan(project)} › ${chalk.cyan(service)}   ${method.padEnd(15)}  ${level}  ${traceId}  ${msg}${dur}`;
+  if (verbose) {
+    const extra = {};
+    Object.keys(entry).forEach((k) => {
+      if (!SKIP_KEYS.has(k)) extra[k] = entry[k];
+    });
+    if (Object.keys(extra).length) {
+      return (
+        main +
+        "\n" +
+        JSON.stringify(extra, null, 2)
+          .split("\n")
+          .map((l) => "      " + chalk.yellow(l))
+          .join("\n")
+      );
+    }
+  }
+  return main;
+}
+
+function parseFilters(filters) {
+  return (filters || [])
+    .map((f) => {
+      const eq = f.indexOf("=");
+      if (eq === -1) return null;
+      return { field: f.slice(0, eq), value: f.slice(eq + 1) };
+    })
+    .filter(Boolean);
+}
+
+function matchesFilters(entry, andFilters, orFilters) {
+  const check = ({ field, value }) => {
+    const v = entry[field];
+    return v != null && String(v).includes(value);
+  };
+  const andPass = andFilters.length === 0 || andFilters.every(check);
+  const orPass = orFilters.length === 0 || orFilters.some(check);
+  if (andFilters.length && orFilters.length) return andPass || orPass;
+  return andPass && orPass;
+}
+
+module.exports = async function logsCommand(
+  url,
+  projectCode,
+  namespace,
+  { level, limit = 50, clear, json, follow, current, verbose, filter, or: orFilters },
+) {
+  const andFilters = parseFilters(filter);
+  const orFiltersParsed = parseFilters(orFilters);
+
+  if (follow) {
+    const manifestFile = path.join(process.cwd(), "systemview.manifest.json");
+    if (!fs.existsSync(manifestFile)) {
+      log.warn("No manifest found. Use: systemview connect <serviceId> <url>");
+      return;
+    }
+    const manifest = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+    const services = manifest.services || [manifest];
+    if (!services.length) {
+      log.warn("No services in manifest. Use: systemview connect <serviceId> <url>");
+      return;
+    }
+
+    console.log("");
+    console.log(chalk.bold("  Streaming logs"));
+    console.log("");
+
+    console.log(chalk.dim(`  Services (${services.length}):`));
+    const connected = [];
+    for (const { serviceId, system } of services) {
+      const { serviceUrl } = system.connectionData;
+      try {
+        const svc = await Client.loadService(serviceUrl);
+        svc.SystemViewLogs.on("log", (entry) => {
+          if (namespace && !(entry.moduleMethod && entry.moduleMethod.includes(namespace))) return;
+          if (andFilters.length || orFiltersParsed.length) {
+            if (!matchesFilters(entry, andFilters, orFiltersParsed)) return;
+          }
+          if (level && entry.level !== level) return;
+          console.log(formatRow(entry, verbose));
+        });
+        console.log(`    ${chalk.green("✓")} ${chalk.cyan(serviceId).padEnd(20)} ${chalk.dim(serviceUrl)}`);
+        connected.push(serviceId);
+      } catch (err) {
+        console.log(`    ${chalk.red("✗")} ${chalk.cyan(serviceId).padEnd(20)} ${chalk.dim(serviceUrl)} ${chalk.red("(failed to connect)")}`);
+      }
+    }
+
+    const activeFilters = [];
+    if (namespace) activeFilters.push(`namespace: ${chalk.white(namespace)}`);
+    if (level) activeFilters.push(`level: ${chalk.white(level)}`);
+    if (andFilters.length) activeFilters.push(`filter: ${chalk.white(andFilters.map((f) => `${f.field}=${f.value}`).join(", "))}`);
+    if (orFiltersParsed.length) activeFilters.push(`or: ${chalk.white(orFiltersParsed.map((f) => `${f.field}=${f.value}`).join(", "))}`);
+    if (verbose) activeFilters.push(`verbose: ${chalk.white("on")}`);
+
+    if (activeFilters.length) {
+      console.log("");
+      console.log(chalk.dim(`  Filters:`));
+      activeFilters.forEach((f) => console.log(`    ${chalk.dim(f)}`));
+    }
+
+    console.log("");
+
+    if (!connected.length) {
+      log.warn("No services connected.");
+      return;
+    }
+
+    if (current) {
+      try {
+        const api = `${url}/systemview/api`;
+        const { SystemView } = await Client.loadService(api);
+        const all = await SystemView.getLogs({ projectCode: manifest.projectCode, level, limit });
+        let entries = all || [];
+        if (namespace) entries = entries.filter((e) => e.moduleMethod && e.moduleMethod.includes(namespace));
+        if (andFilters.length || orFiltersParsed.length) entries = entries.filter((e) => matchesFilters(e, andFilters, orFiltersParsed));
+        if (entries.length) {
+          console.log(chalk.dim(`  ── current (${entries.length}) ──`));
+          entries.forEach((e) => console.log(formatRow(e, verbose)));
+          console.log(chalk.dim(`  ── streaming ──`));
+        }
+      } catch (err) {
+        log.warn("Could not fetch current logs: " + err.message);
+      }
+    }
+
+    return;
+  }
+
+  const api = `${url}/systemview/api`;
+  const { SystemView } = await Client.loadService(api);
+
+  if (clear) {
+    const confirmed = await promptConfirm("Clear all logs? (y/N) ");
+    if (!confirmed) { log.warn("Aborted."); return; }
+    await SystemView.clearLogs();
+    log.success("Logs cleared.");
+    return;
+  }
+
+  const entries = await (async () => {
+    const all = await SystemView.getLogs({ projectCode, level, limit });
+    let filtered = all || [];
+    if (namespace) filtered = filtered.filter((e) => e.moduleMethod && e.moduleMethod.includes(namespace));
+    if (andFilters.length || orFiltersParsed.length) filtered = filtered.filter((e) => matchesFilters(e, andFilters, orFiltersParsed));
+    return filtered;
+  })();
+
+  if (json) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+
+  if (!entries.length) {
+    log.warn("No logs found.");
+    return;
+  }
+
+  console.log("");
+  entries.forEach((e) => console.log(formatRow(e, verbose)));
+  console.log("");
+  log.plain(chalk.dim(`  ${entries.length} entries`));
+};
+
+function promptConfirm(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (data) => {
+      resolve(data.trim().toLowerCase() === "y");
+    });
+  });
+}

package/cli/probe.js

@@ -1,8 +1,12 @@
 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 cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
+
 module.exports = async function probe(namespace, argsStr, { json = false, manifest: manifestPath, headers: cliHeaders = {} } = {}) {
   if (!namespace) {
     log.error("Usage: systemview probe <ServiceId.Module.method> [args]");
@@ -52,7 +56,8 @@ module.exports = async function probe(namespace, argsStr, { json = false, manife
   if (!json) log.info(`${serviceId}.${moduleName}.${methodName}(${argsStr || ""})`);
 
   try {
-    const client = createCookieClient(extraHeaders).createService(service.system.connectionData);
+    const client = Client.createService(service.system.connectionData);
+    if (Object.keys(extraHeaders).length) client.setHeaders(extraHeaders);
     const result = await client[moduleName][methodName](...args);
     if (json) {
       process.stdout.write(JSON.stringify({ serviceId, moduleName, methodName, args, result }, null, 2) + "\n");

package/cli/runTests.js

@@ -1,6 +1,9 @@
 const fs = require("fs");
 const path = require("path");
-const { createCookieClient } = require("./cookieClient");
+const { createClient } = require("systemlynx");
+const { createCookieHttpClient } = require("./cookieClient");
+const cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
 const { initializeSavedTests } = require("../testing-utilities/transformTests");
 const FullTestController = require("../testing-utilities/FullTestController");
 const log = require("./logger");
@@ -72,7 +75,6 @@ module.exports = async function runTests(
   }
 
   const extraHeaders = { ...manifestHeaders, ...cliHeaders };
-  const Client = createCookieClient(extraHeaders);
 
   if (!json) {
     connectedServices.forEach(({ serviceId, system }) => {
@@ -121,7 +123,7 @@ module.exports = async function runTests(
     if (!json) log.info(`Initializing tests for ${serviceId}...`);
 
     try {
-      const initialized = initializeSavedTests(testList, connectedServices, Client);
+      const initialized = initializeSavedTests(testList, connectedServices, Client, extraHeaders);
       const { passed, failed, jsonTests, failures } = await runAllTests(
         initialized,
         url,
@@ -376,8 +378,7 @@ async function resolveServices(api, project_code, manifestPath) {
     }
   }
 
-  const BaseClient = createCookieClient();
-  const services = await getConnectedServices(api, project_code, BaseClient);
+  const services = await getConnectedServices(api, project_code, Client);
   return { services, probeHeaders: {} };
 }
 

package/cli/startLineReader.js

@@ -1,6 +1,7 @@
 const runTests = require("./runTests");
 const cli = require("./utils/cli");
 const openBrowser = require("./openBrowser");
+const logsCommand = require("./logs");
 const readline = require("readline");
 
 module.exports = function startLineReader(url) {
@@ -8,23 +9,42 @@ module.exports = function startLineReader(url) {
     input: process.stdin,
     output: process.stdout,
   });
+
   const handleInput = (input = "") => {
-    const args = input.split(" ").map((s) => s.trim());
-    const command = args.shift();
+    const parts = input.trim().split(/\s+/);
+    const command = parts[0];
+    const args = parts.slice(1);
+
+    const flags = { filter: [], or: [] };
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === "--level" && args[i + 1]) { flags.level = args[++i]; }
+      else if (args[i] === "--limit" && args[i + 1]) { flags.limit = parseInt(args[++i], 10); }
+      else if (args[i] === "--filter" && args[i + 1]) { flags.filter.push(args[++i]); }
+      else if (args[i] === "--or" && args[i + 1]) { flags.or.push(args[++i]); }
+      else if (args[i] === "--verbose") { flags.verbose = true; }
+      else if (args[i] === "--current") { flags.current = true; }
+      else if (args[i] === "--json") { flags.json = true; }
+      else if (!args[i].startsWith("--")) { positional.push(args[i]); }
+    }
+
     if (["exit", "q", "shutdown", "stop"].includes(command)) {
       process.exit(0);
     } else if (command === "test") {
-      try {
-        runTests(url, ...args);
-      } catch (error) {
-        console.error("Error executing tests:", error.message);
-      }
+      try { runTests(url, positional[0], positional[1]); } catch (e) { console.error(e.message); }
+      lineReader.prompt();
+    } else if (command === "logs") {
+      logsCommand(url, positional[0], positional[1], { ...flags, follow: true, current: flags.current });
+    } else if (command === "clearlogs" || command === "flush") {
+      logsCommand(url, null, null, { clear: true, follow: false });
     } else if (command === "help") {
       cli.showHelp(0);
     } else if (command === "open") {
-      openBrowser(url, ...args);
+      openBrowser(url, positional[0], positional[1]);
+      lineReader.prompt();
+    } else {
+      lineReader.prompt();
     }
-    lineReader.prompt();
   };
 
   lineReader.prompt();

package/cli/utils/cli.js

@@ -8,6 +8,7 @@ const HELP_TEXT = `
     start [port]                           Launch SystemView UI (default port 3000)
     test <projectCode> [namespace]         Run saved tests for a project
     list [projectCode] [namespace]         List projects, services, or tests
+    logs [projectCode] [namespace]         View log entries
     connect <serviceId> <url>             Register a service and write manifest
     connect                               Re-probe all services in existing manifest
     probe <ServiceId.Module.method> [args] Call a method ad-hoc
@@ -25,6 +26,10 @@ const HELP_TEXT = `
     --dry-run                              Print which tests would run without executing
     --phase <before|main|events|after>     Run only specified phase(s), comma-separated
     --index <n>                            Run only action at index n within each phase (0-based)
+    --level <trace|info|warn|error|debug>  logs: filter by level
+    --limit <n>                            logs: max entries to return (default 50)
+    --follow                               logs: stream new entries as they arrive
+    --clear                                logs: wipe the log file
 
   Examples:
     systemview start
@@ -44,7 +49,7 @@ const HELP_TEXT = `
 
 const rawArgs = process.argv.slice(2);
 
-const flagValueArgs = ["--manifest", "--header", "--skip", "--phase", "--index"];
+const flagValueArgs = ["--manifest", "--header", "--skip", "--phase", "--index", "--level", "--limit", "--follow", "--filter", "--or"];
 
 const flags = {
   json: rawArgs.includes("--json"),
@@ -73,6 +78,28 @@ const flags = {
     });
     return result;
   })(),
+  level: (() => {
+    const i = rawArgs.indexOf("--level");
+    return i !== -1 ? rawArgs[i + 1] : null;
+  })(),
+  limit: (() => {
+    const i = rawArgs.indexOf("--limit");
+    if (i === -1) return undefined;
+    const val = parseInt(rawArgs[i + 1], 10);
+    return isNaN(val) ? undefined : val;
+  })(),
+  follow: rawArgs.includes("--follow") || rawArgs.includes("-f"),
+  filter: (() => {
+    const result = [];
+    rawArgs.forEach((a, i) => { if (a === "--filter" && rawArgs[i + 1]) result.push(rawArgs[i + 1]); });
+    return result;
+  })(),
+  or: (() => {
+    const result = [];
+    rawArgs.forEach((a, i) => { if (a === "--or" && rawArgs[i + 1]) result.push(rawArgs[i + 1]); });
+    return result;
+  })(),
+  clear: rawArgs.includes("--clear"),
   headers: (() => {
     const result = {};
     rawArgs.forEach((a, i) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "systemview",
   "description": "A documentation and testing suite for SystemLynx",
-  "version": "1.20.1",
+  "version": "2.0.0",
   "license": "UNLICENSED",
   "bin": {
     "systemview": "cli/index.js"
@@ -16,8 +16,8 @@
     "chalk": "^4.1.2",
     "express": "^4.18.2",
     "moment": "^2.29.1",
-    "systemlynx": "^1.19.12",
-    "systemlynx-client": "^1.19.14",
+    "systemlynx": "^2.0.0",
+    "systemlynx-client": "^2.0.0",
     "web-vitals": "^0.2.4"
   },
   "scripts": {

package/testing-utilities/Test.class.js

@@ -13,6 +13,7 @@ module.exports = function Test({
   editMode = true,
   logger,
   client,
+  extraHeaders,
 }) {
   this.index = index;
   this.connection = {};
@@ -101,7 +102,7 @@ module.exports = function Test({
       const { connectionData } = service.system;
 
       this.connection[serviceId] = (client || Client).createService(connectionData);
-      this.connection[serviceId].setHeaders({ Origin: `http://localhost:${3000}` });
+      this.connection[serviceId].setHeaders({ Origin: `http://localhost:${3000}`, ...(extraHeaders || {}) });
     }
 
     return this;

package/testing-utilities/transformTests.js

@@ -1,23 +1,23 @@
 const { Argument } = require("./Argument.class");
 const Test = require("./Test.class");
 
-function initializeSavedTests(savedTests, connectedServices, client) {
+function initializeSavedTests(savedTests, connectedServices, client, extraHeaders) {
   return savedTests.map((ft) => {
     // context matters
     const newTests = [];
     const { title, namespace } = ft;
 
     const Before = ft.Before.map((test) =>
-      resetTestClass(test, newTests, connectedServices, false, client)
+      resetTestClass(test, newTests, connectedServices, false, client, extraHeaders)
     );
     const Main = ft.Main.map((test) =>
-      resetTestClass(test, newTests, connectedServices, false, client)
+      resetTestClass(test, newTests, connectedServices, false, client, extraHeaders)
     );
     const Events = ft.Events.map((test) =>
-      resetTestClass(test, newTests, connectedServices, false, client)
+      resetTestClass(test, newTests, connectedServices, false, client, extraHeaders)
     );
     const After = ft.After.map((test) =>
-      resetTestClass(test, newTests, connectedServices, false, client)
+      resetTestClass(test, newTests, connectedServices, false, client, extraHeaders)
     );
     newTests.push(Before);
     newTests.push(Main);
@@ -27,7 +27,7 @@ function initializeSavedTests(savedTests, connectedServices, client) {
   });
 }
 
-const resetTestClass = (test, FullTest, connectedServices, editMode, client) => {
+const resetTestClass = (test, FullTest, connectedServices, editMode, client, extraHeaders) => {
   return new Test({
     ...test,
     args: test.args.map(
@@ -36,6 +36,7 @@ const resetTestClass = (test, FullTest, connectedServices, editMode, client) =>
     ),
     editMode,
     client,
+    extraHeaders,
   }).getConnection(connectedServices);
 };