@elizaos/autonomous 2.0.0-alpha.72 → 2.0.0-alpha.73

package/src/api/trigger-routes.ts

@@ -0,0 +1,441 @@
+import crypto from "node:crypto";
+import {
+  type AgentRuntime,
+  stringToUuid,
+  type Task,
+  type UUID,
+} from "@elizaos/core";
+import type { TriggerSummary } from "../triggers/types";
+import type { RouteHelpers, RouteRequestContext } from "./route-helpers";
+
+export type TriggerRouteHelpers = RouteHelpers;
+
+interface TriggerConfigLike {
+  triggerId: string;
+  displayName: string;
+  instructions: string;
+  triggerType: string;
+  wakeMode: string;
+  enabled: boolean;
+  createdBy: string;
+  dedupeKey?: string;
+  intervalMs?: number;
+  scheduledAtIso?: string;
+  cronExpression?: string;
+  maxRuns?: number;
+  nextRunAtMs?: number;
+}
+
+type TriggerTaskMetadataLike = Record<string, unknown> & {
+  triggerRuns?: unknown[];
+};
+
+type TriggerSummaryLike = Partial<TriggerSummary>;
+
+type TriggerDraftLike = {
+  displayName: string;
+  instructions: string;
+  triggerType: string;
+  wakeMode: string;
+  enabled: boolean;
+  createdBy: string;
+  intervalMs?: number;
+  scheduledAtIso?: string;
+  cronExpression?: string;
+  maxRuns?: number;
+};
+
+export interface TriggerRouteContext extends RouteRequestContext {
+  runtime: AgentRuntime | null;
+  executeTriggerTask: (
+    runtime: AgentRuntime,
+    task: Task,
+    options: { source: string; force: boolean },
+  ) => Promise<unknown>;
+  getTriggerHealthSnapshot: (runtime: AgentRuntime) => Promise<object>;
+  getTriggerLimit: (runtime: AgentRuntime) => number;
+  listTriggerTasks: (runtime: AgentRuntime) => Promise<Task[]>;
+  readTriggerConfig: (task: Task) => TriggerConfigLike | null;
+  readTriggerRuns: (task: Task) => unknown[];
+  taskToTriggerSummary: (task: Task) => TriggerSummaryLike | null;
+  triggersFeatureEnabled: (runtime: AgentRuntime) => boolean;
+  buildTriggerConfig: (params: {
+    draft: TriggerDraftLike;
+    triggerId: string;
+    previous?: TriggerConfigLike;
+  }) => TriggerConfigLike;
+  buildTriggerMetadata: (params: {
+    existingMetadata?: TriggerTaskMetadataLike;
+    trigger: TriggerConfigLike;
+    nowMs: number;
+  }) => TriggerTaskMetadataLike | null;
+  normalizeTriggerDraft: (params: {
+    input: Record<string, unknown>;
+    fallback: TriggerDraftLike;
+  }) => { draft?: TriggerDraftLike; error?: string };
+  DISABLED_TRIGGER_INTERVAL_MS: number;
+  TRIGGER_TASK_NAME: string;
+  TRIGGER_TASK_TAGS: string[];
+}
+
+function trim(value: string): string {
+  return value.trim().replace(/\s+/g, " ");
+}
+
+async function findTask(
+  runtime: AgentRuntime,
+  id: string,
+  listTriggerTasks: (runtime: AgentRuntime) => Promise<Task[]>,
+  readTriggerConfig: (task: Task) => TriggerConfigLike | null,
+): Promise<Task | null> {
+  const tasks = await listTriggerTasks(runtime);
+  return (
+    tasks.find((task) => {
+      const trigger = readTriggerConfig(task);
+      return trigger?.triggerId === id || task.id === id;
+    }) ?? null
+  );
+}
+
+export async function handleTriggerRoutes(
+  ctx: TriggerRouteContext,
+): Promise<boolean> {
+  const {
+    method,
+    pathname,
+    req,
+    res,
+    runtime,
+    readJsonBody,
+    json,
+    error,
+    executeTriggerTask,
+    getTriggerHealthSnapshot,
+    getTriggerLimit,
+    listTriggerTasks,
+    readTriggerConfig,
+    readTriggerRuns,
+    taskToTriggerSummary,
+    triggersFeatureEnabled,
+    buildTriggerConfig,
+    buildTriggerMetadata,
+    normalizeTriggerDraft,
+    DISABLED_TRIGGER_INTERVAL_MS,
+    TRIGGER_TASK_NAME,
+    TRIGGER_TASK_TAGS,
+  } = ctx;
+
+  if (!pathname.startsWith("/api/triggers")) return false;
+  if (!runtime) {
+    error(res, "Agent is not running", 503);
+    return true;
+  }
+  if (!triggersFeatureEnabled(runtime) && pathname !== "/api/triggers/health") {
+    error(res, "Triggers are disabled by configuration", 503);
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/triggers/health") {
+    json(res, await getTriggerHealthSnapshot(runtime));
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/triggers") {
+    const tasks = await listTriggerTasks(runtime);
+    const triggers = tasks
+      .map(taskToTriggerSummary)
+      .filter((summary): summary is TriggerSummaryLike => summary !== null)
+      .sort((a, b) =>
+        String(a.displayName ?? "").localeCompare(String(b.displayName ?? "")),
+      );
+    json(res, { triggers });
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/triggers") {
+    const body = await readJsonBody<Record<string, unknown>>(req, res);
+    if (!body) return true;
+
+    const creator =
+      typeof body.createdBy === "string"
+        ? trim(body.createdBy) || "api"
+        : "api";
+    const normalized = normalizeTriggerDraft({
+      input: { ...body, enabled: body.enabled ?? true, createdBy: creator },
+      fallback: {
+        displayName:
+          typeof body.displayName === "string" && trim(body.displayName)
+            ? trim(body.displayName)
+            : "New Trigger",
+        instructions:
+          typeof body.instructions === "string" ? trim(body.instructions) : "",
+        triggerType:
+          typeof body.triggerType === "string" ? body.triggerType : "interval",
+        wakeMode:
+          typeof body.wakeMode === "string" ? body.wakeMode : "inject_now",
+        enabled: body.enabled === undefined ? true : body.enabled === true,
+        createdBy: creator,
+        intervalMs:
+          typeof body.intervalMs === "number" ? body.intervalMs : undefined,
+        scheduledAtIso:
+          typeof body.scheduledAtIso === "string"
+            ? body.scheduledAtIso
+            : undefined,
+        cronExpression:
+          typeof body.cronExpression === "string"
+            ? body.cronExpression
+            : undefined,
+        maxRuns: typeof body.maxRuns === "number" ? body.maxRuns : undefined,
+      },
+    });
+    if (!normalized.draft) {
+      error(res, normalized.error ?? "Invalid trigger request", 400);
+      return true;
+    }
+
+    const existingTasks = await listTriggerTasks(runtime);
+    const activeCount = existingTasks.filter((task) => {
+      const trigger = readTriggerConfig(task);
+      return trigger?.enabled && trigger.createdBy === creator;
+    }).length;
+    const limit = getTriggerLimit(runtime);
+    if (activeCount >= limit) {
+      error(res, `Active trigger limit reached (${limit})`, 429);
+      return true;
+    }
+
+    const triggerId = stringToUuid(crypto.randomUUID());
+    const trigger = buildTriggerConfig({ draft: normalized.draft, triggerId });
+
+    const duplicate = existingTasks.find((task) => {
+      const existingTrigger = readTriggerConfig(task);
+      return (
+        existingTrigger?.enabled &&
+        existingTrigger.dedupeKey &&
+        existingTrigger.dedupeKey === trigger.dedupeKey
+      );
+    });
+    if (duplicate?.id) {
+      error(res, "Equivalent trigger already exists", 409);
+      return true;
+    }
+
+    const metadata = buildTriggerMetadata({ trigger, nowMs: Date.now() });
+    if (!metadata) {
+      error(res, "Unable to compute trigger schedule", 400);
+      return true;
+    }
+
+    const roomId = (
+      runtime.getService("AUTONOMY") as { getAutonomousRoomId?(): UUID } | null
+    )?.getAutonomousRoomId?.();
+    const taskId = await runtime.createTask({
+      name: TRIGGER_TASK_NAME,
+      description: trigger.displayName,
+      roomId,
+      tags: [...TRIGGER_TASK_TAGS],
+      metadata: metadata as Task["metadata"],
+    });
+    const created = await runtime.getTask(taskId);
+    const summary = created ? taskToTriggerSummary(created) : null;
+    if (!summary) {
+      error(res, "Trigger created but summary could not be generated", 500);
+      return true;
+    }
+    json(res, { trigger: summary }, 201);
+    return true;
+  }
+
+  const runsMatch = /^\/api\/triggers\/([^/]+)\/runs$/.exec(pathname);
+  if (method === "GET" && runsMatch) {
+    const task = await findTask(
+      runtime,
+      decodeURIComponent(runsMatch[1]),
+      listTriggerTasks,
+      readTriggerConfig,
+    );
+    if (!task) {
+      error(res, "Trigger not found", 404);
+      return true;
+    }
+    json(res, { runs: readTriggerRuns(task) });
+    return true;
+  }
+
+  const execMatch = /^\/api\/triggers\/([^/]+)\/execute$/.exec(pathname);
+  if (method === "POST" && execMatch) {
+    const task = await findTask(
+      runtime,
+      decodeURIComponent(execMatch[1]),
+      listTriggerTasks,
+      readTriggerConfig,
+    );
+    if (!task) {
+      error(res, "Trigger not found", 404);
+      return true;
+    }
+    const result = await executeTriggerTask(runtime, task, {
+      source: "manual",
+      force: true,
+    });
+    const refreshed = task.id ? await runtime.getTask(task.id) : null;
+    json(res, {
+      ok: true,
+      result,
+      trigger: refreshed ? taskToTriggerSummary(refreshed) : null,
+    });
+    return true;
+  }
+
+  const itemMatch = /^\/api\/triggers\/([^/]+)$/.exec(pathname);
+  if (!itemMatch) return false;
+  const triggerId = decodeURIComponent(itemMatch[1]);
+
+  if (method === "GET") {
+    const task = await findTask(
+      runtime,
+      triggerId,
+      listTriggerTasks,
+      readTriggerConfig,
+    );
+    if (!task) {
+      error(res, "Trigger not found", 404);
+      return true;
+    }
+    const summary = taskToTriggerSummary(task);
+    if (!summary) {
+      error(res, "Trigger metadata is invalid", 500);
+      return true;
+    }
+    json(res, { trigger: summary });
+    return true;
+  }
+
+  if (method === "DELETE") {
+    const task = await findTask(
+      runtime,
+      triggerId,
+      listTriggerTasks,
+      readTriggerConfig,
+    );
+    if (!task?.id) {
+      error(res, "Trigger not found", 404);
+      return true;
+    }
+    await runtime.deleteTask(task.id);
+    json(res, { ok: true });
+    return true;
+  }
+
+  if (method === "PUT") {
+    const task = await findTask(
+      runtime,
+      triggerId,
+      listTriggerTasks,
+      readTriggerConfig,
+    );
+    if (!task?.id) {
+      error(res, "Trigger not found", 404);
+      return true;
+    }
+    const current = readTriggerConfig(task);
+    if (!current) {
+      error(res, "Trigger metadata is invalid", 500);
+      return true;
+    }
+
+    const body = await readJsonBody<Record<string, unknown>>(req, res);
+    if (!body) return true;
+
+    const merged = {
+      ...body,
+      createdBy: current.createdBy,
+      intervalMs:
+        typeof body.intervalMs === "number"
+          ? body.intervalMs
+          : current.intervalMs,
+      scheduledAtIso:
+        typeof body.scheduledAtIso === "string"
+          ? body.scheduledAtIso
+          : current.scheduledAtIso,
+      cronExpression:
+        typeof body.cronExpression === "string"
+          ? body.cronExpression
+          : current.cronExpression,
+      maxRuns:
+        typeof body.maxRuns === "number" ? body.maxRuns : current.maxRuns,
+    };
+    const normalized = normalizeTriggerDraft({
+      input: merged,
+      fallback: {
+        displayName: current.displayName,
+        instructions: current.instructions,
+        triggerType: current.triggerType,
+        wakeMode: current.wakeMode,
+        enabled:
+          body.enabled === undefined ? current.enabled : body.enabled === true,
+        createdBy: current.createdBy,
+        intervalMs: current.intervalMs,
+        scheduledAtIso: current.scheduledAtIso,
+        cronExpression: current.cronExpression,
+        maxRuns: current.maxRuns,
+      },
+    });
+    if (!normalized.draft) {
+      error(res, normalized.error ?? "Invalid update", 400);
+      return true;
+    }
+
+    const nextTrigger = buildTriggerConfig({
+      draft: normalized.draft,
+      triggerId: current.triggerId,
+      previous: current,
+    });
+    const existingMeta = (task.metadata ?? {}) as TriggerTaskMetadataLike;
+    const existingRuns = readTriggerRuns(task);
+
+    let nextMeta: TriggerTaskMetadataLike;
+    if (!nextTrigger.enabled) {
+      nextMeta = {
+        ...existingMeta,
+        updatedAt: Date.now(),
+        updateInterval: DISABLED_TRIGGER_INTERVAL_MS,
+        trigger: {
+          ...nextTrigger,
+          nextRunAtMs: Date.now() + DISABLED_TRIGGER_INTERVAL_MS,
+        },
+        triggerRuns: existingRuns,
+      };
+    } else {
+      const built = buildTriggerMetadata({
+        existingMetadata: existingMeta,
+        trigger: nextTrigger,
+        nowMs: Date.now(),
+      });
+      if (!built) {
+        error(res, "Unable to compute trigger schedule", 400);
+        return true;
+      }
+      nextMeta = built;
+    }
+
+    await runtime.updateTask(task.id, {
+      description: nextTrigger.displayName,
+      metadata: nextMeta as Task["metadata"],
+    });
+    const refreshed = await runtime.getTask(task.id);
+    if (!refreshed) {
+      error(res, "Trigger updated but no longer available", 500);
+      return true;
+    }
+    const summary = taskToTriggerSummary(refreshed);
+    if (!summary) {
+      error(res, "Trigger metadata is invalid", 500);
+      return true;
+    }
+    json(res, { trigger: summary });
+    return true;
+  }
+
+  return false;
+}

package/src/api/twitter-verify.ts

@@ -0,0 +1,226 @@
+/**
+ * Twitter/X verification for whitelist eligibility.
+ *
+ * Users post a verification message on X containing their agent name and
+ * wallet address. The app verifies the tweet exists using the FxTwitter API
+ * (free, no auth required). Verified addresses are stored locally and can
+ * be collected into a Merkle tree for on-chain whitelist proofs.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import { resolveStateDir } from "../config/paths";
+import type { VerificationResult } from "../contracts/verification";
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability";
+
+export type { VerificationResult } from "../contracts/verification";
+
+const WHITELIST_FILE = "whitelist.json";
+
+// ── Types ────────────────────────────────────────────────────────────────
+
+interface WhitelistEntry {
+  timestamp: string;
+  tweetUrl: string;
+  handle: string;
+}
+
+interface WhitelistData {
+  verified: Record<string, WhitelistEntry>;
+}
+
+// ── Verification Message ─────────────────────────────────────────────────
+
+export function generateVerificationMessage(
+  agentName: string,
+  walletAddress: string,
+): string {
+  const shortAddr = `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}`;
+  return `Verifying my Eliza agent "${agentName}" | ${shortAddr} #ElizaAgent`;
+}
+
+// ── Tweet Verification ───────────────────────────────────────────────────
+
+function parseTweetUrl(
+  url: string,
+): { screenName: string; tweetId: string } | null {
+  const match = url.match(/(?:twitter\.com|x\.com)\/(\w+)\/status\/(\d+)/);
+  if (!match) return null;
+  return { screenName: match[1], tweetId: match[2] };
+}
+
+export async function verifyTweet(
+  tweetUrl: string,
+  walletAddress: string,
+): Promise<VerificationResult> {
+  const parsed = parseTweetUrl(tweetUrl);
+  if (!parsed) {
+    return {
+      verified: false,
+      error: "Invalid tweet URL. Use a twitter.com or x.com status URL.",
+      handle: null,
+    };
+  }
+
+  const apiUrl = `https://api.fxtwitter.com/${parsed.screenName}/status/${parsed.tweetId}`;
+
+  const verifySpan = createIntegrationTelemetrySpan({
+    boundary: "marketplace",
+    operation: "verify_tweet",
+    timeoutMs: 15_000,
+  });
+
+  let response: Response;
+  try {
+    response = await fetch(apiUrl, {
+      headers: { "User-Agent": "ElizaVerifier/1.0" },
+      signal: AbortSignal.timeout(15_000),
+    });
+  } catch (err) {
+    verifySpan.failure({ error: err });
+    logger.warn(`[twitter-verify] FxTwitter fetch failed: ${err}`);
+    return {
+      verified: false,
+      error: "Could not reach tweet verification service. Try again later.",
+      handle: null,
+    };
+  }
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      verifySpan.success({ statusCode: 404 });
+      return {
+        verified: false,
+        error:
+          "Tweet not found. Make sure the URL is correct and the tweet is public.",
+        handle: null,
+      };
+    }
+    verifySpan.failure({
+      statusCode: response.status,
+      errorKind: "http_error",
+    });
+    return {
+      verified: false,
+      error: `Tweet fetch failed (HTTP ${response.status})`,
+      handle: null,
+    };
+  }
+
+  let data: {
+    code?: number;
+    tweet?: {
+      text?: string;
+      author?: { screen_name?: string };
+    };
+  };
+
+  try {
+    data = (await response.json()) as typeof data;
+  } catch (err) {
+    verifySpan.failure({ error: err, statusCode: response.status });
+    return {
+      verified: false,
+      error: "Invalid response from verification service",
+      handle: null,
+    };
+  }
+
+  if (!data.tweet?.text) {
+    verifySpan.failure({
+      statusCode: response.status,
+      errorKind: "empty_content",
+    });
+    return {
+      verified: false,
+      error: "Could not read tweet content",
+      handle: null,
+    };
+  }
+
+  const tweetText = data.tweet.text;
+  const handle = data.tweet.author?.screen_name ?? parsed.screenName;
+
+  const shortAddr = `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}`;
+  const hasAddress =
+    tweetText.includes(shortAddr) ||
+    tweetText.toLowerCase().includes(walletAddress.toLowerCase().slice(0, 10));
+  const hasHashtag = tweetText.includes("#ElizaAgent");
+
+  if (!hasAddress) {
+    return {
+      verified: false,
+      error:
+        "Tweet does not contain your wallet address. Make sure you copied the full verification message.",
+      handle,
+    };
+  }
+  if (!hasHashtag) {
+    return {
+      verified: false,
+      error: "Tweet is missing #ElizaAgent hashtag.",
+      handle,
+    };
+  }
+
+  verifySpan.success({ statusCode: response.status });
+  return { verified: true, error: null, handle };
+}
+
+// ── Whitelist Storage ────────────────────────────────────────────────────
+
+function whitelistPath(): string {
+  return path.join(resolveStateDir(), WHITELIST_FILE);
+}
+
+export function loadWhitelist(): WhitelistData {
+  const filePath = whitelistPath();
+  if (!fs.existsSync(filePath)) return { verified: {} };
+  const raw = fs.readFileSync(filePath, "utf-8");
+  try {
+    return JSON.parse(raw) as WhitelistData;
+  } catch {
+    logger.warn(
+      `[twitter-verify] Corrupt whitelist file, resetting: ${filePath}`,
+    );
+    return { verified: {} };
+  }
+}
+
+function saveWhitelist(data: WhitelistData): void {
+  const filePath = whitelistPath();
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+    encoding: "utf-8",
+    mode: 0o600,
+  });
+}
+
+export function markAddressVerified(
+  address: string,
+  tweetUrl: string,
+  handle: string,
+): void {
+  const wl = loadWhitelist();
+  wl.verified[address.toLowerCase()] = {
+    timestamp: new Date().toISOString(),
+    tweetUrl,
+    handle,
+  };
+  saveWhitelist(wl);
+  logger.info(`[twitter-verify] Address ${address} verified via @${handle}`);
+}
+
+export function isAddressWhitelisted(address: string): boolean {
+  const wl = loadWhitelist();
+  return address.toLowerCase() in wl.verified;
+}
+
+export function getVerifiedAddresses(): string[] {
+  const wl = loadWhitelist();
+  return Object.keys(wl.verified);
+}