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

package/apps/app-lifeops/src/actions/screen-time.d.ts

@@ -1,8 +0,0 @@
-/**
- * LifeOps screen time action — query per-app and per-website dwell time.
- *
- * Subactions: summary, today, weekly, weekly_average_by_app, by_app, by_website.
- */
-import type { Action } from "@elizaos/core";
-export declare const screenTimeAction: Action;
-//# sourceMappingURL=screen-time.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"screen-time.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/screen-time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAoDvB,eAAO,MAAM,gBAAgB,EAAE,MA6P9B,CAAC"}

package/apps/app-lifeops/src/actions/screen-time.js

@@ -1,249 +0,0 @@
-/**
- * LifeOps screen time action — query per-app and per-website dwell time.
- *
- * Subactions: summary, today, weekly, weekly_average_by_app, by_app, by_website.
- */
-import { LifeOpsService } from "../lifeops/service.js";
-import { hasLifeOpsAccess } from "./lifeops-google-helpers.js";
-function getParams(options) {
-    const params = options?.parameters;
-    return params ?? {};
-}
-function todayIso() {
-    return new Date().toISOString().slice(0, 10);
-}
-function daysAgoIso(days) {
-    const d = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
-    return d.toISOString();
-}
-function formatSeconds(seconds) {
-    const s = Math.max(0, Math.floor(seconds));
-    const h = Math.floor(s / 3600);
-    const m = Math.floor((s % 3600) / 60);
-    if (h > 0) {
-        return `${h}h ${m}m`;
-    }
-    return `${m}m`;
-}
-function resolveWindowDays(value) {
-    const raw = typeof value === "number" && Number.isFinite(value) ? value : 7;
-    return Math.max(1, Math.floor(raw));
-}
-export const screenTimeAction = {
-    name: "SCREEN_TIME",
-    similes: ["SCREENTIME", "APP_USAGE", "WEBSITE_USAGE", "DWELL_TIME"],
-    description: "Query screen time summaries (per app, per website, daily). Use this for quantitative usage questions like 'how much screen time have I used today?', 'break down my screen time by app this week', or 'which websites did I spend the most time on?'. Do not use this when the user is only reflecting or venting like 'I spend too much time on my phone' unless they actually ask for the numbers. Subactions: summary, today, weekly, weekly_average_by_app, by_app, by_website.",
-    validate: async (runtime, message) => {
-        return hasLifeOpsAccess(runtime, message);
-    },
-    handler: async (runtime, message, _state, options, callback) => {
-        if (!(await hasLifeOpsAccess(runtime, message))) {
-            const text = "Screen time data is restricted to the owner.";
-            await callback?.({ text });
-            return { text, success: false, data: { error: "PERMISSION_DENIED" } };
-        }
-        const params = getParams(options);
-        const subaction = params.subaction ?? "summary";
-        const service = new LifeOpsService(runtime);
-        if (subaction === "today") {
-            const date = params.date ?? todayIso();
-            const daily = await service.getScreenTimeDaily({
-                date,
-                source: params.source,
-                limit: 10,
-            });
-            const total = daily.reduce((acc, row) => acc + row.totalSeconds, 0);
-            const text = daily.length === 0
-                ? `No screen time recorded for ${date}.`
-                : `Screen time for ${date} (total ${formatSeconds(total)}):\n${daily
-                    .map((row) => `- ${row.source}: ${row.identifier} — ${formatSeconds(row.totalSeconds)} (${row.sessionCount} session${row.sessionCount === 1 ? "" : "s"})`)
-                    .join("\n")}`;
-            await callback?.({ text, source: "action", action: "SCREEN_TIME" });
-            return { text, success: true, data: { subaction, date, daily } };
-        }
-        if (subaction === "weekly") {
-            const until = new Date().toISOString();
-            const since = daysAgoIso(params.sinceDays ?? 7);
-            const summary = await service.getScreenTimeSummary({
-                since,
-                until,
-                source: params.source,
-                topN: 10,
-            });
-            const text = summary.items.length === 0
-                ? `No screen time recorded in the last ${params.sinceDays ?? 7} days.`
-                : `Top screen time over the last ${params.sinceDays ?? 7} days (total ${formatSeconds(summary.totalSeconds)}):\n${summary.items
-                    .map((item) => `- ${item.source}: ${item.displayName} — ${formatSeconds(item.totalSeconds)}`)
-                    .join("\n")}`;
-            await callback?.({ text, source: "action", action: "SCREEN_TIME" });
-            return {
-                text,
-                success: true,
-                data: { subaction, since, until, summary },
-            };
-        }
-        if (subaction === "weekly_average_by_app") {
-            const daysInWindow = resolveWindowDays(params.sinceDays ?? 7);
-            const until = new Date().toISOString();
-            const since = daysAgoIso(daysInWindow);
-            const weeklyAverage = await service.getScreenTimeWeeklyAverageByApp({
-                since,
-                until,
-                daysInWindow,
-            });
-            const text = weeklyAverage.items.length === 0
-                ? `No app screen time recorded in the last ${daysInWindow} days.`
-                : `Weekly average per app over the last ${daysInWindow} days (total ${formatSeconds(weeklyAverage.totalSeconds)}):\n${weeklyAverage.items
-                    .map((item) => `- ${item.displayName} — ${formatSeconds(item.averageSecondsPerDay)}/day average (${formatSeconds(item.totalSeconds)} total)`)
-                    .join("\n")}`;
-            await callback?.({ text, source: "action", action: "SCREEN_TIME" });
-            return {
-                text,
-                success: true,
-                data: { subaction, source: "app", since, until, weeklyAverage },
-            };
-        }
-        if (subaction === "by_app" || subaction === "by_website") {
-            const source = subaction === "by_app" ? "app" : "website";
-            const until = new Date().toISOString();
-            const since = daysAgoIso(params.sinceDays ?? 1);
-            const summary = await service.getScreenTimeSummary({
-                since,
-                until,
-                source,
-                topN: 10,
-            });
-            const label = source === "app" ? "apps" : "websites";
-            const text = summary.items.length === 0
-                ? `No ${label} recorded in that window.`
-                : `Top ${label} (total ${formatSeconds(summary.totalSeconds)}):\n${summary.items
-                    .map((item) => `- ${item.displayName} — ${formatSeconds(item.totalSeconds)}`)
-                    .join("\n")}`;
-            await callback?.({ text, source: "action", action: "SCREEN_TIME" });
-            return {
-                text,
-                success: true,
-                data: { subaction, source, since, until, summary },
-            };
-        }
-        // summary — default
-        const until = new Date().toISOString();
-        const since = daysAgoIso(params.sinceDays ?? 1);
-        const summary = await service.getScreenTimeSummary({
-            since,
-            until,
-            source: params.source,
-            topN: 10,
-        });
-        const text = summary.items.length === 0
-            ? "No screen time recorded in that window."
-            : `Screen time summary (total ${formatSeconds(summary.totalSeconds)}):\n${summary.items
-                .map((item) => `- ${item.source}: ${item.displayName} — ${formatSeconds(item.totalSeconds)}`)
-                .join("\n")}`;
-        await callback?.({ text, source: "action", action: "SCREEN_TIME" });
-        return {
-            text,
-            success: true,
-            data: { subaction: "summary", since, until, summary },
-        };
-    },
-    parameters: [
-        {
-            name: "subaction",
-            description: "Which screen time query to run: summary, today, weekly, weekly_average_by_app, by_app, by_website.",
-            schema: { type: "string" },
-        },
-        {
-            name: "intent",
-            description: "Free-form user intent used to infer subaction when not explicitly set.",
-            schema: { type: "string" },
-        },
-        {
-            name: "source",
-            description: "Restrict to 'app' or 'website'.",
-            schema: { type: "string" },
-        },
-        {
-            name: "identifier",
-            description: "Specific app bundle id or website domain when filtering to a single source.",
-            schema: { type: "string" },
-        },
-        {
-            name: "date",
-            description: "YYYY-MM-DD for 'today' / daily queries.",
-            schema: { type: "string" },
-        },
-        {
-            name: "sinceDays",
-            description: "Number of days back from now for summary windows.",
-            schema: { type: "number" },
-        },
-    ],
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "How much time did I spend on my computer today?" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Screen time for 2026-04-16 (total 3h 42m): ...",
-                    action: "SCREEN_TIME",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "What are my top apps this week?" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Top screen time over the last 7 days (total 28h 10m): ...",
-                    action: "SCREEN_TIME",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "What's my weekly average per app?" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Weekly average per app over the last 7 days (total 28h 10m): ...",
-                    action: "SCREEN_TIME",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Which websites did I spend the most time on?" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Top websites (total 5h 20m): ...",
-                    action: "SCREEN_TIME",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Show me a screen time summary." },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Screen time summary (total 4h 08m): ...",
-                    action: "SCREEN_TIME",
-                },
-            },
-        ],
-    ],
-};

package/apps/app-lifeops/src/actions/search-across-channels.d.ts

@@ -1,13 +0,0 @@
-/**
- * SEARCH_ACROSS_CHANNELS action (WS1).
- *
- * LLM-driven param extraction (no regex, no English-only keyword
- * matching) — feeds runCrossChannelSearch() and returns a clipboard-ready
- * payload citing the source platform + room + timestamp for each hit.
- * Use this for cross-channel brief/context requests when the owner wants
- * one person or topic searched across Gmail, chat connectors, calendar,
- * and memory.
- */
-import type { Action } from "@elizaos/core";
-export declare const searchAcrossChannelsAction: Action;
-//# sourceMappingURL=search-across-channels.d.ts.map

package/apps/app-lifeops/src/actions/search-across-channels.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search-across-channels.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/search-across-channels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,MAAM,EAOP,MAAM,eAAe,CAAC;AAsPvB,eAAO,MAAM,0BAA0B,EAAE,MAgMxC,CAAC"}

package/apps/app-lifeops/src/actions/search-across-channels.js

@@ -1,338 +0,0 @@
-/**
- * SEARCH_ACROSS_CHANNELS action (WS1).
- *
- * LLM-driven param extraction (no regex, no English-only keyword
- * matching) — feeds runCrossChannelSearch() and returns a clipboard-ready
- * payload citing the source platform + room + timestamp for each hit.
- * Use this for cross-channel brief/context requests when the owner wants
- * one person or topic searched across Gmail, chat connectors, calendar,
- * and memory.
- */
-import { ModelType, logger, parseJSONObjectFromText } from "@elizaos/core";
-import { hasAdminAccess } from "@elizaos/agent";
-import { getRecentMessagesData } from "@elizaos/shared";
-import { CROSS_CHANNEL_SEARCH_CHANNELS, runCrossChannelSearch, } from "../lifeops/cross-channel-search.js";
-const ACTION_NAME = "SEARCH_ACROSS_CHANNELS";
-function isCrossChannelSearchChannel(value) {
-    return (typeof value === "string" &&
-        CROSS_CHANNEL_SEARCH_CHANNELS.includes(value));
-}
-function recentTexts(state, limit = 8) {
-    const out = [];
-    for (const item of getRecentMessagesData(state)) {
-        if (!item || typeof item !== "object")
-            continue;
-        const content = item.content;
-        if (!content || typeof content !== "object")
-            continue;
-        const text = content.text;
-        if (typeof text === "string" && text.trim()) {
-            out.push(text.trim());
-        }
-    }
-    return out.slice(-limit);
-}
-function messageText(message) {
-    const text = message.content?.text;
-    return typeof text === "string" ? text.trim() : "";
-}
-async function extractSearchPlan(runtime, message, state, params) {
-    // If caller already provided a concrete query, trust it.
-    if (params.query && params.query.trim()) {
-        return {
-            query: params.query.trim(),
-            person: params.person ?? null,
-            startIso: params.startIso ?? null,
-            endIso: params.endIso ?? null,
-            channels: params.channels && params.channels.length > 0 ? params.channels : null,
-            shouldAct: true,
-            clarification: null,
-        };
-    }
-    if (typeof runtime.useModel !== "function") {
-        return {
-            query: null,
-            person: null,
-            startIso: null,
-            endIso: null,
-            channels: null,
-            shouldAct: false,
-            clarification: "Cross-channel search planning is unavailable right now — tell me what to search for.",
-        };
-    }
-    const intent = (params.intent ?? messageText(message)).trim();
-    const nowIso = new Date().toISOString();
-    const channelList = CROSS_CHANNEL_SEARCH_CHANNELS.join(", ");
-    const prompt = [
-        "Plan a SEARCH_ACROSS_CHANNELS request.",
-        "The user may speak in any language. Do NOT translate the search query — keep the user's wording.",
-        "Return ONLY valid JSON with exactly these fields:",
-        '{"query":"string|null","person":"string|null","startIso":"ISO8601|null","endIso":"ISO8601|null","channels":["gmail"|"telegram"|"discord"|"imessage"|"whatsapp"|"signal"|"calendly"|"calendar"|"memory"]|null,"shouldAct":true|false,"clarification":"string|null"}',
-        "",
-        "Rules:",
-        "- query: the substantive search phrase (entity, topic, keywords). Strip filler like 'find', 'search for', 'show me'.",
-        "- person: a named individual the search should focus on, or null.",
-        "- startIso / endIso: an ISO time window if the request specifies one (e.g. 'this week', 'yesterday', 'in March'). Otherwise null.",
-        `- Reference time: ${nowIso}.`,
-        "- channels: only set when the user explicitly limits the search to specific platforms.",
-        `- Allowed channel values: ${channelList}.`,
-        "- shouldAct: false ONLY if the request is too vague to derive a query.",
-        "- clarification: when shouldAct is false, ask the minimum clarifying question in the user's language.",
-        "",
-        `Current request: ${JSON.stringify(intent)}`,
-        `Recent conversation: ${JSON.stringify(recentTexts(state).join("\n"))}`,
-    ].join("\n");
-    const raw = await runtime.useModel(ModelType.TEXT_SMALL, { prompt });
-    const text = typeof raw === "string" ? raw : "";
-    const parsed = parseJSONObjectFromText(text);
-    if (!parsed) {
-        return {
-            query: null,
-            person: null,
-            startIso: null,
-            endIso: null,
-            channels: null,
-            shouldAct: false,
-            clarification: "I couldn't parse a search query from that — what should I look up?",
-        };
-    }
-    const query = typeof parsed.query === "string" && parsed.query.trim()
-        ? parsed.query.trim()
-        : null;
-    const person = typeof parsed.person === "string" && parsed.person.trim()
-        ? parsed.person.trim()
-        : null;
-    const startIso = typeof parsed.startIso === "string" && parsed.startIso.trim()
-        ? parsed.startIso.trim()
-        : null;
-    const endIso = typeof parsed.endIso === "string" && parsed.endIso.trim()
-        ? parsed.endIso.trim()
-        : null;
-    const channels = Array.isArray(parsed.channels)
-        ? parsed.channels.filter(isCrossChannelSearchChannel)
-        : null;
-    const shouldAct = typeof parsed.shouldAct === "boolean" ? parsed.shouldAct : query !== null;
-    const clarification = typeof parsed.clarification === "string" && parsed.clarification.trim()
-        ? parsed.clarification.trim()
-        : null;
-    return {
-        query,
-        person,
-        startIso,
-        endIso,
-        channels: channels && channels.length > 0 ? channels : null,
-        shouldAct,
-        clarification,
-    };
-}
-// ---------------------------------------------------------------------------
-// Format
-// ---------------------------------------------------------------------------
-function formatHitForClipboard(hit, index) {
-    const subjectPart = hit.subject ? ` ${hit.subject}` : "";
-    const ts = hit.timestamp.slice(0, 19);
-    const body = hit.text.replace(/\s+/g, " ").trim().slice(0, 240);
-    return `${String(index + 1).padStart(3, " ")} | [${hit.channel}] ${hit.citation.label} (${ts}) ${hit.speaker}:${subjectPart} ${body}`;
-}
-function formatResult(result) {
-    const lines = [];
-    lines.push(`Cross-channel search for "${result.query}" — ${result.hits.length} hits across ${result.channelsWithHits.length} channels`);
-    lines.push("─".repeat(60));
-    result.hits.forEach((hit, idx) => {
-        lines.push(formatHitForClipboard(hit, idx));
-    });
-    if (result.unsupported.length > 0) {
-        lines.push("");
-        lines.push("Unsupported channels (no native search adapter):");
-        for (const u of result.unsupported) {
-            lines.push(`  - ${u.channel}: ${u.reason}`);
-        }
-    }
-    if (result.degraded.length > 0) {
-        lines.push("");
-        lines.push("Degraded channels:");
-        for (const d of result.degraded) {
-            lines.push(`  - ${d.channel}: ${d.reason}`);
-        }
-    }
-    lines.push("");
-    lines.push("To save relevant results to clipboard, use CLIPBOARD_WRITE with the line range.");
-    return lines.join("\n");
-}
-// ---------------------------------------------------------------------------
-// Action
-// ---------------------------------------------------------------------------
-export const searchAcrossChannelsAction = {
-    name: ACTION_NAME,
-    similes: [
-        "CROSS_CHANNEL_SEARCH",
-        "SEARCH_ALL_CHANNELS",
-        "SEARCH_EVERYWHERE",
-        "FIND_ACROSS_PLATFORMS",
-    ],
-    description: "Search across every connected channel — Gmail, Telegram, Discord, " +
-        "iMessage, WhatsApp, Signal, X DMs, Calendly — plus agent memory. " +
-        "Returns merged hits with citations to source platform, room, and " +
-        "timestamp. Connectors without native search emit typed unsupported " +
-        "markers (no fabricated results). Admin/owner only.",
-    descriptionCompressed: "Cross-channel search with citations. Admin only.",
-    validate: async (runtime, message) => hasAdminAccess(runtime, message),
-    handler: async (runtime, message, state, options) => {
-        if (!(await hasAdminAccess(runtime, message))) {
-            return {
-                text: "Permission denied: only the owner or admins may search across channels.",
-                success: false,
-                values: { success: false, error: "PERMISSION_DENIED" },
-                data: { actionName: ACTION_NAME },
-            };
-        }
-        const params = (options?.parameters ??
-            {});
-        const plan = await extractSearchPlan(runtime, message, state, params);
-        if (!plan.shouldAct || !plan.query) {
-            return {
-                text: plan.clarification ??
-                    "What do you want me to search for across your channels?",
-                success: true,
-                values: {
-                    success: true,
-                    noop: true,
-                },
-                data: {
-                    actionName: ACTION_NAME,
-                    noop: true,
-                },
-            };
-        }
-        const personRef = (() => {
-            if (params.primaryEntityId) {
-                return {
-                    primaryEntityId: params.primaryEntityId,
-                    displayName: plan.person ?? params.person ?? undefined,
-                };
-            }
-            const display = plan.person ?? params.person;
-            return display ? { displayName: display } : undefined;
-        })();
-        const timeWindow = (() => {
-            const startIso = plan.startIso ?? params.startIso;
-            const endIso = plan.endIso ?? params.endIso;
-            if (!startIso && !endIso)
-                return undefined;
-            return {
-                startIso: startIso ?? undefined,
-                endIso: endIso ?? undefined,
-            };
-        })();
-        const query = {
-            query: plan.query,
-            personRef,
-            timeWindow,
-            channels: plan.channels ?? params.channels,
-            worldId: params.worldId,
-            limit: params.limit,
-        };
-        try {
-            const result = await runCrossChannelSearch(runtime, query);
-            const formatted = formatResult(result);
-            return {
-                text: formatted,
-                success: true,
-                values: {
-                    success: true,
-                    hitCount: result.hits.length,
-                    unsupportedCount: result.unsupported.length,
-                    degradedCount: result.degraded.length,
-                    channelsWithHits: result.channelsWithHits,
-                },
-                data: {
-                    actionName: ACTION_NAME,
-                    query: result.query,
-                    hits: result.hits.map((hit, idx) => ({
-                        line: idx + 1,
-                        channel: hit.channel,
-                        id: hit.id,
-                        sourceRef: hit.sourceRef,
-                        speaker: hit.speaker,
-                        timestamp: hit.timestamp,
-                        subject: hit.subject,
-                        text: hit.text,
-                        citation: hit.citation,
-                    })),
-                    unsupported: result.unsupported,
-                    degraded: result.degraded,
-                    channelsWithHits: result.channelsWithHits,
-                    resolvedPerson: result.resolvedPerson
-                        ? {
-                            primaryEntityId: result.resolvedPerson.primaryEntityId,
-                            displayName: result.resolvedPerson.displayName,
-                        }
-                        : null,
-                },
-            };
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            logger.error(`[${ACTION_NAME}] Search failed: ${errMsg}`);
-            return {
-                text: `Cross-channel search failed: ${errMsg}`,
-                success: false,
-                values: { success: false, error: "SEARCH_FAILED" },
-                data: { actionName: ACTION_NAME, query: plan.query },
-            };
-        }
-    },
-    parameters: [
-        {
-            name: "query",
-            description: "Exact search phrase. When omitted, the LLM extracts a query from `intent`.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "intent",
-            description: "Natural-language description of what to search for. Multilingual.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "person",
-            description: "Display name of the person to focus the search on. Resolves via the relationships graph when available.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "primaryEntityId",
-            description: "Pre-resolved canonical cluster primary entity id (UUID).",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "startIso",
-            description: "Lower-bound timestamp (ISO 8601). Optional.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "endIso",
-            description: "Upper-bound timestamp (ISO 8601). Optional.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "channels",
-            description: "Channel allowlist. Allowed values: gmail, memory, telegram, discord, imessage, whatsapp, signal, calendly, calendar.",
-            required: false,
-            schema: {
-                type: "array",
-                items: { type: "string" },
-            },
-        },
-        {
-            name: "limit",
-            description: "Per-channel hit cap (default 10).",
-            required: false,
-            schema: { type: "number" },
-        },
-    ],
-};

package/apps/app-lifeops/src/actions/start-remote-session.d.ts

@@ -1,14 +0,0 @@
-/**
- * START_REMOTE_SESSION — control-plane action for T9a.
- *
- * Requires owner access. If MILADY_REMOTE_LOCAL_MODE=1, the pairing code is
- * not required (but `confirmed: true` still is). Otherwise, a valid 6-digit
- * pairing code issued via the cloud pair endpoint must be provided.
- *
- * Does not open a pixel transport. The data-plane ingress is resolved by
- * RemoteSessionService; when no data plane is configured, the action returns
- * an explicit `ingressUrl: null` with `reason: "data-plane-not-configured"`.
- */
-import type { Action } from "@elizaos/core";
-export declare const startRemoteSessionAction: Action;
-//# sourceMappingURL=start-remote-session.d.ts.map

package/apps/app-lifeops/src/actions/start-remote-session.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-remote-session.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/start-remote-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,eAAe,CAAC;AAqBvB,eAAO,MAAM,wBAAwB,EAAE,MA2ItC,CAAC"}