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

package/dist/_sandbox/sandbox-game/sandbox/index.js

@@ -0,0 +1,208 @@
+/** Plain-document helpers for the native engine. Positions use world units. */
+export function game(options = {}) {
+  const scenes = options.scenes ?? [{ id: "level", name: "Level", entities: [] }];
+  return {
+    ...options,
+    schemaVersion: options.schemaVersion ?? 2,
+    engineVersion: "1",
+    id: options.id ?? "game",
+    revision: options.revision ?? "draft",
+    entrySceneId: options.entrySceneId ?? scenes[0]?.id,
+    pixelsPerUnit: options.pixelsPerUnit ?? 32,
+    tickRate: 60,
+    inputActions: options.inputActions ?? ["left", "right", "up", "down", "space"],
+    assets: options.assets ?? {},
+    scenes
+  };
+}
+
+export function entity(id, x = 0, y = 0, options = {}) {
+  return {
+    ...options,
+    id,
+    name: options.name ?? id,
+    templateOnly: options.templateOnly ?? false,
+    transform2d: { ...options.transform2d, x, y,
+      rotation: options.transform2d?.rotation ?? 0,
+      scaleX: options.transform2d?.scaleX ?? 1,
+      scaleY: options.transform2d?.scaleY ?? 1 },
+    behaviors: options.behaviors ?? []
+  };
+}
+
+export function script(source, options = {}) {
+  return { ...options, kind: "script", source: typeof source === "function" ? source.toString() : source,
+    maxCommands: options.maxCommands ?? 16, maxTickMs: options.maxTickMs ?? 8 };
+}
+
+/** Bind installed assets. This does not install bytes or resolve asset IDs. */
+export function registerAssets(document, bindings) {
+  for (const [slot, binding] of Object.entries(bindings)) {
+    const mediaKind = binding.mediaKind ?? "image";
+    document.assets[slot] = { ...binding, mediaKind,
+      ...(mediaKind !== "image" ? { width: binding.width ?? 1, height: binding.height ?? 1 } : {}),
+      pivot: binding.pivot ?? { x: 0.5, y: 0.5 }, sampling: binding.sampling ?? "nearest" };
+  }
+  return document;
+}
+
+function positive(value, name) {
+  if (!Number.isFinite(value) || value <= 0) { throw new Error(`${name} must be positive and finite`); }
+}
+
+function count(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) { throw new Error(`${name} must be a nonnegative integer`); }
+}
+
+/** Append a rectangular grid of tile centres, starting at (x, y). */
+export function fill(tiles, x, y, cols, rows, options = {}) {
+  count(cols, "cols");
+  count(rows, "rows");
+  const { size = 1, width = size, height = size, ...tile } = options;
+  positive(width, "width");
+  positive(height, "height");
+  for (let row = 0; row < rows; row += 1) {
+    for (let col = 0; col < cols; col += 1) {
+      tiles.push({ ...tile, x: x + col * width, y: y + row * height, width, height });
+    }
+  }
+  return tiles;
+}
+
+/** Append one row. Pass {oneWay: true} for a platform crossed from below. */
+export function plank(tiles, x, y, cols, options = {}) {
+  return fill(tiles, x, y, cols, 1, options);
+}
+
+/** Elliptical arc positions, inclusive of its endpoints. Angles are radians. */
+export function arc(x, y, radiusX, radiusY, points, from = 0, to = Math.PI) {
+  count(points, "points");
+  return Array.from({ length: points }, (_, index) => {
+    const angle = from + (to - from) * (points > 1 ? index / (points - 1) : 0);
+    return { x: x + Math.cos(angle) * radiusX, y: y + Math.sin(angle) * radiusY };
+  });
+}
+
+/** Save a complete mutable draft. Publishing remains an explicit tool call. */
+export async function saveGame(bundle, { games, project_id, game_id, base_updated_at } = {}) {
+  if (!games) { throw new Error("saveGame(bundle, {games: nodetool.games, project_id}) requires the game's tool bridge"); }
+  let id = game_id;
+  if (!id) {
+    if (!project_id || !bundle.name) { throw new Error("A new game requires name and project_id"); }
+    const created = await games.create(bundle.name, { project_id });
+    if (created.error || !created.game?.id) { throw new Error(`create_native_game: ${JSON.stringify(created)}`); }
+    id = created.game.id;
+  }
+  if (bundle.program) {
+    const preview = await games.previewAuthoring(id, { program: bundle.program, expected_document: bundle.document, base_updated_at });
+    if (preview.error || !preview.candidate) { throw new Error(`preview_native_game_authoring: ${JSON.stringify(preview)}`); }
+    const applied = await games.applyAuthoring(id, preview.candidate);
+    if (applied.error || !applied.game) { throw new Error(`apply_native_game_authoring: ${JSON.stringify(applied)}`); }
+    return { game_id: applied.game.id, revision: applied.game.revision, draft_updated_at: applied.draft_updated_at };
+  }
+  const saved = await games.edit(id, [{ op: "set_document", document: bundle.document }],
+    base_updated_at === undefined ? {} : { base_updated_at });
+  if (saved.error || !saved.document || !saved.game?.id) {
+    throw new Error(`edit_native_game: ${JSON.stringify(saved)}`);
+  }
+  return { game_id: saved.game.id, revision: saved.game.revision, draft_updated_at: saved.draft_updated_at };
+}
+
+/** Explicit retained function body. All preparation results belong in inputs. */
+export function constructGame(program, build) {
+  if (!program || typeof build !== "function" || !Number.isSafeInteger(program.seed)) {
+    throw new Error("A retained game needs source and an integer authoring seed");
+  }
+  const retainedInputs = JSON.parse(JSON.stringify(program.inputs ?? {}));
+  const inputs = JSON.parse(JSON.stringify(retainedInputs));
+  let state = program.seed >>> 0;
+  const definitions = new Map();
+  const parameters = {};
+  const instances = [];
+  const sceneKeys = new Map();
+  const builder = {
+    game, entity, script, registerAssets, fill, plank, arc,
+    random() {
+      state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
+      return state / 4294967296;
+    },
+    parameter(name, spec) {
+      if (["__proto__", "prototype", "constructor"].includes(name)) { throw new Error(`Unsafe parameter key ${name}`); }
+      if (Object.hasOwn(parameters, name)) { throw new Error(`Duplicate parameter ${name}`); }
+      parameters[name] = JSON.parse(JSON.stringify(spec));
+      const value = inputs[name] ?? spec.default;
+      if (spec.type === "number" && (typeof value !== "number" || !Number.isFinite(value) ||
+        (spec.min !== undefined && value < spec.min) || (spec.max !== undefined && value > spec.max))) {
+        throw new Error(`Invalid number parameter ${name}`);
+      }
+      if ((spec.type === "string" || spec.type === "boolean") && typeof value !== spec.type) {
+        throw new Error(`Invalid ${spec.type} parameter ${name}`);
+      }
+      if (spec.type === "enum" && (!Array.isArray(spec.values) || !spec.values.includes(value))) { throw new Error(`Invalid enum parameter ${name}`); }
+      if ((spec.type === "vector2" || spec.type === "vector3") && (!Array.isArray(value) ||
+        value.length !== (spec.type === "vector2" ? 2 : 3) || value.some((part) => typeof part !== "number" || !Number.isFinite(part)))) {
+        throw new Error(`Invalid vector parameter ${name}`);
+      }
+      if (!["number", "string", "boolean", "enum", "vector2", "vector3"].includes(spec.type)) { throw new Error(`Unknown parameter type ${spec.type}`); }
+      return value;
+    },
+    prefab(key, definition) {
+      if (typeof key !== "string" || !key || definitions.has(key)) { throw new Error(`Duplicate or empty prefab key ${key}`); }
+      definitions.set(key, mergeConstructionProperties({}, definition));
+      return key;
+    },
+    instance(scene, key, prefab, overrides = {}) {
+      let keys = sceneKeys.get(scene);
+      if (!keys) { keys = new Set(scene.entities.map((item) => item.id)); sceneKeys.set(scene, keys); }
+      if (typeof key !== "string" || !key || keys.has(key)) {
+        throw new Error(`Duplicate or empty instance key ${key}`);
+      }
+      const definition = definitions.get(prefab);
+      if (!definition) { throw new Error(`Unknown prefab ${prefab}`); }
+      const instance = { ...mergeConstructionProperties(definition, overrides), id: key };
+      scene.entities.push(instance);
+      keys.add(key);
+      instances.push({ sceneId: scene.id, entityId: key, prefabId: prefab });
+      return instance;
+    }
+  };
+  const document = build(inputs, builder);
+  if (!document || typeof document !== "object" || !Array.isArray(document.scenes)) {
+    throw new Error("Retained construction must return a native document");
+  }
+  const scenes = new Set();
+  const entities = new Set();
+  for (const scene of document.scenes) {
+    if (typeof scene.id !== "string" || !scene.id || scenes.has(scene.id)) { throw new Error(`Duplicate or empty scene key ${scene.id}`); }
+    scenes.add(scene.id);
+    for (const item of scene.entities) {
+      if (typeof item.id !== "string" || !item.id || entities.has(item.id)) { throw new Error(`Duplicate or empty entity key ${item.id}`); }
+      entities.add(item.id);
+    }
+  }
+  return { document, program: { source: program.source ?? `return (${build.toString()})(inputs, builder);`, inputs: retainedInputs, seed: program.seed },
+    parameters, prefabs: Object.fromEntries(definitions), instances };
+}
+
+/** Component fields inherit independently. Arrays are replaced as one value. */
+function mergeConstructionProperties(base, override) {
+  const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+  const checkKeys = (value) => {
+    if (value === null || typeof value !== "object") { return; }
+    for (const [key, item] of Object.entries(value)) {
+      if (["__proto__", "prototype", "constructor"].includes(key)) { throw new Error(`Unsafe construction property ${key}`); }
+      checkKeys(item);
+    }
+  };
+  checkKeys(base);
+  checkKeys(override);
+  const merge = (left, right) => {
+    if (!object(left) || !object(right)) { return JSON.parse(JSON.stringify(right)); }
+    const result = JSON.parse(JSON.stringify(left));
+    for (const [key, value] of Object.entries(right)) {
+      result[key] = object(result[key]) && object(value) ? merge(result[key], value) : JSON.parse(JSON.stringify(value));
+    }
+    return result;
+  };
+  return merge(base, override);
+}

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

@@ -0,0 +1,36 @@
+---
+name: sandbox-gif
+description: Encode an animated GIF from RGBA frames inside a Code node or CodeAct action, with gifenc running in the guest
+---
+
+# GIF encoding in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-gif`. One module, gifenc. Import it at the top of the body.
+
+## Frames to a GIF
+
+```js
+import { GIFEncoder, quantize, applyPalette } from "@nodetool-ai/sandbox-gif";
+
+const gif = GIFEncoder();
+for (const frame of inputs.frames) {
+  const palette = quantize(frame.rgba, 256);
+  const index = applyPalette(frame.rgba, palette);
+  gif.writeFrame(index, inputs.width, inputs.height, {
+    palette,
+    delay: frame.delay ?? 100
+  });
+}
+gif.finish();
+return { bytes: gif.bytes() };
+```
+
+Each `frame.rgba` is a `Uint8Array` of length `width * height * 4`.
+`delay` is milliseconds.
+
+## Gotchas
+
+- **You supply RGBA.** Decode a still with `image.bytes` / canvas, then
+  pack frames yourself.
+- **`gif.bytes()` is a `Uint8Array`.** Write it with
+  `workspace.writeBytes`.

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

@@ -0,0 +1,43 @@
+{
+  "name": "@nodetool-ai/sandbox-gif",
+  "version": "0.8.4",
+  "description": "Encode an animated GIF from RGBA frames inside the NodeTool sandbox, from gifenc",
+  "license": "MIT",
+  "dependencies": {
+    "gifenc": "^1.0.3"
+  },
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "js",
+        "npm": "gifenc"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-gif"
+  },
+  "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",
+    "gif",
+    "animation",
+    "encode"
+  ]
+}

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

@@ -0,0 +1,107 @@
+---
+name: sandbox-html
+description: Select elements out of HTML and convert a page to markdown in a Code node or CodeAct action, with cheerio and turndown running on the host
+---
+
+# HTML in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-html`. Import it at the top of the body.
+
+cheerio imports 25 Node builtins and turndown wants a DOM, so neither compiles
+into the guest. This pack is a **host module**: the import resolves to a
+generated facade over NodeTool's own implementation. Both exports are `async`.
+
+## select — CSS selection
+
+```js
+import { select } from "@nodetool-ai/sandbox-html";
+
+const hrefs = await select(inputs.html, "a[href]", { attr: "href", limit: 500 });
+const titles = await select(inputs.html, "h2");   // trimmed text of each match
+return { hrefs, titles };
+```
+
+Returns trimmed text per match, or the named attribute when `attr` is set.
+`limit` defaults to **100** and is clamped to **1000** — the cap is in the host
+implementation, so raising it in the call does nothing.
+
+## toMarkdown — a whole page
+
+```js
+import { toMarkdown } from "@nodetool-ai/sandbox-html";
+
+const markdown = await toMarkdown(inputs.html);
+return { markdown };
+```
+
+The usual first step before summarizing or indexing a fetched page. Pass
+`{ turndown: {...} }` to override turndown's own options.
+
+## toText — a whole page as plain text
+
+```js
+import { toText } from "@nodetool-ai/sandbox-html";
+
+const text = await toText(inputs.html);
+return { text };
+```
+
+Strips `<script>`/`<style>` and every tag, then collapses whitespace.
+
+## extractLinks / extractImages / extractAudio / extractVideos
+
+```js
+import {
+  extractLinks,
+  extractImages,
+  extractAudio,
+  extractVideos
+} from "@nodetool-ai/sandbox-html";
+
+const links = await extractLinks(inputs.html, inputs.baseUrl);
+// [{ href, text, type: "internal" | "external" }, ...]
+
+const images = await extractImages(inputs.html, inputs.baseUrl); // string[] of resolved URLs
+const audio = await extractAudio(inputs.html, inputs.baseUrl);
+const videos = await extractVideos(inputs.html, inputs.baseUrl);
+```
+
+`baseUrl` is optional. When set, relative `src`/`href` values resolve against
+it and `extractLinks` classifies same-origin links as `internal`. Each
+extractor returns at most 1000 items.
+
+## extractMetadata — title, description, keywords
+
+```js
+import { extractMetadata } from "@nodetool-ai/sandbox-html";
+
+const { title, description, keywords } = await extractMetadata(inputs.html);
+```
+
+Any field the page doesn't set comes back `null`.
+
+## extractReadableText — strip chrome, keep the article
+
+```js
+import { extractReadableText } from "@nodetool-ai/sandbox-html";
+
+const article = await extractReadableText(inputs.html);
+```
+
+Removes `script`/`style`/`nav`/`aside`/`footer`/`header`, then returns the
+text of the first match among `article`, `main`, `[id*=content]`,
+`[class*=content]`, or `body`. A page with none of those returns
+`"No main content found"`.
+
+## Getting a page's base URL
+
+No import needed — `new URL(pageUrl).origin` gives the base URL to pass into
+the extractors above.
+
+## Gotchas
+
+- **Every export is async.**
+- **5 MB of HTML per call.** Larger input is refused by name.
+- **A selector that matches nothing returns `[]`**, never `null`. An invalid
+  selector throws with cheerio's own message.
+- **Extractors cap at 1000 items.** Anything past that is silently dropped.

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

@@ -0,0 +1,40 @@
+{
+  "name": "@nodetool-ai/sandbox-html",
+  "version": "0.8.4",
+  "description": "CSS selection, HTML-to-markdown/text, and link/media/metadata extraction inside the NodeTool sandbox, from cheerio and turndown running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "html"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-html"
+  },
+  "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",
+    "html",
+    "scraping",
+    "markdown"
+  ]
+}

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

@@ -0,0 +1,41 @@
+---
+name: sandbox-ics
+description: Build .ics calendar files in a Code node or CodeAct action, with ics running on the host
+---
+
+# iCalendar in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-ics`. Import it at the top of the body.
+
+The published ics bundle does not compile into QuickJS, so this pack is a
+**host module**.
+
+## createEvent — one event
+
+```js
+import { createEvent } from "@nodetool-ai/sandbox-ics";
+
+const ics = await createEvent({
+  title: inputs.title,
+  start: inputs.start,
+  duration: { hours: 1 },
+  location: inputs.location
+});
+return { ics };
+```
+
+`start` is `[year, month, day, hour, minute]`, e.g. `[2026, 8, 15, 10, 0]`.
+
+## createEvents — many
+
+```js
+import { createEvents } from "@nodetool-ai/sandbox-ics";
+
+const ics = await createEvents(inputs.events);
+return { ics };
+```
+
+## Gotchas
+
+- **Throws on a bad event.** The host unwraps ics's `{ error, value }` bag.
+- **Pair with `@nodetool-ai/sandbox-rrule`** to expand a series first.

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

@@ -0,0 +1,40 @@
+{
+  "name": "@nodetool-ai/sandbox-ics",
+  "version": "0.8.4",
+  "description": "Build iCalendar (.ics) files inside the NodeTool sandbox",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "ics"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-ics"
+  },
+  "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",
+    "ics",
+    "ical",
+    "calendar"
+  ]
+}

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

@@ -0,0 +1,26 @@
+---
+name: sandbox-jmespath
+description: Query a JSON document with JMESPath inside a Code node or CodeAct action
+---
+
+# JMESPath in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-jmespath`. One module, the `jmespath`
+root export. Import it at the top of the body.
+
+## search — pick values out of JSON
+
+```js
+import jmespath from "@nodetool-ai/sandbox-jmespath";
+
+const names = jmespath.search(inputs.data, "items[*].name");
+const total = jmespath.search(inputs.data, "sum(items[*].amount)");
+return { names, total };
+```
+
+## Gotchas
+
+- **Default export.** `import jmespath from "@nodetool-ai/sandbox-jmespath"`.
+- **Missing paths return `null`**, they do not throw.
+- **The expression is a string.** Build it carefully; do not interpolate
+  untrusted input into it.

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

@@ -0,0 +1,43 @@
+{
+  "name": "@nodetool-ai/sandbox-jmespath",
+  "version": "0.8.4",
+  "description": "Query JSON with JMESPath inside the NodeTool sandbox",
+  "license": "MIT",
+  "dependencies": {
+    "jmespath": "^0.16.0"
+  },
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "js",
+        "npm": "jmespath"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-jmespath"
+  },
+  "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",
+    "jmespath",
+    "json",
+    "query"
+  ]
+}

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

@@ -0,0 +1,46 @@
+---
+name: sandbox-mammoth
+description: Read a Word document as text or HTML in a Code node or CodeAct action, with mammoth running on the host
+---
+
+# Word documents in the sandbox (reading)
+
+Specifier: `@nodetool-ai/sandbox-mammoth`. Import it at the top of the body.
+
+mammoth reads a `.docx` buffer through Node's own zip/XML stack; it will never
+be a guest module. This pack is a **host module**: the import resolves to a
+generated facade over NodeTool's own implementation.
+
+## extractRawText — docx bytes to plain text
+
+```js
+import { extractRawText } from "@nodetool-ai/sandbox-mammoth";
+
+const bytes = await workspace.readBytes("report.docx");
+const text = await extractRawText(bytes);
+```
+
+Formatting is discarded — this is the fast path when you only need the words.
+
+## convertToHtml — docx bytes to HTML
+
+```js
+import { convertToHtml } from "@nodetool-ai/sandbox-mammoth";
+
+const html = await convertToHtml(bytes);
+```
+
+Headings, lists, tables, bold/italic runs, and embedded images (as base64 data
+URIs) survive the conversion. Track changes, headers/footers, footnotes, and
+exact visual layout do not — mammoth targets semantic HTML, not a pixel-exact
+render.
+
+Get the bytes from `workspace.readBytes`, or from a fetched body with
+`await response.bytes()`.
+
+## Gotchas
+
+- **Both exports are async.**
+- **10 MB per document.** Larger input is refused by name.
+- **Reading only.** To build a `.docx`, use `@nodetool-ai/sandbox-docx`
+  instead.

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

@@ -0,0 +1,41 @@
+{
+  "name": "@nodetool-ai/sandbox-mammoth",
+  "version": "0.8.4",
+  "description": "Read Word documents inside the NodeTool sandbox, from mammoth running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "mammoth"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-mammoth"
+  },
+  "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",
+    "mammoth",
+    "docx",
+    "word",
+    "document"
+  ]
+}