@elizaos/agent 0.25.9 → 2.0.0-alpha.151

package/apps/app-lifeops/src/lifeops/x-poster.js

@@ -0,0 +1,148 @@
+import crypto from "node:crypto";
+import { logger } from "@elizaos/core";
+import { createIntegrationTelemetrySpan } from "@elizaos/agent/diagnostics/integration-observability";
+const X_POST_URL = "https://api.twitter.com/2/tweets";
+function percentEncode(value) {
+    return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function buildSignatureBaseString(method, url, params) {
+    const sorted = Object.keys(params)
+        .sort()
+        .map((key) => `${percentEncode(key)}=${percentEncode(params[key])}`)
+        .join("&");
+    return `${method.toUpperCase()}&${percentEncode(url)}&${percentEncode(sorted)}`;
+}
+function buildSigningKey(apiSecret, tokenSecret) {
+    return `${percentEncode(apiSecret)}&${percentEncode(tokenSecret)}`;
+}
+function signOAuth1(baseString, signingKey) {
+    return crypto
+        .createHmac("sha1", signingKey)
+        .update(baseString)
+        .digest("base64");
+}
+function buildOAuth1AuthorizationHeader(args) {
+    const { method, url, credentials, nonce, timestamp } = args;
+    const oauthParams = {
+        oauth_consumer_key: credentials.apiKey,
+        oauth_nonce: nonce,
+        oauth_signature_method: "HMAC-SHA1",
+        oauth_timestamp: timestamp,
+        oauth_token: credentials.accessToken,
+        oauth_version: "1.0",
+    };
+    const baseString = buildSignatureBaseString(method, url, oauthParams);
+    const signingKey = buildSigningKey(credentials.apiSecretKey, credentials.accessTokenSecret);
+    oauthParams.oauth_signature = signOAuth1(baseString, signingKey);
+    const header = Object.keys(oauthParams)
+        .sort()
+        .map((key) => `${percentEncode(key)}="${percentEncode(oauthParams[key])}"`)
+        .join(", ");
+    return `OAuth ${header}`;
+}
+function classifyStatus(status) {
+    if (status >= 200 && status < 300)
+        return "success";
+    if (status === 401 || status === 403)
+        return "auth";
+    if (status === 429)
+        return "rate_limit";
+    return "unknown";
+}
+export function readXPosterCredentialsFromEnv(env = process.env) {
+    const apiKey = env.TWITTER_API_KEY?.trim();
+    const apiSecretKey = env.TWITTER_API_SECRET_KEY?.trim();
+    const accessToken = env.TWITTER_ACCESS_TOKEN?.trim();
+    const accessTokenSecret = env.TWITTER_ACCESS_TOKEN_SECRET?.trim();
+    if (!apiKey || !apiSecretKey || !accessToken || !accessTokenSecret) {
+        return null;
+    }
+    return {
+        apiKey,
+        apiSecretKey,
+        accessToken,
+        accessTokenSecret,
+    };
+}
+export async function postToX(args) {
+    const { text, credentials } = args;
+    const span = createIntegrationTelemetrySpan({
+        boundary: "lifeops",
+        operation: "x_post",
+        timeoutMs: 12_000,
+    });
+    const nonce = crypto.randomBytes(16).toString("hex");
+    const timestamp = String(Math.floor(Date.now() / 1000));
+    const authorization = buildOAuth1AuthorizationHeader({
+        method: "POST",
+        url: X_POST_URL,
+        credentials,
+        nonce,
+        timestamp,
+    });
+    try {
+        const response = await fetch(X_POST_URL, {
+            method: "POST",
+            headers: {
+                Authorization: authorization,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ text }),
+            signal: AbortSignal.timeout(12_000),
+        });
+        const payload = (await response.json().catch(() => ({})));
+        const category = classifyStatus(response.status);
+        if (!response.ok) {
+            const errorMessage = payload.errors?.[0]?.detail ??
+                payload.errors?.[0]?.message ??
+                payload.detail ??
+                payload.title ??
+                `HTTP ${response.status}`;
+            logger.warn({
+                boundary: "lifeops",
+                integration: "x",
+                operation: "x_post",
+                statusCode: response.status,
+                category,
+            }, `[lifeops] X post failed: ${errorMessage}`);
+            span.failure({
+                statusCode: response.status,
+                errorKind: category,
+            });
+            return {
+                ok: false,
+                status: response.status,
+                error: errorMessage,
+                category,
+            };
+        }
+        span.success({
+            statusCode: response.status,
+        });
+        return {
+            ok: true,
+            status: response.status,
+            postId: payload.data?.id,
+            category,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error({
+            boundary: "lifeops",
+            integration: "x",
+            operation: "x_post",
+            err: error instanceof Error ? error : undefined,
+        }, `[lifeops] X post failed: ${errorMessage}`);
+        span.failure({
+            error,
+            errorKind: "network",
+        });
+        return {
+            ok: false,
+            status: null,
+            error: errorMessage,
+            category: "network",
+        };
+    }
+}

package/apps/app-lifeops/src/plugin.d.ts

@@ -0,0 +1,22 @@
+import { type Plugin } from "@elizaos/core";
+import { manageLifeOpsBrowserAction } from "./action.ts";
+import { lifeOpsBrowserProvider } from "./provider.ts";
+import { LifeOpsBrowserPluginService } from "./service.ts";
+export declare const appLifeOpsPlugin: Plugin;
+export declare const lifeOpsBrowserPlugin: Plugin;
+export { LifeOpsBrowserPluginService, lifeOpsBrowserProvider, manageLifeOpsBrowserAction, };
+export { calendarAction } from "./actions/calendar.js";
+export { gmailAction } from "./actions/gmail.js";
+export { inboxAction } from "./actions/inbox.js";
+export { lifeAction } from "./actions/life.js";
+export { updateOwnerProfileAction } from "./actions/update-owner-profile.js";
+export { inboxTriageProvider } from "./providers/inbox-triage.js";
+export { lifeOpsProvider } from "./providers/lifeops.js";
+export { handleLifeOpsRoutes } from "./routes/lifeops-routes.js";
+export type { LifeOpsRouteContext } from "./routes/lifeops-routes.js";
+export { handleWebsiteBlockerRoutes } from "./routes/website-blocker-routes.js";
+export type { WebsiteBlockerRouteContext } from "./routes/website-blocker-routes.js";
+export { ensureLifeOpsSchedulerTask, registerLifeOpsTaskWorker, executeLifeOpsSchedulerTask, resolveLifeOpsTaskIntervalMs, LIFEOPS_TASK_NAME, LIFEOPS_TASK_TAGS, LIFEOPS_TASK_INTERVAL_MS, LIFEOPS_TASK_JITTER_MS, } from "./lifeops/runtime.js";
+export * from "./selfcontrol/index.ts";
+export default appLifeOpsPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/apps/app-lifeops/src/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-lifeops/src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAExE,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAkG3D,eAAO,MAAM,gBAAgB,EAAE,MAG9B,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAmB,CAAC;AAErD,OAAO,EACL,2BAA2B,EAC3B,sBAAsB,EACtB,0BAA0B,GAC3B,CAAC;AAGF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,YAAY,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,YAAY,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAGrF,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC3B,4BAA4B,EAC5B,iBAAiB,EACjB,iBAAiB,EACjB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAE9B,cAAc,wBAAwB,CAAC;AAEvC,eAAe,gBAAgB,CAAC"}

package/apps/app-lifeops/src/plugin.js

@@ -0,0 +1,92 @@
+import { logger } from "@elizaos/core";
+import { gatePluginSessionForHostedApp } from "@elizaos/agent/services/app-session-gate";
+import { manageLifeOpsBrowserAction } from "./action.js";
+import { lifeOpsBrowserProvider } from "./provider.js";
+import { LifeOpsBrowserPluginService } from "./service.js";
+import { blockWebsitesAction, getWebsiteBlockStatusAction, requestWebsiteBlockingPermissionAction, unblockWebsitesAction, } from "./selfcontrol/action.js";
+import { websiteBlockerProvider } from "./selfcontrol/provider.js";
+import { getSelfControlStatus, setSelfControlPluginConfig, } from "./selfcontrol/selfcontrol.js";
+import { WebsiteBlockerService } from "./selfcontrol/service.js";
+// LifeOps core actions (calendar, gmail, life/tasks, goals, inbox, owner profile)
+import { calendarAction } from "./actions/calendar.js";
+import { gmailAction } from "./actions/gmail.js";
+import { inboxAction } from "./actions/inbox.js";
+import { lifeAction } from "./actions/life.js";
+import { updateOwnerProfileAction } from "./actions/update-owner-profile.js";
+// LifeOps core providers
+import { inboxTriageProvider } from "./providers/inbox-triage.js";
+import { lifeOpsProvider } from "./providers/lifeops.js";
+// LifeOps runtime (scheduler task worker + registration)
+import { ensureLifeOpsSchedulerTask, registerLifeOpsTaskWorker, } from "./lifeops/runtime.js";
+const rawAppLifeOpsPlugin = {
+    name: "@elizaos/app-lifeops",
+    description: "LifeOps: routines, goals, Google Workspace, Apple Reminders, Twilio, browser companions (Chrome/Safari), hosts-file website blocking, and related surfaces.",
+    actions: [
+        manageLifeOpsBrowserAction,
+        blockWebsitesAction,
+        getWebsiteBlockStatusAction,
+        requestWebsiteBlockingPermissionAction,
+        unblockWebsitesAction,
+        calendarAction,
+        gmailAction,
+        inboxAction,
+        lifeAction,
+        updateOwnerProfileAction,
+    ],
+    providers: [
+        lifeOpsBrowserProvider,
+        websiteBlockerProvider,
+        lifeOpsProvider,
+        inboxTriageProvider,
+    ],
+    services: [LifeOpsBrowserPluginService, WebsiteBlockerService],
+    init: async (pluginConfig, runtime) => {
+        setSelfControlPluginConfig(pluginConfig);
+        const status = await getSelfControlStatus();
+        if (status.available) {
+            logger.info(`[selfcontrol] Hosts-file blocker ready${status.active && status.endsAt ? ` until ${status.endsAt}` : status.active ? " until manually unblocked" : ""}`);
+        }
+        else {
+            logger.warn(`[selfcontrol] Plugin loaded, but local website blocking is unavailable: ${status.reason ?? "unknown reason"}`);
+        }
+        // Register the LifeOps scheduler task worker and ensure the scheduler task exists
+        registerLifeOpsTaskWorker(runtime);
+        void (async () => {
+            const DELAYS = [2_000, 5_000, 10_000];
+            for (let attempt = 0; attempt <= DELAYS.length; attempt++) {
+                try {
+                    await ensureLifeOpsSchedulerTask(runtime);
+                    return;
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    if (attempt < DELAYS.length) {
+                        runtime.logger?.warn?.(`[lifeops] Scheduler task init failed (attempt ${attempt + 1}/${DELAYS.length + 1}), retrying in ${DELAYS[attempt]}ms: ${msg}`);
+                        await new Promise((r) => setTimeout(r, DELAYS[attempt]));
+                    }
+                    else {
+                        runtime.logger?.error?.(`[lifeops] Scheduler task init failed after ${DELAYS.length + 1} attempts — LifeOps scheduler is NOT running: ${msg}`);
+                    }
+                }
+            }
+        })();
+    },
+};
+export const appLifeOpsPlugin = gatePluginSessionForHostedApp(rawAppLifeOpsPlugin, "@elizaos/app-lifeops");
+export const lifeOpsBrowserPlugin = appLifeOpsPlugin;
+export { LifeOpsBrowserPluginService, lifeOpsBrowserProvider, manageLifeOpsBrowserAction, };
+// LifeOps core exports
+export { calendarAction } from "./actions/calendar.js";
+export { gmailAction } from "./actions/gmail.js";
+export { inboxAction } from "./actions/inbox.js";
+export { lifeAction } from "./actions/life.js";
+export { updateOwnerProfileAction } from "./actions/update-owner-profile.js";
+export { inboxTriageProvider } from "./providers/inbox-triage.js";
+export { lifeOpsProvider } from "./providers/lifeops.js";
+// Routes (consumed by agent server.ts via import)
+export { handleLifeOpsRoutes } from "./routes/lifeops-routes.js";
+export { handleWebsiteBlockerRoutes } from "./routes/website-blocker-routes.js";
+// LifeOps runtime exports
+export { ensureLifeOpsSchedulerTask, registerLifeOpsTaskWorker, executeLifeOpsSchedulerTask, resolveLifeOpsTaskIntervalMs, LIFEOPS_TASK_NAME, LIFEOPS_TASK_TAGS, LIFEOPS_TASK_INTERVAL_MS, LIFEOPS_TASK_JITTER_MS, } from "./lifeops/runtime.js";
+export * from "./selfcontrol/index.js";
+export default appLifeOpsPlugin;

package/apps/app-lifeops/src/provider.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "@elizaos/core";
+export declare const lifeOpsBrowserProvider: Provider;
+//# sourceMappingURL=provider.d.ts.map

package/apps/app-lifeops/src/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-lifeops/src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAiCvB,eAAO,MAAM,sBAAsB,EAAE,QAiEpC,CAAC"}

package/apps/app-lifeops/src/provider.js

@@ -0,0 +1,75 @@
+import { LifeOpsService } from "./lifeops/service.js";
+import { hasAdminAccess } from "@elizaos/agent/security/access";
+function formatSettingsLine(settings) {
+    const status = settings.enabled ? settings.trackingMode : "off";
+    const control = settings.allowBrowserControl ? "control on" : "control off";
+    const paused = settings.pauseUntil
+        ? `, paused until ${settings.pauseUntil}`
+        : "";
+    return `LifeOps Browser: ${status}, ${control}${paused}.`;
+}
+function formatCompanionLine(companion) {
+    return `- ${companion.browser}/${companion.profileLabel || companion.profileId}: ${companion.connectionState}${companion.lastSeenAt ? `, seen ${companion.lastSeenAt}` : ""}`;
+}
+function formatTabLine(tab) {
+    const flags = [
+        tab.focusedActive ? "focused" : null,
+        tab.activeInWindow ? "active" : null,
+    ].filter(Boolean);
+    return `- ${tab.title} (${tab.browser}/${tab.profileId}${flags.length > 0 ? `, ${flags.join(", ")}` : ""}) ${tab.url}`;
+}
+export const lifeOpsBrowserProvider = {
+    name: "lifeops_browser",
+    description: "Owner/admin-only context for the user's personal Chrome and Safari LifeOps Browser companions. Separate from the Eliza browser workspace.",
+    dynamic: true,
+    position: 13,
+    async get(runtime, message, _state) {
+        if (!(await hasAdminAccess(runtime, message))) {
+            return { text: "", values: {}, data: {} };
+        }
+        const service = new LifeOpsService(runtime);
+        const [settings, companions, tabs, currentPage, sessions] = await Promise.all([
+            service.getBrowserSettings(),
+            service.listBrowserCompanions(),
+            service.listBrowserTabs(),
+            service.getCurrentBrowserPage(),
+            service.listBrowserSessions(),
+        ]);
+        const activeSessions = sessions.filter((session) => session.status === "awaiting_confirmation" ||
+            session.status === "queued" ||
+            session.status === "running");
+        const lines = [
+            "## LifeOps Browser",
+            "This is the user's personal browser companion, not the Eliza browser workspace.",
+            formatSettingsLine(settings),
+            `Companions: ${companions.length}. Active sessions: ${activeSessions.length}.`,
+        ];
+        if (currentPage) {
+            lines.push(`Current page: ${currentPage.title} ${currentPage.url}`);
+        }
+        if (companions.length > 0) {
+            lines.push("Companion status:");
+            lines.push(...companions.slice(0, 4).map(formatCompanionLine));
+        }
+        if (tabs.length > 0) {
+            lines.push("Remembered tabs:");
+            lines.push(...tabs.slice(0, 6).map(formatTabLine));
+        }
+        return {
+            text: lines.join("\n"),
+            values: {
+                lifeOpsBrowserEnabled: settings.enabled,
+                lifeOpsBrowserTrackingMode: settings.trackingMode,
+                lifeOpsBrowserControlEnabled: settings.allowBrowserControl,
+                lifeOpsBrowserCurrentUrl: currentPage?.url ?? "",
+            },
+            data: {
+                settings,
+                companions,
+                tabs,
+                currentPage,
+                sessions: activeSessions,
+            },
+        };
+    },
+};

package/apps/app-lifeops/src/providers/inbox-triage.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "@elizaos/core";
+export declare const inboxTriageProvider: Provider;
+//# sourceMappingURL=inbox-triage.d.ts.map

package/apps/app-lifeops/src/providers/inbox-triage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox-triage.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/providers/inbox-triage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAYvB,eAAO,MAAM,mBAAmB,EAAE,QA2FjC,CAAC"}

package/apps/app-lifeops/src/providers/inbox-triage.js

@@ -0,0 +1,89 @@
+import { logger } from "@elizaos/core";
+import { hasAdminAccess } from "@elizaos/agent/security/access";
+import { InboxTriageRepository } from "../inbox/repository.js";
+const EMPTY = {
+    text: "",
+    values: { inboxUnresolved: 0, inboxUrgent: 0 },
+    data: {},
+};
+export const inboxTriageProvider = {
+    name: "inboxTriage",
+    description: "Injects pending inbox triage items into admin context. Shows urgent messages, " +
+        "items needing reply, and recent auto-replies across all channels including email. " +
+        "Use INBOX_RESPOND to draft and send replies. Use INBOX_TRIAGE to scan for new messages. " +
+        "Use INBOX_DIGEST for a daily summary.",
+    dynamic: true,
+    position: 14, // after lifeops (12), before escalation (15)
+    async get(runtime, message, _state) {
+        if (!(await hasAdminAccess(runtime, message))) {
+            return EMPTY;
+        }
+        let repo;
+        try {
+            repo = new InboxTriageRepository(runtime);
+        }
+        catch {
+            return EMPTY;
+        }
+        let urgent;
+        let needsReply;
+        let recentAutoReplies;
+        try {
+            [urgent, needsReply, recentAutoReplies] = await Promise.all([
+                repo.getByClassification("urgent", { limit: 5 }),
+                repo.getByClassification("needs_reply", { limit: 10 }),
+                repo.getRecentAutoReplies(5),
+            ]);
+        }
+        catch (error) {
+            logger.debug("[inbox-triage-provider] DB query failed (schema may not exist yet):", String(error));
+            return EMPTY;
+        }
+        const unresolved = urgent.length + needsReply.length;
+        if (unresolved === 0 && recentAutoReplies.length === 0) {
+            return EMPTY;
+        }
+        const lines = [`# Inbox: ${unresolved} items pending`];
+        if (urgent.length > 0) {
+            lines.push("\n## Urgent");
+            for (const item of urgent.slice(0, 3)) {
+                lines.push(formatEntry(item));
+            }
+        }
+        if (needsReply.length > 0) {
+            lines.push("\n## Needs Reply");
+            for (const item of needsReply.slice(0, 5)) {
+                lines.push(formatEntry(item));
+            }
+        }
+        if (recentAutoReplies.length > 0) {
+            lines.push("\n## Recent Auto-Replies");
+            for (const item of recentAutoReplies) {
+                const draftPreview = item.draftResponse
+                    ? `"${item.draftResponse.slice(0, 60)}..."`
+                    : "(no draft)";
+                lines.push(`- Sent to ${item.channelName}: ${draftPreview}`);
+            }
+        }
+        lines.push("\nSay 'respond to [name/channel]' to draft and send replies.");
+        return {
+            text: lines.join("\n"),
+            values: {
+                inboxUnresolved: unresolved,
+                inboxUrgent: urgent.length,
+                inboxNeedsReply: needsReply.length,
+            },
+            data: {
+                urgentItems: urgent,
+                needsReplyItems: needsReply,
+                recentAutoReplies,
+            },
+        };
+    },
+};
+function formatEntry(entry) {
+    const senderInfo = entry.senderName ? ` from ${entry.senderName}` : "";
+    const link = entry.deepLink ? `\n  ${entry.deepLink}` : "";
+    return (`- **${entry.channelName}**${senderInfo} (${entry.source}): "${entry.snippet.slice(0, 80)}"` +
+        link);
+}

package/apps/app-lifeops/src/providers/lifeops.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "@elizaos/core";
+export declare const lifeOpsProvider: Provider;
+//# sourceMappingURL=lifeops.d.ts.map

package/apps/app-lifeops/src/providers/lifeops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeops.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/providers/lifeops.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAkFvB,eAAO,MAAM,eAAe,EAAE,QA2H7B,CAAC"}

package/apps/app-lifeops/src/providers/lifeops.js

@@ -0,0 +1,157 @@
+import { hasLifeOpsAccess } from "../actions/lifeops-google-helpers.js";
+import { readLifeOpsOwnerProfile, } from "../lifeops/owner-profile.js";
+import { LifeOpsService } from "../lifeops/service.js";
+const INTERNAL_URL = new URL("http://127.0.0.1/");
+function formatCount(label, count) {
+    return `${label}: ${count}`;
+}
+function summarizeOccurrences(title, occurrences) {
+    if (occurrences.length === 0) {
+        return [];
+    }
+    return [
+        title,
+        ...occurrences
+            .slice(0, 3)
+            .map((occurrence) => `- ${occurrence.title} (${occurrence.state})`),
+    ];
+}
+function formatRelativeMinutes(minutes) {
+    if (minutes <= 0)
+        return "now";
+    if (minutes < 60)
+        return `${Math.round(minutes)}m`;
+    const hours = Math.floor(minutes / 60);
+    const remaining = Math.round(minutes % 60);
+    if (remaining === 0)
+        return `${hours}h`;
+    return `${hours}h ${remaining}m`;
+}
+function summarizeNextEvent(context) {
+    if (!context.event) {
+        return [];
+    }
+    const event = context.event;
+    const timing = context.startsInMinutes !== null
+        ? ` (${formatRelativeMinutes(context.startsInMinutes)})`
+        : "";
+    const lines = [`Next event: ${event.title}${timing}`];
+    if (context.attendeeNames.length > 0) {
+        lines.push(`  With: ${context.attendeeNames.slice(0, 3).join(", ")}`);
+    }
+    if (context.location) {
+        lines.push(`  At: ${context.location}`);
+    }
+    return lines;
+}
+function summarizeGmailTriage(summary) {
+    const parts = [];
+    if (summary.unreadCount > 0)
+        parts.push(`${summary.unreadCount} unread`);
+    if (summary.importantNewCount > 0)
+        parts.push(`${summary.importantNewCount} important`);
+    if (summary.likelyReplyNeededCount > 0)
+        parts.push(`${summary.likelyReplyNeededCount} needing reply`);
+    if (parts.length === 0) {
+        return [];
+    }
+    return [`Inbox: ${parts.join(", ")}`];
+}
+function summarizeOwnerProfile(profile) {
+    return [
+        `Owner profile: name=${profile.name} | relationship=${profile.relationshipStatus} | partner=${profile.partnerName} | orientation=${profile.orientation} | gender=${profile.gender} | age=${profile.age} | location=${profile.location}`,
+    ];
+}
+export const lifeOpsProvider = {
+    name: "lifeops",
+    description: "Owner, explicitly granted users, and the agent only. Provides the current LifeOps overview, upcoming calendar event, and email triage summary. Use LIFE for habits, reminders, alarms, and goals. Use CALENDAR_ACTION for Google Calendar reads/search/create-event tasks. Use GMAIL_ACTION for Gmail triage, search, draft, and send flows. Available in private owner or granted conversations, including Discord.",
+    dynamic: true,
+    position: 12,
+    async get(runtime, message, _state) {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            return { text: "", values: {}, data: {} };
+        }
+        const service = new LifeOpsService(runtime);
+        const ownerProfile = await readLifeOpsOwnerProfile(runtime);
+        const overview = await service.getOverview();
+        const ownerLines = summarizeOccurrences("Owner active items:", overview.owner.occurrences);
+        const agentLines = summarizeOccurrences("Agent ops:", overview.agentOps.occurrences);
+        const calendarLines = [];
+        const emailLines = [];
+        let nextEventContext = null;
+        let gmailSummary = null;
+        try {
+            const status = await service.getGoogleConnectorStatus(INTERNAL_URL);
+            if (status.connected) {
+                const capabilities = status.grantedCapabilities ?? [];
+                const hasCalendar = capabilities.some((c) => c.startsWith("google.calendar"));
+                const hasGmail = capabilities.some((c) => c.startsWith("google.gmail"));
+                if (hasCalendar) {
+                    try {
+                        nextEventContext =
+                            await service.getNextCalendarEventContext(INTERNAL_URL);
+                        calendarLines.push(...summarizeNextEvent(nextEventContext));
+                    }
+                    catch {
+                        // Calendar fetch failed — skip silently, don't break the provider
+                    }
+                }
+                if (hasGmail) {
+                    try {
+                        const triage = await service.getGmailTriage(INTERNAL_URL, {
+                            maxResults: 5,
+                        });
+                        gmailSummary = triage.summary;
+                        emailLines.push(...summarizeGmailTriage(triage.summary));
+                    }
+                    catch {
+                        // Gmail fetch failed — skip silently, don't break the provider
+                    }
+                }
+            }
+        }
+        catch {
+            // Google connector not configured — skip calendar/email context entirely
+        }
+        return {
+            text: [
+                "## Life Ops",
+                "Use LIFE when the user wants to create, manage, complete, or query tasks, habits, goals, reminders, alarms, escalation, or routines.",
+                "Use CALENDAR_ACTION for calendar questions, event search, next-event context, and creating Google Calendar events.",
+                "Use GMAIL_ACTION for inbox triage, emails needing a reply, Gmail search, reply drafts, and confirmed send flows.",
+                "Use UPDATE_OWNER_PROFILE to silently store stable owner-only profile details when the canonical owner clearly reveals them. Do not ask just to fill blanks.",
+                "When the owner asks about their stable personal details for LifeOps, answer from the stored owner profile values below. If a field is not n/a, treat it as known instead of saying it is missing.",
+                "Owner life-ops are private to the owner, explicitly granted users, and the agent. Agent ops are internal and should stay separated unless explicitly requested.",
+                ...summarizeOwnerProfile(ownerProfile),
+                formatCount("Owner open occurrences", overview.owner.summary.activeOccurrenceCount),
+                formatCount("Owner active goals", overview.owner.summary.activeGoalCount),
+                formatCount("Owner live reminders", overview.owner.summary.activeReminderCount),
+                ...ownerLines,
+                ...calendarLines,
+                ...emailLines,
+                formatCount("Agent open occurrences", overview.agentOps.summary.activeOccurrenceCount),
+                formatCount("Agent active goals", overview.agentOps.summary.activeGoalCount),
+                ...agentLines,
+            ].join("\n"),
+            values: {
+                ownerOpenOccurrences: overview.owner.summary.activeOccurrenceCount,
+                ownerActiveGoals: overview.owner.summary.activeGoalCount,
+                ownerProfileName: ownerProfile.name,
+                ownerRelationshipStatus: ownerProfile.relationshipStatus,
+                ownerPartnerName: ownerProfile.partnerName,
+                ownerOrientation: ownerProfile.orientation,
+                ownerGender: ownerProfile.gender,
+                ownerAge: ownerProfile.age,
+                ownerLocation: ownerProfile.location,
+                agentOpenOccurrences: overview.agentOps.summary.activeOccurrenceCount,
+                agentActiveGoals: overview.agentOps.summary.activeGoalCount,
+            },
+            data: {
+                ownerProfile,
+                overview,
+                nextEventContext,
+                gmailSummary,
+            },
+        };
+    },
+};

package/apps/app-lifeops/src/routes/lifeops-browser-packaging.d.ts

@@ -0,0 +1,16 @@
+import type { LifeOpsBrowserCompanionPackageStatus, LifeOpsBrowserCompanionReleaseManifest, LifeOpsBrowserKind } from "@elizaos/shared/contracts/lifeops";
+export declare function buildLifeOpsBrowserReleaseManifestForVersion(rawVersion: string, env?: NodeJS.ProcessEnv): LifeOpsBrowserCompanionReleaseManifest | null;
+export declare function resolveLifeOpsBrowserReleaseManifest(artifactsDir: string | null, options?: {
+    allowSynthesis?: boolean;
+    version?: string;
+    env?: NodeJS.ProcessEnv;
+}): LifeOpsBrowserCompanionReleaseManifest | null;
+export declare function resolveLifeOpsBrowserExtensionPath(): string | null;
+export declare function getLifeOpsBrowserCompanionPackageStatus(): LifeOpsBrowserCompanionPackageStatus;
+export declare function getLifeOpsBrowserCompanionDownloadFile(browser: LifeOpsBrowserKind): {
+    path: string;
+    filename: string;
+    contentType: string;
+};
+export declare function buildLifeOpsBrowserCompanionPackage(browser: LifeOpsBrowserKind): Promise<LifeOpsBrowserCompanionPackageStatus>;
+//# sourceMappingURL=lifeops-browser-packaging.d.ts.map

package/apps/app-lifeops/src/routes/lifeops-browser-packaging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeops-browser-packaging.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/routes/lifeops-browser-packaging.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,oCAAoC,EACpC,sCAAsC,EACtC,kBAAkB,EACnB,MAAM,mCAAmC,CAAC;AAkO3C,wBAAgB,4CAA4C,CAC1D,UAAU,EAAE,MAAM,EAClB,GAAG,oBAAc,GAChB,sCAAsC,GAAG,IAAI,CA2E/C;AAqBD,wBAAgB,oCAAoC,CAClD,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,OAAO,CAAC,EAAE;IACR,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB,GACA,sCAAsC,GAAG,IAAI,CAc/C;AAqCD,wBAAgB,kCAAkC,IAAI,MAAM,GAAG,IAAI,CAElE;AAED,wBAAgB,uCAAuC,IAAI,oCAAoC,CAgC9F;AAED,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,kBAAkB,GAC1B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAczD;AAED,wBAAsB,mCAAmC,CACvD,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,oCAAoC,CAAC,CAa/C"}