web-comments 0.1.0 → 1.0.1

package/dist/server.js

@@ -1,501 +1,11 @@
+import {
+  CommentsError,
+  createComments,
+  newId
+} from "./chunks/chunk-RRSB326L.js";
 import "./chunks/chunk-WSFCRVEQ.js";
-
-// src/server/index.ts
-import { Hono } from "hono";
-
-// src/server/auth.ts
-async function identify(plugins, request, env) {
-  for (const plugin of plugins) {
-    const who = await plugin.authenticate(request, env);
-    if (who) return who;
-  }
-  return null;
-}
-function loginUrlFor(plugins, request) {
-  for (const plugin of plugins) {
-    const url = plugin.loginUrl?.(request);
-    if (url) return url;
-  }
-  return void 0;
-}
-
-// src/server/validate.ts
-var InvalidInput = class extends Error {
-};
-var MAX_BODY = 1e4;
-var MAX_PAGE = 512;
-var MAX_URL = 4096;
-var MAX_SELECTOR = 2048;
-var MAX_TEXT = 200;
-function record(value, what) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new InvalidInput(`${what} must be an object`);
-  }
-  return value;
-}
-function string(value, what, max) {
-  if (typeof value !== "string") throw new InvalidInput(`${what} must be a string`);
-  if (value.length > max) throw new InvalidInput(`${what} is longer than ${max} characters`);
-  return value;
-}
-function fraction(value, what) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
-    throw new InvalidInput(`${what} must be a number from 0 to 1`);
-  }
-  return value;
-}
-function commentBody(value) {
-  const body = string(value, "body", MAX_BODY).trim();
-  if (!body) throw new InvalidInput("body is empty");
-  return body;
-}
-function reply(value) {
-  return commentBody(record(value, "request body").body);
-}
-function anchor(value) {
-  const input = record(value, "anchor");
-  const selector = string(input.selector, "anchor.selector", MAX_SELECTOR);
-  if (!selector) throw new InvalidInput("anchor.selector is empty");
-  const viewportWidth = input.viewportWidth;
-  if (typeof viewportWidth !== "number" || !Number.isFinite(viewportWidth) || viewportWidth < 0) {
-    throw new InvalidInput("anchor.viewportWidth must be a positive number");
-  }
-  return {
-    selector,
-    tag: string(input.tag, "anchor.tag", 64).toLowerCase(),
-    x: fraction(input.x, "anchor.x"),
-    y: fraction(input.y, "anchor.y"),
-    viewportWidth: Math.round(viewportWidth),
-    ...input.text === void 0 ? {} : { text: string(input.text, "anchor.text", MAX_TEXT) }
-  };
-}
-function finite(value, what) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new InvalidInput(`${what} must be a number`);
-  }
-  return value;
-}
-function size(value, what) {
-  const input = record(value, what);
-  const width = finite(input.width, `${what}.width`);
-  const height = finite(input.height, `${what}.height`);
-  if (width <= 0 || height <= 0 || width > 32768 || height > 32768) {
-    throw new InvalidInput(`${what} must be between 1 and 32768 pixels each way`);
-  }
-  return { width: Math.round(width), height: Math.round(height) };
-}
-function context(value) {
-  const input = record(value, "context");
-  const element = record(input.element, "context.element");
-  const rect = record(element.rect, "context.element.rect");
-  const page = record(input.page, "context.page");
-  const viewport = size(page.viewport, "context.page.viewport");
-  const scroll = record(page.scroll, "context.page.scroll");
-  return {
-    element: {
-      html: string(element.html, "context.element.html", 4096),
-      rect: {
-        x: finite(rect.x, "context.element.rect.x"),
-        y: finite(rect.y, "context.element.rect.y"),
-        width: finite(rect.width, "context.element.rect.width"),
-        height: finite(rect.height, "context.element.rect.height")
-      }
-    },
-    page: {
-      title: string(page.title, "context.page.title", 512),
-      viewport,
-      scroll: {
-        x: finite(scroll.x, "context.page.scroll.x"),
-        y: finite(scroll.y, "context.page.scroll.y")
-      },
-      devicePixelRatio: finite(page.devicePixelRatio, "context.page.devicePixelRatio"),
-      userAgent: string(page.userAgent, "context.page.userAgent", 512)
-    }
-  };
-}
-var SCREENSHOT_KINDS = ["element", "page"];
-function createThread(value) {
-  const input = record(value, "request body");
-  const page = string(input.page, "page", MAX_PAGE);
-  if (!page) throw new InvalidInput("page is empty");
-  const url = string(input.url, "url", MAX_URL);
-  if (!URL.canParse(url)) throw new InvalidInput("url is not an absolute URL");
-  const screenshots = {};
-  if (input.screenshots !== void 0) {
-    const given = record(input.screenshots, "screenshots");
-    for (const kind of SCREENSHOT_KINDS) {
-      if (given[kind] !== void 0) screenshots[kind] = size(given[kind], `screenshots.${kind}`);
-    }
-  }
-  return {
-    page,
-    url,
-    anchor: anchor(input.anchor),
-    body: commentBody(input.body),
-    ...input.context === void 0 ? {} : { context: context(input.context) },
-    screenshots
-  };
-}
-function threadUpdate(value) {
-  const input = record(value, "request body");
-  const update = {};
-  if (input.status !== void 0) {
-    if (input.status !== "open" && input.status !== "resolved") {
-      throw new InvalidInput(`status must be "open" or "resolved"`);
-    }
-    update.status = input.status;
-  }
-  if (input.anchor !== void 0) update.anchor = anchor(input.anchor);
-  if (!update.status && !update.anchor)
-    throw new InvalidInput("nothing to change: send status or anchor");
-  return update;
-}
-
-// src/server/index.ts
-var MAX_JSON_BYTES = 64 * 1024;
-var SEEN_EVERY_MS = 10 * 60 * 1e3;
-var SCREENSHOT_TYPES = {
-  "image/png": "png",
-  "image/jpeg": "jpg",
-  "image/webp": "webp"
-};
-var ID_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
-function newId() {
-  const bytes = crypto.getRandomValues(new Uint8Array(14));
-  return Array.from(bytes, (b) => ID_ALPHABET[b % ID_ALPHABET.length]).join("");
-}
-var lastTime = 0;
-function now() {
-  lastTime = Math.max(Date.now(), lastTime + 1);
-  return new Date(lastTime).toISOString();
-}
-function authorOf(who) {
-  return {
-    id: who.id,
-    name: who.name,
-    kind: who.kind,
-    ...who.avatarUrl ? { avatarUrl: who.avatarUrl } : {}
-  };
-}
-function createComments(options) {
-  const basePath = (options.basePath ?? "/__comments").replace(/\/+$/, "");
-  const allowedOrigins = new Set(options.allowedOrigins ?? []);
-  const maxScreenshotBytes = options.maxScreenshotBytes ?? 5 * 1024 * 1024;
-  const stores = /* @__PURE__ */ new WeakMap();
-  const lastSeen = /* @__PURE__ */ new Map();
-  const app = new Hono().basePath(basePath);
-  function storeFor(env) {
-    let entry = stores.get(env);
-    if (!entry) {
-      const store = options.store(env);
-      const ready = Promise.resolve(store.setup?.());
-      entry = { store, ready };
-      stores.set(env, entry);
-      ready.catch(() => stores.delete(env));
-    }
-    return entry;
-  }
-  function background(c, work) {
-    const logged = work.catch((error) => console.error("web-comments:", error));
-    try {
-      c.executionCtx.waitUntil(logged);
-    } catch {
-    }
-  }
-  function emit(c, event) {
-    if (options.onEvent) background(c, Promise.resolve(options.onEvent(event, c.env)));
-  }
-  function fail(status, code, message) {
-    return Response.json({ error: { code, message } }, { status });
-  }
-  function present(thread) {
-    const { site: _, screenshots, ...rest } = thread;
-    const shown = {};
-    for (const [kind, shot] of Object.entries(screenshots)) {
-      shown[kind] = {
-        url: `${basePath}/assets/${shot.key.split("/").map(encodeURIComponent).join("/")}`,
-        contentType: shot.contentType,
-        width: shot.width,
-        height: shot.height
-      };
-    }
-    return { ...rest, screenshots: shown };
-  }
-  app.use("*", async (c, next) => {
-    const origin = c.req.header("origin");
-    const ownOrigin = new URL(c.req.url).origin;
-    const foreign = origin !== void 0 && origin !== ownOrigin;
-    if (foreign && !allowedOrigins.has(origin)) {
-      return fail(403, "origin_not_allowed", `requests from ${origin} are not allowed`);
-    }
-    if (foreign) {
-      c.header("access-control-allow-origin", origin);
-      c.header("access-control-allow-credentials", "true");
-      c.header("vary", "origin");
-      if (c.req.method === "OPTIONS") {
-        c.header("access-control-allow-methods", "GET, POST, PATCH, DELETE");
-        c.header("access-control-allow-headers", "authorization, content-type");
-        c.header("access-control-max-age", "86400");
-        return c.body(null, 204);
-      }
-    }
-    await next();
-  });
-  if (options.widgetScript !== void 0) {
-    const script = options.widgetScript;
-    let etag;
-    app.get("/widget.js", async (c) => {
-      etag ??= crypto.subtle.digest("SHA-256", new TextEncoder().encode(script)).then(
-        (hash) => `"${Array.from(new Uint8Array(hash).slice(0, 12), (b) => b.toString(16).padStart(2, "0")).join("")}"`
-      );
-      const tag = await etag;
-      c.header("etag", tag);
-      c.header("cache-control", "no-cache");
-      if (c.req.header("if-none-match") === tag) return c.body(null, 304);
-      c.header("content-type", "text/javascript; charset=utf-8");
-      return c.body(script);
-    });
-  }
-  app.use("*", async (c, next) => {
-    const who = await identify(options.auth, c.req.raw, c.env);
-    if (!who) {
-      const loginUrl = loginUrlFor(options.auth, c.req.raw);
-      return Response.json(
-        { error: { code: "unauthenticated", message: "sign in to use comments" }, loginUrl },
-        { status: 401 }
-      );
-    }
-    if (options.authorize && !await options.authorize(who, c.req.raw, c.env)) {
-      return fail(403, "forbidden", `${who.email ?? who.name} may not use comments here`);
-    }
-    const { store, ready } = storeFor(c.env);
-    await ready;
-    const seen = Date.now();
-    if (store.saveUser && seen - (lastSeen.get(who.id) ?? 0) > SEEN_EVERY_MS) {
-      lastSeen.set(who.id, seen);
-      background(c, store.saveUser(who, new Date(seen).toISOString()));
-    }
-    c.set("who", who);
-    c.set("site", options.site?.(c.req.raw, c.env) ?? "default");
-    c.set("store", store);
-    c.set("assets", options.assets?.(c.env) ?? null);
-    await next();
-  });
-  async function readJson(request) {
-    if (!request.headers.get("content-type")?.toLowerCase().startsWith("application/json")) {
-      throw new UnsupportedMedia("send the body as application/json");
-    }
-    const text = await request.text();
-    if (text.length > MAX_JSON_BYTES) throw new TooLarge();
-    return parseJson(text);
-  }
-  app.onError((error) => {
-    if (error instanceof NotConfigured) {
-      return fail(501, "not_configured", "this server keeps no screenshots");
-    }
-    if (error instanceof InvalidInput) return fail(400, "invalid_input", error.message);
-    if (error instanceof UnsupportedMedia) {
-      return fail(415, "unsupported_media_type", error.message);
-    }
-    if (error instanceof TooLarge) return fail(413, "too_large", "request body is too large");
-    console.error("web-comments:", error);
-    return Response.json(
-      { error: { code: "internal", message: "something went wrong" } },
-      { status: 500 }
-    );
-  });
-  app.get("/me", (c) => c.json({ me: c.var.who }));
-  app.get("/threads", async (c) => {
-    const page = c.req.query("page");
-    const threads = await c.var.store.listThreads(c.var.site, {
-      ...page === void 0 ? {} : { page },
-      limit: page === void 0 ? 200 : 500
-    });
-    return c.json({ threads: threads.map(present) });
-  });
-  app.get("/threads/:id", async (c) => {
-    const thread = await c.var.store.getThread(c.var.site, c.req.param("id"));
-    return thread ? c.json({ thread: present(thread) }) : fail(404, "not_found", "no such thread");
-  });
-  app.post("/threads", async (c) => {
-    const type = c.req.header("content-type")?.toLowerCase() ?? "";
-    let input;
-    const files = {};
-    if (type.startsWith("multipart/form-data")) {
-      const length = Number(c.req.header("content-length") ?? 0);
-      if (length > MAX_JSON_BYTES + 2 * maxScreenshotBytes) throw new TooLarge();
-      const form = await c.req.raw.formData();
-      const thread2 = form.get("thread");
-      if (typeof thread2 !== "string") throw new InvalidInput('missing the "thread" field');
-      if (thread2.length > MAX_JSON_BYTES) throw new TooLarge();
-      input = createThread(parseJson(thread2));
-      for (const kind of SCREENSHOT_KINDS) {
-        const file = form.get(kind);
-        if (file instanceof File) files[kind] = file;
-      }
-    } else {
-      input = createThread(await readJson(c.req.raw));
-    }
-    const time = now();
-    const author = authorOf(c.var.who);
-    const threadId = newId();
-    const screenshots = await saveScreenshots(c.var, threadId, files, input.screenshots);
-    const stored = {
-      id: threadId,
-      site: c.var.site,
-      page: input.page,
-      url: input.url,
-      anchor: input.anchor,
-      context: input.context ?? null,
-      screenshots,
-      status: "open",
-      author,
-      createdAt: time,
-      updatedAt: time,
-      resolvedAt: null,
-      resolvedBy: null,
-      comments: []
-    };
-    const first = { id: newId(), threadId, body: input.body, author, createdAt: time };
-    await c.var.store.insertThread(stored, first);
-    const thread = present({ ...stored, comments: [first] });
-    emit(c, { type: "thread.created", thread, actor: c.var.who });
-    return c.json({ thread }, 201);
-  });
-  async function saveScreenshots(vars, threadId, files, sizes) {
-    const saved = {};
-    const kinds = Object.keys(files);
-    if (kinds.length === 0) return saved;
-    if (!vars.assets) throw new NotConfigured();
-    for (const kind of kinds) {
-      const file = files[kind];
-      const extension = SCREENSHOT_TYPES[file.type];
-      if (!extension) throw new UnsupportedMedia("screenshots must be PNG, JPEG or WebP");
-      if (file.size > maxScreenshotBytes) throw new TooLarge();
-      const size2 = sizes[kind];
-      if (!size2) throw new InvalidInput(`screenshots.${kind} needs a width and height`);
-      const key = `${vars.site}/${threadId}/${kind}-${newId()}.${extension}`;
-      await vars.assets.put(key, await file.arrayBuffer(), file.type);
-      saved[kind] = { key, contentType: file.type, ...size2 };
-    }
-    return saved;
-  }
-  app.get("/assets/*", async (c) => {
-    if (!c.var.assets) return fail(404, "not_found", "no such screenshot");
-    const key = decodeURIComponent(c.req.path.slice(`${basePath}/assets/`.length));
-    if (!key.startsWith(`${c.var.site}/`) || key.includes("..")) {
-      return fail(404, "not_found", "no such screenshot");
-    }
-    const asset = await c.var.assets.get(key);
-    if (!asset) return fail(404, "not_found", "no such screenshot");
-    return new Response(asset.body, {
-      headers: {
-        "content-type": asset.contentType,
-        // Keys never change content; the API checks who's asking before serving.
-        "cache-control": "private, max-age=31536000, immutable"
-      }
-    });
-  });
-  app.post("/threads/:id/comments", async (c) => {
-    const body = reply(await readJson(c.req.raw));
-    const thread = await c.var.store.getThread(c.var.site, c.req.param("id"));
-    if (!thread) return fail(404, "not_found", "no such thread");
-    const time = now();
-    const comment = {
-      id: newId(),
-      threadId: thread.id,
-      body,
-      author: authorOf(c.var.who),
-      createdAt: time
-    };
-    await c.var.store.insertComment(c.var.site, comment);
-    await c.var.store.updateThread(c.var.site, thread.id, { updatedAt: time });
-    const updated = present({
-      ...thread,
-      updatedAt: time,
-      comments: [...thread.comments, comment]
-    });
-    emit(c, { type: "comment.created", thread: updated, comment, actor: c.var.who });
-    return c.json({ thread: updated, comment }, 201);
-  });
-  app.patch("/threads/:id", async (c) => {
-    const update = threadUpdate(await readJson(c.req.raw));
-    const before = await c.var.store.getThread(c.var.site, c.req.param("id"));
-    if (!before) return fail(404, "not_found", "no such thread");
-    if (update.anchor && before.author.id !== c.var.who.id) {
-      return fail(403, "forbidden", "only the author can move a comment");
-    }
-    const time = now();
-    const events = [];
-    const changes = {};
-    if (update.anchor) {
-      changes.anchor = update.anchor;
-      events.push("thread.moved");
-    }
-    if (update.status && update.status !== before.status) {
-      const resolved = update.status === "resolved";
-      changes.status = update.status;
-      changes.resolvedAt = resolved ? time : null;
-      changes.resolvedBy = resolved ? authorOf(c.var.who) : null;
-      events.push(resolved ? "thread.resolved" : "thread.reopened");
-    }
-    if (events.length === 0) return c.json({ thread: present(before) });
-    changes.updatedAt = time;
-    await c.var.store.updateThread(c.var.site, before.id, changes);
-    const thread = present({ ...before, ...changes });
-    for (const type of events) emit(c, { type, thread, actor: c.var.who });
-    return c.json({ thread });
-  });
-  app.delete("/comments/:id", async (c) => {
-    const commentId = c.req.param("id");
-    const comment = await c.var.store.getComment(c.var.site, commentId);
-    if (!comment) return fail(404, "not_found", "no such comment");
-    if (comment.author.id !== c.var.who.id) {
-      return fail(403, "forbidden", "only the author can delete a comment");
-    }
-    const thread = await c.var.store.getThread(c.var.site, comment.threadId);
-    if (!thread) return fail(404, "not_found", "no such comment");
-    if (thread.comments[0]?.id === commentId) {
-      await c.var.store.deleteThread(c.var.site, thread.id);
-      const assets = c.var.assets;
-      if (assets?.delete) {
-        const keys = Object.values(thread.screenshots).map((shot) => shot.key);
-        background(c, Promise.all(keys.map((key) => assets.delete?.(key))));
-      }
-      emit(c, { type: "thread.deleted", threadId: thread.id, actor: c.var.who });
-      return c.json({ deleted: "thread", threadId: thread.id });
-    }
-    await c.var.store.deleteComment(c.var.site, commentId);
-    emit(c, { type: "comment.deleted", threadId: thread.id, commentId, actor: c.var.who });
-    return c.json({ deleted: "comment", threadId: thread.id });
-  });
-  return {
-    app,
-    /** Answers requests under basePath; anything else gets a 404. */
-    fetch(request, env, ctx) {
-      return Promise.resolve(app.fetch(request, env, ctx));
-    },
-    /** Whether a request belongs to the comments API, to route it from a larger worker. */
-    matches(request) {
-      const { pathname } = new URL(request.url);
-      return pathname === basePath || pathname.startsWith(`${basePath}/`);
-    }
-  };
-}
-function parseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new InvalidInput("request body is not valid JSON");
-  }
-}
-var UnsupportedMedia = class extends Error {
-};
-var TooLarge = class extends Error {
-};
-var NotConfigured = class extends Error {
-};
 export {
+  CommentsError,
   createComments,
   newId
 };

package/dist/store/d1.js

@@ -1,9 +1,9 @@
 import {
   drizzleStore
-} from "../chunks/chunk-LBIURYPH.js";
-import "../chunks/chunk-6VWNCJ3A.js";
-import "../chunks/chunk-PLAC65HG.js";
-import "../chunks/chunk-GHNSLFY2.js";
+} from "../chunks/chunk-T4WN3STA.js";
+import "../chunks/chunk-7K7K7M5O.js";
+import "../chunks/chunk-WY5E2C47.js";
+import "../chunks/chunk-644PTNSO.js";
 import "../chunks/chunk-WSFCRVEQ.js";
 
 // src/store/d1.ts

package/dist/store/drizzle/mysql.js

@@ -1,13 +1,17 @@
 import {
   comments,
   createTablesSql,
+  links,
   threads,
-  users
-} from "../../chunks/chunk-PLAC65HG.js";
+  users,
+  values
+} from "../../chunks/chunk-WY5E2C47.js";
 import "../../chunks/chunk-WSFCRVEQ.js";
 export {
   comments,
   createTablesSql,
+  links,
   threads,
-  users
+  users,
+  values
 };

package/dist/store/drizzle/pg.js

@@ -1,13 +1,17 @@
 import {
   comments,
   createTablesSql,
+  links,
   threads,
-  users
-} from "../../chunks/chunk-6VWNCJ3A.js";
+  users,
+  values
+} from "../../chunks/chunk-7K7K7M5O.js";
 import "../../chunks/chunk-WSFCRVEQ.js";
 export {
   comments,
   createTablesSql,
+  links,
   threads,
-  users
+  users,
+  values
 };

package/dist/store/drizzle/sqlite.js

@@ -1,13 +1,17 @@
 import {
   comments,
   createTablesSql,
+  links,
   threads,
-  users
-} from "../../chunks/chunk-GHNSLFY2.js";
+  users,
+  values
+} from "../../chunks/chunk-644PTNSO.js";
 import "../../chunks/chunk-WSFCRVEQ.js";
 export {
   comments,
   createTablesSql,
+  links,
   threads,
-  users
+  users,
+  values
 };

package/dist/store/drizzle.js

@@ -1,9 +1,9 @@
 import {
   drizzleStore
-} from "../chunks/chunk-LBIURYPH.js";
-import "../chunks/chunk-6VWNCJ3A.js";
-import "../chunks/chunk-PLAC65HG.js";
-import "../chunks/chunk-GHNSLFY2.js";
+} from "../chunks/chunk-T4WN3STA.js";
+import "../chunks/chunk-7K7K7M5O.js";
+import "../chunks/chunk-WY5E2C47.js";
+import "../chunks/chunk-644PTNSO.js";
 import "../chunks/chunk-WSFCRVEQ.js";
 export {
   drizzleStore

package/dist/store/memory.js

@@ -4,6 +4,9 @@ import "../chunks/chunk-WSFCRVEQ.js";
 function memoryStore() {
   const threads = /* @__PURE__ */ new Map();
   const comments = /* @__PURE__ */ new Map();
+  const links = /* @__PURE__ */ new Map();
+  const values = /* @__PURE__ */ new Map();
+  const linkKey = (site, connector, externalId) => JSON.stringify([site, connector, externalId]);
   function withComments(thread) {
     const own = [...comments.values()].filter((c) => c.threadId === thread.id).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
     return structuredClone({ ...thread, comments: own });
@@ -50,6 +53,37 @@ function memoryStore() {
       if (!find(site, id)) return;
       threads.delete(id);
       for (const [key, comment] of comments) if (comment.threadId === id) comments.delete(key);
+      for (const [key, link] of links) {
+        if (link.site === site && link.threadId === id) links.delete(key);
+      }
+    },
+    async saveLink(site, link) {
+      links.set(linkKey(site, link.connector, link.externalId), { ...structuredClone(link), site });
+    },
+    async findLink(site, connector, externalId) {
+      const link = links.get(linkKey(site, connector, externalId));
+      if (!link) return null;
+      const { site: _, ...rest } = link;
+      return structuredClone(rest);
+    },
+    async listLinks(site, threadIds) {
+      const wanted = new Set(threadIds);
+      return [...links.values()].filter((link) => link.site === site && wanted.has(link.threadId)).map(({ site: _, ...rest }) => structuredClone(rest));
+    },
+    async getValue(name) {
+      const entry = values.get(name);
+      if (!entry) return null;
+      if (entry.expiresAt !== null && entry.expiresAt <= (/* @__PURE__ */ new Date()).toISOString()) {
+        values.delete(name);
+        return null;
+      }
+      return entry.value;
+    },
+    async setValue(name, value, expiresAt) {
+      values.set(name, { value, expiresAt });
+    },
+    async deleteValue(name) {
+      values.delete(name);
     }
   };
 }

package/dist/types/connectors/linear/index.d.ts

@@ -0,0 +1,46 @@
+import type { Connector, Thread } from "../../server";
+export interface LinearOptions {
+    /**
+     * How to call Linear:
+     * - `{ apiKey }`: a personal API key (lin_api_...). Issues and comments are
+     *   that person's; who said what is written into them.
+     * - `{ accessToken }`: an OAuth token.
+     * - `{ clientId, clientSecret }`: an OAuth app with client credentials
+     *   enabled. Issues and comments are the app's, shown under each
+     *   commenter's name and picture.
+     */
+    auth: {
+        apiKey: string;
+    } | {
+        accessToken: string;
+    } | {
+        clientId: string;
+        clientSecret: string;
+    };
+    /** The team new issues go to: its key ("ENG") or id. */
+    team: string;
+    /**
+     * The signing secret of a Linear webhook (Issues and Comments) pointed at
+     * `{basePath}/linear/webhook`. With it, Linear's side comes back: comments
+     * there become replies, and finishing or reopening the issue resolves or
+     * reopens the thread.
+     */
+    webhookSecret?: string;
+    /** Labels to put on new issues, by id. */
+    labelIds?: string[];
+    /** The project new issues go into, by id. */
+    projectId?: string;
+    /** Which threads become issues. All of them, by default. */
+    filter?: (thread: Thread) => boolean;
+    /** Linear's GraphQL endpoint; for tests. */
+    apiUrl?: string;
+}
+/**
+ * Every thread becomes a Linear issue, with its screenshots, and stays in
+ * step with it: replies go both ways, and resolving one resolves the other.
+ * Options can depend on the environment; returning null leaves Linear out
+ * of that one (say, until its secrets are set).
+ *
+ *   connectors: [linear((env) => ({ auth: { apiKey: env.LINEAR_API_KEY }, team: "ENG", webhookSecret: env.LINEAR_WEBHOOK_SECRET }))]
+ */
+export declare function linear<Env = unknown>(options: LinearOptions | ((env: Env) => LinearOptions | null)): Connector<Env>;