@sideboard-ai/core 0.1.324 → 0.1.326

package/dist/chunk-SO7G6O24.js

@@ -0,0 +1,1445 @@
+import {
+  downloadAuthenticatedFile,
+  extractHttpUrls,
+  hostMatches,
+  issueAttachmentWorktreePath,
+  looksLikeHttpUrl,
+  mergeIssueAttachments
+} from "./chunk-DBKHL7NC.js";
+import {
+  previewIssueCommentBody
+} from "./chunk-W3ZLE4PO.js";
+import {
+  httpFetch
+} from "./chunk-JAT3JFOS.js";
+import {
+  disconnectLinearConnection,
+  loadAppSettings,
+  saveLinearOAuth
+} from "./chunk-QPSKQP6E.js";
+
+// src/integrations/linear-oauth.ts
+import { createHash, randomBytes } from "crypto";
+import { createServer } from "http";
+
+// src/integrations/linear-app.ts
+var BAKED_LINEAR_CLIENT_ID = "39a15abc7ea5bea17c47f47f85ff5fd0";
+function hasBakedLinearOAuth() {
+  return Boolean(BAKED_LINEAR_CLIENT_ID.trim());
+}
+
+// src/integrations/linear-oauth.ts
+var LINEAR_OAUTH_PORT = 19848;
+var LINEAR_OAUTH_REDIRECT = `http://127.0.0.1:${LINEAR_OAUTH_PORT}/callback`;
+var LINEAR_AUTHORIZE = "https://linear.app/oauth/authorize";
+var LINEAR_TOKEN = "https://api.linear.app/oauth/token";
+var LINEAR_REVOKE = "https://api.linear.app/oauth/revoke";
+var LINEAR_GRAPHQL = "https://api.linear.app/graphql";
+var LINEAR_OAUTH_SCOPES = "read,write";
+var REFRESH_SKEW_MS = 5 * 6e4;
+function linearOAuthCredentials() {
+  const settings = loadAppSettings();
+  const clientId = process.env.SIDEBOARD_LINEAR_CLIENT_ID?.trim() || settings.integrations.linearClientId?.trim() || BAKED_LINEAR_CLIENT_ID.trim();
+  const clientSecret = process.env.SIDEBOARD_LINEAR_CLIENT_SECRET?.trim() || settings.integrations.linearClientSecret?.trim() || "";
+  if (!clientId) {
+    throw new Error(
+      `Linear browser sign-in needs a Linear OAuth app Client ID. Create one at linear.app/settings/api/applications/new with callback ${LINEAR_OAUTH_REDIRECT}, then set SIDEBOARD_LINEAR_CLIENT_ID (PKCE does not require a secret). You can still paste a personal API key.`
+    );
+  }
+  return { clientId, clientSecret };
+}
+function createLinearPkce() {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function linearOAuthAuthorizeUrl(clientId, state, codeChallenge) {
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: LINEAR_OAUTH_REDIRECT,
+    response_type: "code",
+    scope: LINEAR_OAUTH_SCOPES,
+    state,
+    prompt: "consent",
+    actor: "user",
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  });
+  return `${LINEAR_AUTHORIZE}?${params.toString()}`;
+}
+function linearAuthorizationHeader(token) {
+  const t = token.trim();
+  if (!t) return t;
+  if (/^bearer\s+/i.test(t)) return t;
+  if (t.startsWith("lin_api_")) return t;
+  return `Bearer ${t}`;
+}
+function htmlPage(title, body) {
+  return `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title>
+<style>body{font-family:ui-sans-serif,system-ui,sans-serif;padding:48px 24px;max-width:36rem;margin:0 auto;color:#1a1a1a}
+h1{font-size:1.25rem}p{line-height:1.5;color:#444}</style></head><body>${body}</body></html>`;
+}
+async function exchangeLinearToken(body) {
+  const res = await httpFetch(LINEAR_TOKEN, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || data.error || !data.access_token?.trim()) {
+    const detail = data.error_description || data.error || `HTTP ${res.status}`;
+    throw new Error(`Linear OAuth token exchange failed: ${detail}`);
+  }
+  return data;
+}
+async function persistLinearTokens(data, viewer) {
+  return saveLinearOAuth({
+    accessToken: data.access_token.trim(),
+    refreshToken: data.refresh_token?.trim(),
+    expiresIn: data.expires_in,
+    viewerName: viewer?.name,
+    organizationName: viewer?.organizationName
+  });
+}
+async function fetchLinearViewer(accessToken) {
+  const res = await httpFetch(LINEAR_GRAPHQL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: linearAuthorizationHeader(accessToken)
+    },
+    body: JSON.stringify({
+      query: "{ viewer { name organization { name } } }"
+    })
+  });
+  if (!res.ok) return {};
+  const json = await res.json().catch(() => ({}));
+  const viewer = json.data?.viewer;
+  return {
+    name: viewer?.name?.trim() || void 0,
+    organizationName: viewer?.organization?.name?.trim() || void 0
+  };
+}
+var refreshInFlight = null;
+async function refreshLinearAccessToken(refreshToken) {
+  const { clientId, clientSecret } = linearOAuthCredentials();
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: clientId
+  });
+  if (clientSecret) body.set("client_secret", clientSecret);
+  try {
+    const data = await exchangeLinearToken(body);
+    await persistLinearTokens(data);
+    return data.access_token.trim();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/invalid_grant|invalid_token|unauthorized/i.test(message)) {
+      disconnectLinearConnection();
+      throw new Error("Linear sign-in expired \u2014 connect again in Account settings");
+    }
+    throw err;
+  }
+}
+async function getLinearAuthToken(settings = loadAppSettings()) {
+  const access = settings.integrations.linearAccessToken?.trim() || "";
+  const refresh = settings.integrations.linearRefreshToken?.trim() || "";
+  const expiresAt = settings.integrations.linearTokenExpiresAt ?? 0;
+  const apiKey = settings.integrations.linearApiKey?.trim() || "";
+  if (access && (!refresh || Date.now() < expiresAt - REFRESH_SKEW_MS)) {
+    return access;
+  }
+  if (refresh) {
+    if (!refreshInFlight) {
+      refreshInFlight = refreshLinearAccessToken(refresh).finally(() => {
+        refreshInFlight = null;
+      });
+    }
+    return refreshInFlight.catch((err) => {
+      if (apiKey) return apiKey;
+      throw err;
+    });
+  }
+  return apiKey || null;
+}
+var LINEAR_OAUTH_CANCELLED = "Linear sign-in cancelled";
+var LinearOAuthCancelledError = class extends Error {
+  constructor(message = LINEAR_OAUTH_CANCELLED) {
+    super(message);
+    this.name = "LinearOAuthCancelledError";
+  }
+};
+function isLinearOAuthCancelled(err) {
+  if (err instanceof LinearOAuthCancelledError) return true;
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.includes(LINEAR_OAUTH_CANCELLED)) return true;
+  return err instanceof Error && err.name === "LinearOAuthCancelledError";
+}
+async function startLinearOAuth(opts) {
+  if (opts?.signal?.aborted) {
+    throw new LinearOAuthCancelledError();
+  }
+  const { clientId, clientSecret } = linearOAuthCredentials();
+  const state = randomBytes(16).toString("hex");
+  const pkce = createLinearPkce();
+  const authorizeUrl = linearOAuthAuthorizeUrl(clientId, state, pkce.challenge);
+  const timeoutMs = opts?.timeoutMs ?? 5 * 6e4;
+  const code = await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (err, value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (err) reject(err);
+      else resolve(value);
+    };
+    const server = createServer((req, res) => {
+      try {
+        const url = new URL(req.url || "/", `http://127.0.0.1:${LINEAR_OAUTH_PORT}`);
+        if (url.pathname !== "/callback") {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const err = url.searchParams.get("error");
+        const gotState = url.searchParams.get("state");
+        const gotCode = url.searchParams.get("code");
+        if (err) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(htmlPage("Linear", `<h1>Authorization cancelled</h1><p>${err}</p>`));
+          finish(new LinearOAuthCancelledError(`Linear OAuth: ${err}`));
+          return;
+        }
+        if (gotState !== state || !gotCode) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(htmlPage("Linear", "<h1>Invalid callback</h1><p>State or code missing.</p>"));
+          finish(new Error("Linear OAuth callback was invalid"));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          htmlPage(
+            "Linear connected",
+            "<h1>Linear connected</h1><p>You can close this tab and return to Sideboard.</p>"
+          )
+        );
+        finish(void 0, gotCode);
+      } catch (e) {
+        finish(e instanceof Error ? e : new Error(String(e)));
+      }
+    });
+    const timer = setTimeout(() => {
+      finish(new Error("Linear sign-in timed out \u2014 try again"));
+    }, timeoutMs);
+    const onAbort = () => finish(new LinearOAuthCancelledError());
+    const cleanup = () => {
+      clearTimeout(timer);
+      opts?.signal?.removeEventListener("abort", onAbort);
+      server.close();
+    };
+    opts?.signal?.addEventListener("abort", onAbort, { once: true });
+    if (opts?.signal?.aborted) {
+      onAbort();
+      return;
+    }
+    server.on("error", (e) => {
+      finish(
+        e instanceof Error && e.code === "EADDRINUSE" ? new Error(
+          `Port ${LINEAR_OAUTH_PORT} is in use. Close whatever is bound there, or paste a Linear API key instead.`
+        ) : e instanceof Error ? e : new Error(String(e))
+      );
+    });
+    server.listen(LINEAR_OAUTH_PORT, "127.0.0.1", () => {
+      void Promise.resolve(opts?.openUrl?.(authorizeUrl)).catch((e) => {
+        finish(e instanceof Error ? e : new Error(String(e)));
+      });
+    });
+  });
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: LINEAR_OAUTH_REDIRECT,
+    client_id: clientId,
+    code_verifier: pkce.verifier
+  });
+  if (clientSecret) body.set("client_secret", clientSecret);
+  const data = await exchangeLinearToken(body);
+  const viewer = await fetchLinearViewer(data.access_token.trim()).catch(() => ({}));
+  return persistLinearTokens(data, viewer);
+}
+async function revokeLinearToken(token, tokenTypeHint) {
+  const body = new URLSearchParams({
+    token,
+    token_type_hint: tokenTypeHint
+  });
+  await httpFetch(LINEAR_REVOKE, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  }).catch(() => void 0);
+}
+async function disconnectLinear() {
+  const settings = loadAppSettings();
+  const access = settings.integrations.linearAccessToken?.trim();
+  const refresh = settings.integrations.linearRefreshToken?.trim();
+  if (access) await revokeLinearToken(access, "access_token");
+  if (refresh) await revokeLinearToken(refresh, "refresh_token");
+  return disconnectLinearConnection();
+}
+
+// src/integrations/linear-attachments.ts
+var LINEAR_GRAPHQL2 = "https://api.linear.app/graphql";
+var LINEAR_FILE_HOSTS = ["linear.app", "uploads.linear.app", "linearusercontent.com"];
+var LINEAR_LINK_SOURCE_TYPES = /* @__PURE__ */ new Set([
+  "github",
+  "githubPullRequest",
+  "gitlab",
+  "figma",
+  "slack",
+  "sentry",
+  "zendesk",
+  "intercom",
+  "front"
+]);
+var ATTACHMENT_QUERY = `
+query SideboardAttachment($id: String!) {
+  attachment(id: $id) {
+    id
+    title
+    url
+    subtitle
+    sourceType
+  }
+}
+`;
+function mapLinearAttachments(node) {
+  const listed = [];
+  for (const attachment of node.attachments?.nodes ?? []) {
+    const id = String(attachment.id ?? "");
+    const url = String(attachment.url ?? "").trim();
+    if (!id && !url) continue;
+    listed.push({
+      id,
+      title: String(attachment.title ?? ""),
+      url,
+      subtitle: attachment.subtitle?.trim() || void 0,
+      sourceType: attachment.sourceType?.trim() || void 0
+    });
+  }
+  const embedded = [
+    ...extractHttpUrls(node.description).filter((url) => hostMatches(url, LINEAR_FILE_HOSTS)),
+    ...(node.comments?.nodes ?? []).flatMap(
+      (comment) => extractHttpUrls(comment.body).filter((url) => hostMatches(url, LINEAR_FILE_HOSTS))
+    )
+  ];
+  const merged = mergeIssueAttachments([
+    ...listed.map((item) => ({
+      id: item.id,
+      name: item.title || item.subtitle || "attachment",
+      url: item.url,
+      sourceType: item.sourceType
+    })),
+    ...embedded.map((url) => ({
+      id: url,
+      name: url.split("/").pop() || "image",
+      url,
+      sourceType: "upload"
+    }))
+  ]);
+  const byUrl = new Map(listed.map((item) => [item.url, item]));
+  return merged.map((item) => {
+    const prior = byUrl.get(item.url);
+    return {
+      id: prior?.id || item.id,
+      title: prior?.title || item.name,
+      url: item.url,
+      subtitle: prior?.subtitle,
+      sourceType: prior?.sourceType || item.sourceType
+    };
+  });
+}
+function assertLinearFileUrl(url, sourceType) {
+  const kind = sourceType?.trim();
+  if (kind && LINEAR_LINK_SOURCE_TYPES.has(kind)) {
+    throw new Error(
+      `Linear attachment is a ${kind} link, not a file. Open the URL in the browser instead of downloading it.`
+    );
+  }
+  if (!hostMatches(url, LINEAR_FILE_HOSTS)) {
+    throw new Error(
+      `Linear attachment URL is not a Linear upload (${url}). Only uploads.linear.app / linear.app file hosts can be downloaded with the Linear token.`
+    );
+  }
+}
+async function requireLinearToken(apiKey) {
+  const token = (apiKey ?? await getLinearAuthToken())?.trim();
+  if (!token) {
+    throw new Error("Linear is not connected \u2014 sign in from Account settings");
+  }
+  return token;
+}
+async function downloadLinearAttachment(input, opts) {
+  const id = input.id.trim();
+  if (!id) throw new Error("Linear attachment id or URL is required");
+  const apiKey = await requireLinearToken(opts?.apiKey);
+  let url = id;
+  let name = input.name?.trim();
+  let sourceType;
+  if (!looksLikeHttpUrl(id)) {
+    const res = await httpFetch(LINEAR_GRAPHQL2, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: linearAuthorizationHeader(apiKey)
+      },
+      body: JSON.stringify({ query: ATTACHMENT_QUERY, variables: { id } })
+    });
+    if (!res.ok) {
+      throw new Error(`Linear API error ${res.status} looking up attachment ${id}`);
+    }
+    const json = await res.json();
+    if (json.errors?.length) {
+      throw new Error(json.errors.map((e) => e.message ?? "Linear error").join("; "));
+    }
+    const attachment = json.data?.attachment;
+    if (!attachment?.url?.trim()) {
+      throw new Error(`Linear attachment not found: ${id}`);
+    }
+    url = attachment.url.trim();
+    name = name || attachment.title?.trim() || attachment.subtitle?.trim() || void 0;
+    sourceType = attachment.sourceType?.trim() || void 0;
+  }
+  assertLinearFileUrl(url, sourceType);
+  return downloadAuthenticatedFile({
+    url,
+    headers: { Authorization: linearAuthorizationHeader(apiKey) },
+    worktreePath: issueAttachmentWorktreePath(opts?.destPath),
+    name
+  });
+}
+
+// src/integrations/linear.ts
+var LINEAR_GRAPHQL3 = "https://api.linear.app/graphql";
+var LIST_ISSUE_FIELDS = `
+  id
+  identifier
+  title
+  url
+  createdAt
+  updatedAt
+  assignee { id name }
+  team { id key }
+  labels(first: 10) { nodes { name } }
+  cycle { id name number startsAt endsAt completedAt }
+  project { id name }
+`;
+var ISSUE_REF_FIELDS = `
+  id
+  identifier
+  title
+  url
+`;
+var ISSUE_FIELDS = `
+  id
+  identifier
+  title
+  description
+  url
+  priority
+  estimate
+  dueDate
+  branchName
+  createdAt
+  updatedAt
+  completedAt
+  state { id name type }
+  assignee { id name }
+  creator { id name }
+  team { id key name }
+  labels(first: 50) { nodes { name } }
+  cycle { id name number startsAt endsAt completedAt }
+  project { id name }
+  parent { ${ISSUE_REF_FIELDS} }
+  children(first: 25) { nodes { ${ISSUE_REF_FIELDS} } }
+  relations(first: 25) {
+    nodes {
+      id
+      type
+      relatedIssue { ${ISSUE_REF_FIELDS} }
+    }
+  }
+  inverseRelations(first: 25) {
+    nodes {
+      id
+      type
+      issue { ${ISSUE_REF_FIELDS} }
+    }
+  }
+  comments(first: 50) {
+    nodes {
+      id
+      body
+      url
+      createdAt
+      updatedAt
+      user { id name }
+    }
+  }
+  attachments(first: 20) {
+    nodes { id title url subtitle sourceType }
+  }
+`;
+var ASSIGNED_ISSUES_QUERY = `
+query SideboardAssignedIssues($first: Int!, $filter: IssueFilter) {
+  viewer {
+    id
+    name
+    assignedIssues(
+      first: $first
+      orderBy: updatedAt
+      filter: $filter
+    ) {
+      nodes { ${LIST_ISSUE_FIELDS} }
+    }
+  }
+}
+`;
+var COMMENTS_SINCE_QUERY = `
+query SideboardCommentsSince($first: Int!, $filter: CommentFilter) {
+  viewer { id name }
+  comments(first: $first, orderBy: createdAt, filter: $filter) {
+    nodes {
+      id
+      body
+      url
+      createdAt
+      user { id name }
+      issue { identifier title url }
+    }
+  }
+}
+`;
+var ISSUES_QUERY = `
+query SideboardIssues($first: Int!, $filter: IssueFilter) {
+  viewer { id name }
+  issues(first: $first, orderBy: updatedAt, filter: $filter) {
+    nodes { ${LIST_ISSUE_FIELDS} }
+  }
+}
+`;
+var SEARCH_ISSUES_QUERY = `
+query SideboardSearchIssues($term: String!, $first: Int!, $filter: IssueFilter) {
+  viewer { id name }
+  searchIssues(term: $term, first: $first, includeArchived: false, filter: $filter) {
+    nodes { ${LIST_ISSUE_FIELDS} }
+  }
+}
+`;
+var TEAMS_QUERY = `
+query SideboardTeams {
+  viewer { id name }
+  teams(first: 50) {
+    nodes {
+      id
+      key
+      name
+      states(first: 50) { nodes { id name type } }
+      activeCycle { id name number startsAt endsAt completedAt }
+    }
+  }
+}
+`;
+var TEAM_CYCLES_QUERY = `
+query SideboardTeamCycles($id: String!) {
+  team(id: $id) {
+    id
+    key
+    activeCycle { id name number startsAt endsAt completedAt }
+    cycles(first: 40) {
+      nodes { id name number startsAt endsAt completedAt }
+    }
+  }
+}
+`;
+var ISSUE_QUERY = `
+query SideboardIssue($id: String!) {
+  issue(id: $id) { ${ISSUE_FIELDS} }
+}
+`;
+var ISSUE_CREATE = `
+mutation SideboardIssueCreate($input: IssueCreateInput!) {
+  issueCreate(input: $input) {
+    success
+    issue { ${ISSUE_FIELDS} }
+  }
+}
+`;
+var ISSUE_UPDATE = `
+mutation SideboardIssueUpdate($id: String!, $input: IssueUpdateInput!) {
+  issueUpdate(id: $id, input: $input) {
+    success
+    issue { ${ISSUE_FIELDS} }
+  }
+}
+`;
+var COMMENT_CREATE = `
+mutation SideboardCommentCreate($input: CommentCreateInput!) {
+  commentCreate(input: $input) {
+    success
+    comment { id body url }
+  }
+}
+`;
+var LABELS_QUERY = `
+query SideboardLabels($first: Int!) {
+  issueLabels(first: $first) {
+    nodes { id name }
+  }
+}
+`;
+var TEAM_LABELS_QUERY = `
+query SideboardTeamLabels($id: String!, $first: Int!, $after: String) {
+  team(id: $id) {
+    labels(first: $first, after: $after) {
+      nodes { id name }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+}
+`;
+var PROJECTS_QUERY = `
+query SideboardProjects($first: Int!, $filter: ProjectFilter, $after: String) {
+  projects(first: $first, filter: $filter, after: $after) {
+    nodes { id name slugId }
+    pageInfo { hasNextPage endCursor }
+  }
+}
+`;
+var ISSUE_RELATION_CREATE = `
+mutation SideboardIssueRelationCreate($input: IssueRelationCreateInput!) {
+  issueRelationCreate(input: $input) {
+    success
+    issueRelation { id type }
+  }
+}
+`;
+var ISSUE_RELATION_DELETE = `
+mutation SideboardIssueRelationDelete($id: String!) {
+  issueRelationDelete(id: $id) {
+    success
+  }
+}
+`;
+function rewriteLinearError(message) {
+  if (/scope|permission|not (authorized|allowed)|unauthorized|insufficient/i.test(message)) {
+    return `${message} \u2014 Disconnect and Connect Linear in Account settings to grant write access.`;
+  }
+  return message;
+}
+async function requireLinearToken2(apiKey) {
+  const token = (apiKey ?? await getLinearAuthToken())?.trim();
+  if (!token) {
+    throw new Error("Linear is not connected \u2014 sign in from Account settings");
+  }
+  return token;
+}
+async function linearGraphql(query, variables, opts) {
+  const apiKey = await requireLinearToken2(opts?.apiKey);
+  const res = await httpFetch(LINEAR_GRAPHQL3, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: linearAuthorizationHeader(apiKey)
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      rewriteLinearError(
+        `Linear API error ${res.status}${body ? `: ${body.slice(0, 200)}` : ""}`
+      )
+    );
+  }
+  const json = await res.json();
+  if (json.errors?.length) {
+    throw new Error(
+      rewriteLinearError(json.errors.map((e) => e.message ?? "Linear error").join("; "))
+    );
+  }
+  if (json.data == null) {
+    throw new Error("Linear API returned no data");
+  }
+  return json.data;
+}
+function mapState(node) {
+  if (!node?.id) return void 0;
+  return {
+    id: String(node.id),
+    name: String(node.name ?? ""),
+    type: String(node.type ?? "")
+  };
+}
+function linearCycleIsActive(cycle, now = Date.now()) {
+  if (!cycle) return false;
+  if (cycle.completedAt) return false;
+  const start = cycle.startsAt ? Date.parse(cycle.startsAt) : Number.NaN;
+  const end = cycle.endsAt ? Date.parse(cycle.endsAt) : Number.NaN;
+  if (Number.isFinite(start) && now < start) return false;
+  if (Number.isFinite(end) && now > end) return false;
+  return true;
+}
+function cycleDisplayName(node) {
+  return String(node?.name ?? (node?.number != null ? `Cycle ${node.number}` : "")).trim();
+}
+function mapNamedCycle(node) {
+  if (!node?.id) return null;
+  const name = cycleDisplayName(node);
+  if (!name) return null;
+  return {
+    id: String(node.id),
+    name,
+    number: typeof node.number === "number" ? node.number : void 0,
+    isActive: linearCycleIsActive(node)
+  };
+}
+function mapCycle(node) {
+  if (!node?.name && node?.number == null) return null;
+  const name = cycleDisplayName(node);
+  if (!name) return null;
+  return {
+    ...node.id ? { id: String(node.id) } : {},
+    name,
+    number: typeof node.number === "number" ? node.number : void 0,
+    isActive: linearCycleIsActive(node)
+  };
+}
+function mapUser(node) {
+  if (!node?.id && !node?.name) return void 0;
+  return {
+    id: String(node.id ?? ""),
+    name: String(node.name ?? "")
+  };
+}
+function mapIssueRef(node) {
+  if (!node?.id && !node?.identifier) return void 0;
+  return {
+    id: String(node.id ?? node.identifier ?? ""),
+    identifier: String(node.identifier ?? node.id ?? ""),
+    title: String(node.title ?? ""),
+    url: String(node.url ?? "")
+  };
+}
+function flipLinearRelationType(type) {
+  switch (type) {
+    case "blocks":
+      return "blockedBy";
+    case "blockedBy":
+      return "blocks";
+    case "duplicate":
+      return "duplicateOf";
+    case "duplicateOf":
+      return "duplicate";
+    default:
+      return type;
+  }
+}
+function mapRelations(node) {
+  const out = [];
+  for (const rel of node.relations?.nodes ?? []) {
+    const issue = mapIssueRef(rel.relatedIssue);
+    if (!issue) continue;
+    const id = rel.id?.trim();
+    out.push({ type: String(rel.type ?? "related"), issue, ...id ? { id } : {} });
+  }
+  for (const rel of node.inverseRelations?.nodes ?? []) {
+    const issue = mapIssueRef(rel.issue);
+    if (!issue) continue;
+    const id = rel.id?.trim();
+    out.push({
+      type: flipLinearRelationType(String(rel.type ?? "related")),
+      issue,
+      ...id ? { id } : {}
+    });
+  }
+  return out;
+}
+function mapComments(node) {
+  const out = [];
+  for (const comment of node.comments?.nodes ?? []) {
+    const id = String(comment.id ?? "");
+    const body = String(comment.body ?? "");
+    if (!id && !body) continue;
+    out.push({
+      id,
+      body,
+      url: comment.url?.trim() || void 0,
+      createdAt: comment.createdAt?.trim() || void 0,
+      updatedAt: comment.updatedAt?.trim() || void 0,
+      user: mapUser(comment.user)
+    });
+  }
+  return out;
+}
+function mapIssue(node) {
+  const team = node.team;
+  return {
+    id: String(node.id ?? node.identifier ?? ""),
+    identifier: String(node.identifier ?? node.id ?? ""),
+    title: String(node.title ?? ""),
+    url: String(node.url ?? ""),
+    description: node.description?.trim() || void 0,
+    priority: typeof node.priority === "number" ? node.priority : void 0,
+    estimate: typeof node.estimate === "number" ? node.estimate : void 0,
+    dueDate: node.dueDate?.trim() || void 0,
+    branchName: node.branchName?.trim() || void 0,
+    createdAt: node.createdAt?.trim() || void 0,
+    updatedAt: node.updatedAt?.trim() || void 0,
+    completedAt: node.completedAt?.trim() || void 0,
+    state: mapState(node.state),
+    assignee: mapUser(node.assignee),
+    creator: mapUser(node.creator),
+    team: team?.id ? {
+      id: String(team.id),
+      key: String(team.key ?? ""),
+      name: String(team.name ?? ""),
+      states: (team.states?.nodes ?? []).flatMap((s) => {
+        const state = mapState(s);
+        return state ? [state] : [];
+      })
+    } : void 0,
+    labels: (node.labels?.nodes ?? []).map((l) => l.name).filter((n) => Boolean(n)),
+    cycle: mapCycle(node.cycle),
+    project: node.project?.id ? { id: String(node.project.id), name: String(node.project.name ?? "") } : void 0,
+    parent: mapIssueRef(node.parent),
+    children: (node.children?.nodes ?? []).flatMap((child) => {
+      const ref = mapIssueRef(child);
+      return ref ? [ref] : [];
+    }),
+    relations: mapRelations(node),
+    comments: mapComments(node),
+    attachments: mapLinearAttachments(node)
+  };
+}
+function toIssueInfo(issue) {
+  return {
+    id: issue.id,
+    identifier: issue.identifier,
+    title: issue.title,
+    url: issue.url,
+    labels: issue.labels,
+    provider: "linear",
+    assignee: issue.assignee?.name,
+    assignees: issue.assignee?.name ? [issue.assignee.name] : void 0,
+    cycle: issue.cycle ?? null,
+    teamKey: issue.team?.key || void 0,
+    ...issue.project ? { projects: [issue.project] } : {},
+    ...issue.createdAt ? { createdAt: issue.createdAt } : {},
+    ...issue.updatedAt ? { updatedAt: issue.updatedAt } : {}
+  };
+}
+function mapTeam(node) {
+  const cycles = (node.cycles?.nodes ?? []).flatMap((c) => {
+    const cycle = mapNamedCycle(c);
+    return cycle ? [cycle] : [];
+  });
+  return {
+    id: String(node.id ?? ""),
+    key: String(node.key ?? ""),
+    name: String(node.name ?? ""),
+    states: (node.states?.nodes ?? []).flatMap((s) => {
+      const state = mapState(s);
+      return state ? [state] : [];
+    }),
+    activeCycle: mapNamedCycle(node.activeCycle),
+    ...cycles.length ? { cycles } : {}
+  };
+}
+function resolveLinearTeam(teams, team) {
+  const t = team.trim();
+  if (!t) throw new Error("Linear team is required (id, key, or name from linear_list_teams)");
+  const lower = t.toLowerCase();
+  const found = teams.find(
+    (x) => x.id === t || x.key.toLowerCase() === lower || x.name.toLowerCase() === lower
+  );
+  if (!found) {
+    const keys = teams.map((x) => x.key).filter(Boolean).join(", ") || "(none)";
+    throw new Error(`Linear team not found: ${team}. Known keys: ${keys}`);
+  }
+  return found;
+}
+function resolveLinearState(team, state) {
+  const s = state.trim();
+  if (!s) throw new Error("Linear state is empty");
+  const lower = s.toLowerCase();
+  const found = team.states.find((x) => x.id === s) || team.states.find((x) => x.name.toLowerCase() === lower) || team.states.find((x) => x.type.toLowerCase() === lower);
+  if (!found) {
+    const available = team.states.map((x) => `${x.name} (${x.type})`).join(", ") || "(none)";
+    throw new Error(`Linear state not found on ${team.key}: ${state}. Available: ${available}`);
+  }
+  return found;
+}
+function resolveLinearCycle(team, cycle) {
+  if (cycle == null) return null;
+  const s = cycle.trim();
+  if (!s || /^(none|clear|unschedule|null)$/i.test(s)) return null;
+  if (/^(current|active|this)$/i.test(s)) {
+    const active = team.activeCycle ?? team.cycles?.find((c) => c.isActive);
+    if (!active?.id) {
+      throw new Error(`Linear team ${team.key} has no active cycle`);
+    }
+    return active.id;
+  }
+  const lower = s.toLowerCase();
+  const asNumber = Number.parseInt(s, 10);
+  const seen = /* @__PURE__ */ new Set();
+  const cycles = [team.activeCycle, ...team.cycles ?? []].filter(
+    (c) => {
+      if (!c?.id || seen.has(c.id)) return false;
+      seen.add(c.id);
+      return true;
+    }
+  );
+  const found = cycles.find((c) => c.id === s) || cycles.find((c) => c.name.toLowerCase() === lower) || (Number.isInteger(asNumber) ? cycles.find((c) => c.number === asNumber) : void 0);
+  if (!found) {
+    const available = cycles.map((c) => c.number != null ? `${c.name} (${c.number})` : c.name).join(", ") || "(none)";
+    throw new Error(`Linear cycle not found on ${team.key}: ${cycle}. Available: ${available}`);
+  }
+  return found.id;
+}
+var LINEAR_NONE_RE = /^(none|clear|unschedule|null)$/i;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isLinearNoneToken(value) {
+  if (value == null) return true;
+  const s = value.trim();
+  return !s || LINEAR_NONE_RE.test(s);
+}
+function resolveLinearLabel(labels, name) {
+  const s = name.trim();
+  if (!s) throw new Error("Linear label is empty");
+  const lower = s.toLowerCase();
+  const found = labels.find((x) => x.id === s) || labels.find((x) => x.name.toLowerCase() === lower);
+  if (!found) {
+    const available = labels.map((x) => x.name).filter(Boolean).slice(0, 20).join(", ") || "(none)";
+    throw new Error(`Linear label not found: ${name}. Available: ${available}`);
+  }
+  return found;
+}
+function resolveLinearProject(projects, project) {
+  if (isLinearNoneToken(project)) return null;
+  const s = (project ?? "").trim();
+  const lower = s.toLowerCase();
+  const found = projects.find((x) => x.id === s) || projects.find((x) => x.name.toLowerCase() === lower) || projects.find((x) => x.slugId?.toLowerCase() === lower);
+  if (!found) {
+    const available = projects.map((x) => x.name).filter(Boolean).slice(0, 20).join(", ") || "(none)";
+    throw new Error(`Linear project not found: ${project}. Available: ${available}`);
+  }
+  return found.id;
+}
+function normalizeLinearRelationType(type) {
+  const s = type.trim().toLowerCase().replace(/[\s_-]+/g, "");
+  if (s === "blocks" || s === "block") return "blocks";
+  if (s === "blockedby" || s === "blocked") return "blockedBy";
+  if (s === "related" || s === "relates" || s === "relatesto") return "related";
+  if (s === "duplicate" || s === "dup") return "duplicate";
+  if (s === "duplicateof" || s === "original") return "duplicateOf";
+  if (s === "similar") return "similar";
+  throw new Error(
+    `Linear relation type must be blocks, blockedBy, related, duplicate, or duplicateOf (got ${type})`
+  );
+}
+function linearRelationCreateInput(thisIssueId, type, relatedIssueId) {
+  const view = normalizeLinearRelationType(type);
+  if (view === "blockedBy") {
+    return { issueId: relatedIssueId, relatedIssueId: thisIssueId, type: "blocks" };
+  }
+  if (view === "duplicateOf") {
+    return { issueId: relatedIssueId, relatedIssueId: thisIssueId, type: "duplicate" };
+  }
+  return { issueId: thisIssueId, relatedIssueId, type: view };
+}
+function relationMatches(rel, type, issueRef) {
+  if (rel.type.toLowerCase() !== type.toLowerCase()) return false;
+  const ref = issueRef.trim().toLowerCase();
+  return rel.issue.id.toLowerCase() === ref || rel.issue.identifier.toLowerCase() === ref;
+}
+function formatRelationList(relations) {
+  if (!relations.length) return "(none)";
+  return relations.map((r) => `${r.type} ${r.issue.identifier || r.issue.id}`).join(", ");
+}
+function mapLabelNodes(nodes) {
+  return (nodes ?? []).flatMap((node) => {
+    const id = String(node.id ?? "").trim();
+    const name = String(node.name ?? "").trim();
+    if (!id) return [];
+    return [{ id, name }];
+  });
+}
+async function listLinearWorkspaceLabels(opts) {
+  const json = await linearGraphql(LABELS_QUERY, { first: 250 }, opts);
+  return mapLabelNodes(json.issueLabels?.nodes);
+}
+async function listLinearLabels(opts) {
+  const teamId = opts?.teamId?.trim();
+  if (teamId) {
+    const out = [];
+    let after;
+    for (let page = 0; page < 4; page++) {
+      const json = await linearGraphql(
+        TEAM_LABELS_QUERY,
+        after ? { id: teamId, first: 250, after } : { id: teamId, first: 250 },
+        opts
+      );
+      const conn = json.team?.labels;
+      out.push(...mapLabelNodes(conn?.nodes));
+      if (!conn?.pageInfo?.hasNextPage || !conn.pageInfo.endCursor) break;
+      after = conn.pageInfo.endCursor;
+    }
+    if (out.length) return out;
+  }
+  return listLinearWorkspaceLabels(opts);
+}
+async function queryLinearProjects(filter, opts) {
+  const out = [];
+  let after;
+  for (let page = 0; page < 4; page++) {
+    const json = await linearGraphql(PROJECTS_QUERY, { first: 50, filter: filter ?? {}, ...after ? { after } : {} }, opts);
+    for (const node of json.projects?.nodes ?? []) {
+      const id = String(node.id ?? "").trim();
+      if (!id) continue;
+      out.push({ id, name: String(node.name ?? ""), ...node.slugId ? { slugId: String(node.slugId) } : {} });
+    }
+    const pageInfo = json.projects?.pageInfo;
+    if (!pageInfo?.hasNextPage || !pageInfo.endCursor) break;
+    after = pageInfo.endCursor;
+  }
+  return out;
+}
+function listLinearProjects(opts) {
+  return queryLinearProjects(void 0, opts);
+}
+async function resolveLinearProjectId(project, opts) {
+  if (isLinearNoneToken(project)) return null;
+  const s = (project ?? "").trim();
+  const filter = UUID_RE.test(s) ? { id: { eq: s } } : { name: { eqIgnoreCase: s } };
+  const matched = await queryLinearProjects(filter, opts);
+  try {
+    return resolveLinearProject(matched, s);
+  } catch {
+    if (UUID_RE.test(s)) return s;
+    const listed = await queryLinearProjects(void 0, opts);
+    return resolveLinearProject(listed, s);
+  }
+}
+async function resolveLinearLabelIds(names, opts) {
+  if (names.length === 0) return [];
+  const labels = await listLinearLabels(opts);
+  return names.map((name) => {
+    const s = name.trim();
+    try {
+      return resolveLinearLabel(labels, s).id;
+    } catch (error) {
+      if (UUID_RE.test(s)) return s;
+      throw error;
+    }
+  });
+}
+async function applyLinearIssueRelations(issue, add, remove, opts) {
+  const current = [...issue.relations];
+  for (const rel of remove ?? []) {
+    const type = normalizeLinearRelationType(rel.type);
+    const issueRef = rel.issue.trim();
+    if (!issueRef) throw new Error("Linear removeRelations.issue is required (uuid or ENG-123)");
+    const match = current.find((r) => relationMatches(r, type, issueRef));
+    if (!match?.id) {
+      throw new Error(
+        `Linear relation not found: ${type} ${issueRef}. Existing: ${formatRelationList(current)}`
+      );
+    }
+    const json = await linearGraphql(ISSUE_RELATION_DELETE, { id: match.id }, opts);
+    if (!json.issueRelationDelete?.success) {
+      throw new Error(`Linear issueRelationDelete failed (${type} ${issueRef})`);
+    }
+    const idx = current.indexOf(match);
+    if (idx >= 0) current.splice(idx, 1);
+  }
+  for (const rel of add ?? []) {
+    const type = normalizeLinearRelationType(rel.type);
+    const issueRef = rel.issue.trim();
+    if (!issueRef) throw new Error("Linear relations.issue is required (uuid or ENG-123)");
+    if (current.some((r) => relationMatches(r, type, issueRef))) continue;
+    const related = await getLinearIssue(issueRef, opts);
+    const input = linearRelationCreateInput(issue.id, type, related.id);
+    const json = await linearGraphql(ISSUE_RELATION_CREATE, { input }, opts);
+    if (!json.issueRelationCreate?.success) {
+      throw new Error(`Linear issueRelationCreate failed (${type} ${related.identifier})`);
+    }
+    current.push({ type, issue: related, id: void 0 });
+  }
+}
+function normalizePriority(priority) {
+  if (priority == null) return void 0;
+  if (!Number.isInteger(priority) || priority < 0 || priority > 4) {
+    throw new Error("Linear priority must be 0 (none), 1 (urgent), 2 (high), 3 (medium), or 4 (low)");
+  }
+  return priority;
+}
+function assigneeFilterKey(assignee) {
+  return (assignee ?? "").trim();
+}
+function applyLinearIssueQueryFilter(filter, query) {
+  const term = query?.trim();
+  if (!term) return;
+  const or = [
+    { title: { containsIgnoreCase: term } },
+    { description: { containsIgnoreCase: term } }
+  ];
+  const identifierMatch = term.match(/^[A-Za-z][\w]*-(\d+)$/);
+  const asNumber = identifierMatch ? Number(identifierMatch[1]) : /^\d+$/.test(term) ? Number(term) : NaN;
+  if (Number.isFinite(asNumber) && asNumber > 0) {
+    or.push({ number: { eq: asNumber } });
+  }
+  filter.or = or;
+}
+function buildLinearIssueFilter(input) {
+  const filter = {
+    state: { type: { nin: ["completed", "canceled"] } }
+  };
+  const since = input?.updatedSince?.trim();
+  if (since) filter.updatedAt = { gte: since };
+  applyLinearIssueQueryFilter(filter, input?.query);
+  const raw = assigneeFilterKey(input?.assignee) || "me";
+  const key = raw.toLowerCase();
+  if (key === "all" || key === "*") return filter;
+  if (key === "unassigned" || key === "none" || key === "null") {
+    filter.assignee = { null: true };
+    return filter;
+  }
+  if (key === "me" || key === "@me") {
+    filter.assignee = { isMe: { eq: true } };
+    return filter;
+  }
+  if (UUID_RE.test(raw)) {
+    filter.assignee = { id: { eq: raw } };
+    return filter;
+  }
+  filter.assignee = { name: { eqIgnoreCase: raw } };
+  return filter;
+}
+function isAssignedToMe(assignee) {
+  const key = assignee.toLowerCase();
+  return key === "me" || key === "@me";
+}
+function listedLinearIssues(json, nodes) {
+  return {
+    viewer: {
+      id: String(json.viewer?.id ?? ""),
+      name: String(json.viewer?.name ?? "")
+    },
+    issues: (nodes ?? []).map((node) => toIssueInfo(mapIssue(node)))
+  };
+}
+async function listLinearIssuesFiltered(opts) {
+  const first = Math.max(1, Math.min(250, opts?.limit ?? 200));
+  const query = opts?.query?.trim() ?? "";
+  const assignee = assigneeFilterKey(opts?.assignee) || (query ? "all" : "me");
+  const filter = buildLinearIssueFilter({
+    assignee,
+    updatedSince: opts?.updatedSince
+  });
+  if (query) {
+    const json2 = await linearGraphql(
+      SEARCH_ISSUES_QUERY,
+      { term: query, first, filter },
+      opts
+    );
+    return listedLinearIssues(json2, json2.searchIssues?.nodes);
+  }
+  if (isAssignedToMe(assignee)) {
+    const json2 = await linearGraphql(
+      ASSIGNED_ISSUES_QUERY,
+      { first, filter },
+      opts
+    );
+    return listedLinearIssues(json2, json2.viewer?.assignedIssues?.nodes);
+  }
+  const json = await linearGraphql(
+    ISSUES_QUERY,
+    { first, filter },
+    opts
+  );
+  return listedLinearIssues(json, json.issues?.nodes);
+}
+async function listLinearCommentsSince(opts) {
+  const first = Math.max(1, Math.min(250, opts.limit ?? 200));
+  const query = opts.query?.trim() ?? "";
+  const restrictToIssues = opts.issueIdentifiers != null;
+  const allowed = new Set(
+    (opts.issueIdentifiers ?? []).map((id) => id.trim()).filter(Boolean)
+  );
+  if (restrictToIssues && allowed.size === 0) return [];
+  const assignee = assigneeFilterKey(opts.assignee) || (query ? "all" : "me");
+  const json = await linearGraphql(
+    COMMENTS_SINCE_QUERY,
+    {
+      first,
+      filter: {
+        createdAt: { gte: opts.since },
+        issue: buildLinearIssueFilter({
+          assignee,
+          // Search hits may match identifier/comments — do not also require
+          // title/description contains when an allowlist is already applied.
+          query: restrictToIssues ? void 0 : query || void 0
+        })
+      }
+    },
+    opts
+  );
+  const out = [];
+  for (const node of json.comments?.nodes ?? []) {
+    const identifier = String(node.issue?.identifier ?? "").trim();
+    if (restrictToIssues && !allowed.has(identifier)) continue;
+    const body = previewIssueCommentBody(String(node.body ?? ""));
+    if (!identifier && !body) continue;
+    out.push({
+      identifier: identifier || String(node.id ?? ""),
+      ...node.issue?.title ? { title: String(node.issue.title) } : {},
+      ...node.user?.name ? { author: String(node.user.name) } : {},
+      ...node.createdAt?.trim() ? { createdAt: node.createdAt.trim() } : {},
+      body,
+      ...node.url?.trim() ? { url: node.url.trim() } : {}
+    });
+  }
+  return out;
+}
+async function listLinearAssignedIssues(opts) {
+  return listLinearIssuesFiltered({ ...opts, assignee: "me" });
+}
+async function listLinearIssuesDirect(opts) {
+  return (await listLinearAssignedIssues(opts)).issues;
+}
+async function listLinearTeams(opts) {
+  const json = await linearGraphql(TEAMS_QUERY, void 0, opts);
+  return {
+    viewer: {
+      id: String(json.viewer?.id ?? ""),
+      name: String(json.viewer?.name ?? "")
+    },
+    teams: (json.teams?.nodes ?? []).map(mapTeam)
+  };
+}
+async function listLinearTeamCycles(teamId, opts) {
+  const json = await linearGraphql(TEAM_CYCLES_QUERY, { id: teamId }, opts);
+  if (!json.team?.id) {
+    throw new Error(`Linear team not found: ${teamId}`);
+  }
+  const mapped = mapTeam(json.team);
+  return {
+    id: mapped.id,
+    key: mapped.key,
+    activeCycle: mapped.activeCycle,
+    cycles: mapped.cycles ?? []
+  };
+}
+async function getLinearIssue(id, opts) {
+  const issueId = id.trim();
+  if (!issueId) throw new Error("Linear issue id is required (uuid or ENG-123)");
+  const json = await linearGraphql(
+    ISSUE_QUERY,
+    { id: issueId },
+    opts
+  );
+  if (!json.issue) {
+    throw new Error(`Linear issue not found: ${issueId}`);
+  }
+  return mapIssue(json.issue);
+}
+async function createLinearIssue(input, opts) {
+  const title = input.title.trim();
+  if (!title) throw new Error("Linear issue title is required");
+  const { viewer, teams } = await listLinearTeams(opts);
+  const team = resolveLinearTeam(teams, input.team);
+  const mutationInput = {
+    teamId: team.id,
+    title
+  };
+  const description = input.description?.trim();
+  if (description) mutationInput.description = description;
+  if (input.state?.trim()) {
+    mutationInput.stateId = resolveLinearState(team, input.state).id;
+  }
+  const parentRef = input.parent?.trim();
+  if (parentRef) {
+    const parent = await getLinearIssue(parentRef, opts);
+    mutationInput.parentId = parent.id;
+  }
+  const assignee = input.assignee === void 0 ? void 0 : input.assignee?.trim() || null;
+  if (assignee === "me") mutationInput.assigneeId = viewer.id;
+  else if (assignee) mutationInput.assigneeId = assignee;
+  const priority = normalizePriority(input.priority);
+  if (priority != null) mutationInput.priority = priority;
+  const json = await linearGraphql(ISSUE_CREATE, { input: mutationInput }, opts);
+  if (!json.issueCreate?.success || !json.issueCreate.issue) {
+    throw new Error("Linear issueCreate failed");
+  }
+  return mapIssue(json.issueCreate.issue);
+}
+async function updateLinearIssue(input, opts) {
+  const issueId = input.id.trim();
+  if (!issueId) throw new Error("Linear issue id is required (uuid or ENG-123)");
+  const mutationInput = {};
+  if (input.title !== void 0) {
+    const title = input.title.trim();
+    if (!title) throw new Error("Linear issue title cannot be empty");
+    mutationInput.title = title;
+  }
+  if (input.description !== void 0) {
+    mutationInput.description = input.description;
+  }
+  const addRelations = input.relations?.length ? input.relations : void 0;
+  const removeRelations = input.removeRelations?.length ? input.removeRelations : void 0;
+  const needsIssue = Boolean(input.state?.trim()) || input.cycle !== void 0 || input.labels !== void 0 || Boolean(addRelations) || Boolean(removeRelations);
+  const existing = needsIssue ? await getLinearIssue(issueId, opts) : void 0;
+  if (input.state?.trim()) {
+    const { teams } = await listLinearTeams(opts);
+    const teamRef = existing?.team?.key || existing?.team?.id;
+    const team = teamRef ? resolveLinearTeam(teams, teamRef) : void 0;
+    if (!team?.states.length) {
+      throw new Error(`Linear issue ${existing?.identifier ?? issueId} has no workflow states to resolve "${input.state}"`);
+    }
+    mutationInput.stateId = resolveLinearState(team, input.state).id;
+  }
+  if (input.cycle !== void 0) {
+    const teamId = existing?.team?.id;
+    if (!teamId) {
+      throw new Error(`Linear issue ${existing?.identifier ?? issueId} has no team to resolve a cycle`);
+    }
+    const cycles = await listLinearTeamCycles(teamId, opts);
+    mutationInput.cycleId = resolveLinearCycle(
+      { ...cycles, key: cycles.key || existing?.team?.key || teamId },
+      input.cycle
+    );
+  }
+  if (input.assignee !== void 0) {
+    const assignee = input.assignee?.trim() || null;
+    if (assignee === "me") {
+      const { viewer } = await listLinearTeams(opts);
+      mutationInput.assigneeId = viewer.id;
+    } else {
+      mutationInput.assigneeId = assignee;
+    }
+  }
+  if (input.priority !== void 0) {
+    mutationInput.priority = normalizePriority(input.priority);
+  }
+  if (input.labels !== void 0) {
+    mutationInput.labelIds = await resolveLinearLabelIds(input.labels, {
+      ...opts,
+      teamId: existing?.team?.id
+    });
+  }
+  if (input.project !== void 0) {
+    mutationInput.projectId = await resolveLinearProjectId(input.project, opts);
+  }
+  if (input.parent !== void 0) {
+    if (isLinearNoneToken(input.parent)) {
+      mutationInput.parentId = null;
+    } else {
+      const parent = await getLinearIssue((input.parent ?? "").trim(), opts);
+      mutationInput.parentId = parent.id;
+    }
+  }
+  const hasIssueFields = Object.keys(mutationInput).length > 0;
+  const hasRelationWrites = Boolean(addRelations || removeRelations);
+  if (!hasIssueFields && !hasRelationWrites) {
+    throw new Error(
+      "linear_update_issue needs at least one of title, description, state, assignee, priority, cycle, labels, project, parent, relations, removeRelations"
+    );
+  }
+  let updated;
+  if (hasIssueFields) {
+    const json = await linearGraphql(ISSUE_UPDATE, { id: issueId, input: mutationInput }, opts);
+    if (!json.issueUpdate?.success || !json.issueUpdate.issue) {
+      throw new Error("Linear issueUpdate failed");
+    }
+    updated = mapIssue(json.issueUpdate.issue);
+  }
+  if (hasRelationWrites) {
+    const base = updated ?? existing;
+    if (!base) {
+      throw new Error(`Linear issue not found: ${issueId}`);
+    }
+    await applyLinearIssueRelations(base, addRelations, removeRelations, opts);
+    return getLinearIssue(base.id || issueId, opts);
+  }
+  return updated;
+}
+async function commentLinearIssue(input, opts) {
+  const issueId = input.id.trim();
+  const body = input.body.trim();
+  if (!issueId) throw new Error("Linear issue id is required (uuid or ENG-123)");
+  if (!body) throw new Error("Linear comment body is required");
+  const json = await linearGraphql(COMMENT_CREATE, { input: { issueId, body } }, opts);
+  if (!json.commentCreate?.success || !json.commentCreate.comment?.id) {
+    throw new Error("Linear commentCreate failed");
+  }
+  return {
+    id: String(json.commentCreate.comment.id),
+    body: String(json.commentCreate.comment.body ?? body),
+    url: json.commentCreate.comment.url?.trim() || void 0
+  };
+}
+async function validateLinearApiKey(apiKey) {
+  const key = apiKey.trim();
+  if (!key) return false;
+  try {
+    await listLinearIssuesDirect({ limit: 1, apiKey: key });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  hasBakedLinearOAuth,
+  LINEAR_OAUTH_PORT,
+  LINEAR_OAUTH_REDIRECT,
+  LINEAR_OAUTH_SCOPES,
+  linearOAuthCredentials,
+  createLinearPkce,
+  linearOAuthAuthorizeUrl,
+  linearAuthorizationHeader,
+  getLinearAuthToken,
+  LINEAR_OAUTH_CANCELLED,
+  LinearOAuthCancelledError,
+  isLinearOAuthCancelled,
+  startLinearOAuth,
+  disconnectLinear,
+  downloadLinearAttachment,
+  rewriteLinearError,
+  linearGraphql,
+  linearCycleIsActive,
+  flipLinearRelationType,
+  resolveLinearTeam,
+  resolveLinearState,
+  resolveLinearCycle,
+  isLinearNoneToken,
+  resolveLinearLabel,
+  resolveLinearProject,
+  normalizeLinearRelationType,
+  linearRelationCreateInput,
+  listLinearProjects,
+  buildLinearIssueFilter,
+  listLinearIssuesFiltered,
+  listLinearCommentsSince,
+  listLinearAssignedIssues,
+  listLinearIssuesDirect,
+  listLinearTeams,
+  listLinearTeamCycles,
+  getLinearIssue,
+  createLinearIssue,
+  updateLinearIssue,
+  commentLinearIssue,
+  validateLinearApiKey
+};