@neuctra/notlix-mcp 1.0.0 → 2.0.1

package/src/shared/presentations.js

@@ -0,0 +1,374 @@
+// Copied from neuctra-notlix-client/lib/workspace/presentations.js by scripts/sync.mjs. Don't edit here.
+
+// The presentation model. A deck is JSON, not HTML: every slide is a list of
+// positioned elements on a fixed 960x540 stage, and text is always rendered as
+// plain text. Colors and fonts left unset come from the theme, so changing the
+// theme restyles the whole deck.
+
+export const STAGE = { width: 960, height: 540 };
+export const MIN_ELEMENT_SIZE = 24;
+export const UNTITLED_PRESENTATION = "Untitled presentation";
+export const MAX_TABLE_ROWS = 12;
+export const MAX_TABLE_COLUMNS = 8;
+
+const SNAP_DISTANCE = 6;
+
+export const THEMES = [
+  { id: "paper", name: "Paper", background: "#ffffff", title: "#14231a", body: "#3b4a40", accent: "#0f9d3a", font: "Arial" },
+  { id: "ink", name: "Ink", background: "#10141a", title: "#ffffff", body: "#c7ced8", accent: "#34d399", font: "Arial" },
+  { id: "sand", name: "Sand", background: "#f6efe3", title: "#3a2a1c", body: "#5b4a39", accent: "#c2692d", font: "Georgia" },
+  { id: "ocean", name: "Ocean", background: "#0b2a45", title: "#ffffff", body: "#c9dcec", accent: "#4cc9f0", font: "Verdana" },
+  { id: "plum", name: "Plum", background: "#2b1733", title: "#fdf4ff", body: "#dcc8e4", accent: "#e879f9", font: "Georgia" },
+];
+
+export const getTheme = (themeId) => THEMES.find((theme) => theme.id === themeId) || THEMES[0];
+
+const newId = () => crypto.randomUUID().slice(0, 8);
+
+// Text inside a shape starts in the background color, so it reads on the fill.
+const SHAPE_TEXT = {
+  text: "",
+  placeholder: "",
+  role: "background",
+  fontSize: 20,
+  bold: false,
+  italic: false,
+  align: "center",
+  valign: "middle",
+  bullets: false,
+};
+
+const SHAPE_STYLE = { fill: null, opacity: 1, stroke: null, strokeWidth: 0 };
+
+export function createElement(type, fields = {}) {
+  const base = { id: newId(), type, x: 330, y: 200, w: 300, h: 140 };
+
+  if (type === "text") {
+    return {
+      ...base,
+      h: 60,
+      text: "",
+      placeholder: "Type something",
+      role: "body",
+      fontSize: 22,
+      bold: false,
+      italic: false,
+      align: "left",
+      valign: "top",
+      bullets: false,
+      ...fields,
+    };
+  }
+
+  if (type === "shape") return { ...base, ...SHAPE_TEXT, ...SHAPE_STYLE, shape: "rect", ...fields };
+
+  if (type === "line") {
+    return {
+      id: base.id,
+      type,
+      x1: 360,
+      y1: 270,
+      x2: 600,
+      y2: 270,
+      stroke: null,
+      strokeWidth: 3,
+      dash: "solid",
+      startArrow: false,
+      endArrow: false,
+      ...fields,
+    };
+  }
+
+  if (type === "table") {
+    const { rowCount = 3, columnCount = 3, ...rest } = fields;
+    const h = rowCount * 44;
+
+    return {
+      ...base,
+      x: 160,
+      y: (STAGE.height - h) / 2,
+      w: 640,
+      h,
+      rows: Array.from({ length: rowCount }, () => Array(columnCount).fill("")),
+      header: true,
+      fontSize: 16,
+      ...rest,
+    };
+  }
+
+  return { ...base, src: "", ...fields };
+}
+
+const title = (fields) =>
+  createElement("text", { role: "title", placeholder: "Click to add title", bold: true, ...fields });
+
+const body = (fields) =>
+  createElement("text", { placeholder: "Click to add text", bullets: true, ...fields });
+
+export const LAYOUTS = [
+  {
+    id: "title",
+    name: "Title slide",
+    build: () => [
+      title({ x: 80, y: 170, w: 800, h: 120, fontSize: 48, align: "center", valign: "bottom" }),
+      body({ x: 80, y: 305, w: 800, h: 60, fontSize: 24, align: "center", bullets: false, placeholder: "Click to add subtitle" }),
+    ],
+  },
+  {
+    id: "content",
+    name: "Title and content",
+    build: () => [
+      title({ x: 60, y: 36, w: 840, h: 80, fontSize: 36, valign: "middle" }),
+      body({ x: 60, y: 130, w: 840, h: 360 }),
+    ],
+  },
+  {
+    id: "section",
+    name: "Section header",
+    build: () => [
+      createElement("shape", { x: 60, y: 210, w: 8, h: 120 }),
+      title({ x: 90, y: 210, w: 790, h: 120, fontSize: 44, valign: "middle" }),
+    ],
+  },
+  {
+    id: "columns",
+    name: "Two columns",
+    build: () => [
+      title({ x: 60, y: 36, w: 840, h: 80, fontSize: 36, valign: "middle" }),
+      body({ x: 60, y: 130, w: 410, h: 360 }),
+      body({ x: 490, y: 130, w: 410, h: 360 }),
+    ],
+  },
+  { id: "blank", name: "Blank", build: () => [] },
+];
+
+export function createSlide(layoutId = "content") {
+  const layout = LAYOUTS.find((option) => option.id === layoutId) || LAYOUTS[1];
+  return { id: newId(), notes: "", elements: layout.build() };
+}
+
+/** A copy that sits slightly offset, so it's visible on top of the original. */
+export function duplicateElement(element) {
+  return { ...element, ...nudged(element, 16, 16), id: newId() };
+}
+
+/** The fields that move an element. Lines have two ends, not a box. */
+export function nudged(element, dx, dy) {
+  if (element.type === "line") {
+    return {
+      x1: element.x1 + dx,
+      y1: element.y1 + dy,
+      x2: element.x2 + dx,
+      y2: element.y2 + dy,
+    };
+  }
+
+  return { x: element.x + dx, y: element.y + dy };
+}
+
+export const hasTextContent = (element) => ["text", "shape"].includes(element?.type);
+
+export function lineBox({ x1, y1, x2, y2 }) {
+  return {
+    x: Math.min(x1, x2),
+    y: Math.min(y1, y2),
+    w: Math.abs(x2 - x1),
+    h: Math.abs(y2 - y1),
+  };
+}
+
+/** Moves a whole line, always leaving some of it on the slide. */
+export function moveLine(line, dx, dy) {
+  const box = lineBox(line);
+
+  return nudged(
+    line,
+    Math.min(Math.max(dx, MIN_ELEMENT_SIZE - box.x - box.w), STAGE.width - MIN_ELEMENT_SIZE - box.x),
+    Math.min(Math.max(dy, MIN_ELEMENT_SIZE - box.y - box.h), STAGE.height - MIN_ELEMENT_SIZE - box.y),
+  );
+}
+
+/** Moves one end. `straighten` snaps the angle to the nearest 45 degrees. */
+export function moveLineEnd(line, end, dx, dy, straighten) {
+  const [movedX, movedY, fixedX, fixedY] =
+    end === "start" ? ["x1", "y1", "x2", "y2"] : ["x2", "y2", "x1", "y1"];
+
+  let x = line[movedX] + dx;
+  let y = line[movedY] + dy;
+
+  if (straighten) {
+    const step = Math.PI / 4;
+    const angle = Math.round(Math.atan2(y - line[fixedY], x - line[fixedX]) / step) * step;
+    const length = Math.hypot(x - line[fixedX], y - line[fixedY]);
+    x = line[fixedX] + length * Math.cos(angle);
+    y = line[fixedY] + length * Math.sin(angle);
+  }
+
+  return { [movedX]: x, [movedY]: y };
+}
+
+/** Rows keep their height, so the table grows and shrinks with them. */
+export function resizeTable(table, { rowChange = 0, columnChange = 0 }) {
+  const rowHeight = table.h / table.rows.length;
+  let rows = table.rows;
+
+  if (rowChange > 0) rows = [...rows, Array(rows[0].length).fill("")];
+  if (rowChange < 0) rows = rows.slice(0, -1);
+  if (columnChange > 0) rows = rows.map((row) => [...row, ""]);
+  if (columnChange < 0) rows = rows.map((row) => row.slice(0, -1));
+
+  return { rows, h: rowHeight * rows.length };
+}
+
+export function duplicateSlide(slide) {
+  return {
+    ...slide,
+    id: newId(),
+    elements: slide.elements.map((element) => ({ ...element, id: newId() })),
+  };
+}
+
+/** Records can come from anywhere, so a deck always loads with at least one slide. */
+export function normalizeSlides(slides) {
+  if (!Array.isArray(slides) || slides.length === 0) return [createSlide("title")];
+
+  // Shapes saved before they could hold text get the newer fields.
+  return slides.map((slide) => ({
+    ...slide,
+    elements: slide.elements.map((element) =>
+      element.type === "shape" ? { ...SHAPE_TEXT, ...SHAPE_STYLE, ...element } : element,
+    ),
+  }));
+}
+
+const BULLET = /^(?:[-*+]|\d+[.)])\s+/;
+const NOTES = /^notes?:\s*/i;
+
+// Slides show plain text, so inline markdown would appear as literal symbols.
+const plainText = (line) =>
+  line
+    .replace(/^#+\s*/, "")
+    .replace(BULLET, "")
+    .replace(/\*\*|__|`/g, "")
+    .trim();
+
+function bodyFontSize(lineCount) {
+  if (lineCount <= 7) return 22;
+  return lineCount <= 10 ? 18 : 14;
+}
+
+function parseSlide(source, isFirst) {
+  const lines = source
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (lines.length === 0) return null;
+
+  const notesAt = lines.findIndex((line) => NOTES.test(line));
+  const content = notesAt === -1 ? lines : lines.slice(0, notesAt);
+  const notes = notesAt === -1 ? "" : lines.slice(notesAt).join("\n").replace(NOTES, "");
+
+  const hasHeading = content[0]?.startsWith("#");
+  const heading = hasHeading ? plainText(content[0]) : "";
+  const bodyLines = hasHeading ? content.slice(1) : content;
+
+  let layout = "content";
+  if (heading && bodyLines.length === 0) layout = isFirst ? "title" : "section";
+  if (heading && bodyLines.length === 1 && isFirst) layout = "title";
+
+  const slide = createSlide(layout);
+  slide.notes = notes;
+
+  for (const element of slide.elements) {
+    if (element.role === "title") element.text = heading;
+    if (element.role === "body") {
+      element.text = bodyLines.map(plainText).join("\n");
+      if (layout === "content") {
+        element.fontSize = bodyFontSize(bodyLines.length);
+        element.bullets = bodyLines.some((line) => BULLET.test(line));
+      }
+    }
+  }
+
+  return slide;
+}
+
+/**
+ * Builds slides from markdown, such as an AI's: --- splits slides, # starts a
+ * title, - starts a bullet, and Notes: starts speaker notes.
+ */
+export function markdownToSlides(markdown) {
+  const slides = String(markdown)
+    .split(/^\s*-{3,}\s*$/m)
+    .filter((source) => source.trim())
+    .map((source, index) => parseSlide(source, index === 0));
+
+  return normalizeSlides(slides.filter(Boolean));
+}
+
+/** Plain text for card search. */
+export function slidesText(slides) {
+  return slides
+    .flatMap((slide) => [
+      ...slide.elements.flatMap((element) => element.rows?.flat() ?? element.text),
+      slide.notes,
+    ])
+    .filter(Boolean)
+    .join(" ");
+}
+
+/** Keeps an element reachable, so it can't be dragged fully off the slide. */
+function keepOnStage(box) {
+  return {
+    ...box,
+    x: Math.min(Math.max(box.x, MIN_ELEMENT_SIZE - box.w), STAGE.width - MIN_ELEMENT_SIZE),
+    y: Math.min(Math.max(box.y, MIN_ELEMENT_SIZE - box.h), STAGE.height - MIN_ELEMENT_SIZE),
+  };
+}
+
+/** Moves a box, snapping its center to the slide's center lines. */
+export function moveBox(box, dx, dy) {
+  let x = box.x + dx;
+  let y = box.y + dy;
+  const guides = { vertical: false, horizontal: false };
+
+  if (Math.abs(x + box.w / 2 - STAGE.width / 2) < SNAP_DISTANCE) {
+    x = (STAGE.width - box.w) / 2;
+    guides.vertical = true;
+  }
+  if (Math.abs(y + box.h / 2 - STAGE.height / 2) < SNAP_DISTANCE) {
+    y = (STAGE.height - box.h) / 2;
+    guides.horizontal = true;
+  }
+
+  return { box: keepOnStage({ ...box, x, y }), guides };
+}
+
+/** `handle` is a compass direction, such as "se". Corners can keep the shape's ratio. */
+export function resizeFreely(box, handle, dx, dy, keepRatio) {
+  let { x, y, w, h } = box;
+
+  if (handle.includes("e")) w = Math.max(MIN_ELEMENT_SIZE, w + dx);
+  if (handle.includes("s")) h = Math.max(MIN_ELEMENT_SIZE, h + dy);
+  if (handle.includes("w")) {
+    w = Math.max(MIN_ELEMENT_SIZE, box.w - dx);
+    x = box.x + box.w - w;
+  }
+  if (handle.includes("n")) {
+    h = Math.max(MIN_ELEMENT_SIZE, box.h - dy);
+    y = box.y + box.h - h;
+  }
+
+  if (keepRatio && handle.length === 2) {
+    h = Math.max(MIN_ELEMENT_SIZE, w * (box.h / box.w));
+    w = h * (box.w / box.h);
+    if (handle.includes("n")) y = box.y + box.h - h;
+    if (handle.includes("w")) x = box.x + box.w - w;
+  }
+
+  return { ...box, x, y, w, h };
+}
+
+export function resizeBox(box, handle, dx, dy, keepRatio) {
+  return keepOnStage(resizeFreely(box, handle, dx, dy, keepRatio));
+}

package/src/shared/records.js

@@ -0,0 +1,32 @@
+// Copied from neuctra-notlix-client/lib/data/records.js by scripts/sync.mjs. Don't edit here.
+
+// Shared helpers for Authix list responses.
+
+export function itemsOf(response) {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response?.data)) return response.data;
+  if (Array.isArray(response?.items)) return response.items;
+  return [];
+}
+
+export function nextCursorOf(response) {
+  return (
+    response?.next_cursor ||
+    response?.nextCursor ||
+    response?.pagination?.next_cursor ||
+    response?.pagination?.nextCursor ||
+    null
+  );
+}
+
+/** Follows the cursor so a list is never cut off at one page. */
+export async function fetchAllPages(fetchPage) {
+  const all = [];
+  let cursor;
+  do {
+    const response = await fetchPage(cursor);
+    all.push(...itemsOf(response));
+    cursor = nextCursorOf(response);
+  } while (cursor);
+  return all;
+}

package/src/shared/slideShapes.js

@@ -0,0 +1,133 @@
+// Copied from neuctra-notlix-client/lib/workspace/slideShapes.js by scripts/sync.mjs. Don't edit here.
+
+// The shape catalog. Each id is PowerPoint's own preset name, so a shape exports
+// as a real, editable shape. The outlines follow PowerPoint's default geometry.
+
+const polygon = (points) => (w, h) =>
+  `M${points.map(([x, y]) => `${(x * w) / 100} ${(y * h) / 100}`).join("L")}Z`;
+
+function roundRect(w, h) {
+  const r = Math.min(w, h) / 6;
+  return `M${r} 0H${w - r}A${r} ${r} 0 0 1 ${w} ${r}V${h - r}A${r} ${r} 0 0 1 ${w - r} ${h}H${r}A${r} ${r} 0 0 1 0 ${h - r}V${r}A${r} ${r} 0 0 1 ${r} 0Z`;
+}
+
+function ellipse(w, h) {
+  return `M0 ${h / 2}A${w / 2} ${h / 2} 0 1 1 ${w} ${h / 2}A${w / 2} ${h / 2} 0 1 1 0 ${h / 2}Z`;
+}
+
+function star(w, h) {
+  const points = Array.from({ length: 10 }, (_, index) => {
+    const radius = index % 2 === 0 ? 50 : 19;
+    const angle = (Math.PI / 5) * index - Math.PI / 2;
+    return [50 + radius * Math.cos(angle), 50 + radius * Math.sin(angle)];
+  });
+  return polygon(points)(w, h);
+}
+
+function heart(w, h) {
+  const x = (value) => (value * w) / 100;
+  const y = (value) => (value * h) / 100;
+  return `M${x(50)} ${y(25)}C${x(65)} ${y(-8)} ${x(115)} ${y(5)} ${x(92)} ${y(45)}C${x(83)} ${y(62)} ${x(62)} ${y(82)} ${x(50)} ${y(100)}C${x(38)} ${y(82)} ${x(17)} ${y(62)} ${x(8)} ${y(45)}C${x(-15)} ${y(5)} ${x(35)} ${y(-8)} ${x(50)} ${y(25)}Z`;
+}
+
+function speechBubble(w, h) {
+  const r = Math.min(w, h) / 6;
+  return `M${r} 0H${w - r}A${r} ${r} 0 0 1 ${w} ${r}V${h - r}A${r} ${r} 0 0 1 ${w - r} ${h}H${w * 0.417}L${w * 0.292} ${h * 1.125}L${w * 0.167} ${h}H${r}A${r} ${r} 0 0 1 0 ${h - r}V${r}A${r} ${r} 0 0 1 ${r} 0Z`;
+}
+
+/** Arrow heads keep their size as the shape stretches, as they do in PowerPoint. */
+const arrow = (draw) => (w, h) => {
+  const head = Math.min(w, h) / 2;
+  return `M${draw(w, h, head).map((point) => point.join(" ")).join("L")}Z`;
+};
+
+export const SHAPES = [
+  { id: "rect", name: "Rectangle", group: "Basic", draw: polygon([[0, 0], [100, 0], [100, 100], [0, 100]]) },
+  { id: "roundRect", name: "Rounded rectangle", group: "Basic", draw: roundRect },
+  { id: "ellipse", name: "Ellipse", group: "Basic", draw: ellipse },
+  { id: "triangle", name: "Triangle", group: "Basic", draw: polygon([[50, 0], [100, 100], [0, 100]]) },
+  { id: "rtTriangle", name: "Right triangle", group: "Basic", draw: polygon([[0, 0], [100, 100], [0, 100]]) },
+  { id: "diamond", name: "Diamond", group: "Basic", draw: polygon([[50, 0], [100, 50], [50, 100], [0, 50]]) },
+  { id: "parallelogram", name: "Parallelogram", group: "Basic", draw: polygon([[25, 0], [100, 0], [75, 100], [0, 100]]) },
+  { id: "trapezoid", name: "Trapezoid", group: "Basic", draw: polygon([[25, 0], [75, 0], [100, 100], [0, 100]]) },
+  { id: "pentagon", name: "Pentagon", group: "Basic", draw: polygon([[50, 0], [100, 38], [81, 100], [19, 100], [0, 38]]) },
+  { id: "hexagon", name: "Hexagon", group: "Basic", draw: polygon([[25, 0], [75, 0], [100, 50], [75, 100], [25, 100], [0, 50]]) },
+  { id: "octagon", name: "Octagon", group: "Basic", draw: polygon([[29, 0], [71, 0], [100, 29], [100, 71], [71, 100], [29, 100], [0, 71], [0, 29]]) },
+  { id: "star5", name: "Star", group: "Basic", draw: star },
+  { id: "plus", name: "Cross", group: "Basic", draw: polygon([[25, 0], [75, 0], [75, 25], [100, 25], [100, 75], [75, 75], [75, 100], [25, 100], [25, 75], [0, 75], [0, 25], [25, 25]]) },
+  { id: "heart", name: "Heart", group: "Basic", draw: heart },
+  {
+    id: "rightArrow",
+    name: "Right arrow",
+    group: "Arrows",
+    draw: arrow((w, h, head) => [[0, h / 4], [w - head, h / 4], [w - head, 0], [w, h / 2], [w - head, h], [w - head, (h * 3) / 4], [0, (h * 3) / 4]]),
+  },
+  {
+    id: "leftArrow",
+    name: "Left arrow",
+    group: "Arrows",
+    draw: arrow((w, h, head) => [[w, h / 4], [head, h / 4], [head, 0], [0, h / 2], [head, h], [head, (h * 3) / 4], [w, (h * 3) / 4]]),
+  },
+  {
+    id: "upArrow",
+    name: "Up arrow",
+    group: "Arrows",
+    draw: arrow((w, h, head) => [[w / 4, h], [w / 4, head], [0, head], [w / 2, 0], [w, head], [(w * 3) / 4, head], [(w * 3) / 4, h]]),
+  },
+  {
+    id: "downArrow",
+    name: "Down arrow",
+    group: "Arrows",
+    draw: arrow((w, h, head) => [[w / 4, 0], [w / 4, h - head], [0, h - head], [w / 2, h], [w, h - head], [(w * 3) / 4, h - head], [(w * 3) / 4, 0]]),
+  },
+  {
+    id: "leftRightArrow",
+    name: "Double arrow",
+    group: "Arrows",
+    draw: arrow((w, h, head) => [[0, h / 2], [head, 0], [head, h / 4], [w - head, h / 4], [w - head, 0], [w, h / 2], [w - head, h], [w - head, (h * 3) / 4], [head, (h * 3) / 4], [head, h]]),
+  },
+  {
+    id: "chevron",
+    name: "Chevron",
+    group: "Arrows",
+    draw: arrow((w, h, head) => [[0, 0], [w - head, 0], [w, h / 2], [w - head, h], [0, h], [head, h / 2]]),
+  },
+  {
+    id: "homePlate",
+    name: "Tag arrow",
+    group: "Arrows",
+    draw: arrow((w, h, head) => [[0, 0], [w - head, 0], [w, h / 2], [w - head, h], [0, h]]),
+  },
+  { id: "wedgeRoundRectCallout", name: "Speech bubble", group: "Callouts", draw: speechBubble },
+];
+
+export const SHAPE_GROUPS = ["Basic", "Arrows", "Callouts"];
+
+// These read better wide. The rest start square, so a star isn't squashed.
+const WIDE_SHAPES = new Set([
+  "rect",
+  "roundRect",
+  "parallelogram",
+  "rightArrow",
+  "leftArrow",
+  "leftRightArrow",
+  "chevron",
+  "homePlate",
+  "wedgeRoundRectCallout",
+]);
+
+/** The size a new shape starts at. */
+export const shapeSize = (shapeId) =>
+  WIDE_SHAPES.has(shapeId) ? { w: 280, h: 130 } : { w: 180, h: 180 };
+
+/** The three corners of an arrow head pointing at (toX, toY). */
+export function arrowHeadPoints(fromX, fromY, toX, toY, size) {
+  const angle = Math.atan2(toY - fromY, toX - fromX);
+  const corner = (turn) =>
+    `${toX - size * Math.cos(angle + turn)},${toY - size * Math.sin(angle + turn)}`;
+
+  return `${toX},${toY} ${corner(0.45)} ${corner(-0.45)}`;
+}
+
+export const shapePath = (shapeId, w, h) =>
+  (SHAPES.find((shape) => shape.id === shapeId) || SHAPES[0]).draw(w, h);

package/src/sharedText.js

@@ -0,0 +1,61 @@
+import { documentToReadable } from "./documents.js";
+import { compilePack, noteBody } from "./shared/contextPacks.js";
+
+// Plain text of a live-shared item, for "Link for AI": an AI that fetches the
+// link gets readable markdown instead of a page that needs JavaScript. The
+// same token as the website's /note/share#<token> link, so it's just as live
+// and stops working when the owner stops sharing.
+
+// From LIVE_SHARE_CATEGORIES in the client's lib/sharing/liveShare.js.
+export const SHAREABLE = new Set(["note", "document", "knowledge", "contextpack"]);
+
+export const SHARE_TOKEN = /^[A-Za-z0-9_-]{8,200}$/;
+
+const day = (value) => (value ? String(value).slice(0, 10) : "");
+
+/** An AI Brief's sources, fetched by their own tokens, like fetchBriefParts in the client. */
+async function briefParts(authix, pack) {
+  const tokens = pack.sourceTokens || {};
+  const library = [];
+  for (const source of pack.sources || []) {
+    const token = tokens[source.id];
+    const record = token ? await authix.getShared(token).catch(() => null) : null;
+    if (!record || record.dataCategory !== source.type) continue;
+    library.push({
+      type: source.type,
+      id: source.id,
+      title: record.title || "Untitled",
+      body: source.type === "note" ? noteBody(record) : String(record.content || ""),
+    });
+  }
+  const profile =
+    pack.includeProfile && pack.profileToken ? await authix.getShared(pack.profileToken).catch(() => null) : null;
+  return { library, profile };
+}
+
+/**
+ * `{ title, text }` for a share token, or null when it isn't shared (or isn't
+ * a type that can be). `authix` is an AuthixClient; no session is needed.
+ */
+export async function sharedItemText(authix, token) {
+  if (!SHARE_TOKEN.test(String(token || ""))) return null;
+  const record = await authix.getShared(token);
+  if (!record || !SHAREABLE.has(record.dataCategory)) return null;
+
+  const updated = day(record.updatedAt || record.createdAt);
+  const footer = `\n\n---\nShared from Neuctra Notlix${updated ? `, last updated ${updated}` : ""}. This link always shows the latest version.\n`;
+
+  if (record.dataCategory === "contextpack") {
+    const { markdown, missing } = compilePack(record, await briefParts(authix, record));
+    const gap = missing ? `\n\n(${missing} source${missing === 1 ? " isn't" : "s aren't"} available.)` : "";
+    return { title: record.name || "AI Brief", text: `${markdown.trim()}${gap}${footer}` };
+  }
+
+  const title = record.title || "Untitled";
+  let body = "";
+  if (record.dataCategory === "note") body = noteBody(record);
+  else if (record.dataCategory === "knowledge") body = String(record.content || "");
+  else body = documentToReadable(record.html || "") || String(record.text || "");
+
+  return { title, text: `# ${title}\n\n${body.trim()}${footer}` };
+}

package/src/connection.js

@@ -1,15 +0,0 @@
-// The connection token the Notlix dashboard gives out under Connect AI:
-// `<inbox id>.<write secret>`. Older connections handed out a full URL ending
-// in /mcp/<id>.<secret>; that works too.
-
-export const DEFAULT_API_URL = "https://server.notlix.neuctra.com";
-
-const TOKEN = /^([0-9a-f]{32})\.([0-9a-f]{64})$/;
-
-/** `{ id, secret }` from a token or an old MCP URL, or null when it isn't one. */
-export function parseConnection(value) {
-  const text = String(value || "").trim();
-  const token = text.includes("/mcp/") ? text.split("/mcp/").pop().split(/[/?#]/)[0] : text;
-  const match = TOKEN.exec(token);
-  return match ? { id: match[1], secret: match[2] } : null;
-}

package/src/inbox.js

@@ -1,60 +0,0 @@
-import { seal } from "./seal.js";
-
-// Talks to the Notlix server's inbox API with the write token. It can fetch the
-// inbox's public key and add encrypted items. It can't read anything.
-
-/** An error whose message is safe to show the AI and the user. */
-export class InboxError extends Error {
-  constructor(message, status) {
-    super(message);
-    this.name = "InboxError";
-    this.status = status;
-  }
-}
-
-const UNREACHABLE = "Couldn't reach Notlix. Check the connection and try again.";
-
-/**
- * `apiUrl`: the Notlix server. `fetch`: optional, for a Cloudflare service
- * binding or tests. The public key is fetched once and kept.
- */
-export function createInboxClient({ apiUrl, id, secret, fetch: doFetch = globalThis.fetch }) {
-  const base = String(apiUrl).replace(/\/+$/, "");
-  const headers = { Authorization: `Bearer ${secret}` };
-  let publicKey = null;
-
-  async function call(path, init = {}) {
-    let res;
-    try {
-      res = await doFetch(`${base}/v1/inboxes/${id}${path}`, {
-        ...init,
-        headers: { ...headers, ...init.headers },
-      });
-    } catch {
-      throw new InboxError(UNREACHABLE, 0);
-    }
-    if (res.ok) return res.json();
-    const body = await res.json().catch(() => null);
-    if (res.status === 401) publicKey = null;
-    throw new InboxError(body?.error?.message || UNREACHABLE, res.status);
-  }
-
-  async function getPublicKey() {
-    if (!publicKey) publicKey = (await call("/key")).publicKey;
-    return publicKey;
-  }
-
-  return {
-    getPublicKey,
-    /** Encrypts `item` here and adds it to the inbox. Returns the item id. */
-    async add(item) {
-      const sealed = await seal(await getPublicKey(), item);
-      const { id: itemId } = await call("/items", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(sealed),
-      });
-      return itemId;
-    },
-  };
-}