@plasm_lang/vercel-agent 0.3.111 → 0.3.113

package/templates/mcp-radar/lib/hn-algolia-preflight.ts

@@ -0,0 +1,42 @@
+/** Direct Algolia HN search for MCP radar preflight (no Plasm stub / engine required). */
+
+const ALGOLIA_SEARCH_BY_DATE = "https://hn.algolia.com/api/v1/search_by_date";
+
+export interface AlgoliaHit {
+  objectID: string;
+  title?: string;
+  url?: string;
+}
+
+export interface HnAlgoliaStoryRow {
+  id: string;
+  title?: string;
+  url?: string;
+}
+
+export async function fetchHnMcpStoriesByDate(options: {
+  query: string;
+  tags?: string;
+  perPage?: number;
+}): Promise<HnAlgoliaStoryRow[]> {
+  const params = new URLSearchParams({
+    query: options.query,
+    tags: options.tags ?? "story",
+    hitsPerPage: String(options.perPage ?? 30),
+  });
+  const url = `${ALGOLIA_SEARCH_BY_DATE}?${params.toString()}`;
+  const response = await fetch(url, {
+    headers: { accept: "application/json" },
+  });
+  if (!response.ok) {
+    throw new Error(`Algolia HN search_by_date failed: ${response.status} ${response.statusText}`);
+  }
+  const payload = (await response.json()) as { hits?: AlgoliaHit[] };
+  return (payload.hits ?? [])
+    .map((hit) => ({
+      id: String(hit.objectID ?? ""),
+      title: hit.title,
+      url: hit.url,
+    }))
+    .filter((row) => row.id.length > 0);
+}

package/templates/mcp-radar/lib/instructions.md

@@ -0,0 +1,36 @@
+# MCP Radar
+
+You track **Model Context Protocol (MCP)** innovation on Hacker News, corroborate with Tavily, and **publish** to a live **Proof** document — all via **Plasm programs** in one federated execute session.
+
+## Tool order (mandatory)
+
+1. **`discover_capabilities`** — only when unsure which catalog entities to use.
+2. **`plasm_context`** — open or extend a session with seeds:
+   - `hackernews:Item`
+   - `tavily:SearchResult`
+   - `proof:Document`
+   - **Stable intent** (same every turn): `track MCP innovations from Hacker News and corroborate with Tavily web search`
+3. **`plasm`** — dry-run programs using teaching TSV symbols (`e#`, `m#`, `p#`, `r#`).
+4. **`plasm_run`** — live execute reviewed plans (`pcN` only).
+
+Reuse **`logical_session_ref`** across the whole radar cycle. Do not open a new context per story.
+
+## HN search (Plasm)
+
+Use `item_search_by_date` (or `item_search`) with an MCP-focused query, e.g.:
+
+`"Model Context Protocol" OR MCP server OR MCP tool`
+
+Filter to stories **about MCP** — not general Hacker News. Skip ids already in the Proof document body (read via `document_get_markdown` first).
+
+## Proof document (Plasm)
+
+See skill **`proof-publish`**: bind share link (`document_share_bind`), `presence_update`, read markdown, append via `document_edit_v2`.
+
+If no document exists yet, `share_link_create` then bind. Do not emit proof only in chat — **`plasm_run` must mutate Proof**.
+
+## Tavily
+
+When Tavily is on the session, corroborate with `web_search`. If unavailable, set **Confidence: low** per `mcp-proof-format`.
+
+Do not invent symbols — copy from the teaching TSV.

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

@@ -0,0 +1,28 @@
+function workflowDispatchUrl(): string {
+  const explicit = process.env.PLASM_WORKFLOW_DISPATCH_URL?.trim();
+  if (explicit) return explicit;
+  const production = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim();
+  if (production) return `https://${production}/internal/workflow/dispatch`;
+  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, reset = false) {
+  "use workflow";
+  return mcpRadarScanStep(force, reset);
+}
+
+async function mcpRadarScanStep(force: boolean, reset: boolean) {
+  "use step";
+  const response = await fetch(workflowDispatchUrl(), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ job: "mcp-radar-scan", force, reset }),
+  });
+  if (!response.ok) {
+    throw new Error(`workflow dispatch failed: ${response.status} ${await response.text()}`);
+  }
+  return response.json();
+}

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

@@ -0,0 +1,92 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import { waitUntil } from "@vercel/functions";
+import { defineChannel } from "@plasm_lang/vercel-agent";
+
+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) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
+      if (!body.trim()) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(body));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function sendJson(res: ServerResponse, status: number, payload: unknown): void {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(payload, null, 2));
+}
+
+export default defineChannel({
+  name: "mcp-radar",
+  routes: [
+    {
+      method: "POST",
+      path: "/channel/mcp-radar/run",
+      handler: async (req, res, ctx) => {
+        const body = (await readJsonBody(req)) as { force?: boolean; reset?: boolean };
+        const options = {
+          force: body.force === true,
+          reset: body.reset === true,
+        };
+
+        if (process.env.VERCEL === "1") {
+          waitUntil(
+            startMcpRadarRun(ctx, options).catch((err: unknown) => {
+              console.error("[mcp-radar] workflow start failed:", err);
+            }),
+          );
+          sendJson(res, 202, { accepted: true, workflow: true });
+          return;
+        }
+
+        const run = await startMcpRadarRun(ctx, options);
+        sendJson(res, 200, { accepted: true, workflow: true, run });
+      },
+    },
+    {
+      method: "POST",
+      path: "/channel/mcp-radar/reset",
+      handler: async (_req, res, _ctx) => {
+        sendJson(res, 200, {
+          ok: true,
+          message: 'Trigger POST /channel/mcp-radar/run with {"reset":true}',
+        });
+      },
+    },
+    {
+      method: "GET",
+      path: "/channel/mcp-radar/proof",
+      handler: async (_req, res, _ctx) => {
+        sendJson(res, 200, {
+          note: "Proof document lives in the proof catalog; read/write via agent Plasm session.",
+          sessions: "/operator/sessions",
+          runs: "/operator/runs",
+        });
+      },
+    },
+    {
+      method: "GET",
+      path: "/channel/mcp-radar/status",
+      handler: async (_req, res, ctx) => {
+        sendJson(res, 200, await radarStatus(ctx.agentRoot));
+      },
+    },
+  ],
+});

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

@@ -0,0 +1,43 @@
+const PROOF_HEADING = /^###\s+\[/;
+
+/** Keep only `### [...]` proof blocks; drop agent preamble and troubleshooting narration. */
+export function extractProofMarkdown(raw: string): string {
+  const lines = raw.split(/\r?\n/);
+  const blocks: string[] = [];
+  let current: string[] = [];
+
+  const flush = () => {
+    if (current.length === 0) return;
+    const block = current.join("\n").trim();
+    if (block) blocks.push(block);
+    current = [];
+  };
+
+  for (const line of lines) {
+    if (PROOF_HEADING.test(line)) {
+      flush();
+      current.push(line);
+      continue;
+    }
+    if (current.length > 0) {
+      const trimmed = line.trim();
+      if (trimmed === "") {
+        current.push(line);
+        continue;
+      }
+      if (line.startsWith("- ") || line.startsWith("* ")) {
+        current.push(line);
+        continue;
+      }
+      flush();
+    }
+  }
+  flush();
+
+  return blocks.join("\n\n").trim();
+}
+
+export function isMcpRelevant(title?: string, url?: string): boolean {
+  const haystack = `${title ?? ""} ${url ?? ""}`;
+  return /\b(MCP|Model Context Protocol|model[- ]context)\b/i.test(haystack);
+}

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

@@ -27,6 +27,8 @@ export interface LastRunMeta {
   status: "ok" | "skipped" | "error";
   newItems: number;
   message?: string;
+  runIds?: string[];
+  logicalSessionRef?: string;
 }
 
 export type ProofStoreBackend = "fs" | "vercel";
@@ -35,6 +37,7 @@ export interface ProofStore {
   backend(): ProofStoreBackend;
   readProofMarkdown(): Promise<string>;
   appendProofRun(section: { runAt: string; body: string }): Promise<void>;
+  resetProofState(): Promise<void>;
   loadSeenState(): Promise<SeenState>;
   saveSeenState(state: SeenState): Promise<void>;
   addSeenIds(ids: string[]): Promise<SeenState>;
@@ -127,6 +130,26 @@ class FsProofStore implements ProofStore {
     await appendFile(proofPath(this.agentRoot), `${header}${block}\n`, "utf8");
   }
 
+  async resetProofState(): Promise<void> {
+    await mkdir(researchDir(this.agentRoot), { recursive: true });
+    await writeFile(proofPath(this.agentRoot), PROOF_HEADER, "utf8");
+    await writeFile(seenPath(this.agentRoot), `${JSON.stringify({ itemIds: [] }, null, 2)}\n`, "utf8");
+    await writeFile(
+      lastRunPath(this.agentRoot),
+      `${JSON.stringify(
+        {
+          at: new Date().toISOString(),
+          status: "skipped",
+          newItems: 0,
+          message: "reset",
+        } satisfies LastRunMeta,
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+  }
+
   async loadSeenState(): Promise<SeenState> {
     try {
       const raw = await readFile(seenPath(this.agentRoot), "utf8");
@@ -184,6 +207,17 @@ class VercelProofStore implements ProofStore {
     await blobPutText(PROOF_BLOB_KEY, `${existing}${header}${block}\n`);
   }
 
+  async resetProofState(): Promise<void> {
+    await blobPutText(PROOF_BLOB_KEY, PROOF_HEADER);
+    await blobPutJson(SEEN_BLOB_KEY, { itemIds: [] });
+    await blobPutJson(LAST_RUN_BLOB_KEY, {
+      at: new Date().toISOString(),
+      status: "skipped",
+      newItems: 0,
+      message: "reset",
+    });
+  }
+
   async loadSeenState(): Promise<SeenState> {
     return parseSeenState(await blobGetJson<SeenState>(SEEN_BLOB_KEY));
   }
@@ -235,6 +269,10 @@ export async function appendProofRun(
   return resolveProofStore(agentRoot).appendProofRun(section);
 }
 
+export async function resetProofState(agentRoot: string): Promise<void> {
+  return resolveProofStore(agentRoot).resetProofState();
+}
+
 export async function loadSeenState(agentRoot: string): Promise<SeenState> {
   return resolveProofStore(agentRoot).loadSeenState();
 }

package/templates/mcp-radar/lib/provision-vercel.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * Eve-aligned Vercel bootstrap for mcp-radar:
+ * - Sync secrets from monorepo `.env` → Vercel project env
+ */
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(scriptDir, "..");
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, options);
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+  return result;
+}
+
+function parseEnvFile(filePath) {
+  const vars = new Map();
+  if (!existsSync(filePath)) return vars;
+  const text = readFileSync(filePath, "utf8");
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const withoutExport = trimmed.startsWith("export ")
+      ? trimmed.slice("export ".length).trim()
+      : trimmed;
+    const eq = withoutExport.indexOf("=");
+    if (eq <= 0) continue;
+    const key = withoutExport.slice(0, eq).trim();
+    let value = withoutExport.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    vars.set(key, value);
+  }
+  return vars;
+}
+
+function resolveMonorepoEnv() {
+  const files = [];
+  let dir = projectRoot;
+  for (let depth = 0; depth < 8; depth++) {
+    const candidate = path.join(dir, ".env");
+    if (existsSync(candidate)) files.push(candidate);
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const merged = new Map();
+  for (const file of files.reverse()) {
+    for (const [key, value] of parseEnvFile(file)) {
+      if (value.trim()) merged.set(key, value);
+    }
+  }
+  return merged;
+}
+
+function envAlreadySet(name) {
+  const result = run("vercel", ["env", "ls"], { encoding: "utf8", stdio: ["inherit", "pipe", "inherit"] });
+  return (result.stdout ?? "").includes(name);
+}
+
+function syncEnvVar(name, value) {
+  if (!value?.trim()) {
+    console.warn(`[provision] skip ${name}: not found in monorepo .env`);
+    return;
+  }
+  if (envAlreadySet(name)) {
+    console.log(`[provision] ${name} already set on Vercel — skipping`);
+    return;
+  }
+  for (const target of ["production", "preview"]) {
+    console.log(`[provision] adding ${name} → ${target}…`);
+    run("vercel", ["env", "add", name, target], {
+      input: value,
+      stdio: ["pipe", "inherit", "inherit"],
+    });
+  }
+}
+
+const env = resolveMonorepoEnv();
+
+console.log("Syncing env from monorepo .env → Vercel project…");
+syncEnvVar("TAVILY_API_TOKEN", env.get("TAVILY_API_TOKEN"));
+syncEnvVar("PLASM_TENANT_SCOPE", env.get("PLASM_TENANT_SCOPE") ?? "mcp-radar");
+syncEnvVar("PROOF_API_TOKEN", env.get("PROOF_API_TOKEN"));
+syncEnvVar("PROOF_SHARE_URL", env.get("PROOF_SHARE_URL"));
+syncEnvVar("PROOF_DOCUMENT_SLUG", env.get("PROOF_DOCUMENT_SLUG"));
+
+console.log("Done. Redeploy production so env bindings take effect.");

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

@@ -0,0 +1,53 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export interface LastRunMeta {
+  at: string;
+  status: "ok" | "skipped" | "error";
+  message?: string;
+  runIds?: string[];
+  logicalSessionRef?: string;
+}
+
+function researchDir(agentRoot: string): string {
+  return path.join(agentRoot, ".plasm", "research");
+}
+
+function lastRunPath(agentRoot: string): string {
+  return path.join(researchDir(agentRoot), "last-run.json");
+}
+
+export async function loadLastRun(agentRoot: string): Promise<LastRunMeta | null> {
+  try {
+    const raw = await readFile(lastRunPath(agentRoot), "utf8");
+    return JSON.parse(raw) as LastRunMeta;
+  } catch {
+    return null;
+  }
+}
+
+export async function saveLastRun(agentRoot: string, meta: LastRunMeta): Promise<void> {
+  await mkdir(researchDir(agentRoot), { recursive: true });
+  await writeFile(lastRunPath(agentRoot), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+}
+
+/** Host infra — not a substitute for Plasm catalog calls. */
+export function gatewayConfigured(): boolean {
+  if (
+    process.env.AI_GATEWAY_API_KEY?.trim() ||
+    process.env.AI_API_GATEWAY_KEY?.trim() ||
+    process.env.AI_GATEWAY_KEY?.trim()
+  ) {
+    return true;
+  }
+  return (
+    process.env.VERCEL === "1" ||
+    Boolean(process.env.VERCEL_DEPLOYMENT_ID?.trim()) ||
+    Boolean(process.env.VERCEL_ENV?.trim())
+  );
+}
+
+/** Outbound Tavily auth present on host — agent still calls Tavily via Plasm. */
+export function tavilyConfigured(): boolean {
+  return Boolean(process.env.TAVILY_API_TOKEN?.trim());
+}

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

@@ -0,0 +1,41 @@
+export interface RunAuditRecord {
+  runIds: string[];
+  planCommitRefs: string[];
+  logicalSessionRef?: string;
+  intent?: string;
+}
+
+let pending: RunAuditRecord = {
+  runIds: [],
+  planCommitRefs: [],
+};
+
+export function resetRunAudit(): void {
+  pending = { runIds: [], planCommitRefs: [] };
+}
+
+export function recordRunAudit(detail: Record<string, unknown>): void {
+  const runId = typeof detail.runId === "string" ? detail.runId : undefined;
+  const planCommitRef =
+    typeof detail.planCommitRef === "string"
+      ? detail.planCommitRef
+      : typeof detail.runRef === "string"
+        ? detail.runRef
+        : undefined;
+  const logicalSessionRef =
+    typeof detail.logicalSessionRef === "string" ? detail.logicalSessionRef : undefined;
+  const intent = typeof detail.intent === "string" ? detail.intent : undefined;
+
+  if (runId && !pending.runIds.includes(runId)) pending.runIds.push(runId);
+  if (planCommitRef && !pending.planCommitRefs.includes(planCommitRef)) {
+    pending.planCommitRefs.push(planCommitRef);
+  }
+  if (logicalSessionRef) pending.logicalSessionRef = logicalSessionRef;
+  if (intent) pending.intent = intent;
+}
+
+export function drainRunAudit(): RunAuditRecord {
+  const snapshot = { ...pending, runIds: [...pending.runIds], planCommitRefs: [...pending.planCommitRefs] };
+  resetRunAudit();
+  return snapshot;
+}