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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"calendly.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/calendly.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAMZ,MAAM,eAAe,CAAC;AA6GvB,eAAO,MAAM,cAAc,EAAE,MAqO5B,CAAC"}

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

@@ -0,0 +1,242 @@
+import { logger, } from "@elizaos/core";
+import { hasAdminAccess } from "@elizaos/agent/security/access";
+import { CalendlyError, createCalendlySingleUseLink, getCalendlyAvailability, listCalendlyEventTypes, listCalendlyScheduledEvents, readCalendlyCredentialsFromEnv, } from "../lifeops/calendly-client.js";
+const ACTION_NAME = "CALENDLY";
+function coerceString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function parseSubaction(value) {
+    const s = coerceString(value)?.toLowerCase();
+    if (!s)
+        return null;
+    if (s === "list_event_types" ||
+        s === "availability" ||
+        s === "upcoming_events" ||
+        s === "single_use_link") {
+        return s;
+    }
+    return null;
+}
+function formatEventTypes(types) {
+    if (types.length === 0)
+        return "No Calendly event types found.";
+    const active = types.filter((t) => t.active);
+    const lines = active.map((t) => `- ${t.name} (${t.durationMinutes}m) — ${t.schedulingUrl}\n  uri: ${t.uri}`);
+    return `Calendly event types (${active.length} active):\n${lines.join("\n")}`;
+}
+function formatScheduledEvents(events) {
+    if (events.length === 0)
+        return "No upcoming Calendly events.";
+    const lines = events.map((event) => {
+        const inviteeSummary = event.invitees.length > 0
+            ? event.invitees
+                .map((inv) => inv.name ?? inv.email ?? "(unknown)")
+                .join(", ")
+            : "(no invitees yet)";
+        return `- ${event.name} @ ${event.startTime} → ${event.endTime} [${event.status}] — ${inviteeSummary}`;
+    });
+    return `Calendly scheduled events (${events.length}):\n${lines.join("\n")}`;
+}
+function formatAvailability(days) {
+    if (days.length === 0)
+        return "No available slots in that range.";
+    const lines = days.map((day) => {
+        const times = day.slots.map((s) => s.startTime).join(", ");
+        return `- ${day.date}: ${day.slots.length} slot(s) — ${times}`;
+    });
+    return `Calendly availability:\n${lines.join("\n")}`;
+}
+function failure(text, error, extra = {}) {
+    return {
+        text,
+        success: false,
+        values: { success: false, error, ...extra },
+        data: { actionName: ACTION_NAME, error, ...extra },
+    };
+}
+function success(text, data) {
+    return {
+        text,
+        success: true,
+        values: { success: true },
+        data: { actionName: ACTION_NAME, ...data },
+    };
+}
+export const calendlyAction = {
+    name: ACTION_NAME,
+    similes: [
+        "CALENDLY_LIST_EVENT_TYPES",
+        "CALENDLY_AVAILABILITY",
+        "CALENDLY_UPCOMING",
+        "CALENDLY_BOOKING_LINK",
+    ],
+    description: "Work with Calendly: list event types, check availability, list scheduled events, generate single-use booking links. Subactions: list_event_types, availability, upcoming_events, single_use_link.",
+    validate: async (runtime, message) => {
+        if (!readCalendlyCredentialsFromEnv())
+            return false;
+        return hasAdminAccess(runtime, message);
+    },
+    parameters: [
+        {
+            name: "subaction",
+            description: "One of: list_event_types, availability, upcoming_events, single_use_link.",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "intent",
+            description: "Optional free-form description of the user's intent.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "eventTypeUri",
+            description: "Calendly event type URI. Required for availability and single_use_link.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "startDate",
+            description: "ISO date (YYYY-MM-DD) for range-based queries (availability, upcoming_events).",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "endDate",
+            description: "ISO date (YYYY-MM-DD) for range-based queries.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "timezone",
+            description: "IANA timezone, e.g. America/Los_Angeles.",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Show me my Calendly event types" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Calendly event types (2 active):\n- 30 Minute Meeting (30m) — https://calendly.com/me/30min\n  uri: https://api.calendly.com/event_types/ABCD",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "What's my Calendly availability next week for the 30 min meeting?",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Calendly availability:\n- 2026-04-20: 4 slot(s) — ...",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Generate a one-time Calendly link for my intro call" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Single-use Calendly booking link: https://calendly.com/d/xxx-yyy-zzz",
+                },
+            },
+        ],
+    ],
+    handler: async (runtime, message, _state, options) => {
+        if (!(await hasAdminAccess(runtime, message))) {
+            return failure("Permission denied: only the owner or admin may use Calendly.", "PERMISSION_DENIED");
+        }
+        const credentials = readCalendlyCredentialsFromEnv();
+        if (!credentials) {
+            return failure("Calendly is not configured. Set ELIZA_CALENDLY_TOKEN.", "CALENDLY_NOT_CONFIGURED");
+        }
+        const params = (options?.parameters ??
+            {});
+        const subaction = parseSubaction(params.subaction);
+        if (!subaction) {
+            return failure("Missing or invalid subaction. Use one of: list_event_types, availability, upcoming_events, single_use_link.", "INVALID_SUBACTION");
+        }
+        try {
+            switch (subaction) {
+                case "list_event_types": {
+                    const types = await listCalendlyEventTypes(credentials);
+                    return success(formatEventTypes(types), {
+                        subaction,
+                        eventTypes: types,
+                    });
+                }
+                case "availability": {
+                    const eventTypeUri = coerceString(params.eventTypeUri);
+                    const startDate = coerceString(params.startDate);
+                    const endDate = coerceString(params.endDate);
+                    if (!eventTypeUri) {
+                        return failure("Missing required parameter: eventTypeUri.", "MISSING_EVENT_TYPE_URI");
+                    }
+                    if (!startDate || !endDate) {
+                        return failure("Missing required parameters: startDate and endDate (YYYY-MM-DD).", "MISSING_DATE_RANGE");
+                    }
+                    const availability = await getCalendlyAvailability(credentials, eventTypeUri, {
+                        startDate,
+                        endDate,
+                        timezone: coerceString(params.timezone),
+                    });
+                    return success(formatAvailability(availability), {
+                        subaction,
+                        availability,
+                    });
+                }
+                case "upcoming_events": {
+                    const startDate = coerceString(params.startDate);
+                    const endDate = coerceString(params.endDate);
+                    const events = await listCalendlyScheduledEvents(credentials, {
+                        minStartTime: startDate
+                            ? `${startDate}T00:00:00Z`
+                            : new Date().toISOString(),
+                        maxStartTime: endDate ? `${endDate}T23:59:59Z` : undefined,
+                        status: "active",
+                        limit: 50,
+                    });
+                    return success(formatScheduledEvents(events), {
+                        subaction,
+                        events,
+                    });
+                }
+                case "single_use_link": {
+                    const eventTypeUri = coerceString(params.eventTypeUri);
+                    if (!eventTypeUri) {
+                        return failure("Missing required parameter: eventTypeUri.", "MISSING_EVENT_TYPE_URI");
+                    }
+                    const link = await createCalendlySingleUseLink(credentials, eventTypeUri);
+                    return success(`Single-use Calendly booking link: ${link.bookingUrl} (expires ${link.expiresAt})`, { subaction, link });
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof CalendlyError) {
+                logger.warn({
+                    boundary: "lifeops",
+                    integration: "calendly",
+                    subaction,
+                    statusCode: error.status,
+                }, `[lifeops] Calendly ${subaction} failed: ${error.message}`);
+                return failure(`Calendly ${subaction} failed: ${error.message}`, "CALENDLY_API_ERROR", { statusCode: error.status });
+            }
+            throw error;
+        }
+    },
+};

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

@@ -0,0 +1,4 @@
+import type { Action } from "@elizaos/core";
+export declare const runMorningCheckinAction: Action;
+export declare const runNightCheckinAction: Action;
+//# sourceMappingURL=checkin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkin.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/checkin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAsB,MAAM,eAAe,CAAC;AAuBhE,eAAO,MAAM,uBAAuB,EAAE,MA8BrC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,MA0BnC,CAAC"}

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

@@ -0,0 +1,72 @@
+import { hasOwnerAccess } from "@elizaos/agent/security/access";
+import { CheckinService } from "../lifeops/checkin/checkin-service.js";
+/**
+ * Actions for T9f morning/night check-in engine (plan §6.23). These expose the
+ * entry points used by the scenario runner. Automatic cron firing at the
+ * user-configured morning/night times is a follow-up PR (T9f-followup-PR).
+ */
+function reportToActionData(report) {
+    return {
+        reportId: report.reportId,
+        kind: report.kind,
+        generatedAt: report.generatedAt,
+        escalationLevel: report.escalationLevel,
+        overdueTodos: report.overdueTodos,
+        todaysMeetings: report.todaysMeetings,
+        yesterdaysWins: report.yesterdaysWins,
+    };
+}
+export const runMorningCheckinAction = {
+    name: "RUN_MORNING_CHECKIN",
+    similes: [
+        "MORNING_CHECKIN",
+        "START_MORNING_CHECKIN",
+        "MORNING_ROUTINE_CHECKIN",
+    ],
+    description: "Run the morning check-in: assemble overdue todos, today's meetings, and yesterday's wins for the owner. Use this for a dedicated morning self-review/check-in, not for inbox daily briefs, unread cross-channel summaries, or reply workflows.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime, message) => {
+        if (!(await hasOwnerAccess(runtime, message))) {
+            return {
+                text: "",
+                success: false,
+                data: { error: "PERMISSION_DENIED" },
+            };
+        }
+        const service = new CheckinService(runtime);
+        const report = await service.runMorningCheckin({
+            roomId: typeof message.roomId === "string" ? message.roomId : undefined,
+        });
+        return {
+            text: "",
+            success: true,
+            data: reportToActionData(report),
+        };
+    },
+    parameters: [],
+};
+export const runNightCheckinAction = {
+    name: "RUN_NIGHT_CHECKIN",
+    similes: ["NIGHT_CHECKIN", "START_NIGHT_CHECKIN", "EVENING_CHECKIN"],
+    description: "Run the night check-in: review today's meetings, completed wins, and any overdue todos for the owner. Use this for a dedicated evening wrap-up, not for inbox daily briefs, unread cross-channel summaries, or reply workflows.",
+    validate: async (runtime, message) => hasOwnerAccess(runtime, message),
+    handler: async (runtime, message) => {
+        if (!(await hasOwnerAccess(runtime, message))) {
+            return {
+                text: "",
+                success: false,
+                data: { error: "PERMISSION_DENIED" },
+            };
+        }
+        const service = new CheckinService(runtime);
+        const report = await service.runNightCheckin({
+            roomId: typeof message.roomId === "string" ? message.roomId : undefined,
+        });
+        return {
+            text: "",
+            success: true,
+            data: reportToActionData(report),
+        };
+    },
+    parameters: [],
+};

package/apps/app-lifeops/src/actions/computer-use.d.ts

@@ -0,0 +1,14 @@
+/**
+ * LifeOps computer-use action.
+ *
+ * Thin wrapper over @elizaos/plugin-computeruse's useComputerAction with
+ * LifeOps-specific access control (owner-only) and an opt-out feature flag
+ * (ELIZA_LIFEOPS_COMPUTER_USE_ENABLED=0). If the plugin package is not
+ * installed in the workspace, exports a stub action that returns a clear
+ * "not installed" result instead of crashing the plugin load.
+ */
+import type { Action } from "@elizaos/core";
+export declare const lifeOpsComputerUseAction: Action & {
+    suppressPostActionContinuation?: boolean;
+};
+//# sourceMappingURL=computer-use.d.ts.map

package/apps/app-lifeops/src/actions/computer-use.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computer-use.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/computer-use.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAsDvB,eAAO,MAAM,wBAAwB,EAAE,MAAM,GAAG;IAC9C,8BAA8B,CAAC,EAAE,OAAO,CAAC;CA8F1C,CAAC"}

package/apps/app-lifeops/src/actions/computer-use.js

@@ -0,0 +1,149 @@
+/**
+ * LifeOps computer-use action.
+ *
+ * Thin wrapper over @elizaos/plugin-computeruse's useComputerAction with
+ * LifeOps-specific access control (owner-only) and an opt-out feature flag
+ * (ELIZA_LIFEOPS_COMPUTER_USE_ENABLED=0). If the plugin package is not
+ * installed in the workspace, exports a stub action that returns a clear
+ * "not installed" result instead of crashing the plugin load.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { hasOwnerAccess } from "@elizaos/agent/security/access";
+const ACTION_NAME = "LIFEOPS_COMPUTER_USE";
+function isComputerUseEnabled() {
+    return process.env.ELIZA_LIFEOPS_COMPUTER_USE_ENABLED !== "0";
+}
+async function loadBaseAction() {
+    try {
+        // Dynamic import so a missing peer dependency does not break plugin load.
+        const mod = (await import(__rewriteRelativeImportExtension(
+        /* @vite-ignore */ "@elizaos/plugin-computeruse")));
+        if (mod.useComputerAction)
+            return mod.useComputerAction;
+        const plugin = mod.computerUsePlugin ?? mod.default;
+        const fromPlugin = plugin?.actions?.find((a) => a.name === "USE_COMPUTER" || a.name === "USE_COMPUTER_ACTION");
+        return fromPlugin ?? plugin?.actions?.[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+let cachedBaseAction;
+async function getBaseAction() {
+    if (cachedBaseAction === undefined) {
+        cachedBaseAction = await loadBaseAction();
+    }
+    return cachedBaseAction;
+}
+const stubExamples = [
+    [
+        {
+            name: "{{name1}}",
+            content: { text: "Take a screenshot of my desktop" },
+        },
+        {
+            name: "{{agentName}}",
+            content: {
+                text: "The @elizaos/plugin-computeruse package is not installed. Install it and restart the agent to enable desktop automation.",
+            },
+        },
+    ],
+];
+export const lifeOpsComputerUseAction = {
+    name: ACTION_NAME,
+    similes: [
+        "USE_COMPUTER",
+        "DESKTOP_AUTOMATION",
+        "COMPUTER_USE",
+        "CONTROL_DESKTOP",
+        "PORTAL_UPLOAD",
+        "UPLOAD_DECK",
+    ],
+    tags: [
+        "always-include",
+        "portal upload",
+        "upload deck",
+        "speaker portal",
+        "browser workflow",
+        "form filling",
+    ],
+    description: "Control the owner's desktop (screenshots, mouse, keyboard, browser, " +
+        "windows, files, terminal) via @elizaos/plugin-computeruse. Use this for " +
+        "portal uploads, browser form-filling, and other on-machine workflows the " +
+        "assistant should perform directly, including standing instructions like " +
+        "'when I send the file, upload it to the portal for me.' Owner-only. " +
+        "Disabled when ELIZA_LIFEOPS_COMPUTER_USE_ENABLED=0.",
+    suppressPostActionContinuation: true,
+    validate: async (runtime, message) => {
+        if (!isComputerUseEnabled())
+            return false;
+        if (!(await hasOwnerAccess(runtime, message)))
+            return false;
+        const base = await getBaseAction();
+        if (!base)
+            return true;
+        if (!base.validate)
+            return true;
+        return base.validate(runtime, message, undefined);
+    },
+    parameters: [],
+    examples: [
+        ...stubExamples,
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "When I send over the deck, upload it to the portal for me." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Once you send the deck, I'll handle the portal upload on your machine and keep it gated behind your delivery and approval.",
+                },
+            },
+        ],
+    ],
+    handler: async (runtime, message, state, options, callback) => {
+        if (!isComputerUseEnabled()) {
+            return {
+                text: "Computer use is disabled (ELIZA_LIFEOPS_COMPUTER_USE_ENABLED=0).",
+                success: false,
+                values: { success: false, error: "COMPUTER_USE_DISABLED" },
+                data: { actionName: ACTION_NAME },
+            };
+        }
+        if (!(await hasOwnerAccess(runtime, message))) {
+            return {
+                text: "Permission denied: only the owner may drive computer use.",
+                success: false,
+                values: { success: false, error: "PERMISSION_DENIED" },
+                data: { actionName: ACTION_NAME },
+            };
+        }
+        const base = await getBaseAction();
+        if (!base) {
+            return {
+                text: "The @elizaos/plugin-computeruse package is not installed. Install it and restart the agent to enable desktop automation.",
+                success: false,
+                values: { success: false, error: "COMPUTER_USE_NOT_INSTALLED" },
+                data: { actionName: ACTION_NAME },
+            };
+        }
+        const result = await base.handler(runtime, message, state, options, callback, []);
+        if (result && typeof result === "object" && "success" in result) {
+            return result;
+        }
+        return {
+            text: "",
+            success: true,
+            values: { success: true },
+            data: { actionName: ACTION_NAME, raw: result },
+        };
+    },
+};

package/apps/app-lifeops/src/actions/cross-channel-send.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Unified cross-channel draft/send action.
+ *
+ * Always drafts first. Callers must re-invoke with `confirmed: true` to
+ * actually dispatch. Dispatch is routed per channel:
+ *   - email         → LifeOpsService.sendGmailMessage
+ *   - sms           → sendTwilioSms
+ *   - twilio_voice  → sendTwilioVoiceCall
+ *   - telegram      → LifeOpsService.sendTelegramMessage
+ *   - discord       → runtime send handler registered for "discord"
+ *   - signal        → runtime send handler registered for "signal"
+ *   - imessage      → LifeOpsService.sendIMessage
+ *   - whatsapp      → LifeOpsService.sendWhatsAppMessage
+ *   - notifications → ntfy push (NTFY_BASE_URL)
+ *   - calendly      → createCalendlySingleUseLink (target = event-type URI)
+ *   - x_dm          → X (Twitter) DM via X API v2 (requires x.write capability)
+ */
+import type { Action } from "@elizaos/core";
+export declare const CROSS_CHANNEL_SEND_CHANNELS: readonly ["email", "telegram", "discord", "signal", "sms", "twilio_voice", "imessage", "whatsapp", "notifications", "calendly", "x_dm"];
+export type CrossChannelSendChannel = (typeof CROSS_CHANNEL_SEND_CHANNELS)[number];
+export declare const crossChannelSendAction: Action;
+//# sourceMappingURL=cross-channel-send.d.ts.map

package/apps/app-lifeops/src/actions/cross-channel-send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-channel-send.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/cross-channel-send.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,eAAe,CAAC;AAyBvB,eAAO,MAAM,2BAA2B,yIAY9B,CAAC;AACX,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAwZnF,eAAO,MAAM,sBAAsB,EAAE,MAoMpC,CAAC"}