systemview 2.0.0 → 2.2.0

package/cli/logs.js

@@ -7,9 +7,11 @@ 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),
-  info: (s) => chalk.white(s),
+  log: (s) => chalk.white(s),
   warn: (s) => chalk.yellow(s),
   error: (s) => chalk.red(s),
   debug: (s) => chalk.blue(s),
@@ -17,21 +19,23 @@ const LEVEL_COLOR = {
 
 function colorLevel(level) {
   const fn = LEVEL_COLOR[level] || ((s) => s);
-  return fn((level || "info").padEnd(5));
+  return fn((level || "log").padEnd(5));
 }
 
 const SKIP_KEYS = new Set([
   "timestamp",
   "projectCode",
   "serviceId",
+  "module",
+  "method",
   "moduleMethod",
   "traceId",
   "level",
-  "message",
+  "scope",
   "duration",
 ]);
 
-function formatRow(entry, verbose) {
+function formatRow(entry, verbose, extraFields) {
   const d = new Date(entry.timestamp);
   const time =
     d.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" }) +
@@ -41,10 +45,16 @@ function formatRow(entry, verbose) {
   const service = entry.serviceId || "—";
   const method = entry.moduleMethod || "—";
   const level = colorLevel(entry.level);
-  const msg = entry.message || "";
+  const msg = entry.scope || "";
   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}`;
+  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) => {
@@ -52,7 +62,7 @@ function formatRow(entry, verbose) {
     });
     if (Object.keys(extra).length) {
       return (
-        main +
+        row +
         "\n" +
         JSON.stringify(extra, null, 2)
           .split("\n")
@@ -61,7 +71,17 @@ function formatRow(entry, verbose) {
       );
     }
   }
-  return main;
+  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) {
@@ -76,7 +96,9 @@ function parseFilters(filters) {
 
 function matchesFilters(entry, andFilters, orFilters) {
   const check = ({ field, value }) => {
-    const v = entry[field];
+    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);
@@ -85,129 +107,300 @@ function matchesFilters(entry, andFilters, orFilters) {
   return andPass && orPass;
 }
 
+const DISPLAY_SKIP = new Set([
+  "timestamp",
+  "projectCode",
+  "serviceId",
+  "module",
+  "method",
+  "moduleMethod",
+  "traceId",
+  "level",
+  "scope",
+  "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(
-  url,
   projectCode,
   namespace,
-  { level, limit = 50, clear, json, follow, current, verbose, filter, or: orFilters },
+  {
+    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);
 
-  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>");
+  const printEntry = (entry) => {
+    if (json) {
+      console.log(JSON.stringify(entry));
       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>");
+    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("  Streaming logs"));
+    console.log(chalk.bold(`  Snapshot: ${savePath}  (${entries.length} entries)`));
     console.log("");
+    entries.forEach(printEntry);
+    return;
+  }
 
-    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("");
+  let services = [];
+  let effectiveNamespace = namespace;
 
-    if (!connected.length) {
-      log.warn("No services connected.");
-      return;
-    }
+  try {
+    const { SystemView } = await Client.loadService(`${uiUrl}/systemview/api`);
 
-    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 ──`));
+    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.warn("Could not fetch current logs: " + err.message);
       }
     }
-
+  } catch (err) {
+    log.error("Failed to connect to SystemView: " + err.message);
     return;
   }
 
-  const api = `${url}/systemview/api`;
-  const { SystemView } = await Client.loadService(api);
+  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; }
-    await SystemView.clearLogs();
+    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;
   }
 
-  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;
-  })();
+  console.log("");
+  console.log(chalk.bold("  Streaming logs"));
+  console.log("");
+  console.log(chalk.dim(`  Services (${services.length}):`));
 
-  if (json) {
-    console.log(JSON.stringify(entries, null, 2));
-    return;
+  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 (!entries.length) {
-    log.warn("No logs found.");
-    return;
+  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("");
-  entries.forEach((e) => console.log(formatRow(e, verbose)));
-  console.log("");
-  log.plain(chalk.dim(`  ${entries.length} entries`));
+
+  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);

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

@@ -7,7 +7,7 @@ const log = require("./logger");
 const cookieHttpClient = createCookieHttpClient();
 const Client = createClient(cookieHttpClient);
 
-module.exports = async function probe(namespace, argsStr, { json = false, manifest: manifestPath, headers: cliHeaders = {} } = {}) {
+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;
@@ -31,33 +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 = Client.createService(service.system.connectionData);
-    if (Object.keys(extraHeaders).length) client.setHeaders(extraHeaders);
+    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");