@meetopenbot/linear 0.0.1

package/src/linear-issues.ts

@@ -0,0 +1,188 @@
+import type { RenderUIWidgetData } from "@meetopenbot/plugin-sdk";
+
+export type LinearIssue = {
+  id: string;
+  identifier: string;
+  title: string;
+  url: string;
+  state?: { name: string; type: string };
+  assignee?: { name: string };
+  team?: { name: string; key: string };
+  project?: { name: string };
+};
+
+const OPEN_URL_ACTION_ID = "open_url";
+export const ISSUES_LIST_WIDGET_ID = "linear-issues-list";
+
+type LinearStateType =
+  | "backlog"
+  | "unstarted"
+  | "started"
+  | "completed"
+  | "canceled"
+  | string;
+
+function mapStateStatus(
+  stateType?: LinearStateType,
+): "pending" | "in_progress" | "done" | "cancelled" | undefined {
+  switch (stateType) {
+    case "started":
+      return "in_progress";
+    case "completed":
+      return "done";
+    case "canceled":
+      return "cancelled";
+    case "backlog":
+    case "unstarted":
+      return "pending";
+    default:
+      return undefined;
+  }
+}
+
+export function buildIssuesListWidget(
+  issues: LinearIssue[],
+  options?: { title?: string; description?: string },
+): RenderUIWidgetData {
+  return {
+    kind: "list",
+    widgetId: ISSUES_LIST_WIDGET_ID,
+    title: options?.title ?? "Linear issues",
+    description:
+      options?.description ??
+      (issues.length === 0
+        ? "No issues matched this query."
+        : `${issues.length} issue${issues.length === 1 ? "" : "s"}`),
+    items: issues.map((issue) => {
+      const details = [
+        issue.state?.name,
+        issue.assignee?.name ? `Assignee: ${issue.assignee.name}` : undefined,
+        issue.team?.name,
+        issue.project?.name,
+      ]
+        .filter(Boolean)
+        .join(" · ");
+
+      return {
+        id: issue.id,
+        label: `${issue.identifier}: ${issue.title}`,
+        description: details || undefined,
+        badge: issue.state?.name,
+        status: mapStateStatus(issue.state?.type),
+        actions: issue.url
+          ? [
+              {
+                id: OPEN_URL_ACTION_ID,
+                label: "Open",
+                variant: "secondary" as const,
+                value: { url: issue.url, target: "_blank" },
+              },
+            ]
+          : undefined,
+        metadata: {
+          identifier: issue.identifier,
+          url: issue.url,
+        },
+      };
+    }),
+  };
+}
+
+function extractTextPayload(value: unknown): string | undefined {
+  if (typeof value === "string") return value;
+  if (!value || typeof value !== "object") return undefined;
+
+  const record = value as Record<string, unknown>;
+  if (typeof record.text === "string") return record.text;
+
+  if (Array.isArray(record.content)) {
+    for (const part of record.content) {
+      if (
+        part &&
+        typeof part === "object" &&
+        (part as { type?: string }).type === "text" &&
+        typeof (part as { text?: string }).text === "string"
+      ) {
+        return (part as { text: string }).text;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function parseIssuesPayload(payload: unknown): LinearIssue[] {
+  if (!payload || typeof payload !== "object") return [];
+
+  const root = payload as Record<string, unknown>;
+  const issuesNode =
+    (root.issues as { nodes?: unknown[] } | undefined) ??
+    ((root.data as Record<string, unknown> | undefined)?.issues as
+      | { nodes?: unknown[] }
+      | undefined);
+
+  if (!issuesNode?.nodes || !Array.isArray(issuesNode.nodes)) return [];
+
+  return issuesNode.nodes
+    .filter((node): node is LinearIssue => {
+      if (!node || typeof node !== "object") return false;
+      const issue = node as LinearIssue;
+      return (
+        typeof issue.id === "string" &&
+        typeof issue.identifier === "string" &&
+        typeof issue.title === "string"
+      );
+    })
+    .map((issue) => ({
+      ...issue,
+      url: typeof issue.url === "string" ? issue.url : "",
+    }));
+}
+
+export function extractIssuesFromToolResults(
+  toolResults: Array<{ toolName: string; output: unknown }>,
+): LinearIssue[] {
+  const byId = new Map<string, LinearIssue>();
+
+  for (const toolResult of toolResults) {
+    if (!toolResult.toolName.includes("search_issues")) continue;
+
+    const text = extractTextPayload(toolResult.output);
+    if (!text) continue;
+
+    try {
+      for (const issue of parseIssuesPayload(JSON.parse(text))) {
+        byId.set(issue.id, issue);
+      }
+    } catch {
+      // Ignore malformed tool payloads.
+    }
+  }
+
+  return [...byId.values()];
+}
+
+export function isListIssuesPrompt(message: string): boolean {
+  const normalized = message.trim().toLowerCase();
+  if (!normalized) return false;
+
+  return (
+    /\b(list|show|get|fetch|what are|available)\b/.test(normalized) &&
+    /\bissues?\b/.test(normalized)
+  );
+}
+
+export function isAssignedIssuesPrompt(message: string): boolean {
+  const normalized = message.trim().toLowerCase();
+  return (
+    /\b(assigned to me|my issues|issues for me|issues assigned)\b/.test(
+      normalized,
+    ) || /\bissues?\s+assigned\b/.test(normalized)
+  );
+}
+
+export function issuesListTitle(prompt: string): string {
+  return isAssignedIssuesPrompt(prompt)
+    ? "Issues assigned to you"
+    : "Linear issues";
+}

package/src/linear-mcp.ts

@@ -0,0 +1,33 @@
+import { createRequire } from "node:module";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+
+export type LinearMcpClientArgs = {
+  accessToken: string;
+};
+
+const require = createRequire(import.meta.url);
+
+function resolveMcpServerLinearLaunch(): { command: string; args: string[] } {
+  try {
+    const entry = require.resolve("mcp-server-linear");
+    return { command: process.execPath, args: [entry] };
+  } catch {
+    return { command: "npx", args: ["-y", "mcp-server-linear"] };
+  }
+}
+
+export async function createLinearMcpClient(args: LinearMcpClientArgs) {
+  const launch = resolveMcpServerLinearLaunch();
+
+  return createMCPClient({
+    transport: new Experimental_StdioMCPTransport({
+      command: launch.command,
+      args: launch.args,
+      env: {
+        ...process.env,
+        LINEAR_ACCESS_TOKEN: args.accessToken,
+      },
+    }),
+  });
+}

package/src/oauth-pending.ts

@@ -0,0 +1,68 @@
+import type { Storage } from "@meetopenbot/plugin-sdk";
+
+export const VAR_OAUTH_PENDING = "LINEAR_OAUTH_PENDING";
+
+export interface PendingOAuthSession {
+  state: string;
+  codeVerifier: string;
+  clientId: string;
+  clientSecret?: string;
+  redirectUri: string;
+  expiresAt: number;
+}
+
+type VariableValue = string | { value: string; secret: boolean } | undefined;
+
+function variableValue(
+  variables: Record<string, VariableValue>,
+  key: string,
+): string | undefined {
+  const entry = variables[key];
+  if (typeof entry === "string") return entry || undefined;
+  return entry?.value || undefined;
+}
+
+export async function savePendingOAuthSession(
+  storage: Storage,
+  session: PendingOAuthSession,
+): Promise<void> {
+  await storage.createVariable({
+    key: VAR_OAUTH_PENDING,
+    value: JSON.stringify(session),
+    secret: true,
+  });
+}
+
+export async function loadPendingOAuthSession(
+  storage: Storage,
+): Promise<PendingOAuthSession | null> {
+  const variables = (await storage.getVariables().catch(() => ({}))) as Record<
+    string,
+    VariableValue
+  >;
+  const raw =
+    variableValue(variables, VAR_OAUTH_PENDING) ??
+    process.env[VAR_OAUTH_PENDING];
+  if (!raw) return null;
+
+  try {
+    const session = JSON.parse(raw) as PendingOAuthSession;
+    if (
+      typeof session.state !== "string" ||
+      typeof session.codeVerifier !== "string" ||
+      typeof session.clientId !== "string" ||
+      typeof session.redirectUri !== "string" ||
+      typeof session.expiresAt !== "number"
+    ) {
+      return null;
+    }
+    if (Date.now() > session.expiresAt) return null;
+    return session;
+  } catch {
+    return null;
+  }
+}
+
+export async function clearPendingOAuthSession(storage: Storage): Promise<void> {
+  await storage.deleteVariable({ key: VAR_OAUTH_PENDING }).catch(() => {});
+}