@meetopenbot/linear 0.0.3 → 0.0.4

package/src/config.ts

@@ -1,230 +0,0 @@
-import type { Storage } from "@meetopenbot/plugin-sdk";
-import { refreshAccessToken, type OAuthTokens } 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";
-export const VAR_CLIENT_ID = "LINEAR_CLIENT_ID";
-export const GO_BACK_TO_OPENBOT_URL = "https://openbot.one/settings/agents";
-export const LINEAR_OPENBOT_CLIENT_ID = "1263fc2dbbf08efa7b2c4b1b2b2582be";
-
-const REFRESH_MARGIN_MS = 5 * 60 * 1000;
-
-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;
-};
-
-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 function readLinearConfig(
-  config: Record<string, unknown>,
-): LinearPluginConfig {
-  return {
-    clientId:
-      typeof config.clientId === "string" && config.clientId.trim()
-        ? config.clientId.trim()
-        : LINEAR_OPENBOT_CLIENT_ID,
-    clientSecret:
-      typeof config.clientSecret === "string" && config.clientSecret.trim()
-        ? config.clientSecret.trim()
-        : undefined,
-    apiKey:
-      typeof config.apiKey === "string" && config.apiKey.trim()
-        ? config.apiKey.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",
-    openaiApiKey:
-      typeof config.openaiApiKey === "string" && config.openaiApiKey.trim()
-        ? config.openaiApiKey.trim()
-        : undefined,
-    model:
-      typeof config.model === "string" && config.model.trim()
-        ? config.model.trim()
-        : undefined,
-    webhookBaseUrl:
-      typeof config.webhookBaseUrl === "string" && config.webhookBaseUrl.trim()
-        ? config.webhookBaseUrl.trim()
-        : undefined,
-  };
-}
-
-export function resolveWebhookBaseUrl(
-  config: LinearPluginConfig,
-  publicBaseUrl?: string,
-): string | undefined {
-  const explicit = config.webhookBaseUrl?.replace(/\/$/, "");
-  if (explicit) return explicit;
-  const host = publicBaseUrl?.trim().replace(/\/$/, "");
-  if (host) return host;
-  return undefined;
-}
-
-export async function saveTokens(
-  storage: Storage,
-  tokens: OAuthTokens,
-): Promise<void> {
-  await storage.createVariable({
-    key: VAR_ACCESS_TOKEN,
-    value: tokens.accessToken,
-    secret: true,
-  });
-  if (tokens.refreshToken) {
-    await storage.createVariable({
-      key: VAR_REFRESH_TOKEN,
-      value: tokens.refreshToken,
-      secret: true,
-    });
-  }
-  if (tokens.expiresAt) {
-    await storage.createVariable({
-      key: VAR_TOKEN_EXPIRES_AT,
-      value: String(tokens.expiresAt),
-      secret: false,
-    });
-  }
-}
-
-export async function clearTokens(storage: Storage): Promise<void> {
-  for (const key of [VAR_ACCESS_TOKEN, VAR_REFRESH_TOKEN, VAR_TOKEN_EXPIRES_AT]) {
-    await storage.deleteVariable({ key }).catch(() => { });
-  }
-}
-
-export function formatMissingCredentials(
-  missing: Array<"accessToken" | "openaiApiKey">,
-): string {
-  const lines = [
-    "Linear agent setup is incomplete. Configure the following in plugin config or environment variables:",
-  ];
-
-  if (missing.includes("accessToken")) {
-    lines.push(
-      "- Connect Linear with `linear_connect`, or set `apiKey` / `LINEAR_API_KEY`",
-    );
-  }
-  if (missing.includes("openaiApiKey")) {
-    lines.push(
-      "- `openaiApiKey` / `OPENAI_API_KEY` — OpenAI API key for the agent loop",
-    );
-  }
-
-  return lines.join("\n");
-}
-
-export async function resolveLinearCredentials(
-  config: LinearPluginConfig,
-  storage: Storage,
-  options?: { requireOpenAi?: boolean },
-): Promise<
-  | { ok: true; credentials: LinearCredentials }
-  | { ok: false; missing: Array<"accessToken" | "openaiApiKey"> }
-> {
-  const requireOpenAi = options?.requireOpenAi ?? true;
-  const variables = (await storage.getVariables().catch(() => ({}))) as Record<
-    string,
-    VariableValue
-  >;
-
-  const resolve = (configKey: keyof LinearPluginConfig, envKey: string) => {
-    const fromConfig = config[configKey];
-    if (typeof fromConfig === "string" && fromConfig.trim()) {
-      return fromConfig.trim();
-    }
-    if (process.env[envKey]?.trim()) return process.env[envKey]!.trim();
-    return variableValue(variables, envKey)?.trim();
-  };
-
-  const openaiApiKey = resolve("openaiApiKey", "OPENAI_API_KEY");
-  const model = resolve("model", "OPENAI_MODEL") ?? "gpt-4o-mini";
-
-  let accessToken =
-    config.apiKey ??
-    variableValue(variables, VAR_API_KEY) ??
-    process.env[VAR_API_KEY] ??
-    variableValue(variables, VAR_ACCESS_TOKEN) ??
-    process.env[VAR_ACCESS_TOKEN];
-
-  const clientId =
-    config.clientId ??
-    variableValue(variables, VAR_CLIENT_ID) ??
-    process.env[VAR_CLIENT_ID];
-  const clientSecret = config.clientSecret;
-
-  if (accessToken && !config.apiKey) {
-    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];
-
-    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,
-        });
-        await saveTokens(storage, tokens);
-        accessToken = tokens.accessToken;
-      } catch {
-        // Fall through; a 401 from Linear will prompt reconnect.
-      }
-    }
-  }
-
-  const missing: Array<"accessToken" | "openaiApiKey"> = [];
-  if (!accessToken) missing.push("accessToken");
-  if (requireOpenAi && !openaiApiKey) missing.push("openaiApiKey");
-
-  if (missing.length > 0) {
-    return { ok: false, missing };
-  }
-
-  return {
-    ok: true,
-    credentials: {
-      accessToken: accessToken!,
-      openaiApiKey: openaiApiKey ?? "",
-      model,
-      clientId,
-      clientSecret,
-    },
-  };
-}

package/src/index.ts

@@ -1,451 +0,0 @@
-import {
-  agentOutput,
-  definePlugin,
-  shouldHandleInvoke,
-  toolResult,
-  uiWidget,
-  webhookHttpResponse,
-  type AgentInvokeEvent,
-  type ConfigSchema,
-  type PluginContext,
-  type PluginHandlerContext,
-  type ToolActionEvent,
-  type ToolDefinition,
-  type WebhookEvent,
-} from "@meetopenbot/plugin-sdk";
-import {
-  clearTokens,
-  formatMissingCredentials,
-  LINEAR_OPENBOT_CLIENT_ID,
-  readLinearConfig,
-  resolveLinearCredentials,
-  resolveWebhookBaseUrl,
-  saveTokens,
-  type LinearPluginConfig,
-} from "./config.js";
-import { runLinearAgent } from "./linear-agent.js";
-import {
-  buildIssuesListWidget,
-  isAssignedIssuesPrompt,
-  isListIssuesPrompt,
-  issuesListTitle,
-} from "./linear-issues.js";
-import {
-  OAUTH_WEBHOOK_PROVIDER,
-  buildOAuthRedirectUri,
-  fetchViewer,
-  handleWebhookOAuthCallback,
-  startOAuthFlow,
-  startWebhookOAuthFlow,
-  type OAuthFlowHandle,
-} from "./oauth.js";
-
-/** Client-side action handled by openbot.one — opens `value.url` in the browser. */
-const OPEN_URL_ACTION_ID = "open_url";
-
-const CONNECT_TOOL: ToolDefinition = {
-  description:
-    "Connect the workspace to Linear via OAuth. Returns an authorization link the user must open in their browser; after they approve, the token is stored automatically. Use this when Linear is not connected yet or credentials expired.",
-  inputSchema: { type: "object", properties: {} },
-};
-
-const DISCONNECT_TOOL: ToolDefinition = {
-  description:
-    "Disconnect Linear: removes the stored OAuth tokens from the workspace.",
-  inputSchema: { type: "object", properties: {} },
-};
-
-const CONNECT_WAIT_MS = 120 * 1000;
-const CONNECT_WIDGET_ID = "linear-connect";
-const CONNECT_PROMPT_WIDGET_ID = "linear-connect-prompt";
-
-type ConnectReplyMode = "tool" | "agent";
-type ConnectEvent = { meta?: ToolActionEvent["meta"] };
-
-const toolDefinitions: Record<string, ToolDefinition> = {
-  linear_connect: CONNECT_TOOL,
-  linear_disconnect: DISCONNECT_TOOL,
-};
-
-type LinearPluginFactoryContext = PluginContext & {
-  publicBaseUrl?: string;
-};
-
-function* emitConnectReply(
-  mode: ConnectReplyMode,
-  context: PluginContext,
-  event: ConnectEvent,
-  data: { output: string; error?: string; [key: string]: unknown },
-) {
-  if (mode === "tool") {
-    yield toolResult("linear_connect", event as ToolActionEvent, data);
-    return;
-  }
-
-  yield agentOutput({
-    agentId: context.agentId,
-    content: data.output,
-    threadId: event.meta?.threadId,
-    meta: event.meta,
-  });
-}
-
-function* yieldOAuthAuthorizeWidget(
-  agentId: string,
-  authorizeUrl: string,
-  modeHint: string,
-  options: {
-    threadId?: string;
-    meta?: ConnectEvent["meta"];
-    widgetId?: string;
-  },
-) {
-  yield uiWidget({
-    agentId,
-    threadId: options.threadId,
-    meta: options.meta,
-    widget: {
-      kind: "message",
-      widgetId: options.widgetId ?? CONNECT_WIDGET_ID,
-      title: "Connect Linear",
-      body: `Open Linear in your browser to authorize OpenBot. ${modeHint}`,
-      actions: [
-        {
-          id: OPEN_URL_ACTION_ID,
-          label: "Connect Linear",
-          variant: "primary",
-          value: { url: authorizeUrl },
-        },
-      ],
-    },
-  });
-}
-
-async function createOAuthHandle(
-  context: PluginContext,
-  publicBaseUrl?: string,
-): Promise<{ handle: OAuthFlowHandle; modeHint: string } | null> {
-  const config = readLinearConfig(context.config ?? {});
-  const webhookBaseUrl = resolveWebhookBaseUrl(config, publicBaseUrl);
-
-  if (config.apiKey || !config.clientId) return null;
-
-  const scopes = config.scopes ?? "read,write,issues:create,comments:create";
-  const handle = webhookBaseUrl
-    ? await startWebhookOAuthFlow({
-        storage: context.storage,
-        clientId: config.clientId,
-        clientSecret: config.clientSecret,
-        scopes,
-        webhookBaseUrl,
-      })
-    : startOAuthFlow({
-        clientId: config.clientId,
-        clientSecret: config.clientSecret,
-        port: config.oauthPort ?? 4137,
-        scopes,
-        onSuccess: (tokens) => saveTokens(context.storage, tokens),
-      });
-
-  const modeHint = webhookBaseUrl
-    ? `After approval, Linear redirects to \`${handle.redirectUri}\`.`
-    : "After you approve access you'll be redirected back and can return here.";
-
-  return { handle, modeHint };
-}
-
-function notConnectedMessage(
-  missing: Array<"accessToken" | "openaiApiKey">,
-): string {
-  const needsConnect = missing.includes("accessToken");
-  const needsOpenAi = missing.includes("openaiApiKey");
-
-  if (needsConnect && needsOpenAi) {
-    return "Linear isn't connected yet, and the OpenAI API key is missing. Connect Linear below, then add `openaiApiKey` to the plugin config.";
-  }
-  if (needsConnect) {
-    return "Linear isn't connected yet. Click **Connect Linear** below to open the authorization page.";
-  }
-  return formatMissingCredentials(missing);
-}
-
-async function* handleConnect(
-  context: PluginContext,
-  event: ConnectEvent,
-  publicBaseUrl?: string,
-  replyMode: ConnectReplyMode = "tool",
-) {
-  const config = readLinearConfig(context.config ?? {});
-  const threadId = event.meta?.threadId;
-  const webhookBaseUrl = resolveWebhookBaseUrl(config, publicBaseUrl);
-
-  if (config.apiKey) {
-    yield* emitConnectReply(replyMode, context, event, {
-      output:
-        "Linear is already configured with an API key in the plugin config — no OAuth connection needed.",
-    });
-    return;
-  }
-
-  const oauth = await createOAuthHandle(context, publicBaseUrl);
-  if (!oauth) {
-    const webhookHint = webhookBaseUrl
-      ? `   set its callback URL to ${buildOAuthRedirectUri(webhookBaseUrl)},`
-      : `   set its callback URL to http://localhost:${config.oauthPort}/oauth/callback (local), or configure webhookBaseUrl for ${buildOAuthRedirectUri("https://<your-host>")},`;
-
-    yield* emitConnectReply(replyMode, context, event, {
-      output: [
-        "Linear OAuth is not configured. Ways to connect:",
-        "1. Recommended: open the OpenBot web app → Settings → Plugins and click Connect on the Linear plugin (install-time OAuth, no setup needed).",
-        "2. Self-hosted OAuth: create an OAuth application at https://linear.app/settings/api/applications,",
-        webhookHint,
-        "   then put its Client ID into this plugin's `clientId` config field and run linear_connect again.",
-        "3. API key: create a personal API key at https://linear.app/settings/api and put it into the `apiKey` config field (or a LINEAR_API_KEY secret variable).",
-      ].join("\n"),
-    });
-    return;
-  }
-
-  const { handle, modeHint } = oauth;
-
-  yield* yieldOAuthAuthorizeWidget(
-    context.agentId,
-    handle.authorizeUrl,
-    modeHint,
-    { threadId, meta: event.meta },
-  );
-
-  const outcome = await Promise.race([
-    handle.completion,
-    new Promise<"pending">((resolve) => {
-      const t = setTimeout(() => resolve("pending"), CONNECT_WAIT_MS);
-      t.unref?.();
-    }),
-  ]);
-
-  if (outcome === "pending") {
-    yield* emitConnectReply(replyMode, context, event, {
-      authorizeUrl: handle.authorizeUrl,
-      redirectUri: handle.redirectUri,
-      output:
-        "Authorization link sent. Waiting for the user to approve in the browser — the link stays valid for 10 minutes. Once they confirm, ask me to work with Linear again.",
-    });
-    return;
-  }
-
-  if (!outcome) {
-    yield* emitConnectReply(replyMode, context, event, {
-      error: "authorization_failed",
-      output:
-        "Linear authorization did not complete (denied, failed, or the callback is unavailable). Run linear_connect to try again.",
-    });
-    return;
-  }
-
-  let who = "";
-  try {
-    const { viewer, organization } = await fetchViewer(outcome.accessToken);
-    who = ` as ${viewer.displayName ?? viewer.name} in workspace "${organization.name}"`;
-  } catch {
-    // Connection succeeded even if the identity lookup failed.
-  }
-
-  yield uiWidget({
-    agentId: context.agentId,
-    threadId,
-    widget: {
-      kind: "message",
-      widgetId: CONNECT_WIDGET_ID,
-      title: "Linear connected",
-      body: `✅ Connected to Linear${who}.`,
-      state: "submitted",
-    },
-  });
-
-  yield* emitConnectReply(replyMode, context, event, {
-    connected: true,
-    output: `Successfully connected to Linear${who}. Tokens are stored securely and refresh automatically.`,
-  });
-}
-
-const linearPluginConfigSchema = {
-  type: "object",
-  properties: {
-    clientId: {
-      type: "string",
-      description:
-        "Linear OAuth application Client ID. Defaults to OpenBot's managed Linear application.",
-      default: LINEAR_OPENBOT_CLIENT_ID,
-    },
-    clientSecret: {
-      type: "string",
-      description:
-        "Linear OAuth application Client Secret (optional — PKCE is used when omitted)",
-      format: "password",
-    },
-    apiKey: {
-      type: "string",
-      description: "Linear personal API key (alternative to OAuth)",
-      format: "password",
-    },
-    oauthPort: {
-      type: "number",
-      description:
-        "Local port for the OAuth callback (must match the OAuth app callback URL)",
-      default: 4137,
-    },
-    scopes: {
-      type: "string",
-      description: "Comma-separated OAuth scopes",
-      default: "read,write,issues:create,comments:create",
-    },
-    webhookBaseUrl: {
-      type: "string",
-      description:
-        "Public runtime base URL for OAuth callback via /api/webhooks/linear (e.g. https://my-host.com). Falls back to host publicBaseUrl when omitted.",
-      format: "url",
-    },
-    openaiApiKey: {
-      type: "string",
-      description: "OpenAI API key for direct Linear agent invocations",
-      format: "password",
-    },
-    model: {
-      type: "string",
-      description:
-        "OpenAI model id for direct Linear agent invocations (default: gpt-4o-mini)",
-      default: "gpt-4o-mini",
-    },
-  },
-} satisfies ConfigSchema;
-
-export default definePlugin({
-  id: "linear",
-  name: "Linear",
-  description:
-    "Linear OAuth connect flow and MCP-backed agent for issues, projects, and comments",
-  configSchema: linearPluginConfigSchema,
-  toolDefinitions,
-  factory: (pluginContext) => (builder) => {
-    const { agentId, config, storage } = pluginContext;
-    const linearConfig = readLinearConfig(config) as LinearPluginConfig;
-    const publicBaseUrl =
-      (pluginContext as LinearPluginFactoryContext).publicBaseUrl ?? "";
-
-    builder.on("action:webhook", async function* (event) {
-      const webhook = event as WebhookEvent;
-      if (webhook.data.provider !== OAUTH_WEBHOOK_PROVIDER) return;
-
-      const result = await handleWebhookOAuthCallback({
-        storage,
-        query: webhook.data.query ?? {},
-        onSuccess: (tokens) => saveTokens(storage, tokens),
-      });
-
-      if (result.kind === "ignore") return;
-
-      yield webhookHttpResponse({
-        status: result.status,
-        headers: { "Content-Type": "text/html; charset=utf-8" },
-        body: result.html,
-      });
-    });
-
-    builder.on("action:linear_connect", async function* (event: ToolActionEvent) {
-      yield* handleConnect(pluginContext, event, publicBaseUrl);
-    });
-
-    builder.on("action:linear_disconnect", async function* (event: ToolActionEvent) {
-      await clearTokens(storage);
-      yield toolResult("linear_disconnect", event, {
-        output: "Linear disconnected — stored OAuth tokens were removed.",
-      });
-    });
-
-    builder.on("agent:invoke", async function* (
-      event: AgentInvokeEvent,
-      ctx: PluginHandlerContext,
-    ) {
-      if (!shouldHandleInvoke(event, agentId)) return;
-
-      if (event.meta?.threadId) {
-        ctx.state.threadId = event.meta.threadId;
-      }
-
-      const threadId = event.meta?.threadId ?? ctx.state.threadId;
-      const userMessage = (event.data.content ?? "").trim();
-      if (!userMessage || !threadId) return;
-
-      const auth = await resolveLinearCredentials(linearConfig, storage);
-      if (!auth.ok) {
-        yield agentOutput({
-          agentId,
-          content: notConnectedMessage(auth.missing),
-          threadId,
-          meta: event.meta,
-        });
-
-        if (auth.missing.includes("accessToken")) {
-          const oauth = await createOAuthHandle(pluginContext, publicBaseUrl);
-          if (oauth) {
-            yield* yieldOAuthAuthorizeWidget(
-              agentId,
-              oauth.handle.authorizeUrl,
-              oauth.modeHint,
-              {
-                threadId,
-                meta: event.meta,
-                widgetId: CONNECT_PROMPT_WIDGET_ID,
-              },
-            );
-          }
-        }
-        return;
-      }
-
-      try {
-        const reply = await runLinearAgent({
-          prompt: userMessage,
-          openaiApiKey: auth.credentials.openaiApiKey,
-          accessToken: auth.credentials.accessToken,
-          model: auth.credentials.model,
-        });
-
-        const issues = reply.issues;
-        const shouldListIssues =
-          isListIssuesPrompt(userMessage) || isAssignedIssuesPrompt(userMessage);
-
-        if (shouldListIssues || issues.length > 0) {
-          yield uiWidget({
-            agentId,
-            threadId,
-            meta: event.meta,
-            widget: buildIssuesListWidget(issues, {
-              title: issuesListTitle(userMessage),
-            }),
-          });
-        }
-
-        const content =
-          reply.toolErrors.length > 0 && !reply.usedTools
-            ? `${reply.text}\n\nMCP note: ${reply.toolErrors.join("; ")}`
-            : reply.text;
-
-        yield agentOutput({
-          agentId,
-          content,
-          threadId,
-          meta: event.meta,
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        yield agentOutput({
-          agentId,
-          content: `Linear agent error: ${message}`,
-          threadId,
-          meta: event.meta,
-        });
-      }
-    });
-  },
-});