@kodelyth/tlon 2026.5.42 → 2026.6.1

package/src/urbit/story.ts

@@ -1,332 +0,0 @@
-/**
- * Tlon Story Format - Rich text converter
- *
- * Converts markdown-like text to Tlon's story format.
- */
-
-// Inline content types
-type StoryInline =
-  | string
-  | { bold: StoryInline[] }
-  | { italics: StoryInline[] }
-  | { strike: StoryInline[] }
-  | { blockquote: StoryInline[] }
-  | { "inline-code": string }
-  | { code: string }
-  | { ship: string }
-  | { link: { href: string; content: string } }
-  | { break: null }
-  | { tag: string };
-
-// Block content types
-type StoryBlock =
-  | { header: { tag: "h1" | "h2" | "h3" | "h4" | "h5" | "h6"; content: StoryInline[] } }
-  | { code: { code: string; lang: string } }
-  | { image: { src: string; height: number; width: number; alt: string } }
-  | { rule: null }
-  | { listing: StoryListing };
-
-type StoryListing =
-  | {
-      list: {
-        type: "ordered" | "unordered" | "tasklist";
-        items: StoryListing[];
-        contents: StoryInline[];
-      };
-    }
-  | { item: StoryInline[] };
-
-// A verse is either a block or inline content
-type StoryVerse = { block: StoryBlock } | { inline: StoryInline[] };
-
-// A story is a list of verses
-export type Story = StoryVerse[];
-
-/**
- * Parse inline markdown formatting (bold, italic, code, links, mentions)
- */
-function parseInlineMarkdown(text: string): StoryInline[] {
-  const result: StoryInline[] = [];
-  let remaining = text;
-
-  while (remaining.length > 0) {
-    // Ship mentions: ~sampel-palnet
-    const shipMatch = remaining.match(/^(~[a-z][-a-z0-9]*)/);
-    if (shipMatch) {
-      result.push({ ship: shipMatch[1] });
-      remaining = remaining.slice(shipMatch[0].length);
-      continue;
-    }
-
-    // Bold: **text** or __text__
-    const boldMatch = remaining.match(/^\*\*(.+?)\*\*|^__(.+?)__/);
-    if (boldMatch) {
-      const content = boldMatch[1] || boldMatch[2];
-      result.push({ bold: parseInlineMarkdown(content) });
-      remaining = remaining.slice(boldMatch[0].length);
-      continue;
-    }
-
-    // Italics: *text* or _text_ (but not inside words for _)
-    const italicsMatch = remaining.match(/^\*([^*]+?)\*|^_([^_]+?)_(?![a-zA-Z0-9])/);
-    if (italicsMatch) {
-      const content = italicsMatch[1] || italicsMatch[2];
-      result.push({ italics: parseInlineMarkdown(content) });
-      remaining = remaining.slice(italicsMatch[0].length);
-      continue;
-    }
-
-    // Strikethrough: ~~text~~
-    const strikeMatch = remaining.match(/^~~(.+?)~~/);
-    if (strikeMatch) {
-      result.push({ strike: parseInlineMarkdown(strikeMatch[1]) });
-      remaining = remaining.slice(strikeMatch[0].length);
-      continue;
-    }
-
-    // Inline code: `code`
-    const codeMatch = remaining.match(/^`([^`]+)`/);
-    if (codeMatch) {
-      result.push({ "inline-code": codeMatch[1] });
-      remaining = remaining.slice(codeMatch[0].length);
-      continue;
-    }
-
-    // Links: [text](url)
-    const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
-    if (linkMatch) {
-      result.push({ link: { href: linkMatch[2], content: linkMatch[1] } });
-      remaining = remaining.slice(linkMatch[0].length);
-      continue;
-    }
-
-    // Markdown images: ![alt](url)
-    const imageMatch = remaining.match(/^!\[([^\]]*)\]\(([^)]+)\)/);
-    if (imageMatch) {
-      // Return a special marker that will be hoisted to a block
-      result.push({
-        __image: { src: imageMatch[2], alt: imageMatch[1] },
-      } as unknown as StoryInline);
-      remaining = remaining.slice(imageMatch[0].length);
-      continue;
-    }
-
-    // Plain URL detection
-    const urlMatch = remaining.match(/^(https?:\/\/[^\s<>"\]]+)/);
-    if (urlMatch) {
-      result.push({ link: { href: urlMatch[1], content: urlMatch[1] } });
-      remaining = remaining.slice(urlMatch[0].length);
-      continue;
-    }
-
-    // Hashtags: #tag - disabled, chat UI doesn't render them
-    // const tagMatch = remaining.match(/^#([a-zA-Z][a-zA-Z0-9_-]*)/);
-    // if (tagMatch) {
-    //   result.push({ tag: tagMatch[1] });
-    //   remaining = remaining.slice(tagMatch[0].length);
-    //   continue;
-    // }
-
-    // Plain text: consume until next special character or URL start
-    // Exclude : and / to allow URL detection to work (stops before https://)
-    const plainMatch = remaining.match(/^[^*_`~[#~\n:/]+/);
-    if (plainMatch) {
-      result.push(plainMatch[0]);
-      remaining = remaining.slice(plainMatch[0].length);
-      continue;
-    }
-
-    // Single special char that didn't match a pattern
-    result.push(remaining[0]);
-    remaining = remaining.slice(1);
-  }
-
-  // Merge adjacent strings
-  return mergeAdjacentStrings(result);
-}
-
-/**
- * Merge adjacent string elements in an inline array
- */
-function mergeAdjacentStrings(inlines: StoryInline[]): StoryInline[] {
-  const result: StoryInline[] = [];
-  for (const item of inlines) {
-    if (typeof item === "string" && typeof result[result.length - 1] === "string") {
-      result[result.length - 1] = (result[result.length - 1] as string) + item;
-    } else {
-      result.push(item);
-    }
-  }
-  return result;
-}
-
-/**
- * Create an image block
- */
-export function createImageBlock(
-  src: string,
-  alt: string = "",
-  height: number = 0,
-  width: number = 0,
-): StoryVerse {
-  return {
-    block: {
-      image: { src, height, width, alt },
-    },
-  };
-}
-
-/**
- * Check if URL looks like an image
- */
-export function isImageUrl(url: string): boolean {
-  const imageExtensions = /\.(jpg|jpeg|png|gif|webp|svg|bmp|ico)(\?.*)?$/i;
-  return imageExtensions.test(url);
-}
-
-/**
- * Process inlines and extract any image markers into blocks
- */
-function processInlinesForImages(inlines: StoryInline[]): {
-  inlines: StoryInline[];
-  imageBlocks: StoryVerse[];
-} {
-  const cleanInlines: StoryInline[] = [];
-  const imageBlocks: StoryVerse[] = [];
-
-  for (const inline of inlines) {
-    if (typeof inline === "object" && "__image" in inline) {
-      const img = (inline as unknown as { __image: { src: string; alt: string } })["__image"];
-      imageBlocks.push(createImageBlock(img.src, img.alt));
-    } else {
-      cleanInlines.push(inline);
-    }
-  }
-
-  return { inlines: cleanInlines, imageBlocks };
-}
-
-/**
- * Convert markdown text to Tlon story format
- */
-export function markdownToStory(markdown: string): Story {
-  const story: Story = [];
-  const lines = markdown.split("\n");
-  let i = 0;
-
-  while (i < lines.length) {
-    const line = lines[i];
-
-    // Code block: ```lang\ncode\n```
-    if (line.startsWith("```")) {
-      const lang = line.slice(3).trim() || "plaintext";
-      const codeLines: string[] = [];
-      i++;
-      while (i < lines.length && !lines[i].startsWith("```")) {
-        codeLines.push(lines[i]);
-        i++;
-      }
-      story.push({
-        block: {
-          code: {
-            code: codeLines.join("\n"),
-            lang,
-          },
-        },
-      });
-      i++; // skip closing ```
-      continue;
-    }
-
-    // Headers: # H1, ## H2, etc.
-    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
-    if (headerMatch) {
-      const level = headerMatch[1].length as 1 | 2 | 3 | 4 | 5 | 6;
-      const tag = `h${level}` as const;
-      story.push({
-        block: {
-          header: {
-            tag,
-            content: parseInlineMarkdown(headerMatch[2]),
-          },
-        },
-      });
-      i++;
-      continue;
-    }
-
-    // Horizontal rule: --- or ***
-    if (/^(-{3,}|\*{3,})$/.test(line.trim())) {
-      story.push({ block: { rule: null } });
-      i++;
-      continue;
-    }
-
-    // Blockquote: > text
-    if (line.startsWith("> ")) {
-      const quoteLines: string[] = [];
-      while (i < lines.length && lines[i].startsWith("> ")) {
-        quoteLines.push(lines[i].slice(2));
-        i++;
-      }
-      const quoteText = quoteLines.join("\n");
-      story.push({
-        inline: [{ blockquote: parseInlineMarkdown(quoteText) }],
-      });
-      continue;
-    }
-
-    // Empty line - skip
-    if (line.trim() === "") {
-      i++;
-      continue;
-    }
-
-    // Regular paragraph - collect consecutive non-empty lines
-    const paragraphLines: string[] = [];
-    while (
-      i < lines.length &&
-      lines[i].trim() !== "" &&
-      !lines[i].startsWith("#") &&
-      !lines[i].startsWith("```") &&
-      !lines[i].startsWith("> ") &&
-      !/^(-{3,}|\*{3,})$/.test(lines[i].trim())
-    ) {
-      paragraphLines.push(lines[i]);
-      i++;
-    }
-
-    if (paragraphLines.length > 0) {
-      const paragraphText = paragraphLines.join("\n");
-      // Convert newlines within paragraph to break elements
-      const inlines = parseInlineMarkdown(paragraphText);
-      // Replace \n in strings with break elements
-      const withBreaks: StoryInline[] = [];
-      for (const inline of inlines) {
-        if (typeof inline === "string" && inline.includes("\n")) {
-          const parts = inline.split("\n");
-          for (let j = 0; j < parts.length; j++) {
-            if (parts[j]) {
-              withBreaks.push(parts[j]);
-            }
-            if (j < parts.length - 1) {
-              withBreaks.push({ break: null });
-            }
-          }
-        } else {
-          withBreaks.push(inline);
-        }
-      }
-
-      // Extract any images from inlines and add as separate blocks
-      const { inlines: cleanInlines, imageBlocks } = processInlinesForImages(withBreaks);
-
-      if (cleanInlines.length > 0) {
-        story.push({ inline: cleanInlines });
-      }
-      story.push(...imageBlocks);
-    }
-  }
-
-  return story;
-}

package/src/urbit/upload.test.ts

@@ -1,155 +0,0 @@
-import { fetchWithSsrFGuard } from "klaw/plugin-sdk/ssrf-runtime";
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { uploadFile } from "../tlon-api.js";
-import { uploadImageFromUrl } from "./upload.js";
-
-vi.mock("klaw/plugin-sdk/ssrf-runtime", () => ({
-  fetchWithSsrFGuard: vi.fn(),
-}));
-
-vi.mock("../tlon-api.js", () => ({
-  uploadFile: vi.fn(),
-}));
-
-const mockFetch = vi.mocked(fetchWithSsrFGuard);
-const mockUploadFile = vi.mocked(uploadFile);
-
-type FetchMock = typeof mockFetch;
-
-function mockSuccessfulFetch(params: {
-  mockFetch: FetchMock;
-  blob: Blob;
-  finalUrl: string;
-  contentType: string;
-}) {
-  params.mockFetch.mockResolvedValue({
-    response: {
-      ok: true,
-      headers: new Headers({ "content-type": params.contentType }),
-      blob: () => Promise.resolve(params.blob),
-    } as unknown as Response,
-    finalUrl: params.finalUrl,
-    release: vi.fn().mockResolvedValue(undefined),
-  });
-}
-
-async function setupSuccessfulUpload(params?: {
-  sourceUrl?: string;
-  contentType?: string;
-  uploadedUrl?: string;
-}) {
-  const sourceUrl = params?.sourceUrl ?? "https://example.com/image.png";
-  const contentType = params?.contentType ?? "image/png";
-  const mockBlob = new Blob(["fake-image"], { type: contentType });
-  mockSuccessfulFetch({
-    mockFetch,
-    blob: mockBlob,
-    finalUrl: sourceUrl,
-    contentType,
-  });
-  if (params?.uploadedUrl) {
-    mockUploadFile.mockResolvedValue({ url: params.uploadedUrl });
-  }
-  return { mockBlob };
-}
-
-function requireUploadParams(): { blob?: Blob; contentType?: string; fileName?: string } {
-  const [call] = mockUploadFile.mock.calls;
-  if (!call) {
-    throw new Error("expected Tlon uploadFile call");
-  }
-  const [uploadParams] = call;
-  if (!uploadParams || typeof uploadParams !== "object" || Array.isArray(uploadParams)) {
-    throw new Error("expected Tlon uploadFile params");
-  }
-  return uploadParams as { blob?: Blob; contentType?: string; fileName?: string };
-}
-
-describe("uploadImageFromUrl", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("fetches image and calls uploadFile, returns uploaded URL", async () => {
-    const { mockBlob } = await setupSuccessfulUpload({
-      uploadedUrl: "https://memex.tlon.network/uploaded.png",
-    });
-
-    const result = await uploadImageFromUrl("https://example.com/image.png");
-
-    expect(result).toBe("https://memex.tlon.network/uploaded.png");
-    expect(mockUploadFile).toHaveBeenCalledTimes(1);
-    const uploadParams = requireUploadParams();
-    expect(uploadParams.blob).toBe(mockBlob);
-    expect(uploadParams.contentType).toBe("image/png");
-  });
-
-  it("returns original URL if fetch fails", async () => {
-    mockFetch.mockResolvedValue({
-      response: {
-        ok: false,
-        status: 404,
-      } as unknown as Response,
-      finalUrl: "https://example.com/image.png",
-      release: vi.fn().mockResolvedValue(undefined),
-    });
-
-    const result = await uploadImageFromUrl("https://example.com/image.png");
-
-    expect(result).toBe("https://example.com/image.png");
-  });
-
-  it("returns original URL if upload fails", async () => {
-    await setupSuccessfulUpload();
-    mockUploadFile.mockRejectedValue(new Error("Upload failed"));
-
-    const result = await uploadImageFromUrl("https://example.com/image.png");
-
-    expect(result).toBe("https://example.com/image.png");
-  });
-
-  it("rejects non-http(s) URLs", async () => {
-    const result = await uploadImageFromUrl("file:///etc/passwd");
-    expect(result).toBe("file:///etc/passwd");
-
-    const result2 = await uploadImageFromUrl("ftp://example.com/image.png");
-    expect(result2).toBe("ftp://example.com/image.png");
-  });
-
-  it("handles invalid URLs gracefully", async () => {
-    const result = await uploadImageFromUrl("not-a-valid-url");
-    expect(result).toBe("not-a-valid-url");
-  });
-
-  it("extracts filename from URL path", async () => {
-    const mockBlob = new Blob(["fake-image"], { type: "image/jpeg" });
-    mockSuccessfulFetch({
-      mockFetch,
-      blob: mockBlob,
-      finalUrl: "https://example.com/path/to/my-image.jpg",
-      contentType: "image/jpeg",
-    });
-
-    mockUploadFile.mockResolvedValue({ url: "https://memex.tlon.network/uploaded.jpg" });
-
-    await uploadImageFromUrl("https://example.com/path/to/my-image.jpg");
-
-    expect(requireUploadParams().fileName).toBe("my-image.jpg");
-  });
-
-  it("uses default filename when URL has no path", async () => {
-    const mockBlob = new Blob(["fake-image"], { type: "image/png" });
-    mockSuccessfulFetch({
-      mockFetch,
-      blob: mockBlob,
-      finalUrl: "https://example.com/",
-      contentType: "image/png",
-    });
-
-    mockUploadFile.mockResolvedValue({ url: "https://memex.tlon.network/uploaded.png" });
-
-    await uploadImageFromUrl("https://example.com/");
-
-    expect(requireUploadParams().fileName).toMatch(/^upload-\d+\.png$/);
-  });
-});

package/src/urbit/upload.ts

@@ -1,60 +0,0 @@
-/**
- * Upload an image from a URL to Tlon storage.
- */
-import { fetchWithSsrFGuard } from "klaw/plugin-sdk/ssrf-runtime";
-import { uploadFile } from "../tlon-api.js";
-import { getDefaultSsrFPolicy } from "./context.js";
-
-/**
- * Fetch an image from a URL and upload it to Tlon storage.
- * Returns the uploaded URL, or falls back to the original URL on error.
- *
- * Note: configureClient must be called before using this function.
- */
-export async function uploadImageFromUrl(imageUrl: string): Promise<string> {
-  try {
-    // Validate URL is http/https before fetching
-    const url = new URL(imageUrl);
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-      console.warn(`[tlon] Rejected non-http(s) URL: ${imageUrl}`);
-      return imageUrl;
-    }
-
-    // Fetch the image with SSRF protection
-    // Use fetchWithSsrFGuard directly (not urbitFetch) to preserve the full URL path
-    const { response, release } = await fetchWithSsrFGuard({
-      url: imageUrl,
-      init: { method: "GET" },
-      policy: getDefaultSsrFPolicy(),
-      auditContext: "tlon-upload-image",
-    });
-
-    try {
-      if (!response.ok) {
-        console.warn(`[tlon] Failed to fetch image from ${imageUrl}: ${response.status}`);
-        return imageUrl;
-      }
-
-      const contentType = response.headers.get("content-type") || "image/png";
-      const blob = await response.blob();
-
-      // Extract filename from URL or use a default
-      const urlPath = new URL(imageUrl).pathname;
-      const fileName = urlPath.split("/").pop() || `upload-${Date.now()}.png`;
-
-      // Upload to Tlon storage
-      const result = await uploadFile({
-        blob,
-        fileName,
-        contentType,
-      });
-
-      return result.url;
-    } finally {
-      await release();
-    }
-  } catch (err) {
-    console.warn(`[tlon] Failed to upload image, using original URL: ${String(err)}`);
-    return imageUrl;
-  }
-}

package/test-api.ts

@@ -1 +0,0 @@
-export { tlonPlugin } from "./src/channel.js";

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../tsconfig.package-boundary.base.json",
-  "compilerOptions": {
-    "rootDir": "."
-  },
-  "include": ["./*.ts", "./src/**/*.ts"],
-  "exclude": [
-    "./**/*.test.ts",
-    "./dist/**",
-    "./node_modules/**",
-    "./src/test-support/**",
-    "./src/**/*test-helpers.ts",
-    "./src/**/*test-harness.ts",
-    "./src/**/*test-support.ts"
-  ]
-}