@superglue/cli 1.1.13 → 1.1.14

package/dist/dist/cli.js

@@ -9077,8 +9077,8 @@ var require_luxon = __commonJS({
         let current = null, currentFull = "", bracketed = false;
         const splits = [];
         for (let i = 0; i < fmt.length; i++) {
-          const c3 = fmt.charAt(i);
-          if (c3 === "'") {
+          const c2 = fmt.charAt(i);
+          if (c2 === "'") {
             if (currentFull.length > 0 || bracketed) {
               splits.push({
                 literal: bracketed || /^\s+$/.test(currentFull),
@@ -9089,9 +9089,9 @@ var require_luxon = __commonJS({
             currentFull = "";
             bracketed = !bracketed;
           } else if (bracketed) {
-            currentFull += c3;
-          } else if (c3 === current) {
-            currentFull += c3;
+            currentFull += c2;
+          } else if (c2 === current) {
+            currentFull += c2;
           } else {
             if (currentFull.length > 0) {
               splits.push({
@@ -9099,8 +9099,8 @@ var require_luxon = __commonJS({
                 val: currentFull
               });
             }
-            currentFull = c3;
-            current = c3;
+            currentFull = c2;
+            current = c2;
           }
         }
         if (currentFull.length > 0) {
@@ -11782,7 +11782,7 @@ var require_luxon = __commonJS({
       return fixOffset(objToLocalTS(obj), offset2, zone);
     }
     function adjustTime(inst, dur) {
-      const oPre = inst.o, year = inst.c.year + Math.trunc(dur.years), month = inst.c.month + Math.trunc(dur.months) + Math.trunc(dur.quarters) * 3, c3 = {
+      const oPre = inst.o, year = inst.c.year + Math.trunc(dur.years), month = inst.c.month + Math.trunc(dur.months) + Math.trunc(dur.quarters) * 3, c2 = {
         ...inst.c,
         year,
         month,
@@ -11797,7 +11797,7 @@ var require_luxon = __commonJS({
         minutes: dur.minutes,
         seconds: dur.seconds,
         milliseconds: dur.milliseconds
-      }).as("milliseconds"), localTS = objToLocalTS(c3);
+      }).as("milliseconds"), localTS = objToLocalTS(c2);
       let [ts, o] = fixOffset(localTS, oPre, inst.zone);
       if (millisToAdd !== 0) {
         ts += millisToAdd;
@@ -11832,72 +11832,72 @@ var require_luxon = __commonJS({
     }
     function toISODate(o, extended, precision) {
       const longFormat = o.c.year > 9999 || o.c.year < 0;
-      let c3 = "";
-      if (longFormat && o.c.year >= 0) c3 += "+";
-      c3 += padStart(o.c.year, longFormat ? 6 : 4);
-      if (precision === "year") return c3;
+      let c2 = "";
+      if (longFormat && o.c.year >= 0) c2 += "+";
+      c2 += padStart(o.c.year, longFormat ? 6 : 4);
+      if (precision === "year") return c2;
       if (extended) {
-        c3 += "-";
-        c3 += padStart(o.c.month);
-        if (precision === "month") return c3;
-        c3 += "-";
+        c2 += "-";
+        c2 += padStart(o.c.month);
+        if (precision === "month") return c2;
+        c2 += "-";
       } else {
-        c3 += padStart(o.c.month);
-        if (precision === "month") return c3;
+        c2 += padStart(o.c.month);
+        if (precision === "month") return c2;
       }
-      c3 += padStart(o.c.day);
-      return c3;
+      c2 += padStart(o.c.day);
+      return c2;
     }
     function toISOTime(o, extended, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone, precision) {
-      let showSeconds = !suppressSeconds || o.c.millisecond !== 0 || o.c.second !== 0, c3 = "";
+      let showSeconds = !suppressSeconds || o.c.millisecond !== 0 || o.c.second !== 0, c2 = "";
       switch (precision) {
         case "day":
         case "month":
         case "year":
           break;
         default:
-          c3 += padStart(o.c.hour);
+          c2 += padStart(o.c.hour);
           if (precision === "hour") break;
           if (extended) {
-            c3 += ":";
-            c3 += padStart(o.c.minute);
+            c2 += ":";
+            c2 += padStart(o.c.minute);
             if (precision === "minute") break;
             if (showSeconds) {
-              c3 += ":";
-              c3 += padStart(o.c.second);
+              c2 += ":";
+              c2 += padStart(o.c.second);
             }
           } else {
-            c3 += padStart(o.c.minute);
+            c2 += padStart(o.c.minute);
             if (precision === "minute") break;
             if (showSeconds) {
-              c3 += padStart(o.c.second);
+              c2 += padStart(o.c.second);
             }
           }
           if (precision === "second") break;
           if (showSeconds && (!suppressMilliseconds || o.c.millisecond !== 0)) {
-            c3 += ".";
-            c3 += padStart(o.c.millisecond, 3);
+            c2 += ".";
+            c2 += padStart(o.c.millisecond, 3);
           }
       }
       if (includeOffset) {
         if (o.isOffsetFixed && o.offset === 0 && !extendedZone) {
-          c3 += "Z";
+          c2 += "Z";
         } else if (o.o < 0) {
-          c3 += "-";
-          c3 += padStart(Math.trunc(-o.o / 60));
-          c3 += ":";
-          c3 += padStart(Math.trunc(-o.o % 60));
+          c2 += "-";
+          c2 += padStart(Math.trunc(-o.o / 60));
+          c2 += ":";
+          c2 += padStart(Math.trunc(-o.o % 60));
         } else {
-          c3 += "+";
-          c3 += padStart(Math.trunc(o.o / 60));
-          c3 += ":";
-          c3 += padStart(Math.trunc(o.o % 60));
+          c2 += "+";
+          c2 += padStart(Math.trunc(o.o / 60));
+          c2 += ":";
+          c2 += padStart(Math.trunc(o.o % 60));
         }
       }
       if (extendedZone) {
-        c3 += "[" + o.zone.ianaName + "]";
+        c2 += "[" + o.zone.ianaName + "]";
       }
-      return c3;
+      return c2;
     }
     var defaultUnitValues = {
       month: 1,
@@ -12015,10 +12015,10 @@ var require_luxon = __commonJS({
       });
     }
     function diffRelative(start, end, opts) {
-      const round = isUndefined(opts.round) ? true : opts.round, rounding = isUndefined(opts.rounding) ? "trunc" : opts.rounding, format = (c3, unit) => {
-        c3 = roundTo(c3, round || opts.calendary ? 0 : 2, opts.calendary ? "round" : rounding);
+      const round = isUndefined(opts.round) ? true : opts.round, rounding = isUndefined(opts.rounding) ? "trunc" : opts.rounding, format = (c2, unit) => {
+        c2 = roundTo(c2, round || opts.calendary ? 0 : 2, opts.calendary ? "round" : rounding);
         const formatter = end.loc.clone(opts).relFormatter(opts);
-        return formatter.format(c3, unit);
+        return formatter.format(c2, unit);
       }, differ = (unit) => {
         if (opts.calendary) {
           if (!end.hasSame(start, unit)) {
@@ -12059,16 +12059,16 @@ var require_luxon = __commonJS({
         const zone = config.zone || Settings.defaultZone;
         let invalid = config.invalid || (Number.isNaN(config.ts) ? new Invalid("invalid input") : null) || (!zone.isValid ? unsupportedZone(zone) : null);
         this.ts = isUndefined(config.ts) ? Settings.now() : config.ts;
-        let c3 = null, o = null;
+        let c2 = null, o = null;
         if (!invalid) {
           const unchanged = config.old && config.old.ts === this.ts && config.old.zone.equals(zone);
           if (unchanged) {
-            [c3, o] = [config.old.c, config.old.o];
+            [c2, o] = [config.old.c, config.old.o];
           } else {
             const ot = isNumber(config.o) && !config.old ? config.o : zone.offset(this.ts);
-            c3 = tsToObj(this.ts, ot);
-            invalid = Number.isNaN(c3.year) ? new Invalid("invalid input") : null;
-            c3 = invalid ? null : c3;
+            c2 = tsToObj(this.ts, ot);
+            invalid = Number.isNaN(c2.year) ? new Invalid("invalid input") : null;
+            c2 = invalid ? null : c2;
             o = invalid ? null : ot;
           }
         }
@@ -12077,7 +12077,7 @@ var require_luxon = __commonJS({
         this.invalid = invalid;
         this.weekData = null;
         this.localWeekData = null;
-        this.c = c3;
+        this.c = c2;
         this.o = o;
         this.isLuxonDateTime = true;
       }
@@ -12836,8 +12836,8 @@ var require_luxon = __commonJS({
         const ts1 = localTS - o1 * minuteMs;
         const ts2 = localTS - o2 * minuteMs;
         const c1 = tsToObj(ts1, o1);
-        const c22 = tsToObj(ts2, o2);
-        if (c1.hour === c22.hour && c1.minute === c22.minute && c1.second === c22.second && c1.millisecond === c22.millisecond) {
+        const c2 = tsToObj(ts2, o2);
+        if (c1.hour === c2.hour && c1.minute === c2.minute && c1.second === c2.second && c1.millisecond === c2.millisecond) {
           return [clone2(this, {
             ts: ts1
           }), clone2(this, {
@@ -13235,10 +13235,10 @@ var require_luxon = __commonJS({
         }
         precision = normalizeUnit(precision);
         const ext = format === "extended";
-        let c3 = toISODate(this, ext, precision);
-        if (orderedUnits.indexOf(precision) >= 3) c3 += "T";
-        c3 += toISOTime(this, ext, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone, precision);
-        return c3;
+        let c2 = toISODate(this, ext, precision);
+        if (orderedUnits.indexOf(precision) >= 3) c2 += "T";
+        c2 += toISOTime(this, ext, suppressSeconds, suppressMilliseconds, includeOffset, extendedZone, precision);
+        return c2;
       }
       /**
        * Returns an ISO 8601-compliant string representation of this DateTime's date component
@@ -13297,8 +13297,8 @@ var require_luxon = __commonJS({
           return null;
         }
         precision = normalizeUnit(precision);
-        let c3 = includePrefix && orderedUnits.indexOf(precision) >= 3 ? "T" : "";
-        return c3 + toISOTime(this, format === "extended", suppressSeconds, suppressMilliseconds, includeOffset, extendedZone, precision);
+        let c2 = includePrefix && orderedUnits.indexOf(precision) >= 3 ? "T" : "";
+        return c2 + toISOTime(this, format === "extended", suppressSeconds, suppressMilliseconds, includeOffset, extendedZone, precision);
       }
       /**
        * Returns an RFC 2822-compatible string representation of this DateTime
@@ -17883,7 +17883,7 @@ attempted value: ${formattedValue}
           type: next.type,
           oneOf: next._whitelist.describe(),
           notOneOf: next._blacklist.describe(),
-          tests: next.tests.filter((n, idx, list) => list.findIndex((c3) => c3.OPTIONS.name === n.OPTIONS.name) === idx).map((fn) => {
+          tests: next.tests.filter((n, idx, list) => list.findIndex((c2) => c2.OPTIONS.name === n.OPTIONS.name) === idx).map((fn) => {
             const params = fn.OPTIONS.params && options ? resolveParams(Object.assign({}, fn.OPTIONS.params), options) : fn.OPTIONS.params;
             return {
               name: fn.OPTIONS.name,
@@ -20164,6 +20164,8 @@ var require_utils = __commonJS({
     var getConnectionProtocol2 = (url) => {
       if (url.startsWith("postgres://") || url.startsWith("postgresql://"))
         return "postgres";
+      if (url.startsWith("mssql://") || url.startsWith("sqlserver://"))
+        return "mssql";
       if (url.startsWith("redis://") || url.startsWith("rediss://"))
         return "redis";
       if (url.startsWith("ftp://") || url.startsWith("ftps://") || url.startsWith("sftp://"))
@@ -21499,17 +21501,18 @@ var require_superglue_client = __commonJS({
           options: params.options,
           runId: params.runId
         }, params.traceId ? { "X-Trace-Id": params.traceId } : void 0);
+        const success3 = response.status ? response.status === "success" : response.success ?? false;
         return {
-          success: response.success,
+          success: success3,
           data: response.data,
           error: response.error,
-          tool: response.tool,
+          tool: response.tool || params.tool,
           stepResults: response.stepResults?.map((sr) => ({
             stepId: sr.stepId,
             success: sr.success,
             data: sr.data,
             error: sr.error
-          }))
+          })) || []
         };
       }
       async abortToolExecution(runId) {
@@ -22014,14 +22017,14 @@ var package_default = {
     "LICENSE"
   ],
   dependencies: {
-    commander: "^13.0.0",
-    "fast-json-patch": "^3.1.1"
+    commander: "15.0.0-0",
+    "fast-json-patch": "3.1.1"
   },
   devDependencies: {
     "@superglue/shared": "file:../shared",
-    "@types/node": "^20.0.0",
-    tsup: "^8.0.0",
-    typescript: "^5.0.0"
+    "@types/node": "25.5.0",
+    tsup: "8.5.1",
+    typescript: "5.8.3"
   },
   scripts: {
     build: "tsup && (cp -r skills dist/ 2>/dev/null || true)",
@@ -23432,13 +23435,18 @@ function registerFindCommand2(parent, getContext2) {
       const mode = opts.mode === "dev" || opts.mode === "prod" ? opts.mode : "all";
       const { items } = await client.listSystems(100, 1, { mode });
       table(
-        items.map((s) => ({
-          id: s.id,
-          name: s.name || "",
-          env: s.environment || "prod",
-          url: (s.url || "").slice(0, 50)
-        })),
-        ["id", "name", "env", "url"]
+        items.map((s) => {
+          const credentialKeys = Object.keys(s.credentials || {});
+          const credPlaceholders = credentialKeys.map((k) => `<<${s.id}_${k}>>`).join(", ");
+          return {
+            id: s.id,
+            name: s.name || "",
+            env: s.environment || "prod",
+            url: (s.url || "").slice(0, 40),
+            credentials: credPlaceholders || "(none)"
+          };
+        }),
+        ["id", "name", "env", "url", "credentials"]
       );
     } catch (err) {
       error(err.message);
@@ -23471,7 +23479,7 @@ function registerFindCommand2(parent, getContext2) {
       if (rawQuery === "*") {
         output({
           success: true,
-          systems: items.map((s) => ({ id: s.id, name: s.name, url: s.url }))
+          systems: items.map((s) => filterSystemFields(s))
         });
         return;
       }
@@ -23482,7 +23490,7 @@ function registerFindCommand2(parent, getContext2) {
       });
       output({
         success: true,
-        systems: filtered.map((s) => ({ id: s.id, name: s.name, url: s.url }))
+        systems: filtered.map((s) => filterSystemFields(s))
       });
     } catch (err) {
       error(err.message);
@@ -23505,6 +23513,46 @@ function registerCallCommand(parent, getContext2) {
     []
   ).addOption(
     new import_commander5.Option("--env <environment>", "Environment: dev or prod").choices(["dev", "prod"])
+  ).addHelpText(
+    "after",
+    `
+${c.bold}Discovering Credential Placeholders:${c.reset}
+  Use 'sg system find <system-id>' to see available credential placeholders:
+
+    ${c.dim}$${c.reset} sg system find my_postgres
+    ${c.green}\u2192 credentialPlaceholders:${c.reset} ["<<my_postgres_username>>", "<<my_postgres_password>>"]
+
+  Or use 'sg system list' to see credentials for all systems at once.
+
+${c.bold}Examples:${c.reset}
+  ${c.dim}# HTTP API with API key${c.reset}
+  sg system call --system-id stripe \\
+    --url "https://api.stripe.com/v1/customers" \\
+    --headers '{"Authorization": "Bearer <<stripe_api_key>>"}'
+
+  ${c.dim}# PostgreSQL database query${c.reset}
+  sg system call --system-id my_postgres \\
+    --url "postgres://<<my_postgres_username>>:<<my_postgres_password>>@localhost:5432/mydb" \\
+    --body '{"query": "SELECT * FROM users WHERE id = $1", "params": [123]}'
+
+  ${c.dim}# Microsoft SQL Server with parameterized query${c.reset}
+  sg system call --system-id azure_sql \\
+    --url "mssql://<<azure_sql_username>>:<<azure_sql_password>>@server.database.windows.net:1433/mydb" \\
+    --body '{"query": "SELECT * FROM orders WHERE status = @param1", "params": ["pending"]}'
+
+  ${c.dim}# Redis command${c.reset}
+  sg system call --system-id my_redis \\
+    --url "redis://<<my_redis_password>>@localhost:6379" \\
+    --body '{"command": "GET", "args": ["user:123"]}'
+
+  ${c.dim}# SFTP list files${c.reset}
+  sg system call --system-id sftp_server \\
+    --url "sftp://<<sftp_server_username>>:<<sftp_server_password>>@files.example.com:22" \\
+    --body '{"operation": "list", "path": "/uploads"}'
+
+${c.bold}Supported Protocols:${c.reset}
+  HTTP/HTTPS, PostgreSQL, MSSQL/SQL Server, Redis, SFTP/FTP/FTPS, SMB
+`
   ).action(async (opts) => {
     const { client } = getContext2();
     const method = opts.method || "GET";

package/dist/dist/skills/superglue/SKILL.md

@@ -246,15 +246,15 @@ sg system call --url "sftp://<<my_sftp_host>>:22/data" \
   --body '{"operation":"list","path":"/"}'
 ```
 
-| Flag                | Description                                                            |
-| ------------------- | ---------------------------------------------------------------------- |
-| `--url <url>`       | Full URL with protocol (http/https/postgres/redis/rediss/sftp/ftp/smb) |
-| `--system-id <id>`  | System ID for credential injection                                     |
-| `--method <method>` | HTTP method (GET, POST, PUT, DELETE, PATCH)                            |
-| `--headers <json>`  | HTTP headers JSON with credential placeholders                         |
-| `--body <string>`   | Request body (JSON string)                                             |
-| `--env <env>`       | Environment: `dev` or `prod`                                           |
-| `--file <key=path>` | File references (repeatable)                                           |
+| Flag                | Description                                                                                       |
+| ------------------- | ------------------------------------------------------------------------------------------------- |
+| `--url <url>`       | Full URL with protocol (http/https/postgres/postgresql/mssql/sqlserver/redis/rediss/sftp/ftp/smb) |
+| `--system-id <id>`  | System ID for credential injection                                                                |
+| `--method <method>` | HTTP method (GET, POST, PUT, DELETE, PATCH)                                                       |
+| `--headers <json>`  | HTTP headers JSON with credential placeholders                                                    |
+| `--body <string>`   | Request body (JSON string)                                                                        |
+| `--env <env>`       | Environment: `dev` or `prod`                                                                      |
+| `--file <key=path>` | File references (repeatable)                                                                      |
 
 **`sg system search-docs`** — Search system documentation.
 
@@ -458,7 +458,7 @@ Empty arrays are valid — the step simply skips execution.
 
 ### Two Step Types
 
-**Request step** (HTTP, Postgres, Redis, FTP/SFTP/SMB) — makes an API call:
+**Request step** (HTTP, PostgreSQL, MSSQL, Redis, FTP/SFTP/SMB) — makes an API call:
 
 ```json
 {
@@ -645,7 +645,7 @@ For detailed documentation on specific topics, read these files in the `referenc
 | File                                  | When to read                                                                                     |
 | ------------------------------------- | ------------------------------------------------------------------------------------------------ |
 | `references/integration.md`           | **READ THIS** when deploying tools to production - SDK usage, REST API, webhooks, error handling |
-| `references/databases.md`             | Building tools that query PostgreSQL/MySQL databases                                             |
+| `references/databases.md`             | Building tools that query PostgreSQL or Microsoft SQL Server (Azure SQL) databases               |
 | `references/redis.md`                 | Building tools that interact with Redis (commands, pipelines, data types)                        |
 | `references/file-servers.md`          | Building tools that interact with FTP/SFTP/SMB file servers                                      |
 | `references/transforms-and-output.md` | Complex data transformations, output shaping, JS sandbox constraints                             |

package/dist/dist/skills/superglue/references/databases.md

@@ -1,6 +1,12 @@
-# Database Steps (PostgreSQL)
+# Database Steps
 
-## Step Configuration
+Superglue supports both PostgreSQL and Microsoft SQL Server (including Azure SQL).
+
+---
+
+## PostgreSQL
+
+### Step Configuration
 
 ```typescript
 {
@@ -78,7 +84,7 @@ Returns `result.rows` — array of row objects with column names as keys.
 - `INSERT/UPDATE/DELETE` with `RETURNING`: array of returned rows
 - Mutations without `RETURNING`: empty array
 
-## Batch Operations via Loop
+### Batch Operations via Loop
 
 Use a data selector returning an array to execute a query per item:
 
@@ -86,3 +92,158 @@ Use a data selector returning an array to execute a query per item:
 // dataSelector: (sourceData) => sourceData.newUsers
 // body: {"query": "INSERT INTO users (name) VALUES ($1)", "params": ["<<(sourceData) => sourceData.currentItem.name>>"]}
 ```
+
+---
+
+## Microsoft SQL Server / Azure SQL
+
+### Step Configuration
+
+```typescript
+{
+  type: "request",
+  systemId: "my_azure_sql",
+  url: "mssql://<<my_azure_sql_user>>:<<my_azure_sql_password>>@<<my_azure_sql_host>>:<<my_azure_sql_port>>/<<my_azure_sql_database>>",
+  method: "POST",            // ignored for MSSQL but required by schema
+  body: '{"query": "SELECT * FROM users WHERE id = @param1", "params": [<<userId>>]}'
+}
+```
+
+Configure the connection url depending on which credentials are saved in the stored db system - reference them accordingly.
+
+### URL Format
+
+```
+mssql://user:password@host:port/database
+sqlserver://user:password@host:port/database
+```
+
+Both `mssql://` and `sqlserver://` protocols are supported. All credential variables are resolved before connecting.
+
+#### Azure SQL Database Connection
+
+For Azure SQL Database, use the fully qualified server name:
+
+```
+mssql://myuser@myserver:mypassword@myserver.database.windows.net:1433/mydatabase
+```
+
+You can include connection parameters as query strings:
+
+```
+mssql://user:password@host:port/database?encrypt=true&trustServerCertificate=false
+```
+
+**Connection Parameters:**
+
+- `encrypt` (default: `true`) - Enable/disable encryption (required for Azure SQL)
+- `trustServerCertificate` (default: `false`) - Whether to trust the server certificate
+- `database` - Database name (can be in URL path or query parameter)
+
+### Body Format
+
+JSON string with `query` and optional `params` (or `values`):
+
+```json
+{
+  "query": "SELECT * FROM users WHERE age > @param1 AND status = @param2",
+  "params": [25, "active"]
+}
+```
+
+### Parameterized Queries
+
+**Always use parameterized queries** with `@param1`, `@param2`, etc. — prevents SQL injection.
+
+```json
+{ "query": "SELECT * FROM orders WHERE customer_id = @param1", "params": ["<<customerId>>"] }
+```
+
+With expressions:
+
+```json
+{
+  "query": "INSERT INTO logs (message, level) VALUES (@param1, @param2)",
+  "params": ["<<(sourceData) => sourceData.message>>", "error"]
+}
+```
+
+With OUTPUT (MSSQL equivalent of RETURNING):
+
+```json
+{
+  "query": "INSERT INTO users (name, email) OUTPUT INSERTED.* VALUES (@param1, @param2)",
+  "params": [
+    "<<(sourceData) => sourceData.currentItem.name>>",
+    "<<(sourceData) => sourceData.currentItem.email>>"
+  ]
+}
+```
+
+**Parameter Naming**: MSSQL uses named parameters with `@` prefix. The params array maps positionally: `params[0]` → `@param1`, `params[1]` → `@param2`, etc.
+
+### Connection Pooling
+
+- Pools cached by connection string, max 10 clients per pool
+- 5s connection timeout, configurable request timeout
+- Idle pools cleaned up automatically
+- SSL/TLS encryption enabled by default for Azure SQL
+
+### Retry Logic
+
+Default retries from server config. On final failure, error includes query text and params.
+
+### Return Value
+
+Returns the recordset — array of row objects with column names as keys.
+
+- `SELECT`: array of matching rows
+- `INSERT/UPDATE/DELETE` with `OUTPUT`: array of returned rows
+- Mutations without `OUTPUT`: empty array
+
+### Batch Operations via Loop
+
+Use a data selector returning an array to execute a query per item:
+
+```javascript
+// dataSelector: (sourceData) => sourceData.newUsers
+// body: {"query": "INSERT INTO users (name) VALUES (@param1)", "params": ["<<(sourceData) => sourceData.currentItem.name>>"]}
+```
+
+### Common Patterns
+
+**Simple SELECT:**
+
+```json
+{
+  "query": "SELECT id, name, email FROM users WHERE status = @param1",
+  "params": ["active"]
+}
+```
+
+**INSERT with OUTPUT:**
+
+```json
+{
+  "query": "INSERT INTO users (name, email, created_at) OUTPUT INSERTED.id, INSERTED.created_at VALUES (@param1, @param2, GETUTCDATE())",
+  "params": ["John Doe", "john@example.com"]
+}
+```
+
+**UPDATE with OUTPUT:**
+
+```json
+{
+  "query": "UPDATE users SET last_login = GETUTCDATE() OUTPUT INSERTED.id, INSERTED.last_login WHERE id = @param1",
+  "params": [123]
+}
+```
+
+**Stored Procedure Call:**
+
+```json
+{
+  "query": "EXEC dbo.GetUserById @param1",
+  "params": [123]
+}
+```

package/dist/dist/skills/superglue/references/transforms-and-output.md

@@ -82,9 +82,9 @@ Payload fields are at root level — **NEVER** use `sourceData.payload.*`.
 
 ## JS Code Constraints (all transform points)
 
-Runs in `isolated-vm` sandbox:
+Runs in Deno subprocess sandbox:
 
-- 4096 MB memory limit, 10s timeout (transforms/selectors), 3s timeout (pagination stops)
+- 8192 MB memory limit, 10 minute timeout per transform
 - Synchronous only — no async/await, no Promises, no setTimeout
 - No side effects — no network, filesystem, or console access
 - No external dependencies — only standard JS built-ins (Array, Object, String, Math, Date, JSON, etc.)