@meetopenbot/linear 0.0.2 → 0.0.4

package/dist/mcp-tool-args.js

@@ -0,0 +1,38 @@
+export function sanitizeMcpToolArgs(args) {
+    if (args === null || args === undefined)
+        return args;
+    if (typeof args !== "object" || Array.isArray(args))
+        return args;
+    const result = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (value === "")
+            continue;
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            const nested = sanitizeMcpToolArgs(value);
+            if (nested &&
+                typeof nested === "object" &&
+                !Array.isArray(nested) &&
+                Object.keys(nested).length > 0) {
+                result[key] = nested;
+            }
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+export function wrapMcpTools(tools) {
+    const wrapped = { ...tools };
+    for (const [name, tool] of Object.entries(tools)) {
+        if (!tool.execute)
+            continue;
+        const originalExecute = tool.execute.bind(tool);
+        wrapped[name] = {
+            ...tool,
+            execute: (input, options) => originalExecute(sanitizeMcpToolArgs(input), options),
+        };
+    }
+    return wrapped;
+}

package/dist/model-registry.js

@@ -0,0 +1,40 @@
+const REGISTRY_URL = "https://raw.githubusercontent.com/meetopenbot/openbot-registry/main/registry.json";
+const OPENAI_PROVIDER = "openai";
+const freeInputModelField = () => ({
+    type: "string",
+    override: true,
+    description: "OpenAI model in provider/model-id format (e.g. openai/gpt-4o-mini).",
+    default: "openai/gpt-4o-mini",
+});
+/** Registry-backed model field for plugin configSchema (`enum` + labeled `options`). */
+export async function resolveModelConfigField() {
+    try {
+        const res = await fetch(REGISTRY_URL, {
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok)
+            return freeInputModelField();
+        const registry = (await res.json());
+        const provider = registry.providers?.[OPENAI_PROVIDER];
+        const models = provider?.models ?? [];
+        if (models.length === 0)
+            return freeInputModelField();
+        const defaultModel = models.find((model) => model.id === "gpt-4o-mini")?.id ?? models[0].id;
+        return {
+            type: "string",
+            override: true,
+            description: "OpenAI model from the OpenBot registry.",
+            default: `${OPENAI_PROVIDER}/${defaultModel}`,
+            enum: models.map((model) => `${OPENAI_PROVIDER}/${model.id}`),
+            options: models.map((model) => ({
+                label: `${provider?.label ?? "OpenAI"} — ${model.label}`,
+                value: `${OPENAI_PROVIDER}/${model.id}`,
+                description: model.description,
+            })),
+        };
+    }
+    catch {
+        return freeInputModelField();
+    }
+}

package/dist/model.js

@@ -0,0 +1,24 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { CREDITS_API_KEY_PLACEHOLDER, INTEGRATIONS_TOKEN_HEADER, creditsProviderBaseUrl, resolveCreditsAuthConfig, shouldUseCreditsAuth, } from "./credits-auth.js";
+function normalizeOpenAiModelId(model) {
+    return model.includes("/") ? model.split("/").slice(1).join("/") : model;
+}
+export function resolveOpenAiModel(model, options) {
+    const modelId = normalizeOpenAiModelId(model);
+    const useCredits = shouldUseCreditsAuth(options);
+    if (useCredits) {
+        const config = resolveCreditsAuthConfig();
+        if (!config) {
+            throw new Error("OpenBot Credits is not configured. The cloud host must set OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN.");
+        }
+        const baseURL = creditsProviderBaseUrl(config);
+        const headers = { [INTEGRATIONS_TOKEN_HEADER]: config.token };
+        const apiKey = config.token || CREDITS_API_KEY_PLACEHOLDER;
+        return createOpenAI({ baseURL, apiKey, headers })(modelId);
+    }
+    const apiKey = options?.openaiApiKey?.trim();
+    if (!apiKey) {
+        throw new Error("OpenAI API key is required in BYOK mode. Add `OPENAI_API_KEY` under workspace settings or switch `authMode` to `credits` on cloud.");
+    }
+    return createOpenAI({ apiKey })(modelId);
+}

package/dist/thread-context.js

@@ -0,0 +1,72 @@
+export const MAX_THREAD_CONTEXT_LINES = 20;
+export function threadEventsToContextLines(events, agentId) {
+    const lines = [];
+    for (const raw of events) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const event = raw;
+        if (event.meta?.parentToolCallId)
+            continue;
+        switch (event.type) {
+            case "agent:invoke": {
+                const role = event.data?.role ?? "user";
+                const content = typeof event.data?.content === "string"
+                    ? event.data.content.trim()
+                    : "";
+                if (role === "user" && content) {
+                    lines.push({ role: "user", content });
+                }
+                break;
+            }
+            case "agent:output": {
+                if (event.meta?.agentId !== agentId)
+                    break;
+                const content = typeof event.data?.content === "string"
+                    ? event.data.content.trim()
+                    : "";
+                if (!content)
+                    break;
+                const last = lines[lines.length - 1];
+                if (last?.role === "assistant") {
+                    last.content += content;
+                }
+                else {
+                    lines.push({ role: "assistant", content });
+                }
+                break;
+            }
+        }
+    }
+    if (lines.length > MAX_THREAD_CONTEXT_LINES) {
+        return lines.slice(-MAX_THREAD_CONTEXT_LINES);
+    }
+    return lines;
+}
+export function formatThreadContext(lines) {
+    if (lines.length === 0)
+        return "";
+    const jsonl = lines.map((line) => JSON.stringify(line)).join("\n");
+    return `Previous conversation context (most recent last):\n${jsonl}`;
+}
+export async function loadThreadContext(storage, args) {
+    if (!args.channelId)
+        return "";
+    try {
+        const events = await storage.getEvents({
+            channelId: args.channelId,
+            threadId: args.threadId,
+        });
+        let lines = threadEventsToContextLines(events, args.agentId);
+        const currentMessage = args.currentMessage?.trim();
+        if (currentMessage) {
+            const last = lines[lines.length - 1];
+            if (last?.role === "user" && last.content === currentMessage) {
+                lines = lines.slice(0, -1);
+            }
+        }
+        return formatThreadContext(lines);
+    }
+    catch {
+        return "";
+    }
+}

package/package.json

@@ -1,41 +1,30 @@
 {
   "name": "@meetopenbot/linear",
-  "version": "0.0.2",
-  "description": "Linear OAuth connect flow and MCP-backed agent for issues, projects, and comments",
+  "version": "0.0.4",
+  "description": "Linear MCP-backed specialist agent for OpenBot",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "src",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
+  "exports": {
+    ".": "./dist/index.js"
   },
   "publishConfig": {
     "access": "public"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/meetopenbot/plugin-linear.git"
-  },
-  "keywords": [
-    "openbot",
-    "plugin",
-    "linear",
-    "oauth"
+  "files": [
+    "dist"
   ],
+  "scripts": {
+    "build": "tsc"
+  },
   "dependencies": {
     "@ai-sdk/mcp": "^2.0.14",
     "@ai-sdk/openai": "^4.0.15",
     "@meetopenbot/plugin-sdk": "^0.1.8",
-    "ai": "^7.0.29",
-    "mcp-server-linear": "^1.6.0"
+    "ai": "^7.0.29"
   },
   "devDependencies": {
-    "@types/node": "^25.9.1",
-    "typescript": "^6.0.3"
+    "@types/node": "^20.10.1",
+    "typescript": "^5.9.3"
   }
 }

package/dist/api.d.ts

@@ -1,17 +0,0 @@
-/**
- * Minimal Linear GraphQL helpers used by the OAuth connect flow.
- */
-export declare const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
-export declare function fetchViewer(accessToken: string): Promise<{
-    viewer: {
-        id: string;
-        name: string;
-        displayName: string;
-        email: string;
-    };
-    organization: {
-        id: string;
-        name: string;
-        urlKey: string;
-    };
-}>;

package/dist/api.js

@@ -1,29 +0,0 @@
-/**
- * Minimal Linear GraphQL helpers used by the OAuth connect flow.
- */
-export const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
-async function linearGraphql(accessToken, query, variables) {
-    const response = await fetch(LINEAR_GRAPHQL_URL, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${accessToken}`,
-        },
-        body: JSON.stringify({ query, variables }),
-    });
-    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;
-}
-export async function fetchViewer(accessToken) {
-    return linearGraphql(accessToken, `query { viewer { id name displayName email } organization { id name urlKey } }`);
-}

package/dist/auth.d.ts

@@ -1,33 +0,0 @@
-/**
- * Credential resolution for the Linear plugin.
- *
- * Priority:
- *   1. `apiKey` in plugin config (AGENT.md) — personal API key.
- *   2. `LINEAR_API_KEY` workspace variable / env — personal API key.
- *   3. `LINEAR_ACCESS_TOKEN` workspace variable — OAuth token saved by
- *      `linear_connect`, refreshed automatically via `LINEAR_REFRESH_TOKEN`.
- */
-import type { PluginContext } from '@meetopenbot/plugin-sdk';
-import type { LinearAuth } from './api.js';
-import { type OAuthTokens } from './oauth.js';
-export declare const VAR_API_KEY = "LINEAR_API_KEY";
-export declare const VAR_ACCESS_TOKEN = "LINEAR_ACCESS_TOKEN";
-export declare const VAR_REFRESH_TOKEN = "LINEAR_REFRESH_TOKEN";
-export declare const VAR_TOKEN_EXPIRES_AT = "LINEAR_TOKEN_EXPIRES_AT";
-/** Stored by the runtime's install-time OAuth flow; used to refresh tokens. */
-export declare const VAR_CLIENT_ID = "LINEAR_CLIENT_ID";
-export interface LinearPluginConfig {
-    apiKey?: string;
-    clientId?: string;
-    clientSecret?: string;
-    oauthPort?: number;
-    scopes?: string;
-}
-export declare function readConfig(context: PluginContext): LinearPluginConfig;
-export declare function saveTokens(context: PluginContext, tokens: OAuthTokens): Promise<void>;
-export declare function clearTokens(context: PluginContext): Promise<void>;
-export declare class NotConnectedError extends Error {
-    constructor();
-}
-/** Resolve usable Linear credentials, refreshing the OAuth token if needed. */
-export declare function resolveAuth(context: PluginContext): Promise<LinearAuth>;

package/dist/auth.js

@@ -1,91 +0,0 @@
-/**
- * Credential resolution for the Linear plugin.
- *
- * Priority:
- *   1. `apiKey` in plugin config (AGENT.md) — personal API key.
- *   2. `LINEAR_API_KEY` workspace variable / env — personal API key.
- *   3. `LINEAR_ACCESS_TOKEN` workspace variable — OAuth token saved by
- *      `linear_connect`, refreshed automatically via `LINEAR_REFRESH_TOKEN`.
- */
-import { refreshAccessToken } from './oauth.js';
-export const VAR_API_KEY = 'LINEAR_API_KEY';
-export const VAR_ACCESS_TOKEN = 'LINEAR_ACCESS_TOKEN';
-export const VAR_REFRESH_TOKEN = 'LINEAR_REFRESH_TOKEN';
-export const VAR_TOKEN_EXPIRES_AT = 'LINEAR_TOKEN_EXPIRES_AT';
-/** Stored by the runtime's install-time OAuth flow; used to refresh tokens. */
-export const VAR_CLIENT_ID = 'LINEAR_CLIENT_ID';
-/** Refresh this long before the reported expiry. */
-const REFRESH_MARGIN_MS = 5 * 60 * 1000;
-export function readConfig(context) {
-    const config = (context.config ?? {});
-    return {
-        apiKey: typeof config.apiKey === 'string' && config.apiKey.trim() ? config.apiKey.trim() : undefined,
-        clientId: typeof config.clientId === 'string' && config.clientId.trim() ? config.clientId.trim() : undefined,
-        clientSecret: typeof config.clientSecret === 'string' && config.clientSecret.trim() ? config.clientSecret.trim() : undefined,
-        oauthPort: typeof config.oauthPort === 'number' ? config.oauthPort : 4137,
-        scopes: typeof config.scopes === 'string' && config.scopes.trim()
-            ? config.scopes.trim()
-            : 'read,write,issues:create,comments:create',
-    };
-}
-function variableValue(variables, key) {
-    const entry = variables[key];
-    if (typeof entry === 'string')
-        return entry || undefined;
-    return entry?.value || undefined;
-}
-export async function saveTokens(context, tokens) {
-    await context.storage.createVariable({ key: VAR_ACCESS_TOKEN, value: tokens.accessToken, secret: true });
-    if (tokens.refreshToken) {
-        await context.storage.createVariable({ key: VAR_REFRESH_TOKEN, value: tokens.refreshToken, secret: true });
-    }
-    if (tokens.expiresAt) {
-        await context.storage.createVariable({ key: VAR_TOKEN_EXPIRES_AT, value: String(tokens.expiresAt), secret: false });
-    }
-}
-export async function clearTokens(context) {
-    for (const key of [VAR_ACCESS_TOKEN, VAR_REFRESH_TOKEN, VAR_TOKEN_EXPIRES_AT]) {
-        await context.storage.deleteVariable({ key }).catch(() => { });
-    }
-}
-export class NotConnectedError extends Error {
-    constructor() {
-        super('Linear is not connected. Use the `linear_connect` tool to connect with OAuth, or set an API key in the plugin config / LINEAR_API_KEY variable.');
-        this.name = 'NotConnectedError';
-    }
-}
-/** Resolve usable Linear credentials, refreshing the OAuth token if needed. */
-export async function resolveAuth(context) {
-    const config = readConfig(context);
-    if (config.apiKey)
-        return { kind: 'apiKey', token: config.apiKey };
-    const variables = (await context.storage.getVariables().catch(() => ({})));
-    const apiKey = variableValue(variables, VAR_API_KEY) ?? process.env[VAR_API_KEY];
-    if (apiKey)
-        return { kind: 'apiKey', token: apiKey };
-    const accessToken = variableValue(variables, VAR_ACCESS_TOKEN) ?? process.env[VAR_ACCESS_TOKEN];
-    if (!accessToken)
-        throw new NotConnectedError();
-    const expiresAtRaw = variableValue(variables, VAR_TOKEN_EXPIRES_AT) ?? process.env[VAR_TOKEN_EXPIRES_AT];
-    const expiresAt = expiresAtRaw ? Number(expiresAtRaw) : undefined;
-    const refreshToken = variableValue(variables, VAR_REFRESH_TOKEN) ?? process.env[VAR_REFRESH_TOKEN];
-    // Client id from plugin config, or the variable stored by the runtime's
-    // install-time OAuth flow (openbot.one plugins page).
-    const clientId = config.clientId ?? variableValue(variables, VAR_CLIENT_ID) ?? process.env[VAR_CLIENT_ID];
-    const needsRefresh = expiresAt !== undefined && Number.isFinite(expiresAt) && Date.now() > expiresAt - REFRESH_MARGIN_MS;
-    if (needsRefresh && refreshToken && clientId) {
-        try {
-            const tokens = await refreshAccessToken({
-                refreshToken,
-                clientId,
-                clientSecret: config.clientSecret,
-            });
-            await saveTokens(context, tokens);
-            return { kind: 'oauth', token: tokens.accessToken };
-        }
-        catch {
-            // Fall through and try the stored token; a 401 will tell the user to reconnect.
-        }
-    }
-    return { kind: 'oauth', token: accessToken };
-}

package/dist/config.d.ts

@@ -1,39 +0,0 @@
-import type { Storage } from "@meetopenbot/plugin-sdk";
-import { type OAuthTokens } from "./oauth.js";
-export declare const VAR_API_KEY = "LINEAR_API_KEY";
-export declare const VAR_ACCESS_TOKEN = "LINEAR_ACCESS_TOKEN";
-export declare const VAR_REFRESH_TOKEN = "LINEAR_REFRESH_TOKEN";
-export declare const VAR_TOKEN_EXPIRES_AT = "LINEAR_TOKEN_EXPIRES_AT";
-export declare const VAR_CLIENT_ID = "LINEAR_CLIENT_ID";
-export type LinearPluginConfig = {
-    clientId?: string;
-    clientSecret?: string;
-    apiKey?: string;
-    oauthPort?: number;
-    scopes?: string;
-    openaiApiKey?: string;
-    model?: string;
-    /** Public runtime base URL, e.g. https://my-host.com (used for OAuth webhook callback). */
-    webhookBaseUrl?: string;
-};
-export type LinearCredentials = {
-    accessToken: string;
-    openaiApiKey: string;
-    model: string;
-    clientId?: string;
-    clientSecret?: string;
-};
-export declare function readLinearConfig(config: Record<string, unknown>): LinearPluginConfig;
-export declare function resolveWebhookBaseUrl(config: LinearPluginConfig, publicBaseUrl?: string): string | undefined;
-export declare function saveTokens(storage: Storage, tokens: OAuthTokens): Promise<void>;
-export declare function clearTokens(storage: Storage): Promise<void>;
-export declare function formatMissingCredentials(missing: Array<"accessToken" | "openaiApiKey">): string;
-export declare function resolveLinearCredentials(config: LinearPluginConfig, storage: Storage, options?: {
-    requireOpenAi?: boolean;
-}): Promise<{
-    ok: true;
-    credentials: LinearCredentials;
-} | {
-    ok: false;
-    missing: Array<"accessToken" | "openaiApiKey">;
-}>;

package/dist/index.d.ts

@@ -1,53 +0,0 @@
-import { type PluginContext, type ToolDefinition } from "@meetopenbot/plugin-sdk";
-declare const _default: {
-    id: string;
-    name: string;
-    description: string;
-    configSchema: {
-        type: "object";
-        properties: {
-            clientId: {
-                type: "string";
-                description: string;
-            };
-            clientSecret: {
-                type: "string";
-                description: string;
-                format: "password";
-            };
-            apiKey: {
-                type: "string";
-                description: string;
-                format: "password";
-            };
-            oauthPort: {
-                type: "number";
-                description: string;
-                default: number;
-            };
-            scopes: {
-                type: "string";
-                description: string;
-                default: string;
-            };
-            webhookBaseUrl: {
-                type: "string";
-                description: string;
-                format: "url";
-            };
-            openaiApiKey: {
-                type: "string";
-                description: string;
-                format: "password";
-            };
-            model: {
-                type: "string";
-                description: string;
-                default: string;
-            };
-        };
-    };
-    toolDefinitions: Record<string, ToolDefinition>;
-    factory: (pluginContext: PluginContext) => (builder: import("melony").MelonyBuilder<import("@meetopenbot/plugin-sdk").OpenBotState, import("@meetopenbot/plugin-sdk").OpenBotEvent>) => void;
-};
-export default _default;

package/dist/linear-agent.d.ts

@@ -1,14 +0,0 @@
-import type { LinearIssue } from "./linear-issues.js";
-export type RunLinearAgentArgs = {
-    prompt: string;
-    openaiApiKey: string;
-    accessToken: string;
-    model?: string;
-};
-export type LinearAgentResult = {
-    text: string;
-    issues: LinearIssue[];
-    usedTools: boolean;
-    toolErrors: string[];
-};
-export declare function runLinearAgent(args: RunLinearAgentArgs): Promise<LinearAgentResult>;

package/dist/linear-issues.d.ts

@@ -1,33 +0,0 @@
-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;
-    };
-};
-export declare const ISSUES_LIST_WIDGET_ID = "linear-issues-list";
-export declare function buildIssuesListWidget(issues: LinearIssue[], options?: {
-    title?: string;
-    description?: string;
-}): RenderUIWidgetData;
-export declare function extractIssuesFromToolResults(toolResults: Array<{
-    toolName: string;
-    output: unknown;
-}>): LinearIssue[];
-export declare function isListIssuesPrompt(message: string): boolean;
-export declare function isAssignedIssuesPrompt(message: string): boolean;
-export declare function issuesListTitle(prompt: string): string;