@kodelyth/tlon 2026.5.42 → 2026.6.2

package/src/monitor/approval-runtime.ts

@@ -1,363 +0,0 @@
-import type { RuntimeEnv } from "klaw/plugin-sdk/runtime";
-import type { PendingApproval, TlonSettingsStore } from "../settings.js";
-import { normalizeShip } from "../targets.js";
-import { sendDm } from "../urbit/send.js";
-import type { UrbitSSEClient } from "../urbit/sse-client.js";
-import {
-  findPendingApproval,
-  formatApprovalConfirmation,
-  formatApprovalRequest,
-  formatBlockedList,
-  formatPendingList,
-  parseAdminCommand,
-  parseApprovalResponse,
-  removePendingApproval,
-} from "./approval.js";
-
-type TlonApprovalApi = Pick<UrbitSSEClient, "poke" | "scry">;
-
-type ApprovedMessageProcessor = (approval: PendingApproval) => Promise<void>;
-
-export function createTlonApprovalRuntime(params: {
-  api: TlonApprovalApi;
-  runtime: RuntimeEnv;
-  botShipName: string;
-  getPendingApprovals: () => PendingApproval[];
-  setPendingApprovals: (approvals: PendingApproval[]) => void;
-  getCurrentSettings: () => TlonSettingsStore;
-  setCurrentSettings: (settings: TlonSettingsStore) => void;
-  getEffectiveDmAllowlist: () => string[];
-  setEffectiveDmAllowlist: (ships: string[]) => void;
-  getEffectiveOwnerShip: () => string | null;
-  processApprovedMessage: ApprovedMessageProcessor;
-  refreshWatchedChannels: () => Promise<number>;
-}) {
-  const {
-    api,
-    runtime,
-    botShipName,
-    getPendingApprovals,
-    setPendingApprovals,
-    getCurrentSettings,
-    setCurrentSettings,
-    getEffectiveDmAllowlist,
-    setEffectiveDmAllowlist,
-    getEffectiveOwnerShip,
-    processApprovedMessage,
-    refreshWatchedChannels,
-  } = params;
-
-  const savePendingApprovals = async (): Promise<void> => {
-    try {
-      await api.poke({
-        app: "settings",
-        mark: "settings-event",
-        json: {
-          "put-entry": {
-            desk: "moltbot",
-            "bucket-key": "tlon",
-            "entry-key": "pendingApprovals",
-            value: JSON.stringify(getPendingApprovals()),
-          },
-        },
-      });
-    } catch (err) {
-      runtime.error?.(`[tlon] Failed to save pending approvals: ${String(err)}`);
-    }
-  };
-
-  const addToDmAllowlist = async (ship: string): Promise<void> => {
-    const normalizedShip = normalizeShip(ship);
-    const nextAllowlist = getEffectiveDmAllowlist().includes(normalizedShip)
-      ? getEffectiveDmAllowlist()
-      : [...getEffectiveDmAllowlist(), normalizedShip];
-    setEffectiveDmAllowlist(nextAllowlist);
-    try {
-      await api.poke({
-        app: "settings",
-        mark: "settings-event",
-        json: {
-          "put-entry": {
-            desk: "moltbot",
-            "bucket-key": "tlon",
-            "entry-key": "dmAllowlist",
-            value: nextAllowlist,
-          },
-        },
-      });
-      runtime.log?.(`[tlon] Added ${normalizedShip} to dmAllowlist`);
-    } catch (err) {
-      runtime.error?.(`[tlon] Failed to update dmAllowlist: ${String(err)}`);
-    }
-  };
-
-  const addToChannelAllowlist = async (ship: string, channelNest: string): Promise<void> => {
-    const normalizedShip = normalizeShip(ship);
-    const currentSettings = getCurrentSettings();
-    const channelRules = currentSettings.channelRules ?? {};
-    const rule = channelRules[channelNest] ?? { mode: "restricted", allowedShips: [] };
-    const allowedShips = [...(rule.allowedShips ?? [])];
-
-    if (!allowedShips.includes(normalizedShip)) {
-      allowedShips.push(normalizedShip);
-    }
-
-    const updatedRules = {
-      ...channelRules,
-      [channelNest]: { ...rule, allowedShips },
-    };
-    setCurrentSettings({ ...currentSettings, channelRules: updatedRules });
-
-    try {
-      await api.poke({
-        app: "settings",
-        mark: "settings-event",
-        json: {
-          "put-entry": {
-            desk: "moltbot",
-            "bucket-key": "tlon",
-            "entry-key": "channelRules",
-            value: JSON.stringify(updatedRules),
-          },
-        },
-      });
-      runtime.log?.(`[tlon] Added ${normalizedShip} to ${channelNest} allowlist`);
-    } catch (err) {
-      runtime.error?.(`[tlon] Failed to update channelRules: ${String(err)}`);
-    }
-  };
-
-  const blockShip = async (ship: string): Promise<void> => {
-    const normalizedShip = normalizeShip(ship);
-    try {
-      await api.poke({
-        app: "chat",
-        mark: "chat-block-ship",
-        json: { ship: normalizedShip },
-      });
-      runtime.log?.(`[tlon] Blocked ship ${normalizedShip}`);
-    } catch (err) {
-      runtime.error?.(`[tlon] Failed to block ship ${normalizedShip}: ${String(err)}`);
-    }
-  };
-
-  const isShipBlocked = async (ship: string): Promise<boolean> => {
-    const normalizedShip = normalizeShip(ship);
-    try {
-      const blocked = (await api.scry("/chat/blocked.json")) as string[] | undefined;
-      return (
-        Array.isArray(blocked) && blocked.some((item) => normalizeShip(item) === normalizedShip)
-      );
-    } catch (err) {
-      runtime.log?.(`[tlon] Failed to check blocked list: ${String(err)}`);
-      return false;
-    }
-  };
-
-  const getBlockedShips = async (): Promise<string[]> => {
-    try {
-      const blocked = (await api.scry("/chat/blocked.json")) as string[] | undefined;
-      return Array.isArray(blocked) ? blocked : [];
-    } catch (err) {
-      runtime.log?.(`[tlon] Failed to get blocked list: ${String(err)}`);
-      return [];
-    }
-  };
-
-  const unblockShip = async (ship: string): Promise<boolean> => {
-    const normalizedShip = normalizeShip(ship);
-    try {
-      await api.poke({
-        app: "chat",
-        mark: "chat-unblock-ship",
-        json: { ship: normalizedShip },
-      });
-      runtime.log?.(`[tlon] Unblocked ship ${normalizedShip}`);
-      return true;
-    } catch (err) {
-      runtime.error?.(`[tlon] Failed to unblock ship ${normalizedShip}: ${String(err)}`);
-      return false;
-    }
-  };
-
-  const sendOwnerNotification = async (message: string): Promise<void> => {
-    const ownerShip = getEffectiveOwnerShip();
-    if (!ownerShip) {
-      runtime.log?.("[tlon] No ownerShip configured, cannot send notification");
-      return;
-    }
-    try {
-      await sendDm({
-        api,
-        fromShip: botShipName,
-        toShip: ownerShip,
-        text: message,
-      });
-      runtime.log?.(`[tlon] Sent notification to owner ${ownerShip}`);
-    } catch (err) {
-      runtime.error?.(`[tlon] Failed to send notification to owner: ${String(err)}`);
-    }
-  };
-
-  const queueApprovalRequest = async (approval: PendingApproval): Promise<void> => {
-    if (await isShipBlocked(approval.requestingShip)) {
-      runtime.log?.(`[tlon] Ignoring request from blocked ship ${approval.requestingShip}`);
-      return;
-    }
-
-    const approvals = getPendingApprovals();
-    const existingIndex = approvals.findIndex(
-      (item) =>
-        item.type === approval.type &&
-        item.requestingShip === approval.requestingShip &&
-        (approval.type !== "channel" || item.channelNest === approval.channelNest) &&
-        (approval.type !== "group" || item.groupFlag === approval.groupFlag),
-    );
-
-    if (existingIndex !== -1) {
-      const existing = approvals[existingIndex];
-      if (approval.originalMessage) {
-        existing.originalMessage = approval.originalMessage;
-        existing.messagePreview = approval.messagePreview;
-      }
-      runtime.log?.(
-        `[tlon] Updated existing approval for ${approval.requestingShip} (${approval.type}) - re-sending notification`,
-      );
-      await savePendingApprovals();
-      await sendOwnerNotification(formatApprovalRequest(existing));
-      return;
-    }
-
-    setPendingApprovals([...approvals, approval]);
-    await savePendingApprovals();
-    await sendOwnerNotification(formatApprovalRequest(approval));
-    runtime.log?.(
-      `[tlon] Queued approval request: ${approval.id} (${approval.type} from ${approval.requestingShip})`,
-    );
-  };
-
-  const handleApprovalResponse = async (text: string): Promise<boolean> => {
-    const parsed = parseApprovalResponse(text);
-    if (!parsed) {
-      return false;
-    }
-
-    const approval = findPendingApproval(getPendingApprovals(), parsed.id);
-    if (!approval) {
-      await sendOwnerNotification(
-        `No pending approval found${parsed.id ? ` for ID: ${parsed.id}` : ""}`,
-      );
-      return true;
-    }
-
-    if (parsed.action === "approve") {
-      switch (approval.type) {
-        case "dm":
-          await addToDmAllowlist(approval.requestingShip);
-          if (approval.originalMessage) {
-            runtime.log?.(
-              `[tlon] Processing original message from ${approval.requestingShip} after approval`,
-            );
-            await processApprovedMessage(approval);
-          }
-          break;
-        case "channel":
-          if (approval.channelNest) {
-            await addToChannelAllowlist(approval.requestingShip, approval.channelNest);
-            if (approval.originalMessage) {
-              runtime.log?.(
-                `[tlon] Processing original message from ${approval.requestingShip} in ${approval.channelNest} after approval`,
-              );
-              await processApprovedMessage(approval);
-            }
-          }
-          break;
-        case "group":
-          if (approval.groupFlag) {
-            try {
-              await api.poke({
-                app: "groups",
-                mark: "group-join",
-                json: {
-                  flag: approval.groupFlag,
-                  "join-all": true,
-                },
-              });
-              runtime.log?.(`[tlon] Joined group ${approval.groupFlag} after approval`);
-              setTimeout(() => {
-                void (async () => {
-                  try {
-                    const newCount = await refreshWatchedChannels();
-                    if (newCount > 0) {
-                      runtime.log?.(
-                        `[tlon] Discovered ${newCount} new channel(s) after joining group`,
-                      );
-                    }
-                  } catch (err) {
-                    runtime.log?.(
-                      `[tlon] Channel discovery after group join failed: ${String(err)}`,
-                    );
-                  }
-                })();
-              }, 2000);
-            } catch (err) {
-              runtime.error?.(`[tlon] Failed to join group ${approval.groupFlag}: ${String(err)}`);
-            }
-          }
-          break;
-      }
-
-      await sendOwnerNotification(formatApprovalConfirmation(approval, "approve"));
-    } else if (parsed.action === "block") {
-      await blockShip(approval.requestingShip);
-      await sendOwnerNotification(formatApprovalConfirmation(approval, "block"));
-    } else {
-      await sendOwnerNotification(formatApprovalConfirmation(approval, "deny"));
-    }
-
-    setPendingApprovals(removePendingApproval(getPendingApprovals(), approval.id));
-    await savePendingApprovals();
-    return true;
-  };
-
-  const handleAdminCommand = async (text: string): Promise<boolean> => {
-    const command = parseAdminCommand(text);
-    if (!command) {
-      return false;
-    }
-
-    switch (command.type) {
-      case "blocked": {
-        const blockedShips = await getBlockedShips();
-        await sendOwnerNotification(formatBlockedList(blockedShips));
-        runtime.log?.(`[tlon] Owner requested blocked ships list (${blockedShips.length} ships)`);
-        return true;
-      }
-      case "pending":
-        await sendOwnerNotification(formatPendingList(getPendingApprovals()));
-        runtime.log?.(
-          `[tlon] Owner requested pending approvals list (${getPendingApprovals().length} pending)`,
-        );
-        return true;
-      case "unblock": {
-        const shipToUnblock = command.ship;
-        if (!(await isShipBlocked(shipToUnblock))) {
-          await sendOwnerNotification(`${shipToUnblock} is not blocked.`);
-          return true;
-        }
-        const success = await unblockShip(shipToUnblock);
-        await sendOwnerNotification(
-          success ? `Unblocked ${shipToUnblock}.` : `Failed to unblock ${shipToUnblock}.`,
-        );
-        return true;
-      }
-    }
-    throw new Error("Unsupported Tlon admin command");
-  };
-
-  return {
-    queueApprovalRequest,
-    handleApprovalResponse,
-    handleAdminCommand,
-  };
-}

package/src/monitor/approval.test.ts

@@ -1,33 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-const cryptoMocks = vi.hoisted(() => ({
-  randomBytes: vi.fn(),
-}));
-
-vi.mock("node:crypto", () => ({
-  randomBytes: cryptoMocks.randomBytes,
-}));
-
-let generateApprovalId: typeof import("./approval.js").generateApprovalId;
-
-beforeAll(async () => {
-  ({ generateApprovalId } = await import("./approval.js"));
-});
-
-beforeEach(() => {
-  cryptoMocks.randomBytes.mockReset();
-});
-
-describe("generateApprovalId", () => {
-  it("uses secure hex entropy while preserving the ID format", () => {
-    cryptoMocks.randomBytes.mockReturnValueOnce(Buffer.from("a1b2c3", "hex"));
-    const nowSpy = vi.spyOn(Date, "now").mockReturnValue(1_717_171_717_171);
-
-    try {
-      expect(generateApprovalId("dm")).toBe("dm-1717171717171-a1b2c3");
-      expect(cryptoMocks.randomBytes).toHaveBeenCalledWith(3);
-    } finally {
-      nowSpy.mockRestore();
-    }
-  });
-});

package/src/monitor/approval.ts

@@ -1,283 +0,0 @@
-/**
- * Approval system for managing DM, channel mention, and group invite approvals.
- *
- * When an unknown ship tries to interact with the bot, the owner receives
- * a notification and can approve or deny the request.
- */
-
-// Extensions cannot import core internals directly, so use node:crypto here.
-import { randomBytes } from "node:crypto";
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-import type { PendingApproval } from "../settings.js";
-
-export type { PendingApproval };
-
-export type ApprovalType = "dm" | "channel" | "group";
-
-export type CreateApprovalParams = {
-  type: ApprovalType;
-  requestingShip: string;
-  channelNest?: string;
-  groupFlag?: string;
-  messagePreview?: string;
-  originalMessage?: {
-    messageId: string;
-    messageText: string;
-    messageContent: unknown;
-    timestamp: number;
-    parentId?: string;
-    isThreadReply?: boolean;
-  };
-};
-
-/**
- * Generate a unique approval ID in the format: {type}-{timestamp}-{shortHash}
- */
-export function generateApprovalId(type: ApprovalType): string {
-  const timestamp = Date.now();
-  const randomPart = randomBytes(3).toString("hex");
-  return `${type}-${timestamp}-${randomPart}`;
-}
-
-/**
- * Create a pending approval object.
- */
-export function createPendingApproval(params: CreateApprovalParams): PendingApproval {
-  return {
-    id: generateApprovalId(params.type),
-    type: params.type,
-    requestingShip: params.requestingShip,
-    channelNest: params.channelNest,
-    groupFlag: params.groupFlag,
-    messagePreview: params.messagePreview,
-    originalMessage: params.originalMessage,
-    timestamp: Date.now(),
-  };
-}
-
-/**
- * Truncate text to a maximum length with ellipsis.
- */
-function truncate(text: string, maxLength: number): string {
-  if (text.length <= maxLength) {
-    return text;
-  }
-  return text.slice(0, maxLength - 3) + "...";
-}
-
-/**
- * Format a notification message for the owner about a pending approval.
- */
-export function formatApprovalRequest(approval: PendingApproval): string {
-  const preview = approval.messagePreview ? `\n"${truncate(approval.messagePreview, 100)}"` : "";
-
-  switch (approval.type) {
-    case "dm":
-      return (
-        `New DM request from ${approval.requestingShip}:${preview}\n\n` +
-        `Reply "approve", "deny", or "block" (ID: ${approval.id})`
-      );
-
-    case "channel":
-      return (
-        `${approval.requestingShip} mentioned you in ${approval.channelNest}:${preview}\n\n` +
-        `Reply "approve", "deny", or "block"\n` +
-        `(ID: ${approval.id})`
-      );
-
-    case "group":
-      return (
-        `Group invite from ${approval.requestingShip} to join ${approval.groupFlag}\n\n` +
-        `Reply "approve", "deny", or "block"\n` +
-        `(ID: ${approval.id})`
-      );
-  }
-  throw new Error("Unsupported approval type");
-}
-
-export type ApprovalResponse = {
-  action: "approve" | "deny" | "block";
-  id?: string;
-};
-
-/**
- * Parse an owner's response to an approval request.
- * Supports formats:
- *   - "approve" / "deny" / "block" (applies to most recent pending)
- *   - "approve dm-1234567890-abc" / "deny dm-1234567890-abc" (specific ID)
- *   - "block" permanently blocks the ship via Tlon's native blocking
- */
-export function parseApprovalResponse(text: string): ApprovalResponse | null {
-  const trimmed = normalizeLowercaseStringOrEmpty(text);
-
-  // Match "approve", "deny", or "block" optionally followed by an ID
-  const match = trimmed.match(/^(approve|deny|block)(?:\s+(.+))?$/);
-  if (!match) {
-    return null;
-  }
-
-  const action = match[1] as "approve" | "deny" | "block";
-  const id = match[2]?.trim();
-
-  return { action, id };
-}
-
-/**
- * Check if a message text looks like an approval response.
- * Used to determine if we should intercept the message before normal processing.
- */
-export function isApprovalResponse(text: string): boolean {
-  const trimmed = normalizeLowercaseStringOrEmpty(text);
-  return trimmed.startsWith("approve") || trimmed.startsWith("deny") || trimmed.startsWith("block");
-}
-
-/**
- * Find a pending approval by ID, or return the most recent if no ID specified.
- */
-export function findPendingApproval(
-  pendingApprovals: PendingApproval[],
-  id?: string,
-): PendingApproval | undefined {
-  if (id) {
-    return pendingApprovals.find((a) => a.id === id);
-  }
-  // Return most recent
-  return pendingApprovals[pendingApprovals.length - 1];
-}
-
-/**
- * Check if there's already a pending approval for the same ship/channel/group combo.
- * Used to avoid sending duplicate notifications.
- */
-export function hasDuplicatePending(
-  pendingApprovals: PendingApproval[],
-  type: ApprovalType,
-  requestingShip: string,
-  channelNest?: string,
-  groupFlag?: string,
-): boolean {
-  return pendingApprovals.some((approval) => {
-    if (approval.type !== type || approval.requestingShip !== requestingShip) {
-      return false;
-    }
-    if (type === "channel" && approval.channelNest !== channelNest) {
-      return false;
-    }
-    if (type === "group" && approval.groupFlag !== groupFlag) {
-      return false;
-    }
-    return true;
-  });
-}
-
-/**
- * Remove a pending approval from the list by ID.
- */
-export function removePendingApproval(
-  pendingApprovals: PendingApproval[],
-  id: string,
-): PendingApproval[] {
-  return pendingApprovals.filter((a) => a.id !== id);
-}
-
-/**
- * Format a confirmation message after an approval action.
- */
-export function formatApprovalConfirmation(
-  approval: PendingApproval,
-  action: "approve" | "deny" | "block",
-): string {
-  if (action === "block") {
-    return `Blocked ${approval.requestingShip}. They will no longer be able to contact the bot.`;
-  }
-
-  const actionText = action === "approve" ? "Approved" : "Denied";
-
-  switch (approval.type) {
-    case "dm":
-      if (action === "approve") {
-        return `${actionText} DM access for ${approval.requestingShip}. They can now message the bot.`;
-      }
-      return `${actionText} DM request from ${approval.requestingShip}.`;
-
-    case "channel":
-      if (action === "approve") {
-        return `${actionText} ${approval.requestingShip} for ${approval.channelNest}. They can now interact in this channel.`;
-      }
-      return `${actionText} ${approval.requestingShip} for ${approval.channelNest}.`;
-
-    case "group":
-      if (action === "approve") {
-        return `${actionText} group invite from ${approval.requestingShip} to ${approval.groupFlag}. Joining group...`;
-      }
-      return `${actionText} group invite from ${approval.requestingShip} to ${approval.groupFlag}.`;
-  }
-  throw new Error("Unsupported approval type");
-}
-
-// ============================================================================
-// Admin Commands
-// ============================================================================
-
-export type AdminCommand =
-  | { type: "unblock"; ship: string }
-  | { type: "blocked" }
-  | { type: "pending" };
-
-/**
- * Parse an admin command from owner message.
- * Supports:
- *   - "unblock ~ship" - unblock a specific ship
- *   - "blocked" - list all blocked ships
- *   - "pending" - list all pending approvals
- */
-export function parseAdminCommand(text: string): AdminCommand | null {
-  const trimmed = normalizeLowercaseStringOrEmpty(text);
-
-  // "blocked" - list blocked ships
-  if (trimmed === "blocked") {
-    return { type: "blocked" };
-  }
-
-  // "pending" - list pending approvals
-  if (trimmed === "pending") {
-    return { type: "pending" };
-  }
-
-  // "unblock ~ship" - unblock a specific ship
-  const unblockMatch = trimmed.match(/^unblock\s+(~[\w-]+)$/);
-  if (unblockMatch) {
-    return { type: "unblock", ship: unblockMatch[1] };
-  }
-
-  return null;
-}
-
-/**
- * Check if a message text looks like an admin command.
- */
-export function isAdminCommand(text: string): boolean {
-  return parseAdminCommand(text) !== null;
-}
-
-/**
- * Format the list of blocked ships for display to owner.
- */
-export function formatBlockedList(ships: string[]): string {
-  if (ships.length === 0) {
-    return "No ships are currently blocked.";
-  }
-  return `Blocked ships (${ships.length}):\n${ships.map((s) => `• ${s}`).join("\n")}`;
-}
-
-/**
- * Format the list of pending approvals for display to owner.
- */
-export function formatPendingList(approvals: PendingApproval[]): string {
-  if (approvals.length === 0) {
-    return "No pending approval requests.";
-  }
-  return `Pending approvals (${approvals.length}):\n${approvals
-    .map((a) => `• ${a.id}: ${a.type} from ${a.requestingShip}`)
-    .join("\n")}`;
-}

package/src/monitor/authorization.ts

@@ -1,30 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import type { TlonSettingsStore } from "../settings.js";
-
-type ChannelAuthorization = {
-  mode?: "restricted" | "open";
-  allowedShips?: string[];
-};
-
-export function resolveChannelAuthorization(
-  cfg: KlawConfig,
-  channelNest: string,
-  settings?: TlonSettingsStore,
-): { mode: "restricted" | "open"; allowedShips: string[] } {
-  const tlonConfig = cfg.channels?.tlon as
-    | {
-        authorization?: { channelRules?: Record<string, ChannelAuthorization> };
-        defaultAuthorizedShips?: string[];
-      }
-    | undefined;
-
-  const fileRules = tlonConfig?.authorization?.channelRules ?? {};
-  const settingsRules = settings?.channelRules ?? {};
-  const rule = settingsRules[channelNest] ?? fileRules[channelNest];
-  const defaultShips = settings?.defaultAuthorizedShips ?? tlonConfig?.defaultAuthorizedShips ?? [];
-
-  return {
-    mode: rule?.mode ?? "restricted",
-    allowedShips: rule?.allowedShips ?? defaultShips,
-  };
-}