@rubytech/create-maxy-code 0.1.557 → 0.1.559

package/payload/platform/plugins/admin/skills/video-production/render.mjs

@@ -0,0 +1,429 @@
+#!/usr/bin/env node
+// Frame-accurate MP4 capture over the Chrome DevTools Protocol. No npm packages —
+// Node 22's built-in fetch and WebSocket are the whole transport.
+//
+//   node render.mjs --mode reel --target <path|file:|http:> --out <dir> --name <slug> \
+//                   --width 1080 --height 1920 [--dsf 1] [--mobile] [--pre '<js>'] [--port 9333]
+//
+//   node render.mjs --mode page --target <path|file:|http:> --out <dir> --name <slug> \
+//                   --width 1920 --height 1080 --frames 900 [--dsf 1] [--mobile] \
+//                   [--pre '<js>'] [--port 9333]
+//
+// The two modes differ in one thing: how the clock advances.
+//   reel — the page defines window.__frames and window.__seek(i); every frame is
+//          computed from the index alone, so the timeline is deterministic.
+//   page — Chrome's virtual time clock is advanced one frame at a time, so a page
+//          we do not control is captured with its own animation playing.
+//
+// This script owns the whole run: resolve the browser, launch it, capture, encode,
+// poster, probe, stills, tear down, census. Splitting encode or cleanup out leaves
+// the frame directory with no owner, which is how /tmp fills up with frames.
+
+import {
+  writeFileSync, mkdirSync, rmSync, existsSync, readFileSync,
+  appendFileSync, statSync, readdirSync,
+} from "node:fs";
+import { spawn, execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// ---------------------------------------------------------------- arguments
+
+const argv = process.argv.slice(2);
+const arg = (flag, fallback = null) => {
+  const i = argv.indexOf(flag);
+  return i >= 0 && i + 1 < argv.length ? argv[i + 1] : fallback;
+};
+const flag = f => argv.includes(f);
+
+const mode = arg("--mode");
+const target = arg("--target");
+const outDir = arg("--out");
+const name = arg("--name");
+const width = Number(arg("--width", 1080));
+const height = Number(arg("--height", 1920));
+const dsf = Number(arg("--dsf", 1));
+const mobile = flag("--mobile");
+const pre = arg("--pre");
+const port = arg("--port", "9333");
+const framesArg = arg("--frames");
+
+const FRAME_MS = 1000 / 30;
+const FRAMES_ROOT = join(tmpdir(), "video-production");
+const T0 = Date.now();
+
+// ---------------------------------------------------------------- logging
+// Same fail-open shape as the platform hooks: always stdout, plus a durable
+// breadcrumb in $LOG_DIR when that is a real directory. An unwritable log
+// never fails a render.
+
+const LOG_FILE =
+  process.env.LOG_DIR && existsSync(process.env.LOG_DIR)
+    ? join(process.env.LOG_DIR, "video-render.log")
+    : null;
+
+function log(line) {
+  const s = `${new Date().toISOString()} ${line}`;
+  console.log(s);
+  if (LOG_FILE) { try { appendFileSync(LOG_FILE, s + "\n"); } catch { /* fail open */ } }
+}
+
+function die(line) { log(line); process.exit(1); }
+
+const run = name || "unnamed";
+
+if (!mode || !["reel", "page"].includes(mode)) die(`[video-render] op=bad-args run=${run} reason=mode-must-be-reel-or-page`);
+if (!target) die(`[video-render] op=bad-args run=${run} reason=target-required`);
+if (!outDir) die(`[video-render] op=bad-args run=${run} reason=out-required`);
+if (!name) die(`[video-render] op=bad-args run=${run} reason=name-required`);
+// --name is joined into four filesystem paths and both output filenames, so it is
+// a path component, not a label. A slash or a dot-dot would escape them.
+if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) {
+  die(`[video-render] op=bad-args run=${run} reason=name-must-be-a-slug value=${JSON.stringify(name)}`);
+}
+if (mode === "page" && !framesArg) die(`[video-render] op=bad-args run=${run} reason=frames-required-in-page-mode`);
+
+const url =
+  /^(https?|file):/.test(target) ? target : pathToFileURL(target).href;
+
+log(`[video-render] op=request run=${run} mode=${mode} target=${url} w=${width} h=${height} dsf=${dsf} fps=30`);
+
+// ---------------------------------------------------------------- census
+
+// frameDirs/frameBytes are the strict leak signal: a capture directory outlives
+// its run only when a render died without tearing down, so a healthy end reports
+// zero for both. stillDirs/stillBytes are counted separately because verification
+// stills are deliberately retained for the agent to read after the run — counting
+// them as frames would make every successful render look like a leak.
+function census(phase) {
+  let chromiumLive = 0, frameDirs = 0, frameBytes = 0, stillDirs = 0, stillBytes = 0;
+  try {
+    // A read, never a kill. This process's own argv carries no such string,
+    // so it cannot count itself.
+    chromiumLive = Number(execFileSync("bash", ["-c",
+      'pgrep -f "remote-debugging-port=" 2>/dev/null | wc -l']).toString().trim());
+  } catch { /* pgrep absent or no matches */ }
+  try {
+    for (const d of readdirSync(FRAMES_ROOT)) {
+      const p = join(FRAMES_ROOT, d);
+      if (!statSync(p).isDirectory()) continue;
+      const isStills = d.endsWith("-stills");
+      let bytes = 0;
+      for (const f of readdirSync(p)) {
+        try { bytes += statSync(join(p, f)).size; } catch { /* raced */ }
+      }
+      if (isStills) { stillDirs++; stillBytes += bytes; }
+      else { frameDirs++; frameBytes += bytes; }
+    }
+  } catch { /* root absent on a first run */ }
+  log(`[video-census] phase=${phase} run=${run} chromiumLive=${chromiumLive} frameDirs=${frameDirs} frameBytes=${frameBytes} stillDirs=${stillDirs} stillBytes=${stillBytes}`);
+}
+
+census("start");
+
+// ---------------------------------------------------------------- preflight
+
+const platformRoot =
+  process.env.PLATFORM_ROOT || fileURLToPath(new URL("../../../../", import.meta.url));
+const binFile = join(platformRoot, "config", "chromium-binary.path");
+
+if (!existsSync(binFile)) {
+  die(`[video-render] op=chromium-missing run=${run} file=${binFile}`);
+}
+const bin = readFileSync(binFile, "utf8").trim();
+if (!bin || !existsSync(bin)) {
+  die(`[video-render] op=chromium-missing run=${run} file=${binFile} bin=${bin || "(empty)"}`);
+}
+log(`[video-render] op=chromium-resolve run=${run} bin=${bin} source=config`);
+
+for (const tool of ["ffmpeg", "ffprobe"]) {
+  try { execFileSync("which", [tool], { stdio: "ignore" }); }
+  catch { die(`[video-render] op=tool-missing run=${run} tool=${tool}`); }
+}
+
+const frameDir = join(FRAMES_ROOT, run);
+const stillDir = join(FRAMES_ROOT, `${run}-stills`);
+const profile = join(tmpdir(), `video-production-profile-${run}`);
+rmSync(frameDir, { recursive: true, force: true });
+rmSync(stillDir, { recursive: true, force: true });
+rmSync(profile, { recursive: true, force: true });
+mkdirSync(frameDir, { recursive: true });
+mkdirSync(stillDir, { recursive: true });
+mkdirSync(outDir, { recursive: true });
+
+// ---------------------------------------------------------------- launch
+// detached:true makes the child a process-group leader, which is what lets
+// teardown kill the whole browser tree by group rather than leaving zygotes.
+// Never pkill -f on the port: that pattern also matches the shell that ran it.
+
+const child = spawn(bin, [
+  "--headless=new",
+  `--remote-debugging-port=${port}`,
+  "--remote-debugging-address=127.0.0.1",
+  `--user-data-dir=${profile}`,
+  "--no-sandbox",
+  "--disable-gpu",
+  "--disable-dev-shm-usage",
+  "--hide-scrollbars",
+  "--force-device-scale-factor=1",
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--disable-background-networking",
+  "--disable-features=TranslateUI",
+  "--font-render-hinting=none",
+  `--window-size=${width},${height}`,
+  "about:blank",
+], { detached: true, stdio: "ignore" });
+child.unref();
+const chromePid = child.pid;
+log(`[video-render] op=chromium-start run=${run} pid=${chromePid} port=${port}`);
+
+// ---------------------------------------------------------------- CDP
+
+async function browserSocket(ms = 20000) {
+  const start = Date.now();
+  while (Date.now() - start < ms) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${port}/json/version`);
+      if (r.ok) return (await r.json()).webSocketDebuggerUrl;
+    } catch { /* not up yet */ }
+    await new Promise(r => setTimeout(r, 300));
+  }
+  return null;
+}
+
+const wsUrl = await browserSocket();
+if (!wsUrl) {
+  killBrowser();
+  die(`[video-render] op=cdp-unreachable run=${run} port=${port}`);
+}
+
+const ws = new WebSocket(wsUrl);
+await new Promise((res, rej) => {
+  ws.addEventListener("open", res, { once: true });
+  ws.addEventListener("error", rej, { once: true });
+});
+
+let msgId = 0, sessionId = null;
+const waiting = new Map();
+const listeners = new Map();
+
+ws.addEventListener("message", e => {
+  const m = JSON.parse(e.data);
+  if (m.id && waiting.has(m.id)) { waiting.get(m.id)(m); waiting.delete(m.id); return; }
+  if (m.method && listeners.has(m.method)) {
+    const arr = listeners.get(m.method);
+    listeners.delete(m.method);
+    for (const fn of arr) fn(m.params);
+  }
+});
+
+// Arm BEFORE sending the command that triggers the event, or the event can
+// land between the send and the listen and the await never resolves.
+function armed(method) {
+  let resolve;
+  const p = new Promise(r => { resolve = r; });
+  if (!listeners.has(method)) listeners.set(method, []);
+  listeners.get(method).push(resolve);
+  return p;
+}
+
+const send = (method, params = {}, timeoutMs = 90000) => new Promise((res, rej) => {
+  const n = ++msgId;
+  const t = setTimeout(() => { waiting.delete(n); rej(new Error(`cdp timeout: ${method}`)); }, timeoutMs);
+  waiting.set(n, m => {
+    clearTimeout(t);
+    m.error ? rej(new Error(`${method}: ${JSON.stringify(m.error)}`)) : res(m.result);
+  });
+  const msg = { id: n, method, params };
+  if (sessionId) msg.sessionId = sessionId;
+  ws.send(JSON.stringify(msg));
+});
+
+const ev = async expr =>
+  (await send("Runtime.evaluate", { expression: expr, returnByValue: true, awaitPromise: true }))
+    ?.result?.value;
+
+// Its own tab. Grabbing the first page target collides with any other CDP client
+// already attached to this browser.
+const { targetId } = await send("Target.createTarget", { url: "about:blank" });
+sessionId = (await send("Target.attachToTarget", { targetId, flatten: true })).sessionId;
+
+await send("Page.enable");
+await send("Runtime.enable");
+await send("Emulation.setDeviceMetricsOverride", {
+  width, height, deviceScaleFactor: dsf, mobile,
+  screenWidth: width, screenHeight: height,
+});
+// Load-bearing. Headless otherwise reports prefers-reduced-motion: reduce, and a
+// page that honours it stops animating — a capture that is silently frozen.
+await send("Emulation.setEmulatedMedia", {
+  features: [{ name: "prefers-reduced-motion", value: "no-preference" }],
+});
+
+// ---------------------------------------------------------------- teardown
+
+function killBrowser() {
+  try { process.kill(-chromePid, "SIGTERM"); }
+  catch { try { process.kill(chromePid, "SIGTERM"); } catch { /* already gone */ } }
+}
+
+async function teardown() {
+  try { await send("Target.closeTarget", { targetId }, 10000); } catch { /* browser may be gone */ }
+  try { ws.close(); } catch { /* already closed */ }
+  log(`[video-render] op=chromium-stop run=${run} pid=${chromePid}`);
+  killBrowser();
+  // The delay is required. A synchronous check reports a premature alive=false.
+  await new Promise(r => setTimeout(r, 2000));
+  let alive = true;
+  try { process.kill(chromePid, 0); } catch { alive = false; }
+  if (alive) { try { process.kill(-chromePid, "SIGKILL"); } catch { /* raced */ } }
+  log(`[video-render] op=survives-stop run=${run} pid=${chromePid} alive=${alive}`);
+  rmSync(profile, { recursive: true, force: true });
+}
+
+// A failed render must leave no more behind than a successful one. The frames
+// captured before the failure have no consumer, and a 4600-frame run abandons
+// gigabytes if they are kept.
+async function abort(line) {
+  await teardown();
+  rmSync(frameDir, { recursive: true, force: true });
+  rmSync(stillDir, { recursive: true, force: true }); // no stills exist on an abort
+  log(`${line} framesDirRemoved=${!existsSync(frameDir)}`);
+  census("abort");
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------- navigate
+
+const loaded = armed("Page.loadEventFired");
+try { await send("Page.navigate", { url }); }
+catch (e) { await abort(`[video-render] op=navigate-failed run=${run} url=${url} error=${e.message}`); }
+await loaded;
+await new Promise(r => setTimeout(r, 1500)); // fonts
+
+const stepTime = async ms => {
+  const expired = armed("Emulation.virtualTimeBudgetExpired");
+  await send("Emulation.setVirtualTimePolicy", { policy: "advance", budget: ms });
+  await expired;
+};
+
+if (mode === "page") await stepTime(1);          // arm the virtual clock
+if (pre) {
+  try { await ev(pre); }
+  catch (e) { await abort(`[video-render] op=pre-failed run=${run} error=${e.message}`); }
+  if (mode === "page") await stepTime(60);       // let the pre-actions settle
+}
+
+// ---------------------------------------------------------------- the clock
+
+let total, preShot, postShot;
+if (mode === "reel") {
+  total = await ev("window.__frames");
+  if (!Number.isFinite(total) || total < 1) {
+    await abort(`[video-render] op=frames-missing run=${run} value=${JSON.stringify(total)}`);
+  }
+  preShot = async i => { await ev(`window.__seek(${i})`); };
+  postShot = async () => {};
+} else {
+  total = Number(framesArg);
+  if (!Number.isFinite(total) || total < 1) {
+    await abort(`[video-render] op=bad-args run=${run} reason=frames-not-a-positive-number`);
+  }
+  preShot = async () => {};
+  postShot = async () => { await stepTime(FRAME_MS); };
+}
+log(`[video-render] op=frames-declared run=${run} frames=${total}`);
+
+// ---------------------------------------------------------------- capture
+
+async function shot(i) {
+  let last;
+  for (let attempt = 0; attempt < 4; attempt++) {
+    try {
+      const r = await send("Page.captureScreenshot",
+        { format: "jpeg", quality: 92, captureBeyondViewport: false, fromSurface: true }, 25000);
+      if (r?.data) return Buffer.from(r.data, "base64");
+      last = new Error("no screenshot data");
+    } catch (e) { last = e; }
+  }
+  await abort(`[video-render] op=capture-failed run=${run} i=${i} error=${last?.message}`);
+}
+
+let bytesMin = Infinity, bytesMax = 0, bytesTotal = 0;
+for (let i = 0; i < total; i++) {
+  await preShot(i);
+  const buf = await shot(i);
+  writeFileSync(join(frameDir, `f-${String(i).padStart(5, "0")}.jpg`), buf);
+  if (buf.length < bytesMin) bytesMin = buf.length;
+  if (buf.length > bytesMax) bytesMax = buf.length;
+  bytesTotal += buf.length;
+  if (i % 60 === 0) log(`[video-render] op=capture run=${run} i=${i} bytes=${buf.length}`);
+  await postShot(i);
+}
+// The blank-render discriminator. A frozen capture encodes to a perfectly valid,
+// perfectly useless MP4, and nothing else separates it from a good one.
+log(`[video-render] op=capture-done run=${run} frames=${total} bytesMin=${bytesMin} bytesMax=${bytesMax} bytesTotal=${bytesTotal}`);
+
+await teardown();
+
+// ---------------------------------------------------------------- encode
+
+const mp4 = join(outDir, `${name}.mp4`);
+const poster = join(outDir, `${name}-poster.jpg`);
+
+try {
+  execFileSync("ffmpeg", [
+    "-y", "-loglevel", "error", "-framerate", "30",
+    "-i", join(frameDir, "f-%05d.jpg"),
+    "-c:v", "libx264", "-crf", "21", "-preset", "slow",
+    "-pix_fmt", "yuv420p", "-movflags", "+faststart", "-an", mp4,
+  ]);
+} catch (e) {
+  die(`[video-render] op=encode-failed run=${run} error=${e.message}`);
+}
+
+// Read back what was produced. Never assert the encode arguments as the result.
+let probe;
+try {
+  probe = JSON.parse(execFileSync("ffprobe", [
+    "-v", "error", "-select_streams", "v:0",
+    "-show_entries", "stream=width,height,codec_name",
+    "-show_entries", "format=duration", "-of", "json", mp4,
+  ]).toString());
+} catch (e) {
+  die(`[video-render] op=probe-failed run=${run} error=${e.message}`);
+}
+const stream = probe.streams?.[0] ?? {};
+const durationS = Number(probe.format?.duration ?? 0);
+const fileBytes = statSync(mp4).size;
+log(`[video-render] op=encode run=${run} durationS=${durationS.toFixed(2)} wxh=${stream.width}x${stream.height} codec=${stream.codec_name} fileBytes=${fileBytes}`);
+
+try {
+  execFileSync("ffmpeg", ["-y", "-loglevel", "error", "-ss", String(durationS / 2),
+    "-i", mp4, "-frames:v", "1", "-q:v", "3", poster]);
+} catch (e) {
+  die(`[video-render] op=poster-failed run=${run} error=${e.message}`);
+}
+
+// The agent must READ these. That is the step that catches a wrapped counter or a
+// clipped headline, and no script can do it.
+const stills = [];
+for (const frac of [0.05, 0.35, 0.65, 0.95]) {
+  const at = join(stillDir, `s-${String(Math.round(frac * 100)).padStart(2, "0")}.jpg`);
+  try {
+    execFileSync("ffmpeg", ["-y", "-loglevel", "error", "-ss", String(durationS * frac),
+      "-i", mp4, "-frames:v", "1", "-q:v", "3", at]);
+    stills.push(at);
+  } catch { /* a still past the last keyframe is not fatal */ }
+}
+log(`[video-render] op=stills run=${run} count=${stills.length} paths=${stills.join(",")}`);
+
+// ---------------------------------------------------------------- exit
+
+rmSync(frameDir, { recursive: true, force: true });
+const framesDirRemoved = !existsSync(frameDir);
+log(`[video-render] op=exit run=${run} ranMs=${Date.now() - T0} framesDirRemoved=${framesDirRemoved} outputBytes=${fileBytes} mp4=${mp4} poster=${poster}`);
+census("end");
+process.exit(0);

package/payload/platform/plugins/admin/skills/whats-new/SKILL.md

@@ -9,6 +9,23 @@ Invoked by the admin agent directly.
 
 This is the platform's release timeline, newest first. Each entry shows the date it shipped and the version it shipped in, so you can tell the operator how current their install is. To compare, read the installed version from `capabilities-here` and match it against the versions below. Keep answers high level and in plain English; this is a summary, not a full commit log.
 
+## 2026-08-04 (0.1.559)
+
+- Upgrading no longer deletes specialists. Every upgrade was removing any specialist that did not ship with the install, including ones written for you, and never putting them back. An upgrade now only replaces what it actually ships, and reports at boot any specialist the roster cannot dispatch.
+- A specialist can now tell an instruction from its coordinator apart from text that merely claims to be one. One was refusing genuine operator instructions as suspected injection; every specialist card now states where a coordinator message comes from and what authority it carries.
+- Multi-step workflows can pass data between steps. The runner was discarding each step's structured result, so a later step could never read an earlier one's output.
+- A Telegram bot that receives a message and never answers is now reported. That check existed on the WhatsApp path only.
+- A conversation that starts on a channel and produces nothing is no longer invisible. The assistant's own output is now captured, so a session that boots and then says nothing leaves a trace to diagnose.
+- On a quotation, a gap the assistant noticed while pricing now survives into the saved figures instead of being dropped when the job is handed to the pricing engine.
+- The scheduling health count now covers routines that run without the model, not just those that use it, so the shift away from model-driven runs has something to measure against.
+
+## 2026-08-04 (0.1.558)
+
+- The assistant can now produce short videos and social reels. Ask it for a video and it renders an MP4 from your images, text and audio, rather than assembling a one-off pipeline each time.
+- A public Telegram bot can now reply. Bots opened on the public route were being given a reply tool that was never connected, so messages arrived, the conversation stayed alive, and nothing ever came back.
+- Scrolling back through a very long conversation no longer stops part-way. A single very large message could stall the scroll-back at a fixed point, putting everything above it out of reach no matter how far you scrolled; on one 15 MB conversation that was everything before the last 1.4 MB.
+- The Telegram health check now separates how long ago a conversation was started from how long ago it last said anything, and can see a conversation that has not spoken yet.
+
 ## 2026-08-04 (0.1.557)
 
 - The status dot on a one-time routine that has already run now shows it as finished rather than live, matching the card text added in the previous release.

package/payload/platform/plugins/docs/PLUGIN.md

@@ -27,6 +27,7 @@ Load these when users ask about Maxy features or need guidance:
 - **Projects** → `references/projects-guide.md` — creating projects, tracking health, phase transitions, completing
 - **Workflows** → `references/workflows.md` — saving and running multi-step processes, declared inputs, scheduling, run history
 - **Slides** → `references/slides.md` — generating, theming, and reviewing HTML slide decks with `/slides`
+- **Making videos** → `references/video-production.md` — social reels and animated explainers as real MP4 files, portrait or landscape, made on the device with no upload
 - **Calendar & booking** → `references/calendar-booking.md` — the admin calendar at `/calendar`, deploying a public booking page, setting availability, and how bookings become meetings
 - **Troubleshooting** → `references/troubleshooting.md` — common issues and how to resolve them
 

package/payload/platform/plugins/docs/references/video-production.md

@@ -0,0 +1,37 @@
+# Making videos
+
+{{productName}} makes real video files on your own device. No upload, no external service, no subscription. Ask for one in plain words.
+
+> "Make me three social reels about the free trial."
+>
+> "Can I have that in portrait and landscape?"
+>
+> "Record that page playing its animation."
+
+## What you get
+
+An MP4 file, silent, at whatever size you need. Portrait (1080x1920) for stories and reels, landscape (1920x1080) for a website or a presentation, or any other shape you ask for. Each video comes with a poster image, which is the still that shows before someone presses play.
+
+Ask for another shape at any time and the same content is recut for it. You do not have to describe it again.
+
+## Two kinds of video
+
+**Made from scratch.** The agent designs the video itself, in your brand's colours and type, and animates it frame by frame. This is what you want for a social reel, an explainer, or anything with a message to land.
+
+**A recording of a page.** If you already have a page that animates, the agent can record it playing. Useful when the page is the thing you want to show.
+
+## How long it takes
+
+A short reel takes a few minutes. A long recording of a full page can take considerably longer. The agent tells you when it starts and comes back when it is done.
+
+## What to check
+
+The agent looks at four frames from every video it makes before telling you it is finished, so a video that came out blank or with text running off the edge gets caught and re-rendered. You should still watch it. Text that is correct but reads badly is a judgement only you can make.
+
+## Where the files go
+
+Finished videos land in your account's output folder, and the agent sends them to you in the chat. Ask for them on a web page and they get published to your site with everything on one page you can open on a phone.
+
+## Fonts
+
+Videos use the fonts installed on your device. If you want a specific brand font and it has never been used on this device before, say so — it may need installing first.

package/payload/platform/plugins/filesystem/mcp/dist/lib/result.d.ts

@@ -6,7 +6,11 @@ export interface ToolResult {
     /** Present and true only on error results, so `.isError` is well-typed on the
      *  ok|err union that handlers return. */
     isError?: true;
+    /** Task 2406 — the tool's structured return, for a workflow step's
+     *  `{{key.field}}`. Absent on errors: the workflow engine throws on isError
+     *  before it reads the output. */
+    structuredContent?: Record<string, unknown>;
 }
-export declare const ok: (text: string) => ToolResult;
+export declare const ok: (text: string, structuredContent?: Record<string, unknown>) => ToolResult;
 export declare const err: (text: string) => ToolResult;
 //# sourceMappingURL=result.d.ts.map

package/payload/platform/plugins/filesystem/mcp/dist/lib/result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/lib/result.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1C;6CACyC;IACzC,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED,eAAO,MAAM,EAAE,GAAI,MAAM,MAAM,KAAG,UAAqD,CAAC;AACxF,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,KAAG,UAGjC,CAAC"}
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/lib/result.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1C;6CACyC;IACzC,OAAO,CAAC,EAAE,IAAI,CAAC;IACf;;sCAEkC;IAClC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED,eAAO,MAAM,EAAE,GAAI,MAAM,MAAM,EAAE,oBAAoB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,UAG7E,CAAC;AACH,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,KAAG,UAGjC,CAAC"}

package/payload/platform/plugins/filesystem/mcp/dist/lib/result.js

@@ -1,4 +1,7 @@
-export const ok = (text) => ({ content: [{ type: "text", text }] });
+export const ok = (text, structuredContent) => ({
+    content: [{ type: "text", text }],
+    ...(structuredContent ? { structuredContent } : {}),
+});
 export const err = (text) => ({
     content: [{ type: "text", text }],
     isError: true,

package/payload/platform/plugins/filesystem/mcp/dist/lib/result.js.map

@@ -1 +1 @@
-{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/lib/result.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAY,EAAc,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;AACxF,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,IAAY,EAAc,EAAE,CAAC,CAAC;IAChD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IACjC,OAAO,EAAE,IAAI;CACd,CAAC,CAAC"}
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/lib/result.ts"],"names":[],"mappings":"AAYA,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAY,EAAE,iBAA2C,EAAc,EAAE,CAAC,CAAC;IAC5F,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IACjC,GAAG,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;CACpD,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,IAAY,EAAc,EAAE,CAAC,CAAC;IAChD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IACjC,OAAO,EAAE,IAAI;CACd,CAAC,CAAC"}

package/payload/platform/plugins/filesystem/mcp/dist/tools/file-read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-read.d.ts","sourceRoot":"","sources":["../../src/tools/file-read.ts"],"names":[],"mappings":"AACA,OAAO,EAAiD,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAK1F,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,EAAE,GAAG,yCAmBpG"}
+{"version":3,"file":"file-read.d.ts","sourceRoot":"","sources":["../../src/tools/file-read.ts"],"names":[],"mappings":"AACA,OAAO,EAAiD,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAK1F,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,EAAE,GAAG,yCAoBpG"}

package/payload/platform/plugins/filesystem/mcp/dist/tools/file-read.js

@@ -19,7 +19,8 @@ export function fileRead(args, ctx) {
             return err(`file-read: not a file: ${args.path}`);
         if (st.size > MAX_FILE)
             return err(`file-read: file too large (${st.size} bytes, max ${MAX_FILE})`);
-        return ok(readFileSync(abs, "utf-8"));
+        const content = readFileSync(abs, "utf-8");
+        return ok(content, { path: args.path, content, bytes: st.size });
     }
     catch (e) {
         return err(`file-read: ${e.message}`);

package/payload/platform/plugins/filesystem/mcp/dist/tools/file-read.js.map

@@ -1 +1 @@
-{"version":3,"file":"file-read.js","sourceRoot":"","sources":["../../src/tools/file-read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAY,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAE3C,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,OAAO;AAEzC,MAAM,UAAU,QAAQ,CAAC,IAAkE,EAAE,GAAQ;IACnG,MAAM,CAAC,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3E,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,GAAG,CAAC,qBAAqB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IAC/D,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,aAAa,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,CACR,wCAAwC,CAAC,CAAC,QAAQ,KAAK,iBAAiB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,YAAY,CAC5G,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE;YAAE,OAAO,GAAG,CAAC,0BAA0B,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACpE,IAAI,EAAE,CAAC,IAAI,GAAG,QAAQ;YAAE,OAAO,GAAG,CAAC,8BAA8B,EAAE,CAAC,IAAI,eAAe,QAAQ,GAAG,CAAC,CAAC;QACpG,OAAO,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC;IACxC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,GAAG,CAAC,cAAe,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC;IACnD,CAAC;AACH,CAAC"}
+{"version":3,"file":"file-read.js","sourceRoot":"","sources":["../../src/tools/file-read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAY,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAE3C,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,OAAO;AAEzC,MAAM,UAAU,QAAQ,CAAC,IAAkE,EAAE,GAAQ;IACnG,MAAM,CAAC,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3E,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,GAAG,CAAC,qBAAqB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IAC/D,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,aAAa,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,CACR,wCAAwC,CAAC,CAAC,QAAQ,KAAK,iBAAiB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,YAAY,CAC5G,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE;YAAE,OAAO,GAAG,CAAC,0BAA0B,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACpE,IAAI,EAAE,CAAC,IAAI,GAAG,QAAQ;YAAE,OAAO,GAAG,CAAC,8BAA8B,EAAE,CAAC,IAAI,eAAe,QAAQ,GAAG,CAAC,CAAC;QACpG,MAAM,OAAO,GAAG,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QAC3C,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IACnE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,GAAG,CAAC,cAAe,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC;IACnD,CAAC;AACH,CAAC"}

package/payload/platform/plugins/filesystem/mcp/dist/tools/file-write.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-write.d.ts","sourceRoot":"","sources":["../../src/tools/file-write.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiD,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAG1F,wBAAgB,SAAS,CACvB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,EACnF,GAAG,EAAE,GAAG,yCAmBT"}
+{"version":3,"file":"file-write.d.ts","sourceRoot":"","sources":["../../src/tools/file-write.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiD,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAG1F,wBAAgB,SAAS,CACvB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,EACnF,GAAG,EAAE,GAAG,yCAoBT"}

package/payload/platform/plugins/filesystem/mcp/dist/tools/file-write.js

@@ -16,7 +16,8 @@ export function fileWrite(args, ctx) {
     try {
         mkdirSync(dirname(abs), { recursive: true });
         writeFileSync(abs, args.content, "utf-8");
-        return ok(`wrote ${Buffer.byteLength(args.content)} bytes to ${args.path}`);
+        const bytes = Buffer.byteLength(args.content);
+        return ok(`wrote ${bytes} bytes to ${args.path}`, { path: args.path, bytes });
     }
     catch (e) {
         return err(`file-write: ${e.message}`);

package/payload/platform/plugins/filesystem/mcp/dist/tools/file-write.js.map

@@ -1 +1 @@
-{"version":3,"file":"file-write.js","sourceRoot":"","sources":["../../src/tools/file-write.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAY,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAE3C,MAAM,UAAU,SAAS,CACvB,IAAmF,EACnF,GAAQ;IAER,MAAM,CAAC,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5E,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,GAAG,CAAC,sBAAsB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IAChE,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,aAAa,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,CACR,yCAAyC,CAAC,CAAC,QAAQ,KAAK,iBAAiB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,YAAY,CAC7G,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7C,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC1C,OAAO,EAAE,CAAC,SAAS,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAC9E,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,GAAG,CAAC,eAAgB,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC;IACpD,CAAC;AACH,CAAC"}
+{"version":3,"file":"file-write.js","sourceRoot":"","sources":["../../src/tools/file-write.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAY,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAE3C,MAAM,UAAU,SAAS,CACvB,IAAmF,EACnF,GAAQ;IAER,MAAM,CAAC,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5E,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,GAAG,CAAC,sBAAsB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IAChE,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,aAAa,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,CACR,yCAAyC,CAAC,CAAC,QAAQ,KAAK,iBAAiB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,YAAY,CAC7G,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7C,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC1C,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9C,OAAO,EAAE,CAAC,SAAS,KAAK,aAAa,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAChF,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,GAAG,CAAC,eAAgB,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC;IACpD,CAAC;AACH,CAAC"}

package/payload/platform/plugins/scheduling/PLUGIN.md

@@ -138,11 +138,11 @@ Backfilling already-written `:Event` appointments into `:Meeting` is a separate
 
 ### Reading meetings back
 
-Both labels are readable. `schedule-list` returns meetings and events together and tags each row `kind`; a meeting renders as `MEETING — <title> (<start>) → <end> (<uid>)`. `status` filters **events only**, because a `:Meeting` carries no `eventStatus`; `from`, `to` and `upcoming` apply to meetings on `startsAt`.
+Both labels are readable. `schedule-list` returns meetings and events together and tags each row `kind`; a meeting renders as `MEETING — <title> (<start>) → <end> (<uid>)`. `status` filters **events only**, because a `:Meeting` carries no `eventStatus`; `from`, `to` and `upcoming` apply to meetings on `startsAt`. `kind` selects one source: `kind: "event"` returns scheduled events only, `kind: "meeting"` returns booked meetings only, and omitting it returns both. Because `status` is event-only, `kind: "meeting"` combined with a status returns nothing rather than silently dropping one of the two filters.
 
 A meeting's handle is its `uid`. `schedule-event` returns it on creation, and `schedule-get`, `schedule-update` and `schedule-cancel` accept it wherever they accept an event id — they resolve an event first, then a meeting, so a caller never has to say which kind it holds. Updating a meeting sets `title`, `startsAt`, `endsAt` and `location` and never rewrites the `uid`; `eventStatus`, `recurrence`, `note`, `action` and `agentDispatch` have no meeting equivalent and do not cross over. A meeting DOES carry a `description`: `schedule-event` writes one, `schedule-get` returns it, and the admin Calendar edits it. `schedule-update` does not write it, so this tool's field set is narrower than the admin Calendar edit's. Cancelling a meeting **deletes** it and its attendee edges, the same as deleting it on the Calendar page — a `:Meeting` has no status to set to cancelled. A booking-sourced meeting that is deleted is rewritten by the next reconcile run.
 
-Until this landed, `schedule-list` matched `:Event` alone while `schedule-event` wrote `:Meeting`, so an agent could not see its own writes: a calendar-sync turn read back an empty list, re-applied the same three meetings, and told the operator over WhatsApp that they had not saved. Observability is therefore two-part. Every list call logs `[schedule-list] op=result meetings=<n> events=<n>`. The standing check is `[schedule-audit] account=<id> meetings=<n> listable=<n> invisible=<n>`, emitted per account on every `reconcile-bookings` run (every 120 s) **before** that script's Cloudflare gates, so it also reports on installs with no booking site. `listable` is what the real `scheduleList` returns, not a re-implementation of its query — that is the whole point, since a copy would agree with a broken original. `invisible=0` is the success signal; `invisible>0` means a calendar entry exists that the agent cannot see.
+Until this landed, `schedule-list` matched `:Event` alone while `schedule-event` wrote `:Meeting`, so an agent could not see its own writes: a calendar-sync turn read back an empty list, re-applied the same three meetings, and told the operator over WhatsApp that they had not saved. Observability is therefore two-part. Every list call logs `[schedule-list] op=result kind=<kind|any> meetings=<n> events=<n>`. The standing check is `[schedule-audit] account=<id> meetings=<n> listable=<n> invisible=<n>`, emitted per account on every `reconcile-bookings` run (every 120 s) **before** that script's Cloudflare gates, so it also reports on installs with no booking site. `listable` is what the real `scheduleList` returns, not a re-implementation of its query — that is the whole point, since a copy would agree with a broken original. `invisible=0` is the success signal; `invisible>0` means a calendar entry exists that the agent cannot see.
 
 ### Routine run records
 
@@ -389,6 +389,8 @@ The `sessionKey` parameter on `schedule-event` automatically creates the `PART_O
 
 Export events as `.ics` files so users can add them to Apple Calendar, Google Calendar, or Outlook. Use `schedule-export-ics` with the event IDs; it writes the `.ics` under the account's `output/ics/` directory and returns the path. Deliver that file to the operator (see the `file-presentation` skill for how delivery works on this surface).
 
+Both `schedule-list` and `schedule-export-ics` also return `structuredContent` — `{ events, count }` and the export result (`outputPath`, `eventCount`, `rruleMapped`, `rruleFallback`, `notFound`, `noStartDate`) — so a workflow step can address those fields directly instead of parsing the prose.
+
 Import `.ics` files uploaded by the user. Use `schedule-import-ics` with the attachment path. Present the extracted events for confirmation before creating them via `schedule-event`.
 
 Cron→RRULE mapping for recurring events: daily, weekly-with-days, and monthly-by-date patterns produce standard RRULE properties. Cron patterns that cannot map to RRULE (e.g. `0 8 1,15 * *`) produce individual VEVENTs per occurrence instead.