systemview 1.20.1 → 1.22.0

package/cli/logs.js

@@ -0,0 +1,412 @@
+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 DEFAULT_SNAPSHOT = "systemview-snapshot.ndjson";
+
+const LEVEL_COLOR = {
+  trace: (s) => chalk.dim(s),
+  log: (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 || "log").padEnd(5));
+}
+
+const SKIP_KEYS = new Set([
+  "timestamp",
+  "projectCode",
+  "serviceId",
+  "module",
+  "method",
+  "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",
+  "module",
+  "method",
+  "moduleMethod",
+  "traceId",
+  "level",
+  "message",
+  "duration",
+]);
+
+function filterDisplayField(f) {
+  if (f.field === "has" || f.field === "missing") return f.value;
+  return f.field;
+}
+
+function appendSnapshot(filePath, entry, saveLimit) {
+  try {
+    let lines = [];
+    if (fs.existsSync(filePath)) {
+      lines = fs.readFileSync(filePath, "utf8").split("\n").filter(Boolean);
+    }
+    lines.push(JSON.stringify(entry));
+    if (lines.length > saveLimit) lines = lines.slice(lines.length - saveLimit);
+    fs.writeFileSync(filePath, lines.join("\n") + "\n");
+  } catch {}
+}
+
+module.exports = async function logsCommand(
+  projectCode,
+  namespace,
+  {
+    uiUrl,
+    level,
+    limit = 300,
+    clear,
+    current,
+    follow,
+    verbose,
+    filter,
+    or: orFilters,
+    include,
+    json,
+    save,
+    saved,
+    saveLimit = 500,
+  },
+) {
+  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);
+
+  const savePath =
+    save && typeof save === "string"
+      ? path.resolve(process.cwd(), save)
+      : path.resolve(process.cwd(), DEFAULT_SNAPSHOT);
+
+  const printEntry = (entry) => {
+    if (json) {
+      console.log(JSON.stringify(entry));
+      return;
+    }
+    console.log(formatRow(entry, verbose, extraFields));
+  };
+
+  // --saved: read local snapshot, no live streaming
+  if (saved) {
+    if (!fs.existsSync(savePath)) {
+      log.warn(`No snapshot found at: ${savePath}`);
+      return;
+    }
+    let entries = [];
+    try {
+      entries = fs
+        .readFileSync(savePath, "utf8")
+        .split("\n")
+        .filter(Boolean)
+        .map((l) => JSON.parse(l));
+    } catch (err) {
+      log.error("Failed to read snapshot: " + err.message);
+      return;
+    }
+    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 (level) entries = entries.filter((e) => e.level === level);
+    entries = entries.slice(-limit);
+    console.log("");
+    console.log(chalk.bold(`  Snapshot: ${savePath}  (${entries.length} entries)`));
+    console.log("");
+    entries.forEach(printEntry);
+    return;
+  }
+
+  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;
+        if (save) appendSnapshot(savePath, entry, saveLimit);
+        printEntry(entry);
+        if (queryUrl && !json && entry.traceId) {
+          const sep = queryUrl.includes("?") ? "&" : "?";
+          console.log(`      ${chalk.dim(queryUrl + sep + "traceId=" + encodeURIComponent(entry.traceId))}`);
+        }
+        console.log("");
+      });
+      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)")}`,
+      );
+    }
+  }
+
+  if (save) {
+    console.log(chalk.dim(`  Snapshot: ${savePath}  (limit ${saveLimit})`));
+  }
+
+  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")}`);
+  const queryUrl = uiUrl ? buildLogsUrl(uiUrl, { projectCode, effectiveNamespace, level, andFilters, orFilters }) : null;
+
+  if (activeFilters.length) {
+    console.log("");
+    console.log(chalk.dim(`  Filters:`));
+    activeFilters.forEach((f) => console.log(`    ${chalk.dim(f)}`));
+  }
+  if (queryUrl && !json) {
+    console.log("");
+    console.log(`  ${chalk.dim("UI:")} ${chalk.cyan(queryUrl)}`);
+  }
+  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((entry) => {
+        printEntry(entry);
+        if (queryUrl && !json && entry.traceId) {
+          const sep = queryUrl.includes("?") ? "&" : "?";
+          console.log(`      ${chalk.dim(queryUrl + sep + "traceId=" + encodeURIComponent(entry.traceId))}`);
+        }
+        console.log("");
+      });
+    }
+
+    if (!follow) {
+      connected.forEach(({ unsub }) => unsub());
+      return () => {};
+    }
+    console.log(chalk.dim(`  ── streaming ──`));
+  }
+
+  return () => {
+    connected.forEach(({ unsub }) => unsub());
+  };
+};
+
+function buildLogsUrl(uiUrl, { projectCode, effectiveNamespace, level, andFilters, orFilters }) {
+  const params = new URLSearchParams();
+  if (projectCode && effectiveNamespace !== projectCode) params.set("project", projectCode);
+  if (effectiveNamespace) params.set("method", effectiveNamespace);
+  if (level) params.set("level", level);
+  for (const f of andFilters || []) {
+    if (f.field === "has") params.append("has", f.value);
+    else if (f.field === "missing") params.append("missing", f.value);
+    else params.set(f.field, f.value);
+  }
+  const q = params.toString();
+  return `${uiUrl}/logs${q ? "?" + q : ""}`;
+}
+
+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/openBrowser.js

@@ -8,7 +8,7 @@ module.exports = function openBrowser(url, project_code, namespace, connectedSer
   }
 
   const browserCommand = process.platform === "win32" ? "start" : "open";
-  const code = project_code ? "/" + project_code : "";
+  const code = project_code ? "/specs/" + project_code : "/specs";
 
   if (namespace && connectedServices && connectedServices.length) {
     const matches = resolveNamespace(namespace, connectedServices);

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");