@nodetool-ai/node-sdk 0.8.4-a24.2 → 0.8.4

package/dist/_sandbox/sandbox-pptxgen/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: sandbox-pptxgen
+description: Build PowerPoint files in a Code node or CodeAct action, with PptxGenJS running on the host
+---
+
+# PowerPoint writing in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-pptxgen`. Import it at the top of the body.
+
+This pack **writes** PPTX files. To extract text from an existing deck, use
+`@nodetool-ai/sandbox-pptx` instead.
+
+## build — slides to PPTX bytes
+
+Positions are **inches from the top-left**. A widescreen slide is 13.33×7.5.
+
+```js
+import { build } from "@nodetool-ai/sandbox-pptxgen";
+
+const bytes = await build({
+  title: "Q3 Review",
+  author: "NodeTool",
+  slides: [
+    {
+      background: "#0f172a",
+      items: [
+        { type: "text", x: 0.5, y: 0.4, w: 12, h: 1, text: "Q3 Review", fontSize: 36, color: "#ffffff", bold: true },
+        { type: "shape", shape: "rect", x: 0.5, y: 1.6, w: 4, h: 0.15, fill: "#38bdf8" },
+        { type: "image", x: 8, y: 2.5, w: 4, h: 3, data: inputs.chart }
+      ]
+    }
+  ]
+});
+await workspace.writeBytes("q3.pptx", bytes);
+```
+
+Item types:
+
+- `text` — `x`, `y`, `w`/`h` (or `width`/`height`), `text`, `fontSize`,
+  `color` (hex), `bold`, `align` (`left`/`center`/`right`)
+- `image` — `x`, `y`, `w`/`h`, `data` (`Uint8Array` PNG or JPEG)
+- `shape` — `shape` (PptxGenJS name, default `rect`), `x`, `y`, `w`/`h`,
+  `fill` (hex)
+
+## Gotchas
+
+- **Host module.** `build` is async and returns a `Uint8Array`.
+- **At most 200 slides.**
+- **Hex colors** may include a leading `#`.

package/dist/_sandbox/sandbox-pptxgen/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@nodetool-ai/sandbox-pptxgen",
+  "version": "0.8.4",
+  "description": "Build PowerPoint files inside the NodeTool sandbox, with PptxGenJS running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "pptxgen"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-pptxgen"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "pptx"
+  ]
+}

package/dist/_sandbox/sandbox-qr/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: sandbox-qr
+description: Encode text into a QR matrix or SVG inside a Code node or CodeAct action, with uqr running in the guest
+---
+
+# QR codes in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-qr`. One module, the `uqr` root export.
+Import it at the top of the body.
+
+## encode — text to a QR matrix
+
+```js
+import { encode } from "@nodetool-ai/sandbox-qr";
+
+const qr = encode(inputs.text);
+return { size: qr.size, data: qr.data };
+```
+
+`data` is a boolean matrix (`true` is a dark module). `size` is the module count.
+
+## encode — text to SVG
+
+```js
+import { encode } from "@nodetool-ai/sandbox-qr";
+
+const qr = encode(inputs.text);
+const cells = [];
+for (let y = 0; y < qr.size; y++) {
+  for (let x = 0; x < qr.size; x++) {
+    if (qr.data[y][x]) cells.push(`<rect x="${x}" y="${y}" width="1" height="1"/>`);
+  }
+}
+const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${qr.size} ${qr.size}" shape-rendering="crispEdges">${cells.join("")}</svg>`;
+return { svg, size: qr.size };
+```
+
+Or pass the matrix to `@nodetool-ai/sandbox-fabric` if you already have that pack.
+
+## Gotchas
+
+- **Guest only.** No canvas, no PNG encoder. Build SVG yourself or rasterize with Fabric.
+- **Named export.** `import { encode } from "@nodetool-ai/sandbox-qr"`.

package/dist/_sandbox/sandbox-qr/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@nodetool-ai/sandbox-qr",
+  "version": "0.8.4",
+  "description": "Encode QR codes as a matrix or SVG inside the NodeTool sandbox, from uqr",
+  "license": "MIT",
+  "dependencies": {
+    "uqr": "^0.1.3"
+  },
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "js",
+        "npm": "uqr"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-qr"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "qr",
+    "barcode"
+  ]
+}

package/dist/_sandbox/sandbox-rrule/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: sandbox-rrule
+description: Expand iCalendar recurrence rules inside a Code node or CodeAct action, with rrule running in the guest
+---
+
+# Recurrence in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-rrule`. One module, rrule. Import it at the top of the body.
+
+## Build a rule and expand it
+
+```js
+import { RRule } from "@nodetool-ai/sandbox-rrule";
+
+const rule = new RRule({
+  freq: RRule.WEEKLY,
+  interval: 1,
+  count: 4,
+  dtstart: new Date(inputs.start)
+});
+return { dates: rule.all().map((d) => d.toISOString()) };
+```
+
+## Parse an RRULE string
+
+```js
+import { rrulestr } from "@nodetool-ai/sandbox-rrule";
+
+const rule = rrulestr(inputs.rrule);
+return { dates: rule.between(new Date(inputs.from), new Date(inputs.to)).map((d) => d.toISOString()) };
+```
+
+## Gotchas
+
+- **UTC.** Same guest limit as date-fns.
+- **Cap `count` / `between`.** An unbounded `all()` can allocate
+  without end.

package/dist/_sandbox/sandbox-rrule/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@nodetool-ai/sandbox-rrule",
+  "version": "0.8.4",
+  "description": "Recurrence rules (iCalendar RRULE) inside the NodeTool sandbox",
+  "license": "MIT",
+  "dependencies": {
+    "rrule": "^2.8.1"
+  },
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "js",
+        "npm": "rrule"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-rrule"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "rrule",
+    "recurrence",
+    "calendar"
+  ]
+}

package/dist/_sandbox/sandbox-stats/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: sandbox-stats
+description: Mean, median, quantiles, and linear regression inside a Code node or CodeAct action, with simple-statistics running in the guest
+---
+
+# Statistics in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-stats`. One module, simple-statistics.
+Import it at the top of the body.
+
+## Column summaries
+
+```js
+import { mean, median, standardDeviation, quantile } from "@nodetool-ai/sandbox-stats";
+
+const xs = inputs.values;
+return {
+  mean: mean(xs),
+  median: median(xs),
+  sd: standardDeviation(xs),
+  p90: quantile(xs, 0.9)
+};
+```
+
+## Linear regression
+
+```js
+import { linearRegression, linearRegressionLine } from "@nodetool-ai/sandbox-stats";
+
+const fit = linearRegression(inputs.points);
+const line = linearRegressionLine(fit);
+return { m: fit.m, b: fit.b, at10: line(10) };
+```
+
+`inputs.points` is `[[x, y], ...]`.
+
+## Gotchas
+
+- **Named imports.** Import only the functions you use.
+- **Empty arrays throw.** Guard before `mean([])`.
+- **This is not TFJS.** Classification and embeddings stay on
+  `@nodetool-ai/sandbox-tfjs`.

package/dist/_sandbox/sandbox-stats/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@nodetool-ai/sandbox-stats",
+  "version": "0.8.4",
+  "description": "Descriptive statistics and simple regression inside the NodeTool sandbox, from simple-statistics",
+  "license": "MIT",
+  "dependencies": {
+    "simple-statistics": "^7.10.1"
+  },
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "js",
+        "npm": "simple-statistics"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-stats"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "statistics",
+    "regression",
+    "mean"
+  ]
+}

package/dist/_sandbox/sandbox-subtitle/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: sandbox-subtitle
+description: Parse and stringify SRT/WebVTT captions in a Code node or CodeAct action, with subtitle running on the host
+---
+
+# Captions in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-subtitle`. Import it at the top of the body.
+
+The published subtitle bundle uses streams the guest refuses, so this pack
+is a **host module**. You work with plain cue objects.
+
+## parse — SRT or VTT to cues
+
+```js
+import { parse } from "@nodetool-ai/sandbox-subtitle";
+
+const cues = await parse(inputs.captions);
+return { cues };
+```
+
+Each cue is `{ start, end, text }` with times in milliseconds.
+
+## stringify — cues to SRT or VTT
+
+```js
+import { stringify } from "@nodetool-ai/sandbox-subtitle";
+
+const srt = await stringify(inputs.cues, { format: "SRT" });
+return { srt };
+```
+
+Pass `{ format: "WebVTT" }` for VTT.
+
+## Gotchas
+
+- **Async host calls.** Always `await`.
+- **Cue text keeps newlines.** Split on `\n` if you need lines.

package/dist/_sandbox/sandbox-subtitle/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@nodetool-ai/sandbox-subtitle",
+  "version": "0.8.4",
+  "description": "Parse and write SRT and WebVTT captions inside the NodeTool sandbox",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "subtitle"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-subtitle"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "srt",
+    "vtt",
+    "captions",
+    "subtitle"
+  ]
+}

package/dist/_sandbox/sandbox-supabase/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: sandbox-supabase
+description: Read and write Supabase tables from a Code node or CodeAct action, with NodeTool's PostgREST request builder running on the host
+---
+
+# Supabase in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-supabase`. Import it at the top of the body.
+
+Supabase's REST surface is PostgREST: the whole query lives in the URL and the
+write semantics live in a `Prefer` header. Both are easy to get subtly wrong —
+an upsert without `resolution=merge-duplicates` is just a failed insert — so
+this pack does the encoding.
+
+**Nothing here sends a request.** Both exports build one; the guest's own
+`fetch` sends it, under the run's fetch cap and SSRF guard.
+
+## from — one table
+
+```js
+import { from } from "@nodetool-ai/sandbox-supabase";
+
+const url = await nodetool.secrets.get("SUPABASE_URL");
+const key = await nodetool.secrets.get("SUPABASE_KEY");
+
+const req = await from({
+  url, key,
+  table: "issues",
+  select: "id,title,status",
+  filters: { status: "eq.open" },
+  order: "created_at.desc",
+  limit: 20
+});
+const res = await fetch(req.url, req);
+if (!res.ok) throw new Error(`Supabase select failed: ${res.status}`);
+return { rows: res.json };
+```
+
+`method` picks the operation:
+
+| method | operation |
+|---|---|
+| `GET` (default) | select |
+| `POST` | insert, or upsert with `onConflict` |
+| `PATCH` | update the rows the filters match |
+| `DELETE` | delete the rows the filters match |
+
+Options: `url` and `key` (required), `table` (required), `method`, `select`,
+`filters`, `order`, `limit`, `offset`, `body`, `onConflict`, `count`,
+`returning`, `query`.
+
+**Filters** take either form:
+
+```js
+filters: { status: "eq.open", priority: "in.(high,urgent)" }   // raw PostgREST
+filters: { age: { gte: 18, lt: 65 } }                          // operator object
+```
+
+**Insert**
+
+```js
+const req = await from({ url, key, table: "events", method: "POST", body: inputs.rows });
+```
+
+**Update the matching rows**
+
+```js
+const req = await from({
+  url, key, table: "issues", method: "PATCH",
+  filters: { id: `eq.${inputs.id}` },
+  body: { status: "closed" }
+});
+```
+
+**Upsert** — `onConflict` names the unique column and turns the insert into a
+merge:
+
+```js
+const req = await from({
+  url, key, table: "users", method: "POST",
+  onConflict: "email", body: inputs.users
+});
+```
+
+A write returns the affected rows. Pass `returning: "minimal"` when you do not
+want them back.
+
+## rpc — a Postgres function
+
+```js
+import { rpc } from "@nodetool-ai/sandbox-supabase";
+
+const req = await rpc({ url, key, fn: "search_issues", args: { term: inputs.term } });
+return { rows: (await fetch(req.url, req)).json };
+```
+
+## Gotchas
+
+- **Every export is async.** A host call is a round trip.
+- **A `DELETE` or `PATCH` with no filters hits every row.** PostgREST does not
+  refuse it. Pass the filters.
+- **The anon key obeys row-level security.** A select that returns `[]` against
+  a table with rows usually means RLS, not an empty table. The service-role key
+  bypasses it — and bypasses it for every row, so keep it out of anything a
+  user's prompt can steer.
+- **Errors arrive as JSON with a non-2xx status.** Check `res.ok` and read
+  `res.json.message`; PostgREST says exactly what it disliked.
+- **Supabase caps a page at 1000 rows.** Page with `limit` and `offset`.

package/dist/_sandbox/sandbox-supabase/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@nodetool-ai/sandbox-supabase",
+  "version": "0.8.4",
+  "description": "Build Supabase REST and RPC requests inside the NodeTool sandbox, from NodeTool's PostgREST helper running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "supabase"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-supabase"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "supabase",
+    "postgrest"
+  ]
+}

package/dist/_sandbox/sandbox-tfjs/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: sandbox-tfjs
+description: Classify and embed images, detect objects, and answer from a passage in a Code node or CodeAct action, with TensorFlow.js running on the host
+---
+
+# TensorFlow.js models in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-tfjs`. Import it at the top of the body.
+
+The models are tens of megabytes of weights, fetched over the network and kept
+between calls. The guest has neither the heap for them nor a way to keep
+anything alive past a run, so this pack is a **host module**: the import
+resolves to a generated facade over NodeTool's own implementation, and each
+model loads once per process.
+
+These models are small, local, and free — that is the whole reason to reach for
+them. For anything a description or a caption would answer better, use a vision
+model through `nodetool.media` instead.
+
+## classify — ImageNet labels
+
+```js
+import { classify } from "@nodetool-ai/sandbox-tfjs";
+
+const labels = await classify(await workspace.readBytes("photo.jpg"), { topK: 3 });
+return { best: labels[0].className, probability: labels[0].probability };
+```
+
+MobileNet v2 over the 1000 ImageNet classes, most likely first. `topK` defaults
+to 5.
+
+## embed — a feature vector for an image
+
+```js
+import { embed } from "@nodetool-ai/sandbox-tfjs";
+
+const vector = await embed(bytes);   // 1280 numbers
+```
+
+The MobileNet penultimate layer. Compare two vectors by cosine similarity for
+near-duplicate detection or nearest-neighbour search.
+
+## detect — objects with boxes
+
+```js
+import { detect } from "@nodetool-ai/sandbox-tfjs";
+
+const objects = await detect(bytes, { maxBoxes: 10, minScore: 0.6 });
+// [{ className: "person", score: 0.91, bbox: { x, y, width, height } }, …]
+```
+
+COCO-SSD over the 80 COCO classes. The box is in image pixels. `maxBoxes`
+defaults to 20 and `minScore` to 0.5.
+
+## answer — extractive question answering
+
+```js
+import { answer } from "@nodetool-ai/sandbox-tfjs";
+
+const spans = await answer("When was it founded?", inputs.article);
+return { answer: spans[0]?.text ?? null };
+```
+
+BERT QnA quotes the passage — it never writes prose. Each span carries a
+`score` and its `startIndex`/`endIndex` in the passage.
+
+## Gotchas
+
+- **Every export is async**, and the first call to each model waits for its
+  weights to download.
+- **Images go in as encoded bytes** (PNG/JPEG/WebP), decoded through the
+  sandbox's own `image` backend — so the same pixel caps `image.decode`
+  enforces apply, and 10 MB is the input limit.
+- **The models see pixels, nothing else.** `classify` on a screenshot of text
+  answers with an ImageNet class, not with the text; that is
+  `@nodetool-ai/sandbox-ocr`.

package/dist/_sandbox/sandbox-tfjs/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@nodetool-ai/sandbox-tfjs",
+  "version": "0.8.4",
+  "description": "Classify images, detect objects and answer questions inside the NodeTool sandbox, from TensorFlow.js running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "tfjs"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-tfjs"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "tensorflow",
+    "tfjs",
+    "machine-learning",
+    "image-classification",
+    "object-detection"
+  ]
+}