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

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

@@ -0,0 +1,181 @@
+/**
+ * In-process store for browser-extension session registrations and the
+ * recent per-domain focus reports they push.
+ *
+ * This is intentionally a simple runtime-scoped cache. The canonical
+ * long-lived store is the LifeOps browser-session tables managed by
+ * `service-mixin-browser.ts`; that mixin predates this task and has its
+ * own `CreateLifeOpsBrowserSession` flow. Browser activity is short-window
+ * telemetry, so the action layer keeps a bounded in-memory history here
+ * and aggregates across that history on demand.
+ */
+const STORE_KEY = Symbol.for("lifeops.browser-extension.store");
+const MAX_REPORT_HISTORY = 2_048;
+const MAX_REPORT_AGE_MS = 30 * 24 * 60 * 60 * 1_000;
+function getStore(runtime) {
+    const host = runtime;
+    const existing = host[STORE_KEY];
+    if (existing) {
+        return existing;
+    }
+    const created = { registrations: new Map(), reports: [] };
+    host[STORE_KEY] = created;
+    return created;
+}
+function parseIsoMs(value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function normalizeReport(report) {
+    const windowStartMs = parseIsoMs(report.windowStart);
+    const windowEndMs = parseIsoMs(report.windowEnd);
+    if (windowStartMs === null ||
+        windowEndMs === null ||
+        windowEndMs <= windowStartMs) {
+        return null;
+    }
+    return {
+        deviceId: report.deviceId,
+        generatedAt: report.generatedAt ?? new Date(windowEndMs).toISOString(),
+        windowStart: new Date(windowStartMs).toISOString(),
+        windowEnd: new Date(windowEndMs).toISOString(),
+        domains: report.domains.map((domain) => ({
+            ...domain,
+            domain: domain.domain.trim().toLowerCase(),
+        })),
+    };
+}
+function trimReports(reports) {
+    if (reports.length === 0) {
+        return reports;
+    }
+    const newestEndMs = parseIsoMs(reports[reports.length - 1].windowEnd) ?? Date.now();
+    const earliestAllowedMs = newestEndMs - MAX_REPORT_AGE_MS;
+    const ageTrimmed = reports.filter((report) => {
+        const reportEndMs = parseIsoMs(report.windowEnd);
+        return reportEndMs !== null && reportEndMs >= earliestAllowedMs;
+    });
+    return ageTrimmed.slice(-MAX_REPORT_HISTORY);
+}
+function matchingReports(reports, deviceId) {
+    if (!deviceId) {
+        return [...reports];
+    }
+    return reports.filter((report) => report.deviceId === deviceId);
+}
+function domainsMatch(reportedDomain, requestedDomain) {
+    return (reportedDomain === requestedDomain ||
+        reportedDomain.endsWith(`.${requestedDomain}`) ||
+        requestedDomain.endsWith(`.${reportedDomain}`));
+}
+function domainFromUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return null;
+        }
+        const hostname = parsed.hostname.trim().toLowerCase().replace(/\.+$/, "");
+        return hostname || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function recordBrowserSessionRegistration(runtime, registration) {
+    const store = getStore(runtime);
+    store.registrations.set(registration.deviceId, registration);
+}
+export async function recordBrowserActivityReport(runtime, report) {
+    const store = getStore(runtime);
+    const normalized = normalizeReport(report);
+    if (!normalized) {
+        return;
+    }
+    store.reports = trimReports([...store.reports, normalized]);
+}
+export async function recordBrowserFocusWindow(runtime, args) {
+    const domain = domainFromUrl(args.url);
+    const windowStartMs = parseIsoMs(args.windowStart);
+    const windowEndMs = parseIsoMs(args.windowEnd);
+    if (!domain ||
+        windowStartMs === null ||
+        windowEndMs === null ||
+        windowEndMs <= windowStartMs) {
+        return false;
+    }
+    await recordBrowserActivityReport(runtime, {
+        deviceId: args.deviceId,
+        generatedAt: new Date(windowEndMs).toISOString(),
+        windowStart: new Date(windowStartMs).toISOString(),
+        windowEnd: new Date(windowEndMs).toISOString(),
+        domains: [
+            {
+                domain,
+                focusMs: windowEndMs - windowStartMs,
+                sessionCount: 1,
+                firstObservedAt: new Date(windowStartMs).toISOString(),
+                lastObservedAt: new Date(windowEndMs).toISOString(),
+            },
+        ],
+    });
+    return true;
+}
+export async function getBrowserActivitySnapshot(runtime, options) {
+    const store = getStore(runtime);
+    const reports = matchingReports(store.reports, options.deviceId);
+    const report = reports[reports.length - 1] ?? null;
+    if (!report) {
+        return {
+            deviceId: options.deviceId ?? null,
+            windowStart: new Date(0).toISOString(),
+            windowEnd: new Date(0).toISOString(),
+            domains: [],
+        };
+    }
+    const sorted = [...report.domains].sort((a, b) => b.focusMs - a.focusMs);
+    return {
+        deviceId: report.deviceId,
+        windowStart: report.windowStart,
+        windowEnd: report.windowEnd,
+        domains: sorted.slice(0, options.limit),
+    };
+}
+export async function getBrowserDomainActivity(runtime, options) {
+    const normalizedDomain = options.domain.trim().toLowerCase();
+    if (!normalizedDomain || options.untilMs <= options.sinceMs) {
+        return { totalMs: 0, reportCount: 0 };
+    }
+    const reports = matchingReports(getStore(runtime).reports, options.deviceId).filter((report) => {
+        const reportStartMs = parseIsoMs(report.windowStart);
+        const reportEndMs = parseIsoMs(report.windowEnd);
+        return (reportStartMs !== null &&
+            reportEndMs !== null &&
+            reportEndMs > options.sinceMs &&
+            reportStartMs < options.untilMs);
+    });
+    let totalMs = 0;
+    for (const report of reports) {
+        const reportStartMs = parseIsoMs(report.windowStart);
+        const reportEndMs = parseIsoMs(report.windowEnd);
+        if (reportStartMs === null || reportEndMs === null) {
+            continue;
+        }
+        const overlapStartMs = Math.max(reportStartMs, options.sinceMs);
+        const overlapEndMs = Math.min(reportEndMs, options.untilMs);
+        const overlapMs = Math.max(0, overlapEndMs - overlapStartMs);
+        const reportWindowMs = Math.max(1, reportEndMs - reportStartMs);
+        if (overlapMs === 0) {
+            continue;
+        }
+        const overlapRatio = overlapMs / reportWindowMs;
+        for (const domain of report.domains) {
+            if (domainsMatch(domain.domain, normalizedDomain)) {
+                totalMs += domain.focusMs * overlapRatio;
+            }
+        }
+    }
+    return { totalMs: Math.round(totalMs), reportCount: reports.length };
+}
+export function getRegisteredSessions(runtime) {
+    return Array.from(getStore(runtime).registrations.values());
+}

package/apps/app-lifeops/src/lifeops/calendly-client.d.ts

@@ -0,0 +1,61 @@
+export interface CalendlyCredentials {
+    personalAccessToken: string;
+    organizationUri?: string;
+    userUri?: string;
+}
+export interface CalendlyEventType {
+    uri: string;
+    name: string;
+    slug: string;
+    schedulingUrl: string;
+    durationMinutes: number;
+    active: boolean;
+}
+export interface CalendlyScheduledEvent {
+    uri: string;
+    name: string;
+    startTime: string;
+    endTime: string;
+    status: "active" | "canceled";
+    invitees: Array<{
+        name?: string;
+        email?: string;
+        status: string;
+    }>;
+}
+export interface CalendlyAvailability {
+    date: string;
+    slots: Array<{
+        startTime: string;
+        endTime: string;
+    }>;
+}
+export declare class CalendlyError extends Error {
+    readonly status: number;
+    readonly body?: unknown;
+    constructor(message: string, status: number, body?: unknown);
+}
+export declare function readCalendlyCredentialsFromEnv(env?: NodeJS.ProcessEnv): CalendlyCredentials | null;
+export declare function getCalendlyUser(creds: CalendlyCredentials): Promise<{
+    uri: string;
+    name: string;
+    email: string;
+    schedulingUrl: string;
+}>;
+export declare function listCalendlyEventTypes(creds: CalendlyCredentials): Promise<CalendlyEventType[]>;
+export declare function listCalendlyScheduledEvents(creds: CalendlyCredentials, opts?: {
+    minStartTime?: string;
+    maxStartTime?: string;
+    status?: "active" | "canceled";
+    limit?: number;
+}): Promise<CalendlyScheduledEvent[]>;
+export declare function getCalendlyAvailability(creds: CalendlyCredentials, eventTypeUri: string, opts: {
+    startDate: string;
+    endDate: string;
+    timezone?: string;
+}): Promise<CalendlyAvailability[]>;
+export declare function createCalendlySingleUseLink(creds: CalendlyCredentials, eventTypeUri: string): Promise<{
+    bookingUrl: string;
+    expiresAt: string;
+}>;
+//# sourceMappingURL=calendly-client.d.ts.map

package/apps/app-lifeops/src/lifeops/calendly-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendly-client.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/calendly-client.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,mBAAmB;IAClC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC9B,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtD;AAED,qBAAa,aAAc,SAAQ,KAAK;aAGpB,MAAM,EAAE,MAAM;aACd,IAAI,CAAC,EAAE,OAAO;gBAF9B,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO;CAKjC;AAMD,wBAAgB,8BAA8B,CAC5C,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,mBAAmB,GAAG,IAAI,CAY5B;AA8HD,wBAAsB,eAAe,CACnC,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAY9E;AAQD,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAY9B;AAED,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,mBAAmB,EAC1B,IAAI,GAAE;IACJ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,GACL,OAAO,CAAC,sBAAsB,EAAE,CAAC,CA8BnC;AAeD,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,mBAAmB,EAC1B,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9D,OAAO,CAAC,oBAAoB,EAAE,CAAC,CA0BjC;AAqBD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,mBAAmB,EAC1B,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAgBpD"}

package/apps/app-lifeops/src/lifeops/calendly-client.js

@@ -0,0 +1,218 @@
+import { logger } from "@elizaos/core";
+export class CalendlyError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "CalendlyError";
+    }
+}
+const CALENDLY_BASE_URL = process.env.MILADY_MOCK_CALENDLY_BASE ?? "https://api.calendly.com";
+const REQUEST_TIMEOUT_MS = 12_000;
+export function readCalendlyCredentialsFromEnv(env = process.env) {
+    const personalAccessToken = env.ELIZA_CALENDLY_TOKEN?.trim();
+    if (!personalAccessToken) {
+        return null;
+    }
+    const organizationUri = env.ELIZA_CALENDLY_ORG_URI?.trim() || undefined;
+    const userUri = env.ELIZA_CALENDLY_USER_URI?.trim() || undefined;
+    return {
+        personalAccessToken,
+        organizationUri,
+        userUri,
+    };
+}
+async function calendlyRequest(creds, path, init = {}) {
+    const url = path.startsWith("http") ? path : `${CALENDLY_BASE_URL}${path}`;
+    const response = await fetch(url, {
+        ...init,
+        headers: {
+            Authorization: `Bearer ${creds.personalAccessToken}`,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...(init.headers ?? {}),
+        },
+        signal: init.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+    const text = await response.text();
+    const body = text.length > 0 ? safeJsonParse(text) : undefined;
+    if (!response.ok) {
+        const message = extractErrorMessage(body) ?? `HTTP ${response.status}`;
+        logger.warn({
+            boundary: "lifeops",
+            integration: "calendly",
+            statusCode: response.status,
+            path,
+        }, `[lifeops] Calendly request failed: ${message}`);
+        throw new CalendlyError(message, response.status, body);
+    }
+    return body;
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function extractErrorMessage(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const record = body;
+    if (typeof record.message === "string")
+        return record.message;
+    if (typeof record.title === "string")
+        return record.title;
+    if (Array.isArray(record.details) && record.details.length > 0) {
+        const first = record.details[0];
+        if (first && typeof first === "object") {
+            const msg = first.message;
+            if (typeof msg === "string")
+                return msg;
+        }
+    }
+    return null;
+}
+async function paginate(creds, initialPath, limit) {
+    const out = [];
+    let nextPath = initialPath;
+    while (nextPath && out.length < limit) {
+        const page = await calendlyRequest(creds, nextPath);
+        if (Array.isArray(page.collection)) {
+            for (const item of page.collection) {
+                out.push(item);
+                if (out.length >= limit)
+                    break;
+            }
+        }
+        nextPath = page.pagination?.next_page ?? null;
+    }
+    return out;
+}
+export async function getCalendlyUser(creds) {
+    const response = await calendlyRequest(creds, "/users/me");
+    const user = response.resource;
+    return {
+        uri: user.uri,
+        name: user.name,
+        email: user.email,
+        schedulingUrl: user.scheduling_url,
+    };
+}
+async function resolveUserUri(creds) {
+    if (creds.userUri)
+        return creds.userUri;
+    const user = await getCalendlyUser(creds);
+    return user.uri;
+}
+export async function listCalendlyEventTypes(creds) {
+    const userUri = await resolveUserUri(creds);
+    const path = `/event_types?user=${encodeURIComponent(userUri)}&count=100`;
+    const raw = await paginate(creds, path, 500);
+    return raw.map((r) => ({
+        uri: r.uri,
+        name: r.name,
+        slug: r.slug,
+        schedulingUrl: r.scheduling_url,
+        durationMinutes: r.duration,
+        active: r.active,
+    }));
+}
+export async function listCalendlyScheduledEvents(creds, opts = {}) {
+    const userUri = await resolveUserUri(creds);
+    const limit = opts.limit ?? 50;
+    const query = new URLSearchParams({
+        user: userUri,
+        count: String(Math.min(limit, 100)),
+    });
+    if (opts.minStartTime)
+        query.set("min_start_time", opts.minStartTime);
+    if (opts.maxStartTime)
+        query.set("max_start_time", opts.maxStartTime);
+    if (opts.status)
+        query.set("status", opts.status);
+    const rawEvents = await paginate(creds, `/scheduled_events?${query.toString()}`, limit);
+    const enriched = [];
+    for (const event of rawEvents) {
+        const invitees = await fetchEventInvitees(creds, event.uri);
+        enriched.push({
+            uri: event.uri,
+            name: event.name,
+            startTime: event.start_time,
+            endTime: event.end_time,
+            status: event.status,
+            invitees,
+        });
+    }
+    return enriched;
+}
+async function fetchEventInvitees(creds, eventUri) {
+    const path = `${eventUri}/invitees`;
+    const raw = await paginate(creds, path, 100);
+    return raw.map((inv) => ({
+        name: inv.name,
+        email: inv.email,
+        status: inv.status,
+    }));
+}
+export async function getCalendlyAvailability(creds, eventTypeUri, opts) {
+    const query = new URLSearchParams({
+        event_type: eventTypeUri,
+        start_time: toIsoBoundary(opts.startDate, "start"),
+        end_time: toIsoBoundary(opts.endDate, "end"),
+    });
+    if (opts.timezone)
+        query.set("timezone", opts.timezone);
+    const response = await calendlyRequest(creds, `/event_type_available_times?${query.toString()}`);
+    const byDate = new Map();
+    for (const slot of response.collection ?? []) {
+        if (slot.status !== "available")
+            continue;
+        const start = new Date(slot.start_time);
+        const dateKey = toDateKey(start, opts.timezone);
+        const end = new Date(start.getTime() + 30 * 60 * 1000);
+        const entry = byDate.get(dateKey) ?? [];
+        entry.push({ startTime: slot.start_time, endTime: end.toISOString() });
+        byDate.set(dateKey, entry);
+    }
+    return Array.from(byDate.entries())
+        .map(([date, slots]) => ({ date, slots }))
+        .sort((a, b) => a.date.localeCompare(b.date));
+}
+function toIsoBoundary(date, boundary) {
+    if (date.includes("T"))
+        return date;
+    return boundary === "start" ? `${date}T00:00:00Z` : `${date}T23:59:59Z`;
+}
+function toDateKey(date, timezone) {
+    if (!timezone)
+        return date.toISOString().slice(0, 10);
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).formatToParts(date);
+    const year = parts.find((p) => p.type === "year")?.value ?? "1970";
+    const month = parts.find((p) => p.type === "month")?.value ?? "01";
+    const day = parts.find((p) => p.type === "day")?.value ?? "01";
+    return `${year}-${month}-${day}`;
+}
+export async function createCalendlySingleUseLink(creds, eventTypeUri) {
+    const response = await calendlyRequest(creds, "/scheduling_links", {
+        method: "POST",
+        body: JSON.stringify({
+            max_event_count: 1,
+            owner: eventTypeUri,
+            owner_type: "EventType",
+        }),
+    });
+    const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString();
+    return {
+        bookingUrl: response.resource.booking_url,
+        expiresAt,
+    };
+}

package/apps/app-lifeops/src/lifeops/checkin/checkin-service.d.ts

@@ -0,0 +1,24 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import type { CheckinReport, EscalationLevel, RecordAcknowledgementRequest, RunCheckinRequest } from "./types.js";
+/**
+ * Check-in engine (T9f). Assembles morning/night reports from existing LifeOps data
+ * and tracks acknowledgement state for tone escalation.
+ *
+ * CQRS: read methods return typed shapes; write methods return void or an id.
+ * Graceful degradation: if an upstream collector source is missing (e.g. no
+ * meetings table yet), the collector logs once per process and returns [].
+ */
+export declare const CHECKIN_REPORTS_TABLE = "life_checkin_reports";
+/** Exposed for tests that want to reset the process-level once-log. */
+export declare function __resetCheckinMissingSourceLog(): void;
+export declare class CheckinService {
+    private readonly runtime;
+    constructor(runtime: IAgentRuntime);
+    runMorningCheckin(request?: RunCheckinRequest): Promise<CheckinReport>;
+    runNightCheckin(request?: RunCheckinRequest): Promise<CheckinReport>;
+    getEscalationLevel(now?: Date): Promise<EscalationLevel>;
+    recordCheckinAcknowledgement(request: RecordAcknowledgementRequest): Promise<void>;
+    private runCheckin;
+    private persistReport;
+}
+//# sourceMappingURL=checkin-service.d.ts.map

package/apps/app-lifeops/src/lifeops/checkin/checkin-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkin-service.d.ts","sourceRoot":"","sources":["../../../../../../../../apps/app-lifeops/src/lifeops/checkin/checkin-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,KAAK,EAEV,aAAa,EACb,eAAe,EAIf,4BAA4B,EAC5B,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB;;;;;;;GAOG;AAEH,eAAO,MAAM,qBAAqB,yBAAyB,CAAC;AAY5D,uEAAuE;AACvE,wBAAgB,8BAA8B,IAAI,IAAI,CAErD;AAwJD,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,aAAa;IAE7C,iBAAiB,CACrB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,aAAa,CAAC;IAInB,eAAe,CACnB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,aAAa,CAAC;IAInB,kBAAkB,CAAC,GAAG,GAAE,IAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAoBpE,4BAA4B,CAChC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,IAAI,CAAC;YAkBF,UAAU;YAyBV,aAAa;CA0B5B"}