@kodelyth/tlon 2026.5.42 → 2026.6.2

package/src/monitor/media.test.ts

@@ -1,80 +0,0 @@
-import {
-  readRemoteMediaBuffer,
-  MAX_IMAGE_BYTES,
-  saveRemoteMedia,
-} from "klaw/plugin-sdk/media-runtime";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { downloadMedia, extractImageBlocks } from "./media.js";
-
-vi.mock("klaw/plugin-sdk/media-runtime", () => ({
-  MAX_IMAGE_BYTES: 6 * 1024 * 1024,
-  readRemoteMediaBuffer: vi.fn(),
-  saveRemoteMedia: vi.fn(),
-}));
-
-const readRemoteMediaBufferMock = vi.mocked(readRemoteMediaBuffer);
-const saveRemoteMediaMock = vi.mocked(saveRemoteMedia);
-
-describe("tlon monitor media", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(console, "error").mockImplementation(() => undefined);
-    vi.spyOn(console, "warn").mockImplementation(() => undefined);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("caps extracted images at eight per message", () => {
-    const content = Array.from({ length: 10 }, (_, index) => ({
-      block: { image: { src: `https://example.com/${index}.png`, alt: `image-${index}` } },
-    }));
-
-    const images = extractImageBlocks(content);
-
-    expect(images).toHaveLength(8);
-    expect(images.map((image) => image.url)).toEqual(
-      Array.from({ length: 8 }, (_, index) => `https://example.com/${index}.png`),
-    );
-  });
-
-  it("stores fetched media through the shared inbound media store with the image cap", async () => {
-    saveRemoteMediaMock.mockResolvedValue({
-      id: "photo---uuid.png",
-      path: "/tmp/klaw/media/inbound/photo---uuid.png",
-      size: "image-data".length,
-      contentType: "image/png",
-    });
-
-    const result = await downloadMedia("https://example.com/photo.png");
-
-    expect(readRemoteMediaBufferMock).not.toHaveBeenCalled();
-    expect(saveRemoteMediaMock).toHaveBeenCalledTimes(1);
-    expect(saveRemoteMediaMock).toHaveBeenCalledWith({
-      url: "https://example.com/photo.png",
-      maxBytes: MAX_IMAGE_BYTES,
-      readIdleTimeoutMs: 30_000,
-      ssrfPolicy: undefined,
-      requestInit: { method: "GET" },
-    });
-    expect(result).toEqual({
-      localPath: "/tmp/klaw/media/inbound/photo---uuid.png",
-      contentType: "image/png",
-      originalUrl: "https://example.com/photo.png",
-    });
-  });
-
-  it("returns null when the fetch exceeds the image cap", async () => {
-    saveRemoteMediaMock.mockRejectedValue(
-      new Error(
-        `Failed to fetch media from https://example.com/photo.png: payload exceeds maxBytes ${MAX_IMAGE_BYTES}`,
-      ),
-    );
-
-    const result = await downloadMedia("https://example.com/photo.png");
-
-    expect(result).toBeNull();
-    expect(readRemoteMediaBufferMock).not.toHaveBeenCalled();
-  });
-});

package/src/monitor/media.ts

@@ -1,156 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
-import * as path from "node:path";
-import { formatErrorMessage } from "klaw/plugin-sdk/error-runtime";
-import { extensionForMime } from "klaw/plugin-sdk/media-mime";
-import {
-  readRemoteMediaBuffer,
-  MAX_IMAGE_BYTES,
-  saveRemoteMedia,
-} from "klaw/plugin-sdk/media-runtime";
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-import { getDefaultSsrFPolicy } from "../urbit/context.js";
-
-const MAX_IMAGES_PER_MESSAGE = 8;
-const TLON_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS = 30_000;
-
-interface ExtractedImage {
-  url: string;
-  alt?: string;
-}
-
-interface DownloadedMedia {
-  localPath: string;
-  contentType: string;
-  originalUrl: string;
-}
-
-/**
- * Extract image blocks from Tlon message content.
- * Returns array of image URLs found in the message.
- */
-export function extractImageBlocks(content: unknown): ExtractedImage[] {
-  if (!content || !Array.isArray(content)) {
-    return [];
-  }
-
-  const images: ExtractedImage[] = [];
-
-  for (const verse of content) {
-    if (verse?.block?.image?.src) {
-      images.push({
-        url: verse.block.image.src,
-        alt: verse.block.image.alt,
-      });
-      if (images.length >= MAX_IMAGES_PER_MESSAGE) {
-        break;
-      }
-    }
-  }
-
-  return images;
-}
-
-/**
- * Download a media file from URL to local storage.
- * Returns the local path where the file was saved.
- */
-export async function downloadMedia(
-  url: string,
-  mediaDir?: string,
-): Promise<DownloadedMedia | null> {
-  try {
-    // Validate URL is http/https before fetching
-    const parsedUrl = new URL(url);
-    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-      console.warn(`[tlon-media] Rejected non-http(s) URL: ${url}`);
-      return null;
-    }
-
-    const fetchOptions = {
-      url,
-      maxBytes: MAX_IMAGE_BYTES,
-      readIdleTimeoutMs: TLON_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS,
-      ssrfPolicy: getDefaultSsrFPolicy(),
-      requestInit: { method: "GET" },
-    };
-
-    if (!mediaDir) {
-      const saved = await saveRemoteMedia(fetchOptions);
-      return {
-        localPath: saved.path,
-        contentType: saved.contentType ?? "application/octet-stream",
-        originalUrl: url,
-      };
-    }
-
-    const fetched = await readRemoteMediaBuffer(fetchOptions);
-    await mkdir(mediaDir, { recursive: true });
-    const ext =
-      getExtensionFromFileName(fetched.fileName) ||
-      getExtensionFromContentType(fetched.contentType ?? "") ||
-      getExtensionFromUrl(url) ||
-      "bin";
-    const localPath = path.join(mediaDir, `${randomUUID()}.${ext}`);
-    await writeFile(localPath, fetched.buffer);
-
-    return {
-      localPath,
-      contentType: fetched.contentType ?? "application/octet-stream",
-      originalUrl: url,
-    };
-  } catch (error: unknown) {
-    console.error(`[tlon-media] Error downloading ${url}: ${formatErrorMessage(error)}`);
-    return null;
-  }
-}
-
-function getExtensionFromFileName(fileName?: string): string | null {
-  if (!fileName) {
-    return null;
-  }
-  const ext = path.extname(fileName).replace(/^\./, "");
-  return ext || null;
-}
-
-function getExtensionFromContentType(contentType: string): string | null {
-  return extensionForMime(contentType)?.replace(/^\./u, "") ?? null;
-}
-
-function getExtensionFromUrl(url: string): string | null {
-  try {
-    const pathname = new URL(url).pathname;
-    const match = pathname.match(/\.([a-z0-9]+)$/i);
-    return match ? normalizeLowercaseStringOrEmpty(match[1]) : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Download all images from a message and return attachment metadata.
- * Format matches Klaw's expected attachment structure.
- */
-export async function downloadMessageImages(
-  content: unknown,
-  mediaDir?: string,
-): Promise<Array<{ path: string; contentType: string }>> {
-  const images = extractImageBlocks(content);
-  if (images.length === 0) {
-    return [];
-  }
-
-  const attachments: Array<{ path: string; contentType: string }> = [];
-
-  for (const image of images) {
-    const downloaded = await downloadMedia(image.url, mediaDir);
-    if (downloaded) {
-      attachments.push({
-        path: downloaded.localPath,
-        contentType: downloaded.contentType,
-      });
-    }
-  }
-
-  return attachments;
-}

package/src/monitor/processed-messages.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  createProcessedMessageTracker,
-  runWithProcessedMessageClaim,
-} from "./processed-messages.js";
-
-describe("createProcessedMessageTracker", () => {
-  it("dedupes and evicts oldest entries", () => {
-    const tracker = createProcessedMessageTracker(3);
-
-    expect(tracker.mark("a")).toBe(true);
-    expect(tracker.mark("a")).toBe(false);
-    expect(tracker.has("a")).toBe(true);
-
-    tracker.mark("b");
-    tracker.mark("c");
-    expect(tracker.size()).toBe(3);
-
-    tracker.mark("d");
-    expect(tracker.size()).toBe(3);
-    expect(tracker.has("a")).toBe(false);
-    expect(tracker.has("b")).toBe(true);
-    expect(tracker.has("c")).toBe(true);
-    expect(tracker.has("d")).toBe(true);
-  });
-
-  it("releases failed claims so retries can run again", async () => {
-    const tracker = createProcessedMessageTracker();
-
-    await expect(
-      runWithProcessedMessageClaim({
-        tracker,
-        id: "evt-1",
-        task: async () => {
-          throw new Error("boom");
-        },
-      }),
-    ).rejects.toThrow("boom");
-
-    expect(tracker.has("evt-1")).toBe(false);
-    expect(tracker.claim("evt-1")).toEqual({ kind: "claimed" });
-  });
-
-  it("keeps successful claims deduped", async () => {
-    const tracker = createProcessedMessageTracker();
-
-    await expect(
-      runWithProcessedMessageClaim({
-        tracker,
-        id: "evt-2",
-        task: async () => undefined,
-      }),
-    ).resolves.toEqual({ kind: "processed", value: undefined });
-
-    expect(tracker.has("evt-2")).toBe(true);
-    expect(tracker.claim("evt-2")).toEqual({ kind: "duplicate" });
-  });
-});

package/src/monitor/processed-messages.ts

@@ -1,89 +0,0 @@
-import { createDedupeCache } from "../../runtime-api.js";
-
-type ProcessedMessageTracker = {
-  claim: (id?: string | null) => { kind: "claimed" } | { kind: "duplicate" };
-  commit: (id?: string | null) => void;
-  release: (id?: string | null) => void;
-  mark: (id?: string | null) => boolean;
-  has: (id?: string | null) => boolean;
-  size: () => number;
-};
-
-export function createProcessedMessageTracker(limit = 2000): ProcessedMessageTracker {
-  const dedupe = createDedupeCache({ ttlMs: 0, maxSize: limit });
-  const inFlight = new Set<string>();
-
-  const claim = (id?: string | null) => {
-    const trimmed = id?.trim();
-    if (!trimmed) {
-      return { kind: "claimed" } as const;
-    }
-    if (inFlight.has(trimmed) || dedupe.peek(trimmed)) {
-      return { kind: "duplicate" } as const;
-    }
-    inFlight.add(trimmed);
-    return { kind: "claimed" } as const;
-  };
-
-  const commit = (id?: string | null) => {
-    const trimmed = id?.trim();
-    if (!trimmed) {
-      return;
-    }
-    inFlight.delete(trimmed);
-    dedupe.check(trimmed);
-  };
-
-  const release = (id?: string | null) => {
-    const trimmed = id?.trim();
-    if (!trimmed) {
-      return;
-    }
-    inFlight.delete(trimmed);
-  };
-
-  const mark = (id?: string | null) => {
-    const claimed = claim(id);
-    if (claimed.kind === "duplicate") {
-      return false;
-    }
-    commit(id);
-    return true;
-  };
-
-  const has = (id?: string | null) => {
-    const trimmed = id?.trim();
-    if (!trimmed) {
-      return false;
-    }
-    return dedupe.peek(trimmed);
-  };
-
-  return {
-    claim,
-    commit,
-    release,
-    mark,
-    has,
-    size: () => dedupe.size(),
-  };
-}
-
-export async function runWithProcessedMessageClaim<T>(params: {
-  tracker: ProcessedMessageTracker;
-  id?: string | null;
-  task: () => Promise<T>;
-}): Promise<{ kind: "processed"; value: T } | { kind: "duplicate" }> {
-  const claim = params.tracker.claim(params.id);
-  if (claim.kind === "duplicate") {
-    return claim;
-  }
-  try {
-    const value = await params.task();
-    params.tracker.commit(params.id);
-    return { kind: "processed", value };
-  } catch (error) {
-    params.tracker.release(params.id);
-    throw error;
-  }
-}

package/src/monitor/settings-helpers.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { TlonResolvedAccount } from "../types.js";
-import {
-  applyTlonSettingsOverrides,
-  buildTlonSettingsMigrations,
-  shouldMigrateTlonSetting,
-} from "./settings-helpers.js";
-
-const baseAccount: TlonResolvedAccount = {
-  accountId: "default",
-  name: "Tlon",
-  enabled: true,
-  configured: true,
-  ship: "~sampel-palnet",
-  url: "https://example.com",
-  code: "lidlut-tabwed-pillex-ridrup",
-  dangerouslyAllowPrivateNetwork: false,
-  groupChannels: ["chat/~host/general"],
-  dmAllowlist: ["~zod"],
-  groupInviteAllowlist: ["~bus"],
-  autoDiscoverChannels: true,
-  showModelSignature: false,
-  autoAcceptDmInvites: true,
-  autoAcceptGroupInvites: true,
-  defaultAuthorizedShips: ["~nec"],
-  ownerShip: "~marzod",
-};
-
-function allowlistMigrationDecisions(currentSettings: Record<string, unknown>) {
-  const allowlistKeys = new Set(["dmAllowlist", "groupInviteAllowlist", "defaultAuthorizedShips"]);
-  return Object.fromEntries(
-    buildTlonSettingsMigrations(baseAccount, currentSettings)
-      .filter((migration) => allowlistKeys.has(migration.key))
-      .map((migration) => [
-        migration.key,
-        shouldMigrateTlonSetting(migration.fileValue, migration.settingsValue),
-      ]),
-  );
-}
-
-describe("shouldMigrateTlonSetting", () => {
-  it("does not rehydrate explicit empty-array revocations during startup migration", () => {
-    const decisions = allowlistMigrationDecisions({
-      dmAllowlist: [],
-      groupInviteAllowlist: [],
-      defaultAuthorizedShips: [],
-    });
-
-    expect(decisions).toEqual({
-      dmAllowlist: false,
-      groupInviteAllowlist: false,
-      defaultAuthorizedShips: false,
-    });
-  });
-
-  it("still seeds file-config allowlists on first run when settings are missing", () => {
-    const decisions = allowlistMigrationDecisions({});
-
-    expect(decisions).toEqual({
-      dmAllowlist: true,
-      groupInviteAllowlist: true,
-      defaultAuthorizedShips: true,
-    });
-  });
-});
-
-describe("applyTlonSettingsOverrides", () => {
-  it("treats explicit empty settings allowlists as authoritative deny-all", () => {
-    const result = applyTlonSettingsOverrides({
-      account: baseAccount,
-      currentSettings: {
-        dmAllowlist: [],
-        groupInviteAllowlist: [],
-      },
-    });
-
-    expect(result.effectiveDmAllowlist).toStrictEqual([]);
-    expect(result.effectiveGroupInviteAllowlist).toStrictEqual([]);
-  });
-
-  it("falls back to file config when settings fields are removed", () => {
-    const result = applyTlonSettingsOverrides({
-      account: baseAccount,
-      currentSettings: {},
-    });
-
-    expect(result.effectiveDmAllowlist).toEqual(baseAccount.dmAllowlist);
-    expect(result.effectiveGroupInviteAllowlist).toEqual(baseAccount.groupInviteAllowlist);
-    expect(result.effectiveAutoDiscoverChannels).toBe(baseAccount.autoDiscoverChannels);
-    expect(result.effectiveOwnerShip).toBe(baseAccount.ownerShip);
-  });
-
-  it("keeps other explicit settings overrides authoritative", () => {
-    const result = applyTlonSettingsOverrides({
-      account: baseAccount,
-      currentSettings: {
-        autoDiscoverChannels: false,
-        autoAcceptDmInvites: false,
-        autoAcceptGroupInvites: false,
-        showModelSig: true,
-        ownerShip: "~nec",
-        pendingApprovals: [],
-      },
-    });
-
-    expect(result.effectiveAutoDiscoverChannels).toBe(false);
-    expect(result.effectiveAutoAcceptDmInvites).toBe(false);
-    expect(result.effectiveAutoAcceptGroupInvites).toBe(false);
-    expect(result.effectiveShowModelSig).toBe(true);
-    expect(result.effectiveOwnerShip).toBe("~nec");
-    expect(result.pendingApprovals).toStrictEqual([]);
-  });
-});

package/src/monitor/settings-helpers.ts

@@ -1,158 +0,0 @@
-import type { PendingApproval, TlonSettingsStore } from "../settings.js";
-import { normalizeShip } from "../targets.js";
-import type { TlonResolvedAccount } from "../types.js";
-
-type TlonMonitorSettingsState = {
-  effectiveDmAllowlist: string[];
-  effectiveShowModelSig: boolean;
-  effectiveAutoAcceptDmInvites: boolean;
-  effectiveAutoAcceptGroupInvites: boolean;
-  effectiveGroupInviteAllowlist: string[];
-  effectiveAutoDiscoverChannels: boolean;
-  effectiveOwnerShip: string | null;
-  pendingApprovals: PendingApproval[];
-  currentSettings: TlonSettingsStore;
-};
-
-export function buildTlonSettingsMigrations(
-  account: TlonResolvedAccount,
-  currentSettings: TlonSettingsStore,
-): Array<{ key: string; fileValue: unknown; settingsValue: unknown }> {
-  return [
-    {
-      key: "dmAllowlist",
-      fileValue: account.dmAllowlist,
-      settingsValue: currentSettings.dmAllowlist,
-    },
-    {
-      key: "groupInviteAllowlist",
-      fileValue: account.groupInviteAllowlist,
-      settingsValue: currentSettings.groupInviteAllowlist,
-    },
-    {
-      key: "groupChannels",
-      fileValue: account.groupChannels,
-      settingsValue: currentSettings.groupChannels,
-    },
-    {
-      key: "defaultAuthorizedShips",
-      fileValue: account.defaultAuthorizedShips,
-      settingsValue: currentSettings.defaultAuthorizedShips,
-    },
-    {
-      key: "autoDiscoverChannels",
-      fileValue: account.autoDiscoverChannels,
-      settingsValue: currentSettings.autoDiscoverChannels,
-    },
-    {
-      key: "autoAcceptDmInvites",
-      fileValue: account.autoAcceptDmInvites,
-      settingsValue: currentSettings.autoAcceptDmInvites,
-    },
-    {
-      key: "autoAcceptGroupInvites",
-      fileValue: account.autoAcceptGroupInvites,
-      settingsValue: currentSettings.autoAcceptGroupInvites,
-    },
-    {
-      key: "showModelSig",
-      fileValue: account.showModelSignature,
-      settingsValue: currentSettings.showModelSig,
-    },
-  ];
-}
-
-export function shouldMigrateTlonSetting(fileValue: unknown, settingsValue: unknown): boolean {
-  const hasFileValue = Array.isArray(fileValue) ? fileValue.length > 0 : fileValue != null;
-  const hasSettingsValue = settingsValue != null;
-  return hasFileValue && !hasSettingsValue;
-}
-
-export function applyTlonSettingsOverrides(params: {
-  account: TlonResolvedAccount;
-  currentSettings: TlonSettingsStore;
-  log?: (message: string) => void;
-}): TlonMonitorSettingsState {
-  let effectiveDmAllowlist = params.account.dmAllowlist;
-  let effectiveShowModelSig = params.account.showModelSignature ?? false;
-  let effectiveAutoAcceptDmInvites = params.account.autoAcceptDmInvites ?? false;
-  let effectiveAutoAcceptGroupInvites = params.account.autoAcceptGroupInvites ?? false;
-  let effectiveGroupInviteAllowlist = params.account.groupInviteAllowlist;
-  let effectiveAutoDiscoverChannels = params.account.autoDiscoverChannels ?? false;
-  let effectiveOwnerShip = params.account.ownerShip
-    ? normalizeShip(params.account.ownerShip)
-    : null;
-  let pendingApprovals: PendingApproval[] = [];
-
-  if (params.currentSettings.defaultAuthorizedShips?.length) {
-    params.log?.(
-      `[tlon] Using defaultAuthorizedShips from settings store: ${params.currentSettings.defaultAuthorizedShips.join(", ")}`,
-    );
-  }
-  if (params.currentSettings.autoDiscoverChannels !== undefined) {
-    effectiveAutoDiscoverChannels = params.currentSettings.autoDiscoverChannels;
-    params.log?.(
-      `[tlon] Using autoDiscoverChannels from settings store: ${effectiveAutoDiscoverChannels}`,
-    );
-  }
-  if (params.currentSettings.dmAllowlist !== undefined) {
-    effectiveDmAllowlist = params.currentSettings.dmAllowlist;
-    params.log?.(
-      `[tlon] Using dmAllowlist from settings store: ${effectiveDmAllowlist.join(", ")}`,
-    );
-  }
-  if (params.currentSettings.showModelSig !== undefined) {
-    effectiveShowModelSig = params.currentSettings.showModelSig;
-  }
-  if (params.currentSettings.autoAcceptDmInvites !== undefined) {
-    effectiveAutoAcceptDmInvites = params.currentSettings.autoAcceptDmInvites;
-    params.log?.(
-      `[tlon] Using autoAcceptDmInvites from settings store: ${effectiveAutoAcceptDmInvites}`,
-    );
-  }
-  if (params.currentSettings.autoAcceptGroupInvites !== undefined) {
-    effectiveAutoAcceptGroupInvites = params.currentSettings.autoAcceptGroupInvites;
-    params.log?.(
-      `[tlon] Using autoAcceptGroupInvites from settings store: ${effectiveAutoAcceptGroupInvites}`,
-    );
-  }
-  if (params.currentSettings.groupInviteAllowlist !== undefined) {
-    effectiveGroupInviteAllowlist = params.currentSettings.groupInviteAllowlist;
-    params.log?.(
-      `[tlon] Using groupInviteAllowlist from settings store: ${effectiveGroupInviteAllowlist.join(", ")}`,
-    );
-  }
-  if (params.currentSettings.ownerShip) {
-    effectiveOwnerShip = normalizeShip(params.currentSettings.ownerShip);
-    params.log?.(`[tlon] Using ownerShip from settings store: ${effectiveOwnerShip}`);
-  }
-  if (params.currentSettings.pendingApprovals?.length) {
-    pendingApprovals = params.currentSettings.pendingApprovals;
-    params.log?.(`[tlon] Loaded ${pendingApprovals.length} pending approval(s) from settings`);
-  }
-
-  return {
-    effectiveDmAllowlist,
-    effectiveShowModelSig,
-    effectiveAutoAcceptDmInvites,
-    effectiveAutoAcceptGroupInvites,
-    effectiveGroupInviteAllowlist,
-    effectiveAutoDiscoverChannels,
-    effectiveOwnerShip,
-    pendingApprovals,
-    currentSettings: params.currentSettings,
-  };
-}
-
-export function mergeUniqueStrings(base: string[], next?: string[]): string[] {
-  if (!next?.length) {
-    return [...base];
-  }
-  const merged = [...base];
-  for (const value of next) {
-    if (!merged.includes(value)) {
-      merged.push(value);
-    }
-  }
-  return merged;
-}