web-comments 0.0.1 → 1.0.0

package/dist/chunks/chunk-T4WN3STA.js

@@ -0,0 +1,239 @@
+import {
+  pg_exports
+} from "./chunk-7K7K7M5O.js";
+import {
+  mysql_exports
+} from "./chunk-WY5E2C47.js";
+import {
+  sqlite_exports
+} from "./chunk-644PTNSO.js";
+
+// src/store/drizzle/index.ts
+import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
+var SCHEMAS = { sqlite: sqlite_exports, pg: pg_exports, mysql: mysql_exports };
+var IN_CHUNK = 90;
+function drizzleStore(options) {
+  const { threads, comments, users, links, values, createTablesSql } = SCHEMAS[options.dialect];
+  const db = options.db;
+  async function together(build) {
+    if (typeof db.batch === "function") {
+      await db.batch(build(db));
+      return;
+    }
+    await db.transaction(async (tx) => {
+      for (const query of build(tx)) await query;
+    });
+  }
+  async function commentsOf(threadIds) {
+    const byThread = new Map(threadIds.map((id) => [id, []]));
+    for (let i = 0; i < threadIds.length; i += IN_CHUNK) {
+      const rows = await db.select().from(comments).where(inArray(comments.threadId, threadIds.slice(i, i + IN_CHUNK))).orderBy(asc(comments.createdAt), asc(comments.id));
+      for (const row of rows) byThread.get(row.threadId)?.push(toComment(row));
+    }
+    return byThread;
+  }
+  function upsert(table, row, target) {
+    const set = { ...row };
+    const insert = db.insert(table).values(row);
+    return options.dialect === "mysql" ? insert.onDuplicateKeyUpdate({ set }) : insert.onConflictDoUpdate({ target, set });
+  }
+  async function threadRows(site, id) {
+    const rows = await db.select().from(threads).where(and(eq(threads.site, site), eq(threads.id, id))).limit(1);
+    return rows[0];
+  }
+  return {
+    async setup() {
+      if (options.createTables === false) return;
+      for (const statement of createTablesSql) {
+        if (options.dialect === "sqlite") await db.run(sql.raw(statement));
+        else await db.execute(sql.raw(statement));
+      }
+    },
+    async listThreads(site, { page, limit }) {
+      const rows = await db.select().from(threads).where(
+        page === void 0 ? eq(threads.site, site) : and(eq(threads.site, site), eq(threads.page, page))
+      ).orderBy(page === void 0 ? desc(threads.createdAt) : asc(threads.createdAt)).limit(limit);
+      const byThread = await commentsOf(rows.map((row) => row.id));
+      return rows.map((row) => toThread(row, byThread.get(row.id) ?? []));
+    },
+    async getThread(site, id) {
+      const row = await threadRows(site, id);
+      if (!row) return null;
+      const byThread = await commentsOf([row.id]);
+      return toThread(row, byThread.get(row.id) ?? []);
+    },
+    async insertThread(thread, first) {
+      await together((on) => [
+        on.insert(threads).values(threadRow(thread)),
+        on.insert(comments).values(commentRow(first))
+      ]);
+    },
+    async insertComment(site, comment) {
+      if (!await threadRows(site, comment.threadId)) return;
+      await db.insert(comments).values(commentRow(comment));
+    },
+    async updateThread(site, id, changes) {
+      const set = changedColumns(changes);
+      if (Object.keys(set).length === 0) return;
+      await db.update(threads).set(set).where(and(eq(threads.site, site), eq(threads.id, id)));
+    },
+    async getComment(site, id) {
+      const rows = await db.select().from(comments).where(eq(comments.id, id)).limit(1);
+      const row = rows[0];
+      if (!row || !await threadRows(site, row.threadId)) return null;
+      return toComment(row);
+    },
+    async deleteComment(site, id) {
+      const comment = await this.getComment(site, id);
+      if (comment) await db.delete(comments).where(eq(comments.id, id));
+    },
+    async deleteThread(site, id) {
+      if (!await threadRows(site, id)) return;
+      await together((on) => [
+        on.delete(comments).where(eq(comments.threadId, id)),
+        on.delete(links).where(and(eq(links.site, site), eq(links.threadId, id))),
+        on.delete(threads).where(and(eq(threads.site, site), eq(threads.id, id)))
+      ]);
+    },
+    async saveUser(who, seenAt) {
+      const row = {
+        id: who.id,
+        name: who.name,
+        email: who.email ?? null,
+        avatarUrl: who.avatarUrl ?? null,
+        kind: who.kind,
+        lastSeenAt: seenAt
+      };
+      await upsert(users, row, [users.id]);
+    },
+    async saveLink(site, link) {
+      await upsert(links, { site, ...link }, [links.site, links.connector, links.externalId]);
+    },
+    async findLink(site, connector, externalId) {
+      const rows = await db.select().from(links).where(
+        and(
+          eq(links.site, site),
+          eq(links.connector, connector),
+          eq(links.externalId, externalId)
+        )
+      ).limit(1);
+      return rows[0] ? toLink(rows[0]) : null;
+    },
+    async listLinks(site, threadIds) {
+      const found = [];
+      for (let i = 0; i < threadIds.length; i += IN_CHUNK) {
+        const rows = await db.select().from(links).where(
+          and(eq(links.site, site), inArray(links.threadId, threadIds.slice(i, i + IN_CHUNK)))
+        ).orderBy(asc(links.createdAt));
+        found.push(...rows.map(toLink));
+      }
+      return found;
+    },
+    async getValue(name) {
+      const rows = await db.select({ value: values.value, expiresAt: values.expiresAt }).from(values).where(eq(values.name, name)).limit(1);
+      const row = rows[0];
+      if (!row) return null;
+      if (row.expiresAt !== null && row.expiresAt <= (/* @__PURE__ */ new Date()).toISOString()) {
+        await db.delete(values).where(eq(values.name, name));
+        return null;
+      }
+      return row.value;
+    },
+    async setValue(name, value, expiresAt) {
+      await upsert(values, { name, value, expiresAt }, [values.name]);
+    },
+    async deleteValue(name) {
+      await db.delete(values).where(eq(values.name, name));
+    }
+  };
+}
+function toLink(row) {
+  const { site: _, ...link } = row;
+  return link;
+}
+function json(value) {
+  return value === null ? null : JSON.parse(value);
+}
+function rowAuthor(row) {
+  return {
+    id: row.authorId,
+    name: row.authorName,
+    kind: row.authorKind,
+    ...row.authorAvatar ? { avatarUrl: row.authorAvatar } : {}
+  };
+}
+function toComment(row) {
+  return {
+    id: row.id,
+    threadId: row.threadId,
+    body: row.body,
+    author: rowAuthor(row),
+    createdAt: row.createdAt
+  };
+}
+function toThread(row, comments) {
+  return {
+    id: row.id,
+    site: row.site,
+    page: row.page,
+    url: row.url,
+    anchor: JSON.parse(row.anchor),
+    context: json(row.context),
+    screenshots: JSON.parse(row.screenshots),
+    status: row.status,
+    author: rowAuthor(row),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    resolvedAt: row.resolvedAt,
+    resolvedBy: json(row.resolvedBy),
+    comments
+  };
+}
+function threadRow(thread) {
+  return {
+    id: thread.id,
+    site: thread.site,
+    page: thread.page,
+    url: thread.url,
+    anchor: JSON.stringify(thread.anchor),
+    context: thread.context ? JSON.stringify(thread.context) : null,
+    screenshots: JSON.stringify(thread.screenshots),
+    status: thread.status,
+    authorId: thread.author.id,
+    authorName: thread.author.name,
+    authorAvatar: thread.author.avatarUrl ?? null,
+    authorKind: thread.author.kind,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    resolvedAt: thread.resolvedAt,
+    resolvedBy: thread.resolvedBy ? JSON.stringify(thread.resolvedBy) : null
+  };
+}
+function commentRow(comment) {
+  return {
+    id: comment.id,
+    threadId: comment.threadId,
+    body: comment.body,
+    authorId: comment.author.id,
+    authorName: comment.author.name,
+    authorAvatar: comment.author.avatarUrl ?? null,
+    authorKind: comment.author.kind,
+    createdAt: comment.createdAt
+  };
+}
+function changedColumns(changes) {
+  const set = {};
+  if (changes.status !== void 0) set.status = changes.status;
+  if (changes.anchor !== void 0) set.anchor = JSON.stringify(changes.anchor);
+  if (changes.screenshots !== void 0) set.screenshots = JSON.stringify(changes.screenshots);
+  if (changes.updatedAt !== void 0) set.updatedAt = changes.updatedAt;
+  if (changes.resolvedAt !== void 0) set.resolvedAt = changes.resolvedAt;
+  if (changes.resolvedBy !== void 0) {
+    set.resolvedBy = changes.resolvedBy ? JSON.stringify(changes.resolvedBy) : null;
+  }
+  return set;
+}
+
+export {
+  drizzleStore
+};

package/dist/chunks/chunk-WSFCRVEQ.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunks/chunk-WY5E2C47.js

@@ -0,0 +1,99 @@
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/store/drizzle/mysql.ts
+var mysql_exports = {};
+__export(mysql_exports, {
+  comments: () => comments,
+  createTablesSql: () => createTablesSql,
+  links: () => links,
+  threads: () => threads,
+  users: () => users,
+  values: () => values
+});
+import { index, mysqlTable, primaryKey, text, varchar } from "drizzle-orm/mysql-core";
+var id = (name) => varchar(name, { length: 64 });
+var threads = mysqlTable(
+  "wc_threads",
+  {
+    id: id("id").primaryKey(),
+    site: varchar("site", { length: 128 }).notNull(),
+    page: varchar("page", { length: 512 }).notNull(),
+    url: text("url").notNull(),
+    anchor: text("anchor").notNull(),
+    context: text("context"),
+    screenshots: text("screenshots").notNull(),
+    status: varchar("status", { length: 16 }).notNull(),
+    authorId: varchar("author_id", { length: 255 }).notNull(),
+    authorName: varchar("author_name", { length: 255 }).notNull(),
+    authorAvatar: text("author_avatar"),
+    authorKind: varchar("author_kind", { length: 16 }).notNull(),
+    createdAt: varchar("created_at", { length: 32 }).notNull(),
+    updatedAt: varchar("updated_at", { length: 32 }).notNull(),
+    resolvedAt: varchar("resolved_at", { length: 32 }),
+    resolvedBy: text("resolved_by")
+  },
+  (t) => [index("wc_threads_page").on(t.site, t.page, t.createdAt)]
+);
+var comments = mysqlTable(
+  "wc_comments",
+  {
+    id: id("id").primaryKey(),
+    threadId: id("thread_id").notNull(),
+    body: text("body").notNull(),
+    authorId: varchar("author_id", { length: 255 }).notNull(),
+    authorName: varchar("author_name", { length: 255 }).notNull(),
+    authorAvatar: text("author_avatar"),
+    authorKind: varchar("author_kind", { length: 16 }).notNull(),
+    createdAt: varchar("created_at", { length: 32 }).notNull()
+  },
+  (t) => [index("wc_comments_thread").on(t.threadId, t.createdAt)]
+);
+var users = mysqlTable("wc_users", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  name: varchar("name", { length: 255 }).notNull(),
+  email: varchar("email", { length: 320 }),
+  avatarUrl: text("avatar_url"),
+  kind: varchar("kind", { length: 16 }).notNull(),
+  lastSeenAt: varchar("last_seen_at", { length: 32 }).notNull()
+});
+var links = mysqlTable(
+  "wc_links",
+  {
+    site: varchar("site", { length: 128 }).notNull(),
+    connector: varchar("connector", { length: 64 }).notNull(),
+    externalId: varchar("external_id", { length: 255 }).notNull(),
+    threadId: id("thread_id").notNull(),
+    commentId: id("comment_id"),
+    url: text("url"),
+    title: varchar("title", { length: 255 }),
+    createdAt: varchar("created_at", { length: 32 }).notNull()
+  },
+  (t) => [
+    primaryKey({ columns: [t.site, t.connector, t.externalId] }),
+    index("wc_links_thread").on(t.site, t.threadId)
+  ]
+);
+var values = mysqlTable("wc_values", {
+  name: varchar("name", { length: 512 }).primaryKey(),
+  value: text("value").notNull(),
+  expiresAt: varchar("expires_at", { length: 32 })
+});
+var createTablesSql = [
+  `CREATE TABLE IF NOT EXISTS wc_threads (id VARCHAR(64) NOT NULL PRIMARY KEY, site VARCHAR(128) NOT NULL, page VARCHAR(512) NOT NULL, url TEXT NOT NULL, anchor TEXT NOT NULL, context TEXT, screenshots TEXT NOT NULL, status VARCHAR(16) NOT NULL, author_id VARCHAR(255) NOT NULL, author_name VARCHAR(255) NOT NULL, author_avatar TEXT, author_kind VARCHAR(16) NOT NULL, created_at VARCHAR(32) NOT NULL, updated_at VARCHAR(32) NOT NULL, resolved_at VARCHAR(32), resolved_by TEXT, KEY wc_threads_page (site, page, created_at)) DEFAULT CHARSET=utf8mb4`,
+  `CREATE TABLE IF NOT EXISTS wc_comments (id VARCHAR(64) NOT NULL PRIMARY KEY, thread_id VARCHAR(64) NOT NULL, body TEXT NOT NULL, author_id VARCHAR(255) NOT NULL, author_name VARCHAR(255) NOT NULL, author_avatar TEXT, author_kind VARCHAR(16) NOT NULL, created_at VARCHAR(32) NOT NULL, KEY wc_comments_thread (thread_id, created_at)) DEFAULT CHARSET=utf8mb4`,
+  `CREATE TABLE IF NOT EXISTS wc_users (id VARCHAR(255) NOT NULL PRIMARY KEY, name VARCHAR(255) NOT NULL, email VARCHAR(320), avatar_url TEXT, kind VARCHAR(16) NOT NULL, last_seen_at VARCHAR(32) NOT NULL) DEFAULT CHARSET=utf8mb4`,
+  `CREATE TABLE IF NOT EXISTS wc_links (site VARCHAR(128) NOT NULL, connector VARCHAR(64) NOT NULL, external_id VARCHAR(255) NOT NULL, thread_id VARCHAR(64) NOT NULL, comment_id VARCHAR(64), url TEXT, title VARCHAR(255), created_at VARCHAR(32) NOT NULL, PRIMARY KEY (site, connector, external_id), KEY wc_links_thread (site, thread_id)) DEFAULT CHARSET=utf8mb4`,
+  `CREATE TABLE IF NOT EXISTS wc_values (name VARCHAR(512) NOT NULL PRIMARY KEY, value TEXT NOT NULL, expires_at VARCHAR(32)) DEFAULT CHARSET=utf8mb4`
+];
+
+export {
+  threads,
+  comments,
+  users,
+  links,
+  values,
+  createTablesSql,
+  mysql_exports
+};

package/dist/connectors/linear.js

@@ -0,0 +1,318 @@
+import "../chunks/chunk-WSFCRVEQ.js";
+
+// src/connectors/linear/index.ts
+var API = "https://api.linear.app/graphql";
+var TOKEN_URL = "https://api.linear.app/oauth/token";
+var DAY = 24 * 60 * 60;
+var MAX_REPLY = 1e4;
+function linear(options) {
+  const optionsFor = (env) => typeof options === "function" ? options(env) : options;
+  return {
+    name: "linear",
+    async onEvent(event, context) {
+      const settings = optionsFor(context.env);
+      if (settings) await mirror(event, context, settings, client(context, settings));
+    },
+    async fetch(request, context) {
+      const { pathname } = new URL(request.url);
+      const settings = optionsFor(context.env);
+      if (!settings || pathname !== `${new URL(context.url).pathname}/webhook`) {
+        return Response.json({ error: "not_found" }, { status: 404 });
+      }
+      if (request.method !== "POST")
+        return new Response(null, { status: 405, headers: { allow: "POST" } });
+      return webhook(request, context, settings);
+    }
+  };
+}
+function client(context, options) {
+  const url = options.apiUrl ?? API;
+  return async function call(query, variables = {}, retried = false) {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: await authorization(context, options, retried)
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    if (response.status === 401 && "clientId" in options.auth && !retried) {
+      return call(
+        query,
+        variables,
+        true
+      );
+    }
+    const body = await response.json().catch(() => null);
+    if (!response.ok || !body?.data || body.errors?.length) {
+      const reason = body?.errors?.map((error) => error.message).join("; ") || `HTTP ${response.status}`;
+      throw new Error(`Linear: ${reason}`);
+    }
+    return body.data;
+  };
+}
+async function authorization(context, options, fresh) {
+  const { auth } = options;
+  if ("apiKey" in auth) return auth.apiKey;
+  if ("accessToken" in auth) return `Bearer ${auth.accessToken}`;
+  const cached = fresh ? null : await context.storage.get("app-token");
+  if (cached) return `Bearer ${cached}`;
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "content-type": "application/x-www-form-urlencoded",
+      authorization: `Basic ${btoa(`${auth.clientId}:${auth.clientSecret}`)}`
+    },
+    body: new URLSearchParams({
+      grant_type: "client_credentials",
+      scope: "read,write,issues:create,comments:create"
+    })
+  });
+  const body = await response.json().catch(() => null);
+  if (!response.ok || !body?.access_token) {
+    throw new Error(`Linear: couldn't get an app token (HTTP ${response.status})`);
+  }
+  const ttl = Math.max(60, (body.expires_in ?? 30 * DAY) - DAY);
+  await context.storage.set("app-token", body.access_token, { ttlSeconds: ttl });
+  return `Bearer ${body.access_token}`;
+}
+var actsAsApp = (options) => "clientId" in options.auth;
+async function teamOf(context, options, call) {
+  const key = `team:${options.team}`;
+  const cached = await context.storage.get(key);
+  if (cached) return JSON.parse(cached);
+  const isId = /^[0-9a-f-]{36}$/i.test(options.team);
+  const fields = "id states { nodes { id type position } }";
+  const found = isId ? (await call(`query($id: String!) { team(id: $id) { ${fields} } }`, {
+    id: options.team
+  })).team : (await call(
+    `query($key: String!) { teams(filter: { key: { eq: $key } }) { nodes { ${fields} } } }`,
+    { key: options.team }
+  )).teams.nodes[0];
+  if (!found) throw new Error(`Linear: no team ${options.team}`);
+  const first = (type) => found.states.nodes.filter((state) => state.type === type).sort((a, b) => a.position - b.position)[0]?.id ?? null;
+  const team = { id: found.id, completed: first("completed"), unstarted: first("unstarted") };
+  await context.storage.set(key, JSON.stringify(team), { ttlSeconds: DAY });
+  return team;
+}
+async function upload(context, call, thread, kind) {
+  const shot = await context.screenshot(thread, kind);
+  if (!shot) return null;
+  try {
+    const extension = shot.contentType.split("/")[1] ?? "png";
+    const { fileUpload } = await call(
+      `mutation($contentType: String!, $filename: String!, $size: Int!) {
+        fileUpload(contentType: $contentType, filename: $filename, size: $size) {
+          uploadFile { uploadUrl assetUrl headers { key value } }
+        }
+      }`,
+      {
+        contentType: shot.contentType,
+        filename: `${kind}.${extension}`,
+        size: shot.body.byteLength
+      }
+    );
+    const file = fileUpload.uploadFile;
+    if (!file) return null;
+    const headers = new Headers({
+      "content-type": shot.contentType,
+      "cache-control": "public, max-age=31536000"
+    });
+    for (const { key, value } of file.headers) headers.set(key, value);
+    const put = await fetch(file.uploadUrl, { method: "PUT", headers, body: shot.body });
+    return put.ok ? file.assetUrl : null;
+  } catch (error) {
+    console.error("web-comments: Linear upload failed", error);
+    return null;
+  }
+}
+function titleOf(body) {
+  const line = body.split("\n").find((l) => l.trim())?.trim() ?? "Comment";
+  if (line.length <= 80) return line;
+  const cut = line.slice(0, 79);
+  return `${cut.slice(0, Math.max(cut.lastIndexOf(" "), 60))}\u2026`;
+}
+function byline(comment) {
+  return `\u2014 ${comment.author.name}`;
+}
+function as(options, comment) {
+  if (!actsAsApp(options)) return {};
+  return {
+    createAsUser: comment.author.name,
+    ...comment.author.avatarUrl?.startsWith("https://") ? { displayIconUrl: comment.author.avatarUrl } : {}
+  };
+}
+async function describe(context, call, thread, options) {
+  const first = thread.comments[0];
+  const { anchor } = thread;
+  const where = thread.context?.page.title || thread.url;
+  const lines = [
+    first.body,
+    "",
+    actsAsApp(options) ? `On [${where}](${context.threadUrl(thread)})` : `${byline(first)}, on [${where}](${context.threadUrl(thread)})`,
+    "",
+    `**Element** \`<${anchor.tag}>\` \`${anchor.selector.replace(/`/g, "'")}\`${anchor.text ? ` \u201C${anchor.text}\u201D` : ""}`
+  ];
+  const [element, page] = await Promise.all([
+    upload(context, call, thread, "element"),
+    upload(context, call, thread, "page")
+  ]);
+  if (element) lines.push("", `![The element](${element})`);
+  if (page) lines.push("", `![The page](${page})`);
+  return lines.join("\n");
+}
+async function mirror(event, context, options, call) {
+  switch (event.type) {
+    case "thread.created": {
+      const { thread } = event;
+      if (options.filter && !options.filter(thread)) return;
+      const team = await teamOf(context, options, call);
+      const first = thread.comments[0];
+      const { issueCreate } = await call(
+        `mutation($input: IssueCreateInput!) { issueCreate(input: $input) { issue { id identifier url } } }`,
+        {
+          input: {
+            teamId: team.id,
+            title: titleOf(first.body),
+            description: await describe(context, call, thread, options),
+            ...options.labelIds?.length ? { labelIds: options.labelIds } : {},
+            ...options.projectId ? { projectId: options.projectId } : {},
+            ...as(options, first)
+          }
+        }
+      );
+      const { issue } = issueCreate;
+      await context.links.save({
+        externalId: issue.id,
+        threadId: thread.id,
+        url: issue.url,
+        title: issue.identifier
+      });
+      return;
+    }
+    case "comment.created": {
+      const issue = await issueOf(context, event.thread.id);
+      if (!issue) return;
+      const { comment } = event;
+      const id = crypto.randomUUID();
+      await context.links.save({
+        externalId: id,
+        threadId: event.thread.id,
+        commentId: comment.id
+      });
+      await call(
+        `mutation($input: CommentCreateInput!) { commentCreate(input: $input) { success } }`,
+        {
+          input: {
+            id,
+            issueId: issue,
+            body: actsAsApp(options) ? comment.body : `${comment.body}
+
+${byline(comment)}`,
+            ...as(options, comment)
+          }
+        }
+      );
+      return;
+    }
+    case "thread.resolved":
+    case "thread.reopened": {
+      const issue = await issueOf(context, event.thread.id);
+      if (!issue) return;
+      const team = await teamOf(context, options, call);
+      const stateId = event.type === "thread.resolved" ? team.completed : team.unstarted;
+      if (!stateId) return;
+      await call(
+        `mutation($id: String!, $stateId: String!) { issueUpdate(id: $id, input: { stateId: $stateId }) { success } }`,
+        {
+          id: issue,
+          stateId
+        }
+      );
+      return;
+    }
+    case "comment.deleted": {
+      const links = await context.links.forThread(event.threadId);
+      const mirrored = links.find((link) => link.commentId === event.commentId);
+      if (!mirrored) return;
+      await call(`mutation($id: String!) { commentDelete(id: $id) { success } }`, {
+        id: mirrored.externalId
+      });
+      return;
+    }
+    default:
+      return;
+  }
+}
+async function issueOf(context, threadId) {
+  const links = await context.links.forThread(threadId);
+  return links.find((link) => link.commentId === null && link.url)?.externalId ?? null;
+}
+async function verified(request, secret) {
+  const signature = request.headers.get("linear-signature") ?? "";
+  const body = await request.text();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["verify"]
+  );
+  const bytes = signature.match(/^[0-9a-f]{64}$/i)?.[0].match(/../g)?.map((hex) => Number.parseInt(hex, 16));
+  if (!bytes) return null;
+  const ok = await crypto.subtle.verify(
+    "HMAC",
+    key,
+    new Uint8Array(bytes),
+    new TextEncoder().encode(body)
+  );
+  return ok ? body : null;
+}
+async function webhook(request, context, options) {
+  if (!options.webhookSecret)
+    return Response.json({ error: "no webhook secret configured" }, { status: 404 });
+  const body = await verified(request, options.webhookSecret);
+  if (body === null) return Response.json({ error: "bad signature" }, { status: 401 });
+  const payload = JSON.parse(body);
+  if (Math.abs(Date.now() - payload.webhookTimestamp) > 6e4) {
+    return Response.json({ error: "stale webhook" }, { status: 401 });
+  }
+  context.waitUntil(receive(payload, context));
+  return new Response(null, { status: 200 });
+}
+function personOf(actor) {
+  return {
+    id: `linear:${actor?.id ?? "unknown"}`,
+    name: actor?.name ?? "Someone in Linear",
+    kind: actor?.type === "user" || actor?.type === void 0 ? "human" : "agent",
+    ...actor?.avatarUrl ? { avatarUrl: actor.avatarUrl } : {}
+  };
+}
+async function receive(payload, context) {
+  const { data } = payload;
+  if (payload.type === "Comment" && payload.action === "create") {
+    const id = String(data.id ?? "");
+    if (!id || await context.links.find(id)) return;
+    const issue = await context.links.find(String(data.issueId ?? ""));
+    if (!issue) return;
+    const text = String(data.body ?? "").trim().slice(0, MAX_REPLY);
+    if (!text) return;
+    const { comment } = await context.as(personOf(payload.actor)).reply(issue.threadId, text);
+    await context.links.save({ externalId: id, threadId: issue.threadId, commentId: comment.id });
+    return;
+  }
+  if (payload.type === "Issue" && payload.action === "update" && payload.updatedFrom && "stateId" in payload.updatedFrom) {
+    const issue = await context.links.find(String(data.id ?? ""));
+    if (!issue) return;
+    const state = data.state;
+    const done = state?.type === "completed" || state?.type === "canceled";
+    const actions = context.as(personOf(payload.actor));
+    const thread = await actions.getThread(issue.threadId);
+    if (!thread) return;
+    if (done && thread.status === "open") await actions.setStatus(thread.id, "resolved");
+    if (!done && thread.status === "resolved") await actions.setStatus(thread.id, "open");
+  }
+}
+export {
+  linear
+};