npm - @meetopenbot/linear - Versions diffs - 0.0.3 → 0.0.5 - Mend

@meetopenbot/linear 0.0.3 → 0.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (36) hide show

package/dist/oauth.js DELETED Viewed

@@ -1,381 +0,0 @@
-/**
- * Linear OAuth 2.0 (authorization code + PKCE).
- *
- * Two callback modes:
- * - Loopback: temporary localhost server (local runtimes).
- * - Webhook: redirect to `https://<host>/api/webhooks/linear` (cloud/remote).
- */
-import { createHash, randomBytes } from "node:crypto";
-import { createServer } from "node:http";
-import { GO_BACK_TO_OPENBOT_URL } from "./config.js";
-import { clearPendingOAuthSession, loadPendingOAuthSession, savePendingOAuthSession, } from "./oauth-pending.js";
-export const LINEAR_AUTHORIZE_URL = "https://linear.app/oauth/authorize";
-export const LINEAR_TOKEN_URL = "https://api.linear.app/oauth/token";
-export const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
-export const OAUTH_WEBHOOK_PROVIDER = "linear";
-const LOOPBACK_CALLBACK_PATH = "/oauth/callback";
-const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
-const PENDING_SESSION_MS = 10 * 60 * 1000;
-let activeServer = null;
-const webhookOAuthCompletions = new Map();
-function base64url(buffer) {
-    return buffer
-        .toString("base64")
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=+$/, "");
-}
-export function oauthHtmlPage(title, body, ok) {
-    return `<!doctype html>
-<html>
-<head>
-<meta charset="utf-8" />
-<meta name="viewport" content="width=device-width, initial-scale=1" />
-<title>${title}</title>
-<link rel="preconnect" href="https://fonts.googleapis.com" />
-<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" rel="stylesheet" />
-<style>
-  body { font-family: Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; background: #101012; color: #ededef; }
-  .card { text-align: center; padding: 40px 48px; border-radius: 14px; background: #1b1b1f; border: 1px solid #2a2a30; max-width: 420px; }
-  .icon { height: 28px; margin-bottom: 18px; font-size: 28px; font-weight: 500; line-height: 28px; }
-  .success { color: #4ade80; }
-  h1 { font-size: 20px; font-weight: 600; margin: 0 0 8px; }
-  p { color: #9b9ba3; margin: 0; line-height: 1.5; }
-  .back-link { margin: 20px 0 0; font-size: 14px; }
-  .back-link a { color: #ededef; text-decoration: none; }
-  .back-link a:hover { text-decoration: underline; }
-</style>
-</head>
-<body>
-  <div class="card">
-    <div class="icon${ok ? " success" : ""}">${ok ? "✓" : "⚠"}</div>
-    <h1>${title}</h1>
-    <p>${body}</p>
-    <p class="back-link">Go back to <a href="${GO_BACK_TO_OPENBOT_URL}">OpenBot</a></p>
-  </div>
-</body>
-</html>`;
-}
-export function buildOAuthRedirectUri(webhookBaseUrl) {
-    const base = webhookBaseUrl.replace(/\/$/, "");
-    return `${base}/api/webhooks/${OAUTH_WEBHOOK_PROVIDER}`;
-}
-function generatePkce() {
-    const state = base64url(randomBytes(24));
-    const codeVerifier = base64url(randomBytes(48));
-    const codeChallenge = base64url(createHash("sha256").update(codeVerifier).digest());
-    return { state, codeVerifier, codeChallenge };
-}
-export function buildAuthorizeUrl(args) {
-    return (`${LINEAR_AUTHORIZE_URL}?` +
-        new URLSearchParams({
-            client_id: args.clientId,
-            redirect_uri: args.redirectUri,
-            response_type: "code",
-            scope: args.scopes,
-            state: args.state,
-            prompt: "consent",
-            code_challenge: args.codeChallenge,
-            code_challenge_method: "S256",
-        }).toString());
-}
-export async function exchangeAuthorizationCode(args) {
-    const body = new URLSearchParams({
-        grant_type: "authorization_code",
-        code: args.code,
-        redirect_uri: args.redirectUri,
-        client_id: args.clientId,
-        code_verifier: args.codeVerifier,
-    });
-    if (args.clientSecret)
-        body.set("client_secret", args.clientSecret);
-    const response = await fetch(LINEAR_TOKEN_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body,
-    });
-    const payload = (await response.json().catch(() => ({})));
-    if (!response.ok || typeof payload.access_token !== "string") {
-        const detail = typeof payload.error_description === "string"
-            ? payload.error_description
-            : JSON.stringify(payload);
-        throw new Error(`Linear token exchange failed (${response.status}): ${detail}`);
-    }
-    return normalizeTokenResponse(payload);
-}
-export async function refreshAccessToken(args) {
-    const body = new URLSearchParams({
-        grant_type: "refresh_token",
-        refresh_token: args.refreshToken,
-        client_id: args.clientId,
-    });
-    if (args.clientSecret)
-        body.set("client_secret", args.clientSecret);
-    const response = await fetch(LINEAR_TOKEN_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body,
-    });
-    const payload = (await response.json().catch(() => ({})));
-    if (!response.ok || typeof payload.access_token !== "string") {
-        const detail = typeof payload.error_description === "string"
-            ? payload.error_description
-            : JSON.stringify(payload);
-        throw new Error(`Linear token refresh failed (${response.status}): ${detail}`);
-    }
-    return normalizeTokenResponse(payload);
-}
-function normalizeTokenResponse(payload) {
-    return {
-        accessToken: payload.access_token,
-        refreshToken: typeof payload.refresh_token === "string"
-            ? payload.refresh_token
-            : undefined,
-        expiresAt: typeof payload.expires_in === "number"
-            ? Date.now() + payload.expires_in * 1000
-            : undefined,
-        scope: Array.isArray(payload.scope)
-            ? payload.scope.join(",")
-            : payload.scope,
-    };
-}
-function registerWebhookOAuthCompletion(state, timeoutMs) {
-    return new Promise((resolve) => {
-        const existing = webhookOAuthCompletions.get(state);
-        if (existing) {
-            webhookOAuthCompletions.delete(state);
-        }
-        const timeout = setTimeout(() => {
-            webhookOAuthCompletions.delete(state);
-            resolve(null);
-        }, timeoutMs);
-        timeout.unref?.();
-        webhookOAuthCompletions.set(state, (tokens) => {
-            clearTimeout(timeout);
-            resolve(tokens);
-        });
-    });
-}
-function settleWebhookOAuthCompletion(state, tokens) {
-    const resolve = webhookOAuthCompletions.get(state);
-    if (!resolve)
-        return;
-    webhookOAuthCompletions.delete(state);
-    resolve(tokens);
-}
-export async function startWebhookOAuthFlow(args) {
-    const { state, codeVerifier, codeChallenge } = generatePkce();
-    const redirectUri = buildOAuthRedirectUri(args.webhookBaseUrl);
-    const pending = {
-        state,
-        codeVerifier,
-        clientId: args.clientId,
-        clientSecret: args.clientSecret,
-        redirectUri,
-        expiresAt: Date.now() + PENDING_SESSION_MS,
-    };
-    await savePendingOAuthSession(args.storage, pending);
-    const authorizeUrl = buildAuthorizeUrl({
-        clientId: args.clientId,
-        redirectUri,
-        scopes: args.scopes,
-        state,
-        codeChallenge,
-    });
-    const timeoutMs = args.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const completion = registerWebhookOAuthCompletion(state, timeoutMs);
-    return {
-        authorizeUrl,
-        redirectUri,
-        completion,
-        cancel: () => {
-            settleWebhookOAuthCompletion(state, null);
-            void clearPendingOAuthSession(args.storage);
-        },
-    };
-}
-export async function handleWebhookOAuthCallback(args) {
-    const code = queryParam(args.query, "code");
-    const state = queryParam(args.query, "state");
-    const oauthError = queryParam(args.query, "error");
-    if (!code && !state && !oauthError) {
-        return { kind: "ignore" };
-    }
-    if (oauthError) {
-        if (state)
-            settleWebhookOAuthCompletion(state, null);
-        await clearPendingOAuthSession(args.storage);
-        return {
-            kind: "oauth",
-            status: 400,
-            html: oauthHtmlPage("Connection failed", `Linear returned: ${oauthError}. Return to OpenBot and try again.`, false),
-            tokens: null,
-            state,
-        };
-    }
-    const pending = await loadPendingOAuthSession(args.storage);
-    if (!pending || !code || !state || pending.state !== state) {
-        return {
-            kind: "oauth",
-            status: 400,
-            html: oauthHtmlPage("Connection failed", "Invalid callback (missing code or state mismatch). Return to OpenBot and try again.", false),
-            tokens: null,
-            state,
-        };
-    }
-    try {
-        const tokens = await exchangeAuthorizationCode({
-            code,
-            redirectUri: pending.redirectUri,
-            clientId: pending.clientId,
-            clientSecret: pending.clientSecret,
-            codeVerifier: pending.codeVerifier,
-        });
-        await args.onSuccess(tokens);
-        await clearPendingOAuthSession(args.storage);
-        settleWebhookOAuthCompletion(state, tokens);
-        return {
-            kind: "oauth",
-            status: 200,
-            html: oauthHtmlPage("Connected to Linear", "You can close this tab and return to OpenBot.", true),
-            tokens,
-            state,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        await clearPendingOAuthSession(args.storage);
-        settleWebhookOAuthCompletion(state, null);
-        return {
-            kind: "oauth",
-            status: 500,
-            html: oauthHtmlPage("Connection failed", `${message}. Return to OpenBot and try again.`, false),
-            tokens: null,
-            state,
-        };
-    }
-}
-function queryParam(query, key) {
-    const value = query[key];
-    if (typeof value === "string" && value.trim())
-        return value.trim();
-    if (Array.isArray(value) && typeof value[0] === "string") {
-        return value[0].trim();
-    }
-    return undefined;
-}
-export function startOAuthFlow(args) {
-    if (activeServer) {
-        activeServer.close();
-        activeServer = null;
-    }
-    const { state, codeVerifier, codeChallenge } = generatePkce();
-    const redirectUri = `http://localhost:${args.port}${LOOPBACK_CALLBACK_PATH}`;
-    const authorizeUrl = buildAuthorizeUrl({
-        clientId: args.clientId,
-        redirectUri,
-        scopes: args.scopes,
-        state,
-        codeChallenge,
-    });
-    let settle;
-    const completion = new Promise((resolve) => {
-        settle = resolve;
-    });
-    const server = createServer(async (req, res) => {
-        const url = new URL(req.url ?? "/", `http://localhost:${args.port}`);
-        if (url.pathname !== LOOPBACK_CALLBACK_PATH) {
-            res.writeHead(404).end();
-            return;
-        }
-        const finish = (status, title, body, ok) => {
-            res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
-            res.end(oauthHtmlPage(title, body, ok));
-        };
-        const error = url.searchParams.get("error");
-        if (error) {
-            finish(400, "Connection failed", `Linear returned: ${error}. Return to OpenBot and try again.`, false);
-            cleanup();
-            args.onError?.(new Error(`Linear authorization failed: ${error}`));
-            settle(null);
-            return;
-        }
-        const code = url.searchParams.get("code");
-        if (!code || url.searchParams.get("state") !== state) {
-            finish(400, "Connection failed", "Invalid callback (missing code or state mismatch). Return to OpenBot and try again.", false);
-            return;
-        }
-        try {
-            const tokens = await exchangeAuthorizationCode({
-                code,
-                redirectUri,
-                clientId: args.clientId,
-                clientSecret: args.clientSecret,
-                codeVerifier,
-            });
-            await args.onSuccess(tokens);
-            finish(200, "Connected to Linear", "You can close this tab and return to OpenBot.", true);
-            cleanup();
-            settle(tokens);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            finish(500, "Connection failed", `${message}. Return to OpenBot and try again.`, false);
-            cleanup();
-            args.onError?.(error instanceof Error ? error : new Error(message));
-            settle(null);
-        }
-    });
-    const timeout = setTimeout(() => {
-        cleanup();
-        settle(null);
-    }, args.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    timeout.unref?.();
-    function cleanup() {
-        clearTimeout(timeout);
-        if (activeServer === server)
-            activeServer = null;
-        server.close();
-    }
-    server.on("error", (error) => {
-        cleanup();
-        args.onError?.(error);
-        settle(null);
-    });
-    server.listen(args.port);
-    activeServer = server;
-    return {
-        authorizeUrl,
-        redirectUri,
-        completion,
-        cancel: () => {
-            cleanup();
-            settle(null);
-        },
-    };
-}
-export async function fetchViewer(accessToken) {
-    const response = await fetch(LINEAR_GRAPHQL_URL, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${accessToken}`,
-        },
-        body: JSON.stringify({
-            query: `query { viewer { id name displayName email } organization { id name urlKey } }`,
-        }),
-    });
-    if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        throw new Error(`Linear API request failed (${response.status}): ${body.slice(0, 500)}`);
-    }
-    const payload = (await response.json());
-    if (payload.errors?.length) {
-        throw new Error(payload.errors.map((e) => e.message).join("; "));
-    }
-    if (!payload.data) {
-        throw new Error("Linear API returned no data.");
-    }
-    return payload.data;
-}

package/dist/tools.d.ts DELETED Viewed

@@ -1,17 +0,0 @@
-/**
- * Linear tool implementations. Each tool returns structured `data` for the
- * model plus a human-readable `output` summary, and optionally a UI widget
- * spec rendered in the OpenBot client.
- */
-import type { RenderUIWidgetData, ToolDefinition } from '@meetopenbot/plugin-sdk';
-import { type LinearAuth } from './api.js';
-export interface ToolRunResult {
-    data: unknown;
-    output: string;
-    widget?: RenderUIWidgetData;
-}
-export interface LinearTool {
-    definition: ToolDefinition;
-    run: (auth: LinearAuth, args: Record<string, unknown>) => Promise<ToolRunResult>;
-}
-export declare const linearTools: Record<string, LinearTool>;

package/dist/tools.js DELETED Viewed

@@ -1,266 +0,0 @@
-/**
- * Linear tool implementations. Each tool returns structured `data` for the
- * model plus a human-readable `output` summary, and optionally a UI widget
- * spec rendered in the OpenBot client.
- */
-import { z } from 'zod';
-import { ISSUE_FIELDS, LinearApiError, fetchViewer, formatIssue, linearRequest, resolveTeam, } from './api.js';
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-async function resolveIssueId(auth, idOrIdentifier) {
-    if (UUID_RE.test(idOrIdentifier))
-        return idOrIdentifier;
-    const issue = await findIssueByIdentifier(auth, idOrIdentifier);
-    return issue.id;
-}
-async function findIssueByIdentifier(auth, identifier) {
-    const data = await linearRequest(auth, `query($term: String!) { searchIssues(term: $term, first: 10) { nodes { ${ISSUE_FIELDS} } } }`, { term: identifier });
-    const match = data.searchIssues.nodes.find((n) => n.identifier.toLowerCase() === identifier.toLowerCase());
-    if (!match)
-        throw new LinearApiError(`No Linear issue found with identifier "${identifier}".`);
-    return match;
-}
-function issueListWidget(title, issues) {
-    return {
-        kind: 'list',
-        title,
-        items: issues.map((issue) => ({
-            id: issue.id,
-            label: `${issue.identifier} · ${issue.title}`,
-            description: [issue.assignee?.displayName, issue.project?.name].filter(Boolean).join(' · ') || undefined,
-            status: issue.state?.name,
-            statusVariant: issue.state?.type === 'completed'
-                ? 'success'
-                : issue.state?.type === 'started'
-                    ? 'info'
-                    : issue.state?.type === 'canceled'
-                        ? 'danger'
-                        : 'default',
-            metadata: { url: issue.url },
-        })),
-    };
-}
-export const linearTools = {
-    linear_status: {
-        definition: {
-            description: 'Check whether Linear is connected and which user/workspace the credentials belong to.',
-            // The openbot runtime plugin passes inputSchema straight to the AI SDK,
-            // which requires Zod schemas (plain JSON Schema objects fail).
-            inputSchema: z.object({}),
-        },
-        run: async (auth) => {
-            const { viewer, organization } = await fetchViewer(auth);
-            return {
-                data: { connected: true, viewer, organization, authKind: auth.kind },
-                output: `Connected to Linear workspace "${organization.name}" as ${viewer.displayName ?? viewer.name} (${viewer.email}) via ${auth.kind === 'apiKey' ? 'API key' : 'OAuth'}.`,
-            };
-        },
-    },
-    list_teams: {
-        definition: {
-            description: 'List Linear teams, including their workflow states (useful for setting issue status).',
-            inputSchema: z.object({}),
-        },
-        run: async (auth) => {
-            const data = await linearRequest(auth, `query { teams(first: 100) { nodes { id key name states { nodes { id name type } } } } }`);
-            const teams = data.teams.nodes;
-            return {
-                data: teams,
-                output: `Found ${teams.length} team(s): ${teams.map((t) => `${t.key} (${t.name})`).join(', ')}`,
-            };
-        },
-    },
-    list_issues: {
-        definition: {
-            description: 'List Linear issues, optionally filtered by team (key, name, or id), assignee ("me" or a user id), and state type.',
-            inputSchema: z.object({
-                team: z.string().optional().describe('Team key (e.g. "ENG"), name, or id'),
-                assignee: z.string().optional().describe('"me" for the connected user, or a Linear user id'),
-                stateType: z
-                    .enum(['triage', 'backlog', 'unstarted', 'started', 'completed', 'canceled'])
-                    .optional()
-                    .describe('Filter by workflow state type'),
-                limit: z.number().optional().describe('Max issues to return (default 25)'),
-            }),
-        },
-        run: async (auth, args) => {
-            const { team, assignee, stateType, limit } = args;
-            const filter = {};
-            if (team)
-                filter.team = { id: { eq: (await resolveTeam(auth, team)).id } };
-            if (stateType)
-                filter.state = { type: { eq: stateType } };
-            if (assignee) {
-                if (assignee === 'me') {
-                    const { viewer } = await fetchViewer(auth);
-                    filter.assignee = { id: { eq: viewer.id } };
-                }
-                else {
-                    filter.assignee = { id: { eq: assignee } };
-                }
-            }
-            const data = await linearRequest(auth, `query($filter: IssueFilter, $first: Int!) { issues(filter: $filter, first: $first, orderBy: updatedAt) { nodes { ${ISSUE_FIELDS} } } }`, { filter, first: Math.min(limit ?? 25, 100) });
-            const issues = data.issues.nodes;
-            return {
-                data: issues.map(formatIssue),
-                output: `Found ${issues.length} issue(s).`,
-                widget: issueListWidget('Linear Issues', issues),
-            };
-        },
-    },
-    search_issues: {
-        definition: {
-            description: 'Full-text search Linear issues by keyword.',
-            inputSchema: z.object({
-                query: z.string().describe('Search term'),
-                limit: z.number().optional().describe('Max results (default 10)'),
-            }),
-        },
-        run: async (auth, args) => {
-            const { query, limit } = args;
-            const data = await linearRequest(auth, `query($term: String!, $first: Int!) { searchIssues(term: $term, first: $first) { nodes { ${ISSUE_FIELDS} } } }`, { term: query, first: Math.min(limit ?? 10, 50) });
-            const issues = data.searchIssues.nodes;
-            return {
-                data: issues.map(formatIssue),
-                output: `Found ${issues.length} issue(s) matching "${query}".`,
-                widget: issueListWidget(`Search: ${query}`, issues),
-            };
-        },
-    },
-    get_issue: {
-        definition: {
-            description: 'Get full details of a Linear issue by identifier (e.g. "ENG-123") or id, including comments.',
-            inputSchema: z.object({
-                issue: z.string().describe('Issue identifier (e.g. "ENG-123") or Linear issue id'),
-            }),
-        },
-        run: async (auth, args) => {
-            const { issue: issueRef } = args;
-            const issueId = await resolveIssueId(auth, issueRef);
-            const data = await linearRequest(auth, `query($id: String!) { issue(id: $id) { ${ISSUE_FIELDS} comments(first: 25) { nodes { body createdAt user { displayName } } } } }`, { id: issueId });
-            const issue = data.issue;
-            const comments = issue.comments.nodes.map((c) => ({
-                author: c.user?.displayName,
-                createdAt: c.createdAt,
-                body: c.body,
-            }));
-            return {
-                data: { ...formatIssue(issue), comments },
-                output: `Retrieved ${issue.identifier}: ${issue.title} (${issue.state?.name ?? 'unknown state'}).`,
-            };
-        },
-    },
-    create_issue: {
-        definition: {
-            description: 'Create a new Linear issue.',
-            inputSchema: z.object({
-                team: z.string().describe('Team key (e.g. "ENG"), name, or id'),
-                title: z.string().describe('Issue title'),
-                description: z.string().optional().describe('Issue description (markdown)'),
-                priority: z.number().optional().describe('0 none, 1 urgent, 2 high, 3 medium, 4 low'),
-                assignee: z.string().optional().describe('"me" or a Linear user id'),
-                stateId: z.string().optional().describe('Workflow state id (see list_teams)'),
-            }),
-        },
-        run: async (auth, args) => {
-            const { team, title, description, priority, assignee, stateId } = args;
-            const teamId = (await resolveTeam(auth, team)).id;
-            let assigneeId = assignee;
-            if (assignee === 'me')
-                assigneeId = (await fetchViewer(auth)).viewer.id;
-            const data = await linearRequest(auth, `mutation($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { ${ISSUE_FIELDS} } } }`, { input: { teamId, title, description, priority, assigneeId, stateId } });
-            const issue = data.issueCreate.issue;
-            return {
-                data: formatIssue(issue),
-                output: `Created ${issue.identifier}: ${issue.title} — ${issue.url}`,
-            };
-        },
-    },
-    update_issue: {
-        definition: {
-            description: 'Update a Linear issue (title, description, priority, state, assignee).',
-            inputSchema: z.object({
-                issue: z.string().describe('Issue identifier (e.g. "ENG-123") or id'),
-                title: z.string().optional().describe('New title'),
-                description: z.string().optional().describe('New description (markdown)'),
-                priority: z.number().optional().describe('0 none, 1 urgent, 2 high, 3 medium, 4 low'),
-                assignee: z.string().optional().describe('"me", a Linear user id, or "none" to unassign'),
-                stateId: z.string().optional().describe('Workflow state id (see list_teams)'),
-            }),
-        },
-        run: async (auth, args) => {
-            const { issue: issueRef, title, description, priority, assignee, stateId } = args;
-            const issueId = await resolveIssueId(auth, issueRef);
-            let assigneeId = assignee;
-            if (assignee === 'me')
-                assigneeId = (await fetchViewer(auth)).viewer.id;
-            if (assignee === 'none')
-                assigneeId = null;
-            const data = await linearRequest(auth, `mutation($id: String!, $input: IssueUpdateInput!) { issueUpdate(id: $id, input: $input) { success issue { ${ISSUE_FIELDS} } } }`, { id: issueId, input: { title, description, priority, assigneeId, stateId } });
-            const issue = data.issueUpdate.issue;
-            return {
-                data: formatIssue(issue),
-                output: `Updated ${issue.identifier}: ${issue.title} (${issue.state?.name ?? 'unknown state'}).`,
-            };
-        },
-    },
-    create_comment: {
-        definition: {
-            description: 'Add a comment to a Linear issue.',
-            inputSchema: z.object({
-                issue: z.string().describe('Issue identifier (e.g. "ENG-123") or id'),
-                body: z.string().describe('Comment body (markdown)'),
-            }),
-        },
-        run: async (auth, args) => {
-            const { issue: issueRef, body } = args;
-            const issueId = await resolveIssueId(auth, issueRef);
-            await linearRequest(auth, `mutation($input: CommentCreateInput!) { commentCreate(input: $input) { success } }`, { input: { issueId, body } });
-            return {
-                data: { success: true },
-                output: `Comment added to ${issueRef}.`,
-            };
-        },
-    },
-    list_projects: {
-        definition: {
-            description: 'List Linear projects.',
-            inputSchema: z.object({
-                limit: z.number().optional().describe('Max projects to return (default 25)'),
-            }),
-        },
-        run: async (auth, args) => {
-            const { limit } = args;
-            const data = await linearRequest(auth, `query($first: Int!) { projects(first: $first) { nodes { id name state progress url lead { displayName } } } }`, { first: Math.min(limit ?? 25, 100) });
-            const projects = data.projects.nodes;
-            return {
-                data: projects,
-                output: `Found ${projects.length} project(s): ${projects.map((p) => p.name).join(', ')}`,
-                widget: {
-                    kind: 'list',
-                    title: 'Linear Projects',
-                    items: projects.map((p) => ({
-                        id: p.id,
-                        label: p.name,
-                        description: p.lead?.displayName ? `Lead: ${p.lead.displayName}` : undefined,
-                        status: p.state,
-                        metadata: { url: p.url },
-                    })),
-                },
-            };
-        },
-    },
-    list_users: {
-        definition: {
-            description: 'List members of the Linear workspace (useful for resolving assignee ids).',
-            inputSchema: z.object({}),
-        },
-        run: async (auth) => {
-            const data = await linearRequest(auth, `query { users(first: 100) { nodes { id name displayName email active } } }`);
-            const users = data.users.nodes.filter((u) => u.active);
-            return {
-                data: users,
-                output: `Found ${users.length} active user(s).`,
-            };
-        },
-    },
-};