@smartreviq/cli 0.3.2 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartreviq/cli",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Edit, test and ship SmartRevIQ process-engine scripts from your editor and CI.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -669,6 +669,22 @@ function localScripts(root) {
   return out;
 }
 
+/**
+ * Every script key the environment holds, as `folder/name.script`.
+ *
+ * One request. Deliberately NOT wrapped in a try/catch: if this fails, the
+ * caller cannot distinguish a script that is absent from one it simply could
+ * not read, and every answer it gives afterwards would be invented.
+ */
+async function listRemoteKeys(api) {
+  const listing = await api.listScripts();
+  const keys = new Set();
+  for (const [folder, names] of Object.entries(listing ?? {})) {
+    for (const n of names) if (n.endsWith('.script')) keys.add(`${folder}/${n}`);
+  }
+  return keys;
+}
+
 async function cmdPush(argv) {
   const { root, config, target, flags, positional } = projectTarget(argv);
   const api = clientFor(target);
@@ -680,6 +696,7 @@ async function cmdPush(argv) {
     log(`${yellow('→')} target: ${bold(target.env)} ${dim(target.api)}`);
   }
   const platform = platformOwned(root);
+  const remoteKeys = await listRemoteKeys(api);
 
   let targets = localScripts(root);
   if (positional.length) {
@@ -714,11 +731,17 @@ async function cmdPush(argv) {
     }
 
     const body = unwrap(text);
-    let remote = null;
-    try { remote = await api.getScript(s3Name, t.folder); } catch { /* new script */ }
+    const key = `${t.folder}/${s3Name}`;
+    if (!remoteKeys.has(key)) {
+      changed.push({ ...t, s3Name, body, isNew: true });
+      continue;
+    }
+    // Existence came from the listing; this only answers "has it changed".
+    // Reading a failure here as "new" is what let an expired token report a
+    // whole project as added — see listRemoteKeys.
+    const remote = await api.getScript(s3Name, t.folder);
     if (remote === body) continue;
-
-    changed.push({ ...t, s3Name, body, isNew: remote === null });
+    changed.push({ ...t, s3Name, body, isNew: false });
   }
 
   if (blocked.length) {
@@ -756,14 +779,26 @@ async function cmdStatus(argv) {
   const api = clientFor(target);
 
   const locals = localScripts(root);
+
+  // THE LISTING DECIDES WHAT EXISTS. It used to be inferred: fetch each script
+  // and treat any failure as "not there". That reads a 401 as a new script, so
+  // an expired token — they last an hour — turned a clean status into every
+  // file reported as added. Observed on a 422-script project, which also
+  // showed how convincing the wrong answer looks.
+  //
+  // The error code cannot rescue that inference either: a script that really
+  // is absent comes back 500 SYSTEM_ERROR, the same as a server fault. So the
+  // guess is replaced by the one authoritative answer, which this command was
+  // already fetching for orphan detection, and a failure to get it is fatal
+  // rather than best-effort — without it, A and M cannot be told apart.
+  const remoteKeys = await listRemoteKeys(api);
   const rows = [];
   for (const t of locals) {
-    const s3Name = toRemoteName(t.localName);
+    const key = `${t.folder}/${toRemoteName(t.localName)}`;
+    if (!remoteKeys.has(key)) { rows.push(['A', `${t.folder}/${t.localName}`]); continue; }
     const body = unwrap(readFileSync(t.absPath, 'utf8'));
-    let remote = null;
-    try { remote = await api.getScript(s3Name, t.folder); } catch { /* new */ }
-    if (remote === null) rows.push(['A', `${t.folder}/${t.localName}`]);
-    else if (remote !== body) rows.push(['M', `${t.folder}/${t.localName}`]);
+    const remote = await api.getScript(toRemoteName(t.localName), t.folder);
+    if (remote !== body) rows.push(['M', `${t.folder}/${t.localName}`]);
   }
 
   // Scripts live on the environment with no local file. `push` only ever
@@ -776,13 +811,8 @@ async function cmdStatus(argv) {
   // and the real answer is simply `sriq pull`.
   let orphans = [];
   if (locals.length) {
-    try {
-      const listing = await api.listScripts();
-      const here = new Set(locals.map((t) => `${t.folder}/${toRemoteName(t.localName)}`));
-      orphans = Object.entries(listing)
-        .flatMap(([folder, names]) => names.map((n) => `${folder}/${n}`))
-        .filter((k) => !here.has(k));
-    } catch { /* best effort — the per-script diff above is the contract */ }
+    const here = new Set(locals.map((t) => `${t.folder}/${toRemoteName(t.localName)}`));
+    orphans = [...remoteKeys].filter((k) => !here.has(k));
   }
 
   log(`${bold(target.env)} ${dim(target.api + (target.apiPrefix ?? DEFAULT_API_PREFIX))}`);

package/src/client.mjs

@@ -79,8 +79,15 @@ export class Client {
         // matters most — an SSO-only account being refused a password login
         // reads as an expired session, which it is not.
         const said = parsed?.message || parsed?.error;
+        // The status goes in the text even when the server said something
+        // useful. Without it "Invalid token" is just a sentence: it does not
+        // say an AUTH check failed, so it reads as a problem with the script
+        // or the request. A reader who sees 401 knows to re-authenticate
+        // without being told to — which matters, because telling them to would
+        // be wrong for the SSO-only account this branch exists to serve.
         throw new ApiError(
-          said || 'Unauthorized. Your session may have expired — run `sriq login`.',
+          said ? `${said} (401 — ${method} ${fullPath})`
+               : 'Unauthorized. Your session may have expired — run `sriq login`.',
           401, parsed
         );
       }