systemview 2.2.4 → 2.3.0

package/cli/connectService.js

@@ -3,6 +3,7 @@ const { createCookieHttpClient } = require("./cookieClient");
 const cookieHttpClient = createCookieHttpClient();
 const Client = createClient(cookieHttpClient);
 const log = require("./logger");
+const manifestCommands = require("./manifest");
 
 async function getUiSvc(uiUrl) {
   try {
@@ -33,7 +34,7 @@ function printSummary(entries) {
   console.log("");
 }
 
-module.exports = async function connectService(target, { useManifest, force, connectedUrls, uiUrl } = {}) {
+module.exports = async function connectService(target, { useManifest, save, force, connectedUrls, uiUrl } = {}) {
   const uiSvc = await getUiSvc(uiUrl);
 
   // connect (no args) — connect to every service stored in UI
@@ -133,6 +134,17 @@ module.exports = async function connectService(target, { useManifest, force, con
           }
         }
         printSummary(summary);
+        if (save) {
+          // --save persists THIS connection to the local manifest. The subject is the connection
+          // (the services); the applied headers + captured session cookie tag along via save().
+          const services = manifest.services.map((s) => ({
+            projectCode: manifest.projectCode,
+            serviceId: s.serviceId,
+            system: s.system,
+            specList: s.specList || { tests: [], docs: [] },
+          }));
+          manifestCommands.save(services);
+        }
       } else {
         log.warn("No plugin manifest found. Storing as connected-services.");
         const connectionData = await HttpClient.request({ url: target });
@@ -165,6 +177,11 @@ module.exports = async function connectService(target, { useManifest, force, con
       await notifyUi(uiSvc, project);
       log.success(`connected-services › ${serviceId}`);
       printSummary([{ projectCode: "connected-services", serviceId, url: target }]);
+      if (save) {
+        manifestCommands.save([
+          { projectCode: "connected-services", serviceId, system: { connectionData }, specList: { tests: [], docs: [] } },
+        ]);
+      }
     }
   } catch (err) {
     log.error(`Connection failed: ${err.message}`);

package/cli/cookieClient.js

@@ -1,55 +1,25 @@
 const axios = require("axios").default;
 const FormData = require("form-data");
-const fs = require("fs");
 const path = require("path");
-const { createClient } = require("systemlynx");
+const { headersFor, captureCookie } = require("./manifestHeaders");
 
-const COOKIE_FILE = path.resolve(process.cwd(), "systemview.cookies.json");
-
-function readCookies() {
-  try {
-    return JSON.parse(fs.readFileSync(COOKIE_FILE, "utf8"));
-  } catch {
-    return {};
-  }
-}
-
-function captureCookies(setCookieHeaders) {
-  if (!setCookieHeaders || !setCookieHeaders.length) return;
-  const existing = readCookies();
-  let changed = false;
-  setCookieHeaders.forEach((header) => {
-    const [pair] = header.split(";");
-    const eqIdx = pair.indexOf("=");
-    if (eqIdx === -1) return;
-    const name = pair.slice(0, eqIdx).trim();
-    const value = pair.slice(eqIdx + 1).trim();
-    if (name) {
-      existing[name] = value;
-      changed = true;
-    }
-  });
-  if (changed) fs.writeFileSync(COOKIE_FILE, JSON.stringify(existing, null, 2));
-}
-
-function cookieHeader() {
-  const cookies = readCookies();
-  const pairs = Object.entries(cookies)
-    .map(([k, v]) => `${k}=${v}`)
-    .join("; ");
-  return pairs || null;
-}
+// HTTP client for the SystemLynx CLI. Per request it attaches the manifest's headers for
+// the target origin (auth tokens, cookies, any scheme — see manifestHeaders.js) and folds
+// any Set-Cookie response back into that store. `extraHeaders` (e.g. --header flags) win on
+// conflict. Cookies + tokens now live in the manifest; there is no separate cookie jar.
 
 function createCookieHttpClient(extraHeaders = {}) {
   return {
     request: async ({ method = "get", url, body: data, headers }) => {
       method = method.toLowerCase();
-      const cookie = cookieHeader();
-      headers = { ...headers, ...extraHeaders };
-      if (cookie) headers.Cookie = cookie;
+      // Manifest headers are the base/default; caller-set headers (systemlynx setHeaders, i.e. the
+      // CLI `--header` flag) and constructor extraHeaders override them by name. (Matches the upload
+      // path below — the request path previously had these flipped, letting the manifest win over
+      // an explicit --header.)
+      headers = { ...headersFor(url), ...headers, ...extraHeaders };
       try {
         const res = await axios({ url, method, headers, data });
-        captureCookies(res.headers["set-cookie"]);
+        captureCookie(url, res.headers["set-cookie"]);
         if (res.status >= 400) throw res.data;
         return res.data;
       } catch (error) {
@@ -65,16 +35,15 @@ function createCookieHttpClient(extraHeaders = {}) {
       if (file) form.append("file", file, path.basename(file.path));
       if (files) files.forEach((f) => form.append("files", f, path.basename(f.path)));
       if (__arguments) form.append("__arguments", JSON.stringify(__arguments));
-      const cookie = cookieHeader();
       const allHeaders = {
-        ...extraHeaders,
-        ...(cookie ? { Cookie: cookie } : {}),
+        ...headersFor(url),
         ...headers,
+        ...extraHeaders,
         "Content-Type": "multipart/form-data",
       };
       try {
         const res = await axios.post(url, form, { headers: allHeaders });
-        captureCookies(res.headers["set-cookie"]);
+        captureCookie(url, res.headers["set-cookie"]);
         if (res.status >= 400) throw res.data;
         return res.data;
       } catch (error) {

package/cli/index.js

@@ -25,6 +25,17 @@ const DEFAULT_PORT = 3000;
 const VERSION = require("../package.json").version;
 const UI_URL = `http://localhost:${DEFAULT_PORT}`;
 
+// process.exit() truncates buffered stdout when stdout is a pipe (agents/CI, and large `--json`
+// output). Drain stdout + stderr first, then exit — otherwise big results get cut off mid-stream.
+function flushAndExit(code = 0) {
+  let pending = 2;
+  const done = () => {
+    if (--pending === 0) process.exit(code);
+  };
+  process.stdout.write("", done);
+  process.stderr.write("", done);
+}
+
 const MANIFEST_FILE =
   flags.manifest || path.join(process.cwd(), "systemview.manifest.json");
 const connectedUrls = new Set();
@@ -80,10 +91,10 @@ async function startTest() {
       index: flags.index,
       skip: flags.skip,
     });
-    process.exit(exitCode);
+    flushAndExit(exitCode);
   } catch (error) {
     log.error("Error executing tests: " + error.message);
-    process.exit(1);
+    flushAndExit(1);
   }
 }
 
@@ -99,7 +110,7 @@ async function list() {
     verbose: flags.verbose,
     json: flags.json,
   });
-  process.exit(0);
+  flushAndExit(0);
 }
 
 async function open() {
@@ -119,7 +130,7 @@ async function open() {
   }
 
   openBrowser(UI_URL, project_code, namespace, connectedServices);
-  process.exit(0);
+  flushAndExit(0);
 }
 
 async function quitApp() {
@@ -136,18 +147,18 @@ async function quitApp() {
       log.success("SystemView shutdown successful!");
     } else {
       log.error("Remote shutdown failed!");
-      process.exit(1);
+      flushAndExit(1);
     }
   } else {
     log.warn(`No SystemView instance found @ ${api}`);
   }
-  process.exit(0);
+  flushAndExit(0);
 }
 
 (async () => {
   if (process.argv.includes("--version") || process.argv.includes("-v")) {
     console.log(VERSION);
-    process.exit(0);
+    flushAndExit(0);
   }
 
   init();
@@ -168,17 +179,18 @@ async function quitApp() {
     const useManifest = process.argv.includes("--manifest");
     await connectService(input[1], {
       useManifest,
+      save: process.argv.includes("--save"),
       force: flags.force,
       connectedUrls,
       uiUrl: UI_URL,
     });
-    process.exit(0);
+    flushAndExit(0);
   } else if (command === "disconnect") {
     await manifestCommands.disconnect(input[1], input[2], {
       connectedUrls,
       uiUrl: UI_URL,
     });
-    process.exit(0);
+    flushAndExit(0);
   } else if (command === "manifest") {
     const sub = input[1];
     if (sub === "save") {
@@ -188,7 +200,7 @@ async function quitApp() {
     } else {
       log.warn("Usage: systemview manifest <save|clean>");
     }
-    process.exit(0);
+    flushAndExit(0);
   } else if (command === "probe") {
     await launchApp(DEFAULT_PORT);
     const exitCode = await probe(input[1], input[2], {
@@ -197,7 +209,7 @@ async function quitApp() {
       headers: flags.headers,
       uiUrl: UI_URL,
     });
-    process.exit(exitCode || 0);
+    flushAndExit(exitCode || 0);
   } else if (command === "logs" || command === "log") {
     await launchApp(DEFAULT_PORT);
     await logsCommand(input[1], input[2], {
@@ -216,7 +228,7 @@ async function quitApp() {
       saved: flags.saved,
       saveLimit: flags.saveLimit,
     });
-    if (!flags.follow) process.exit(0);
+    if (!flags.follow) flushAndExit(0);
   } else {
     await startApp();
   }

package/cli/manifest.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const path = require("path");
 const { HttpClient, createClient } = require("systemlynx");
 const { createCookieHttpClient } = require("./cookieClient");
+const { getHeaders } = require("./manifestHeaders");
 const cookieHttpClient = createCookieHttpClient();
 const Client = createClient(cookieHttpClient);
 const log = require("./logger");
@@ -17,7 +18,7 @@ async function getUiSvc(uiUrl) {
   }
 }
 
-module.exports.save = function saveManifest(manifestServices, manifestFile = DEFAULT_MANIFEST, probeHeaders = {}) {
+module.exports.save = function saveManifest(manifestServices, manifestFile = DEFAULT_MANIFEST) {
   if (!manifestServices || !manifestServices.length) {
     log.warn("No services in session to save.");
     return;
@@ -32,13 +33,19 @@ module.exports.save = function saveManifest(manifestServices, manifestFile = DEF
     log.warn("Multiple project codes in session — saving first project only: " + projectCodes[0]);
   }
   const projectCode = projectCodes[0];
+  const headers = getHeaders();
   const manifest = {
     projectCode,
     services: byProject[projectCode],
-    ...(Object.keys(probeHeaders).length && { probeHeaders }),
+    ...(headers && Object.keys(headers).length && { headers }),
   };
   fs.writeFileSync(manifestFile, JSON.stringify(manifest, null, 2));
-  log.success(`Manifest saved to ${manifestFile} (${manifest.services.length} service(s))`);
+  const headerOrigins = Object.keys(headers || {});
+  const cookieOrigins = headerOrigins.filter((o) => headers[o] && headers[o].Cookie);
+  const parts = [`${manifest.services.length} service(s)`];
+  if (headerOrigins.length) parts.push(`headers for ${headerOrigins.length} origin(s)`);
+  if (cookieOrigins.length) parts.push(`cookies for ${cookieOrigins.length} origin(s)`);
+  log.success(`Manifest saved to ${manifestFile} — ${parts.join(", ")}`);
 };
 
 module.exports.clean = async function cleanManifest(manifestFile = DEFAULT_MANIFEST) {

package/cli/manifestHeaders.js

@@ -0,0 +1,117 @@
+// Manifest-backed request headers (RFC-010 Phase 1).
+//
+// Headers live in the manifest, indexed by URL origin. Each value is either a literal
+// ("Bearer abc") or a file-pointer ("@./token") that keeps the secret out of the manifest.
+// Cookies are just the "Cookie" header — a captured Set-Cookie folds into the same store.
+//
+// Read on load, written only on `save`. This module holds the manifest's `headers` in
+// memory for the life of the CLI process (shared across every command via Node's module
+// cache), so a cookie captured by one request is re-sent by the next, and `save` persists
+// whatever accumulated.
+
+const fs = require("fs");
+const path = require("path");
+
+const MANIFEST_FILE = path.join(process.cwd(), "systemview.manifest.json");
+
+// { "<origin>": { "Header-Name": "value" | "@file", "Cookie": "a=1; b=2" } }
+// This is the ONLY header store — user-authored, indexed by service URL origin. The plugin never
+// writes headers; there is no separate project-level default (the old `probeHeaders` is gone).
+let headers = null;
+
+// One-time, de-duplicated notices surfaced by CLI commands so the user gets confirmation
+// that something happened ("using headers for X", "captured cookie for X"). Drained via takeNotices().
+const _notified = new Set();
+const _notices = [];
+function note(key, msg) {
+  if (_notified.has(key)) return;
+  _notified.add(key);
+  _notices.push(msg);
+}
+
+function load() {
+  if (headers) return headers;
+  headers = {};
+  try {
+    const m = JSON.parse(fs.readFileSync(MANIFEST_FILE, "utf8"));
+    if (m && m.headers && typeof m.headers === "object") headers = m.headers;
+  } catch {
+    /* no manifest / unreadable — start empty */
+  }
+  return headers;
+}
+
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+
+// "@path" → file contents (trimmed); anything else returned as-is.
+function deref(value) {
+  if (typeof value === "string" && value.startsWith("@")) {
+    try {
+      return fs.readFileSync(path.resolve(process.cwd(), value.slice(1)), "utf8").trim();
+    } catch {
+      return "";
+    }
+  }
+  return value;
+}
+
+// Resolved header name→value pairs for a request URL, matched by origin.
+function headersFor(url) {
+  const origin = originOf(url);
+  load();
+  const bucket = headers[origin] || {};
+  const out = {};
+  for (const [name, raw] of Object.entries(bucket)) {
+    const value = deref(raw);
+    if (value != null && value !== "") out[name] = value;
+  }
+  const names = Object.keys(out);
+  if (names.length) note("attach:" + origin, `using ${names.length} manifest header(s) for ${origin}`);
+  return out;
+}
+
+// Fold Set-Cookie response headers into the in-memory Cookie header for the url's origin.
+function captureCookie(url, setCookieHeaders) {
+  if (!setCookieHeaders || !setCookieHeaders.length) return;
+  const origin = originOf(url);
+  if (!origin) return;
+  const store = load();
+  if (!store[origin]) store[origin] = {};
+
+  const jar = {};
+  const existing = store[origin].Cookie;
+  if (typeof existing === "string") {
+    existing.split(";").forEach((p) => {
+      const i = p.indexOf("=");
+      if (i > -1) jar[p.slice(0, i).trim()] = p.slice(i + 1).trim();
+    });
+  }
+  setCookieHeaders.forEach((h) => {
+    const [pair] = h.split(";");
+    const i = pair.indexOf("=");
+    if (i > -1) jar[pair.slice(0, i).trim()] = pair.slice(i + 1).trim();
+  });
+  store[origin].Cookie = Object.entries(jar)
+    .map(([k, v]) => `${k}=${v}`)
+    .join("; ");
+  note("cookie:" + origin, `captured cookie for ${origin}`);
+}
+
+// The live headers map — for `save` to persist. (Not dereferenced: @file pointers and
+// literals are written back as authored; captured cookies are written as literal values.)
+function getHeaders() {
+  return load();
+}
+
+// Drain the accumulated one-time notices (for a command to print as confirmations).
+function takeNotices() {
+  return _notices.splice(0, _notices.length);
+}
+
+module.exports = { headersFor, captureCookie, getHeaders, takeNotices, MANIFEST_FILE };

package/cli/probe.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const path = require("path");
 const { createClient } = require("systemlynx");
 const { createCookieHttpClient } = require("./cookieClient");
+const { takeNotices } = require("./manifestHeaders");
 const log = require("./logger");
 
 const cookieHttpClient = createCookieHttpClient();
@@ -76,6 +77,7 @@ module.exports = async function probe(namespace, argsStr, { json = false, manife
     } else {
       log.success("result:");
       console.log(JSON.stringify(result, null, 2));
+      takeNotices().forEach((n) => log.info(n));
     }
     return 0;
   } catch (err) {
@@ -83,6 +85,7 @@ module.exports = async function probe(namespace, argsStr, { json = false, manife
       process.stdout.write(JSON.stringify({ serviceId, moduleName, methodName, args, error: err.message }, null, 2) + "\n");
     } else {
       log.error(err.message);
+      takeNotices().forEach((n) => log.info(n));
     }
     return 1;
   }

package/cli/utils/cli.js

@@ -13,7 +13,9 @@ const HELP_TEXT = `
     flush                                  Wipe the log file and stop streaming  [alias: clearlogs]
     connect [url|projectCode]             Connect a service URL, reconnect a stored project, or connect all
     connect <url> --manifest              Connect via plugin manifest — registers under real projectCode
+    connect <url> --manifest --save       Connect, then persist the connection (services + headers + cookie) to the manifest
     disconnect [projectCode] [serviceId]  Remove a project or service from the UI store
+    manifest save                          Persist session manifest — services, auth headers, cookies  [interactive]
     manifest clean                        Re-probe manifest entries, remove stale ones
     probe <ServiceId.Module.method> [args] Call a service method ad-hoc
     open [projectCode] [namespace]         Open the browser UI
@@ -26,7 +28,9 @@ const HELP_TEXT = `
     --verbose                              test: full results and args for all phases; list: expand hierarchy
     --manifest                             connect: use plugin manifest to get real projectCode
     --manifest <path>                      probe: path to manifest file (default: ./systemview.manifest.json)
-    --header "Name: Value"                 Extra request header (repeatable)
+    --header "Name: Value"                 Extra request header (repeatable; overrides manifest headers).
+                                             For a standing token, add it to the manifest "headers"
+                                             (literal or "@file") — see docs/cli.md.
     --skip <pattern>                       Exclude tests matching pattern (repeatable)
     --bail                                 Stop after first failure
     --dry-run                              Print which tests would run without executing
@@ -42,6 +46,7 @@ const HELP_TEXT = `
     --filter missing=<field>                 → only entries where field is absent
     --or <field=value>                     logs: OR filter on a field (repeatable)
     --include <field>                      logs: include extra field as a column (repeatable)
+    --save                                 connect: persist this connection to the manifest (headers + cookie tag along)
     --save [path]                          logs: append streamed entries to a local snapshot file
     --saved                                logs: read from local snapshot instead of live service
     --save-limit <n>                       logs: max entries to keep in snapshot (default 500)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "systemview",
   "description": "A documentation and testing suite for SystemLynx",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "license": "UNLICENSED",
   "bin": {
     "systemview": "cli/index.js"