@elizaos/autonomous 2.0.0-alpha.37

package/dist/packages/autonomous/src/api/diagnostics-routes.d.ts

@@ -0,0 +1,46 @@
+import type http from "node:http";
+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;
+}
+export declare function handleDiagnosticsRoutes(ctx: DiagnosticsRouteContext): Promise<boolean>;
+export {};
+//# sourceMappingURL=diagnostics-routes.d.ts.map

package/dist/packages/autonomous/src/api/diagnostics-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/diagnostics-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEtE,UAAU,YAAY;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,UAAU,uBAAuB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,UAAU,cAAc;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,CAAC;CAC7D;AAED,KAAK,kBAAkB,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC;AAC7D,KAAK,uBAAuB,GAAG,CAC7B,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,KACX,IAAI,CAAC;AAEV,MAAM,WAAW,uBACf,SAAQ,gBAAgB,EACtB,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC;IAC5B,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,WAAW,EAAE,uBAAuB,EAAE,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,oBAAoB,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAC3C,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,YAAY,CAAC,EAAE,uBAAuB,CAAC;IACvC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,gBAAgB,EAAE,MAAM,MAAM,CAAC;IAC/B,cAAc,EAAE,CAAC,KAAK,EAAE;QACtB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,KAAK,cAAc,EAAE,CAAC;IACvB,kBAAkB,EAAE,CAClB,UAAU,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,KACxC,MAAM,IAAI,CAAC;CACjB;AA2GD,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,uBAAuB,GAC3B,OAAO,CAAC,OAAO,CAAC,CA+NlB"}

package/dist/packages/autonomous/src/api/diagnostics-routes.js

@@ -0,0 +1,241 @@
+import { parseClampedInteger } from "../utils/number-parsing";
+async function defaultCheckRelayReachable(relayPort) {
+    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() {
+    return null;
+}
+function isAutonomyEvent(event) {
+    return event.type === "agent_event" || event.type === "heartbeat_event";
+}
+function defaultInitSse(res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+    });
+}
+function defaultWriteSseData(res, data, event) {
+    if (event) {
+        res.write(`event: ${event}\n`);
+    }
+    const safe = data.replace(/\r?\n/g, "\ndata: ");
+    res.write(`data: ${safe}\n\n`);
+}
+function defaultWriteSseJson(res, payload, event) {
+    defaultWriteSseData(res, JSON.stringify(payload), event);
+}
+function parseAuditSince(raw) {
+    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) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return (normalized === "1" ||
+        normalized === "true" ||
+        normalized === "yes" ||
+        normalized === "on");
+}
+function matchesAuditFilter(entry, filters) {
+    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) {
+    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;
+        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;
+        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/dist/packages/autonomous/src/api/drop-service.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 type { DropStatus, MintResult } from "../contracts/drop";
+import type { TxService } from "./tx-service";
+export type { DropStatus, MintResult } from "../contracts/drop";
+export declare class DropService {
+    private readonly contract;
+    private readonly txService;
+    private readonly dropEnabled;
+    constructor(txService: TxService, collectionAddress: string, dropEnabled: boolean);
+    getStatus(): Promise<DropStatus>;
+    mint(name: string, endpoint: string, capabilitiesHash?: string): Promise<MintResult>;
+    mintShiny(name: string, endpoint: string, capabilitiesHash?: string): Promise<MintResult>;
+    mintWithWhitelist(name: string, endpoint: string, proof: string[], capabilitiesHash?: string): Promise<MintResult>;
+    getMintNumber(agentId: number): Promise<number>;
+    checkIsShiny(agentId: number): Promise<boolean>;
+    private parseMintReceipt;
+}
+//# sourceMappingURL=drop-service.d.ts.map

package/dist/packages/autonomous/src/api/drop-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-service.d.ts","sourceRoot":"","sources":["../../../../../src/api/drop-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA2BhE,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;gBAGpC,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,MAAM,EACzB,WAAW,EAAE,OAAO;IAOhB,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC;IAwChC,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,CAAC;IAehB,SAAS,CACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,CAAC;IAqBhB,iBAAiB,CACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EAAE,EACf,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,CAAC;IAuBhB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI/C,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrD,OAAO,CAAC,gBAAgB;CA2BzB"}

package/dist/packages/autonomous/src/api/drop-service.js

@@ -0,0 +1,134 @@
+/**
+ * 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";
+// ── 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)",
+];
+const DEFAULT_CAP_HASH = ethers.id("milady-agent");
+// ── Service ──────────────────────────────────────────────────────────────
+export class DropService {
+    contract;
+    txService;
+    dropEnabled;
+    constructor(txService, collectionAddress, dropEnabled) {
+        this.txService = txService;
+        this.contract = txService.getContract(collectionAddress, COLLECTION_ABI);
+        this.dropEnabled = dropEnabled;
+    }
+    async getStatus() {
+        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(),
+            this.contract.whitelistMintOpen(),
+            this.contract.hasMinted(this.txService.address),
+            this.contract.SHINY_PRICE(),
+        ]);
+        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, endpoint, capabilitiesHash) {
+        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, endpoint, capabilitiesHash) {
+        const capHash = capabilitiesHash || DEFAULT_CAP_HASH;
+        const shinyPrice = (await this.contract.SHINY_PRICE());
+        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, endpoint, proof, capabilitiesHash) {
+        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) {
+        return Number(await this.contract.getAgentMintNumber(agentId));
+    }
+    async checkIsShiny(agentId) {
+        return this.contract.isShiny(agentId);
+    }
+    parseMintReceipt(receipt, shiny) {
+        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,
+                data: log.data,
+            });
+            if (parsed && parsed.name === "AgentMinted") {
+                agentId = Number(parsed.args[0]);
+                mintNumber = Number(parsed.args[1]);
+                shiny = parsed.args[3];
+                break;
+            }
+        }
+        logger.info(`[drop] Minted: agentId=${agentId} mintNumber=${mintNumber} shiny=${shiny} txHash=${receipt.hash}`);
+        return { agentId, mintNumber, txHash: receipt.hash, isShiny: shiny };
+    }
+}

package/dist/packages/autonomous/src/api/early-logs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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
+ */
+export interface EarlyLogEntry {
+    timestamp: number;
+    level: string;
+    message: string;
+    source: string;
+    tags: string[];
+}
+/**
+ * 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 declare function captureEarlyLogs(): void;
+/**
+ * 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 declare function flushEarlyLogs(): EarlyLogEntry[];
+//# sourceMappingURL=early-logs.d.ts.map

package/dist/packages/autonomous/src/api/early-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"early-logs.d.ts","sourceRoot":"","sources":["../../../../../src/api/early-logs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAaD;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAuDvC;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,aAAa,EAAE,CAQhD"}

package/dist/packages/autonomous/src/api/early-logs.js

@@ -0,0 +1,95 @@
+/**
+ * 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";
+// ---------------------------------------------------------------------------
+// Module-level state (shared via the exported accessors)
+// ---------------------------------------------------------------------------
+let earlyLogBuffer = null;
+let earlyPatchCleanup = 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() {
+    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.__miladyLogPatched)
+        return;
+    earlyLogBuffer = [];
+    const EARLY_PATCHED = "__miladyEarlyPatched";
+    if (logger[EARLY_PATCHED])
+        return;
+    const LEVELS = ["debug", "info", "warn", "error"];
+    const originals = new Map();
+    for (const lvl of LEVELS) {
+        const original = logger[lvl].bind(logger);
+        originals.set(lvl, original);
+        const earlyPatched = (...args) => {
+            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];
+                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[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;
+        }
+        delete logger[EARLY_PATCHED];
+        // Don't set the main PATCHED_MARKER — `patchLogger` will do that
+        delete logger.__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() {
+    const entries = earlyLogBuffer ? [...earlyLogBuffer] : [];
+    if (earlyPatchCleanup) {
+        earlyPatchCleanup();
+        earlyPatchCleanup = null;
+    }
+    earlyLogBuffer = null;
+    return entries;
+}

package/dist/packages/autonomous/src/api/http-helpers.d.ts

@@ -0,0 +1,50 @@
+import type http from "node:http";
+/**
+ * Common request body size guard used across API/benchmark endpoints.
+ */
+export declare const DEFAULT_MAX_BODY_BYTES = 1048576;
+export interface RequestBodyOptions {
+    /** Maximum accepted body size in bytes. */
+    maxBytes?: number;
+    /** String conversion encoding for body text helpers. */
+    encoding?: BufferEncoding;
+    /** Error message returned when the request body exceeds `maxBytes`. */
+    tooLargeMessage?: string;
+    /** When true, resolves to `null` instead of rejecting on body read failure. */
+    returnNullOnError?: boolean;
+    /** When true, resolves to `null` instead of rejecting on size limit exceed. */
+    returnNullOnTooLarge?: boolean;
+    /** Whether to destroy the request stream as soon as the body limit is exceeded. */
+    destroyOnTooLarge?: boolean;
+}
+export declare function readRequestBodyBuffer(req: http.IncomingMessage, { maxBytes, returnNullOnError, returnNullOnTooLarge, destroyOnTooLarge, tooLargeMessage, }?: RequestBodyOptions): Promise<Buffer | null>;
+export interface ReadTextBodyOptions extends RequestBodyOptions {
+}
+export declare function readRequestBody(req: http.IncomingMessage, options?: ReadTextBodyOptions): Promise<string | null>;
+export interface ReadJsonBodyOptions extends ReadTextBodyOptions {
+    /** Whether to require JSON object shape (not arrays/null). */
+    requireObject?: boolean;
+    /** Response status used for parse/read failures. */
+    readErrorStatus?: number;
+    /** Response status used for non-object body when `requireObject` is true. */
+    nonObjectStatus?: number;
+    /** Response status used for invalid JSON syntax. */
+    parseErrorStatus?: number;
+    /** Override for read errors (including size / stream errors). */
+    readErrorMessage?: string;
+    /** Override when JSON is valid but not an object. */
+    nonObjectMessage?: string;
+    /** Override for malformed JSON parse errors. */
+    parseErrorMessage?: string;
+}
+export declare function isJsonObjectBody(value: unknown): value is Record<string, unknown>;
+export declare function writeJsonResponse(res: http.ServerResponse, body: unknown, status?: number): Promise<void>;
+export declare function writeJsonError(res: http.ServerResponse, message: string, status?: number): Promise<void>;
+export declare function writeJsonResponseSafe(res: http.ServerResponse, body: unknown, status?: number): void;
+/** Shorthand responder for successful JSON payloads with safe fire-and-forget write. */
+export declare function sendJson(res: http.ServerResponse, body: unknown, status?: number): void;
+/** Shorthand responder for JSON error payloads with safe fire-and-forget write. */
+export declare function sendJsonError(res: http.ServerResponse, message: string, status?: number): void;
+export declare function writeJsonErrorSafe(res: http.ServerResponse, message: string, status?: number): void;
+export declare function readJsonBody<T = Record<string, unknown>>(req: http.IncomingMessage, res: http.ServerResponse, { readErrorStatus, nonObjectStatus, parseErrorStatus, readErrorMessage, nonObjectMessage, parseErrorMessage, requireObject, ...readOptions }?: ReadJsonBodyOptions): Promise<T | null>;
+//# sourceMappingURL=http-helpers.d.ts.map

package/dist/packages/autonomous/src/api/http-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-helpers.d.ts","sourceRoot":"","sources":["../../../../../src/api/http-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC;;GAEG;AACH,eAAO,MAAM,sBAAsB,UAAY,CAAC;AAEhD,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,uEAAuE;IACvE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,+EAA+E;IAC/E,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,mFAAmF;IACnF,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAMD,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,EACE,QAAiC,EACjC,iBAAyB,EACzB,oBAA4B,EAC5B,iBAAyB,EACzB,eAAe,GAChB,GAAE,kBAAuB,GACzB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8ExB;AAED,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;CAE9D;AAED,wBAAsB,eAAe,CACnC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAKxB;AAED,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC9D,8DAA8D;IAC9D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oDAAoD;IACpD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oDAAoD;IACpD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gDAAgD;IAChD,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAElC;AAED,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,IAAI,EAAE,OAAO,EACb,MAAM,SAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAIf;AAED,wBAAsB,cAAc,CAClC,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,SAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,IAAI,EAAE,OAAO,EACb,MAAM,SAAM,GACX,IAAI,CAIN;AAED,wFAAwF;AACxF,wBAAgB,QAAQ,CACtB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,IAAI,EAAE,OAAO,EACb,MAAM,SAAM,GACX,IAAI,CAEN;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAC3B,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,SAAM,GACX,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,SAAM,GACX,IAAI,CAIN;AAED,wBAAsB,YAAY,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5D,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,EACE,eAAqB,EACrB,eAAqB,EACrB,gBAAsB,EACtB,gBAAgD,EAChD,gBAAuD,EACvD,iBAAkD,EAClD,aAAoB,EACpB,GAAG,WAAW,EACf,GAAE,mBAAwB,GAC1B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CA8BnB"}