systemview 1.20.0 → 1.21.0

package/cli/logs.js

@@ -0,0 +1,251 @@
+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, extraFields) {
+  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 || "—");
+  let row = `  ${chalk.dim(time)}  ${chalk.cyan(project)} › ${chalk.cyan(service)}   ${method.padEnd(15)}  ${level}  ${traceId}  ${msg}${dur}`;
+  if (extraFields && extraFields.length) {
+    const parts = extraFields.map((p) => `${chalk.dim(p + ":")} ${cellStr(getAtPath(entry, p))}`);
+    row += "  " + parts.join("  ");
+  }
+  if (verbose) {
+    const extra = {};
+    Object.keys(entry).forEach((k) => {
+      if (!SKIP_KEYS.has(k)) extra[k] = entry[k];
+    });
+    if (Object.keys(extra).length) {
+      return (
+        row +
+        "\n" +
+        JSON.stringify(extra, null, 2)
+          .split("\n")
+          .map((l) => "      " + chalk.yellow(l))
+          .join("\n")
+      );
+    }
+  }
+  return row;
+}
+
+function getAtPath(entry, field) {
+  return field.split(".").reduce((o, k) => (o != null ? o[k] : undefined), entry);
+}
+
+function cellStr(v) {
+  if (v === null || v === undefined) return "—";
+  if (typeof v === "object") return Array.isArray(v) ? `[${v.length}]` : "{…}";
+  return String(v);
+}
+
+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 }) => {
+    if (field === "has") return getAtPath(entry, value) != null;
+    if (field === "missing") return getAtPath(entry, value) == null;
+    const v = getAtPath(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;
+}
+
+const DISPLAY_SKIP = new Set(["timestamp", "projectCode", "serviceId", "moduleMethod", "traceId", "level", "message", "duration"]);
+
+function filterDisplayField(f) {
+  if (f.field === "has" || f.field === "missing") return f.value;
+  return f.field;
+}
+
+module.exports = async function logsCommand(
+  projectCode,
+  namespace,
+  { uiUrl, level, limit = 50, clear, current, verbose, filter, or: orFilters, include },
+) {
+  const andFilters = parseFilters(filter);
+  const orFiltersParsed = parseFilters(orFilters);
+  const extraFields = [
+    ...andFilters.map(filterDisplayField),
+    ...orFiltersParsed.map(filterDisplayField),
+    ...(include || []),
+  ].filter((f, i, arr) => !DISPLAY_SKIP.has(f) && arr.indexOf(f) === i);
+
+  let services = [];
+  let effectiveNamespace = namespace;
+
+  try {
+    const { SystemView } = await Client.loadService(`${uiUrl}/systemview/api`);
+
+    if (!projectCode) {
+      const projects = await SystemView.getProjects();
+      services = Object.values(projects).flat();
+    } else {
+      const matches = await SystemView.getServices(projectCode);
+      if (matches && matches.length) {
+        services = matches;
+      } else {
+        // Fuzzy namespace: check if arg is a module/method name
+        const projects = await SystemView.getProjects();
+        const all = Object.values(projects).flat();
+        const isNamespace = all.some(({ system }) =>
+          (system.connectionData.modules || []).some(({ name, methods }) =>
+            name.toLowerCase().includes(projectCode.toLowerCase()) ||
+            (methods || []).some(({ fn }) => fn.toLowerCase().includes(projectCode.toLowerCase()))
+          )
+        );
+        if (isNamespace) {
+          services = all;
+          effectiveNamespace = projectCode;
+        } else {
+          log.warn(`No services found for: ${projectCode}`);
+          return;
+        }
+      }
+    }
+  } catch (err) {
+    log.error("Failed to connect to SystemView: " + err.message);
+    return;
+  }
+
+  if (!services.length) {
+    log.warn("No services in store. Use: systemview connect <url>");
+    return;
+  }
+
+  if (clear) {
+    const confirmed = await promptConfirm("Clear all logs? (y/N) ");
+    if (!confirmed) { log.warn("Aborted."); return; }
+    for (const { system } of services) {
+      try {
+        const svc = await Client.loadService(system.connectionData.serviceUrl);
+        await svc.SystemView.clearLog();
+      } catch {}
+    }
+    log.success("Logs cleared.");
+    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);
+      const unsub = svc.SystemView.on("log", (entry) => {
+        if (effectiveNamespace && !(entry.moduleMethod && entry.moduleMethod.includes(effectiveNamespace))) return;
+        if (andFilters.length || orFiltersParsed.length) {
+          if (!matchesFilters(entry, andFilters, orFiltersParsed)) return;
+        }
+        if (level && entry.level !== level) return;
+        console.log(formatRow(entry, verbose, extraFields));
+      });
+      console.log(`    ${chalk.green("✓")} ${chalk.cyan(serviceId).padEnd(20)} ${chalk.dim(serviceUrl)}`);
+      connected.push({ serviceId, svc, unsub });
+    } catch {
+      console.log(`    ${chalk.red("✗")} ${chalk.cyan(serviceId).padEnd(20)} ${chalk.dim(serviceUrl)} ${chalk.red("(failed to connect)")}`);
+    }
+  }
+
+  const activeFilters = [];
+  if (effectiveNamespace) activeFilters.push(`namespace: ${chalk.white(effectiveNamespace)}`);
+  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 (extraFields.length) activeFilters.push(`include: ${chalk.white(extraFields.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) {
+    const allEntries = [];
+    for (const { svc } of connected) {
+      try {
+        let entries = await svc.SystemView.getLog({ limit });
+        entries = entries || [];
+        if (effectiveNamespace) entries = entries.filter((e) => e.moduleMethod && e.moduleMethod.includes(effectiveNamespace));
+        if (andFilters.length || orFiltersParsed.length) entries = entries.filter((e) => matchesFilters(e, andFilters, orFiltersParsed));
+        if (level) entries = entries.filter((e) => e.level === level);
+        allEntries.push(...entries);
+      } catch {}
+    }
+    if (allEntries.length) {
+      console.log(chalk.dim(`  ── current (${allEntries.length}) ──`));
+      allEntries.forEach((e) => console.log(formatRow(e, verbose, extraFields)));
+      console.log(chalk.dim(`  ── streaming ──`));
+    }
+  }
+
+  return () => { connected.forEach(({ unsub }) => unsub()); };
+};
+
+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/manifest.js

@@ -0,0 +1,97 @@
+const fs = require("fs");
+const path = require("path");
+const { HttpClient, createClient } = require("systemlynx");
+const { createCookieHttpClient } = require("./cookieClient");
+const cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
+const log = require("./logger");
+
+const DEFAULT_MANIFEST = path.join(process.cwd(), "systemview.manifest.json");
+
+async function getUiSvc(uiUrl) {
+  try {
+    const { SystemView } = await Client.loadService(`${uiUrl}/systemview/api`);
+    return SystemView;
+  } catch {
+    return null;
+  }
+}
+
+module.exports.save = function saveManifest(manifestServices, manifestFile = DEFAULT_MANIFEST, probeHeaders = {}) {
+  if (!manifestServices || !manifestServices.length) {
+    log.warn("No services in session to save.");
+    return;
+  }
+  const byProject = {};
+  for (const { projectCode, serviceId, system, specList } of manifestServices) {
+    if (!byProject[projectCode]) byProject[projectCode] = [];
+    byProject[projectCode].push({ serviceId, system, specList });
+  }
+  const projectCodes = Object.keys(byProject);
+  if (projectCodes.length > 1) {
+    log.warn("Multiple project codes in session — saving first project only: " + projectCodes[0]);
+  }
+  const projectCode = projectCodes[0];
+  const manifest = {
+    projectCode,
+    services: byProject[projectCode],
+    ...(Object.keys(probeHeaders).length && { probeHeaders }),
+  };
+  fs.writeFileSync(manifestFile, JSON.stringify(manifest, null, 2));
+  log.success(`Manifest saved to ${manifestFile} (${manifest.services.length} service(s))`);
+};
+
+module.exports.clean = async function cleanManifest(manifestFile = DEFAULT_MANIFEST) {
+  if (!fs.existsSync(manifestFile)) {
+    log.warn("No manifest file found at " + manifestFile);
+    return;
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+  } catch {
+    log.error("Failed to parse manifest.");
+    return;
+  }
+  const services = manifest.services || [manifest];
+  log.info(`Re-probing ${services.length} service(s)...`);
+  const alive = [];
+  for (const entry of services) {
+    const url = entry.system && entry.system.connectionData && entry.system.connectionData.serviceUrl;
+    if (!url) continue;
+    try {
+      await HttpClient.request({ url });
+      alive.push(entry);
+      log.success(`alive: ${entry.serviceId}`);
+    } catch {
+      log.warn(`stale: ${entry.serviceId} (removed)`);
+    }
+  }
+  manifest.services = alive;
+  fs.writeFileSync(manifestFile, JSON.stringify(manifest, null, 2));
+  log.success(`Manifest cleaned. ${alive.length} service(s) remaining.`);
+};
+
+module.exports.disconnect = async function disconnect(projectCode, serviceId, { connectedUrls, uiUrl } = {}) {
+  if (!projectCode) {
+    log.warn("Usage: systemview disconnect <projectCode> [serviceId]");
+    return;
+  }
+  const uiSvc = await getUiSvc(uiUrl);
+  if (serviceId) {
+    if (uiSvc) {
+      try { await uiSvc.deleteService(projectCode, serviceId); } catch {}
+    }
+    if (connectedUrls) {
+      for (const url of connectedUrls) {
+        if (url.includes(serviceId)) connectedUrls.delete(url);
+      }
+    }
+    log.success(`Disconnected: ${projectCode} › ${serviceId}`);
+  } else {
+    if (uiSvc) {
+      try { await uiSvc.deleteProject(projectCode); } catch {}
+    }
+    log.success(`Disconnected project: ${projectCode}`);
+  }
+};

package/cli/probe.js

@@ -1,9 +1,13 @@
 const fs = require("fs");
 const path = require("path");
-const { createCookieClient } = require("./cookieClient");
+const { createClient } = require("systemlynx");
+const { createCookieHttpClient } = require("./cookieClient");
 const log = require("./logger");
 
-module.exports = async function probe(namespace, argsStr, { json = false, manifest: manifestPath, headers: cliHeaders = {} } = {}) {
+const cookieHttpClient = createCookieHttpClient();
+const Client = createClient(cookieHttpClient);
+
+module.exports = async function probe(namespace, argsStr, { json = false, manifest: manifestPath, headers: cliHeaders = {}, uiUrl } = {}) {
   if (!namespace) {
     log.error("Usage: systemview probe <ServiceId.Module.method> [args]");
     return 1;
@@ -27,32 +31,45 @@ module.exports = async function probe(namespace, argsStr, { json = false, manife
     }
   }
 
-  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 service = null;
 
-  let manifest;
-  try {
-    manifest = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
-  } catch (err) {
-    log.error(`Failed to read manifest: ${err.message}`);
-    return 1;
+  // Try UI server first
+  if (uiUrl) {
+    try {
+      const { SystemView } = await Client.loadService(`${uiUrl}/systemview/api`);
+      const projects = await SystemView.getProjects();
+      const all = Object.values(projects).flat();
+      service = all.find((s) => s.serviceId === serviceId);
+    } catch {}
   }
 
-  const services = manifest.services || [manifest];
-  const service = services.find((s) => s.serviceId === serviceId);
+  // Fall back to manifest file
   if (!service) {
-    log.error(`Service "${serviceId}" not found in manifest`);
-    return 1;
+    const manifestFile = manifestPath || path.join(process.cwd(), "systemview.manifest.json");
+    if (!fs.existsSync(manifestFile)) {
+      log.error(`Service "${serviceId}" not found. Connect it first with: systemview connect <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];
+    service = services.find((s) => s.serviceId === serviceId);
+    if (!service) {
+      log.error(`Service "${serviceId}" not found in manifest`);
+      return 1;
+    }
   }
 
-  const extraHeaders = { ...(manifest.probeHeaders || {}), ...cliHeaders };
   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(cliHeaders).length) client.setHeaders(cliHeaders);
     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,7 @@
-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");
@@ -45,7 +46,6 @@ module.exports = async function runTests(
   {
     json = false,
     verbose = false,
-    manifest: manifestPath,
     headers: cliHeaders = {},
     bail = false,
     dryRun = false,
@@ -61,23 +61,25 @@ module.exports = async function runTests(
     return 1;
   }
 
-  const { services: connectedServices, probeHeaders: manifestHeaders } = await resolveServices(
-    api,
-    project_code,
-    manifestPath
-  );
+  const { services: connectedServices, resolvedNamespace } = await resolveServices(api, project_code);
+  if (resolvedNamespace && !namespace) namespace = resolvedNamespace;
   if (!connectedServices || !connectedServices.length) {
     log.warn("No connected services found for project: " + project_code);
     return 1;
   }
 
-  const extraHeaders = { ...manifestHeaders, ...cliHeaders };
-  const Client = createCookieClient(extraHeaders);
+  const extraHeaders = { ...cliHeaders };
 
   if (!json) {
     connectedServices.forEach(({ serviceId, system }) => {
       log.success(`connected: ${serviceId} @ ${system.connectionData.serviceUrl}`);
     });
+    if (namespace || skipPatterns.length) {
+      console.log("");
+      console.log(chalk.dim(`  Filters:`));
+      if (namespace) console.log(`    ${chalk.dim(`namespace: ${chalk.white(namespace)}`)}`);
+      if (skipPatterns.length) console.log(`    ${chalk.dim(`skip: ${chalk.white(skipPatterns.join(", "))}`)}`);
+    }
   }
 
   const allTestLists = await getTests(connectedServices, Client);
@@ -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,
@@ -354,39 +356,32 @@ async function getTests(connectedServices, Client) {
   return results;
 }
 
-async function resolveServices(api, project_code, manifestPath) {
-  const manifestFile = manifestPath || path.join(process.cwd(), "systemview.manifest.json");
+async function resolveServices(api, project_code) {
+  try {
+    const { SystemView } = await Client.loadService(api);
 
-  if (fs.existsSync(manifestFile)) {
-    try {
-      const raw = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
-      const services = raw.services
-        ? raw.services
-        : [{ serviceId: raw.serviceId, system: raw.system, specList: raw.specList }];
-
-      if (project_code && raw.projectCode && raw.projectCode !== project_code) {
-        log.warn(
-          `Manifest projectCode "${raw.projectCode}" doesn't match "${project_code}", falling back to API`
-        );
-      } else {
-        return { services, probeHeaders: raw.probeHeaders || {} };
-      }
-    } catch (err) {
-      log.warn(`Failed to read manifest: ${err.message}`);
+    // Try exact project code match first
+    const services = await SystemView.getServices(project_code);
+    if (services && services.length) {
+      return { services };
     }
-  }
 
-  const BaseClient = createCookieClient();
-  const services = await getConnectedServices(api, project_code, BaseClient);
-  return { services, probeHeaders: {} };
-}
+    // Fuzzy namespace: check if project_code matches any module or method across all services
+    const projects = await SystemView.getProjects();
+    const all = Object.values(projects).flat();
+    const isNamespace = all.some(({ system }) =>
+      (system.connectionData.modules || []).some(({ name, methods }) =>
+        name.toLowerCase().includes(project_code.toLowerCase()) ||
+        (methods || []).some(({ fn }) => fn.toLowerCase().includes(project_code.toLowerCase()))
+      )
+    );
+    if (isNamespace) {
+      return { services: all, resolvedNamespace: project_code };
+    }
 
-async function getConnectedServices(api, project_code, Client) {
-  try {
-    const { SystemView } = await Client.loadService(api);
-    return await SystemView.getServices(project_code);
+    return { services: [] };
   } catch (error) {
     log.error("Failed to connect to SystemView: " + error.message);
-    return [];
+    return { services: [] };
   }
 }