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

package/apps/app-lifeops/src/travel-time/service.d.ts

@@ -0,0 +1,61 @@
+/**
+ * T8a — Travel-time awareness (plan §6.9).
+ *
+ * {@link TravelTimeService} computes a travel-time buffer (in minutes) for a
+ * calendar event. When GOOGLE_MAPS_API_KEY is set, it calls Google's
+ * Distance Matrix API with `departure_time=now` and prefers
+ * `duration_in_traffic` over `duration`. When the key is absent or the call
+ * fails, it returns an explicit fallback result carrying
+ * `method: "fallback-fixed"` so consumers can branch on partial data — this
+ * is explicit-absence, not a stub.
+ */
+import type { IAgentRuntime } from "@elizaos/core";
+import type { LifeOpsCalendarFeed } from "@elizaos/shared/contracts/lifeops";
+export declare const FALLBACK_FIXED_BUFFER_MINUTES = 30;
+export declare const GOOGLE_DISTANCE_MATRIX_URL = "https://maps.googleapis.com/maps/api/distancematrix/json";
+export type TravelBufferMethod = "maps-api" | "fallback-fixed";
+export interface TravelBufferResult {
+    bufferMinutes: number;
+    method: TravelBufferMethod;
+    /** Reason included when method === "fallback-fixed". */
+    reason?: string;
+    originAddress: string | null;
+    destinationAddress: string | null;
+}
+export interface ComputeTravelBufferInput {
+    eventId: string;
+    originAddress?: string;
+}
+/** Structural provider for resolving an event's destination address. */
+export interface CalendarEventLookupLike {
+    getCalendarFeed(requestUrl: URL, request: {
+        timeMin?: string;
+        timeMax?: string;
+    }, now?: Date): Promise<LifeOpsCalendarFeed>;
+}
+/** Injectable HTTP fetcher so tests don't hit the network. */
+export type TravelTimeFetch = (url: string, init?: {
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+}>;
+export interface TravelTimeServiceDeps {
+    calendar: CalendarEventLookupLike;
+    /** Optional fetch override. Defaults to global `fetch`. */
+    fetchImpl?: TravelTimeFetch;
+    /** Optional env accessor — defaults to `process.env.GOOGLE_MAPS_API_KEY`. */
+    getApiKey?: () => string | undefined;
+    /** Default origin used when caller omits originAddress. */
+    defaultOriginAddress?: string | null;
+}
+export declare class TravelTimeService {
+    private readonly runtime;
+    private readonly deps;
+    constructor(runtime: IAgentRuntime, deps: TravelTimeServiceDeps);
+    computeBuffer(input: ComputeTravelBufferInput): Promise<TravelBufferResult>;
+    private fallback;
+    private resolveEvent;
+}
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/travel-time/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,mCAAmC,CAAC;AAE3C,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAChD,eAAO,MAAM,0BAA0B,6DACqB,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAE/D,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wEAAwE;AACxE,MAAM,WAAW,uBAAuB;IACtC,eAAe,CACb,UAAU,EAAE,GAAG,EACf,OAAO,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,EAC/C,GAAG,CAAC,EAAE,IAAI,GACT,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACjC;AAED,8DAA8D;AAC9D,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,KAC5B,OAAO,CAAC;IACX,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9B,CAAC,CAAC;AAEH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,uBAAuB,CAAC;IAClC,2DAA2D;IAC3D,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACrC,2DAA2D;IAC3D,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAeD,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBADJ,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,qBAAqB;IAGxC,aAAa,CACjB,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,kBAAkB,CAAC;IA+D9B,OAAO,CAAC,QAAQ;YAiBF,YAAY;CAmB3B"}

package/apps/app-lifeops/src/travel-time/service.js

@@ -0,0 +1,145 @@
+/**
+ * T8a — Travel-time awareness (plan §6.9).
+ *
+ * {@link TravelTimeService} computes a travel-time buffer (in minutes) for a
+ * calendar event. When GOOGLE_MAPS_API_KEY is set, it calls Google's
+ * Distance Matrix API with `departure_time=now` and prefers
+ * `duration_in_traffic` over `duration`. When the key is absent or the call
+ * fails, it returns an explicit fallback result carrying
+ * `method: "fallback-fixed"` so consumers can branch on partial data — this
+ * is explicit-absence, not a stub.
+ */
+import { logger } from "@elizaos/core";
+export const FALLBACK_FIXED_BUFFER_MINUTES = 30;
+export const GOOGLE_DISTANCE_MATRIX_URL = "https://maps.googleapis.com/maps/api/distancematrix/json";
+export class TravelTimeService {
+    runtime;
+    deps;
+    constructor(runtime, deps) {
+        this.runtime = runtime;
+        this.deps = deps;
+    }
+    async computeBuffer(input) {
+        const event = await this.resolveEvent(input.eventId);
+        if (!event) {
+            throw new Error(`[TravelTimeService] event ${input.eventId} not found`);
+        }
+        const destinationAddress = normalizeAddress(event.location);
+        const originAddress = normalizeAddress(input.originAddress) ??
+            normalizeAddress(this.deps.defaultOriginAddress ?? null);
+        if (!destinationAddress) {
+            return this.fallback(originAddress, destinationAddress, "event has no location");
+        }
+        if (!originAddress) {
+            return this.fallback(originAddress, destinationAddress, "no origin address supplied");
+        }
+        const apiKey = (this.deps.getApiKey ?? (() => process.env.GOOGLE_MAPS_API_KEY))();
+        if (!apiKey) {
+            return this.fallback(originAddress, destinationAddress, "GOOGLE_MAPS_API_KEY not set");
+        }
+        const url = buildDistanceMatrixUrl({
+            apiKey,
+            origin: originAddress,
+            destination: destinationAddress,
+        });
+        const fetchImpl = this.deps.fetchImpl ?? globalFetch;
+        const response = await safeFetch(fetchImpl, url);
+        if (response.ok === false) {
+            return this.fallback(originAddress, destinationAddress, `distance matrix ${response.kind}: ${response.message}`);
+        }
+        const parsed = parseDistanceMatrix(response.body);
+        if (parsed.ok === false) {
+            return this.fallback(originAddress, destinationAddress, parsed.reason);
+        }
+        return {
+            bufferMinutes: parsed.bufferMinutes,
+            method: "maps-api",
+            originAddress,
+            destinationAddress,
+        };
+    }
+    fallback(originAddress, destinationAddress, reason) {
+        logger.warn(`[TravelTimeService] falling back to fixed ${FALLBACK_FIXED_BUFFER_MINUTES}m buffer: ${reason}`);
+        return {
+            bufferMinutes: FALLBACK_FIXED_BUFFER_MINUTES,
+            method: "fallback-fixed",
+            reason,
+            originAddress,
+            destinationAddress,
+        };
+    }
+    async resolveEvent(eventId) {
+        const now = new Date();
+        const timeMin = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
+            .toISOString();
+        const timeMax = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000)
+            .toISOString();
+        const feed = await this.deps.calendar.getCalendarFeed(new URL("internal://travel-time/resolve"), { timeMin, timeMax }, now);
+        return (feed.events.find((e) => e.id === eventId || e.externalId === eventId) ?? null);
+    }
+}
+function normalizeAddress(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildDistanceMatrixUrl(input) {
+    const params = new URLSearchParams({
+        origins: input.origin,
+        destinations: input.destination,
+        departure_time: "now",
+        key: input.apiKey,
+    });
+    return `${GOOGLE_DISTANCE_MATRIX_URL}?${params.toString()}`;
+}
+async function safeFetch(fetchImpl, url) {
+    try {
+        const res = await fetchImpl(url);
+        if (!res.ok) {
+            return {
+                ok: false,
+                kind: "http",
+                message: `status ${res.status}`,
+            };
+        }
+        const body = await res.json();
+        return { ok: true, body };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            kind: "network",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function parseDistanceMatrix(body) {
+    if (!body || typeof body !== "object") {
+        return { ok: false, reason: "response was not an object" };
+    }
+    const resp = body;
+    if (resp.status !== "OK") {
+        return { ok: false, reason: `distance matrix status ${resp.status}` };
+    }
+    const element = resp.rows?.[0]?.elements?.[0];
+    if (!element) {
+        return { ok: false, reason: "distance matrix returned no elements" };
+    }
+    if (element.status !== "OK") {
+        return { ok: false, reason: `element status ${element.status}` };
+    }
+    const seconds = element.duration_in_traffic?.value ?? element.duration?.value ?? null;
+    if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) {
+        return { ok: false, reason: "no duration in response" };
+    }
+    return { ok: true, bufferMinutes: Math.max(1, Math.ceil(seconds / 60)) };
+}
+const globalFetch = async (url, init) => {
+    const res = await fetch(url, init);
+    return {
+        ok: res.ok,
+        status: res.status,
+        json: () => res.json(),
+    };
+};

package/apps/app-lifeops/src/types/app-blocker-settings-card.d.ts

@@ -0,0 +1,2 @@
+export type { AppBlockerSettingsCardProps, AppBlockerSettingsMode, } from "@elizaos/shared/contracts/lifeops";
+//# sourceMappingURL=app-blocker-settings-card.d.ts.map

package/apps/app-lifeops/src/types/app-blocker-settings-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-blocker-settings-card.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/types/app-blocker-settings-card.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,2BAA2B,EAC3B,sBAAsB,GACvB,MAAM,mCAAmC,CAAC"}

package/apps/app-lifeops/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { AppBlockerSettingsCardProps, AppBlockerSettingsMode, } from "./app-blocker-settings-card.ts";
+export type { WebsiteBlockerSettingsCardProps, WebsiteBlockerSettingsMode, } from "./website-blocker-settings-card.ts";
+//# sourceMappingURL=index.d.ts.map

package/apps/app-lifeops/src/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,2BAA2B,EAC3B,sBAAsB,GACvB,MAAM,gCAAgC,CAAC;AACxC,YAAY,EACV,+BAA+B,EAC/B,0BAA0B,GAC3B,MAAM,oCAAoC,CAAC"}

package/apps/app-lifeops/src/types/website-blocker-settings-card.d.ts

@@ -0,0 +1,2 @@
+export type { WebsiteBlockerSettingsCardProps, WebsiteBlockerSettingsMode, } from "@elizaos/shared/contracts/lifeops";
+//# sourceMappingURL=website-blocker-settings-card.d.ts.map

package/apps/app-lifeops/src/types/website-blocker-settings-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"website-blocker-settings-card.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/types/website-blocker-settings-card.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,+BAA+B,EAC/B,0BAA0B,GAC3B,MAAM,mCAAmC,CAAC"}

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

@@ -0,0 +1,8 @@
+import { type IAgentRuntime, type Memory } from "@elizaos/core";
+export declare const SELFCONTROL_ACCESS_ERROR = "Website blocking is restricted to OWNER and ADMIN users.";
+export declare function getSelfControlAccess(runtime: IAgentRuntime, message: Memory): Promise<{
+    allowed: boolean;
+    role: string | null;
+    reason?: string;
+}>;
+//# sourceMappingURL=access.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/website-blocker/access.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAGxE,eAAO,MAAM,wBAAwB,6DACuB,CAAC;AAE7D,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IACT,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAgCD"}

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

@@ -0,0 +1,32 @@
+import { logger } from "@elizaos/core";
+import { checkSenderRole } from "./roles.js";
+export const SELFCONTROL_ACCESS_ERROR = "Website blocking is restricted to OWNER and ADMIN users.";
+export async function getSelfControlAccess(runtime, message) {
+    let roleCheck;
+    try {
+        roleCheck = await checkSenderRole(runtime, message);
+    }
+    catch (err) {
+        // checkSenderRole throws when the world/room/entity setup is broken.
+        // Log loudly so the root cause gets fixed, but don't crash the whole
+        // action-validation pass (Promise.all in the actions provider would
+        // reject and kill every action, not just this one).
+        logger.error({ err, roomId: message.roomId, entityId: message.entityId }, "[selfcontrol] Role check failed — world/room/entity setup is broken");
+        return {
+            allowed: false,
+            role: null,
+            reason: `Website blocking is unavailable: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!roleCheck.isAdmin) {
+        return {
+            allowed: false,
+            role: roleCheck.role,
+            reason: SELFCONTROL_ACCESS_ERROR,
+        };
+    }
+    return {
+        allowed: true,
+        role: roleCheck.role,
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"blockUntilTaskComplete.d.ts","sourceRoot":"","sources":["../../../../../../../../../apps/app-lifeops/src/website-blocker/chat-integration/actions/blockUntilTaskComplete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAwHvB,eAAO,MAAM,4BAA4B,EAAE,MA8H1C,CAAC"}

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

@@ -0,0 +1,212 @@
+import { logger } from "@elizaos/core";
+import crypto from "node:crypto";
+import { executeRawSql, sqlQuote } from "../../../lifeops/sql.js";
+import { BlockRuleWriter } from "../block-rule-service.js";
+function coerceStringArray(value) {
+    if (typeof value === "string") {
+        return value
+            .split(/[,\s]+/)
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0);
+    }
+    if (Array.isArray(value)) {
+        const result = [];
+        for (const entry of value) {
+            if (typeof entry !== "string")
+                continue;
+            const trimmed = entry.trim();
+            if (trimmed.length > 0)
+                result.push(trimmed);
+        }
+        return result;
+    }
+    return [];
+}
+function coerceNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function coerceString(value) {
+    if (typeof value === "string" && value.trim().length > 0) {
+        return value.trim();
+    }
+    return null;
+}
+async function findTodoIdByName(runtime, name) {
+    const agentId = String(runtime.agentId);
+    const needle = name.toLowerCase();
+    const rows = await executeRawSql(runtime, `SELECT id, title FROM life_task_definitions
+       WHERE agent_id = ${sqlQuote(agentId)}
+         AND status = 'active'
+       ORDER BY created_at DESC`);
+    for (const row of rows) {
+        const title = typeof row.title === "string" ? row.title.toLowerCase() : "";
+        if (title === needle || title.includes(needle)) {
+            const id = row.id;
+            if (typeof id === "string")
+                return id;
+        }
+    }
+    return null;
+}
+async function createTodoByName(runtime, name) {
+    const agentId = String(runtime.agentId);
+    const id = crypto.randomUUID();
+    const nowIso = new Date().toISOString();
+    await executeRawSql(runtime, `INSERT INTO life_task_definitions (
+       id, agent_id, domain, subject_type, subject_id, visibility_scope,
+       context_policy, kind, title, description, original_intent, timezone,
+       status, priority, cadence_json, window_policy_json,
+       progression_rule_json, website_access_json, reminder_plan_id, goal_id, source,
+       metadata_json, created_at, updated_at
+     ) VALUES (
+       ${sqlQuote(id)},
+       ${sqlQuote(agentId)},
+       'user_lifeops',
+       'owner',
+       ${sqlQuote(agentId)},
+       'owner_agent_admin',
+       'explicit_only',
+       'todo',
+       ${sqlQuote(name)},
+       '',
+       ${sqlQuote(name)},
+       'UTC',
+       'active',
+       3,
+       '{}',
+       '{}',
+       '{}',
+       NULL,
+       NULL,
+       NULL,
+       'block-until-task-complete',
+       '{}',
+       ${sqlQuote(nowIso)},
+       ${sqlQuote(nowIso)}
+     )`);
+    logger.info(`[BLOCK_UNTIL_TASK_COMPLETE] Created todo ${id} for "${name}"`);
+    return id;
+}
+export const blockUntilTaskCompleteAction = {
+    name: "BLOCK_UNTIL_TASK_COMPLETE",
+    similes: [
+        "BLOCK_SITES_UNTIL_TODO_DONE",
+        "BLOCK_WEBSITE_UNTIL_TASK",
+        "CONDITIONAL_WEBSITE_BLOCK",
+    ],
+    description: "Block websites until a specific todo is marked complete. Creates a block rule whose release is gated on todo completion. " +
+        "If todoName is provided with no matching active todo, the todo is created first.",
+    descriptionCompressed: "Block websites until a named todo is completed.",
+    validate: async () => true,
+    handler: async (runtime, _message, _state, options) => {
+        const params = (options?.parameters ?? {});
+        const websites = coerceStringArray(params.websites);
+        if (websites.length === 0) {
+            return {
+                success: false,
+                text: "BLOCK_UNTIL_TASK_COMPLETE requires at least one website.",
+            };
+        }
+        const explicitTodoId = coerceString(params.todoId);
+        const todoName = coerceString(params.todoName);
+        const unlockDurationMinutes = coerceNumber(params.unlockDurationMinutes);
+        const profile = coerceString(params.profile) ?? `chat-${websites.join(",")}`;
+        let todoId;
+        let createdTodo = false;
+        if (explicitTodoId) {
+            todoId = explicitTodoId;
+        }
+        else if (todoName) {
+            const matched = await findTodoIdByName(runtime, todoName);
+            if (matched) {
+                todoId = matched;
+            }
+            else {
+                todoId = await createTodoByName(runtime, todoName);
+                createdTodo = true;
+            }
+        }
+        else {
+            return {
+                success: false,
+                text: "BLOCK_UNTIL_TASK_COMPLETE requires either todoId or todoName.",
+            };
+        }
+        const writer = new BlockRuleWriter(runtime);
+        const unlockDurationMs = unlockDurationMinutes !== null && unlockDurationMinutes > 0
+            ? Math.round(unlockDurationMinutes * 60_000)
+            : null;
+        const ruleId = await writer.createBlockRule({
+            profile,
+            websites,
+            gateType: "until_todo",
+            gateTodoId: todoId,
+            unlockDurationMs,
+        });
+        return {
+            success: true,
+            text: `Block rule created for ${websites.join(", ")} until todo ${todoId} is completed.`,
+            data: {
+                ruleId,
+                todoId,
+                createdTodo,
+                websites,
+                unlockDurationMs,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "websites",
+            description: "List of website hostnames to block.",
+            required: true,
+            schema: { type: "array", items: { type: "string" } },
+        },
+        {
+            name: "todoId",
+            description: "ID of an existing todo. Preferred over todoName when known.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "todoName",
+            description: "Name of the todo. Resolved against active todos; created if no match.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "unlockDurationMinutes",
+            description: "Optional: once the gate is satisfied, re-lock the same websites after this many minutes.",
+            required: false,
+            schema: { type: "number" },
+        },
+        {
+            name: "profile",
+            description: "Optional profile label for the block rule.",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Block x.com until I finish my workout." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Block rule created for x.com until todo workout is completed.",
+                    action: "BLOCK_UNTIL_TASK_COMPLETE",
+                },
+            },
+        ],
+    ],
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"listActiveBlocks.d.ts","sourceRoot":"","sources":["../../../../../../../../../apps/app-lifeops/src/website-blocker/chat-integration/actions/listActiveBlocks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAIP,MAAM,eAAe,CAAC;AAGvB,eAAO,MAAM,sBAAsB,EAAE,MA0DpC,CAAC"}

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

@@ -0,0 +1,57 @@
+import { BlockRuleReader } from "../block-rule-service.js";
+export const listActiveBlocksAction = {
+    name: "LIST_ACTIVE_BLOCKS",
+    similes: ["LIST_BLOCK_RULES", "SHOW_ACTIVE_BLOCKS", "WEBSITE_BLOCKS_STATUS"],
+    description: "List all currently active website block rules, including their gate type and gate target. Only use this for website/app blocking status. Do not use it for inbox blockers, message priority, daily briefs, or general executive-assistant triage.",
+    descriptionCompressed: "List active website block rules.",
+    validate: async () => true,
+    handler: async (runtime) => {
+        const reader = new BlockRuleReader(runtime);
+        const rules = await reader.listActiveBlocks();
+        if (rules.length === 0) {
+            return {
+                success: true,
+                text: "No active website block rules.",
+                data: { rules: [] },
+            };
+        }
+        const summaries = rules.map((rule) => {
+            const parts = [
+                `${rule.id} (${rule.gateType})`,
+                `sites=${rule.websites.join(",")}`,
+            ];
+            if (rule.gateType === "until_todo" && rule.gateTodoId) {
+                parts.push(`todo=${rule.gateTodoId}`);
+            }
+            if (rule.gateType === "until_iso" && rule.gateUntilMs !== null) {
+                parts.push(`until=${new Date(rule.gateUntilMs).toISOString()}`);
+            }
+            if (rule.gateType === "fixed_duration" &&
+                rule.fixedDurationMs !== null) {
+                parts.push(`duration_ms=${rule.fixedDurationMs}`);
+            }
+            return parts.join(" ");
+        });
+        return {
+            success: true,
+            text: `Active block rules:\n${summaries.join("\n")}`,
+            data: { rules },
+        };
+    },
+    parameters: [],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "What website blocks are active right now?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Active block rules: ...",
+                    action: "LIST_ACTIVE_BLOCKS",
+                },
+            },
+        ],
+    ],
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"releaseBlock.d.ts","sourceRoot":"","sources":["../../../../../../../../../apps/app-lifeops/src/website-blocker/chat-integration/actions/releaseBlock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AA0BvB,eAAO,MAAM,kBAAkB,EAAE,MAsFhC,CAAC"}