@mastra/code-sdk 0.0.0-aggregate-trace-20261015182851

package/dist/utils/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/utils/errors.ts"],"sourcesContent":["/**\n * Error handling utilities for the Mastra Code TUI.\n * Parses API errors and provides user-friendly messages.\n */\n\nimport { PROVIDER_AUTH_REQUIRED_ERROR } from '../auth/provider-auth-error.js';\n\nexport interface ParsedError {\n  /** User-friendly error message */\n  message: string;\n  /** Extra diagnostic detail to surface to the user */\n  detail?: string;\n  /** Request URL involved in the failure, when available */\n  requestUrl?: string;\n  /** Error type for categorization */\n  type: ErrorType;\n  /** Whether this error is retryable */\n  retryable: boolean;\n  /** Suggested retry delay in ms (if retryable) */\n  retryDelay?: number;\n  /** Original error for debugging */\n  originalError: Error;\n}\n\nexport type ErrorType =\n  | 'rate_limit'\n  | 'auth'\n  | 'network'\n  | 'timeout'\n  | 'invalid_request'\n  | 'server_error'\n  | 'model_not_found'\n  | 'context_length'\n  | 'content_filter'\n  | 'unknown';\n\n/**\n * Parse an error and return a user-friendly representation.\n */\nfunction summarizeErrorDetail(error: unknown): string | undefined {\n  if (error instanceof Error) {\n    if (error.cause instanceof Error && error.cause.message) {\n      return error.cause.message;\n    }\n\n    if (typeof error.cause === 'string' && error.cause.trim().length > 0) {\n      return error.cause;\n    }\n\n    if (error.message.trim().length > 0) {\n      return error.message;\n    }\n  }\n\n  if (typeof error === 'string' && error.trim().length > 0) {\n    return error;\n  }\n\n  if (error && typeof error === 'object') {\n    const errorObj = error as Record<string, unknown>;\n    const candidates = [errorObj['message'], errorObj['cause'], errorObj['code'], errorObj['statusText']];\n\n    for (const candidate of candidates) {\n      if (typeof candidate === 'string' && candidate.trim().length > 0) {\n        return candidate;\n      }\n    }\n  }\n\n  return undefined;\n}\n\nfunction extractRequestUrl(error: unknown): string | undefined {\n  if (!error || typeof error !== 'object') {\n    return undefined;\n  }\n\n  const candidates: unknown[] = [];\n  const errorObj = error as Record<string, unknown>;\n  candidates.push(errorObj['requestUrl'], errorObj['url']);\n\n  if (errorObj['cause'] && typeof errorObj['cause'] === 'object') {\n    const causeObj = errorObj['cause'] as Record<string, unknown>;\n    candidates.push(causeObj['requestUrl'], causeObj['url']);\n  }\n\n  for (const candidate of candidates) {\n    if (typeof candidate === 'string' && candidate.trim().length > 0) {\n      return candidate;\n    }\n  }\n\n  return undefined;\n}\n\n/** A flattened error crossing the wire: the server sends `{ name, message }`, not an `Error`. */\nfunction isSerializedError(value: unknown): value is { name: string; message: string } {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'name' in value &&\n    typeof value.name === 'string' &&\n    'message' in value &&\n    typeof value.message === 'string'\n  );\n}\n\nfunction toError(error: unknown): Error {\n  if (error instanceof Error) return error;\n  if (!isSerializedError(error)) return new Error(String(error));\n  const rebuilt = new Error(error.message);\n  rebuilt.name = error.name;\n  return rebuilt;\n}\n\nexport function parseError(error: unknown): ParsedError {\n  const err = toError(error);\n  const message = err.message.toLowerCase();\n  const errorObj = error as Record<string, unknown>;\n  const detail = summarizeErrorDetail(error);\n  const requestUrl = extractRequestUrl(error);\n\n  // Matched by name, not instance: the error may have crossed a serialization boundary.\n  if (err.name === PROVIDER_AUTH_REQUIRED_ERROR) {\n    return { message: err.message, detail, requestUrl, type: 'auth', retryable: false, originalError: err };\n  }\n\n  // Check for rate limiting\n  if (\n    message.includes('rate limit') ||\n    message.includes('rate_limit') ||\n    message.includes('429') ||\n    errorObj.statusCode === 429 ||\n    errorObj.status === 429\n  ) {\n    const retryAfter = extractRetryAfter(errorObj);\n    return {\n      message: 'Rate limited. Please wait a moment before trying again.',\n      type: 'rate_limit',\n      retryable: true,\n      retryDelay: retryAfter || 5000,\n      originalError: err,\n    };\n  }\n\n  // Check for authentication errors\n  if (\n    message.includes('unauthorized') ||\n    message.includes('authentication') ||\n    message.includes('invalid api key') ||\n    message.includes('invalid_api_key') ||\n    message.includes('api key') ||\n    errorObj.statusCode === 401 ||\n    errorObj.status === 401\n  ) {\n    return {\n      message: 'Authentication failed. Check the credential configured for this provider.',\n      detail,\n      requestUrl,\n      type: 'auth',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for forbidden/permission errors\n  if (errorObj.statusCode === 403 || errorObj.status === 403) {\n    return {\n      message: 'Access denied. You may not have permission to use this model.',\n      detail,\n      requestUrl,\n      type: 'auth',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for network errors\n  if (\n    message.includes('network') ||\n    message.includes('econnrefused') ||\n    message.includes('enotfound') ||\n    message.includes('fetch failed') ||\n    message.includes('connection')\n  ) {\n    return {\n      message: 'Network error while contacting the provider or gateway.',\n      detail,\n      requestUrl,\n      type: 'network',\n      retryable: true,\n      retryDelay: 2000,\n      originalError: err,\n    };\n  }\n\n  // Check for timeout errors\n  if (message.includes('timeout') || message.includes('timed out') || message.includes('etimedout')) {\n    return {\n      message: 'Request timed out. The server may be overloaded.',\n      type: 'timeout',\n      retryable: true,\n      retryDelay: 3000,\n      originalError: err,\n    };\n  }\n\n  // Check for model not found\n  if (\n    message.includes('model not found') ||\n    message.includes('model_not_found') ||\n    message.includes('does not exist') ||\n    message.includes('invalid model')\n  ) {\n    return {\n      message: 'Model not found. Please select a different model with /models.',\n      type: 'model_not_found',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for context length errors\n  if (\n    message.includes('context length') ||\n    message.includes('context_length') ||\n    message.includes('too many tokens') ||\n    message.includes('maximum context') ||\n    message.includes('token limit')\n  ) {\n    return {\n      message: 'Message too long. Try starting a new thread with /new.',\n      type: 'context_length',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for content filter errors\n  if (\n    message.includes('content filter') ||\n    message.includes('content_filter') ||\n    message.includes('content policy') ||\n    message.includes('safety') ||\n    message.includes('prohibited')\n  ) {\n    return {\n      message: \"Content was filtered by the model's safety system.\",\n      type: 'content_filter',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for server errors\n  if (\n    message.includes('internal server') ||\n    message.includes('server error') ||\n    errorObj.statusCode === 500 ||\n    errorObj.status === 500 ||\n    errorObj.statusCode === 502 ||\n    errorObj.status === 502 ||\n    errorObj.statusCode === 503 ||\n    errorObj.status === 503\n  ) {\n    return {\n      message: 'Server error. The API may be experiencing issues.',\n      type: 'server_error',\n      retryable: true,\n      retryDelay: 5000,\n      originalError: err,\n    };\n  }\n\n  // Check for invalid request errors\n  if (\n    message.includes('invalid request') ||\n    message.includes('bad request') ||\n    errorObj.statusCode === 400 ||\n    errorObj.status === 400\n  ) {\n    return {\n      message: `Invalid request: ${extractErrorDetail(err)}`,\n      type: 'invalid_request',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Unknown error - try to extract useful info\n  return {\n    message: extractErrorDetail(err),\n    type: 'unknown',\n    retryable: false,\n    originalError: err,\n  };\n}\n\n/**\n * Extract retry-after header value from error.\n */\nfunction extractRetryAfter(error: Record<string, unknown>): number | undefined {\n  const headers = error.headers as Record<string, unknown> | undefined;\n  const retryAfter = error.retryAfter || headers?.['retry-after'];\n  if (typeof retryAfter === 'number') {\n    return retryAfter * 1000; // Convert seconds to ms\n  }\n  if (typeof retryAfter === 'string') {\n    const seconds = parseInt(retryAfter, 10);\n    if (!isNaN(seconds)) {\n      return seconds * 1000;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Extract a useful error detail from an error object.\n */\nfunction extractErrorDetail(error: Error): string {\n  const errorObj = error as unknown as Record<string, unknown>;\n\n  // Try to get a specific error message from common API error formats\n  if (errorObj.error && typeof errorObj.error === 'object') {\n    const apiError = errorObj.error as Record<string, unknown>;\n    if (apiError.message) return String(apiError.message);\n  }\n\n  if (errorObj.message) return String(errorObj.message);\n  if (errorObj.detail) return String(errorObj.detail);\n  if (errorObj.reason) return String(errorObj.reason);\n\n  // Clean up the error message\n  let message = error.message;\n\n  // Remove common prefixes\n  message = message.replace(/^(error|exception|failed):\\s*/i, '');\n\n  // Truncate very long messages\n  if (message.length > 200) {\n    message = message.substring(0, 200) + '...';\n  }\n\n  return message || 'An unknown error occurred';\n}\n\n/**\n * Sleep for a given number of milliseconds.\n */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * Retry a function with exponential backoff.\n */\nexport async function withRetry<T>(\n  fn: () => Promise<T>,\n  options: {\n    maxRetries?: number;\n    initialDelay?: number;\n    maxDelay?: number;\n    onRetry?: (error: ParsedError, attempt: number) => void;\n  } = {},\n): Promise<T> {\n  const { maxRetries = 3, initialDelay = 1000, maxDelay = 30000, onRetry } = options;\n\n  let lastError: ParsedError | undefined;\n\n  for (let attempt = 0; attempt <= maxRetries; attempt++) {\n    try {\n      return await fn();\n    } catch (error) {\n      lastError = parseError(error);\n\n      // Don't retry non-retryable errors\n      if (!lastError.retryable || attempt === maxRetries) {\n        throw lastError.originalError;\n      }\n\n      // Calculate delay with exponential backoff\n      const delay = Math.min(lastError.retryDelay || initialDelay * Math.pow(2, attempt), maxDelay);\n\n      if (onRetry) {\n        onRetry(lastError, attempt + 1);\n      }\n\n      await sleep(delay);\n    }\n  }\n\n  // Should never reach here, but TypeScript needs this\n  throw lastError?.originalError || new Error('Retry failed');\n}\n"],"mappings":"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"}

package/dist/utils/gateway-sync.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gateway sync utility for keeping the model registry up to date.
+ *
+ * This is a thin wrapper around `@mastra/core/llm`'s `GatewayRegistry` so
+ * mastracode and `mastra dev` share a single implementation for fetching
+ * providers, generating types, and writing to the global cache. Keep this
+ * file small — provider/registry logic belongs in `@mastra/core`.
+ */
+/**
+ * Sync gateways and update the global cache via `@mastra/core`'s registry.
+ *
+ * Skips the sync if the global cache was refreshed within the last
+ * `DEFAULT_SYNC_INTERVAL_MS`, unless `force` is set. Multiple calls in
+ * the same process coalesce while a sync is in flight.
+ */
+export declare function syncGateways(force?: boolean): Promise<void>;
+/**
+ * Start periodic gateway sync.
+ * @param intervalMs Sync interval in milliseconds (default: 5 minutes)
+ */
+export declare function startGatewaySync(intervalMs?: number): void;
+/**
+ * Stop periodic gateway sync.
+ */
+export declare function stopGatewaySync(): void;
+//# sourceMappingURL=gateway-sync.d.ts.map

package/dist/utils/gateway-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-sync.d.ts","sourceRoot":"","sources":["../../src/utils/gateway-sync.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,KAAK,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB/D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,SAA2B,GAAG,IAAI,CAe5E;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAKtC"}

package/dist/utils/gateway-sync.js

@@ -0,0 +1,61 @@
+import { GatewayRegistry } from "@mastra/core/llm";
+//#region src/utils/gateway-sync.ts
+/**
+* Gateway sync utility for keeping the model registry up to date.
+*
+* This is a thin wrapper around `@mastra/core/llm`'s `GatewayRegistry` so
+* mastracode and `mastra dev` share a single implementation for fetching
+* providers, generating types, and writing to the global cache. Keep this
+* file small — provider/registry logic belongs in `@mastra/core`.
+*/
+const DEFAULT_SYNC_INTERVAL_MS = 300 * 1e3;
+let syncInterval = null;
+let isSyncing = false;
+function getRegistry() {
+	return GatewayRegistry.getInstance({ useDynamicLoading: true });
+}
+/**
+* Sync gateways and update the global cache via `@mastra/core`'s registry.
+*
+* Skips the sync if the global cache was refreshed within the last
+* `DEFAULT_SYNC_INTERVAL_MS`, unless `force` is set. Multiple calls in
+* the same process coalesce while a sync is in flight.
+*/
+async function syncGateways(force = false) {
+	if (isSyncing && !force) return;
+	if (!force) {
+		const lastSync = getRegistry().getLastRefreshTime();
+		if (lastSync && Date.now() - lastSync.getTime() < DEFAULT_SYNC_INTERVAL_MS) return;
+	}
+	isSyncing = true;
+	try {
+		await getRegistry().syncGateways(true);
+	} catch {} finally {
+		isSyncing = false;
+	}
+}
+/**
+* Start periodic gateway sync.
+* @param intervalMs Sync interval in milliseconds (default: 5 minutes)
+*/
+function startGatewaySync(intervalMs = DEFAULT_SYNC_INTERVAL_MS) {
+	if (syncInterval) return;
+	syncGateways().catch(() => {});
+	syncInterval = setInterval(() => {
+		syncGateways().catch(() => {});
+	}, intervalMs);
+	syncInterval.unref();
+}
+/**
+* Stop periodic gateway sync.
+*/
+function stopGatewaySync() {
+	if (syncInterval) {
+		clearInterval(syncInterval);
+		syncInterval = null;
+	}
+}
+//#endregion
+export { startGatewaySync, stopGatewaySync, syncGateways };
+
+//# sourceMappingURL=gateway-sync.js.map

package/dist/utils/gateway-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-sync.js","names":[],"sources":["../../src/utils/gateway-sync.ts"],"sourcesContent":["/**\n * Gateway sync utility for keeping the model registry up to date.\n *\n * This is a thin wrapper around `@mastra/core/llm`'s `GatewayRegistry` so\n * mastracode and `mastra dev` share a single implementation for fetching\n * providers, generating types, and writing to the global cache. Keep this\n * file small — provider/registry logic belongs in `@mastra/core`.\n */\n\nimport { GatewayRegistry } from '@mastra/core/llm';\n\nconst DEFAULT_SYNC_INTERVAL_MS = 5 * 60 * 1000;\n\nlet syncInterval: NodeJS.Timeout | null = null;\nlet isSyncing = false;\n\nfunction getRegistry(): GatewayRegistry {\n  return GatewayRegistry.getInstance({ useDynamicLoading: true });\n}\n\n/**\n * Sync gateways and update the global cache via `@mastra/core`'s registry.\n *\n * Skips the sync if the global cache was refreshed within the last\n * `DEFAULT_SYNC_INTERVAL_MS`, unless `force` is set. Multiple calls in\n * the same process coalesce while a sync is in flight.\n */\nexport async function syncGateways(force = false): Promise<void> {\n  if (isSyncing && !force) {\n    return;\n  }\n\n  if (!force) {\n    const lastSync = getRegistry().getLastRefreshTime();\n    if (lastSync && Date.now() - lastSync.getTime() < DEFAULT_SYNC_INTERVAL_MS) {\n      return;\n    }\n  }\n\n  isSyncing = true;\n  try {\n    await getRegistry().syncGateways(true);\n  } catch {\n    // Silently ignore — the bundled registry already contains all model\n    // data so a failed network fetch is non-critical.\n  } finally {\n    isSyncing = false;\n  }\n}\n\n/**\n * Start periodic gateway sync.\n * @param intervalMs Sync interval in milliseconds (default: 5 minutes)\n */\nexport function startGatewaySync(intervalMs = DEFAULT_SYNC_INTERVAL_MS): void {\n  if (syncInterval) {\n    return;\n  }\n\n  // Do an initial sync (will skip if recently synced)\n  syncGateways().catch(() => {});\n\n  // Set up periodic sync\n  syncInterval = setInterval(() => {\n    syncGateways().catch(() => {});\n  }, intervalMs);\n\n  // Don't prevent process exit\n  syncInterval.unref();\n}\n\n/**\n * Stop periodic gateway sync.\n */\nexport function stopGatewaySync(): void {\n  if (syncInterval) {\n    clearInterval(syncInterval);\n    syncInterval = null;\n  }\n}\n"],"mappings":";;;;;;;;;;AAWA,MAAM,2BAA2B,MAAS;AAE1C,IAAI,eAAsC;AAC1C,IAAI,YAAY;AAEhB,SAAS,cAA+B;CACtC,OAAO,gBAAgB,YAAY,EAAE,mBAAmB,KAAK,CAAC;AAChE;;;;;;;;AASA,eAAsB,aAAa,QAAQ,OAAsB;CAC/D,IAAI,aAAa,CAAC,OAChB;CAGF,IAAI,CAAC,OAAO;EACV,MAAM,WAAW,YAAY,CAAC,CAAC,mBAAmB;EAClD,IAAI,YAAY,KAAK,IAAI,IAAI,SAAS,QAAQ,IAAI,0BAChD;CAEJ;CAEA,YAAY;CACZ,IAAI;EACF,MAAM,YAAY,CAAC,CAAC,aAAa,IAAI;CACvC,QAAQ,CAGR,UAAU;EACR,YAAY;CACd;AACF;;;;;AAMA,SAAgB,iBAAiB,aAAa,0BAAgC;CAC5E,IAAI,cACF;CAIF,aAAa,CAAC,CAAC,YAAY,CAAC,CAAC;CAG7B,eAAe,kBAAkB;EAC/B,aAAa,CAAC,CAAC,YAAY,CAAC,CAAC;CAC/B,GAAG,UAAU;CAGb,aAAa,MAAM;AACrB;;;;AAKA,SAAgB,kBAAwB;CACtC,IAAI,cAAc;EAChB,cAAc,YAAY;EAC1B,eAAe;CACjB;AACF"}

package/dist/utils/maintenance-lock.d.ts

@@ -0,0 +1,42 @@
+export declare class MaintenanceLockError extends Error {
+    readonly ownerPids: number[];
+    constructor(message: string, ownerPids: number[]);
+}
+export declare function getMaintenanceLockPath(): string;
+/** Owner of a lock whose pid file is still being written (PID not known yet). */
+export declare const UNKNOWN_OWNER = -1;
+/**
+ * Creating a pid file (open, then write) is not atomic, so an empty or
+ * unparseable file may belong to a process that is mid-write. Only treat it as
+ * stale once it is older than this.
+ */
+export declare const MALFORMED_PID_FILE_GRACE_MS = 5000;
+/**
+ * PID holding the maintenance lock, `UNKNOWN_OWNER` while its pid file is still
+ * being written, or null. Stale locks are removed.
+ */
+export declare function getMaintenanceLockOwner(): number | null;
+/** PIDs of other live registered sessions. Stale registrations are removed. */
+export declare function getLiveSessionPids(): number[];
+/** Test-only: drop every registration held by this process and forget lock ownership. */
+export declare function resetSessionRegistrationsForTesting(): void;
+/** Register one running session in this process. Pair with exactly one unregisterSession(). */
+export declare function registerSession(): void;
+/** Release one registration made by registerSession(). */
+export declare function unregisterSession(): void;
+/**
+ * Register this session, then wait for any running maintenance to finish.
+ * Waits indefinitely by default: a vacuum on a multi-GB database can take
+ * minutes. With `timeoutMs`, throws after that long naming the holder.
+ */
+export declare function registerSessionAndWaitForMaintenance({ timeoutMs, pollMs, onWait, }?: {
+    timeoutMs?: number;
+    pollMs?: number;
+    onWait?: (ownerPid: number) => void;
+}): Promise<void>;
+/**
+ * Acquire the maintenance lock, then refuse if any mastracode session is live.
+ * Returns a release function.
+ */
+export declare function acquireMaintenanceLock(): () => void;
+//# sourceMappingURL=maintenance-lock.d.ts.map

package/dist/utils/maintenance-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maintenance-lock.d.ts","sourceRoot":"","sources":["../../src/utils/maintenance-lock.ts"],"names":[],"mappings":"AAiBA,qBAAa,oBAAqB,SAAQ,KAAK;aAG3B,SAAS,EAAE,MAAM,EAAE;gBADnC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EAAE;CAKtC;AAcD,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED,iFAAiF;AACjF,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,OAAQ,CAAC;AAuCjD;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,GAAG,IAAI,CAgBvD;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAmB7C;AAOD,yFAAyF;AACzF,wBAAgB,mCAAmC,IAAI,IAAI,CAG1D;AAYD,+FAA+F;AAC/F,wBAAgB,eAAe,IAAI,IAAI,CAStC;AAED,0DAA0D;AAC1D,wBAAgB,iBAAiB,IAAI,IAAI,CAIxC;AAED;;;;GAIG;AACH,wBAAsB,oCAAoC,CAAC,EACzD,SAAoB,EACpB,MAAY,EACZ,MAAM,GACP,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBnG;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,IAAI,CA0CnD"}

package/dist/utils/maintenance-lock.js

@@ -0,0 +1,199 @@
+import { getAppDataDir } from "./project.js";
+import path from "path";
+import fs from "fs";
+//#region src/utils/maintenance-lock.ts
+/**
+* Mutual exclusion between storage maintenance (`mastracode prune`) and running
+* mastracode sessions, using the same pid-file / stale-PID pattern as
+* thread-lock.ts.
+*
+* - Every process that opens storage registers a session pid file.
+* - `prune` holds `maintenance.lock` for its whole run.
+*
+* The checks are ordered so the race is closed both ways: `prune` acquires the
+* lock and THEN looks for live sessions; a starter registers and THEN looks for
+* the lock. Whichever acts second always sees the other.
+*/
+var MaintenanceLockError = class extends Error {
+	ownerPids;
+	constructor(message, ownerPids) {
+		super(message);
+		this.ownerPids = ownerPids;
+		this.name = "MaintenanceLockError";
+	}
+};
+function getLocksDir() {
+	const dir = path.join(getAppDataDir(), "locks");
+	fs.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+function getSessionsDir() {
+	const dir = path.join(getLocksDir(), "sessions");
+	fs.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+function getMaintenanceLockPath() {
+	return path.join(getLocksDir(), "maintenance.lock");
+}
+/** Owner of a lock whose pid file is still being written (PID not known yet). */
+const UNKNOWN_OWNER = -1;
+/**
+* Creating a pid file (open, then write) is not atomic, so an empty or
+* unparseable file may belong to a process that is mid-write. Only treat it as
+* stale once it is older than this.
+*/
+const MALFORMED_PID_FILE_GRACE_MS = 5e3;
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+/** Whether a pid file with no readable PID is old enough to reap. Missing files count as reapable. */
+function isMalformedPidFileStale(file) {
+	try {
+		return Date.now() - fs.statSync(file).mtimeMs > MALFORMED_PID_FILE_GRACE_MS;
+	} catch {
+		return true;
+	}
+}
+function describeOwners(pids) {
+	const known = pids.filter((pid) => pid !== -1);
+	return known.length > 0 ? ` (PID ${known.join(", ")})` : "";
+}
+function readPid(file) {
+	try {
+		const pid = parseInt(fs.readFileSync(file, "utf-8").trim(), 10);
+		return isNaN(pid) ? null : pid;
+	} catch {
+		return null;
+	}
+}
+let lockHeld = false;
+/**
+* PID holding the maintenance lock, `UNKNOWN_OWNER` while its pid file is still
+* being written, or null. Stale locks are removed.
+*/
+function getMaintenanceLockOwner() {
+	const lockPath = getMaintenanceLockPath();
+	if (!fs.existsSync(lockPath)) return null;
+	const pid = readPid(lockPath);
+	if (pid === process.pid) {
+		if (lockHeld) return pid;
+	} else if (pid !== null && isProcessAlive(pid)) return pid;
+	if (pid === null && !isMalformedPidFileStale(lockPath)) return -1;
+	try {
+		fs.unlinkSync(lockPath);
+	} catch {}
+	return null;
+}
+/** PIDs of other live registered sessions. Stale registrations are removed. */
+function getLiveSessionPids() {
+	const dir = getSessionsDir();
+	const live = [];
+	for (const file of fs.readdirSync(dir)) {
+		if (!file.endsWith(".pid")) continue;
+		const filePath = path.join(dir, file);
+		const pid = readPid(filePath);
+		if (pid === process.pid) continue;
+		if (pid !== null && isProcessAlive(pid)) live.push(pid);
+		else if (pid === null && !isMalformedPidFileStale(filePath)) live.push(-1);
+		else try {
+			fs.unlinkSync(filePath);
+		} catch {}
+	}
+	return live;
+}
+let sessionRefs = 0;
+let exitHookInstalled = false;
+/** Test-only: drop every registration held by this process and forget lock ownership. */
+function resetSessionRegistrationsForTesting() {
+	while (sessionRefs > 0) unregisterSession();
+	lockHeld = false;
+}
+function getSessionPidPath() {
+	return path.join(getSessionsDir(), `${process.pid}.pid`);
+}
+function removeSessionPidFile() {
+	try {
+		fs.unlinkSync(getSessionPidPath());
+	} catch {}
+}
+/** Register one running session in this process. Pair with exactly one unregisterSession(). */
+function registerSession() {
+	if (sessionRefs === 0) fs.writeFileSync(getSessionPidPath(), String(process.pid), { mode: 420 });
+	sessionRefs++;
+	if (!exitHookInstalled) {
+		exitHookInstalled = true;
+		process.once("exit", removeSessionPidFile);
+	}
+}
+/** Release one registration made by registerSession(). */
+function unregisterSession() {
+	if (sessionRefs === 0) return;
+	sessionRefs--;
+	if (sessionRefs === 0) removeSessionPidFile();
+}
+/**
+* Register this session, then wait for any running maintenance to finish.
+* Waits indefinitely by default: a vacuum on a multi-GB database can take
+* minutes. With `timeoutMs`, throws after that long naming the holder.
+*/
+async function registerSessionAndWaitForMaintenance({ timeoutMs = Infinity, pollMs = 250, onWait } = {}) {
+	registerSession();
+	const deadline = Date.now() + timeoutMs;
+	let notified = false;
+	for (;;) {
+		const owner = getMaintenanceLockOwner();
+		if (owner === null) return;
+		if (!notified) {
+			notified = true;
+			onWait?.(owner);
+		}
+		if (Date.now() >= deadline) {
+			unregisterSession();
+			throw new MaintenanceLockError(`Storage maintenance (mastracode prune${describeOwners([owner])}) is still running after ${Math.round(timeoutMs / 1e3)}s. Wait for it to finish, or stop it, then start mastracode again.`, [owner]);
+		}
+		await new Promise((resolve) => setTimeout(resolve, pollMs));
+	}
+}
+/**
+* Acquire the maintenance lock, then refuse if any mastracode session is live.
+* Returns a release function.
+*/
+function acquireMaintenanceLock() {
+	const lockPath = getMaintenanceLockPath();
+	for (let attempt = 0;; attempt++) try {
+		fs.writeFileSync(lockPath, String(process.pid), {
+			flag: "wx",
+			mode: 420
+		});
+		lockHeld = true;
+		break;
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		const owner = getMaintenanceLockOwner();
+		if (owner !== null || attempt > 0) throw new MaintenanceLockError(`Another mastracode prune is already running${owner === null ? "" : describeOwners([owner])}.`, owner === null ? [] : [owner]);
+	}
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		lockHeld = false;
+		if (readPid(lockPath) === process.pid) try {
+			fs.unlinkSync(lockPath);
+		} catch {}
+	};
+	const sessions = getLiveSessionPids();
+	if (sessions.length > 0) {
+		release();
+		throw new MaintenanceLockError(`mastracode is running${describeOwners(sessions)}. Exit every mastracode session before running prune.`, sessions);
+	}
+	return release;
+}
+//#endregion
+export { MALFORMED_PID_FILE_GRACE_MS, MaintenanceLockError, UNKNOWN_OWNER, acquireMaintenanceLock, getLiveSessionPids, getMaintenanceLockOwner, getMaintenanceLockPath, registerSession, registerSessionAndWaitForMaintenance, resetSessionRegistrationsForTesting, unregisterSession };
+
+//# sourceMappingURL=maintenance-lock.js.map

package/dist/utils/maintenance-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maintenance-lock.js","names":[],"sources":["../../src/utils/maintenance-lock.ts"],"sourcesContent":["/**\n * Mutual exclusion between storage maintenance (`mastracode prune`) and running\n * mastracode sessions, using the same pid-file / stale-PID pattern as\n * thread-lock.ts.\n *\n * - Every process that opens storage registers a session pid file.\n * - `prune` holds `maintenance.lock` for its whole run.\n *\n * The checks are ordered so the race is closed both ways: `prune` acquires the\n * lock and THEN looks for live sessions; a starter registers and THEN looks for\n * the lock. Whichever acts second always sees the other.\n */\nimport fs from 'node:fs';\nimport path from 'node:path';\n\nimport { getAppDataDir } from './project.js';\n\nexport class MaintenanceLockError extends Error {\n  constructor(\n    message: string,\n    public readonly ownerPids: number[],\n  ) {\n    super(message);\n    this.name = 'MaintenanceLockError';\n  }\n}\n\nfunction getLocksDir(): string {\n  const dir = path.join(getAppDataDir(), 'locks');\n  fs.mkdirSync(dir, { recursive: true });\n  return dir;\n}\n\nfunction getSessionsDir(): string {\n  const dir = path.join(getLocksDir(), 'sessions');\n  fs.mkdirSync(dir, { recursive: true });\n  return dir;\n}\n\nexport function getMaintenanceLockPath(): string {\n  return path.join(getLocksDir(), 'maintenance.lock');\n}\n\n/** Owner of a lock whose pid file is still being written (PID not known yet). */\nexport const UNKNOWN_OWNER = -1;\n\n/**\n * Creating a pid file (open, then write) is not atomic, so an empty or\n * unparseable file may belong to a process that is mid-write. Only treat it as\n * stale once it is older than this.\n */\nexport const MALFORMED_PID_FILE_GRACE_MS = 5_000;\n\nfunction isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (error) {\n    // Only ESRCH proves the process is gone; EPERM etc. mean it exists.\n    return (error as NodeJS.ErrnoException).code !== 'ESRCH';\n  }\n}\n\n/** Whether a pid file with no readable PID is old enough to reap. Missing files count as reapable. */\nfunction isMalformedPidFileStale(file: string): boolean {\n  try {\n    return Date.now() - fs.statSync(file).mtimeMs > MALFORMED_PID_FILE_GRACE_MS;\n  } catch {\n    return true;\n  }\n}\n\nfunction describeOwners(pids: number[]): string {\n  const known = pids.filter(pid => pid !== UNKNOWN_OWNER);\n  return known.length > 0 ? ` (PID ${known.join(', ')})` : '';\n}\n\nfunction readPid(file: string): number | null {\n  try {\n    const pid = parseInt(fs.readFileSync(file, 'utf-8').trim(), 10);\n    return isNaN(pid) ? null : pid;\n  } catch {\n    return null;\n  }\n}\n\n// True while this process holds maintenance.lock, so an own-PID lock can be told\n// apart from a stale leftover whose PID we reused.\nlet lockHeld = false;\n\n/**\n * PID holding the maintenance lock, `UNKNOWN_OWNER` while its pid file is still\n * being written, or null. Stale locks are removed.\n */\nexport function getMaintenanceLockOwner(): number | null {\n  const lockPath = getMaintenanceLockPath();\n  if (!fs.existsSync(lockPath)) return null;\n  const pid = readPid(lockPath);\n  if (pid === process.pid) {\n    // We hold it (e.g. a concurrent prune in this process): a live owner.\n    if (lockHeld) return pid;\n    // Otherwise it is a leftover from a dead process whose PID we reused.\n  } else if (pid !== null && isProcessAlive(pid)) {\n    return pid;\n  }\n  if (pid === null && !isMalformedPidFileStale(lockPath)) return UNKNOWN_OWNER;\n  try {\n    fs.unlinkSync(lockPath);\n  } catch {}\n  return null;\n}\n\n/** PIDs of other live registered sessions. Stale registrations are removed. */\nexport function getLiveSessionPids(): number[] {\n  const dir = getSessionsDir();\n  const live: number[] = [];\n  for (const file of fs.readdirSync(dir)) {\n    if (!file.endsWith('.pid')) continue;\n    const filePath = path.join(dir, file);\n    const pid = readPid(filePath);\n    if (pid === process.pid) continue;\n    if (pid !== null && isProcessAlive(pid)) {\n      live.push(pid);\n    } else if (pid === null && !isMalformedPidFileStale(filePath)) {\n      live.push(UNKNOWN_OWNER);\n    } else {\n      try {\n        fs.unlinkSync(filePath);\n      } catch {}\n    }\n  }\n  return live;\n}\n\n// Refcounted: one process may start several sessions (e.g. repeated\n// createMastraCode() calls). The pid file exists while the count is > 0.\nlet sessionRefs = 0;\nlet exitHookInstalled = false;\n\n/** Test-only: drop every registration held by this process and forget lock ownership. */\nexport function resetSessionRegistrationsForTesting(): void {\n  while (sessionRefs > 0) unregisterSession();\n  lockHeld = false;\n}\n\nfunction getSessionPidPath(): string {\n  return path.join(getSessionsDir(), `${process.pid}.pid`);\n}\n\nfunction removeSessionPidFile(): void {\n  try {\n    fs.unlinkSync(getSessionPidPath());\n  } catch {}\n}\n\n/** Register one running session in this process. Pair with exactly one unregisterSession(). */\nexport function registerSession(): void {\n  if (sessionRefs === 0) {\n    fs.writeFileSync(getSessionPidPath(), String(process.pid), { mode: 0o644 });\n  }\n  sessionRefs++;\n  if (!exitHookInstalled) {\n    exitHookInstalled = true;\n    process.once('exit', removeSessionPidFile);\n  }\n}\n\n/** Release one registration made by registerSession(). */\nexport function unregisterSession(): void {\n  if (sessionRefs === 0) return;\n  sessionRefs--;\n  if (sessionRefs === 0) removeSessionPidFile();\n}\n\n/**\n * Register this session, then wait for any running maintenance to finish.\n * Waits indefinitely by default: a vacuum on a multi-GB database can take\n * minutes. With `timeoutMs`, throws after that long naming the holder.\n */\nexport async function registerSessionAndWaitForMaintenance({\n  timeoutMs = Infinity,\n  pollMs = 250,\n  onWait,\n}: { timeoutMs?: number; pollMs?: number; onWait?: (ownerPid: number) => void } = {}): Promise<void> {\n  registerSession();\n  const deadline = Date.now() + timeoutMs;\n  let notified = false;\n  for (;;) {\n    const owner = getMaintenanceLockOwner();\n    if (owner === null) return;\n    if (!notified) {\n      notified = true;\n      onWait?.(owner);\n    }\n    if (Date.now() >= deadline) {\n      unregisterSession();\n      throw new MaintenanceLockError(\n        `Storage maintenance (mastracode prune${describeOwners([owner])}) is still running after ${Math.round(timeoutMs / 1000)}s. ` +\n          `Wait for it to finish, or stop it, then start mastracode again.`,\n        [owner],\n      );\n    }\n    await new Promise(resolve => setTimeout(resolve, pollMs));\n  }\n}\n\n/**\n * Acquire the maintenance lock, then refuse if any mastracode session is live.\n * Returns a release function.\n */\nexport function acquireMaintenanceLock(): () => void {\n  const lockPath = getMaintenanceLockPath();\n  for (let attempt = 0; ; attempt++) {\n    try {\n      // 'wx' makes creation atomic, so two prunes cannot both win.\n      fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx', mode: 0o644 });\n      lockHeld = true;\n      break;\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;\n      // getMaintenanceLockOwner() removes a stale lock, so the retry can win.\n      const owner = getMaintenanceLockOwner();\n      if (owner !== null || attempt > 0) {\n        throw new MaintenanceLockError(\n          `Another mastracode prune is already running${owner === null ? '' : describeOwners([owner])}.`,\n          owner === null ? [] : [owner],\n        );\n      }\n    }\n  }\n\n  let released = false;\n  const release = () => {\n    if (released) return;\n    released = true;\n    lockHeld = false;\n    if (readPid(lockPath) === process.pid) {\n      try {\n        fs.unlinkSync(lockPath);\n      } catch {}\n    }\n  };\n\n  const sessions = getLiveSessionPids();\n  if (sessions.length > 0) {\n    release();\n    throw new MaintenanceLockError(\n      `mastracode is running${describeOwners(sessions)}. Exit every mastracode session before running prune.`,\n      sessions,\n    );\n  }\n  return release;\n}\n"],"mappings":"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"}

package/dist/utils/notification-dispatch.d.ts

@@ -0,0 +1,59 @@
+import type { LeaseProvider } from '@mastra/core/events';
+import type { Mastra } from '@mastra/core/mastra';
+/**
+ * Whether this call runs inside this process's own dispatch pass for
+ * `resourceId`, as opposed to the dispatch schedule every process sharing the
+ * database takes turns running.
+ */
+export declare function isDispatchingNotificationsFor(resourceId: string): boolean;
+/**
+ * Whether a delivery-time policy should leave a due notification pending
+ * (`hold`). Deliveries happen from this process's own dispatch pass for the
+ * record's resource. Anything else holds: a thread no session here owns
+ * belongs to another process sharing the database, and once this process's
+ * dispatcher runs, its own resources are delivered by whichever process holds
+ * their dispatch lease, never by the shared dispatch schedule.
+ */
+export declare function shouldHoldNotificationDelivery({ resourceId, ownedHere, dispatcher, }: {
+    resourceId: string;
+    /** Whether a session in this process owns the resource. */
+    ownedHere: boolean;
+    dispatcher: {
+        readonly running: boolean;
+    };
+}): boolean;
+export type ResourceNotificationDispatcherOptions = {
+    getMastra: () => Mastra | undefined;
+    /** The resources this process runs sessions for. */
+    getResourceIds: () => Iterable<string>;
+    /**
+     * Cross-process leases. When set, a resource's notifications are dispatched
+     * only by the process holding its dispatch lease, so two processes serving
+     * the same resource (worktrees of one repo) never both deliver them.
+     */
+    leases?: LeaseProvider;
+    /** Unique to this process. */
+    owner: string;
+    intervalMs?: number;
+    leaseTtlMs?: number;
+    onError?: (error: unknown) => void;
+};
+/**
+ * Delivers the due notifications of the resources this process serves, on a
+ * timer of its own.
+ *
+ * Every Mastra Code process shares one database, so one notification store and
+ * one dispatch schedule, and the scheduler gives each fire to whichever process
+ * claims it first, usually the same one for as long as it runs. That process
+ * cannot run another project's thread, so its delivery policy holds those
+ * records. Each process therefore dispatches its own resources here.
+ */
+export declare function createResourceNotificationDispatcher(options: ResourceNotificationDispatcherOptions): {
+    readonly running: boolean;
+    start(): void;
+    stop(): Promise<void>;
+    /** Runs one dispatch pass now. Only dispatches while started. */
+    tick: () => Promise<void>;
+};
+export type ResourceNotificationDispatcher = ReturnType<typeof createResourceNotificationDispatcher>;
+//# sourceMappingURL=notification-dispatch.d.ts.map

package/dist/utils/notification-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-dispatch.d.ts","sourceRoot":"","sources":["../../src/utils/notification-dispatch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAWlD;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,EAC7C,UAAU,EACV,SAAS,EACT,UAAU,GACX,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAC3C,GAAG,OAAO,CAGV;AAED,MAAM,MAAM,qCAAqC,GAAG;IAClD,SAAS,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACpC,oDAAoD;IACpD,cAAc,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,CAAC;IACvC;;;;OAIG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,oCAAoC,CAAC,OAAO,EAAE,qCAAqC;sBA2DhF,OAAO;aAGb,IAAI;YAMC,OAAO,CAAC,IAAI,CAAC;IAM3B,iEAAiE;gBA1BlD,OAAO,CAAC,IAAI,CAAC;EA6B/B;AAED,MAAM,MAAM,8BAA8B,GAAG,UAAU,CAAC,OAAO,oCAAoC,CAAC,CAAC"}

package/dist/utils/notification-dispatch.js

@@ -0,0 +1,109 @@
+import { notificationDispatchLeaseKey } from "./signals-pubsub.js";
+import { dispatchDueNotifications } from "@mastra/core/notifications";
+import { AsyncLocalStorage } from "async_hooks";
+//#region src/utils/notification-dispatch.ts
+const DEFAULT_INTERVAL_MS = 1e4;
+const DEFAULT_LEASE_TTL_MS = 6e4;
+/** The resource whose notifications the current async context is dispatching. */
+const dispatchingFor = new AsyncLocalStorage();
+/**
+* Whether this call runs inside this process's own dispatch pass for
+* `resourceId`, as opposed to the dispatch schedule every process sharing the
+* database takes turns running.
+*/
+function isDispatchingNotificationsFor(resourceId) {
+	return dispatchingFor.getStore() === resourceId;
+}
+/**
+* Whether a delivery-time policy should leave a due notification pending
+* (`hold`). Deliveries happen from this process's own dispatch pass for the
+* record's resource. Anything else holds: a thread no session here owns
+* belongs to another process sharing the database, and once this process's
+* dispatcher runs, its own resources are delivered by whichever process holds
+* their dispatch lease, never by the shared dispatch schedule.
+*/
+function shouldHoldNotificationDelivery({ resourceId, ownedHere, dispatcher }) {
+	if (isDispatchingNotificationsFor(resourceId)) return false;
+	return !ownedHere || dispatcher.running;
+}
+/**
+* Delivers the due notifications of the resources this process serves, on a
+* timer of its own.
+*
+* Every Mastra Code process shares one database, so one notification store and
+* one dispatch schedule, and the scheduler gives each fire to whichever process
+* claims it first, usually the same one for as long as it runs. That process
+* cannot run another project's thread, so its delivery policy holds those
+* records. Each process therefore dispatches its own resources here.
+*/
+function createResourceNotificationDispatcher(options) {
+	const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+	const leaseTtlMs = options.leaseTtlMs ?? DEFAULT_LEASE_TTL_MS;
+	const held = /* @__PURE__ */ new Set();
+	let timer;
+	let ticking;
+	const release = async (resourceId) => {
+		held.delete(resourceId);
+		await options.leases?.releaseLease(notificationDispatchLeaseKey(resourceId), options.owner).catch(options.onError);
+	};
+	const claim = async (resourceId) => {
+		if (!options.leases) return true;
+		try {
+			const { acquired } = await options.leases.acquireLease(notificationDispatchLeaseKey(resourceId), options.owner, leaseTtlMs);
+			if (acquired) held.add(resourceId);
+			else held.delete(resourceId);
+			return acquired;
+		} catch (error) {
+			options.onError?.(error);
+			return false;
+		}
+	};
+	const runTick = async () => {
+		const mastra = options.getMastra();
+		const storage = await mastra?.getStorage()?.getStore("notifications");
+		if (!mastra || !storage) return;
+		const resourceIds = new Set(options.getResourceIds());
+		for (const resourceId of [...held]) if (!resourceIds.has(resourceId)) await release(resourceId);
+		for (const resourceId of resourceIds) {
+			if (!timer || !await claim(resourceId)) continue;
+			try {
+				await dispatchingFor.run(resourceId, () => dispatchDueNotifications({
+					mastra,
+					storage,
+					resourceId
+				}));
+			} catch (error) {
+				options.onError?.(error);
+			}
+		}
+	};
+	const tick = () => {
+		ticking ??= runTick().catch((error) => options.onError?.(error)).finally(() => {
+			ticking = void 0;
+		});
+		return ticking;
+	};
+	return {
+		get running() {
+			return timer !== void 0;
+		},
+		start() {
+			if (timer) return;
+			timer = setInterval(() => void tick(), intervalMs);
+			timer.unref?.();
+			tick();
+		},
+		async stop() {
+			if (timer) clearInterval(timer);
+			timer = void 0;
+			await ticking;
+			await Promise.all([...held].map(release));
+		},
+		/** Runs one dispatch pass now. Only dispatches while started. */
+		tick
+	};
+}
+//#endregion
+export { createResourceNotificationDispatcher, isDispatchingNotificationsFor, shouldHoldNotificationDelivery };
+
+//# sourceMappingURL=notification-dispatch.js.map

package/dist/utils/notification-dispatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-dispatch.js","names":[],"sources":["../../src/utils/notification-dispatch.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\n\nimport type { LeaseProvider } from '@mastra/core/events';\nimport type { Mastra } from '@mastra/core/mastra';\nimport { dispatchDueNotifications } from '@mastra/core/notifications';\n\nimport { notificationDispatchLeaseKey } from './signals-pubsub.js';\n\nconst DEFAULT_INTERVAL_MS = 10_000;\nconst DEFAULT_LEASE_TTL_MS = 60_000;\n\n/** The resource whose notifications the current async context is dispatching. */\nconst dispatchingFor = new AsyncLocalStorage<string>();\n\n/**\n * Whether this call runs inside this process's own dispatch pass for\n * `resourceId`, as opposed to the dispatch schedule every process sharing the\n * database takes turns running.\n */\nexport function isDispatchingNotificationsFor(resourceId: string): boolean {\n  return dispatchingFor.getStore() === resourceId;\n}\n\n/**\n * Whether a delivery-time policy should leave a due notification pending\n * (`hold`). Deliveries happen from this process's own dispatch pass for the\n * record's resource. Anything else holds: a thread no session here owns\n * belongs to another process sharing the database, and once this process's\n * dispatcher runs, its own resources are delivered by whichever process holds\n * their dispatch lease, never by the shared dispatch schedule.\n */\nexport function shouldHoldNotificationDelivery({\n  resourceId,\n  ownedHere,\n  dispatcher,\n}: {\n  resourceId: string;\n  /** Whether a session in this process owns the resource. */\n  ownedHere: boolean;\n  dispatcher: { readonly running: boolean };\n}): boolean {\n  if (isDispatchingNotificationsFor(resourceId)) return false;\n  return !ownedHere || dispatcher.running;\n}\n\nexport type ResourceNotificationDispatcherOptions = {\n  getMastra: () => Mastra | undefined;\n  /** The resources this process runs sessions for. */\n  getResourceIds: () => Iterable<string>;\n  /**\n   * Cross-process leases. When set, a resource's notifications are dispatched\n   * only by the process holding its dispatch lease, so two processes serving\n   * the same resource (worktrees of one repo) never both deliver them.\n   */\n  leases?: LeaseProvider;\n  /** Unique to this process. */\n  owner: string;\n  intervalMs?: number;\n  leaseTtlMs?: number;\n  onError?: (error: unknown) => void;\n};\n\n/**\n * Delivers the due notifications of the resources this process serves, on a\n * timer of its own.\n *\n * Every Mastra Code process shares one database, so one notification store and\n * one dispatch schedule, and the scheduler gives each fire to whichever process\n * claims it first, usually the same one for as long as it runs. That process\n * cannot run another project's thread, so its delivery policy holds those\n * records. Each process therefore dispatches its own resources here.\n */\nexport function createResourceNotificationDispatcher(options: ResourceNotificationDispatcherOptions) {\n  const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;\n  const leaseTtlMs = options.leaseTtlMs ?? DEFAULT_LEASE_TTL_MS;\n  const held = new Set<string>();\n  let timer: ReturnType<typeof setInterval> | undefined;\n  let ticking: Promise<void> | undefined;\n\n  const release = async (resourceId: string) => {\n    held.delete(resourceId);\n    await options.leases?.releaseLease(notificationDispatchLeaseKey(resourceId), options.owner).catch(options.onError);\n  };\n\n  const claim = async (resourceId: string): Promise<boolean> => {\n    if (!options.leases) return true;\n    try {\n      // Acquiring a lease this process already holds renews it.\n      const { acquired } = await options.leases.acquireLease(\n        notificationDispatchLeaseKey(resourceId),\n        options.owner,\n        leaseTtlMs,\n      );\n      if (acquired) held.add(resourceId);\n      else held.delete(resourceId);\n      return acquired;\n    } catch (error) {\n      options.onError?.(error);\n      return false;\n    }\n  };\n\n  const runTick = async () => {\n    const mastra = options.getMastra();\n    const storage = await mastra?.getStorage()?.getStore('notifications');\n    if (!mastra || !storage) return;\n    const resourceIds = new Set(options.getResourceIds());\n    for (const resourceId of [...held]) {\n      if (!resourceIds.has(resourceId)) await release(resourceId);\n    }\n    for (const resourceId of resourceIds) {\n      if (!timer || !(await claim(resourceId))) continue;\n      try {\n        await dispatchingFor.run(resourceId, () => dispatchDueNotifications({ mastra, storage, resourceId }));\n      } catch (error) {\n        options.onError?.(error);\n      }\n    }\n  };\n\n  const tick = (): Promise<void> => {\n    // Ticks run from a timer, so a failure must be reported, never left as an unhandled rejection.\n    ticking ??= runTick()\n      .catch(error => options.onError?.(error))\n      .finally(() => {\n        ticking = undefined;\n      });\n    return ticking;\n  };\n\n  return {\n    get running(): boolean {\n      return timer !== undefined;\n    },\n    start(): void {\n      if (timer) return;\n      timer = setInterval(() => void tick(), intervalMs);\n      timer.unref?.();\n      void tick();\n    },\n    async stop(): Promise<void> {\n      if (timer) clearInterval(timer);\n      timer = undefined;\n      await ticking;\n      await Promise.all([...held].map(release));\n    },\n    /** Runs one dispatch pass now. Only dispatches while started. */\n    tick,\n  };\n}\n\nexport type ResourceNotificationDispatcher = ReturnType<typeof createResourceNotificationDispatcher>;\n"],"mappings":";;;;AAQA,MAAM,sBAAsB;AAC5B,MAAM,uBAAuB;;AAG7B,MAAM,iBAAiB,IAAI,kBAA0B;;;;;;AAOrD,SAAgB,8BAA8B,YAA6B;CACzE,OAAO,eAAe,SAAS,MAAM;AACvC;;;;;;;;;AAUA,SAAgB,+BAA+B,EAC7C,YACA,WACA,cAMU;CACV,IAAI,8BAA8B,UAAU,GAAG,OAAO;CACtD,OAAO,CAAC,aAAa,WAAW;AAClC;;;;;;;;;;;AA6BA,SAAgB,qCAAqC,SAAgD;CACnG,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,uBAAO,IAAI,IAAY;CAC7B,IAAI;CACJ,IAAI;CAEJ,MAAM,UAAU,OAAO,eAAuB;EAC5C,KAAK,OAAO,UAAU;EACtB,MAAM,QAAQ,QAAQ,aAAa,6BAA6B,UAAU,GAAG,QAAQ,KAAK,CAAC,CAAC,MAAM,QAAQ,OAAO;CACnH;CAEA,MAAM,QAAQ,OAAO,eAAyC;EAC5D,IAAI,CAAC,QAAQ,QAAQ,OAAO;EAC5B,IAAI;GAEF,MAAM,EAAE,aAAa,MAAM,QAAQ,OAAO,aACxC,6BAA6B,UAAU,GACvC,QAAQ,OACR,UACF;GACA,IAAI,UAAU,KAAK,IAAI,UAAU;QAC5B,KAAK,OAAO,UAAU;GAC3B,OAAO;EACT,SAAS,OAAO;GACd,QAAQ,UAAU,KAAK;GACvB,OAAO;EACT;CACF;CAEA,MAAM,UAAU,YAAY;EAC1B,MAAM,SAAS,QAAQ,UAAU;EACjC,MAAM,UAAU,MAAM,QAAQ,WAAW,CAAC,EAAE,SAAS,eAAe;EACpE,IAAI,CAAC,UAAU,CAAC,SAAS;EACzB,MAAM,cAAc,IAAI,IAAI,QAAQ,eAAe,CAAC;EACpD,KAAK,MAAM,cAAc,CAAC,GAAG,IAAI,GAC/B,IAAI,CAAC,YAAY,IAAI,UAAU,GAAG,MAAM,QAAQ,UAAU;EAE5D,KAAK,MAAM,cAAc,aAAa;GACpC,IAAI,CAAC,SAAS,CAAE,MAAM,MAAM,UAAU,GAAI;GAC1C,IAAI;IACF,MAAM,eAAe,IAAI,kBAAkB,yBAAyB;KAAE;KAAQ;KAAS;IAAW,CAAC,CAAC;GACtG,SAAS,OAAO;IACd,QAAQ,UAAU,KAAK;GACzB;EACF;CACF;CAEA,MAAM,aAA4B;EAEhC,YAAY,QAAQ,CAAC,CAClB,OAAM,UAAS,QAAQ,UAAU,KAAK,CAAC,CAAC,CACxC,cAAc;GACb,UAAU,KAAA;EACZ,CAAC;EACH,OAAO;CACT;CAEA,OAAO;EACL,IAAI,UAAmB;GACrB,OAAO,UAAU,KAAA;EACnB;EACA,QAAc;GACZ,IAAI,OAAO;GACX,QAAQ,kBAAkB,KAAK,KAAK,GAAG,UAAU;GACjD,MAAM,QAAQ;GACd,KAAU;EACZ;EACA,MAAM,OAAsB;GAC1B,IAAI,OAAO,cAAc,KAAK;GAC9B,QAAQ,KAAA;GACR,MAAM;GACN,MAAM,QAAQ,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,OAAO,CAAC;EAC1C;;EAEA;CACF;AACF"}

package/dist/utils/open-url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Best-effort browser opening for OAuth and other login flows.
+ */
+/**
+ * Open a URL in the default browser without going through a shell.
+ * Only well-formed http(s) URLs are opened; anything else is ignored
+ * (the URL is still displayed for the user to open manually).
+ */
+export declare function openUrlInBrowser(url: string): void;
+//# sourceMappingURL=open-url.d.ts.map

package/dist/utils/open-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-url.d.ts","sourceRoot":"","sources":["../../src/utils/open-url.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAsBlD"}

package/dist/utils/open-url.js

@@ -0,0 +1,30 @@
+import { spawn } from "child_process";
+//#region src/utils/open-url.ts
+/**
+* Best-effort browser opening for OAuth and other login flows.
+*/
+/**
+* Open a URL in the default browser without going through a shell.
+* Only well-formed http(s) URLs are opened; anything else is ignored
+* (the URL is still displayed for the user to open manually).
+*/
+function openUrlInBrowser(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return;
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
+	const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+	const child = spawn(cmd, args, {
+		stdio: "ignore",
+		detached: true
+	});
+	child.on("error", () => {});
+	child.unref();
+}
+//#endregion
+export { openUrlInBrowser };
+
+//# sourceMappingURL=open-url.js.map