@elizaos/autonomous 2.0.0-alpha.10

package/src/api/diagnostics-routes.ts

@@ -0,0 +1,389 @@
+import type http from "node:http";
+import { parseClampedInteger } from "../utils/number-parsing";
+import type { RouteHelpers, RouteRequestMeta } from "./route-helpers";
+
+interface LogEntryLike {
+  timestamp: number;
+  level: string;
+  source: string;
+  tags: string[];
+}
+
+interface StreamEventEnvelopeLike {
+  type: string;
+  eventId: string;
+  runId?: string;
+  seq?: number;
+}
+
+interface AuditEntryLike {
+  timestamp: string;
+  type: string;
+  summary: string;
+  severity: string;
+  metadata?: Record<string, string | number | boolean | null>;
+}
+
+type DiagnosticsSseInit = (res: http.ServerResponse) => void;
+type DiagnosticsSseWriteJson = (
+  res: http.ServerResponse,
+  payload: object,
+  event?: string,
+) => void;
+
+export interface DiagnosticsRouteContext
+  extends RouteRequestMeta,
+    Pick<RouteHelpers, "json"> {
+  url: URL;
+  logBuffer: LogEntryLike[];
+  eventBuffer: StreamEventEnvelopeLike[];
+  relayPort?: number;
+  checkRelayReachable?: (relayPort: number) => Promise<boolean>;
+  resolveExtensionPath?: () => string | null;
+  initSse?: DiagnosticsSseInit;
+  writeSseJson?: DiagnosticsSseWriteJson;
+  auditEventTypes: readonly string[];
+  auditSeverities: readonly string[];
+  getAuditFeedSize: () => number;
+  queryAuditFeed: (query: {
+    type?: string;
+    severity?: string;
+    sinceMs?: number;
+    limit?: number;
+  }) => AuditEntryLike[];
+  subscribeAuditFeed: (
+    subscriber: (entry: AuditEntryLike) => void,
+  ) => () => void;
+}
+
+async function defaultCheckRelayReachable(relayPort: number): Promise<boolean> {
+  try {
+    const response = await fetch(`http://127.0.0.1:${relayPort}/`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(2000),
+    });
+    return response.ok || response.status < 500;
+  } catch {
+    return false;
+  }
+}
+
+function defaultResolveExtensionPath(): string | null {
+  return null;
+}
+
+function isAutonomyEvent(event: StreamEventEnvelopeLike): boolean {
+  return event.type === "agent_event" || event.type === "heartbeat_event";
+}
+
+function defaultInitSse(res: http.ServerResponse): void {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no",
+  });
+}
+
+function defaultWriteSseData(
+  res: http.ServerResponse,
+  data: string,
+  event?: string,
+): void {
+  if (event) {
+    res.write(`event: ${event}\n`);
+  }
+  const safe = data.replace(/\r?\n/g, "\ndata: ");
+  res.write(`data: ${safe}\n\n`);
+}
+
+function defaultWriteSseJson(
+  res: http.ServerResponse,
+  payload: object,
+  event?: string,
+): void {
+  defaultWriteSseData(res, JSON.stringify(payload), event);
+}
+
+function parseAuditSince(raw: string | null): {
+  value?: number;
+  error?: string;
+} {
+  if (raw == null) return {};
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return {
+      error: 'Invalid "since" filter: expected epoch ms or ISO timestamp.',
+    };
+  }
+
+  const numeric = Number(trimmed);
+  if (Number.isFinite(numeric)) {
+    return { value: Math.trunc(numeric) };
+  }
+
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) {
+    return {
+      error: 'Invalid "since" filter: expected epoch ms or ISO timestamp.',
+    };
+  }
+  return { value: parsed };
+}
+
+function isTruthyQueryParam(value: string | null): boolean {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return (
+    normalized === "1" ||
+    normalized === "true" ||
+    normalized === "yes" ||
+    normalized === "on"
+  );
+}
+
+function matchesAuditFilter(
+  entry: AuditEntryLike,
+  filters: {
+    type?: string;
+    severity?: string;
+    sinceMs?: number;
+  },
+): boolean {
+  if (filters.type && entry.type !== filters.type) return false;
+  if (filters.severity && entry.severity !== filters.severity) return false;
+  if (
+    filters.sinceMs !== undefined &&
+    Date.parse(entry.timestamp) < filters.sinceMs
+  ) {
+    return false;
+  }
+  return true;
+}
+
+export async function handleDiagnosticsRoutes(
+  ctx: DiagnosticsRouteContext,
+): Promise<boolean> {
+  const {
+    req,
+    res,
+    method,
+    pathname,
+    url,
+    logBuffer,
+    eventBuffer,
+    relayPort: relayPortOverride,
+    checkRelayReachable,
+    resolveExtensionPath,
+    initSse,
+    writeSseJson,
+    auditEventTypes,
+    auditSeverities,
+    getAuditFeedSize,
+    queryAuditFeed,
+    subscribeAuditFeed,
+    json,
+  } = ctx;
+
+  if (method === "GET" && pathname === "/api/logs") {
+    let entries = logBuffer;
+
+    const sourceFilter = url.searchParams.get("source");
+    if (sourceFilter) {
+      entries = entries.filter((entry) => entry.source === sourceFilter);
+    }
+
+    const levelFilter = url.searchParams.get("level");
+    if (levelFilter) {
+      entries = entries.filter((entry) => entry.level === levelFilter);
+    }
+
+    const tagFilter = url.searchParams.get("tag");
+    if (tagFilter) {
+      entries = entries.filter((entry) => entry.tags.includes(tagFilter));
+    }
+
+    const sinceFilter = url.searchParams.get("since");
+    if (sinceFilter) {
+      const sinceTimestamp = Number(sinceFilter);
+      if (!Number.isNaN(sinceTimestamp)) {
+        entries = entries.filter((entry) => entry.timestamp >= sinceTimestamp);
+      }
+    }
+
+    const sources = [...new Set(logBuffer.map((entry) => entry.source))].sort();
+    const tags = [...new Set(logBuffer.flatMap((entry) => entry.tags))].sort();
+    json(res, { entries: entries.slice(-200), sources, tags });
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/agent/events") {
+    const limit = parseClampedInteger(url.searchParams.get("limit"), {
+      min: 1,
+      max: 1000,
+      fallback: 200,
+    });
+    const runIdFilter = url.searchParams.get("runId");
+    const fromSeqRaw = url.searchParams.get("fromSeq");
+    const fromSeq = parseClampedInteger(fromSeqRaw, {
+      min: 0,
+    });
+    if (fromSeqRaw !== null && fromSeq === undefined) {
+      json(res, { error: 'Invalid "fromSeq" filter.' }, 400);
+      return true;
+    }
+    const afterEventId = url.searchParams.get("after");
+    let autonomyEvents = eventBuffer.filter(isAutonomyEvent);
+    if (runIdFilter) {
+      autonomyEvents = autonomyEvents.filter(
+        (event) => event.runId === runIdFilter,
+      );
+    }
+    if (fromSeq !== undefined) {
+      autonomyEvents = autonomyEvents.filter(
+        (event) => typeof event.seq === "number" && event.seq >= fromSeq,
+      );
+    }
+
+    let startIndex = 0;
+    if (afterEventId) {
+      const index = autonomyEvents.findIndex(
+        (event) => event.eventId === afterEventId,
+      );
+      if (index >= 0) {
+        startIndex = index + 1;
+      }
+    }
+
+    const events = autonomyEvents.slice(startIndex, startIndex + limit);
+    const latestEventId =
+      events.length > 0 ? events[events.length - 1].eventId : null;
+
+    json(res, {
+      events,
+      latestEventId,
+      totalBuffered: autonomyEvents.length,
+      replayed: true,
+    });
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/security/audit") {
+    const typeFilterRaw = url.searchParams.get("type");
+    const severityFilterRaw = url.searchParams.get("severity");
+    const limitFilter = parseClampedInteger(url.searchParams.get("limit"), {
+      min: 1,
+      max: 1000,
+      fallback: 200,
+    });
+    const sinceFilter = parseAuditSince(url.searchParams.get("since"));
+
+    if (sinceFilter.error) {
+      json(res, { error: sinceFilter.error }, 400);
+      return true;
+    }
+
+    let typeFilter: string | undefined;
+    if (typeFilterRaw) {
+      const candidate = typeFilterRaw.trim();
+      if (!auditEventTypes.includes(candidate)) {
+        json(
+          res,
+          {
+            error: `Invalid "type" filter. Expected one of: ${auditEventTypes.join(", ")}`,
+          },
+          400,
+        );
+        return true;
+      }
+      typeFilter = candidate;
+    }
+
+    let severityFilter: string | undefined;
+    if (severityFilterRaw) {
+      const candidate = severityFilterRaw.trim();
+      if (!auditSeverities.includes(candidate)) {
+        json(
+          res,
+          {
+            error: `Invalid "severity" filter. Expected one of: ${auditSeverities.join(", ")}`,
+          },
+          400,
+        );
+        return true;
+      }
+      severityFilter = candidate;
+    }
+
+    const streamRequested =
+      isTruthyQueryParam(url.searchParams.get("stream")) ||
+      (req.headers.accept ?? "").includes("text/event-stream");
+    const filter = {
+      type: typeFilter,
+      severity: severityFilter,
+      sinceMs: sinceFilter.value,
+    };
+
+    if (!streamRequested) {
+      const entries = queryAuditFeed({
+        ...filter,
+        limit: limitFilter,
+      });
+      json(res, {
+        entries,
+        totalBuffered: getAuditFeedSize(),
+        replayed: true,
+      });
+      return true;
+    }
+
+    const startSse = initSse ?? defaultInitSse;
+    const sendSseJson = writeSseJson ?? defaultWriteSseJson;
+    startSse(res);
+    sendSseJson(res, {
+      type: "snapshot",
+      entries: queryAuditFeed({ ...filter, limit: limitFilter }),
+      totalBuffered: getAuditFeedSize(),
+    });
+
+    const unsubscribe = subscribeAuditFeed((entry) => {
+      if (!matchesAuditFilter(entry, filter)) return;
+      sendSseJson(res, { type: "entry", entry });
+    });
+
+    let closed = false;
+    const close = () => {
+      if (closed) return;
+      closed = true;
+      unsubscribe();
+      if (!res.writableEnded) {
+        res.end();
+      }
+    };
+
+    req.on("close", close);
+    req.on("aborted", close);
+    res.on("close", close);
+
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/extension/status") {
+    const relayPort = relayPortOverride ?? 18792;
+    const relayReachable = await (
+      checkRelayReachable ?? defaultCheckRelayReachable
+    )(relayPort);
+    const extensionPath = (
+      resolveExtensionPath ?? defaultResolveExtensionPath
+    )();
+
+    json(res, {
+      relayReachable,
+      relayPort,
+      extensionPath,
+    });
+    return true;
+  }
+
+  return false;
+}

package/src/api/drop-service.ts

@@ -0,0 +1,205 @@
+/**
+ * MiladyMaker drop/mint service.
+ *
+ * Handles the ERC-8041 fixed-supply collection minting:
+ * - Public free mint (user pays gas)
+ * - Shiny mint (0.1 ETH + gas)
+ * - Whitelist mint (Merkle proof)
+ * - Supply tracking and status
+ */
+
+import { logger } from "@elizaos/core";
+import { ethers } from "ethers";
+import type { DropStatus, MintResult } from "../contracts/drop";
+import type { TxService } from "./tx-service";
+
+export type { DropStatus, MintResult } from "../contracts/drop";
+
+// ── ABI ──────────────────────────────────────────────────────────────────
+
+const COLLECTION_ABI = [
+  "function mint(string,string,bytes32) external returns (uint256)",
+  "function mintShiny(string,string,bytes32) external payable returns (uint256)",
+  "function mintWhitelist(string,string,bytes32,bytes32[]) external returns (uint256)",
+  "function mintFor(address,string,string,bytes32,bool) external returns (uint256)",
+  "function currentSupply() view returns (uint256)",
+  "function publicMintOpen() view returns (bool)",
+  "function whitelistMintOpen() view returns (bool)",
+  "function hasMinted(address) view returns (bool)",
+  "function getAgentMintNumber(uint256) view returns (uint256)",
+  "function isShiny(uint256) view returns (bool)",
+  "function getCollectionDetails() view returns (uint256,uint256,bool)",
+  "function MAX_SUPPLY() view returns (uint256)",
+  "function SHINY_PRICE() view returns (uint256)",
+  "function merkleRoot() view returns (bytes32)",
+  "event AgentMinted(uint256 indexed agentId, uint256 indexed mintNumber, address indexed owner, bool shiny)",
+  "event CollectionUpdated(uint256 maxSupply, uint256 currentSupply, bool publicOpen, bool whitelistOpen)",
+] as const;
+
+const DEFAULT_CAP_HASH = ethers.id("milady-agent");
+
+// ── Service ──────────────────────────────────────────────────────────────
+
+export class DropService {
+  private readonly contract: ethers.Contract;
+  private readonly txService: TxService;
+  private readonly dropEnabled: boolean;
+
+  constructor(
+    txService: TxService,
+    collectionAddress: string,
+    dropEnabled: boolean,
+  ) {
+    this.txService = txService;
+    this.contract = txService.getContract(collectionAddress, COLLECTION_ABI);
+    this.dropEnabled = dropEnabled;
+  }
+
+  async getStatus(): Promise<DropStatus> {
+    if (!this.dropEnabled) {
+      return {
+        dropEnabled: false,
+        publicMintOpen: false,
+        whitelistMintOpen: false,
+        mintedOut: false,
+        currentSupply: 0,
+        maxSupply: 2138,
+        shinyPrice: "0.1",
+        userHasMinted: false,
+      };
+    }
+
+    const [collectionDetails, whitelistOpen, hasMinted, shinyPriceBN] =
+      await Promise.all([
+        this.contract.getCollectionDetails() as Promise<
+          [bigint, bigint, boolean]
+        >,
+        this.contract.whitelistMintOpen() as Promise<boolean>,
+        this.contract.hasMinted(this.txService.address) as Promise<boolean>,
+        this.contract.SHINY_PRICE() as Promise<bigint>,
+      ]);
+
+    const [maxSupply, currentSupply, publicOpen] = collectionDetails;
+    const maxSupplyNum = Number(maxSupply);
+    const currentSupplyNum = Number(currentSupply);
+
+    return {
+      dropEnabled: true,
+      publicMintOpen: publicOpen,
+      whitelistMintOpen: whitelistOpen,
+      mintedOut: currentSupplyNum >= maxSupplyNum,
+      currentSupply: currentSupplyNum,
+      maxSupply: maxSupplyNum,
+      shinyPrice: ethers.formatEther(shinyPriceBN),
+      userHasMinted: hasMinted,
+    };
+  }
+
+  async mint(
+    name: string,
+    endpoint: string,
+    capabilitiesHash?: string,
+  ): Promise<MintResult> {
+    const capHash = capabilitiesHash || DEFAULT_CAP_HASH;
+
+    logger.info(`[drop] Minting agent "${name}" for ${this.txService.address}`);
+
+    // Get fresh nonce before transaction
+    const nonce = await this.txService.getFreshNonce();
+
+    const tx = await this.contract.mint(name, endpoint, capHash, { nonce });
+    logger.info(`[drop] Mint tx submitted: ${tx.hash}`);
+
+    const receipt = await tx.wait();
+    return this.parseMintReceipt(receipt, false);
+  }
+
+  async mintShiny(
+    name: string,
+    endpoint: string,
+    capabilitiesHash?: string,
+  ): Promise<MintResult> {
+    const capHash = capabilitiesHash || DEFAULT_CAP_HASH;
+    const shinyPrice = (await this.contract.SHINY_PRICE()) as bigint;
+
+    logger.info(
+      `[drop] Minting SHINY agent "${name}" for ${this.txService.address} (${ethers.formatEther(shinyPrice)} ETH)`,
+    );
+
+    // Get fresh nonce before transaction
+    const nonce = await this.txService.getFreshNonce();
+
+    const tx = await this.contract.mintShiny(name, endpoint, capHash, {
+      value: shinyPrice,
+      nonce,
+    });
+    logger.info(`[drop] Shiny mint tx submitted: ${tx.hash}`);
+
+    const receipt = await tx.wait();
+    return this.parseMintReceipt(receipt, true);
+  }
+
+  async mintWithWhitelist(
+    name: string,
+    endpoint: string,
+    proof: string[],
+    capabilitiesHash?: string,
+  ): Promise<MintResult> {
+    const capHash = capabilitiesHash || DEFAULT_CAP_HASH;
+
+    logger.info(
+      `[drop] Whitelist minting agent "${name}" for ${this.txService.address}`,
+    );
+
+    // Get fresh nonce before transaction
+    const nonce = await this.txService.getFreshNonce();
+
+    const tx = await this.contract.mintWhitelist(
+      name,
+      endpoint,
+      capHash,
+      proof,
+      { nonce },
+    );
+    logger.info(`[drop] Whitelist mint tx submitted: ${tx.hash}`);
+
+    const receipt = await tx.wait();
+    return this.parseMintReceipt(receipt, false);
+  }
+
+  async getMintNumber(agentId: number): Promise<number> {
+    return Number(await this.contract.getAgentMintNumber(agentId));
+  }
+
+  async checkIsShiny(agentId: number): Promise<boolean> {
+    return this.contract.isShiny(agentId) as Promise<boolean>;
+  }
+
+  private parseMintReceipt(
+    receipt: ethers.TransactionReceipt,
+    shiny: boolean,
+  ): MintResult {
+    const iface = new ethers.Interface(COLLECTION_ABI);
+    let agentId = 0;
+    let mintNumber = 0;
+
+    for (const log of receipt.logs) {
+      const parsed = iface.parseLog({
+        topics: log.topics as string[],
+        data: log.data,
+      });
+      if (parsed && parsed.name === "AgentMinted") {
+        agentId = Number(parsed.args[0]);
+        mintNumber = Number(parsed.args[1]);
+        shiny = parsed.args[3] as boolean;
+        break;
+      }
+    }
+
+    logger.info(
+      `[drop] Minted: agentId=${agentId} mintNumber=${mintNumber} shiny=${shiny} txHash=${receipt.hash}`,
+    );
+
+    return { agentId, mintNumber, txHash: receipt.hash, isShiny: shiny };
+  }
+}

package/src/api/early-logs.ts

@@ -0,0 +1,111 @@
+/**
+ * Early log capture — split out from server.ts to avoid pulling in the entire
+ * API server dependency graph when only the log-buffer bootstrap is needed
+ * (e.g. during headless `startEliza()`).
+ *
+ * @module api/early-logs
+ */
+
+import { logger } from "@elizaos/core";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface EarlyLogEntry {
+  timestamp: number;
+  level: string;
+  message: string;
+  source: string;
+  tags: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Module-level state (shared via the exported accessors)
+// ---------------------------------------------------------------------------
+
+let earlyLogBuffer: EarlyLogEntry[] | null = null;
+let earlyPatchCleanup: (() => void) | null = null;
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Start capturing logs from the global @elizaos/core logger before the API
+ * server is up.  Call this once, early in the startup flow (e.g. before
+ * `startEliza`).  When `startApiServer` runs it will flush and take over.
+ */
+export function captureEarlyLogs(): void {
+  if (earlyLogBuffer) return; // already capturing
+  // If the global logger is already fully patched (e.g. dev-server started
+  // the API server before calling startEliza), skip early capture entirely.
+  if ((logger as unknown as Record<string, unknown>).__miladyLogPatched) return;
+  earlyLogBuffer = [];
+  const EARLY_PATCHED = "__miladyEarlyPatched";
+  if ((logger as unknown as Record<string, unknown>)[EARLY_PATCHED]) return;
+
+  const LEVELS = ["debug", "info", "warn", "error"] as const;
+  const originals = new Map<string, (...args: unknown[]) => void>();
+
+  for (const lvl of LEVELS) {
+    const original = logger[lvl].bind(logger);
+    originals.set(lvl, original as (...args: unknown[]) => void);
+    const earlyPatched: (typeof logger)[typeof lvl] = (
+      ...args: Parameters<typeof original>
+    ) => {
+      let msg = "";
+      let source = "agent";
+      const tags = ["agent"];
+      if (typeof args[0] === "string") {
+        msg = args[0];
+      } else if (args[0] && typeof args[0] === "object") {
+        const obj = args[0] as Record<string, unknown>;
+        if (typeof obj.src === "string") source = obj.src;
+        msg = typeof args[1] === "string" ? args[1] : JSON.stringify(obj);
+      }
+      const bracketMatch = /^\[([^\]]+)\]\s*/.exec(msg);
+      if (bracketMatch && source === "agent") source = bracketMatch[1];
+      if (source !== "agent" && !tags.includes(source)) tags.push(source);
+      earlyLogBuffer?.push({
+        timestamp: Date.now(),
+        level: lvl,
+        message: msg,
+        source,
+        tags,
+      });
+      return original(...args);
+    };
+    logger[lvl] = earlyPatched;
+  }
+
+  (logger as unknown as Record<string, unknown>)[EARLY_PATCHED] = true;
+
+  earlyPatchCleanup = () => {
+    // Restore originals so `patchLogger` inside `startApiServer` can re-patch
+    for (const lvl of LEVELS) {
+      const orig = originals.get(lvl);
+      if (orig) logger[lvl] = orig as (typeof logger)[typeof lvl];
+    }
+    delete (logger as unknown as Record<string, unknown>)[EARLY_PATCHED];
+    // Don't set the main PATCHED_MARKER — `patchLogger` will do that
+    delete (logger as unknown as Record<string, unknown>).__miladyLogPatched;
+  };
+}
+
+/**
+ * Drain the early log buffer and clean up the early logger patch.
+ * Called by `startApiServer` to flush buffered entries into the main log
+ * buffer, then hand control to the server's own logger patch.
+ *
+ * Returns the buffered entries (empty array if none).
+ */
+export function flushEarlyLogs(): EarlyLogEntry[] {
+  const entries = earlyLogBuffer ? [...earlyLogBuffer] : [];
+  if (earlyPatchCleanup) {
+    earlyPatchCleanup();
+    earlyPatchCleanup = null;
+  }
+  earlyLogBuffer = null;
+  return entries;
+}