@elizaos/ui 2.0.0-alpha.382 → 2.0.0-alpha.385

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

@@ -1,475 +0,0 @@
-/**
- * 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 { extractActionParamsViaLlm, hasOwnerAccess } from "@elizaos/agent";
-import { DEFAULT_AUTOFILL_WHITELIST, extractRegistrableDomain, isUrlWhitelisted, normalizeAutofillDomain, } from "../lifeops/autofill-whitelist.js";
-import { requireFeatureEnabled } from "../lifeops/feature-flags.js";
-import { FeatureNotEnabledError } from "../lifeops/feature-flags.types.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)) {
-        throw new Error("AUTOFILL_WHITELIST_CACHE_UNAVAILABLE");
-    }
-    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 one specific field via the installed password manager (1Password or ProtonPass). Use this only when the current tab URL and exact field purpose are already known. Refuses on domains not in the user's autofill whitelist. Credentials never pass through the agent — the extension resolves them locally. Do not use this for whole portal-upload or broader browser workflows; those belong to LIFEOPS_COMPUTER_USE.",
-    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");
-        }
-        try {
-            await requireFeatureEnabled(runtime, "browser.automation");
-        }
-        catch (error) {
-            if (error instanceof FeatureNotEnabledError) {
-                return failure("REQUEST_FIELD_FILL", error.code, {
-                    featureKey: error.featureKey,
-                    message: error.message,
-                });
-            }
-            throw error;
-        }
-        const rawParams = options?.parameters ?? {};
-        const params = (await extractActionParamsViaLlm({
-            runtime,
-            message,
-            state,
-            actionName: "REQUEST_FIELD_FILL",
-            actionDescription: requestFieldFillAction.description ?? "",
-            paramSchema: requestFieldFillAction.parameters ?? [],
-            existingParams: rawParams,
-            requiredFields: ["tabUrl", "fieldPurpose"],
-        }));
-        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" },
-        },
-    ],
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "Can you log me into github? I'm on the sign-in page.",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Requested password autofill on github.com via the browser extension.",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "Fill in my email on this signup form.",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Requested email autofill on example.com via the browser extension.",
-                },
-            },
-        ],
-    ],
-};
-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 rawParams = options?.parameters ?? {};
-        const params = (await extractActionParamsViaLlm({
-            runtime,
-            message,
-            state,
-            actionName: "ADD_AUTOFILL_WHITELIST",
-            actionDescription: addAutofillWhitelistAction.description ?? "",
-            paramSchema: addAutofillWhitelistAction.parameters ?? [],
-            existingParams: rawParams,
-            requiredFields: ["domain"],
-        }));
-        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];
-        try {
-            await saveUserDomains(runtime, next);
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            logger.warn({ action: "ADD_AUTOFILL_WHITELIST", domain: normalized, detail }, `[ADD_AUTOFILL_WHITELIST] failed to persist ${normalized}: ${detail}`);
-            return failure("ADD_AUTOFILL_WHITELIST", "PERSISTENCE_UNAVAILABLE", {
-                domain: normalized,
-                detail,
-            });
-        }
-        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" },
-        },
-    ],
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "Yes, trust notion.so for autofill going forward.",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Added notion.so to the autofill whitelist.",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "Go ahead and approve linear.app for password autofill.",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Added linear.app to the autofill whitelist.",
-                },
-            },
-        ],
-    ],
-};
-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: [],
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "Which sites are allowed for autofill right now?",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Autofill whitelist (4 entries): github.com, notion.so, linear.app, example.com",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "Show me my trusted sites.",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Autofill whitelist (3 entries): github.com, notion.so, linear.app",
-                },
-            },
-        ],
-    ],
-};
-export const __internal = {
-    effectiveWhitelist,
-    loadUserDomains,
-    saveUserDomains,
-    WHITELIST_CACHE_KEY,
-};

package/apps/app-lifeops/src/actions/book-travel-executor.d.ts

@@ -1,9 +0,0 @@
-import type { ActionResult, HandlerCallback, IAgentRuntime } from "@elizaos/core";
-import type { ApprovalQueue, ApprovalRequest } from "../lifeops/approval-queue.types.js";
-export declare function executeApprovedBookTravel(args: {
-    runtime: IAgentRuntime;
-    queue: ApprovalQueue;
-    request: ApprovalRequest;
-    callback?: HandlerCallback;
-}): Promise<ActionResult>;
-//# sourceMappingURL=book-travel-executor.d.ts.map

package/apps/app-lifeops/src/actions/book-travel-executor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"book-travel-executor.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/book-travel-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EAChB,MAAM,oCAAoC,CAAC;AAI5C,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B,GAAG,OAAO,CAAC,YAAY,CAAC,CAmExB"}

package/apps/app-lifeops/src/actions/book-travel-executor.js

@@ -1,65 +0,0 @@
-import { LifeOpsService } from "../lifeops/service.js";
-import { INTERNAL_URL } from "./lifeops-google-helpers.js";
-export async function executeApprovedBookTravel(args) {
-    if (args.request.payload.action !== "book_travel") {
-        throw new Error("executeApprovedBookTravel received a non-travel request");
-    }
-    const payload = args.request.payload;
-    if (payload.kind !== "flight") {
-        throw new Error(`Unsupported travel kind: ${payload.kind}`);
-    }
-    if (!payload.offerId && !payload.search) {
-        throw new Error("Approved travel booking is missing offer/search context");
-    }
-    const passengers = Array.isArray(payload.passengers)
-        ? payload.passengers
-        : [];
-    if (passengers.length === 0) {
-        throw new Error("Approved travel booking is missing passenger details");
-    }
-    await args.queue.markExecuting(args.request.id);
-    const service = new LifeOpsService(args.runtime);
-    const booked = await service.bookFlightItinerary(INTERNAL_URL, {
-        offerId: payload.offerId ?? null,
-        search: payload.search ?? null,
-        passengers,
-        calendarSync: payload.calendarSync ?? null,
-    });
-    const done = await args.queue.markDone(args.request.id);
-    const route = payload.summary?.trim() || `${booked.offer.id}`;
-    const bookingReference = booked.order.bookingReference
-        ? ` Booking reference: ${booked.order.bookingReference}.`
-        : "";
-    const paymentText = booked.payment
-        ? ` Payment ${booked.payment.id} captured for ${booked.payment.amount} ${booked.payment.currency}.`
-        : "";
-    const calendarText = booked.calendarEvent
-        ? ` Synced to calendar as "${booked.calendarEvent.title}".`
-        : "";
-    const text = `Booked ${route}.${bookingReference}${paymentText}${calendarText}`.trim();
-    if (args.callback) {
-        await args.callback({ text });
-    }
-    return {
-        text,
-        success: true,
-        values: {
-            success: true,
-            requestId: done.id,
-            bookingReference: booked.order.bookingReference,
-            orderId: booked.order.id,
-            paymentId: booked.payment?.id ?? null,
-            calendarEventId: booked.calendarEvent?.id ?? null,
-        },
-        data: {
-            actionName: "BOOK_TRAVEL",
-            requestId: done.id,
-            state: done.state,
-            bookingReference: booked.order.bookingReference,
-            orderId: booked.order.id,
-            paymentId: booked.payment?.id ?? null,
-            calendarEventId: booked.calendarEvent?.id ?? null,
-            offerId: booked.offer.id,
-        },
-    };
-}

package/apps/app-lifeops/src/actions/book-travel.d.ts

@@ -1,5 +0,0 @@
-import type { Action } from "@elizaos/core";
-export declare const bookTravelAction: Action & {
-    suppressPostActionContinuation?: boolean;
-};
-//# sourceMappingURL=book-travel.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"book-travel.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/book-travel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,eAAe,CAAC;AAgRvB,eAAO,MAAM,gBAAgB,EAAE,MAAM,GAAG;IACtC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CA6U1C,CAAC"}