@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/actions/website-block.js

@@ -0,0 +1,719 @@
+import {
+  ModelType,
+  parseJsonModelRecord,
+  requireConfirmation,
+  resolveActionArgs,
+  runWithTrajectoryContext
+} from "@elizaos/core";
+import {
+  formatWebsiteList,
+  getSelfControlAccess,
+  getSelfControlStatus,
+  normalizeWebsiteTargets,
+  parseSelfControlBlockRequest,
+  requestSelfControlPermission,
+  SELFCONTROL_ACCESS_ERROR,
+  stopSelfControlBlock
+} from "@elizaos/plugin-blocker/services/website-blocker/index";
+import { activateBlockRule } from "../website-blocker/chat-integration/block-activator.js";
+import {
+  BlockRuleReader,
+  BlockRuleWriter
+} from "../website-blocker/chat-integration/block-rule-service.js";
+import { hasActiveHarshNoBypassRule } from "../website-blocker/chat-integration/harsh-mode-check.js";
+const ACTION_NAME = "BLOCK";
+const SUBACTIONS = {
+  block: {
+    description: "Start a hosts-file block on a set of public hostnames for a fixed duration or indefinitely. Always drafts first; requires confirmed:true to actually edit the hosts file. Heuristic and LLM extract hosts from intent.",
+    descriptionCompressed: "hosts-file block hostnames duration draft-confirm heuristic+LLM extract-hosts",
+    required: ["intent"],
+    optional: ["hostnames", "durationMinutes", "confirmed"]
+  },
+  unblock: {
+    description: "Clear the active hosts-file block and restore the entries Eliza added. Blocked when a harsh-no-bypass rule is set.",
+    descriptionCompressed: "clear hosts-file block restore entries blocked-if-harsh-no-bypass",
+    required: []
+  },
+  status: {
+    description: "Check whether a hosts-file website block is currently active and when it ends.",
+    descriptionCompressed: "hosts-block active+endsAt",
+    required: []
+  },
+  request_permission: {
+    description: "Request administrator/root approval for hosts-file edits, or explain the manual change needed when the OS does not support an elevation prompt.",
+    descriptionCompressed: "request admin/root approval hosts-edits | explain manual-change",
+    required: []
+  },
+  release: {
+    description: "Release a managed website block rule by id. Asks the user to confirm on a follow-up turn (reply yes) before releasing \u2014 an LLM-supplied confirmed flag is never authoritative. harsh_no_bypass rules cannot be released through this path \u2014 they must wait for gate fulfillment.",
+    descriptionCompressed: "release managed-block-rule(id) two-turn-confirm; harsh_no_bypass not releasable",
+    required: ["ruleId"],
+    optional: ["reason", "confirmed"]
+  },
+  list_active: {
+    description: "Report the current website blocker state by combining the live OS-level hosts/SelfControl status with LifeOps-managed block rules (id, gateType, websites, gate target). Toggle either source via includeLiveStatus and includeManagedRules.",
+    descriptionCompressed: "list-active-blocks live hosts/SelfControl + managed rules",
+    required: [],
+    optional: ["includeLiveStatus", "includeManagedRules"]
+  }
+};
+function coerceConfirmedFlag(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "true" || normalized === "yes" || normalized === "1";
+  }
+  return false;
+}
+function getMessageText(message) {
+  return typeof message.content.text === "string" ? message.content.text : "";
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function memoryLikeToConversationTurn(value, agentId) {
+  const memory = asRecord(value);
+  const content = asRecord(memory?.content);
+  const text = typeof content?.text === "string" ? content.text.trim() : "";
+  if (!text) return null;
+  return {
+    speaker: memory?.entityId === agentId ? "assistant" : "user",
+    text
+  };
+}
+function collectProviderBackedConversationTurns(args) {
+  const providers = asRecord(asRecord(args.state?.data)?.providers);
+  const recentMessagesProvider = asRecord(providers?.RECENT_MESSAGES);
+  const recentMessages = asRecord(recentMessagesProvider?.data)?.recentMessages;
+  if (!Array.isArray(recentMessages)) return [];
+  return recentMessages.map((memory) => memoryLikeToConversationTurn(memory, args.agentId)).filter(
+    (turn) => turn !== null && turn.text.length > 0
+  ).slice(-args.limit);
+}
+function normalizeWebsiteCandidates(value) {
+  const values = Array.isArray(value) ? value : typeof value === "string" ? value.slice(0, 1e4).split(/\s{0,256}\|\|\s{0,256}|,|\n/) : [];
+  return [
+    ...new Set(
+      values.filter((item) => typeof item === "string").map((item) => item.trim().slice(0, 1024)).map((item) => item.replace(/^[[\]'"]{1,32}|[[\]'"]{1,32}$/g, "")).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 void 0;
+    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 void 0;
+}
+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 void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+const WEBSITE_ALIAS_MAP = {
+  twitter: ["x.com", "twitter.com"],
+  x: ["x.com", "twitter.com"],
+  reddit: ["reddit.com"],
+  youtube: ["youtube.com"],
+  facebook: ["facebook.com"],
+  instagram: ["instagram.com"],
+  tiktok: ["tiktok.com"]
+};
+const SOCIAL_MEDIA_SITES = [
+  "facebook.com",
+  "instagram.com",
+  "reddit.com",
+  "tiktok.com",
+  "twitter.com",
+  "x.com",
+  "youtube.com"
+];
+function extractHostsFromIntent(text) {
+  const normalized = text.toLowerCase();
+  const fromAliases = Object.entries(WEBSITE_ALIAS_MAP).flatMap(
+    ([alias, websites]) => {
+      if (!new RegExp(`(^|[^a-z0-9])${alias}([^a-z0-9]|$)`, "i").test(normalized)) {
+        return [];
+      }
+      return [...websites];
+    }
+  );
+  const explicitHosts = Array.from(
+    normalized.matchAll(
+      /\b(?:https?:\/\/)?(?:www\.)?([a-z0-9-]+(?:\.[a-z0-9-]+)+)\b/g
+    ),
+    (match) => match[1] ?? ""
+  );
+  if (/\bsocial media\b/i.test(normalized)) {
+    return normalizeWebsiteCandidates([
+      ...explicitHosts,
+      ...fromAliases,
+      ...SOCIAL_MEDIA_SITES
+    ]);
+  }
+  return normalizeWebsiteCandidates([...explicitHosts, ...fromAliases]);
+}
+function extractHeuristicDurationMinutes(text) {
+  const normalized = text.toLowerCase();
+  if (/\buntil (?:i|we) unblock\b/.test(normalized) || /\buntil manual(?:ly)? removed?\b/.test(normalized) || /\bforever\b/.test(normalized)) {
+    return null;
+  }
+  const hourMatch = normalized.match(/\b(\d+(?:\.\d+)?)\s*hours?\b/);
+  if (hourMatch?.[1]) {
+    return Math.round(Number.parseFloat(hourMatch[1]) * 60);
+  }
+  const minuteMatch = normalized.match(/\b(\d+(?:\.\d+)?)\s*minutes?\b/);
+  if (minuteMatch?.[1]) {
+    return Math.round(Number.parseFloat(minuteMatch[1]));
+  }
+  return void 0;
+}
+function shouldTrustExplicitWebsites(explicitWebsites, heuristicWebsites) {
+  if (explicitWebsites.length === 0) return false;
+  if (heuristicWebsites.length === 0) return true;
+  return explicitWebsites.every(
+    (website) => heuristicWebsites.includes(website)
+  );
+}
+async function collectWebsiteBlockConversationTurns(args) {
+  const roomId = typeof args.message.roomId === "string" ? args.message.roomId : "";
+  if (!roomId || typeof args.runtime.getMemories !== "function") {
+    return collectProviderBackedConversationTurns({
+      state: args.state,
+      agentId: String(args.runtime.agentId),
+      limit: args.limit
+    });
+  }
+  try {
+    const memories = await args.runtime.getMemories({
+      roomId,
+      tableName: "messages",
+      limit: Math.max(args.limit * 2, args.limit)
+    });
+    if (!Array.isArray(memories)) return [];
+    return memories.slice().sort((left, right) => (left.createdAt ?? 0) - (right.createdAt ?? 0)).map((memory) => {
+      const text = typeof memory.content.text === "string" ? memory.content.text.trim() : "";
+      if (!text) return null;
+      return {
+        speaker: memory.entityId === args.runtime.agentId ? "assistant" : "user",
+        text
+      };
+    }).filter(
+      (turn) => turn !== null && turn.text.length > 0
+    ).slice(-args.limit);
+  } catch {
+    return collectProviderBackedConversationTurns({
+      state: args.state,
+      agentId: String(args.runtime.agentId),
+      limit: args.limit
+    });
+  }
+}
+async function resolveWebsiteBlockPlanWithLlm(args) {
+  const recentTurns = await collectWebsiteBlockConversationTurns({
+    runtime: args.runtime,
+    message: args.message,
+    state: args.state,
+    limit: 10
+  });
+  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 JSON only as a single 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, or null/omit for an indefinite/manual block",
+    "",
+    "Rules:",
+    "- Only start a block when the user is clearly asking to block websites now.",
+    "- Do not encode user authorization in JSON; authorization is collected on a follow-up user message.",
+    "- Generic focus-block requests like 'turn on a focus block for all social media sites' belong here; do not invent a task gate for them.",
+    "- If the user says not now, 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.",
+    "- If the user does not give a duration, omit durationMinutes so the block stays active until manually removed.",
+    "- Use durationMinutes=null when the user explicitly wants the block to last until manual removal.",
+    "- If the user gives an exact timed duration like 45, 90, or 135 minutes, preserve that exact duration.",
+    "",
+    'Return JSON only, for example {"shouldAct":true,"response":null,"websites":["x.com"],"durationMinutes":60}.',
+    "Current request:",
+    currentMessage || "(empty)",
+    "Recent conversation turns:",
+    recentTurns.map((t) => `${t.speaker}: ${t.text}`).join("\n") || "(none)"
+  ].join("\n");
+  try {
+    const result = await runWithTrajectoryContext(
+      { purpose: "lifeops-website-block-planner" },
+      () => args.runtime.useModel(ModelType.TEXT_LARGE, {
+        prompt
+      })
+    );
+    const rawResponse = typeof result === "string" ? result : "";
+    const parsed = parseJsonModelRecord(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-block",
+        error: error instanceof Error ? error.message : String(error)
+      },
+      "Website blocker planning model call failed"
+    );
+    return { websites: [], shouldAct: null };
+  }
+}
+async function recoverWebsiteContextWithLlm(args) {
+  const recentTurns = await collectWebsiteBlockConversationTurns({
+    runtime: args.runtime,
+    message: args.message,
+    state: args.state,
+    limit: 12
+  });
+  if (recentTurns.length === 0) return [];
+  const currentMessage = getMessageText(args.message).trim();
+  const prompt = [
+    "Recover previously mentioned public website hostnames for a website-block request.",
+    "Use the current request plus recent conversation context.",
+    'Return JSON only as {"websites":["example.com"]}.',
+    "  websites: array of public website hostnames or URLs relevant to the current blocking request",
+    "",
+    "Rules:",
+    "- Extract only websites that were actually mentioned in recent conversation.",
+    "- Prefer bare public hostnames like x.com.",
+    "- Do not invent websites.",
+    "- Return an empty array when no websites were previously mentioned.",
+    "",
+    "Return JSON only.",
+    "Current request:",
+    currentMessage || "(empty)",
+    "Recent conversation turns:",
+    recentTurns.map((t) => `${t.speaker}: ${t.text}`).join("\n") || "(none)"
+  ].join("\n");
+  try {
+    const result = await runWithTrajectoryContext(
+      { purpose: "lifeops-website-block-recovery" },
+      () => args.runtime.useModel(ModelType.TEXT_LARGE, {
+        prompt
+      })
+    );
+    const rawResponse = typeof result === "string" ? result : "";
+    const parsed = parseJsonModelRecord(rawResponse);
+    return normalizeWebsiteCandidates(parsed?.websites);
+  } catch (error) {
+    args.runtime.logger.warn(
+      {
+        src: "action:website-block",
+        error: error instanceof Error ? error.message : String(error)
+      },
+      "Website blocker context recovery model call failed"
+    );
+    return [];
+  }
+}
+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.";
+}
+async function handleBlock(runtime, message, state, params) {
+  const messageText = getMessageText(message);
+  const explicitWebsites = normalizeWebsiteTargets(
+    normalizeWebsiteCandidates(params.hostnames)
+  );
+  const explicitDurationMinutes = normalizeDurationMinutes(
+    params.durationMinutes
+  );
+  const heuristicWebsites = normalizeWebsiteTargets(
+    extractHostsFromIntent(messageText)
+  );
+  const trustedExplicitWebsites = shouldTrustExplicitWebsites(
+    explicitWebsites,
+    heuristicWebsites
+  ) ? explicitWebsites : [];
+  const heuristicDurationMinutes = explicitDurationMinutes === void 0 ? extractHeuristicDurationMinutes(messageText) : explicitDurationMinutes;
+  const llmPlan = trustedExplicitWebsites.length === 0 && heuristicWebsites.length === 0 ? await resolveWebsiteBlockPlanWithLlm({ runtime, message, state }) : null;
+  const recoveredWebsites = trustedExplicitWebsites.length === 0 && (llmPlan?.websites.length ?? 0) === 0 ? await recoverWebsiteContextWithLlm({ runtime, message, state }) : [];
+  const plannedWebsites = trustedExplicitWebsites.length > 0 ? trustedExplicitWebsites : heuristicWebsites.length > 0 ? heuristicWebsites : ((llmPlan?.websites.length ?? 0) > 0 ? llmPlan?.websites : recoveredWebsites) ?? [];
+  const plannedWebsitesSafe = plannedWebsites;
+  if (llmPlan?.shouldAct === false && trustedExplicitWebsites.length === 0) {
+    return {
+      success: false,
+      text: llmPlan.response ?? (plannedWebsitesSafe.length > 0 ? `I noted ${formatWebsiteList(plannedWebsitesSafe)} and will wait for your confirmation before blocking them.` : "I noted those websites and will wait for your confirmation before blocking them."),
+      data: {
+        deferred: true,
+        noop: true,
+        websites: [...plannedWebsitesSafe]
+      }
+    };
+  }
+  const parsed = parseSelfControlBlockRequest({
+    parameters: {
+      websites: plannedWebsitesSafe.length > 0 ? [...plannedWebsitesSafe] : null,
+      durationMinutes: explicitDurationMinutes !== void 0 ? explicitDurationMinutes : heuristicDurationMinutes !== void 0 ? heuristicDurationMinutes : llmPlan?.durationMinutes ?? null
+    }
+  });
+  if (!parsed.request) {
+    return {
+      success: false,
+      text: llmPlan?.response ?? parsed.error ?? "Could not determine which public website hostnames to block."
+    };
+  }
+  const websitesLabel = formatWebsiteList(parsed.request.websites);
+  const durationLabel = parsed.request.durationMinutes === null ? "until you manually unblock" : `for ${parsed.request.durationMinutes} minute${parsed.request.durationMinutes === 1 ? "" : "s"}`;
+  const confirmPrompt = `Ready to block ${websitesLabel} ${durationLabel}.`;
+  const decision = await requireConfirmation({
+    runtime,
+    message,
+    actionName: "WEBSITE_BLOCK",
+    pendingKey: `block:${parsed.request.websites.join(",")}:${parsed.request.durationMinutes ?? "manual"}`,
+    prompt: confirmPrompt
+  });
+  if (decision.status !== "confirmed") {
+    return {
+      success: decision.status === "pending",
+      text: decision.status === "pending" ? `${confirmPrompt} Reply yes to confirm or no to cancel.` : "Website block cancelled.",
+      data: {
+        draft: true,
+        requiresConfirmation: decision.status === "pending",
+        awaitingUserInput: decision.status === "pending",
+        cancelled: decision.status === "cancelled",
+        websites: parsed.request.websites,
+        durationMinutes: parsed.request.durationMinutes
+      }
+    };
+  }
+  const activation = await activateBlockRule({
+    runtime,
+    websites: parsed.request.websites,
+    durationMinutes: parsed.request.durationMinutes
+  });
+  if (activation.success === false) {
+    return {
+      success: false,
+      text: activation.error
+    };
+  }
+  return {
+    success: true,
+    text: activation.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 ${activation.endsAt}.`,
+    data: {
+      websites: parsed.request.websites,
+      durationMinutes: parsed.request.durationMinutes,
+      endsAt: activation.endsAt
+    }
+  };
+}
+async function handleUnblock(runtime) {
+  if (await hasActiveHarshNoBypassRule(runtime)) {
+    return {
+      success: false,
+      text: "You set a harsh-no-bypass rule for this \u2014 clear the rule first via the rule manager. The reconciler would re-create the block on its next tick anyway.",
+      data: { refusedByHarshNoBypassRule: true }
+    };
+  }
+  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
+      } : void 0
+    };
+  }
+  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
+    }
+  };
+}
+async function handleStatus() {
+  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
+    }
+  };
+}
+async function handleRequestPermission() {
+  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
+    }
+  };
+}
+function coerceString(value) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim();
+  }
+  return null;
+}
+function coerceBooleanFlag(value, fallback) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "yes", "1", "on"].includes(normalized)) return true;
+    if (["false", "no", "0", "off"].includes(normalized)) return false;
+  }
+  return fallback;
+}
+function formatLiveWebsiteBlockStatus(status) {
+  if (!status.available) {
+    return status.reason ?? "The live website blocker is unavailable on this machine.";
+  }
+  const permissionNote = status.reason ? ` ${status.reason}` : "";
+  if (!status.active) {
+    return `No live website block is active right now.${permissionNote}`;
+  }
+  const websites = status.websites.length > 0 ? formatWebsiteList(status.websites) : "an unknown website set";
+  return status.endsAt ? `A live website block is active for ${websites} until ${status.endsAt}.${permissionNote}` : `A live website block is active for ${websites} until you remove it.${permissionNote}`;
+}
+async function handleRelease(runtime, message, params) {
+  const ruleId = coerceString(params.ruleId);
+  if (!ruleId) {
+    return {
+      success: false,
+      text: "BLOCK action=release requires a ruleId."
+    };
+  }
+  const rule = await new BlockRuleReader(runtime).getBlockRuleById(ruleId);
+  if (rule?.gateType === "harsh_no_bypass") {
+    return {
+      success: false,
+      text: `Block rule ${ruleId} is harsh_no_bypass and cannot be released by confirmation \u2014 it must wait for gate fulfillment.`,
+      data: { actionName: ACTION_NAME, subaction: "release", ruleId }
+    };
+  }
+  const releasePrompt = `Release website block rule ${ruleId}?`;
+  const decision = await requireConfirmation({
+    runtime,
+    message,
+    actionName: "WEBSITE_BLOCK_RELEASE",
+    pendingKey: `release:${ruleId}`,
+    prompt: releasePrompt
+  });
+  if (decision.status !== "confirmed") {
+    return {
+      success: decision.status === "pending",
+      text: decision.status === "pending" ? `${releasePrompt} Reply yes to confirm or no to cancel.` : "Release cancelled.",
+      data: {
+        requiresConfirmation: decision.status === "pending",
+        awaitingUserInput: decision.status === "pending",
+        ruleId
+      }
+    };
+  }
+  const reason = coerceString(params.reason) ?? "user_confirmed";
+  const writer = new BlockRuleWriter(runtime);
+  try {
+    await writer.releaseBlockRule(ruleId, { confirmed: true, reason });
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      text: `Failed to release block rule ${ruleId}: ${message2}`
+    };
+  }
+  return {
+    success: true,
+    text: `Released block rule ${ruleId}.`,
+    data: { ruleId, reason }
+  };
+}
+async function handleListActive(runtime, params) {
+  const includeLiveStatus = coerceBooleanFlag(params.includeLiveStatus, true);
+  const includeManagedRules = coerceBooleanFlag(
+    params.includeManagedRules,
+    true
+  );
+  const reader = new BlockRuleReader(runtime);
+  const [rules, liveStatus] = await Promise.all([
+    includeManagedRules ? reader.listActiveBlocks() : Promise.resolve([]),
+    includeLiveStatus ? getSelfControlStatus() : Promise.resolve(
+      null
+    )
+  ]);
+  const sections = liveStatus ? [formatLiveWebsiteBlockStatus(liveStatus)] : [];
+  if (!includeManagedRules) {
+    return {
+      success: true,
+      text: sections.join("\n") || "Managed block rule listing was not requested.",
+      data: {
+        actionName: ACTION_NAME,
+        rules: [],
+        liveStatus
+      }
+    };
+  }
+  if (rules.length === 0) {
+    sections.push("No managed website block rules are active.");
+    return {
+      success: true,
+      text: sections.join("\n"),
+      data: { actionName: ACTION_NAME, rules: [], liveStatus }
+    };
+  }
+  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(" ");
+  });
+  sections.push(`Managed block rules:
+${summaries.join("\n")}`);
+  return {
+    success: true,
+    text: sections.join("\n"),
+    data: { actionName: ACTION_NAME, rules, liveStatus }
+  };
+}
+async function websiteBlockValidate(runtime, message) {
+  const access = await getSelfControlAccess(runtime, message);
+  return access.allowed;
+}
+async function runWebsiteBlockHandler(runtime, message, state, options) {
+  const access = await getSelfControlAccess(runtime, message);
+  if (!access.allowed) {
+    return {
+      success: false,
+      text: access.reason ?? SELFCONTROL_ACCESS_ERROR
+    };
+  }
+  const resolved = await resolveActionArgs({
+    runtime,
+    message,
+    state,
+    options,
+    actionName: ACTION_NAME,
+    subactions: SUBACTIONS
+  });
+  if (!resolved.ok) {
+    return {
+      success: false,
+      text: resolved.clarification,
+      data: { actionName: ACTION_NAME, missing: resolved.missing }
+    };
+  }
+  const { subaction, params } = resolved;
+  switch (subaction) {
+    case "block":
+      return handleBlock(runtime, message, state, params);
+    case "unblock":
+      return handleUnblock(runtime);
+    case "status":
+      return handleStatus();
+    case "request_permission":
+      return handleRequestPermission();
+    case "release":
+      return handleRelease(runtime, message, params);
+    case "list_active":
+      return handleListActive(runtime, params);
+  }
+}
+export {
+  runWebsiteBlockHandler,
+  websiteBlockValidate
+};
+//# sourceMappingURL=website-block.js.map