@elizaos/agent 2.0.0-alpha.441 → 2.0.0-alpha.501

package/apps/app-lifeops/src/lifeops/service-mixin-scheduling.js

@@ -78,15 +78,11 @@ export function withScheduling(Base) {
                     name: relationship.name,
                 };
             }
-            const email = typeof relationship.email === "string"
-                ? relationship.email.trim()
-                : "";
+            const email = typeof relationship.email === "string" ? relationship.email.trim() : "";
             if (email) {
                 return { channel: "email", target: email, name: relationship.name };
             }
-            const phone = typeof relationship.phone === "string"
-                ? relationship.phone.trim()
-                : "";
+            const phone = typeof relationship.phone === "string" ? relationship.phone.trim() : "";
             if (phone) {
                 return { channel: "sms", target: phone, name: relationship.name };
             }
@@ -147,10 +143,10 @@ export function withScheduling(Base) {
                         break;
                     }
                     case "sms": {
-                        fail(501, `SCHEDULING_DISPATCH_UNAVAILABLE: sms dispatch for scheduling is not wired (counterparty phone=${contact.target}). Use OWNER_SEND_MESSAGE for SMS.`);
+                        return fail(501, `SCHEDULING_DISPATCH_UNAVAILABLE: sms dispatch for scheduling is not wired (counterparty phone=${contact.target}). Use OWNER_SEND_MESSAGE for SMS.`);
                     }
                     default: {
-                        fail(501, `SCHEDULING_DISPATCH_UNAVAILABLE: unsupported channel ${contact.channel}`);
+                        return fail(501, `SCHEDULING_DISPATCH_UNAVAILABLE: unsupported channel ${contact.channel}`);
                     }
                 }
             }
@@ -178,8 +174,7 @@ export function withScheduling(Base) {
                 agentId: this.agentId(),
                 subject,
                 relationshipId: input.relationshipId ?? null,
-                durationMinutes: typeof input.durationMinutes === "number" &&
-                    input.durationMinutes > 0
+                durationMinutes: typeof input.durationMinutes === "number" && input.durationMinutes > 0
                     ? Math.floor(input.durationMinutes)
                     : 30,
                 timezone: input.timezone ?? "UTC",

package/apps/app-lifeops/src/lifeops/service-mixin-screentime.js

@@ -2,6 +2,7 @@
 import crypto from "node:crypto";
 import { getActivityReportBetween } from "../activity-profile/activity-tracker-reporting.js";
 import { isSystemInactivityApp } from "../activity-profile/system-inactivity-apps.js";
+import { browserBridgeCompanionIsRecent, browserBridgePermissionsReady, isBrowserBridgePaused, } from "./browser-readiness.js";
 import { fail } from "./service-normalize.js";
 import { classifyScreenTimeTarget, isSocialCategory, } from "./social-taxonomy.js";
 function isoNow() {
@@ -22,6 +23,7 @@ function computeDurationSeconds(startAt, endAt, provided) {
     const delta = Math.max(0, Math.floor((endMs - startMs) / 1000));
     return delta;
 }
+const DAY_MS = 86_400_000;
 function resolveUtcDateWindow(date) {
     const startIso = `${date}T00:00:00.000Z`;
     const endIso = `${date}T23:59:59.999Z`;
@@ -42,6 +44,98 @@ function buildWindowBounds(since, until) {
     }
     return { sinceMs, untilMs };
 }
+function startOfLocalDay(date) {
+    const start = new Date(date);
+    start.setHours(0, 0, 0, 0);
+    return start;
+}
+function addDays(date, days) {
+    const next = new Date(date);
+    next.setDate(next.getDate() + days);
+    return next;
+}
+function screenTimeRangeLabel(range) {
+    switch (range) {
+        case "today":
+            return "Today";
+        case "this-week":
+            return "This Week";
+        case "7d":
+            return "Last 7d";
+        case "30d":
+            return "Last 30d";
+    }
+}
+function computeScreenTimeRange(range, now = new Date()) {
+    const until = now.toISOString();
+    if (range === "today") {
+        return { since: startOfLocalDay(now).toISOString(), until };
+    }
+    if (range === "this-week") {
+        const startToday = startOfLocalDay(now);
+        const dayOfWeek = startToday.getDay();
+        return { since: addDays(startToday, -dayOfWeek).toISOString(), until };
+    }
+    if (range === "7d") {
+        return { since: addDays(startOfLocalDay(now), -6).toISOString(), until };
+    }
+    return { since: addDays(startOfLocalDay(now), -29).toISOString(), until };
+}
+function computePriorScreenTimeRange(range, current) {
+    if (range === "today") {
+        return null;
+    }
+    const sinceMs = Date.parse(current.since);
+    const untilMs = Date.parse(current.until);
+    const spanMs = untilMs - sinceMs;
+    return {
+        since: new Date(sinceMs - spanMs).toISOString(),
+        until: current.since,
+    };
+}
+function enumerateHistoryDays(period) {
+    const days = [];
+    const endMs = Date.parse(period.until);
+    let cursor = startOfLocalDay(new Date(Date.parse(period.since)));
+    while (cursor.getTime() <= endMs) {
+        const dayStart = cursor;
+        const dayEnd = addDays(dayStart, 1);
+        days.push({
+            date: dayStart.toISOString().slice(0, 10),
+            since: dayStart.toISOString(),
+            until: new Date(Math.min(dayEnd.getTime(), endMs)).toISOString(),
+            label: new Intl.DateTimeFormat(undefined, {
+                month: "numeric",
+                day: "numeric",
+            }).format(dayStart),
+        });
+        cursor = dayEnd;
+    }
+    return days;
+}
+function deltaPercent(current, prior) {
+    if (prior <= 0) {
+        return current > 0 ? null : 0;
+    }
+    return Math.round(((current - prior) / prior) * 100);
+}
+function bucketSeconds(buckets, key) {
+    return buckets.find((item) => item.key === key)?.totalSeconds ?? 0;
+}
+function serviceSeconds(summary, key) {
+    return summary.services.find((item) => item.key === key)?.totalSeconds ?? 0;
+}
+function normalizeIdentifierFilter(identifier) {
+    const normalized = identifier?.trim();
+    return normalized && normalized.length > 0 ? normalized : null;
+}
+function filterRowsByIdentifier(rows, identifier) {
+    const normalized = normalizeIdentifierFilter(identifier);
+    if (!normalized) {
+        return rows;
+    }
+    return rows.filter((row) => row.identifier === normalized);
+}
 function clipSessionDurationSeconds(session, windowStartMs, windowEndMs) {
     const sessionStartMs = Date.parse(session.startAt);
     if (!Number.isFinite(sessionStartMs)) {
@@ -264,6 +358,107 @@ function toBreakdownItems(rows, topN) {
         fetchedAt: isoNow(),
     };
 }
+function buildScreenTimeMetrics(breakdown, social, priorBreakdown, priorSocial) {
+    const totalSeconds = breakdown.totalSeconds;
+    const appSeconds = bucketSeconds(breakdown.bySource, "app");
+    const webSeconds = bucketSeconds(breakdown.bySource, "website");
+    const phoneSeconds = bucketSeconds(breakdown.byDevice, "phone");
+    const socialSeconds = social.totalSeconds;
+    const youtubeSeconds = serviceSeconds(social, "youtube");
+    const xSeconds = serviceSeconds(social, "x");
+    const messageOpened = social.messages.opened;
+    const messageOutbound = social.messages.outbound;
+    const messageInbound = social.messages.inbound;
+    if (!priorBreakdown || !priorSocial) {
+        return {
+            totalSeconds,
+            appSeconds,
+            webSeconds,
+            phoneSeconds,
+            socialSeconds,
+            youtubeSeconds,
+            xSeconds,
+            messageOpened,
+            messageOutbound,
+            messageInbound,
+            deltas: null,
+        };
+    }
+    return {
+        totalSeconds,
+        appSeconds,
+        webSeconds,
+        phoneSeconds,
+        socialSeconds,
+        youtubeSeconds,
+        xSeconds,
+        messageOpened,
+        messageOutbound,
+        messageInbound,
+        deltas: {
+            totalPercent: deltaPercent(totalSeconds, priorBreakdown.totalSeconds),
+            appPercent: deltaPercent(appSeconds, bucketSeconds(priorBreakdown.bySource, "app")),
+            webPercent: deltaPercent(webSeconds, bucketSeconds(priorBreakdown.bySource, "website")),
+            phonePercent: deltaPercent(phoneSeconds, bucketSeconds(priorBreakdown.byDevice, "phone")),
+            socialPercent: deltaPercent(socialSeconds, priorSocial.totalSeconds),
+            youtubePercent: deltaPercent(youtubeSeconds, serviceSeconds(priorSocial, "youtube")),
+            xPercent: deltaPercent(xSeconds, serviceSeconds(priorSocial, "x")),
+            messageOpenedPercent: deltaPercent(messageOpened, priorSocial.messages.opened),
+        },
+    };
+}
+function buildVisibleBuckets(breakdown, social) {
+    const categories = breakdown.byCategory.filter((item) => item.totalSeconds > 0);
+    const devices = breakdown.byDevice.filter((item) => item.totalSeconds > 0);
+    const browsers = breakdown.byBrowser.filter((item) => item.totalSeconds > 0);
+    const services = social.services.filter((item) => item.totalSeconds > 0);
+    const surfaces = social.surfaces.filter((item) => item.totalSeconds > 0);
+    const topTargets = breakdown.items
+        .filter((item) => item.totalSeconds > 0)
+        .map((item) => ({
+        key: `${item.source}:${item.identifier}`,
+        label: item.displayName,
+        totalSeconds: item.totalSeconds,
+        source: item.source,
+        identifier: item.identifier,
+    }));
+    const sessionBuckets = social.sessions
+        .filter((item) => item.totalSeconds > 0)
+        .map((item) => ({
+        key: `${item.source}:${item.identifier}`,
+        label: item.serviceLabel ?? item.displayName,
+        totalSeconds: item.totalSeconds,
+        source: item.source,
+        identifier: item.identifier,
+    }));
+    const channels = social.messages.channels.filter((channel) => channel.opened > 0 || channel.outbound > 0 || channel.inbound > 0);
+    const hasMessageActivity = social.messages.opened > 0 ||
+        social.messages.outbound > 0 ||
+        social.messages.inbound > 0;
+    const setupSources = social.dataSources.filter((source) => source.state !== "live");
+    return {
+        categories,
+        devices,
+        browsers,
+        services,
+        surfaces,
+        topTargets,
+        sessionBuckets,
+        channels,
+        setupSources,
+        hasMessageActivity,
+        hasUsage: breakdown.totalSeconds > 0 ||
+            categories.length > 0 ||
+            devices.length > 0 ||
+            browsers.length > 0 ||
+            topTargets.length > 0 ||
+            social.totalSeconds > 0 ||
+            services.length > 0 ||
+            surfaces.length > 0 ||
+            sessionBuckets.length > 0 ||
+            hasMessageActivity,
+    };
+}
 function inWindow(iso, sinceMs, untilMs) {
     if (!iso)
         return false;
@@ -301,7 +496,10 @@ function androidPackageLabel(packageName) {
             return packageName;
     }
 }
-function androidUsageRowsFromSignals(signals) {
+function androidUsageRowsFromSignals(signals, sinceMs, untilMs) {
+    if (untilMs - sinceMs > DAY_MS) {
+        return [];
+    }
     const byPackage = new Map();
     for (const signal of signals) {
         const screenTime = asRecord(signal.metadata.screenTime);
@@ -333,6 +531,85 @@ function androidUsageRowsFromSignals(signals) {
     }
     return [...byPackage.values()];
 }
+function mobileScreenTimeDataSourceFromSignals(signals, platform) {
+    const platformSignals = signals.filter((signal) => signal.platform === platform &&
+        (signal.source === "mobile_device" || signal.source === "mobile_health"));
+    if (platformSignals.length === 0) {
+        return {
+            state: "unwired",
+            statusLabel: "Not connected",
+            detail: platform === "android"
+                ? "No recent Android Usage Stats signal has been received."
+                : "No recent iOS Screen Time signal has been received.",
+        };
+    }
+    for (const signal of platformSignals) {
+        const screenTime = asRecord(signal.metadata.screenTime);
+        if (!screenTime)
+            continue;
+        if (platform === "android") {
+            return screenTime.granted === true
+                ? {
+                    state: "partial",
+                    statusLabel: "Snapshot only",
+                    detail: "Android currently provides rolling Usage Stats snapshots; multi-day totals exclude Android until daily exports are wired.",
+                }
+                : {
+                    state: "partial",
+                    statusLabel: "Permission needed",
+                    detail: "Android Usage Stats permission has not been granted.",
+                };
+        }
+        const authorization = asRecord(screenTime.authorization);
+        if (authorization?.status === "approved") {
+            return {
+                state: "partial",
+                statusLabel: "Export pending",
+                detail: "iOS Screen Time authorization is present, but usage export is not wired yet.",
+            };
+        }
+        return screenTime.supported === true
+            ? {
+                state: "partial",
+                statusLabel: "Authorization needed",
+                detail: "iOS Screen Time setup has not been approved.",
+            }
+            : {
+                state: "unwired",
+                statusLabel: "Unsupported",
+                detail: "This iOS device has not reported Screen Time support.",
+            };
+    }
+    return {
+        state: "partial",
+        statusLabel: "Signal incomplete",
+        detail: "Recent mobile signals did not include screen-time metadata.",
+    };
+}
+function browserTrackingDataSourceState(settings, companions) {
+    if (!settings.enabled || settings.trackingMode === "off") {
+        return "unwired";
+    }
+    if (isBrowserBridgePaused(settings)) {
+        return "partial";
+    }
+    if (companions.length === 0) {
+        return "unwired";
+    }
+    const connectedCompanions = companions.filter((companion) => companion.connectionState === "connected");
+    if (connectedCompanions.length === 0) {
+        return companions.some((companion) => companion.connectionState === "permission_blocked")
+            ? "partial"
+            : "unwired";
+    }
+    const recentConnectedCompanions = connectedCompanions.filter((companion) => browserBridgeCompanionIsRecent(companion));
+    if (recentConnectedCompanions.length === 0) {
+        return "partial";
+    }
+    return recentConnectedCompanions.some((companion) => browserBridgePermissionsReady(settings, companion.permissions))
+        ? "live"
+        : "partial";
+}
 /** @internal */
 export function withScreenTime(Base) {
     class LifeOpsScreenTimeServiceMixin extends Base {
@@ -395,13 +672,13 @@ export function withScreenTime(Base) {
                     limit: 200,
                 });
                 rows.push(...androidUsageRowsFromSignals(mobileSignals.filter((signal) => signal.platform === "android" &&
-                    inWindow(signal.observedAt, sinceMs, untilMs))));
+                    inWindow(signal.observedAt, sinceMs, untilMs)), sinceMs, untilMs));
             }
             if (!opts.source || opts.source === "website") {
                 const websiteSessions = await this.repository.listScreenTimeSessionsOverlapping(this.agentId(), opts.since, opts.until, { source: "website" });
                 rows.push(...aggregateWebsiteSessions(websiteSessions, sinceMs, untilMs));
             }
-            return rows;
+            return filterRowsByIdentifier(rows, opts.identifier);
         }
         async getScreenTimeDaily(opts) {
             const { startIso, endIso } = resolveUtcDateWindow(opts.date);
@@ -409,6 +686,7 @@ export function withScreenTime(Base) {
                 since: startIso,
                 until: endIso,
                 source: opts.source,
+                identifier: opts.identifier,
             });
             const dailyRows = toDailyRows(this.agentId(), opts.date, rows);
             return dailyRows.slice(0, opts.limit ?? dailyRows.length);
@@ -444,6 +722,14 @@ export function withScreenTime(Base) {
             const xOutbound = xReceivedWindowDms.length - xInbound;
             const xOpened = xDms.filter((dm) => inWindow(dm.readAt, sinceMs, untilMs)).length;
             const xReplied = xDms.filter((dm) => inWindow(dm.repliedAt, sinceMs, untilMs)).length;
+            const [browserSettings, browserCompanions, recentMobileSignals] = await Promise.all([
+                this.getBrowserSettings(),
+                this.listBrowserCompanions(),
+                this.repository.listActivitySignals(this.agentId(), {
+                    sinceAt: new Date(Date.now() - 7 * 24 * 60 * 60_000).toISOString(),
+                    limit: 100,
+                }),
+            ]);
             const messageChannels = [
                 {
                     channel: "x_dm",
@@ -454,8 +740,9 @@ export function withScreenTime(Base) {
                     replied: xReplied,
                 },
             ];
-            const hasBrowserRows = socialRows.some((row) => row.source === "website");
-            const hasPhoneRows = socialRows.some((row) => row.device === "phone" || row.device === "tablet");
+            const browserState = browserTrackingDataSourceState(browserSettings, browserCompanions);
+            const androidState = mobileScreenTimeDataSourceFromSignals(recentMobileSignals, "android");
+            const iosState = mobileScreenTimeDataSourceFromSignals(recentMobileSignals, "ios");
             return {
                 since: opts.since,
                 until: opts.until,
@@ -473,27 +760,102 @@ export function withScreenTime(Base) {
                     replied: xReplied,
                 },
                 dataSources: [
-                    { id: "macos_activity", label: "Mac apps", state: "live" },
+                    {
+                        id: "macos_activity",
+                        label: "Mac apps",
+                        state: "live",
+                        statusLabel: "Live",
+                        detail: "macOS app focus events are included in screen-time totals.",
+                    },
                     {
                         id: "browser_bridge",
-                        label: "Chrome/Safari",
-                        state: hasBrowserRows ? "live" : "partial",
+                        label: "Browser",
+                        state: browserState,
+                        statusLabel: browserState === "live"
+                            ? "Live"
+                            : browserState === "partial"
+                                ? "Needs attention"
+                                : "Not connected",
+                        detail: browserState === "live"
+                            ? "Browser focus sessions are included in website totals."
+                            : browserState === "partial"
+                                ? "Browser tracking is enabled but permissions, recency, or pause state are incomplete."
+                                : "Browser tracking is disabled or no companion is connected.",
                     },
                     {
                         id: "android_usage_stats",
                         label: "Android apps",
-                        state: hasPhoneRows ? "live" : "partial",
+                        ...androidState,
+                    },
+                    {
+                        id: "ios_device_activity",
+                        label: "iOS apps",
+                        ...iosState,
                     },
-                    { id: "ios_device_activity", label: "iOS apps", state: "unwired" },
                 ],
                 fetchedAt: isoNow(),
             };
         }
+        async getScreenTimeHistory(opts) {
+            const window = computeScreenTimeRange(opts.range);
+            const priorWindow = computePriorScreenTimeRange(opts.range, window);
+            const [breakdown, social, priorBreakdown, priorSocial] = await Promise.all([
+                this.getScreenTimeBreakdown({
+                    since: window.since,
+                    until: window.until,
+                    topN: opts.topN,
+                }),
+                this.getSocialHabitSummary({
+                    since: window.since,
+                    until: window.until,
+                    topN: opts.socialTopN,
+                }),
+                priorWindow
+                    ? this.getScreenTimeBreakdown({
+                        since: priorWindow.since,
+                        until: priorWindow.until,
+                        topN: opts.topN,
+                    })
+                    : Promise.resolve(null),
+                priorWindow
+                    ? this.getSocialHabitSummary({
+                        since: priorWindow.since,
+                        until: priorWindow.until,
+                        topN: opts.socialTopN,
+                    })
+                    : Promise.resolve(null),
+            ]);
+            const history = opts.range === "today"
+                ? []
+                : await Promise.all(enumerateHistoryDays(window).map(async (day) => {
+                    const summary = await this.getScreenTimeSummary({
+                        since: day.since,
+                        until: day.until,
+                    });
+                    return {
+                        ...day,
+                        totalSeconds: summary.totalSeconds,
+                    };
+                }));
+            return {
+                range: opts.range,
+                label: screenTimeRangeLabel(opts.range),
+                window,
+                priorWindow,
+                breakdown,
+                social,
+                history,
+                metrics: buildScreenTimeMetrics(breakdown, social, priorBreakdown, priorSocial),
+                visible: buildVisibleBuckets(breakdown, social),
+                fetchedAt: isoNow(),
+            };
+        }
         async getScreenTimeWeeklyAverageByApp(opts) {
             const summary = await this.getScreenTimeSummary({
                 since: opts.since,
                 until: opts.until,
                 source: "app",
+                identifier: opts.identifier,
                 topN: opts.topN,
             });
             const daysInWindow = Math.max(1, Math.floor(opts.daysInWindow));