@mastra/code-sdk 1.8.4-alpha.5 → 1.9.0-alpha.10

package/dist/plugins/scaffold.js

@@ -1,8 +1,8 @@
 import "../constants.js";
 import { upsertPluginManifestEntry } from "./manifest.js";
 import { ensureMastraCodePackageLink } from "./package-link.js";
-import fs from "fs";
 import path from "path";
+import fs from "fs";
 //#region src/plugins/scaffold.ts
 function resolveScaffoldTarget(target, options = {}) {
 	if (isBarePluginName(target)) return path.join(options.projectRoot ?? process.cwd(), options.configDir ?? ".mastracode", "plugins", "sources", "local", target);

package/dist/process-memory-diagnostics.js

@@ -1,11 +1,11 @@
-import { randomUUID } from "crypto";
-import { homedir } from "os";
 import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
 import { appendFile, chmod, mkdir, rename, rm, writeFile } from "fs/promises";
+import { getHeapSpaceStatistics, getHeapStatistics } from "v8";
 import { Session } from "inspector/promises";
 import { PerformanceObserver } from "perf_hooks";
 import { arch as arch$1, platform as platform$1 } from "process";
-import { getHeapSpaceStatistics, getHeapStatistics } from "v8";
 //#region src/process-memory-diagnostics.ts
 const PROCESS_MEMORY_DIAGNOSTICS_DEFAULTS = {
 	sampleIntervalMs: 1e4,

package/dist/providers/amazon-bedrock-gateway.js

@@ -1,6 +1,6 @@
 import { getBedrockModelCatalog } from "./amazon-bedrock.js";
-import { existsSync } from "fs";
 import path from "path";
+import { existsSync } from "fs";
 import { MastraModelGateway } from "@mastra/core/llm";
 import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers";

package/dist/providers/openai-codex.js

@@ -1,6 +1,6 @@
+import { supportsMaxReasoningEffort } from "../thinking.js";
 import { AuthStorage } from "../auth/storage.js";
 import { ProviderAuthRequiredError } from "../auth/provider-auth-error.js";
-import { supportsMaxReasoningEffort } from "../thinking.js";
 import { createOpenAI } from "@ai-sdk/openai";
 import { wrapLanguageModel } from "ai";
 //#region src/providers/openai-codex.ts

package/dist/schedules/index.d.ts

@@ -0,0 +1,10 @@
+export { parseInterval, validateInterval, nextFireTime } from './interval.js';
+export type { ParsedInterval, IntervalError, IntervalCheck } from './interval.js';
+export { assembleSchedulePrompt, formatScriptOutput, SCRIPT_TIMEOUT_MS } from './prompt.js';
+export type { RunScript, ScriptResult, AssemblePromptOptions, AssembledPrompt } from './prompt.js';
+export { ThreadScheduler, shortScheduleId, describeScheduleSource, scheduleSignalAttributes, SCHEDULE_SIGNAL_SOURCE, LATE_FIRE_GRACE_MS, } from './scheduler.js';
+export type { ThreadSchedule, ThreadScheduleSpec, ThreadScheduleSource, ScheduleTrigger, ScheduleFile, ThreadSchedulerOptions, ScheduleRunResult, } from './scheduler.js';
+export { runScript, resolveScriptCommand, isExecutableFile } from './run-script.js';
+export { createScheduleTools, SCHEDULE_TOOL_IDS } from './tools.js';
+export type { ScheduleToolsOptions, ScheduleFileOptions } from './tools.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schedules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schedules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC9E,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC5F,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnG,OAAO,EACL,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpE,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/schedules/index.js

@@ -0,0 +1,6 @@
+import { nextFireTime, parseInterval, validateInterval } from "./interval.js";
+import { SCRIPT_TIMEOUT_MS, assembleSchedulePrompt, formatScriptOutput } from "./prompt.js";
+import { LATE_FIRE_GRACE_MS, SCHEDULE_SIGNAL_SOURCE, ThreadScheduler, describeScheduleSource, scheduleSignalAttributes, shortScheduleId } from "./scheduler.js";
+import { isExecutableFile, resolveScriptCommand, runScript } from "./run-script.js";
+import { SCHEDULE_TOOL_IDS, createScheduleTools } from "./tools.js";
+export { LATE_FIRE_GRACE_MS, SCHEDULE_SIGNAL_SOURCE, SCHEDULE_TOOL_IDS, SCRIPT_TIMEOUT_MS, ThreadScheduler, assembleSchedulePrompt, createScheduleTools, describeScheduleSource, formatScriptOutput, isExecutableFile, nextFireTime, parseInterval, resolveScriptCommand, runScript, scheduleSignalAttributes, shortScheduleId, validateInterval };

package/dist/schedules/interval.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Interval parsing and fire-time math for `/schedules`.
+ *
+ * Users type `5m`, `2h`, `1 day`. Schedules fire on local wall-clock
+ * boundaries (5m fires at :00, :05, ...), so only intervals that divide the
+ * hour (minutes) or the day (hours) give a stable cadence; anything else is
+ * rejected with the nearest valid suggestion instead of silently drifting.
+ */
+export type ParsedInterval = {
+    ms: number;
+    label: string;
+};
+export type IntervalError = {
+    error: string;
+};
+/** Parse `5m`, `2h`, `1 day`, `90 minutes` into milliseconds plus a normalized label. */
+export declare function parseInterval(text: string): ParsedInterval | IntervalError;
+export type IntervalCheck = {
+    ok: true;
+} | {
+    error: string;
+    suggestion?: string;
+};
+/**
+ * Check that an interval fires on stable clock boundaries: whole minutes that
+ * divide the hour, whole hours that divide the day, or exactly one day.
+ */
+export declare function validateInterval({ ms }: {
+    ms: number;
+}): IntervalCheck;
+/**
+ * The first boundary strictly after `after`, on the local wall clock
+ * (5m → :00, :05, ...; 2h → 00:00, 02:00, ...; 1d → midnight). `intervalMs`
+ * must pass {@link validateInterval}.
+ *
+ * Around daylight-saving changes this behaves like cron:
+ * - Sub-hour cadences follow the minute hand, so they keep firing every N real
+ *   minutes through both the skipped and the repeated hour. Across a
+ *   half-hour change, the gap between fires never exceeds the interval.
+ * - Hourly and daily cadences fire once per wall-clock slot. A boundary that
+ *   falls in a skipped hour fires at the first minute after the jump (02:00 →
+ *   03:00), and a repeated hour does not fire a second time.
+ *
+ * Computing from `after` rather than from the previous fire means a late
+ * timer (sleep, busy event loop) skips missed boundaries instead of bursting
+ * to catch up.
+ */
+export declare function nextFireTime(intervalMs: number, after: number): number;
+//# sourceMappingURL=interval.d.ts.map

package/dist/schedules/interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.d.ts","sourceRoot":"","sources":["../../src/schedules/interval.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3D,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAyB9C,yFAAyF;AACzF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,aAAa,CAc1E;AAED,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAWlF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE,EAAE;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CA6CtE;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAkBtE"}

package/dist/schedules/interval.js

@@ -0,0 +1,215 @@
+//#region src/schedules/interval.ts
+/**
+* Interval parsing and fire-time math for `/schedules`.
+*
+* Users type `5m`, `2h`, `1 day`. Schedules fire on local wall-clock
+* boundaries (5m fires at :00, :05, ...), so only intervals that divide the
+* hour (minutes) or the day (hours) give a stable cadence; anything else is
+* rejected with the nearest valid suggestion instead of silently drifting.
+*/
+const SECOND_MS = 1e3;
+const MINUTE_MS = 60 * SECOND_MS;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+const UNIT_MS = {
+	s: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	sec: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	secs: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	second: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	seconds: {
+		ms: SECOND_MS,
+		short: "s"
+	},
+	m: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	min: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	mins: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	minute: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	minutes: {
+		ms: MINUTE_MS,
+		short: "m"
+	},
+	h: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	hr: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	hrs: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	hour: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	hours: {
+		ms: HOUR_MS,
+		short: "h"
+	},
+	d: {
+		ms: DAY_MS,
+		short: "d"
+	},
+	day: {
+		ms: DAY_MS,
+		short: "d"
+	},
+	days: {
+		ms: DAY_MS,
+		short: "d"
+	}
+};
+const INTERVAL_RE = /^(\d+)\s*([a-z]+)$/i;
+/** Parse `5m`, `2h`, `1 day`, `90 minutes` into milliseconds plus a normalized label. */
+function parseInterval(text) {
+	const match = INTERVAL_RE.exec(text.trim());
+	if (!match) return { error: `Invalid interval "${text}". Use a number followed by a unit, e.g. 5m, 2h, 1d.` };
+	const value = Number(match[1]);
+	const unit = UNIT_MS[match[2].toLowerCase()];
+	if (!unit) return { error: `Unknown interval unit "${match[2]}". Use s, m, h, or d.` };
+	if (value <= 0) return { error: "Interval must be greater than zero." };
+	return {
+		ms: value * unit.ms,
+		label: `${value}${unit.short}`
+	};
+}
+const MINUTE_DIVISORS = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	10,
+	12,
+	15,
+	20,
+	30,
+	60
+];
+const HOUR_DIVISORS = [
+	1,
+	2,
+	3,
+	4,
+	6,
+	8,
+	12,
+	24
+];
+function nearest(candidates, target) {
+	return candidates.reduce((best, candidate) => Math.abs(candidate - target) < Math.abs(best - target) ? candidate : best);
+}
+/**
+* Check that an interval fires on stable clock boundaries: whole minutes that
+* divide the hour, whole hours that divide the day, or exactly one day.
+*/
+function validateInterval({ ms }) {
+	if (ms < MINUTE_MS) return {
+		error: "Schedules fire at most once per minute.",
+		suggestion: "1m"
+	};
+	if (ms % MINUTE_MS !== 0) {
+		const minutes = Math.round(ms / MINUTE_MS);
+		return {
+			error: "Interval must be a whole number of minutes.",
+			suggestion: `${Math.max(1, nearest(MINUTE_DIVISORS, minutes))}m`
+		};
+	}
+	const minutes = ms / MINUTE_MS;
+	if (minutes < 60) {
+		if (60 % minutes === 0) return { ok: true };
+		return {
+			error: `${minutes}m does not divide an hour evenly.`,
+			suggestion: `${nearest(MINUTE_DIVISORS, minutes)}m`
+		};
+	}
+	if (minutes % 60 !== 0) {
+		const hours = Math.round(minutes / 60);
+		return {
+			error: `${minutes}m is not a whole number of hours.`,
+			suggestion: hours < 24 ? `${nearest(HOUR_DIVISORS, hours)}h` : "1d"
+		};
+	}
+	const hours = minutes / 60;
+	if (hours < 24) {
+		if (24 % hours === 0) return { ok: true };
+		return {
+			error: `${hours}h does not divide a day evenly.`,
+			suggestion: `${nearest(HOUR_DIVISORS, hours)}h`
+		};
+	}
+	if (hours === 24) return { ok: true };
+	return {
+		error: "Intervals longer than one day are not supported.",
+		suggestion: "1d"
+	};
+}
+/** Hour-and-longer cadences: which local wall-clock slot a minute belongs to. */
+function hourSlotKey(date, stepHours) {
+	return ((date.getFullYear() * 12 + date.getMonth()) * 31 + date.getDate()) * 24 + Math.floor(date.getHours() / stepHours) * stepHours;
+}
+/**
+* The first boundary strictly after `after`, on the local wall clock
+* (5m → :00, :05, ...; 2h → 00:00, 02:00, ...; 1d → midnight). `intervalMs`
+* must pass {@link validateInterval}.
+*
+* Around daylight-saving changes this behaves like cron:
+* - Sub-hour cadences follow the minute hand, so they keep firing every N real
+*   minutes through both the skipped and the repeated hour. Across a
+*   half-hour change, the gap between fires never exceeds the interval.
+* - Hourly and daily cadences fire once per wall-clock slot. A boundary that
+*   falls in a skipped hour fires at the first minute after the jump (02:00 →
+*   03:00), and a repeated hour does not fire a second time.
+*
+* Computing from `after` rather than from the previous fire means a late
+* timer (sleep, busy event loop) skips missed boundaries instead of bursting
+* to catch up.
+*/
+function nextFireTime(intervalMs, after) {
+	const cursor = /* @__PURE__ */ new Date(Math.floor(after / MINUTE_MS) * MINUTE_MS);
+	const stepMinutes = intervalMs / MINUTE_MS;
+	if (stepMinutes < 60) {
+		const latest = cursor.getTime() + intervalMs;
+		do
+			cursor.setTime(cursor.getTime() + MINUTE_MS);
+		while (cursor.getMinutes() % stepMinutes !== 0 && cursor.getTime() < latest);
+		return cursor.getTime();
+	}
+	const stepHours = stepMinutes / 60;
+	const startSlot = hourSlotKey(new Date(after), stepHours);
+	do
+		cursor.setTime(cursor.getTime() + MINUTE_MS);
+	while (hourSlotKey(cursor, stepHours) <= startSlot);
+	return cursor.getTime();
+}
+//#endregion
+export { nextFireTime, parseInterval, validateInterval };
+
+//# sourceMappingURL=interval.js.map

package/dist/schedules/interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.js","names":[],"sources":["../../src/schedules/interval.ts"],"sourcesContent":["/**\n * Interval parsing and fire-time math for `/schedules`.\n *\n * Users type `5m`, `2h`, `1 day`. Schedules fire on local wall-clock\n * boundaries (5m fires at :00, :05, ...), so only intervals that divide the\n * hour (minutes) or the day (hours) give a stable cadence; anything else is\n * rejected with the nearest valid suggestion instead of silently drifting.\n */\n\nconst SECOND_MS = 1_000;\nconst MINUTE_MS = 60 * SECOND_MS;\nconst HOUR_MS = 60 * MINUTE_MS;\nconst DAY_MS = 24 * HOUR_MS;\n\nexport type ParsedInterval = { ms: number; label: string };\nexport type IntervalError = { error: string };\n\nconst UNIT_MS: Record<string, { ms: number; short: string }> = {\n  s: { ms: SECOND_MS, short: 's' },\n  sec: { ms: SECOND_MS, short: 's' },\n  secs: { ms: SECOND_MS, short: 's' },\n  second: { ms: SECOND_MS, short: 's' },\n  seconds: { ms: SECOND_MS, short: 's' },\n  m: { ms: MINUTE_MS, short: 'm' },\n  min: { ms: MINUTE_MS, short: 'm' },\n  mins: { ms: MINUTE_MS, short: 'm' },\n  minute: { ms: MINUTE_MS, short: 'm' },\n  minutes: { ms: MINUTE_MS, short: 'm' },\n  h: { ms: HOUR_MS, short: 'h' },\n  hr: { ms: HOUR_MS, short: 'h' },\n  hrs: { ms: HOUR_MS, short: 'h' },\n  hour: { ms: HOUR_MS, short: 'h' },\n  hours: { ms: HOUR_MS, short: 'h' },\n  d: { ms: DAY_MS, short: 'd' },\n  day: { ms: DAY_MS, short: 'd' },\n  days: { ms: DAY_MS, short: 'd' },\n};\n\nconst INTERVAL_RE = /^(\\d+)\\s*([a-z]+)$/i;\n\n/** Parse `5m`, `2h`, `1 day`, `90 minutes` into milliseconds plus a normalized label. */\nexport function parseInterval(text: string): ParsedInterval | IntervalError {\n  const match = INTERVAL_RE.exec(text.trim());\n  if (!match) {\n    return { error: `Invalid interval \"${text}\". Use a number followed by a unit, e.g. 5m, 2h, 1d.` };\n  }\n  const value = Number(match[1]);\n  const unit = UNIT_MS[match[2]!.toLowerCase()];\n  if (!unit) {\n    return { error: `Unknown interval unit \"${match[2]}\". Use s, m, h, or d.` };\n  }\n  if (value <= 0) {\n    return { error: 'Interval must be greater than zero.' };\n  }\n  return { ms: value * unit.ms, label: `${value}${unit.short}` };\n}\n\nexport type IntervalCheck = { ok: true } | { error: string; suggestion?: string };\n\nconst MINUTE_DIVISORS = [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60];\nconst HOUR_DIVISORS = [1, 2, 3, 4, 6, 8, 12, 24];\n\nfunction nearest(candidates: number[], target: number): number {\n  return candidates.reduce((best, candidate) =>\n    Math.abs(candidate - target) < Math.abs(best - target) ? candidate : best,\n  );\n}\n\n/**\n * Check that an interval fires on stable clock boundaries: whole minutes that\n * divide the hour, whole hours that divide the day, or exactly one day.\n */\nexport function validateInterval({ ms }: { ms: number }): IntervalCheck {\n  if (ms < MINUTE_MS) {\n    return { error: 'Schedules fire at most once per minute.', suggestion: '1m' };\n  }\n  if (ms % MINUTE_MS !== 0) {\n    const minutes = Math.round(ms / MINUTE_MS);\n    return {\n      error: 'Interval must be a whole number of minutes.',\n      suggestion: `${Math.max(1, nearest(MINUTE_DIVISORS, minutes))}m`,\n    };\n  }\n  const minutes = ms / MINUTE_MS;\n  if (minutes < 60) {\n    if (60 % minutes === 0) {\n      return { ok: true };\n    }\n    return {\n      error: `${minutes}m does not divide an hour evenly.`,\n      suggestion: `${nearest(MINUTE_DIVISORS, minutes)}m`,\n    };\n  }\n  if (minutes % 60 !== 0) {\n    const hours = Math.round(minutes / 60);\n    return {\n      error: `${minutes}m is not a whole number of hours.`,\n      suggestion: hours < 24 ? `${nearest(HOUR_DIVISORS, hours)}h` : '1d',\n    };\n  }\n  const hours = minutes / 60;\n  if (hours < 24) {\n    if (24 % hours === 0) {\n      return { ok: true };\n    }\n    return {\n      error: `${hours}h does not divide a day evenly.`,\n      suggestion: `${nearest(HOUR_DIVISORS, hours)}h`,\n    };\n  }\n  if (hours === 24) {\n    return { ok: true };\n  }\n  return {\n    error: 'Intervals longer than one day are not supported.',\n    suggestion: '1d',\n  };\n}\n\n/** Hour-and-longer cadences: which local wall-clock slot a minute belongs to. */\nfunction hourSlotKey(date: Date, stepHours: number): number {\n  return (\n    ((date.getFullYear() * 12 + date.getMonth()) * 31 + date.getDate()) * 24 +\n    Math.floor(date.getHours() / stepHours) * stepHours\n  );\n}\n\n/**\n * The first boundary strictly after `after`, on the local wall clock\n * (5m → :00, :05, ...; 2h → 00:00, 02:00, ...; 1d → midnight). `intervalMs`\n * must pass {@link validateInterval}.\n *\n * Around daylight-saving changes this behaves like cron:\n * - Sub-hour cadences follow the minute hand, so they keep firing every N real\n *   minutes through both the skipped and the repeated hour. Across a\n *   half-hour change, the gap between fires never exceeds the interval.\n * - Hourly and daily cadences fire once per wall-clock slot. A boundary that\n *   falls in a skipped hour fires at the first minute after the jump (02:00 →\n *   03:00), and a repeated hour does not fire a second time.\n *\n * Computing from `after` rather than from the previous fire means a late\n * timer (sleep, busy event loop) skips missed boundaries instead of bursting\n * to catch up.\n */\nexport function nextFireTime(intervalMs: number, after: number): number {\n  // Truncate in UTC: local setters resolve a repeated hour to its first occurrence.\n  const cursor = new Date(Math.floor(after / MINUTE_MS) * MINUTE_MS);\n  const stepMinutes = intervalMs / MINUTE_MS;\n  // Walk minute by minute: at most an hour for sub-hour cadences, ~a day otherwise.\n  if (stepMinutes < 60) {\n    // Never wait longer than one interval: a half-hour clock change (Lord Howe\n    // Island) can otherwise shift the minute hand past the next boundary.\n    const latest = cursor.getTime() + intervalMs;\n    do cursor.setTime(cursor.getTime() + MINUTE_MS);\n    while (cursor.getMinutes() % stepMinutes !== 0 && cursor.getTime() < latest);\n    return cursor.getTime();\n  }\n  const stepHours = stepMinutes / 60;\n  const startSlot = hourSlotKey(new Date(after), stepHours);\n  do cursor.setTime(cursor.getTime() + MINUTE_MS);\n  while (hourSlotKey(cursor, stepHours) <= startSlot);\n  return cursor.getTime();\n}\n"],"mappings":"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"}

package/dist/schedules/prompt.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Fire-time prompt assembly for Mastra Code schedules.
+ *
+ * File-backed schedules only hold a descriptor; each fire runs the script or
+ * re-reads the file so the model always sees current output. Failures become
+ * the prompt text rather than a skipped fire — a schedule that silently stops
+ * delivering is worse than one that reports "the script broke".
+ */
+import type { ThreadSchedule } from './scheduler.js';
+export declare const SCRIPT_TIMEOUT_MS = 60000;
+export type ScriptResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+};
+export type RunScript = (absPath: string, options: {
+    cwd: string;
+    timeoutMs: number;
+}) => Promise<ScriptResult>;
+/**
+ * One fire's prompt. `outcome` summarizes a file-backed fire for the
+ * transcript header: `exit 0`, `exit 3`, `killed` (timeout/signal), or
+ * `failed` (the file could not be run or read).
+ */
+export type AssembledPrompt = {
+    prompt: string;
+    outcome?: string;
+};
+export type AssemblePromptOptions = {
+    cwd: string;
+    runScript: RunScript;
+    readFile: (absPath: string) => Promise<string>;
+};
+export declare function formatScriptOutput(displayPath: string, result: ScriptResult): string;
+export declare function assembleSchedulePrompt(spec: Pick<ThreadSchedule, 'prompt' | 'file' | 'extraPrompt'>, options: AssemblePromptOptions): Promise<AssembledPrompt>;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/schedules/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/schedules/prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,eAAO,MAAM,iBAAiB,QAAS,CAAC;AAExC,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAEvF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAEhH;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,MAAM,MAAM,qBAAqB,GAAG;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAChD,CAAC;AAMF,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAMpF;AAMD,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,QAAQ,GAAG,MAAM,GAAG,aAAa,CAAC,EAC7D,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CAmB1B"}

package/dist/schedules/prompt.js

@@ -0,0 +1,39 @@
+//#region src/schedules/prompt.ts
+const SCRIPT_TIMEOUT_MS = 6e4;
+function appendExtra(text, extra) {
+	return extra ? `${text}\n\n${extra}` : text;
+}
+function formatScriptOutput(displayPath, result) {
+	const body = [result.stdout, result.stderr].map((part) => part.trimEnd()).filter(Boolean).join("\n");
+	return `Output of ${displayPath} (exit ${result.exitCode ?? "null"}):\n${body || "(no output)"}`;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function assembleSchedulePrompt(spec, options) {
+	const { file } = spec;
+	if (!file) return { prompt: spec.prompt ?? "" };
+	let text;
+	let outcome;
+	try {
+		if (file.mode === "script") {
+			const result = await options.runScript(file.path, {
+				cwd: options.cwd,
+				timeoutMs: SCRIPT_TIMEOUT_MS
+			});
+			text = formatScriptOutput(file.displayPath, result);
+			outcome = result.exitCode === null ? "killed" : `exit ${result.exitCode}`;
+		} else text = (await options.readFile(file.path)).trim();
+	} catch (error) {
+		text = `Schedule ${file.displayPath} failed: ${errorMessage(error)}`;
+		outcome = "failed";
+	}
+	return {
+		prompt: appendExtra(text, spec.extraPrompt),
+		...outcome ? { outcome } : {}
+	};
+}
+//#endregion
+export { SCRIPT_TIMEOUT_MS, assembleSchedulePrompt, formatScriptOutput };
+
+//# sourceMappingURL=prompt.js.map

package/dist/schedules/prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.js","names":[],"sources":["../../src/schedules/prompt.ts"],"sourcesContent":["/**\n * Fire-time prompt assembly for Mastra Code schedules.\n *\n * File-backed schedules only hold a descriptor; each fire runs the script or\n * re-reads the file so the model always sees current output. Failures become\n * the prompt text rather than a skipped fire — a schedule that silently stops\n * delivering is worse than one that reports \"the script broke\".\n */\nimport type { ThreadSchedule } from './scheduler.js';\n\nexport const SCRIPT_TIMEOUT_MS = 60_000;\n\nexport type ScriptResult = { stdout: string; stderr: string; exitCode: number | null };\n\nexport type RunScript = (absPath: string, options: { cwd: string; timeoutMs: number }) => Promise<ScriptResult>;\n\n/**\n * One fire's prompt. `outcome` summarizes a file-backed fire for the\n * transcript header: `exit 0`, `exit 3`, `killed` (timeout/signal), or\n * `failed` (the file could not be run or read).\n */\nexport type AssembledPrompt = { prompt: string; outcome?: string };\n\nexport type AssemblePromptOptions = {\n  cwd: string;\n  runScript: RunScript;\n  readFile: (absPath: string) => Promise<string>;\n};\n\nfunction appendExtra(text: string, extra: string | undefined): string {\n  return extra ? `${text}\\n\\n${extra}` : text;\n}\n\nexport function formatScriptOutput(displayPath: string, result: ScriptResult): string {\n  const body = [result.stdout, result.stderr]\n    .map(part => part.trimEnd())\n    .filter(Boolean)\n    .join('\\n');\n  return `Output of ${displayPath} (exit ${result.exitCode ?? 'null'}):\\n${body || '(no output)'}`;\n}\n\nfunction errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nexport async function assembleSchedulePrompt(\n  spec: Pick<ThreadSchedule, 'prompt' | 'file' | 'extraPrompt'>,\n  options: AssemblePromptOptions,\n): Promise<AssembledPrompt> {\n  const { file } = spec;\n  if (!file) return { prompt: spec.prompt ?? '' };\n\n  let text: string;\n  let outcome: string | undefined;\n  try {\n    if (file.mode === 'script') {\n      const result = await options.runScript(file.path, { cwd: options.cwd, timeoutMs: SCRIPT_TIMEOUT_MS });\n      text = formatScriptOutput(file.displayPath, result);\n      outcome = result.exitCode === null ? 'killed' : `exit ${result.exitCode}`;\n    } else {\n      text = (await options.readFile(file.path)).trim();\n    }\n  } catch (error) {\n    text = `Schedule ${file.displayPath} failed: ${errorMessage(error)}`;\n    outcome = 'failed';\n  }\n  return { prompt: appendExtra(text, spec.extraPrompt), ...(outcome ? { outcome } : {}) };\n}\n"],"mappings":";AAUA,MAAa,oBAAoB;AAmBjC,SAAS,YAAY,MAAc,OAAmC;CACpE,OAAO,QAAQ,GAAG,KAAK,MAAM,UAAU;AACzC;AAEA,SAAgB,mBAAmB,aAAqB,QAA8B;CACpF,MAAM,OAAO,CAAC,OAAO,QAAQ,OAAO,MAAM,CAAC,CACxC,KAAI,SAAQ,KAAK,QAAQ,CAAC,CAAC,CAC3B,OAAO,OAAO,CAAC,CACf,KAAK,IAAI;CACZ,OAAO,aAAa,YAAY,SAAS,OAAO,YAAY,OAAO,MAAM,QAAQ;AACnF;AAEA,SAAS,aAAa,OAAwB;CAC5C,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEA,eAAsB,uBACpB,MACA,SAC0B;CAC1B,MAAM,EAAE,SAAS;CACjB,IAAI,CAAC,MAAM,OAAO,EAAE,QAAQ,KAAK,UAAU,GAAG;CAE9C,IAAI;CACJ,IAAI;CACJ,IAAI;EACF,IAAI,KAAK,SAAS,UAAU;GAC1B,MAAM,SAAS,MAAM,QAAQ,UAAU,KAAK,MAAM;IAAE,KAAK,QAAQ;IAAK,WAAW;GAAkB,CAAC;GACpG,OAAO,mBAAmB,KAAK,aAAa,MAAM;GAClD,UAAU,OAAO,aAAa,OAAO,WAAW,QAAQ,OAAO;EACjE,OACE,QAAQ,MAAM,QAAQ,SAAS,KAAK,IAAI,EAAA,CAAG,KAAK;CAEpD,SAAS,OAAO;EACd,OAAO,YAAY,KAAK,YAAY,WAAW,aAAa,KAAK;EACjE,UAAU;CACZ;CACA,OAAO;EAAE,QAAQ,YAAY,MAAM,KAAK,WAAW;EAAG,GAAI,UAAU,EAAE,QAAQ,IAAI,CAAC;CAAG;AACxF"}

package/dist/schedules/run-script.d.ts

@@ -0,0 +1,8 @@
+import type { RunScript } from './prompt.js';
+export declare function isExecutableFile(absPath: string): boolean;
+export declare function resolveScriptCommand(absPath: string): {
+    command: string;
+    args: string[];
+};
+export declare const runScript: RunScript;
+//# sourceMappingURL=run-script.d.ts.map

package/dist/schedules/run-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-script.d.ts","sourceRoot":"","sources":["../../src/schedules/run-script.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,aAAa,CAAC;AAc3D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOzD;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAOzF;AAED,eAAO,MAAM,SAAS,EAAE,SAyBvB,CAAC"}

package/dist/schedules/run-script.js

@@ -0,0 +1,83 @@
+import * as path$1 from "path";
+import { execFile } from "child_process";
+import * as fs$1 from "fs";
+//#region src/schedules/run-script.ts
+/**
+* Runs a schedule's script file at fire time.
+*
+* The file path is always passed as the literal command (or as the single
+* argument to a fixed interpreter) — never through a shell string — so the
+* user's extra prompt can never be interpolated into a command line.
+*/
+/** Interpreter for scripts that lack an executable bit, keyed by extension. */
+const INTERPRETERS = {
+	".sh": () => "/bin/sh",
+	".js": () => process.execPath,
+	".mjs": () => process.execPath,
+	".cjs": () => process.execPath,
+	".ts": () => process.execPath,
+	".py": () => "python3"
+};
+const MAX_OUTPUT_BYTES = 1024 * 1024;
+function isExecutableFile(absPath) {
+	try {
+		fs$1.accessSync(absPath, fs$1.constants.X_OK);
+		return fs$1.statSync(absPath).isFile();
+	} catch {
+		return false;
+	}
+}
+function resolveScriptCommand(absPath) {
+	if (isExecutableFile(absPath)) return {
+		command: absPath,
+		args: []
+	};
+	const interpreter = INTERPRETERS[path$1.extname(absPath).toLowerCase()];
+	if (!interpreter) throw new Error(`${absPath} is not executable and has no known interpreter`);
+	return {
+		command: interpreter(),
+		args: [absPath]
+	};
+}
+const runScript = async (absPath, { cwd, timeoutMs }) => {
+	const { command, args } = resolveScriptCommand(absPath);
+	return new Promise((resolve, reject) => {
+		execFile(command, args, {
+			cwd,
+			timeout: timeoutMs,
+			maxBuffer: MAX_OUTPUT_BYTES,
+			windowsHide: true
+		}, (error, stdout, stderr) => {
+			if (!error) {
+				resolve({
+					stdout,
+					stderr,
+					exitCode: 0
+				});
+				return;
+			}
+			const spawnError = error;
+			if (typeof spawnError.code === "number") {
+				resolve({
+					stdout,
+					stderr,
+					exitCode: spawnError.code
+				});
+				return;
+			}
+			if (spawnError.killed) {
+				resolve({
+					stdout,
+					stderr: `${stderr}\n[timed out after ${timeoutMs}ms]`.trim(),
+					exitCode: null
+				});
+				return;
+			}
+			reject(error);
+		});
+	});
+};
+//#endregion
+export { isExecutableFile, resolveScriptCommand, runScript };
+
+//# sourceMappingURL=run-script.js.map

package/dist/schedules/run-script.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-script.js","names":["fs","path"],"sources":["../../src/schedules/run-script.ts"],"sourcesContent":["/**\n * Runs a schedule's script file at fire time.\n *\n * The file path is always passed as the literal command (or as the single\n * argument to a fixed interpreter) — never through a shell string — so the\n * user's extra prompt can never be interpolated into a command line.\n */\nimport { execFile } from 'node:child_process';\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport type { RunScript, ScriptResult } from './prompt.js';\n\n/** Interpreter for scripts that lack an executable bit, keyed by extension. */\nconst INTERPRETERS: Record<string, () => string> = {\n  '.sh': () => '/bin/sh',\n  '.js': () => process.execPath,\n  '.mjs': () => process.execPath,\n  '.cjs': () => process.execPath,\n  '.ts': () => process.execPath,\n  '.py': () => 'python3',\n};\n\nconst MAX_OUTPUT_BYTES = 1024 * 1024;\n\nexport function isExecutableFile(absPath: string): boolean {\n  try {\n    fs.accessSync(absPath, fs.constants.X_OK);\n    return fs.statSync(absPath).isFile();\n  } catch {\n    return false;\n  }\n}\n\nexport function resolveScriptCommand(absPath: string): { command: string; args: string[] } {\n  if (isExecutableFile(absPath)) return { command: absPath, args: [] };\n  const interpreter = INTERPRETERS[path.extname(absPath).toLowerCase()];\n  if (!interpreter) {\n    throw new Error(`${absPath} is not executable and has no known interpreter`);\n  }\n  return { command: interpreter(), args: [absPath] };\n}\n\nexport const runScript: RunScript = async (absPath, { cwd, timeoutMs }) => {\n  const { command, args } = resolveScriptCommand(absPath);\n  return new Promise<ScriptResult>((resolve, reject) => {\n    execFile(\n      command,\n      args,\n      { cwd, timeout: timeoutMs, maxBuffer: MAX_OUTPUT_BYTES, windowsHide: true },\n      (error, stdout, stderr) => {\n        if (!error) {\n          resolve({ stdout, stderr, exitCode: 0 });\n          return;\n        }\n        const spawnError = error as NodeJS.ErrnoException & { code?: number | string; killed?: boolean };\n        if (typeof spawnError.code === 'number') {\n          resolve({ stdout, stderr, exitCode: spawnError.code });\n          return;\n        }\n        if (spawnError.killed) {\n          resolve({ stdout, stderr: `${stderr}\\n[timed out after ${timeoutMs}ms]`.trim(), exitCode: null });\n          return;\n        }\n        reject(error);\n      },\n    );\n  });\n};\n"],"mappings":";;;;;;;;;;;;AAaA,MAAM,eAA6C;CACjD,aAAa;CACb,aAAa,QAAQ;CACrB,cAAc,QAAQ;CACtB,cAAc,QAAQ;CACtB,aAAa,QAAQ;CACrB,aAAa;AACf;AAEA,MAAM,mBAAmB,OAAO;AAEhC,SAAgB,iBAAiB,SAA0B;CACzD,IAAI;EACF,KAAG,WAAW,SAASA,KAAG,UAAU,IAAI;EACxC,OAAOA,KAAG,SAAS,OAAO,CAAC,CAAC,OAAO;CACrC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAgB,qBAAqB,SAAsD;CACzF,IAAI,iBAAiB,OAAO,GAAG,OAAO;EAAE,SAAS;EAAS,MAAM,CAAC;CAAE;CACnE,MAAM,cAAc,aAAaC,OAAK,QAAQ,OAAO,CAAC,CAAC,YAAY;CACnE,IAAI,CAAC,aACH,MAAM,IAAI,MAAM,GAAG,QAAQ,gDAAgD;CAE7E,OAAO;EAAE,SAAS,YAAY;EAAG,MAAM,CAAC,OAAO;CAAE;AACnD;AAEA,MAAa,YAAuB,OAAO,SAAS,EAAE,KAAK,gBAAgB;CACzE,MAAM,EAAE,SAAS,SAAS,qBAAqB,OAAO;CACtD,OAAO,IAAI,SAAuB,SAAS,WAAW;EACpD,SACE,SACA,MACA;GAAE;GAAK,SAAS;GAAW,WAAW;GAAkB,aAAa;EAAK,IACzE,OAAO,QAAQ,WAAW;GACzB,IAAI,CAAC,OAAO;IACV,QAAQ;KAAE;KAAQ;KAAQ,UAAU;IAAE,CAAC;IACvC;GACF;GACA,MAAM,aAAa;GACnB,IAAI,OAAO,WAAW,SAAS,UAAU;IACvC,QAAQ;KAAE;KAAQ;KAAQ,UAAU,WAAW;IAAK,CAAC;IACrD;GACF;GACA,IAAI,WAAW,QAAQ;IACrB,QAAQ;KAAE;KAAQ,QAAQ,GAAG,OAAO,qBAAqB,UAAU,KAAK,KAAK;KAAG,UAAU;IAAK,CAAC;IAChG;GACF;GACA,OAAO,KAAK;EACd,CACF;CACF,CAAC;AACH"}

package/dist/schedules/scheduler.d.ts

@@ -0,0 +1,101 @@
+import type { ParsedInterval } from './interval.js';
+import type { AssembledPrompt } from './prompt.js';
+/** `source` attribute on fired signals; the TUI labels these turns `schedule`. */
+export declare const SCHEDULE_SIGNAL_SOURCE = "schedule";
+/** When a schedule fires. Only recurring `every` triggers exist today. */
+export type ScheduleTrigger = {
+    kind: 'every';
+    interval: ParsedInterval;
+};
+/** A file a schedule runs as a script, or re-reads and sends as the prompt, on every fire. */
+export type ScheduleFile = {
+    path: string;
+    displayPath: string;
+    mode: 'script' | 'prompt';
+};
+/** What to send on each fire: `prompt` text, or a `file` (plus `extraPrompt` appended after it). */
+export type ThreadScheduleSource = {
+    prompt: string;
+} | {
+    file: ScheduleFile;
+    extraPrompt?: string;
+};
+export type ThreadScheduleSpec = ThreadScheduleSource & {
+    trigger: ScheduleTrigger;
+    /** Who is creating it: the user via `/schedules`, or the agent via its schedule tools. Defaults to `user`. */
+    createdBy?: 'user' | 'agent';
+};
+export type ThreadSchedule = {
+    id: string;
+    threadId: string;
+    resourceId: string;
+    trigger: ScheduleTrigger;
+    prompt?: string;
+    file?: ScheduleFile;
+    extraPrompt?: string;
+    createdBy: 'user' | 'agent';
+    status: 'active' | 'paused';
+    /** Next boundary this schedule fires at; only meaningful while active. */
+    nextFireAt: number;
+    createdAt: number;
+};
+export type ThreadSchedulerOptions = {
+    /** Build the prompt for one fire (runs scripts / reads files). */
+    assemblePrompt: (schedule: ThreadSchedule) => Promise<AssembledPrompt>;
+    /** Hand the prompt to the agent for the schedule's thread. */
+    deliver: (schedule: ThreadSchedule, assembled: AssembledPrompt) => Promise<void>;
+    /** A fire failed before reaching the agent. */
+    onError?: (error: unknown, schedule: ThreadSchedule) => void;
+    now?: () => number;
+};
+/** How late a timer may run before its fire counts as missed (sleep, stalled event loop). */
+export declare const LATE_FIRE_GRACE_MS = 60000;
+/**
+ * Outcome of a manual `run()`. `failed` means nothing reached the agent: the
+ * prompt could not be built or the agent refused it.
+ */
+export type ScheduleRunResult = {
+    status: 'fired';
+} | {
+    status: 'failed';
+    error: unknown;
+} | {
+    status: 'busy';
+} | {
+    status: 'not-found';
+};
+export declare class ThreadScheduler {
+    #private;
+    constructor(options: ThreadSchedulerOptions);
+    /** Throws when the interval is not a supported wall-clock cadence (see `validateInterval`) or the prompt is empty. */
+    create(spec: ThreadScheduleSpec, target: {
+        threadId: string;
+        resourceId: string;
+    }): ThreadSchedule;
+    list(filter?: {
+        threadId?: string;
+    }): ThreadSchedule[];
+    delete(id: string): boolean;
+    pause(id: string): boolean;
+    resume(id: string): boolean;
+    /** Whether a fire of this schedule (timer or manual) is still assembling or delivering. */
+    isFiring(id: string): boolean;
+    /**
+     * Fire once now, outside the cadence. Returns `busy` without firing when a
+     * fire of this schedule is still running (a slow script, say), so the same
+     * script never runs twice at once. Resolves once the fire finished; a fire
+     * that never reached the agent resolves `failed` instead of calling `onError`.
+     */
+    run(id: string): Promise<ScheduleRunResult>;
+    /** Drop every schedule and timer (process shutdown). */
+    stop(): void;
+}
+export declare function shortScheduleId(id: string): string;
+/** One-line human summary of what a schedule sends: `run ./check.sh + "extra"`, `read notes.md`, `"prompt"`. */
+export declare function describeScheduleSource(schedule: Pick<ThreadSchedule, 'prompt' | 'file' | 'extraPrompt'>): string;
+/**
+ * Attributes on a fired schedule signal. They carry everything the transcript
+ * header needs, so reloaded history renders without the process-local entry.
+ */
+export declare function scheduleSignalAttributes(schedule: ThreadSchedule, assembled?: Pick<AssembledPrompt, 'outcome'>): Record<string, string>;
+//# sourceMappingURL=scheduler.d.ts.map