@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

package/apps/app-companion/src/actions/emote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emote.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-companion/src/actions/emote.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EACV,MAAM,EAIP,MAAM,eAAe,CAAC;AAMvB,eAAO,MAAM,WAAW,EAAE,MA4EzB,CAAC"}
+{"version":3,"file":"emote.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-companion/src/actions/emote.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EACV,MAAM,EAIP,MAAM,eAAe,CAAC;AAMvB,eAAO,MAAM,WAAW,EAAE,MA8EzB,CAAC"}

package/apps/app-companion/src/actions/emote.js

@@ -28,6 +28,7 @@ export const emoteAction = {
         "parameter to a valid emote ID. If you also want speech, chain it " +
         "before, after, or alongside other actions in the same turn " +
         "(for example with REPLY, SEND_MESSAGE, or stream actions).",
+    descriptionCompressed: "Play one-shot VRM avatar emote animation. Silent visual side-action.",
     validate: async (runtime, message, _state) => {
         if (runtime.character?.settings?.DISABLE_EMOTES)
             return false;

package/apps/app-elizamaker/src/drop-routes.d.ts

@@ -0,0 +1,22 @@
+import type http from "node:http";
+import type { DropService } from "./drop-service.js";
+import type { ReadJsonBodyOptions } from "@elizaos/agent/api/http-helpers";
+export interface DropRouteContext {
+    req: http.IncomingMessage;
+    res: http.ServerResponse;
+    method: string;
+    pathname: string;
+    url: URL;
+    json: (res: http.ServerResponse, data: unknown, status?: number) => void;
+    error: (res: http.ServerResponse, message: string, status?: number) => void;
+    readJsonBody: <T extends object>(req: http.IncomingMessage, res: http.ServerResponse, options?: ReadJsonBodyOptions) => Promise<T | null>;
+    dropService: DropService | null;
+    agentName: string;
+    getWalletAddresses: () => {
+        evmAddress?: string;
+        solanaAddress?: string;
+    };
+    readOGCodeFromState: () => string | null;
+}
+export declare function handleDropRoutes(ctx: DropRouteContext): Promise<boolean>;
+//# sourceMappingURL=drop-routes.d.ts.map

package/apps/app-elizamaker/src/drop-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-routes.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-elizamaker/src/drop-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAa3E,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,IAAI,CAAC,eAAe,CAAC;IAC1B,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,GAAG,CAAC;IACT,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,KAAK,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5E,YAAY,EAAE,CAAC,CAAC,SAAS,MAAM,EAC7B,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,CAAC,EAAE,mBAAmB,KAC1B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACvB,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1E,mBAAmB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CAC1C;AAMD,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,OAAO,CAAC,CA4LlB"}

package/apps/app-elizamaker/src/drop-service.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ElizaMaker 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 "@elizaos/agent/contracts/drop";
+import type { TxService } from "@elizaos/app-steward/api/tx-service";
+export type { DropStatus, MintResult } from "@elizaos/agent/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/apps/app-elizamaker/src/drop-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-service.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-elizamaker/src/drop-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAErE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AA2B5E,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/apps/app-elizamaker/src/index.d.ts

@@ -0,0 +1,8 @@
+export { handleDropRoutes } from "./drop-routes.js";
+export { DropService } from "./drop-service.js";
+export type { DropStatus, MintResult } from "./drop-service.js";
+export { generateVerificationMessage, getVerifiedAddresses, isAddressWhitelisted, markAddressVerified, verifyTweet, } from "./twitter-verify.js";
+export type { VerificationResult } from "./twitter-verify.js";
+export { buildWhitelistTree, generateProof } from "./merkle-tree.js";
+export { initializeOGCode } from "./og-tracker.js";
+//# sourceMappingURL=index.d.ts.map

package/apps/app-elizamaker/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-elizamaker/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,WAAW,GACZ,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}

package/apps/app-elizamaker/src/index.js

@@ -0,0 +1,5 @@
+export { handleDropRoutes } from "./drop-routes.js";
+export { DropService } from "./drop-service.js";
+export { generateVerificationMessage, getVerifiedAddresses, isAddressWhitelisted, markAddressVerified, verifyTweet, } from "./twitter-verify.js";
+export { buildWhitelistTree, generateProof } from "./merkle-tree.js";
+export { initializeOGCode } from "./og-tracker.js";

package/apps/app-elizamaker/src/merkle-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle-tree.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-elizamaker/src/merkle-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAQH,MAAM,WAAW,iBAAiB;IAChC,gEAAgE;IAChE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,gCAAgC;IAChC,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAID;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKhD;AAoBD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CA4BtD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAmBjE;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAEhD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EAAE,EACf,YAAY,EAAE,MAAM,GACnB,OAAO,CAMT;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI;IACpC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IACjB,IAAI,EAAE,cAAc,CAAC;CACtB,CAmBA;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,iBAAiB,CA8BtE"}

package/apps/app-elizamaker/src/og-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"og-tracker.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-elizamaker/src/og-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAWvC;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAI1C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAYxE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,MAAY,GAClB,OAAO,CAGT"}

package/apps/app-elizamaker/src/og-tracker.js

@@ -0,0 +1,60 @@
+/**
+ * OG tracking code system.
+ *
+ * Silently writes a unique identifier to ~/.eliza/.og on first run.
+ * The code is a random UUID. A set of 100 "winning" codes can be
+ * generated deterministically from a secret seed (in ElizaMaker scripts).
+ * This file is planted now; whitelist eligibility is revealed in a future update.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "@elizaos/agent/config/paths";
+const OG_FILENAME = ".og";
+/**
+ * Write a random tracking UUID to ~/.eliza/.og if it does not already exist.
+ * Called once during startup. Silent on failure.
+ */
+export function initializeOGCode() {
+    const dir = resolveStateDir();
+    const filePath = path.join(dir, OG_FILENAME);
+    if (fs.existsSync(filePath))
+        return;
+    const code = crypto.randomUUID();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(filePath, code, { encoding: "utf-8", mode: 0o600 });
+}
+/**
+ * Read the stored OG code, or null if it doesn't exist.
+ */
+export function readOGCode() {
+    const filePath = path.join(resolveStateDir(), OG_FILENAME);
+    if (!fs.existsSync(filePath))
+        return null;
+    return fs.readFileSync(filePath, "utf-8").trim();
+}
+/**
+ * Generate the set of valid OG codes from a seed.
+ * Used in ElizaMaker scripts -- not called in the Eliza app.
+ */
+export function generateValidCodes(seed, count) {
+    const codes = [];
+    for (let i = 0; i < count; i++) {
+        const hash = crypto
+            .createHash("sha256")
+            .update(`${seed}:og:${i}`)
+            .digest("hex");
+        codes.push(`${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`);
+    }
+    return codes;
+}
+/**
+ * Check if a given code is in the valid set.
+ * Requires the seed to regenerate the valid codes.
+ */
+export function isValidOGCode(code, seed, count = 100) {
+    const validCodes = generateValidCodes(seed, count);
+    return validCodes.includes(code);
+}

package/apps/app-elizamaker/src/twitter-verify.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 type { VerificationResult } from "@elizaos/agent/contracts/verification";
+export type { VerificationResult } from "@elizaos/agent/contracts/verification";
+interface WhitelistEntry {
+    timestamp: string;
+    tweetUrl: string;
+    handle: string;
+}
+interface WhitelistData {
+    verified: Record<string, WhitelistEntry>;
+}
+export declare function generateVerificationMessage(agentName: string, walletAddress: string): string;
+export declare function verifyTweet(tweetUrl: string, walletAddress: string): Promise<VerificationResult>;
+export declare function loadWhitelist(): WhitelistData;
+export declare function markAddressVerified(address: string, tweetUrl: string, handle: string): void;
+export declare function isAddressWhitelisted(address: string): boolean;
+export declare function getVerifiedAddresses(): string[];
+//# sourceMappingURL=twitter-verify.d.ts.map

package/apps/app-elizamaker/src/twitter-verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"twitter-verify.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-elizamaker/src/twitter-verify.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAGhF,YAAY,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAMhF,UAAU,cAAc;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC1C;AAID,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GACpB,MAAM,CAGR;AAYD,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAiH7B;AAQD,wBAAgB,aAAa,IAAI,aAAa,CAY7C;AAcD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,IAAI,CASN;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAG7D;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAG/C"}

package/apps/app-elizamaker/src/twitter-verify.js

@@ -0,0 +1,168 @@
+/**
+ * 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 "@elizaos/agent/config/paths";
+import { createIntegrationTelemetrySpan } from "@elizaos/agent/diagnostics/integration-observability";
+const WHITELIST_FILE = "whitelist.json";
+// ── Verification Message ─────────────────────────────────────────────────
+export function generateVerificationMessage(agentName, walletAddress) {
+    const shortAddr = `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}`;
+    return `Verifying my Eliza agent "${agentName}" | ${shortAddr} #ElizaAgent`;
+}
+// ── Tweet Verification ───────────────────────────────────────────────────
+function parseTweetUrl(url) {
+    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, walletAddress) {
+    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;
+    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;
+    try {
+        data = (await response.json());
+    }
+    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() {
+    return path.join(resolveStateDir(), WHITELIST_FILE);
+}
+export function loadWhitelist() {
+    const filePath = whitelistPath();
+    if (!fs.existsSync(filePath))
+        return { verified: {} };
+    const raw = fs.readFileSync(filePath, "utf-8");
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        logger.warn(`[twitter-verify] Corrupt whitelist file, resetting: ${filePath}`);
+        return { verified: {} };
+    }
+}
+function saveWhitelist(data) {
+    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, tweetUrl, handle) {
+    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) {
+    const wl = loadWhitelist();
+    return address.toLowerCase() in wl.verified;
+}
+export function getVerifiedAddresses() {
+    const wl = loadWhitelist();
+    return Object.keys(wl.verified);
+}

package/apps/app-lifeops/src/actions/activity-report.d.ts

@@ -0,0 +1,13 @@
+/**
+ * T8d — Activity tracker actions.
+ *
+ * GET_ACTIVITY_REPORT — per-app time breakdown for the last N hours.
+ * GET_TIME_ON_APP      — time spent on a specific app (by name or bundle id).
+ * GET_TIME_ON_SITE     — time spent on a specific site based on browser
+ *                        activity reports pushed into the runtime store.
+ */
+import type { Action } from "@elizaos/core";
+export declare const getActivityReportAction: Action;
+export declare const getTimeOnAppAction: Action;
+export declare const getTimeOnSiteAction: Action;
+//# sourceMappingURL=activity-report.d.ts.map

package/apps/app-lifeops/src/actions/activity-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-report.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/activity-report.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAiEvB,eAAO,MAAM,uBAAuB,EAAE,MA6ErC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MA8FhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,MAqGjC,CAAC"}

package/apps/app-lifeops/src/actions/activity-report.js

@@ -0,0 +1,287 @@
+/**
+ * T8d — Activity tracker actions.
+ *
+ * GET_ACTIVITY_REPORT — per-app time breakdown for the last N hours.
+ * GET_TIME_ON_APP      — time spent on a specific app (by name or bundle id).
+ * GET_TIME_ON_SITE     — time spent on a specific site based on browser
+ *                        activity reports pushed into the runtime store.
+ */
+import { logger } from "@elizaos/core";
+import { isSupportedPlatform } from "@elizaos/native-activity-tracker";
+import { getActivityReport, getTimeOnApp, } from "../activity-profile/activity-tracker-reporting.js";
+import { getBrowserDomainActivity } from "../lifeops/browser-extension-store.js";
+import { hasLifeOpsAccess } from "./lifeops-google-helpers.js";
+const DEFAULT_WINDOW_HOURS = 24;
+const MAX_WINDOW_HOURS = 24 * 30;
+function resolveWindowMs(windowHours) {
+    const raw = typeof windowHours === "number" && Number.isFinite(windowHours)
+        ? windowHours
+        : DEFAULT_WINDOW_HOURS;
+    const clamped = Math.max(0.25, Math.min(MAX_WINDOW_HOURS, raw));
+    return Math.round(clamped * 60 * 60 * 1000);
+}
+function getParams(options) {
+    const params = options?.parameters;
+    return params ?? {};
+}
+function formatMinutes(totalMs) {
+    return Math.round(totalMs / 60_000);
+}
+function normalizeDomain(value) {
+    const trimmed = value.trim().toLowerCase().replace(/\.+$/, "");
+    if (!trimmed.startsWith("http://") && !trimmed.startsWith("https://")) {
+        return trimmed;
+    }
+    try {
+        return new URL(trimmed).hostname.toLowerCase();
+    }
+    catch {
+        return "";
+    }
+}
+function buildReportSummary(apps) {
+    if (apps.length === 0)
+        return "No app focus events recorded in that window.";
+    return apps
+        .slice(0, 10)
+        .map((app) => `- ${app.appName || app.bundleId}: ${formatMinutes(app.totalMs)}m`)
+        .join("\n");
+}
+export const getActivityReportAction = {
+    name: "GET_ACTIVITY_REPORT",
+    similes: ["ACTIVITY_REPORT", "WHAT_DID_I_WORK_ON", "TIME_TRACKING_REPORT"],
+    description: "T8d — Per-app time breakdown for the last N hours (default 24h). Returns noDataReason='macos-only' on non-Darwin platforms.",
+    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+    handler: async (runtime, message, _state, options, callback) => {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            const text = "Activity reports are restricted to the owner.";
+            await callback?.({ text });
+            return { text, success: false, data: { error: "PERMISSION_DENIED" } };
+        }
+        const params = getParams(options);
+        const windowMs = resolveWindowMs(params.windowHours);
+        if (!isSupportedPlatform()) {
+            const text = "Activity tracking is macOS-only. No data available on this platform.";
+            await callback?.({ text, source: "action", action: "GET_ACTIVITY_REPORT" });
+            return {
+                text,
+                success: true,
+                data: {
+                    apps: [],
+                    totalMs: 0,
+                    windowMs,
+                    noDataReason: "macos-only",
+                },
+            };
+        }
+        const agentId = String(runtime.agentId);
+        const report = await getActivityReport(runtime, agentId, {
+            windowMs,
+            limit: 20,
+        });
+        const text = `Activity report (${formatMinutes(report.totalMs)}m total):\n${buildReportSummary(report.apps)}`;
+        await callback?.({ text, source: "action", action: "GET_ACTIVITY_REPORT" });
+        return {
+            text,
+            success: true,
+            data: {
+                sinceMs: report.sinceMs,
+                untilMs: report.untilMs,
+                totalMs: report.totalMs,
+                apps: report.apps,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "windowHours",
+            description: "Number of hours of history to report on (default 24, max 720).",
+            schema: { type: "number" },
+        },
+    ],
+    examples: [
+        [
+            { name: "{{name1}}", content: { text: "What did I work on today?" } },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Activity report (312m total):\n- VS Code: 184m\n- Safari: 82m",
+                    action: "GET_ACTIVITY_REPORT",
+                },
+            },
+        ],
+    ],
+};
+export const getTimeOnAppAction = {
+    name: "GET_TIME_ON_APP",
+    similes: ["TIME_IN_APP", "HOW_LONG_IN_APP"],
+    description: "T8d — Time spent on a specific app (matched by app name or bundle id) over the last N hours.",
+    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+    handler: async (runtime, message, _state, options, callback) => {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            const text = "Activity reports are restricted to the owner.";
+            await callback?.({ text });
+            return { text, success: false, data: { error: "PERMISSION_DENIED" } };
+        }
+        const params = getParams(options);
+        const target = (params.appNameOrBundleId ?? "").trim();
+        if (!target) {
+            const text = "Specify an app name or bundle id.";
+            await callback?.({ text });
+            return {
+                text,
+                success: false,
+                data: { error: "MISSING_APP" },
+            };
+        }
+        const windowMs = resolveWindowMs(params.windowHours);
+        if (!isSupportedPlatform()) {
+            const text = `Activity tracking is macOS-only; no time-on-app data for ${target}.`;
+            await callback?.({ text, source: "action", action: "GET_TIME_ON_APP" });
+            return {
+                text,
+                success: true,
+                data: {
+                    minutes: 0,
+                    totalMs: 0,
+                    windowMs,
+                    app: target,
+                    noDataReason: "macos-only",
+                },
+            };
+        }
+        const agentId = String(runtime.agentId);
+        const result = await getTimeOnApp(runtime, agentId, target, { windowMs });
+        const minutes = formatMinutes(result.totalMs);
+        const text = result.matchedBy === "none"
+            ? `No focus events recorded for ${target} in that window.`
+            : `${target}: ${minutes}m (matched by ${result.matchedBy}).`;
+        await callback?.({ text, source: "action", action: "GET_TIME_ON_APP" });
+        return {
+            text,
+            success: true,
+            data: {
+                app: target,
+                minutes,
+                totalMs: result.totalMs,
+                matchedBy: result.matchedBy,
+                windowMs,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "appNameOrBundleId",
+            description: "App name (e.g. 'Safari') or bundle id (e.g. 'com.apple.Safari').",
+            schema: { type: "string" },
+        },
+        {
+            name: "windowHours",
+            description: "Window in hours (default 24, max 720).",
+            schema: { type: "number" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "How long was I in VS Code today?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "VS Code: 184m (matched by appName).",
+                    action: "GET_TIME_ON_APP",
+                },
+            },
+        ],
+    ],
+};
+export const getTimeOnSiteAction = {
+    name: "GET_TIME_ON_SITE",
+    similes: ["TIME_ON_WEBSITE", "TIME_ON_DOMAIN"],
+    description: "T8d — Time on a specific site based on browser activity reports pushed into the runtime store.",
+    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+    handler: async (runtime, message, _state, options, callback) => {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            const text = "Activity reports are restricted to the owner.";
+            await callback?.({ text });
+            return { text, success: false, data: { error: "PERMISSION_DENIED" } };
+        }
+        const params = getParams(options);
+        const rawDomain = (params.domain ?? "").trim();
+        const domain = rawDomain ? normalizeDomain(rawDomain) : "";
+        if (!domain) {
+            const text = "Specify a site domain.";
+            await callback?.({ text });
+            return { text, success: false, data: { error: "MISSING_DOMAIN" } };
+        }
+        const windowMs = resolveWindowMs(params.windowHours);
+        const untilMs = Date.now();
+        const sinceMs = untilMs - windowMs;
+        const result = await getBrowserDomainActivity(runtime, {
+            domain,
+            sinceMs,
+            untilMs,
+        });
+        const minutes = formatMinutes(result.totalMs);
+        if (result.reportCount === 0) {
+            const text = "No browser activity reports have been received yet. Connect the LifeOps browser activity source and try again.";
+            logger.debug({ domain, windowMs }, "[activity-tracker] GET_TIME_ON_SITE invoked before any browser activity reports were recorded.");
+            await callback?.({ text, source: "action", action: "GET_TIME_ON_SITE" });
+            return {
+                text,
+                success: true,
+                data: {
+                    domain,
+                    minutes: 0,
+                    totalMs: 0,
+                    windowMs,
+                    noDataReason: "no-browser-activity-yet",
+                },
+            };
+        }
+        const text = result.totalMs > 0
+            ? `${domain}: ${minutes}m.`
+            : `No browser activity recorded for ${domain} in that window.`;
+        await callback?.({ text, source: "action", action: "GET_TIME_ON_SITE" });
+        return {
+            text,
+            success: true,
+            data: {
+                domain,
+                minutes,
+                totalMs: result.totalMs,
+                windowMs,
+                ...(result.totalMs === 0 ? { noDataReason: "no-domain-activity" } : {}),
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "domain",
+            description: "Hostname (e.g. 'github.com').",
+            schema: { type: "string" },
+        },
+        {
+            name: "windowHours",
+            description: "Window in hours (default 24, max 720).",
+            schema: { type: "number" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "How long was I on github.com today?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "github.com: 42m.",
+                    action: "GET_TIME_ON_SITE",
+                },
+            },
+        ],
+    ],
+};