@plasm_lang/vercel-agent 0.3.85 → 0.3.87

package/templates/mcp-radar/agent/channels/mcp-radar.ts

@@ -4,7 +4,8 @@ import { waitUntil } from "@vercel/functions";
 import { defineChannel } from "@plasm_lang/vercel-agent";
 
 import { readProofMarkdown } from "../../lib/proof-store.js";
-import { radarStatus, runRadar } from "../../lib/run-radar.js";
+import { radarStatus } from "../../lib/run-radar.js";
+import { startMcpRadarRun } from "../../lib/start-mcp-radar.js";
 
 function readJsonBody(req: IncomingMessage): Promise<unknown> {
   return new Promise((resolve, reject) => {
@@ -45,17 +46,16 @@ export default defineChannel({
 
         if (process.env.VERCEL === "1") {
           waitUntil(
-            runRadar(ctx, options).catch((err: unknown) => {
-              console.error("[mcp-radar] background run failed:", err);
+            startMcpRadarRun(ctx, options).catch((err: unknown) => {
+              console.error("[mcp-radar] workflow start failed:", err);
             }),
           );
-          sendJson(res, 202, { accepted: true, async: true });
+          sendJson(res, 202, { accepted: true, workflow: true });
           return;
         }
 
-        const result = await runRadar(ctx, options);
-        const status = result.ok ? 200 : 500;
-        sendJson(res, status, result);
+        const run = await startMcpRadarRun(ctx, options);
+        sendJson(res, 200, { accepted: true, workflow: true, run });
       },
     },
     {

package/templates/mcp-radar/agent/schedules/mcp-radar-scan.ts

@@ -1,14 +1,12 @@
 import { defineSchedule } from "@plasm_lang/vercel-agent";
 
-import { runRadar } from "../../lib/run-radar.js";
+import { startMcpRadarRun } from "../../lib/start-mcp-radar.js";
 
 export default defineSchedule({
   name: "mcp-radar-scan",
   cron: "0 */6 * * *",
   handler: async (ctx) => {
-    const result = await runRadar(ctx);
-    console.log(
-      `[mcp-radar:schedule] ok=${result.ok} skipped=${result.skipped} new=${result.newCandidates.length} reason=${result.reason ?? ""}`,
-    );
+    await startMcpRadarRun(ctx);
+    console.log("[mcp-radar:schedule] workflow started");
   },
 });

package/templates/mcp-radar/lib/proof-store.ts

@@ -1,6 +1,20 @@
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 
+function isVercelHosted(): boolean {
+  return (
+    process.env.VERCEL === "1" ||
+    Boolean(process.env.VERCEL_DEPLOYMENT_ID?.trim()) ||
+    Boolean(process.env.VERCEL_ENV?.trim())
+  );
+}
+
+function hasLinkedBlobStore(): boolean {
+  return Boolean(
+    process.env.BLOB_READ_WRITE_TOKEN?.trim() || process.env.BLOB_STORE_ID?.trim(),
+  );
+}
+
 export interface SeenState {
   itemIds: string[];
   lastRunAt?: string;
@@ -28,9 +42,9 @@ export interface ProofStore {
   saveLastRun(meta: LastRunMeta): Promise<void>;
 }
 
-const SEEN_KV_KEY = "plasm:mcp-radar:seen";
-const LAST_RUN_KV_KEY = "plasm:mcp-radar:last-run";
 const PROOF_BLOB_KEY = "research/mcp-innovations-proof.md";
+const SEEN_BLOB_KEY = "research/seen-hn-items.json";
+const LAST_RUN_BLOB_KEY = "research/last-run.json";
 const PROOF_HEADER = "# MCP Innovations Proof Log\n\n";
 
 function researchDir(agentRoot: string): string {
@@ -52,24 +66,10 @@ function lastRunPath(agentRoot: string): string {
 export function resolveProofStoreBackend(): ProofStoreBackend {
   const explicit = process.env.PLASM_PROOF_STORE_BACKEND?.trim().toLowerCase();
   if (explicit === "fs" || explicit === "vercel") return explicit;
-  const hasKv =
-    Boolean(process.env.KV_REST_API_URL?.trim()) ||
-    Boolean(process.env.PLASM_KV_REST_API_URL?.trim());
-  const hasBlob = Boolean(process.env.BLOB_READ_WRITE_TOKEN?.trim());
-  if (hasKv && hasBlob) return "vercel";
+  if (isVercelHosted() || hasLinkedBlobStore()) return "vercel";
   return "fs";
 }
 
-type KvClient = {
-  get<T>(key: string): Promise<T | null>;
-  set(key: string, value: unknown): Promise<unknown>;
-};
-
-async function loadKv(): Promise<KvClient> {
-  const mod = await import("@vercel/kv");
-  return mod.kv as KvClient;
-}
-
 async function blobGetText(key: string): Promise<string | null> {
   const { head } = await import("@vercel/blob");
   const meta = await head(key).catch(() => null);
@@ -84,6 +84,26 @@ async function blobPutText(key: string, body: string): Promise<void> {
   await put(key, body, { access: "public", addRandomSuffix: false });
 }
 
+async function blobGetJson<T>(key: string): Promise<T | null> {
+  const text = await blobGetText(key);
+  if (!text) return null;
+  return JSON.parse(text) as T;
+}
+
+async function blobPutJson(key: string, value: unknown): Promise<void> {
+  await blobPutText(key, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function parseSeenState(parsed: SeenState | null): SeenState {
+  if (!parsed) return { itemIds: [] };
+  return {
+    itemIds: Array.isArray(parsed.itemIds) ? parsed.itemIds.map(String) : [],
+    lastRunAt: parsed.lastRunAt,
+    lastRunStatus: parsed.lastRunStatus,
+    lastNewCount: parsed.lastNewCount,
+  };
+}
+
 class FsProofStore implements ProofStore {
   constructor(private readonly agentRoot: string) {}
 
@@ -110,13 +130,7 @@ class FsProofStore implements ProofStore {
   async loadSeenState(): Promise<SeenState> {
     try {
       const raw = await readFile(seenPath(this.agentRoot), "utf8");
-      const parsed = JSON.parse(raw) as SeenState;
-      return {
-        itemIds: Array.isArray(parsed.itemIds) ? parsed.itemIds.map(String) : [],
-        lastRunAt: parsed.lastRunAt,
-        lastRunStatus: parsed.lastRunStatus,
-        lastNewCount: parsed.lastNewCount,
-      };
+      return parseSeenState(JSON.parse(raw) as SeenState);
     } catch {
       return { itemIds: [] };
     }
@@ -171,20 +185,11 @@ class VercelProofStore implements ProofStore {
   }
 
   async loadSeenState(): Promise<SeenState> {
-    const kv = await loadKv();
-    const parsed = await kv.get<SeenState>(SEEN_KV_KEY);
-    if (!parsed) return { itemIds: [] };
-    return {
-      itemIds: Array.isArray(parsed.itemIds) ? parsed.itemIds.map(String) : [],
-      lastRunAt: parsed.lastRunAt,
-      lastRunStatus: parsed.lastRunStatus,
-      lastNewCount: parsed.lastNewCount,
-    };
+    return parseSeenState(await blobGetJson<SeenState>(SEEN_BLOB_KEY));
   }
 
   async saveSeenState(state: SeenState): Promise<void> {
-    const kv = await loadKv();
-    await kv.set(SEEN_KV_KEY, state);
+    await blobPutJson(SEEN_BLOB_KEY, state);
   }
 
   async addSeenIds(ids: string[]): Promise<SeenState> {
@@ -197,13 +202,11 @@ class VercelProofStore implements ProofStore {
   }
 
   async loadLastRun(): Promise<LastRunMeta | null> {
-    const kv = await loadKv();
-    return kv.get<LastRunMeta>(LAST_RUN_KV_KEY);
+    return blobGetJson<LastRunMeta>(LAST_RUN_BLOB_KEY);
   }
 
   async saveLastRun(meta: LastRunMeta): Promise<void> {
-    const kv = await loadKv();
-    await kv.set(LAST_RUN_KV_KEY, meta);
+    await blobPutJson(LAST_RUN_BLOB_KEY, meta);
   }
 }
 
@@ -264,9 +267,5 @@ export function gatewayConfigured(): boolean {
   ) {
     return true;
   }
-  return (
-    process.env.VERCEL === "1" ||
-    Boolean(process.env.VERCEL_DEPLOYMENT_ID?.trim()) ||
-    Boolean(process.env.VERCEL_ENV?.trim())
-  );
+  return isVercelHosted();
 }

package/templates/mcp-radar/lib/run-radar.ts

@@ -134,7 +134,7 @@ export async function runRadar(
       reason: "ai_gateway_missing",
       candidates,
       newCandidates,
-      error: "AI_GATEWAY_API_KEY is required for agent synthesis",
+      error: "AI Gateway is not configured (link project on Vercel or set AI_GATEWAY_API_KEY locally)",
     };
     await saveLastRun(ctx.agentRoot, {
       at: new Date().toISOString(),

package/templates/mcp-radar/lib/start-mcp-radar.ts

@@ -0,0 +1,12 @@
+import type { AuthoringContext } from "@plasm_lang/vercel-agent";
+
+import type { RadarRunOptions } from "./run-radar.js";
+
+export async function startMcpRadarRun(
+  ctx: AuthoringContext,
+  options: RadarRunOptions = {},
+): Promise<unknown> {
+  const { start } = await import("workflow/api");
+  const { mcpRadarScanWorkflow } = await import("../workflows/mcp-radar-scan.js");
+  return start(mcpRadarScanWorkflow, [ctx.agentRoot, options.force === true]);
+}

package/templates/mcp-radar/scripts/provision-vercel-storage.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Eve-aligned Blob bootstrap for mcp-radar on Vercel.
+ * Links a public Blob store to the project (OIDC at runtime — no manual tokens).
+ */
+import { spawnSync } from "node:child_process";
+
+function run(command, args) {
+  const result = spawnSync(command, args, { stdio: "inherit" });
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+console.log("Linking Vercel Blob store (OIDC, public)…");
+run("vercel", ["blob", "create-store", "mcp-radar-proof", "--access", "public", "--yes"]);
+
+console.log("Done. Redeploy so production picks up linked Blob storage.");

package/templates/mcp-radar/workflows/mcp-radar-scan.ts

@@ -0,0 +1,26 @@
+function workflowDispatchUrl(): string {
+  const explicit = process.env.PLASM_WORKFLOW_DISPATCH_URL?.trim();
+  if (explicit) return explicit;
+  const vercelUrl = process.env.VERCEL_URL?.trim();
+  if (vercelUrl) return `https://${vercelUrl}/internal/workflow/dispatch`;
+  const port = process.env.PORT ?? "3000";
+  return `http://127.0.0.1:${port}/internal/workflow/dispatch`;
+}
+
+export async function mcpRadarScanWorkflow(_agentRoot: string, force = false) {
+  "use workflow";
+  return mcpRadarScanStep(force);
+}
+
+async function mcpRadarScanStep(force: boolean) {
+  "use step";
+  const response = await fetch(workflowDispatchUrl(), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ job: "mcp-radar-scan", force }),
+  });
+  if (!response.ok) {
+    throw new Error(`workflow dispatch failed: ${response.status} ${await response.text()}`);
+  }
+  return response.json();
+}