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

package/apps/app-lifeops/src/actions/update-owner-profile.js

@@ -1,28 +1,5 @@
 import { normalizeLifeOpsOwnerProfilePatch, persistConfiguredOwnerName, updateLifeOpsOwnerProfile, } from "../lifeops/owner-profile.js";
 import { hasOwnerAccess } from "@elizaos/agent/security/access";
-function extractOwnerProfilePatchFromText(text) {
-    if (!text) {
-        return {};
-    }
-    const patch = {};
-    const readMatch = (pattern) => {
-        const match = text.match(pattern);
-        return match?.[1]?.trim();
-    };
-    patch.name = readMatch(/\bname\s*[:=]\s*([^,.;\n]+)/i);
-    patch.relationshipStatus = readMatch(/\brelationship(?:\s+status)?\s*[:=]\s*([^,.;\n]+)/i);
-    patch.partnerName = readMatch(/\bpartner(?:\s+name)?\s*[:=]\s*([^,.;\n]+)/i);
-    patch.orientation = readMatch(/\borientation\s*[:=]\s*([^,.;\n]+)/i);
-    patch.gender = readMatch(/\bgender\s*[:=]\s*([^,.;\n]+)/i);
-    patch.age =
-        readMatch(/\bage\s*[:=]\s*(\d{1,3})\b/i) ??
-            readMatch(/\bi(?: am|'m)\s+(\d{1,3})\s+years?\s+old\b/i) ??
-            readMatch(/\bmy age is\s+(\d{1,3})\b/i);
-    patch.location =
-        readMatch(/\blocation\s*[:=]\s*([^,.;\n]+)/i) ??
-            readMatch(/\bi live in\s+([^,.;\n]+)/i);
-    return patch;
-}
 export const updateOwnerProfileAction = {
     name: "UPDATE_OWNER_PROFILE",
     similes: [
@@ -30,9 +7,23 @@ export const updateOwnerProfileAction = {
         "SET_OWNER_PROFILE",
         "UPDATE_USER_PROFILE",
         "SAVE_USER_PROFILE",
+        "SAVE_TRAVEL_PREFERENCES",
+        "TRAVEL_PROFILE",
+        "BOOKING_PREFERENCES",
+    ],
+    tags: [
+        "always-include",
+        "travel preferences",
+        "flight preferences",
+        "hotel preferences",
+        "booking preferences",
+        "owner profile",
     ],
     description: "Silently persist stable, owner-only LifeOps profile details when the canonical owner clearly states or confirms them. " +
-        "Use only for the owner, never for other contacts, and do not ask follow-up questions just to fill these fields.",
+        "Use only for the owner, never for other contacts, and do not ask follow-up questions just to fill these fields. " +
+        "This includes durable travel-booking preferences or a reusable travel-preference checklist when the owner wants those preferences remembered for future bookings.",
+    descriptionCompressed: "Persist stable owner profile details when stated/confirmed. Owner only.",
+    suppressPostActionContinuation: true,
     validate: async (runtime, message) => {
         return hasOwnerAccess(runtime, message);
     },
@@ -45,15 +36,10 @@ export const updateOwnerProfileAction = {
             };
         }
         const params = options?.parameters;
-        const content = message.content;
-        const extractedFromText = extractOwnerProfilePatchFromText(typeof content?.text === "string" ? content.text : undefined);
-        const patch = normalizeLifeOpsOwnerProfilePatch({
-            ...extractedFromText,
-            ...(params ?? {}),
-        });
+        const patch = normalizeLifeOpsOwnerProfilePatch(params ?? {});
         if (Object.keys(patch).length === 0) {
             return {
-                text: "",
+                text: "Tell me the reusable flight and hotel preferences you want saved, such as seat, class, luggage, hotel budget, venue distance, and whether an extra night is okay.",
                 success: false,
                 data: { error: "NO_FIELDS" },
             };
@@ -127,5 +113,40 @@ export const updateOwnerProfileAction = {
             description: "Owner location when clearly stated.",
             schema: { type: "string" },
         },
+        {
+            name: "travelBookingPreferences",
+            description: "Reusable flight and hotel preference checklist or summary to remember for future bookings.",
+            schema: { type: "string" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Set up a list of my flight and hotel preferences so you don't have to ask every time.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "I'll store a reusable travel-preference checklist on your owner profile covering flight class, seat, luggage, hotel budget, distance tolerance, and trip-extension preference so future booking flows can reuse it.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Remember that I prefer aisle seats, carry-on only, moderate hotels close to the venue, and I'm open to staying an extra night if it makes the trip easier.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Stored your travel-booking preferences on the owner profile for future flight and hotel bookings.",
+                },
+            },
+        ],
     ],
 };

package/apps/app-lifeops/src/actions/website-blocker.d.ts

@@ -0,0 +1,10 @@
+import type { Action } from "@elizaos/core";
+export declare const blockWebsitesAction: Action;
+export declare const getWebsiteBlockStatusAction: Action;
+export declare const requestWebsiteBlockingPermissionAction: Action;
+export declare const unblockWebsitesAction: Action;
+export declare const selfControlBlockWebsitesAction: Action;
+export declare const selfControlGetStatusAction: Action;
+export declare const selfControlRequestPermissionAction: Action;
+export declare const selfControlUnblockWebsitesAction: Action;
+//# sourceMappingURL=website-blocker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"website-blocker.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/website-blocker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAgOvB,eAAO,MAAM,mBAAmB,EAAE,MAgMjC,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,MAuDzC,CAAC;AAEF,eAAO,MAAM,sCAAsC,EAAE,MA8DpD,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,MA6FnC,CAAC;AAEF,eAAO,MAAM,8BAA8B,QAAsB,CAAC;AAClE,eAAO,MAAM,0BAA0B,QAA8B,CAAC;AACtE,eAAO,MAAM,kCAAkC,QACP,CAAC;AACzC,eAAO,MAAM,gCAAgC,QAAwB,CAAC"}

package/apps/app-lifeops/src/actions/website-blocker.js

@@ -0,0 +1,539 @@
+import { ModelType, parseJSONObjectFromText, parseKeyValueXml, } from "@elizaos/core";
+import { getSelfControlAccess, SELFCONTROL_ACCESS_ERROR } from "../website-blocker/access.js";
+import { formatWebsiteList, getSelfControlStatus, parseSelfControlBlockRequest, requestSelfControlPermission, startSelfControlBlock, stopSelfControlBlock, } from "../website-blocker/engine.js";
+import { syncWebsiteBlockerExpiryTask } from "../website-blocker/service.js";
+import { recentConversationTexts as collectRecentConversationTexts } from "./life-recent-context.js";
+function formatStatusText(status) {
+    if (!status.available) {
+        return (status.reason ?? "Local website blocking is unavailable on this machine.");
+    }
+    const permissionNote = status.reason ? ` ${status.reason}` : "";
+    if (!status.active) {
+        return `No website block is active right now.${permissionNote}`;
+    }
+    const websites = status.websites.length > 0
+        ? formatWebsiteList(status.websites)
+        : "an unknown website set";
+    return status.endsAt
+        ? `A website block is active for ${websites} until ${status.endsAt}.${permissionNote}`
+        : `A website block is active for ${websites} until you remove it.${permissionNote}`;
+}
+function formatPermissionText(permission) {
+    if (permission.status === "granted") {
+        return (permission.reason ??
+            "Website blocking permission is ready. Eliza can edit the system hosts file directly on this machine.");
+    }
+    if (permission.canRequest) {
+        return (permission.reason ??
+            "Eliza can ask the OS for administrator/root approval whenever it needs to edit the system hosts file.");
+    }
+    return (permission.reason ??
+        "Eliza cannot raise an administrator/root prompt for website blocking on this machine.");
+}
+function normalizeShouldAct(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
+        }
+    }
+    return null;
+}
+function normalizePlannerResponse(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function getMessageText(message) {
+    return typeof message.content?.text === "string" ? message.content.text : "";
+}
+function normalizeWebsiteCandidates(value) {
+    const values = Array.isArray(value)
+        ? value
+        : typeof value === "string"
+            ? value.split(/\s*\|\|\s*|,|\n/)
+            : [];
+    return [...new Set(values
+            .filter((item) => typeof item === "string")
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0))];
+}
+function normalizeDurationMinutes(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return Math.round(value);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim().toLowerCase();
+        if (!trimmed) {
+            return undefined;
+        }
+        if (trimmed === "indefinite" ||
+            trimmed === "manual" ||
+            trimmed === "until-unblocked" ||
+            trimmed === "forever") {
+            return null;
+        }
+        const parsed = Number.parseFloat(trimmed);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.round(parsed);
+        }
+    }
+    return undefined;
+}
+async function resolveWebsiteBlockPlanWithLlm(args) {
+    const recentConversation = (await collectRecentConversationTexts({
+        runtime: args.runtime,
+        message: args.message,
+        state: args.state,
+        limit: 8,
+    })).join("\n");
+    const currentMessage = getMessageText(args.message).trim();
+    const prompt = [
+        "Plan the website blocking action for this request.",
+        "Use the current request plus recent conversation context.",
+        "Return a JSON object with these fields:",
+        "  shouldAct: boolean",
+        "  response: short natural-language reply when clarification or deferral is needed",
+        "  websites: array of public website hostnames or URLs to block",
+        "  durationMinutes: positive integer for a timed block, null for an indefinite/manual block, or omit it when the default duration should apply",
+        "",
+        "Rules:",
+        "- Only start a block when the user is clearly asking to block websites now.",
+        "- If the user says not yet, later, hold off, wait, or is only discussing candidate sites, set shouldAct=false and explain that you will wait for confirmation.",
+        "- If the current request refers to previously mentioned websites, recover them from recent conversation context.",
+        "- If the websites are unclear or missing, set shouldAct=false and ask the user to name the public hostnames explicitly.",
+        "- Prefer bare public hostnames like x.com in the websites array.",
+        "- Use durationMinutes=null only when the user explicitly wants the block to last until manual removal.",
+        "",
+        "Examples:",
+        '  {"shouldAct":true,"response":null,"websites":["x.com","twitter.com"],"durationMinutes":120}',
+        '  {"shouldAct":false,"response":"I noted those websites and will wait for your confirmation before blocking them.","websites":["x.com","twitter.com"]}',
+        '  {"shouldAct":false,"response":"Tell me which public website hostnames to block, such as x.com or youtube.com.","websites":[]}',
+        "",
+        "Return ONLY valid JSON.",
+        `Current request: ${JSON.stringify(currentMessage)}`,
+        `Recent conversation: ${JSON.stringify(recentConversation)}`,
+    ].join("\n");
+    try {
+        const result = await args.runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+        });
+        const rawResponse = typeof result === "string" ? result : "";
+        const parsed = parseKeyValueXml(rawResponse) ??
+            parseJSONObjectFromText(rawResponse);
+        if (!parsed) {
+            return {
+                websites: [],
+                shouldAct: null,
+            };
+        }
+        return {
+            shouldAct: normalizeShouldAct(parsed.shouldAct),
+            response: normalizePlannerResponse(parsed.response),
+            websites: normalizeWebsiteCandidates(parsed.websites),
+            durationMinutes: normalizeDurationMinutes(parsed.durationMinutes),
+        };
+    }
+    catch (error) {
+        args.runtime.logger?.warn?.({
+            src: "action:website-blocker",
+            error: error instanceof Error ? error.message : String(error),
+        }, "Website blocker planning model call failed");
+        return {
+            websites: [],
+            shouldAct: null,
+        };
+    }
+}
+export const blockWebsitesAction = {
+    name: "BLOCK_WEBSITES",
+    similes: [
+        "SELFCONTROL_BLOCK_WEBSITES",
+        "BLOCK_WEBSITE",
+        "BLOCK_SITE",
+        "BLOCK_WEBSITE_NOW",
+        "WEBSITE_BLOCKER",
+        "WEBSITEBLOCKER",
+        "START_FOCUS_BLOCK",
+        "BLOCK_SITE",
+        "BLOCK_DISTRACTING_SITES",
+    ],
+    description: "Admin-only. Start a local website block by editing the system hosts file. " +
+        "Use recent conversation context to block public websites like x.com for a fixed duration or until manually unblocked. " +
+        "If the user confirms a block in a follow-up message without repeating the hostnames, reuse that context through the action planner.",
+    descriptionCompressed: "Admin: block websites via hosts file for set duration.",
+    validate: async (runtime, message) => {
+        const access = await getSelfControlAccess(runtime, message);
+        return access.allowed;
+    },
+    handler: async (runtime, message, state, options) => {
+        const access = await getSelfControlAccess(runtime, message);
+        if (!access.allowed) {
+            return {
+                success: false,
+                text: access.reason ?? SELFCONTROL_ACCESS_ERROR,
+            };
+        }
+        const params = options?.parameters;
+        const explicitWebsites = normalizeWebsiteCandidates(params?.websites);
+        const explicitDurationMinutes = normalizeDurationMinutes(params?.durationMinutes);
+        const llmPlan = explicitWebsites.length === 0
+            ? await resolveWebsiteBlockPlanWithLlm({
+                runtime,
+                message,
+                state,
+            })
+            : null;
+        if (llmPlan?.shouldAct === false && explicitWebsites.length === 0) {
+            return {
+                success: true,
+                text: llmPlan.response ??
+                    "I noted those websites and will wait for your confirmation before blocking them.",
+                data: {
+                    deferred: true,
+                    noop: true,
+                },
+            };
+        }
+        const parsed = parseSelfControlBlockRequest({
+            parameters: {
+                websites: explicitWebsites.length > 0
+                    ? explicitWebsites
+                    : (llmPlan?.websites ?? null),
+                durationMinutes: explicitDurationMinutes !== undefined
+                    ? explicitDurationMinutes
+                    : (llmPlan?.durationMinutes ?? null),
+            },
+        });
+        if (!parsed.request) {
+            return {
+                success: false,
+                text: llmPlan?.response ??
+                    parsed.error ??
+                    "Could not determine which public website hostnames to block.",
+            };
+        }
+        const result = await startSelfControlBlock({
+            ...parsed.request,
+            scheduledByAgentId: String(runtime.agentId),
+        });
+        if (result.success === false) {
+            return {
+                success: false,
+                text: result.error,
+                data: result.status
+                    ? {
+                        active: result.status.active,
+                        endsAt: result.status.endsAt,
+                        websites: result.status.websites,
+                        requiresElevation: result.status.requiresElevation,
+                    }
+                    : undefined,
+            };
+        }
+        if (parsed.request.durationMinutes !== null) {
+            try {
+                const taskId = await syncWebsiteBlockerExpiryTask(runtime);
+                if (!taskId) {
+                    await stopSelfControlBlock();
+                    return {
+                        success: false,
+                        text: "Eliza started the website block but could not schedule its automatic unblock task, so it rolled the block back.",
+                    };
+                }
+            }
+            catch (error) {
+                await stopSelfControlBlock();
+                return {
+                    success: false,
+                    text: `Eliza could not schedule the automatic unblock task, so it rolled the website block back. ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        }
+        return {
+            success: true,
+            text: result.endsAt === null
+                ? `Started a website block for ${formatWebsiteList(parsed.request.websites)} until you unblock it.`
+                : `Started a website block for ${formatWebsiteList(parsed.request.websites)} until ${result.endsAt}.`,
+            data: {
+                websites: parsed.request.websites,
+                durationMinutes: parsed.request.durationMinutes,
+                endsAt: result.endsAt,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "websites",
+            description: "Website hostnames or URLs to block, for example ['x.com', 'twitter.com']. When omitted, the planner can recover them from recent conversation context.",
+            required: false,
+            schema: {
+                type: "array",
+                items: { type: "string" },
+            },
+        },
+        {
+            name: "durationMinutes",
+            description: "How long to block those websites, in minutes. Omit this to use the default duration.",
+            required: false,
+            schema: { type: "number", default: 60 },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Block x.com and twitter.com for 2 hours." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Started a website block for x.com, twitter.com until 2026-04-04T13:44:54.000Z.",
+                    action: "BLOCK_WEBSITES",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "The websites distracting me are x.com and twitter.com. Do not block them yet.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "I noted those websites and will wait for your confirmation before blocking them.",
+                },
+            },
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Use self control now. Actually block the websites for 1 minute instead of giving advice.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Started a website block for x.com, twitter.com until 2026-04-04T13:44:54.000Z.",
+                    action: "BLOCK_WEBSITES",
+                },
+            },
+        ],
+    ],
+};
+export const getWebsiteBlockStatusAction = {
+    name: "GET_WEBSITE_BLOCK_STATUS",
+    similes: [
+        "SELFCONTROL_GET_BLOCK_STATUS",
+        "CHECK_WEBSITE_BLOCK_STATUS",
+        "CHECK_SELFCONTROL",
+        "IS_BLOCK_RUNNING",
+    ],
+    description: "Admin-only. Check whether a local hosts-file website block is currently active and when it ends.",
+    descriptionCompressed: "Admin: check website block status.",
+    validate: async (runtime, message) => {
+        const access = await getSelfControlAccess(runtime, message);
+        return access.allowed;
+    },
+    handler: async (runtime, message) => {
+        const access = await getSelfControlAccess(runtime, message);
+        if (!access.allowed) {
+            return {
+                success: false,
+                text: access.reason ?? SELFCONTROL_ACCESS_ERROR,
+            };
+        }
+        const status = await getSelfControlStatus();
+        return {
+            success: status.available,
+            text: formatStatusText(status),
+            data: {
+                available: status.available,
+                active: status.active,
+                endsAt: status.endsAt,
+                websites: status.websites,
+                requiresElevation: status.requiresElevation,
+                engine: status.engine,
+                platform: status.platform,
+            },
+        };
+    },
+    parameters: [],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Is there a website block running right now?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "A website block is active for x.com, twitter.com until 2026-04-04T13:44:54.000Z.",
+                    action: "GET_WEBSITE_BLOCK_STATUS",
+                },
+            },
+        ],
+    ],
+};
+export const requestWebsiteBlockingPermissionAction = {
+    name: "REQUEST_WEBSITE_BLOCKING_PERMISSION",
+    similes: [
+        "ENABLE_WEBSITE_BLOCKING",
+        "ALLOW_WEBSITE_BLOCKING",
+        "GRANT_WEBSITE_BLOCKING_PERMISSION",
+        "REQUEST_WEBSITE_BLOCKING_PERMISSION",
+        "REQUEST_SELFCONTROL_PERMISSION",
+    ],
+    description: "Admin-only. Prepare local website blocking by requesting administrator/root approval when the machine supports it, or explain the manual change needed when it does not.",
+    descriptionCompressed: "Admin: request website blocking permission.",
+    validate: async (runtime, message) => {
+        const access = await getSelfControlAccess(runtime, message);
+        return access.allowed;
+    },
+    handler: async (runtime, message) => {
+        const access = await getSelfControlAccess(runtime, message);
+        if (!access.allowed) {
+            return {
+                success: false,
+                text: access.reason ?? SELFCONTROL_ACCESS_ERROR,
+            };
+        }
+        const permission = await requestSelfControlPermission();
+        const success = permission.status === "granted" || permission.promptSucceeded === true;
+        return {
+            success,
+            text: formatPermissionText(permission),
+            data: {
+                status: permission.status,
+                canRequest: permission.canRequest,
+                reason: permission.reason,
+                hostsFilePath: permission.hostsFilePath,
+                supportsElevationPrompt: permission.supportsElevationPrompt,
+                elevationPromptMethod: permission.elevationPromptMethod,
+                promptAttempted: permission.promptAttempted,
+                promptSucceeded: permission.promptSucceeded,
+            },
+        };
+    },
+    parameters: [],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Give yourself permission to block websites on this machine.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "The approval prompt completed successfully. Eliza can ask the OS for administrator/root approval whenever it needs to edit the system hosts file. That approval is per operation, so you may see the prompt again when starting or stopping a block.",
+                    action: "REQUEST_WEBSITE_BLOCKING_PERMISSION",
+                },
+            },
+        ],
+    ],
+};
+export const unblockWebsitesAction = {
+    name: "UNBLOCK_WEBSITES",
+    similes: [
+        "SELFCONTROL_UNBLOCK_WEBSITES",
+        "UNBLOCK_WEBSITES",
+        "REMOVE_WEBSITE_BLOCK",
+        "STOP_BLOCKING_SITES",
+    ],
+    description: "Admin-only. Remove the current local website block by restoring the system hosts file entries Eliza added.",
+    descriptionCompressed: "Admin: remove website block.",
+    validate: async (runtime, message) => {
+        const access = await getSelfControlAccess(runtime, message);
+        return access.allowed;
+    },
+    handler: async (runtime, message) => {
+        const access = await getSelfControlAccess(runtime, message);
+        if (!access.allowed) {
+            return {
+                success: false,
+                text: access.reason ?? SELFCONTROL_ACCESS_ERROR,
+            };
+        }
+        const status = await getSelfControlStatus();
+        if (!status.available) {
+            return {
+                success: false,
+                text: status.reason ??
+                    "Local website blocking is unavailable on this machine, so there is nothing to unblock.",
+            };
+        }
+        if (!status.active) {
+            return {
+                success: true,
+                text: "No website block is active right now.",
+                data: {
+                    active: false,
+                    canUnblockEarly: false,
+                    requiresElevation: status.requiresElevation,
+                },
+            };
+        }
+        const result = await stopSelfControlBlock();
+        if (result.success === false) {
+            return {
+                success: false,
+                text: result.error,
+                data: result.status
+                    ? {
+                        active: result.status.active,
+                        canUnblockEarly: result.status.canUnblockEarly,
+                        endsAt: result.status.endsAt,
+                        websites: result.status.websites,
+                        requiresElevation: result.status.requiresElevation,
+                    }
+                    : undefined,
+            };
+        }
+        return {
+            success: true,
+            text: status.endsAt === null
+                ? `Removed the website block for ${formatWebsiteList(status.websites)}.`
+                : `Removed the website block for ${formatWebsiteList(status.websites)} before its scheduled end time.`,
+            data: {
+                active: false,
+                canUnblockEarly: true,
+                endsAt: null,
+                websites: status.websites,
+            },
+        };
+    },
+    parameters: [],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Unblock x.com right now." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Removed the website block for x.com before its scheduled end time.",
+                    action: "UNBLOCK_WEBSITES",
+                },
+            },
+        ],
+    ],
+};
+export const selfControlBlockWebsitesAction = blockWebsitesAction;
+export const selfControlGetStatusAction = getWebsiteBlockStatusAction;
+export const selfControlRequestPermissionAction = requestWebsiteBlockingPermissionAction;
+export const selfControlUnblockWebsitesAction = unblockWebsitesAction;

package/apps/app-lifeops/src/actions/x-read.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"x-read.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/x-read.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAQP,MAAM,eAAe,CAAC;AA6MvB,eAAO,MAAM,WAAW,EAAE,MAuOzB,CAAC"}