opentool 0.7.9 → 0.7.11

package/README.md

@@ -82,7 +82,7 @@ export const profile = {
   description: "Stake 100 USDC daily at 12:00 UTC",
   fixedAmount: "100",
   tokenSymbol: "USDC",
-  schedule: { cron: "0 12 * * *", enabled: true },
+  schedule: { cron: "0 12 * * *", enabled: false },
   limits: { concurrency: 1, dailyCap: 1 },
 };
 
@@ -115,6 +115,11 @@ export async function POST(req: Request) {
 }
 ```
 
+### Cron schedules (`profile.schedule`)
+
+- GET-only tools require `profile.schedule` with a standard 5–6 field cron expression (e.g., `0 12 * * *` or `0 0 ? * MON-FRI *`).
+- Build validates the cron shape and emits `.well-known/opentool/cron.json` capturing each scheduled tool (`toolName`, `toolPath`, `scheduleExpression`). Enabled defaults to `false` even if authors set it to `true` in code. Deployment targets can translate these cron strings to their provider format (e.g., EventBridge) downstream.
+
 ### Public tools: Add x402 payments (optional)
 
 Protect your public tools with crypto payments using x402:

package/dist/cli/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { M as Metadata, I as InternalToolDefinition } from '../validate-BBjyq5nS.js';
-export { G as GenerateMetadataOptions, a as GenerateMetadataResult, V as ValidateOptions, b as generateMetadata, g as generateMetadataCommand, l as loadAndValidateTools, v as validateCommand, c as validateFullCommand } from '../validate-BBjyq5nS.js';
+import { M as Metadata, I as InternalToolDefinition } from '../validate-uetwG5jo.js';
+export { G as GenerateMetadataOptions, a as GenerateMetadataResult, V as ValidateOptions, b as generateMetadata, g as generateMetadataCommand, l as loadAndValidateTools, v as validateCommand, c as validateFullCommand } from '../validate-uetwG5jo.js';
 import 'zod';
 import '../x402/index.js';
 import 'viem';
@@ -17,6 +17,7 @@ interface BuildArtifacts {
     tools: InternalToolDefinition[];
     compiledTools: CompiledToolArtifact[];
     workflowBundles: WorkflowBundleArtifact | null;
+    cronManifestPath: string | null;
 }
 interface CompiledToolArtifact {
     name: string;

package/dist/cli/index.js

@@ -932,6 +932,40 @@ var HTTP_METHODS = [
   "OPTIONS"
 ];
 
+// src/utils/schedule.ts
+var CRON_WRAPPED_REGEX = /^cron\((.*)\)$/i;
+var CRON_TOKEN_REGEX = /^[A-Za-z0-9*?/,\-#L]+$/;
+function normalizeScheduleExpression(raw, context) {
+  const value = raw?.trim();
+  if (!value) {
+    throw new Error(`${context}: profile.schedule.cron must be a non-empty string`);
+  }
+  const cronBody = extractCronBody(value);
+  const cronFields = cronBody.trim().split(/\s+/).filter(Boolean);
+  if (cronFields.length !== 5 && cronFields.length !== 6) {
+    throw new Error(`${context}: cron expression must have 5 or 6 fields (got ${cronFields.length})`);
+  }
+  validateCronTokens(cronFields, context);
+  return {
+    type: "cron",
+    expression: cronFields.join(" ")
+  };
+}
+function extractCronBody(value) {
+  const cronMatch = CRON_WRAPPED_REGEX.exec(value);
+  if (cronMatch) {
+    return (cronMatch[1] ?? "").trim();
+  }
+  return value;
+}
+function validateCronTokens(fields, context) {
+  fields.forEach((token, idx) => {
+    if (!CRON_TOKEN_REGEX.test(token)) {
+      throw new Error(`${context}: invalid cron token "${token}" at position ${idx + 1}`);
+    }
+  });
+}
+
 // src/cli/validate.ts
 var SUPPORTED_EXTENSIONS = [
   ".ts",
@@ -1051,11 +1085,16 @@ async function loadAndValidateTools(toolsDir, options = {}) {
       if (hasGET === hasPOST) {
         throw new Error(`${file}: export exactly one of GET or POST`);
       }
+      let normalizedSchedule = null;
       if (hasGET) {
         const schedule = toolModule?.profile?.schedule;
         if (!schedule || typeof schedule?.cron !== "string" || schedule.cron.trim().length === 0) {
           throw new Error(`${file}: GET tools require profile.schedule { cron }`);
         }
+        normalizedSchedule = normalizeScheduleExpression(schedule.cron, file);
+        if (typeof schedule.enabled === "boolean") {
+          normalizedSchedule.authoredEnabled = schedule.enabled;
+        }
       }
       if (hasPOST) {
         if (!schema) {
@@ -1112,7 +1151,9 @@ async function loadAndValidateTools(toolsDir, options = {}) {
         filename: toBaseName(file),
         sourcePath: path5.join(toolsDir, file),
         handler: async (params) => adapter(params),
-        payment: paymentExport ?? null
+        payment: paymentExport ?? null,
+        schedule: normalizedSchedule,
+        profileDescription: typeof toolModule?.profile?.description === "string" ? toolModule.profile?.description ?? null : null
       };
       tools.push(tool);
     }
@@ -1334,6 +1375,11 @@ async function buildProject(options) {
     projectRoot,
     outputDir
   });
+  const cronManifestPath = await writeCronManifest({
+    tools,
+    compiledTools,
+    outputDir
+  });
   const workflowBundles = await buildWorkflowsIfPresent({
     projectRoot,
     outputDir
@@ -1356,7 +1402,8 @@ async function buildProject(options) {
     defaultsApplied,
     tools,
     compiledTools,
-    workflowBundles
+    workflowBundles,
+    cronManifestPath
   };
 }
 async function emitTools(tools, config) {
@@ -1499,6 +1546,55 @@ async function writeMcpServer(options) {
   fs4.writeFileSync(serverPath, serverCode);
   fs4.chmodSync(serverPath, 493);
 }
+function writeCronManifest(options) {
+  const scheduledTools = options.tools.filter((tool) => tool.schedule?.expression);
+  const manifestDir = path5.join(options.outputDir, ".well-known", "opentool");
+  const manifestPath = path5.join(manifestDir, "cron.json");
+  if (scheduledTools.length === 0) {
+    if (fs4.existsSync(manifestPath)) {
+      fs4.rmSync(manifestPath);
+    }
+    return null;
+  }
+  const entries = scheduledTools.map((tool) => {
+    const schedule = tool.schedule;
+    if (!schedule) {
+      throw new Error(`Internal error: missing schedule for tool ${tool.filename}`);
+    }
+    const compiled = options.compiledTools.find(
+      (artifact) => artifact.filename === tool.filename
+    );
+    if (!compiled) {
+      throw new Error(`Internal error: missing compiled artifact for ${tool.filename}`);
+    }
+    const toolName = tool.metadata?.name ?? tool.filename;
+    const description = tool.metadata?.description ?? tool.profileDescription ?? void 0;
+    const payloadPath = compiled.modulePath.replace(/\\/g, "/");
+    const entry = {
+      toolName,
+      scheduleType: schedule.type,
+      scheduleExpression: schedule.expression,
+      enabledDefault: false,
+      ...schedule.authoredEnabled !== void 0 ? { authoredEnabled: schedule.authoredEnabled } : {},
+      payload: {
+        toolPath: payloadPath,
+        httpMethod: "GET"
+      }
+    };
+    if (description !== void 0) {
+      entry.description = description;
+    }
+    return entry;
+  });
+  const manifest = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entries
+  };
+  fs4.mkdirSync(manifestDir, { recursive: true });
+  fs4.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  return manifestPath;
+}
 function logBuildSummary(artifacts, options) {
   const end = timestamp();
   console.log(`[${end}] Build completed successfully!`);
@@ -1515,6 +1611,9 @@ function logBuildSummary(artifacts, options) {
     console.log(`     - ${tool.name} [${methods}]${walletBadge}`);
   });
   console.log("  \u2022 metadata.json (registry artifact)");
+  if (artifacts.cronManifestPath) {
+    console.log("  \u2022 .well-known/opentool/cron.json (cron manifest)");
+  }
   if (artifacts.workflowBundles) {
     console.log("  \u2022 .well-known/workflow/v1/ (workflow bundles)");
     console.log("     - flow.js");