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

package/apps/app-lifeops/src/actions/autofill.js

@@ -0,0 +1,340 @@
+/**
+ * Browser-extension autofill actions (T8f — plan §6.14).
+ *
+ * Three actions:
+ *
+ *   - REQUEST_FIELD_FILL     — agent asks the browser extension to fill a
+ *                              field via the installed password manager.
+ *                              Refuses on non-whitelisted domains before
+ *                              dispatching anywhere.
+ *   - ADD_AUTOFILL_WHITELIST — user explicitly adds a domain to the local
+ *                              whitelist. `confirmed: true` required.
+ *   - LIST_AUTOFILL_WHITELIST — list effective whitelist entries
+ *                               (defaults + user additions).
+ *
+ * Credential-flow invariant: the agent NEVER sees credential material. It
+ * only says "fill the password field on github.com". The browser extension
+ * asks 1Password / ProtonPass to resolve and inject the secret. This file
+ * contains zero code paths that accept, store, log, or return a plaintext
+ * credential.
+ */
+import { logger, } from "@elizaos/core";
+import { hasOwnerAccess } from "@elizaos/agent/security/access";
+import { DEFAULT_AUTOFILL_WHITELIST, extractRegistrableDomain, isUrlWhitelisted, normalizeAutofillDomain, } from "../lifeops/autofill-whitelist.js";
+const FIELD_PURPOSES = ["email", "password", "name", "phone", "custom"];
+const WHITELIST_CACHE_KEY = "eliza:lifeops-autofill-whitelist";
+const DEVICE_BUS_URL_ENV = "MILADY_DEVICE_BUS_URL";
+const DEVICE_BUS_TOKEN_ENV = "MILADY_DEVICE_BUS_TOKEN";
+function hasRuntimeCache(runtime) {
+    if (!runtime || typeof runtime !== "object")
+        return false;
+    const r = runtime;
+    return typeof r.getCache === "function" && typeof r.setCache === "function";
+}
+async function loadUserDomains(runtime) {
+    if (!hasRuntimeCache(runtime))
+        return [];
+    const cached = await runtime.getCache(WHITELIST_CACHE_KEY);
+    if (!Array.isArray(cached))
+        return [];
+    return cached.filter((v) => typeof v === "string");
+}
+async function saveUserDomains(runtime, domains) {
+    if (!hasRuntimeCache(runtime))
+        return;
+    await runtime.setCache(WHITELIST_CACHE_KEY, domains);
+}
+async function effectiveWhitelist(runtime) {
+    const user = await loadUserDomains(runtime);
+    const merged = new Set();
+    for (const d of DEFAULT_AUTOFILL_WHITELIST) {
+        const n = normalizeAutofillDomain(d);
+        if (n)
+            merged.add(n);
+    }
+    for (const d of user) {
+        const n = normalizeAutofillDomain(d);
+        if (n)
+            merged.add(n);
+    }
+    return [...merged].sort();
+}
+function readDeviceBusConfig(runtime) {
+    const readString = (key) => {
+        const env = process.env[key]?.trim();
+        if (env)
+            return env;
+        const setting = runtime?.getSetting?.(key);
+        return typeof setting === "string" && setting.trim().length > 0
+            ? setting.trim()
+            : null;
+    };
+    const url = readString(DEVICE_BUS_URL_ENV);
+    if (!url)
+        return null;
+    return { url, token: readString(DEVICE_BUS_TOKEN_ENV) };
+}
+function failure(actionName, error, extra) {
+    return {
+        text: "",
+        success: false,
+        values: { success: false, error },
+        data: { actionName, error, ...(extra ?? {}) },
+    };
+}
+function asFieldPurpose(value) {
+    if (typeof value !== "string")
+        return null;
+    const lower = value.trim().toLowerCase();
+    return FIELD_PURPOSES.includes(lower)
+        ? lower
+        : null;
+}
+async function dispatchToExtension(runtime, payload) {
+    const config = readDeviceBusConfig(runtime);
+    if (!config) {
+        logger.warn({ action: "REQUEST_FIELD_FILL" }, "[REQUEST_FIELD_FILL] device bus not configured; extension cannot be reached from agent");
+        return { dispatched: false, via: "none" };
+    }
+    const endpoint = `${config.url.replace(/\/$/, "")}/api/v1/device-bus/intents`;
+    const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...(config.token ? { Authorization: `Bearer ${config.token}` } : {}),
+        },
+        body: JSON.stringify({
+            kind: "autofill.requestFill",
+            payload,
+        }),
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        return {
+            dispatched: false,
+            via: "device-bus",
+            detail: text.slice(0, 500),
+        };
+    }
+    return { dispatched: true, via: "device-bus" };
+}
+export const requestFieldFillAction = {
+    name: "REQUEST_FIELD_FILL",
+    similes: ["AUTOFILL_FIELD", "AUTOFILL_REQUEST", "FILL_PASSWORD_FIELD"],
+    description: "Ask the LifeOps browser extension to autofill a field via the installed password manager (1Password or ProtonPass). Refuses on domains not in the user's autofill whitelist. Credentials never pass through the agent — the extension resolves them locally.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime, message, _state, options) => {
+        if (!(await hasOwnerAccess(runtime, message))) {
+            return failure("REQUEST_FIELD_FILL", "PERMISSION_DENIED");
+        }
+        const params = options?.parameters ?? {};
+        const tabUrl = (params.tabUrl ?? "").toString().trim();
+        if (!tabUrl)
+            return failure("REQUEST_FIELD_FILL", "MISSING_TAB_URL");
+        const fieldPurpose = asFieldPurpose(params.fieldPurpose);
+        if (!fieldPurpose) {
+            return failure("REQUEST_FIELD_FILL", "INVALID_FIELD_PURPOSE", {
+                allowed: [...FIELD_PURPOSES],
+            });
+        }
+        const whitelist = await effectiveWhitelist(runtime);
+        const check = isUrlWhitelisted(tabUrl, whitelist);
+        if (!check.registrableDomain) {
+            return failure("REQUEST_FIELD_FILL", "INVALID_TAB_URL");
+        }
+        if (!check.allowed) {
+            logger.warn({
+                action: "REQUEST_FIELD_FILL",
+                registrableDomain: check.registrableDomain,
+                fieldPurpose,
+            }, `[REQUEST_FIELD_FILL] refused non-whitelisted domain ${check.registrableDomain}`);
+            return {
+                text: `Autofill refused: ${check.registrableDomain} is not in your autofill whitelist. Add it explicitly with ADD_AUTOFILL_WHITELIST if you trust this site.`,
+                success: false,
+                values: {
+                    success: false,
+                    reason: "not-whitelisted",
+                    registrableDomain: check.registrableDomain,
+                },
+                data: {
+                    actionName: "REQUEST_FIELD_FILL",
+                    reason: "not-whitelisted",
+                    registrableDomain: check.registrableDomain,
+                    fieldPurpose,
+                },
+            };
+        }
+        const dispatch = await dispatchToExtension(runtime, {
+            tabUrl,
+            fieldPurpose,
+            fieldSelector: params.fieldSelector?.trim() || null,
+            customKey: params.customKey?.trim() || null,
+        });
+        if (!dispatch.dispatched) {
+            return {
+                text: "",
+                success: false,
+                values: {
+                    success: false,
+                    reason: "extension-unreachable",
+                    via: dispatch.via,
+                },
+                data: {
+                    actionName: "REQUEST_FIELD_FILL",
+                    reason: "extension-unreachable",
+                    via: dispatch.via,
+                    ...(dispatch.detail ? { detail: dispatch.detail } : {}),
+                },
+            };
+        }
+        logger.info({
+            action: "REQUEST_FIELD_FILL",
+            registrableDomain: check.registrableDomain,
+            fieldPurpose,
+        }, `[REQUEST_FIELD_FILL] dispatched autofill request for ${check.registrableDomain}`);
+        return {
+            text: `Requested ${fieldPurpose} autofill on ${check.registrableDomain} via the browser extension.`,
+            success: true,
+            values: {
+                success: true,
+                registrableDomain: check.registrableDomain,
+                matched: check.matched,
+                fieldPurpose,
+            },
+            data: {
+                actionName: "REQUEST_FIELD_FILL",
+                registrableDomain: check.registrableDomain,
+                matched: check.matched,
+                fieldPurpose,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "tabUrl",
+            description: "URL of the tab where the field should be filled. Used for whitelist enforcement.",
+            schema: { type: "string" },
+        },
+        {
+            name: "fieldPurpose",
+            description: "One of: email, password, name, phone, custom. Tells the password manager which field to resolve.",
+            schema: { type: "string" },
+        },
+        {
+            name: "fieldSelector",
+            description: "Optional CSS selector narrowing which field to fill on the page.",
+            schema: { type: "string" },
+        },
+        {
+            name: "customKey",
+            description: "When fieldPurpose is 'custom', the key in the password-manager item to resolve (e.g. 'API key').",
+            schema: { type: "string" },
+        },
+    ],
+};
+export const addAutofillWhitelistAction = {
+    name: "ADD_AUTOFILL_WHITELIST",
+    similes: ["TRUST_SITE_FOR_AUTOFILL", "APPROVE_AUTOFILL_DOMAIN"],
+    description: "Add a domain to the autofill whitelist. Requires explicit user confirmation (confirmed: true). Persisted to the local profile store.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime, message, _state, options) => {
+        if (!(await hasOwnerAccess(runtime, message))) {
+            return failure("ADD_AUTOFILL_WHITELIST", "PERMISSION_DENIED");
+        }
+        const params = options?.parameters ?? {};
+        const rawDomain = (params.domain ?? "").toString().trim();
+        if (!rawDomain) {
+            return failure("ADD_AUTOFILL_WHITELIST", "MISSING_DOMAIN");
+        }
+        const normalized = extractRegistrableDomain(rawDomain);
+        if (!normalized) {
+            return failure("ADD_AUTOFILL_WHITELIST", "INVALID_DOMAIN", {
+                input: rawDomain,
+            });
+        }
+        if (params.confirmed !== true) {
+            return failure("ADD_AUTOFILL_WHITELIST", "CONFIRMATION_REQUIRED", {
+                domain: normalized,
+            });
+        }
+        const existing = await loadUserDomains(runtime);
+        const existingNormalized = existing
+            .map((e) => normalizeAutofillDomain(e))
+            .filter((v) => v !== null);
+        const alreadyShipped = DEFAULT_AUTOFILL_WHITELIST.includes(normalized);
+        const alreadyUser = existingNormalized.includes(normalized);
+        if (alreadyShipped || alreadyUser) {
+            return {
+                text: `Domain ${normalized} already whitelisted.`,
+                success: true,
+                values: { success: true, domain: normalized, added: false },
+                data: {
+                    actionName: "ADD_AUTOFILL_WHITELIST",
+                    domain: normalized,
+                    added: false,
+                    source: alreadyShipped ? "default" : "user",
+                },
+            };
+        }
+        const next = [...existingNormalized, normalized];
+        await saveUserDomains(runtime, next);
+        logger.info({ action: "ADD_AUTOFILL_WHITELIST", domain: normalized }, `[ADD_AUTOFILL_WHITELIST] added ${normalized} to user whitelist`);
+        return {
+            text: `Added ${normalized} to the autofill whitelist.`,
+            success: true,
+            values: { success: true, domain: normalized, added: true },
+            data: {
+                actionName: "ADD_AUTOFILL_WHITELIST",
+                domain: normalized,
+                added: true,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "domain",
+            description: "Domain to add. Stored as a registrable domain (e.g. 'example.com'). Subdomains are covered by the parent entry.",
+            schema: { type: "string" },
+        },
+        {
+            name: "confirmed",
+            description: "Must be explicitly true. Required to ensure the user approved the addition, not the agent.",
+            schema: { type: "boolean" },
+        },
+    ],
+};
+export const listAutofillWhitelistAction = {
+    name: "LIST_AUTOFILL_WHITELIST",
+    similes: ["SHOW_AUTOFILL_WHITELIST", "GET_AUTOFILL_WHITELIST"],
+    description: "List effective autofill whitelist entries: the bundled defaults plus user-added entries.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime, message) => {
+        if (!(await hasOwnerAccess(runtime, message))) {
+            return failure("LIST_AUTOFILL_WHITELIST", "PERMISSION_DENIED");
+        }
+        const user = await loadUserDomains(runtime);
+        const effective = await effectiveWhitelist(runtime);
+        return {
+            text: `Autofill whitelist (${effective.length} entries): ${effective.join(", ")}`,
+            success: true,
+            values: {
+                success: true,
+                count: effective.length,
+            },
+            data: {
+                actionName: "LIST_AUTOFILL_WHITELIST",
+                defaults: [...DEFAULT_AUTOFILL_WHITELIST],
+                userAdded: [...user],
+                effective: [...effective],
+            },
+        };
+    },
+    parameters: [],
+};
+export const __internal = {
+    effectiveWhitelist,
+    loadUserDomains,
+    saveUserDomains,
+    WHITELIST_CACHE_KEY,
+};

package/apps/app-lifeops/src/actions/browser-extension.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Agent-side actions that bridge the LifeOps browser extension to the
+ * LifeOps agent runtime (plan §6.13 — T8e).
+ *
+ * REGISTER_BROWSER_SESSION
+ *   Invoked when the extension announces itself at startup. Persists the
+ *   deviceId and vendor metadata in the runtime cache so subsequent
+ *   context requests can find the active browser session.
+ *
+ * FETCH_BROWSER_ACTIVITY
+ *   Reads the most recent per-domain time report pushed by the
+ *   extension. The actual WebSocket listener lives at the runtime level
+ *   (see `BrowserExtensionBridge`); this action exposes the stored data
+ *   to the agent's reasoning loop.
+ */
+import type { Action } from "@elizaos/core";
+export declare const registerBrowserSessionAction: Action;
+export declare const fetchBrowserActivityAction: Action;
+//# sourceMappingURL=browser-extension.d.ts.map

package/apps/app-lifeops/src/actions/browser-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-extension.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/browser-extension.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAmCvB,eAAO,MAAM,4BAA4B,EAAE,MAyC1C,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,MAwCxC,CAAC"}

package/apps/app-lifeops/src/actions/browser-extension.js

@@ -0,0 +1,88 @@
+/**
+ * Agent-side actions that bridge the LifeOps browser extension to the
+ * LifeOps agent runtime (plan §6.13 — T8e).
+ *
+ * REGISTER_BROWSER_SESSION
+ *   Invoked when the extension announces itself at startup. Persists the
+ *   deviceId and vendor metadata in the runtime cache so subsequent
+ *   context requests can find the active browser session.
+ *
+ * FETCH_BROWSER_ACTIVITY
+ *   Reads the most recent per-domain time report pushed by the
+ *   extension. The actual WebSocket listener lives at the runtime level
+ *   (see `BrowserExtensionBridge`); this action exposes the stored data
+ *   to the agent's reasoning loop.
+ */
+import { hasLifeOpsAccess } from "./lifeops-google-helpers.js";
+import { getBrowserActivitySnapshot, recordBrowserSessionRegistration, } from "../lifeops/browser-extension-store.js";
+const REGISTER_NAME = "REGISTER_BROWSER_SESSION";
+const FETCH_NAME = "FETCH_BROWSER_ACTIVITY";
+function getParams(options) {
+    const params = options?.parameters;
+    return (params ?? {});
+}
+function toVendor(value) {
+    if (value === "chrome" || value === "safari") {
+        return value;
+    }
+    return "unknown";
+}
+export const registerBrowserSessionAction = {
+    name: REGISTER_NAME,
+    similes: ["BROWSER_EXTENSION_REGISTER", "ANNOUNCE_BROWSER_SESSION"],
+    description: "Record that a LifeOps browser extension has announced itself. Parameters: deviceId, userAgent, extensionVersion, browserVendor.",
+    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+    handler: async (runtime, message, _state, options, callback) => {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            const text = "Browser session registration is restricted to the owner.";
+            await callback?.({ text });
+            return { text, success: false, data: { error: "PERMISSION_DENIED" } };
+        }
+        const params = getParams(options);
+        const deviceId = params.deviceId?.trim();
+        if (!deviceId) {
+            const text = "REGISTER_BROWSER_SESSION requires a deviceId.";
+            await callback?.({ text });
+            return { text, success: false, data: { error: "MISSING_DEVICE_ID" } };
+        }
+        const registration = {
+            deviceId,
+            userAgent: params.userAgent?.trim() ?? "",
+            extensionVersion: params.extensionVersion?.trim() ?? "0.0.0",
+            browserVendor: toVendor(params.browserVendor),
+            registeredAt: new Date().toISOString(),
+        };
+        await recordBrowserSessionRegistration(runtime, registration);
+        const text = `Registered browser session ${deviceId} (${registration.browserVendor}).`;
+        await callback?.({ text, source: "action", action: REGISTER_NAME });
+        return { text, success: true, data: { registration } };
+    },
+};
+export const fetchBrowserActivityAction = {
+    name: FETCH_NAME,
+    similes: ["BROWSER_ACTIVITY", "GET_BROWSER_ACTIVITY", "TIME_ON_SITE"],
+    description: "Return the most recent per-domain focus time pushed by the LifeOps browser extension. Parameters: deviceId (optional), limit (optional, default 10).",
+    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+    handler: async (runtime, message, _state, options, callback) => {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            const text = "Browser activity is restricted to the owner.";
+            await callback?.({ text });
+            return { text, success: false, data: { error: "PERMISSION_DENIED" } };
+        }
+        const params = getParams(options);
+        const limit = typeof params.limit === "number" && params.limit > 0 ? Math.floor(params.limit) : 10;
+        const snapshot = await getBrowserActivitySnapshot(runtime, {
+            deviceId: params.deviceId?.trim(),
+            limit,
+        });
+        if (snapshot.domains.length === 0) {
+            const text = "No browser activity has been reported yet.";
+            await callback?.({ text, source: "action", action: FETCH_NAME });
+            return { text, success: true, data: { snapshot } };
+        }
+        const lines = snapshot.domains.map((d) => `- ${d.domain}: ${Math.round(d.focusMs / 1000)}s (${d.sessionCount} session${d.sessionCount === 1 ? "" : "s"})`);
+        const text = `Browser activity (device ${snapshot.deviceId ?? "any"}, window ending ${snapshot.windowEnd}):\n${lines.join("\n")}`;
+        await callback?.({ text, source: "action", action: FETCH_NAME });
+        return { text, success: true, data: { snapshot } };
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/calendar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKN,aAAa,EACb,MAAM,EACN,KAAK,EACN,MAAM,eAAe,CAAC;AAgDvB,KAAK,iBAAiB,GAClB,MAAM,GACN,YAAY,GACZ,eAAe,GACf,cAAc,GACd,cAAc,GACd,cAAc,GACd,aAAa,CAAC;AAiBlB,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACpC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AA67DF,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,MAAM,EAAE,MAAM,EACd,QAAQ,SAA2B,GAClC,OAAO,CAAC,eAAe,CAAC,CAuJ1B;AAm/BD,eAAO,MAAM,cAAc,EAAE,MAAM,GAAG;IACpC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAioC1C,CAAC"}
+{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/calendar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKN,aAAa,EACb,MAAM,EACN,KAAK,EACN,MAAM,eAAe,CAAC;AAwCvB,KAAK,iBAAiB,GAClB,MAAM,GACN,YAAY,GACZ,eAAe,GACf,cAAc,GACd,cAAc,GACd,cAAc,GACd,aAAa,CAAC;AAuBlB,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACpC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AA0pCF,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,MAAM,EAAE,MAAM,EACd,QAAQ,SAA2B,GAClC,OAAO,CAAC,eAAe,CAAC,CAsJ1B;AAu8BD,eAAO,MAAM,cAAc,EAAE,MAAM,GAAG;IACpC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAyjC1C,CAAC"}