@tenonhq/dovetail-servicenow 0.0.32 → 0.0.33

package/dist/cli.js

@@ -906,7 +906,8 @@ function printHelp() {
         "  invoke-rest        Invoke an arbitrary authenticated REST operation (Scripted REST incl.)\n" +
         "                     DRY-RUN BY DEFAULT — nothing is sent without --confirm\n" +
         "                     (--method <GET|POST|PUT|DELETE> --path /api/<scope>/<service>/<resource>\n" +
-        "                      [--body '<json>' | --body-json <path>] [--confirm] [--dry-run] [--json])\n" +
+        "                      [--body '<json>' | --body-json <path>] [--confirm] [--dry-run] [--json]\n" +
+        "                      [--out <file>  full JSON result to a file (atomic; overwrites); for large bodies])\n" +
         "  set-field          Set field value(s) on an EXISTING record, into an update set, then verify\n" +
         "                     (--table <t> --sys-id <id>|--query <q> --update-set <sys_id>\n" +
         '                      (--fields "k=v,k2=v2" | --from-json <path>) [--dry-run] [--json])\n' +
@@ -1516,6 +1517,11 @@ async function runHostAssets(flags) {
  *   --confirm               Send for real. WITHOUT it the command is a DRY-RUN.
  *   --dry-run               Force a dry-run even with --confirm.
  *   --json                  Emit the structured InvokeRestResult.
+ *   --out <file>            Also write the full structured result to a file
+ *                           (pretty JSON, atomic temp+rename, OVERWRITES an
+ *                           existing file; parent dir must exist). The reliable
+ *                           channel for large response bodies - piped stdout is
+ *                           flush-guarded but a file needs no downstream reader.
  *
  * Invoke an arbitrary authenticated REST operation (Scripted REST included).
  * Dry-run by default; --confirm sends and returns { httpStatus, ok, body } with
@@ -1562,6 +1568,17 @@ async function runInvokeRest(flags) {
         params.body = body;
     }
     var result = await (0, invokeRest_1.invokeRest)(params);
+    if (flags.out) {
+        try {
+            (0, invokeRest_1.writeInvokeRestResultFile)(flags.out, result);
+        }
+        catch (err) {
+            process.stderr.write("invoke-rest: --out write failed: " +
+                (err instanceof Error ? err.message : String(err)) +
+                "\n");
+            return 1;
+        }
+    }
     if (flags.json === "true") {
         process.stdout.write(JSON.stringify(result, null, 2) + "\n");
     }
@@ -1783,13 +1800,57 @@ async function main() {
     }
     throw new Error("Unknown command: " + parsed.command);
 }
+// A closed downstream pipe (e.g. `dove-sn ... --json | head`) surfaces as an
+// EPIPE on stdout. Exit quietly with the code already set instead of crashing
+// with an unhandled stream error.
+process.stdout.on("error", function (err) {
+    if (err && err.code === "EPIPE") {
+        process.exit(typeof process.exitCode === "number" ? process.exitCode : 0);
+    }
+    throw err;
+});
+/**
+ * process.exit() discards buffered stdout/stderr - when stdout is a PIPE,
+ * anything past the OS pipe buffer (~64KB) is silently dropped, which is how
+ * `invoke-rest --json` used to truncate large bodies mid-string. Queue an
+ * empty chunk behind any pending data on each stream and exit only when both
+ * callbacks confirm the flush. The barrier is queued UNCONDITIONALLY (not
+ * gated on writableLength) so the exit never races stream internals about
+ * whether a prior write is still in flight.
+ */
+function exitAfterFlush(code) {
+    process.exitCode = code;
+    var pending = 0;
+    var finish = function () {
+        pending -= 1;
+        if (pending <= 0) {
+            process.exit(code);
+        }
+    };
+    [process.stdout, process.stderr].forEach(function (stream) {
+        if (stream.destroyed || !stream.writable) {
+            return;
+        }
+        pending += 1;
+        try {
+            stream.write("", finish);
+        }
+        catch (writeErr) {
+            // A stream that rejects the barrier write has nothing left to flush.
+            pending -= 1;
+        }
+    });
+    if (pending === 0) {
+        process.exit(code);
+    }
+}
 main()
     .then(function (code) {
-    process.exit(code);
+    exitAfterFlush(code);
 })
     .catch(function (err) {
     process.stderr.write("dove-sn error: " +
         (err && err.message ? err.message : String(err)) +
         "\n");
-    process.exit(1);
+    exitAfterFlush(1);
 });

package/dist/invokeRest.d.ts

@@ -48,3 +48,15 @@ export interface InvokeRestResult {
     note: string;
 }
 export declare function invokeRest(params: InvokeRestParams): Promise<InvokeRestResult>;
+/**
+ * Write an invoke-rest result to a file as pretty-printed JSON — the
+ * first-class landing spot for large responses (piped stdout truncates at the
+ * OS pipe buffer if the process exits before draining; see the CLI's
+ * flush-aware exit). ATOMIC: writes to a same-directory temp file then
+ * renames, so a killed process leaves either the old file or the new one —
+ * never a silently-truncated hybrid. Overwrites an existing file by design
+ * (documented in --help). The parent directory must already exist; a missing
+ * or unwritable directory throws with the underlying error so the CLI can
+ * exit 1 loudly instead of "succeeding" with no file.
+ */
+export declare function writeInvokeRestResultFile(outPath: string, result: unknown): void;

package/dist/invokeRest.js

@@ -17,9 +17,46 @@
  * only in the returned result. Any log line about an invocation elsewhere must
  * carry method, path and status ONLY.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.INVOKE_REST_METHODS = void 0;
 exports.invokeRest = invokeRest;
+exports.writeInvokeRestResultFile = writeInvokeRestResultFile;
+const fs = __importStar(require("fs"));
+// Aliased: `path` is the instance-relative REST path throughout this module.
+const nodePath = __importStar(require("path"));
 const client_1 = require("./client");
 exports.INVOKE_REST_METHODS = ["GET", "POST", "PUT", "DELETE"];
 function normalizeMethod(method) {
@@ -91,3 +128,33 @@ async function invokeRest(params) {
     }
     return result;
 }
+/**
+ * Write an invoke-rest result to a file as pretty-printed JSON — the
+ * first-class landing spot for large responses (piped stdout truncates at the
+ * OS pipe buffer if the process exits before draining; see the CLI's
+ * flush-aware exit). ATOMIC: writes to a same-directory temp file then
+ * renames, so a killed process leaves either the old file or the new one —
+ * never a silently-truncated hybrid. Overwrites an existing file by design
+ * (documented in --help). The parent directory must already exist; a missing
+ * or unwritable directory throws with the underlying error so the CLI can
+ * exit 1 loudly instead of "succeeding" with no file.
+ */
+function writeInvokeRestResultFile(outPath, result) {
+    var dir = nodePath.dirname(outPath);
+    var tempPath = nodePath.join(dir, "." + nodePath.basename(outPath) + ".tmp-" + process.pid + "-" + Date.now());
+    var payload = JSON.stringify(result, null, 2) + "\n";
+    try {
+        fs.writeFileSync(tempPath, payload, { encoding: "utf8" });
+        fs.renameSync(tempPath, outPath);
+    }
+    catch (err) {
+        // Best-effort temp cleanup so a failed write leaves no residue.
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch (cleanupErr) {
+            // The temp file never landed — nothing to clean.
+        }
+        throw err;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-servicenow",
-  "version": "0.0.32",
+  "version": "0.0.33",
   "engines": {
     "node": ">=22"
   },