@tenonhq/dovetail-servicenow 0.0.31 → 0.0.33

package/dist/cli.js

@@ -895,10 +895,19 @@ function printHelp() {
         "                     Shorten or clear those values first, then re-run.\n" +
         "                     --element / --internal-type are REFUSED with an explanation:\n" +
         "                     ServiceNow silently ignores both on an existing column.\n" +
+        "  set-table          Update an EXISTING TABLE's own dictionary row (the collection row),\n" +
+        "                     into an update set, then verify against the instance\n" +
+        "                     (--table <t> --update-set <sys_id> [--audit true|false]\n" +
+        "                      [--dry-run] [--json])\n" +
+        "                     --audit turns RECORD AUDITING on/off for the whole table: with it\n" +
+        "                     true ServiceNow writes a sys_audit row per changed field on every\n" +
+        "                     insert and update — a real cost on a high-write table.\n" +
+        "                     Column attributes belong to set-column, record values to set-field.\n" +
         "  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' +
@@ -1118,12 +1127,12 @@ async function runAddColumn(flags) {
 }
 /** Parse a CLI boolean flag. Bare `--mandatory` means true; `--mandatory false` means
  *  false. Anything else is rejected rather than quietly coerced to `true`. */
-function parseBoolFlag(name, raw) {
+function parseBoolFlag(name, raw, verb = "set-column") {
     if (raw === "true")
         return true;
     if (raw === "false")
         return false;
-    throw new Error("set-column: --" + name + " must be true or false (got '" + raw + "').");
+    throw new Error(verb + ": --" + name + " must be true or false (got '" + raw + "').");
 }
 /**
  * dove-sn set-column:
@@ -1221,6 +1230,71 @@ async function runSetColumn(flags, bare) {
         return 2;
     return 0;
 }
+/**
+ * dove-sn set-table:
+ *   --table x_cadso_core_setting --audit true --update-set <sys_id>
+ *   [--dry-run] [--json]
+ *
+ * Updates the TABLE's own dictionary row (the `internal_type=collection` row, whose
+ * `element` is empty) — not a column's. Column attributes belong to set-column; a
+ * record's values belong to set-field.
+ */
+async function runSetTable(flags, bare) {
+    // Guard the string flags AND the updateSetSysId alias: a value-less string flag
+    // arrives as the literal "true", so --update-set (or its alias) with nothing after
+    // it would silently become the sys_id "true" and later fail as "not found".
+    var stringFlags = ["table", "update-set", "updateSetSysId"];
+    for (var f = 0; f < stringFlags.length; f += 1) {
+        if (bare[stringFlags[f]]) {
+            process.stderr.write("set-table: --" + stringFlags[f] + " needs a value (it was given none).\n");
+            return 1;
+        }
+    }
+    var table = flags.table;
+    if (!table) {
+        process.stderr.write("set-table: --table is required " +
+            "(--update-set is required too, unless --dry-run)\n");
+        return 1;
+    }
+    var attributes = {};
+    if (flags.audit !== undefined) {
+        attributes.audit = parseBoolFlag("audit", flags.audit, "set-table");
+    }
+    var params = {
+        client: (0, client_1.createClient)({}),
+        table: table,
+        attributes: attributes,
+    };
+    var setTableUs = flags["update-set"] || flags.updateSetSysId;
+    if (setTableUs)
+        params.updateSetSysId = setTableUs;
+    if (flags["dry-run"] === "true")
+        params.dryRun = true;
+    var result = await (0, table_1.setTable)(params);
+    if (flags.json === "true") {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    }
+    else {
+        process.stdout.write("[" +
+            result.status +
+            "] " +
+            result.table +
+            (result.verified && result.status === "applied" ? " — verified" : "") +
+            (result.status === "applied" && !result.capturedInUpdateSet
+                ? " — NOT CAPTURED"
+                : "") +
+            "\n" +
+            result.note +
+            "\n");
+    }
+    // 2 = the write landed but the instance does not reflect it (or it was not
+    // captured), which must not read as success to a script.
+    if (result.status === "failed")
+        return 2;
+    if (result.status === "applied" && !result.capturedInUpdateSet)
+        return 2;
+    return 0;
+}
 /** Parse inline `--fields "k=v, k2=v2"` into a field map. */
 function parseFieldsInline(input) {
     var out = {};
@@ -1443,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
@@ -1489,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");
     }
@@ -1659,6 +1749,9 @@ async function main() {
     if (parsed.command === "set-column") {
         return await runSetColumn(parsed.flags, parsed.bare);
     }
+    if (parsed.command === "set-table") {
+        return await runSetTable(parsed.flags, parsed.bare);
+    }
     if (parsed.command === "set-field") {
         return await runSetField(parsed.flags);
     }
@@ -1707,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/index.d.ts

@@ -19,8 +19,8 @@ export { sincPlugin } from "./plugin";
 export { listTemplates, verifyArtifact, cloneSubflow, cloneActionType, triggerPublication, publishActionType, editActionType, applyStepOps, verifySteps, summarizeSteps, formatStepPill, readFlow, readActionType, publishFlow, copyFlow, createFlow, buildPublishModel, editFlow, testFlow, DEFAULT_RUN_FLOW_PATH, generateSysId, topoSort, executeWritePlan, WriteOrderError, } from "./flowDesigner";
 export type { TemplateRef, ListTemplatesParams, FlowKind, VerifyExpect, VerifyFound, VerifyFailure, VerifyReport, VerifyArtifactParams, CloneSubflowParams, CloneSubflowResult, CloneActionTypeParams, CloneActionTypeResult, TriggerPublicationParams, TriggerPublicationResult, PublishActionTypeParams, PublishActionTypeResult, EditActionTypeParams, EditActionTypeResult, EditActionTypeOps, StepOps, StepRecord, StepSummary, StepIoSummary, PatchStepScriptOp, AddStepOutputOp, AddStepInputOp, ApplyStepOpsResult, VerifyStepsResult, ReadFlowParams, ReadFlowResult, FlowStep, FlowVariable, ReadActionTypeParams, ReadActionTypeResult, ActionIo, PublishFlowParams, PublishFlowResult, CopyFlowParams, CopyFlowResult, CreateFlowParams, CreateFlowResult, EditFlowParams, EditFlowResult, EditFlowOps, StepInputPatch, TestFlowParams, TestFlowResult, WriteOp, WriteOpResult, } from "./flowDesigner";
 export type { ServiceNowClientConfig, ChoiceValue, ChoiceType, AddChoicesParams, AddChoicesResult, ChoiceActionResult, DictionaryRecord, UpdateSetRecord, LayoutAction, LayoutRecordResult, LayoutResult, CreateViewParams, CreateViewResult, FormSectionSpec, SetFormLayoutParams, SetListLayoutParams, SetRelatedListsParams, ChunkRole, ChunkInfo, ChunkResult, PrunedResult, HostAssetsParams, HostAssetsResult, } from "./types";
-export { createTable, projectTableGraph, buildColumnXml, normalizeColumns, resolveType, applyTableSaveOverlay, defaultAccessFlags, TYPE_MAP, DEFAULT_SUPER_CLASS, DEFAULT_SAVE_ACTION, addColumn, deriveElement, setColumn, resolveAttributes, toStoredValue, } from "./table";
-export type { CreateTableParams, CreateTableResult, AddColumnParams, AddColumnResult, SetColumnParams, SetColumnResult, ColumnAttributes, AttributeChange, TableGraph, NormalizedColumn, ColumnSpec, AccessFlags, OverlaySpec, } from "./table";
+export { createTable, projectTableGraph, buildColumnXml, normalizeColumns, resolveType, applyTableSaveOverlay, defaultAccessFlags, TYPE_MAP, DEFAULT_SUPER_CLASS, DEFAULT_SAVE_ACTION, addColumn, deriveElement, setColumn, resolveAttributes, toStoredValue, setTable, resolveTableAttributes, } from "./table";
+export type { CreateTableParams, CreateTableResult, AddColumnParams, AddColumnResult, SetColumnParams, SetColumnResult, ColumnAttributes, AttributeChange, SetTableParams, SetTableResult, TableAttributes, TableGraph, NormalizedColumn, ColumnSpec, AccessFlags, OverlaySpec, } from "./table";
 export { setField } from "./setField";
 export { createRecord } from "./createRecord";
 export type { RecordWriteResult, SetFieldParams, SetFieldResult, } from "./setField";

package/dist/index.js

@@ -7,7 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addColumn = exports.DEFAULT_SAVE_ACTION = exports.DEFAULT_SUPER_CLASS = exports.TYPE_MAP = exports.defaultAccessFlags = exports.applyTableSaveOverlay = exports.resolveType = exports.normalizeColumns = exports.buildColumnXml = exports.projectTableGraph = exports.createTable = exports.WriteOrderError = exports.executeWritePlan = exports.topoSort = exports.generateSysId = exports.DEFAULT_RUN_FLOW_PATH = exports.testFlow = exports.editFlow = exports.buildPublishModel = exports.createFlow = exports.copyFlow = exports.publishFlow = exports.readActionType = exports.readFlow = exports.formatStepPill = exports.summarizeSteps = exports.verifySteps = exports.applyStepOps = exports.editActionType = exports.publishActionType = exports.triggerPublication = exports.cloneActionType = exports.cloneSubflow = exports.verifyArtifact = exports.listTemplates = exports.sincPlugin = exports.formatCreateViewResult = exports.formatLayoutResult = exports.setRelatedLists = exports.setFormLayout = exports.setListLayout = exports.createView = exports.formatAddChoicesResult = exports.formatHostAssetsResult = exports.classifyChunks = exports.hostAssets = exports.addChoicesToField = exports.resolveConfigFromEnvFile = exports.createClientFromEnvFile = exports.createClient = void 0;
-exports.PUBLISH_POLL_DELAYS_MS = exports.DEFAULT_PUBLISH_TIMEOUT_MS = exports.parseCicdProgress = exports.parseCicdPublishResponse = exports.harvestProgressResults = exports.flattenSteps = exports.classifyProgress = exports.parseProgressTree = exports.parseXmlAnswer = exports.buildStartFields = exports.publishApp = exports.INVOKE_REST_METHODS = exports.invokeRest = exports.createRecord = exports.setField = exports.toStoredValue = exports.resolveAttributes = exports.setColumn = exports.deriveElement = void 0;
+exports.PUBLISH_POLL_DELAYS_MS = exports.DEFAULT_PUBLISH_TIMEOUT_MS = exports.parseCicdProgress = exports.parseCicdPublishResponse = exports.harvestProgressResults = exports.flattenSteps = exports.classifyProgress = exports.parseProgressTree = exports.parseXmlAnswer = exports.buildStartFields = exports.publishApp = exports.INVOKE_REST_METHODS = exports.invokeRest = exports.createRecord = exports.setField = exports.resolveTableAttributes = exports.setTable = exports.toStoredValue = exports.resolveAttributes = exports.setColumn = exports.deriveElement = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_1.createClient; } });
 var createClientFromEnvFile_1 = require("./createClientFromEnvFile");
@@ -75,6 +75,8 @@ Object.defineProperty(exports, "deriveElement", { enumerable: true, get: functio
 Object.defineProperty(exports, "setColumn", { enumerable: true, get: function () { return table_1.setColumn; } });
 Object.defineProperty(exports, "resolveAttributes", { enumerable: true, get: function () { return table_1.resolveAttributes; } });
 Object.defineProperty(exports, "toStoredValue", { enumerable: true, get: function () { return table_1.toStoredValue; } });
+Object.defineProperty(exports, "setTable", { enumerable: true, get: function () { return table_1.setTable; } });
+Object.defineProperty(exports, "resolveTableAttributes", { enumerable: true, get: function () { return table_1.resolveTableAttributes; } });
 var setField_1 = require("./setField");
 Object.defineProperty(exports, "setField", { enumerable: true, get: function () { return setField_1.setField; } });
 var createRecord_1 = require("./createRecord");

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/dist/mcp/registry.d.ts

@@ -10,7 +10,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import type { ToolAnnotations } from "@tenonhq/dovetail-mcp-kit";
 import type { ServiceNowClient } from "../client";
-export declare var TOOL_NAMES: readonly ["create_view", "set_list_layout", "set_form_layout", "set_related_lists", "add_choices_to_field", "flow_view", "action_view", "action_edit", "flow_publish", "flow_copy", "flow_create", "flow_test", "flow_edit", "create_table", "add_column", "set_column", "set_field", "create_record", "host_assets", "invoke_rest", "app_publish"];
+export declare var TOOL_NAMES: readonly ["create_view", "set_list_layout", "set_form_layout", "set_related_lists", "add_choices_to_field", "flow_view", "action_view", "action_edit", "flow_publish", "flow_copy", "flow_create", "flow_test", "flow_edit", "create_table", "add_column", "set_column", "set_table", "set_field", "create_record", "host_assets", "invoke_rest", "app_publish"];
 export type ToolName = (typeof TOOL_NAMES)[number];
 export interface RegistryDeps {
     /** Optional client injection for tests; defaults to createClient({}). */

package/dist/mcp/registry.js

@@ -50,6 +50,7 @@ exports.TOOL_NAMES = [
     "create_table",
     "add_column",
     "set_column",
+    "set_table",
     "set_field",
     "create_record",
     "host_assets",
@@ -393,6 +394,42 @@ function buildDescriptors(deps = {}) {
                 });
             },
         },
+        {
+            name: "set_table",
+            annotations: dovetail_mcp_kit_1.WRITE_OVERWRITE,
+            description: "Update an EXISTING ServiceNow TABLE's own dictionary attributes — the row where " +
+                "internal_type=collection and element is EMPTY — captured into a named update set, then " +
+                "READ BACK from the instance to verify. Completes the trio: set_field changes a RECORD's " +
+                "value, set_column changes a COLUMN's definition, set_table changes the TABLE's own. " +
+                "Currently settable: audit. audit=true turns RECORD AUDITING on for the whole table — " +
+                "ServiceNow then writes a sys_audit row per changed field on every insert and update, " +
+                "which is a real storage and write cost on a high-volume table, so weigh it before " +
+                "enabling. Attributes are a closed set, never an open field map; a COLUMN attribute " +
+                "(label/mandatory/default/maxLength/readOnly/element/internalType) is refused by name and " +
+                "redirected to set_column. When the requested value already matches, nothing is written " +
+                "and the status is 'unchanged' — note that an identical-value write also captures " +
+                "NOTHING, so there is no update-set row to promote. dryRun:true diffs against the " +
+                "instance and writes nothing.",
+            shape: schemas_1.setTableSchema.shape,
+            handler: async function (args) {
+                var p = schemas_1.setTableSchema.parse(args);
+                // Same live-path guard as set_column: the schema leaves updateSetSysId
+                // optional so dry-run works without one.
+                if (p.dryRun !== true &&
+                    (!p.updateSetSysId || !p.updateSetSysId.trim())) {
+                    throw new Error("set_table: updateSetSysId is required on the live path so the schema " +
+                        "change is captured in a known update set — set dryRun:true to plan " +
+                        "without one.");
+                }
+                return (0, table_1.setTable)({
+                    client: client(),
+                    table: p.table,
+                    attributes: p.attributes,
+                    updateSetSysId: p.updateSetSysId,
+                    dryRun: p.dryRun,
+                });
+            },
+        },
         {
             name: "set_field",
             annotations: dovetail_mcp_kit_1.WRITE_OVERWRITE,

package/dist/mcp/schemas.d.ts

@@ -914,6 +914,43 @@ export declare var setColumnSchema: z.ZodObject<{
     dryRun?: boolean | undefined;
     updateSetSysId?: string | undefined;
 }>;
+export declare var tableAttributesSchema: z.ZodObject<{
+    audit: z.ZodOptional<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    audit: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    audit: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare var setTableSchema: z.ZodObject<{
+    table: z.ZodString;
+    attributes: z.ZodObject<{
+        audit: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        audit: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        audit: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>;
+    updateSetSysId: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    table: string;
+    attributes: {
+        audit?: boolean | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    dryRun?: boolean | undefined;
+    updateSetSysId?: string | undefined;
+}, {
+    table: string;
+    attributes: {
+        audit?: boolean | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    dryRun?: boolean | undefined;
+    updateSetSysId?: string | undefined;
+}>;
 export declare var setFieldSchema: z.ZodObject<{
     table: z.ZodString;
     sysId: z.ZodOptional<z.ZodString>;

package/dist/mcp/schemas.js

@@ -4,7 +4,7 @@
  * own file so registry.ts stays focused on wiring.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.invokeRestSchema = exports.publishAppSchema = exports.createRecordSchema = exports.setFieldSchema = exports.setColumnSchema = exports.columnAttributesSchema = exports.addColumnSchema = exports.createTableSchema = exports.columnSpecSchema = exports.hostAssetsSchema = exports.editFlowSchema = exports.editActionSchema = exports.stepInputPatchSchema = exports.testFlowSchema = exports.createFlowSchema = exports.copyFlowSchema = exports.publishFlowSchema = exports.viewActionSchema = exports.viewFlowSchema = exports.addChoicesToFieldSchema = exports.choiceValueSchema = exports.setRelatedListsSchema = exports.setFormLayoutSchema = exports.formSectionSchema = exports.setListLayoutSchema = exports.createViewSchema = void 0;
+exports.invokeRestSchema = exports.publishAppSchema = exports.createRecordSchema = exports.setFieldSchema = exports.setTableSchema = exports.tableAttributesSchema = exports.setColumnSchema = exports.columnAttributesSchema = exports.addColumnSchema = exports.createTableSchema = exports.columnSpecSchema = exports.hostAssetsSchema = exports.editFlowSchema = exports.editActionSchema = exports.stepInputPatchSchema = exports.testFlowSchema = exports.createFlowSchema = exports.copyFlowSchema = exports.publishFlowSchema = exports.viewActionSchema = exports.viewFlowSchema = exports.addChoicesToFieldSchema = exports.choiceValueSchema = exports.setRelatedListsSchema = exports.setFormLayoutSchema = exports.formSectionSchema = exports.setListLayoutSchema = exports.createViewSchema = void 0;
 const zod_1 = require("zod");
 exports.createViewSchema = zod_1.z.object({
     name: zod_1.z.string().min(1),
@@ -241,6 +241,28 @@ exports.setColumnSchema = zod_1.z.object({
     updateSetSysId: zod_1.z.string().min(1).optional(),
     dryRun: zod_1.z.boolean().optional(),
 });
+// set-table takes a CLOSED attribute set for the same reason set-column does: an
+// unbounded write to sys_dictionary lets a caller silently corrupt schema. These are
+// the TABLE's own attributes (the internal_type=collection row), not a column's.
+//
+// .passthrough() is deliberate: z.object() strips unknown keys by default, which would
+// silently drop a column attribute (or a typo) BEFORE resolveTableAttributes could see
+// it — so { audit:true, label:"x" } would succeed, quietly discarding label. Passing
+// unknown keys through lets the core allowlist reject them (a column attribute earns the
+// "use set-column" redirect; anything else, "not a settable table attribute").
+exports.tableAttributesSchema = zod_1.z
+    .object({
+    audit: zod_1.z.boolean().optional(),
+})
+    .passthrough();
+exports.setTableSchema = zod_1.z.object({
+    table: zod_1.z.string().min(1),
+    attributes: exports.tableAttributesSchema,
+    // Optional because dryRun works without one; the live-path requirement is
+    // enforced at the tool boundary (registry.ts), matching set_column.
+    updateSetSysId: zod_1.z.string().min(1).optional(),
+    dryRun: zod_1.z.boolean().optional(),
+});
 // Data-record write verbs. Kept as plain z.object (no .refine wrapper) so
 // registry.ts can read `.shape`; the deeper rules — one of sysId/query, at
 // least one field, the schema-table refusal — are enforced by the core

package/dist/table/index.d.ts

@@ -15,3 +15,5 @@ export { addColumn, deriveElement } from "./addColumn";
 export type { AddColumnParams, AddColumnResult } from "./addColumn";
 export { setColumn, resolveAttributes, toStoredValue, findTruncationRisk, } from "./setColumn";
 export type { SetColumnParams, SetColumnResult, ColumnAttributes, AttributeChange, TruncationRisk, } from "./setColumn";
+export { setTable, resolveTableAttributes } from "./setTable";
+export type { SetTableParams, SetTableResult, TableAttributes, } from "./setTable";

package/dist/table/index.js

@@ -5,7 +5,7 @@
  * live-validation caveat.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findTruncationRisk = exports.toStoredValue = exports.resolveAttributes = exports.setColumn = exports.deriveElement = exports.addColumn = exports.decodeHtmlEntities = exports.scrapeCk = exports.postForm = exports.parseFormInputs = exports.getNewRecordForm = exports.getRecordForm = exports.setCurrentApplication = exports.openFormSession = exports.resolveFormAuth = exports.TYPE_MAP = exports.listEditKey = exports.showInMenuKey = exports.defaultAccessFlags = exports.applyTableSaveOverlay = exports.resolveType = exports.normalizeColumns = exports.xmlEscape = exports.buildColumnXml = exports.DEFAULT_COLUMNS_REL_ID = exports.DEFAULT_SAVE_ACTION = exports.DEFAULT_SUPER_CLASS = exports.parseSysIdFromLocation = exports.projectTableGraph = exports.createTable = void 0;
+exports.resolveTableAttributes = exports.setTable = exports.findTruncationRisk = exports.toStoredValue = exports.resolveAttributes = exports.setColumn = exports.deriveElement = exports.addColumn = exports.decodeHtmlEntities = exports.scrapeCk = exports.postForm = exports.parseFormInputs = exports.getNewRecordForm = exports.getRecordForm = exports.setCurrentApplication = exports.openFormSession = exports.resolveFormAuth = exports.TYPE_MAP = exports.listEditKey = exports.showInMenuKey = exports.defaultAccessFlags = exports.applyTableSaveOverlay = exports.resolveType = exports.normalizeColumns = exports.xmlEscape = exports.buildColumnXml = exports.DEFAULT_COLUMNS_REL_ID = exports.DEFAULT_SAVE_ACTION = exports.DEFAULT_SUPER_CLASS = exports.parseSysIdFromLocation = exports.projectTableGraph = exports.createTable = void 0;
 var createTable_1 = require("./createTable");
 Object.defineProperty(exports, "createTable", { enumerable: true, get: function () { return createTable_1.createTable; } });
 Object.defineProperty(exports, "projectTableGraph", { enumerable: true, get: function () { return createTable_1.projectTableGraph; } });
@@ -42,3 +42,6 @@ Object.defineProperty(exports, "setColumn", { enumerable: true, get: function ()
 Object.defineProperty(exports, "resolveAttributes", { enumerable: true, get: function () { return setColumn_1.resolveAttributes; } });
 Object.defineProperty(exports, "toStoredValue", { enumerable: true, get: function () { return setColumn_1.toStoredValue; } });
 Object.defineProperty(exports, "findTruncationRisk", { enumerable: true, get: function () { return setColumn_1.findTruncationRisk; } });
+var setTable_1 = require("./setTable");
+Object.defineProperty(exports, "setTable", { enumerable: true, get: function () { return setTable_1.setTable; } });
+Object.defineProperty(exports, "resolveTableAttributes", { enumerable: true, get: function () { return setTable_1.resolveTableAttributes; } });

package/dist/table/setTable.d.ts

@@ -0,0 +1,73 @@
+/**
+ * dove-sn set-table — update the dictionary attributes of an EXISTING ServiceNow
+ * TABLE, captured into a named update set, then read back and verified against the
+ * instance.
+ *
+ * WHY THIS IS NOT set-column. Every table carries one sys_dictionary row that
+ * describes the TABLE rather than any column: `internal_type=collection`, with
+ * `element` empty. Table-wide settings live there. `set-column` targets
+ * `name=<table>^element=<column>` and its whole apparatus — inheritance walking,
+ * the max_length ALTER, the shrink guard — is column-shaped; none of it applies to
+ * a collection row. And `set-field` is a DATA verb that refuses sys_dictionary
+ * outright. So the collection row had no owner. This is it.
+ *
+ * The split that settled in practice, extended one step:
+ *   "field"  = a record's value          -> set-field
+ *   "column" = a table's column schema   -> set-column
+ *   "table"  = the table's own schema    -> set-table  (this verb)
+ *
+ * AUDIT IS A TABLE-LEVEL FLAG. `sys_dictionary.audit` on the collection row is what
+ * turns record auditing on for a table: with it true, ServiceNow writes a sys_audit
+ * row per changed field on every insert and update. That is a genuine cost on a
+ * high-write table, so this verb reports the before -> after honestly and never
+ * writes a value over itself.
+ *
+ * THE ALLOWLIST IS DELIBERATELY SMALL. An unbounded write to sys_dictionary lets a
+ * caller silently corrupt schema, so — exactly as set-column does — only named
+ * attributes are settable and everything else is refused by name. Widen WRITABLE
+ * only for an attribute whose behaviour on a collection row has been verified live.
+ */
+import type { ServiceNowClient } from "../client";
+import type { AttributeChange } from "./setColumn";
+export interface TableAttributes {
+    /**
+     * Record auditing for the whole table (sys_dictionary.audit on the collection
+     * row). True makes ServiceNow write a sys_audit row per changed field on every
+     * insert and update.
+     */
+    audit?: boolean;
+}
+export interface SetTableParams {
+    client: ServiceNowClient;
+    /** The table, by name (e.g. "x_cadso_core_setting"). */
+    table: string;
+    /** The attributes to set. At least one is required. */
+    attributes: TableAttributes;
+    /** Update set to capture the change into. REQUIRED on the live path. */
+    updateSetSysId?: string;
+    /** Plan only — resolves and diffs, writes nothing. */
+    dryRun?: boolean;
+}
+export interface SetTableResult {
+    status: "dry-run" | "applied" | "unchanged" | "failed";
+    table: string;
+    /** sys_id of the table's collection sys_dictionary row. */
+    tableSysId: string;
+    updateSetSysId: string;
+    /** The attributes that differed and were written (empty when nothing changed). */
+    changes: Array<AttributeChange>;
+    /** True only when every requested value was READ BACK from the instance and matched. */
+    verified: boolean;
+    /** True when the sys_update_xml row for this table was found in the named update
+     *  set. A write that lands but is not captured cannot be promoted — it dies on this
+     *  instance, so a 200 alone is not success. */
+    capturedInUpdateSet: boolean;
+    note: string;
+}
+/**
+ * Translate the caller's friendly attributes into the sys_dictionary columns to
+ * write. Throws on anything not on the allowlist, and redirects column attributes
+ * to set-column by name rather than reporting them as merely unknown.
+ */
+export declare function resolveTableAttributes(attributes: TableAttributes): Record<string, string>;
+export declare function setTable(params: SetTableParams): Promise<SetTableResult>;

package/dist/table/setTable.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * dove-sn set-table — update the dictionary attributes of an EXISTING ServiceNow
+ * TABLE, captured into a named update set, then read back and verified against the
+ * instance.
+ *
+ * WHY THIS IS NOT set-column. Every table carries one sys_dictionary row that
+ * describes the TABLE rather than any column: `internal_type=collection`, with
+ * `element` empty. Table-wide settings live there. `set-column` targets
+ * `name=<table>^element=<column>` and its whole apparatus — inheritance walking,
+ * the max_length ALTER, the shrink guard — is column-shaped; none of it applies to
+ * a collection row. And `set-field` is a DATA verb that refuses sys_dictionary
+ * outright. So the collection row had no owner. This is it.
+ *
+ * The split that settled in practice, extended one step:
+ *   "field"  = a record's value          -> set-field
+ *   "column" = a table's column schema   -> set-column
+ *   "table"  = the table's own schema    -> set-table  (this verb)
+ *
+ * AUDIT IS A TABLE-LEVEL FLAG. `sys_dictionary.audit` on the collection row is what
+ * turns record auditing on for a table: with it true, ServiceNow writes a sys_audit
+ * row per changed field on every insert and update. That is a genuine cost on a
+ * high-write table, so this verb reports the before -> after honestly and never
+ * writes a value over itself.
+ *
+ * THE ALLOWLIST IS DELIBERATELY SMALL. An unbounded write to sys_dictionary lets a
+ * caller silently corrupt schema, so — exactly as set-column does — only named
+ * attributes are settable and everything else is refused by name. Widen WRITABLE
+ * only for an attribute whose behaviour on a collection row has been verified live.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTableAttributes = resolveTableAttributes;
+exports.setTable = setTable;
+const setField_1 = require("../setField");
+const choices_1 = require("../choices");
+const setColumn_1 = require("./setColumn");
+/** The table-level dictionary attributes set-table will write, keyed by the friendly
+ *  name a caller uses. Everything absent from this map is refused. */
+var WRITABLE = {
+    audit: "audit",
+};
+/**
+ * Attributes that belong to a COLUMN, not the table. Refused by name so that asking
+ * for one earns a redirect to set-column instead of a confusing "not settable".
+ */
+var COLUMN_ATTRIBUTES = [
+    "label",
+    "mandatory",
+    "default",
+    "readOnly",
+    "maxLength",
+    "internalType",
+    "element",
+];
+/**
+ * Translate the caller's friendly attributes into the sys_dictionary columns to
+ * write. Throws on anything not on the allowlist, and redirects column attributes
+ * to set-column by name rather than reporting them as merely unknown.
+ */
+function resolveTableAttributes(attributes) {
+    if (!attributes || typeof attributes !== "object") {
+        throw new Error("set-table: attributes object is required.");
+    }
+    var out = {};
+    var keys = Object.keys(attributes);
+    for (var i = 0; i < keys.length; i += 1) {
+        var key = keys[i];
+        var value = attributes[key];
+        if (value === undefined || value === null)
+            continue;
+        if (COLUMN_ATTRIBUTES.indexOf(key) !== -1) {
+            throw new Error("set-table: '" +
+                key +
+                "' is a COLUMN attribute, not a table one — it lives on a column's " +
+                "dictionary row, not the table's collection row. Use set-column.");
+        }
+        var target = WRITABLE[key];
+        if (!target) {
+            throw new Error("set-table: '" +
+                key +
+                "' is not a settable table attribute. Settable: " +
+                Object.keys(WRITABLE).join(", ") +
+                ".");
+        }
+        out[target] = (0, setColumn_1.toStoredValue)(value);
+    }
+    if (Object.keys(out).length === 0) {
+        throw new Error("set-table: at least one attribute is required.");
+    }
+    return out;
+}
+/**
+ * Fetch the table's collection dictionary row — `element` empty, which is what
+ * distinguishes the table's own row from every column row sharing its `name`.
+ */
+async function fetchCollectionRow(client, table, fields) {
+    var rows = await client.table.query("sys_dictionary", "name=" + (0, choices_1.encodeQueryValue)(table) + "^elementISEMPTY", { limit: 1, fields: fields });
+    if (rows.length > 0)
+        return rows[0];
+    throw new Error("set-table: no collection dictionary row found for '" +
+        table +
+        "'. Check the table name — every real table has exactly one row with " +
+        "internal_type=collection and an empty element.");
+}
+/**
+ * Require the update set to be open. A write into a Complete/Ignored set is accepted
+ * and then silently lost — the change lands on the instance and is captured nowhere,
+ * so it can never be promoted.
+ */
+async function assertUpdateSetOpen(client, updateSetSysId) {
+    var rows = await client.table.query("sys_update_set", "sys_id=" + (0, choices_1.encodeQueryValue)(updateSetSysId), { limit: 1, fields: ["sys_id", "name", "state"] });
+    if (rows.length === 0) {
+        throw new Error("set-table: update set " + updateSetSysId + " not found on this instance.");
+    }
+    var state = (0, setField_1.fieldToString)(rows[0].state);
+    if (state !== "in progress" && state !== "in_progress") {
+        throw new Error("set-table: update set '" +
+            (0, setField_1.fieldToString)(rows[0].name) +
+            "' is '" +
+            state +
+            "', not 'in progress'. A change written into a closed set is captured " +
+            "nowhere and can never be promoted.");
+    }
+}
+/**
+ * Assert the change was captured. The collection row's update name is deterministic
+ * and ends in `_null` — the element is empty, so ServiceNow names the row for "no
+ * column" rather than for a column.
+ */
+async function assertCaptured(client, table, updateSetSysId) {
+    var name = "sys_dictionary_" + table + "_null";
+    var rows = await client.table.query("sys_update_xml", "update_set=" +
+        (0, choices_1.encodeQueryValue)(updateSetSysId) +
+        "^name=" +
+        (0, choices_1.encodeQueryValue)(name), { limit: 1, fields: ["sys_id", "name"] });
+    return rows.length > 0;
+}
+function describeChanges(changes) {
+    return changes
+        .map(function (c) {
+        return c.attribute + " " + (c.from === "" ? "(empty)" : c.from) + " -> " + c.to;
+    })
+        .join(", ");
+}
+async function setTable(params) {
+    if (!params || !params.client) {
+        throw new Error("set-table: client is required.");
+    }
+    if (!params.table || !String(params.table).trim()) {
+        throw new Error("set-table: --table is required.");
+    }
+    // The allowlist is enforced BEFORE anything touches the instance, so an
+    // unsettable attribute fails on the dry-run too.
+    var writes = resolveTableAttributes(params.attributes);
+    var targets = Object.keys(writes);
+    var table = String(params.table).trim();
+    var readFields = ["sys_id", "name", "element", "internal_type"].concat(targets);
+    var row = await fetchCollectionRow(params.client, table, readFields);
+    var tableSysId = (0, setField_1.fieldToString)(row.sys_id);
+    // Diff against what the instance actually stores, so a same-value request is
+    // reported as unchanged rather than written over itself and called applied.
+    var changes = [];
+    for (var i = 0; i < targets.length; i += 1) {
+        var field = targets[i];
+        var from = (0, setField_1.fieldToString)(row[field]);
+        var to = writes[field];
+        if (from !== to) {
+            changes.push({ attribute: field, from: from, to: to });
+        }
+    }
+    if (params.dryRun) {
+        return {
+            status: "dry-run",
+            table: table,
+            tableSysId: tableSysId,
+            updateSetSysId: params.updateSetSysId ? String(params.updateSetSysId).trim() : "",
+            changes: changes,
+            verified: false,
+            capturedInUpdateSet: false,
+            note: changes.length === 0
+                ? "dry-run: no write. " +
+                    table +
+                    " already holds every requested value — nothing would change."
+                : "dry-run: no write. Would set " +
+                    describeChanges(changes) +
+                    " on " +
+                    table +
+                    ", captured into update set " +
+                    (params.updateSetSysId ? params.updateSetSysId : "(none provided)") +
+                    ".",
+        };
+    }
+    if (!params.updateSetSysId || !String(params.updateSetSysId).trim()) {
+        throw new Error("set-table: --update-set <sys_id> is required so the schema change is " +
+            "captured and can be promoted. An uncaptured change exists only on this " +
+            "instance.");
+    }
+    var updateSetSysId = String(params.updateSetSysId).trim();
+    await assertUpdateSetOpen(params.client, updateSetSysId);
+    if (changes.length === 0) {
+        return {
+            status: "unchanged",
+            table: table,
+            tableSysId: tableSysId,
+            updateSetSysId: updateSetSysId,
+            changes: [],
+            verified: true,
+            capturedInUpdateSet: false,
+            note: table +
+                " already holds every requested value — nothing written, and nothing " +
+                "captured: an identical-value write produces no sys_update_xml row.",
+        };
+    }
+    var fieldsToWrite = {};
+    for (var k = 0; k < changes.length; k += 1) {
+        fieldsToWrite[changes[k].attribute] = changes[k].to;
+    }
+    try {
+        await params.client.claude.pushWithUpdateSet({
+            update_set_sys_id: updateSetSysId,
+            table: "sys_dictionary",
+            record_sys_id: tableSysId,
+            fields: fieldsToWrite,
+        });
+    }
+    catch (e) {
+        // The write may or may not have landed — the transport failed, not necessarily
+        // the change. Say exactly that rather than leaving the caller to guess.
+        return {
+            status: "failed",
+            table: table,
+            tableSysId: tableSysId,
+            updateSetSysId: updateSetSysId,
+            changes: changes,
+            verified: false,
+            capturedInUpdateSet: false,
+            note: "the write to " +
+                table +
+                " failed in transport: " +
+                (e instanceof Error ? e.message : String(e)) +
+                ". Re-read the dictionary row before retrying — the change may or may not " +
+                "have landed.",
+        };
+    }
+    // Read back from the instance. A 200 is not proof the value stuck.
+    var afterRow = await fetchCollectionRow(params.client, table, readFields);
+    var verified = true;
+    for (var m = 0; m < targets.length; m += 1) {
+        if ((0, setField_1.fieldToString)(afterRow[targets[m]]) !== writes[targets[m]]) {
+            verified = false;
+        }
+    }
+    var captured = await assertCaptured(params.client, table, updateSetSysId);
+    if (!verified) {
+        return {
+            status: "failed",
+            table: table,
+            tableSysId: tableSysId,
+            updateSetSysId: updateSetSysId,
+            changes: changes,
+            verified: false,
+            capturedInUpdateSet: captured,
+            note: "the write to " +
+                table +
+                " landed but the read-back does not match what was requested — check " +
+                "dictionary ACLs on this instance.",
+        };
+    }
+    return {
+        status: "applied",
+        table: table,
+        tableSysId: tableSysId,
+        updateSetSysId: updateSetSysId,
+        changes: changes,
+        verified: true,
+        capturedInUpdateSet: captured,
+        note: captured
+            ? "Set " +
+                describeChanges(changes) +
+                " on " +
+                table +
+                ", verified by read-back and captured in update set " +
+                updateSetSysId +
+                "."
+            : "Set " +
+                describeChanges(changes) +
+                " on " +
+                table +
+                " and verified by read-back, but NO sys_update_xml row was found in " +
+                "update set " +
+                updateSetSysId +
+                " — the change cannot be promoted off this instance until it is captured.",
+    };
+}

package/package.json

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