@meetopenbot/github 0.0.1 → 0.1.1

package/README.md

@@ -1,53 +1,37 @@
-# GitHub OpenBot Plugin
+# @meetopenbot/github
 
-This plugin lets OpenBot interact with your GitHub account, enabling you to browse repositories, manage issues, and work with pull requests through natural language or direct tool calls.
+GitHub specialist agent for OpenBot, backed by GitHub's official remote MCP.
 
-## Features
+## Setup
 
-- **List Repositories**: View repositories for the authenticated user.
-- **Get Repository**: Get detailed information about a repository.
-- **List Issues**: See open or closed issues for a repository.
-- **Create Issue**: Open a new issue.
-- **List Pull Requests**: See pull requests for a repository.
-- **Get Pull Request**: Get details about a specific pull request.
-- **Create Pull Request**: Open a new pull request.
-- **Natural Language Support**: Ask the agent about your repos and it will summarize results.
+### GitHub token
 
-## Configuration
+If no GitHub token is already available (plugin config, `GITHUB_TOKEN` env, or a workspace variable), the agent shows a form. Submitting it stores the token as a secret `GITHUB_TOKEN` workspace variable.
 
-To use this plugin, you need a GitHub Personal Access Token. You can create one in your [GitHub Developer Settings](https://github.com/settings/tokens) with `repo` scope.
+You can also set the token in `AGENT.md`:
 
-### Config Schema
+```yaml
+plugins:
+  - id: "@meetopenbot/github"
+    config:
+      githubToken: ghp_your_token_here
+```
 
-- `githubToken` (Required): Your GitHub Personal Access Token.
-- `openaiApiKey` (Optional): OpenAI API key for natural language support (can also be set via environment).
+Create a Personal Access Token at [GitHub Developer Settings](https://github.com/settings/tokens) with `repo` scope.
 
-## Usage
-
-### Natural Language
+### OpenAI
 
-You can ask things like:
-
-- "What repositories do I have on GitHub?"
-- "Show me the open issues for owner/repo"
-- "Create an issue in owner/repo titled 'Fix login bug'"
-- "List the pull requests for owner/repo"
+On cloud, `authMode: credits` (the default) uses your workspace credit balance via OpenBot. For BYOK, set `authMode: byok` and add `OPENAI_API_KEY` under workspace settings.
 
-### Tools
+Locally, the agent uses BYOK from `OPENAI_API_KEY` in the environment or workspace variables.
 
-The plugin provides the following tools:
+## Usage
 
-- `list_repos`: List repositories for the authenticated user.
-- `get_repo`: Get repository details.
-- `list_issues`: List issues for a repository.
-- `create_issue`: Create a new issue.
-- `list_pull_requests`: List pull requests for a repository.
-- `get_pull_request`: Get pull request details.
-- `create_pull_request`: Create a new pull request.
+Ask things like:
 
-## Installation
+- "What repositories do I have on GitHub?"
+- "Show me the open issues for owner/repo"
+- "Create an issue in owner/repo titled Fix login bug"
+- "Show the diff for PR 42 in owner/repo"
 
-1. Clone this repository into your OpenBot plugins directory.
-2. Run `npm install`.
-3. Run `npm run build`.
-4. Configure the plugin in your `AGENT.md` or via the OpenBot UI.
+Pull request and commit file changes render as a **Diff** widget in the chat timeline.

package/dist/agent.js

@@ -0,0 +1,191 @@
+import { createMCPClient } from '@ai-sdk/mcp';
+import { toolTraceWidget } from '@meetopenbot/plugin-sdk';
+import { generateText, stepCountIs } from 'ai';
+import { resolveOpenAiModel } from './model.js';
+import { diffWidgetFromTool, prIdentityFromInput, shouldFollowUpPrFiles, toolInputFrom, unwrapToolOutput, } from './diff.js';
+export const GITHUB_MCP_URL = 'https://api.githubcopilot.com/mcp/';
+const TOOL_OUTPUT_MAX_LENGTH = 2_000;
+function formatToolOutput(output) {
+    if (output === undefined || output === null)
+        return 'Done.';
+    if (typeof output === 'string')
+        return truncate(output);
+    try {
+        return truncate(JSON.stringify(output, null, 2));
+    }
+    catch {
+        return truncate(String(output));
+    }
+}
+function truncate(text) {
+    if (text.length <= TOOL_OUTPUT_MAX_LENGTH)
+        return text;
+    return `${text.slice(0, TOOL_OUTPUT_MAX_LENGTH)}…`;
+}
+function toolCallWidget(args) {
+    return toolTraceWidget({
+        widgetId: args.widgetId,
+        groupId: 'github:tools',
+        title: args.title,
+        body: args.body,
+    });
+}
+function findMcpTool(tools, name) {
+    const direct = tools[name];
+    if (direct)
+        return direct;
+    const needle = name.toLowerCase();
+    for (const [key, tool] of Object.entries(tools)) {
+        if (key.toLowerCase() === needle || key.toLowerCase().includes(needle)) {
+            return tool;
+        }
+    }
+    return undefined;
+}
+async function fetchPrFilesDiffWidget(args) {
+    const identity = prIdentityFromInput(args.input);
+    if (!identity)
+        return null;
+    const tool = findMcpTool(args.tools, 'pull_request_read');
+    if (!tool?.execute)
+        return null;
+    try {
+        const output = await tool.execute({
+            method: 'get_files',
+            owner: identity.owner,
+            repo: identity.repo,
+            pullNumber: identity.pullNumber,
+            perPage: 100,
+        }, { toolCallId: args.widgetId, messages: [] });
+        return diffWidgetFromTool({
+            widgetId: args.widgetId,
+            toolName: args.toolName,
+            input: {
+                ...(typeof args.input === 'object' && args.input ? args.input : {}),
+                method: 'get_files',
+                ...identity,
+            },
+            output,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+const SYSTEM_PROMPT = `You are a GitHub assistant. Use the GitHub MCP tools to help with repositories, issues, and pull requests.
+Parse owner/repo from "owner/repo" when the user provides that format.
+Be concise and helpful.
+
+When the user asks to inspect, review, or see a pull request, commit, or code change:
+- Call pull_request_read with method get for title/author/status if needed.
+- Always also call pull_request_read with method get_files (preferred; includes per-file patches) or get_diff.
+A Diff widget is rendered from that file/diff result — keep your text reply to a short summary, not a pasted patch.`;
+export async function* runGithubAgent(args) {
+    const mcpClient = await createMCPClient({
+        transport: {
+            type: 'http',
+            url: GITHUB_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${args.githubToken}`,
+                'X-MCP-Toolsets': 'repos,issues,pull_requests',
+            },
+        },
+    });
+    const queue = [];
+    let wake;
+    let agentDone = false;
+    let agentError;
+    const enqueue = (event) => {
+        queue.push(event);
+        wake?.();
+        wake = undefined;
+    };
+    const waitForQueue = () => new Promise((resolve) => {
+        wake = resolve;
+    });
+    const agentTask = (async () => {
+        try {
+            const tools = await mcpClient.tools();
+            const model = resolveOpenAiModel(args.model ?? 'openai/gpt-4o', {
+                authMode: args.authMode,
+                openaiApiKey: args.openaiApiKey,
+            });
+            const result = await generateText({
+                model,
+                stopWhen: stepCountIs(5),
+                system: SYSTEM_PROMPT,
+                prompt: args.prompt,
+                tools,
+                onToolExecutionStart: ({ toolCall }) => {
+                    enqueue({
+                        kind: 'widget',
+                        widget: toolCallWidget({
+                            widgetId: toolCall.toolCallId,
+                            title: toolCall.toolName,
+                        }),
+                    });
+                },
+                onToolExecutionEnd: async ({ toolCall, toolOutput }) => {
+                    const input = toolInputFrom(toolCall, toolOutput);
+                    const payload = unwrapToolOutput(toolOutput);
+                    enqueue({
+                        kind: 'widget',
+                        widget: toolCallWidget({
+                            widgetId: toolCall.toolCallId,
+                            title: toolCall.toolName,
+                            body: formatToolOutput(payload),
+                        }),
+                    });
+                    const widgetId = `github-diff:${toolCall.toolCallId}`;
+                    let widget = diffWidgetFromTool({
+                        widgetId,
+                        toolName: toolCall.toolName,
+                        input,
+                        output: payload,
+                    });
+                    if (!widget &&
+                        shouldFollowUpPrFiles({
+                            toolName: toolCall.toolName,
+                            input,
+                            hasDiffWidget: false,
+                        })) {
+                        widget = await fetchPrFilesDiffWidget({
+                            tools: tools,
+                            widgetId,
+                            toolName: toolCall.toolName,
+                            input,
+                        });
+                    }
+                    if (widget)
+                        enqueue({ kind: 'widget', widget });
+                },
+            });
+            if (result.text.trim()) {
+                enqueue({ kind: 'reply', content: result.text.trim() });
+            }
+        }
+        catch (error) {
+            agentError = error;
+        }
+        finally {
+            agentDone = true;
+            wake?.();
+            wake = undefined;
+        }
+    })();
+    try {
+        while (!agentDone || queue.length > 0) {
+            if (queue.length === 0) {
+                await waitForQueue();
+                continue;
+            }
+            yield queue.shift();
+        }
+        await agentTask;
+        if (agentError)
+            throw agentError;
+    }
+    finally {
+        await mcpClient.close().catch(() => undefined);
+    }
+}

package/dist/cloud-mode.js

@@ -0,0 +1,10 @@
+/** True when this runtime is a platform-managed cloud deployment. */
+export const isCloudMode = () => process.env.OPENBOT_CLOUD_MODE === "1";
+/** Default auth mode: Credits on cloud, BYOK locally. */
+export const defaultAuthMode = () => isCloudMode() ? "credits" : "byok";
+export function resolveAuthMode(config) {
+    if (config.authMode === "byok" || config.authMode === "credits") {
+        return config.authMode;
+    }
+    return defaultAuthMode();
+}

package/dist/config.js

@@ -0,0 +1,74 @@
+import { resolveAuthMode } from "./cloud-mode.js";
+import { shouldUseCreditsAuth } from "./credits-auth.js";
+export const GITHUB_TOKEN_VAR = "GITHUB_TOKEN";
+function variableValue(variables, key) {
+    const entry = variables[key];
+    if (typeof entry === "string")
+        return entry || undefined;
+    return entry?.value || undefined;
+}
+export function readGithubConfig(config) {
+    return {
+        githubToken: typeof config.githubToken === "string" && config.githubToken.trim()
+            ? config.githubToken.trim()
+            : undefined,
+        authMode: config.authMode === "byok" || config.authMode === "credits"
+            ? config.authMode
+            : undefined,
+        model: typeof config.model === "string" && config.model.trim()
+            ? config.model.trim()
+            : undefined,
+    };
+}
+export function formatMissingCredentials(missing, authMode) {
+    const lines = [
+        "GitHub agent setup is incomplete. Configure the following in plugin config, workspace settings, or environment variables:",
+    ];
+    if (missing.includes("githubToken")) {
+        lines.push("- `githubToken` / `GITHUB_TOKEN` — GitHub Personal Access Token with repo scope");
+    }
+    if (missing.includes("openaiApiKey")) {
+        if (authMode === "credits") {
+            lines.push("- OpenAI API key is required in BYOK mode — add `OPENAI_API_KEY` under workspace settings, or switch `authMode` to `credits` on cloud");
+        }
+        else {
+            lines.push("- `OPENAI_API_KEY` — OpenAI API key for the agent loop (BYOK mode), or switch `authMode` to `credits` on cloud");
+        }
+    }
+    return lines.join("\n");
+}
+export async function resolveGithubCredentials(config, storage) {
+    const authMode = resolveAuthMode({ authMode: config.authMode });
+    const useCredits = shouldUseCreditsAuth({ authMode });
+    const variables = (await storage.getVariables().catch(() => ({})));
+    const resolve = (configKey, envKey) => {
+        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 githubToken = resolve("githubToken", GITHUB_TOKEN_VAR);
+    const openaiApiKey = process.env.OPENAI_API_KEY?.trim() ||
+        variableValue(variables, "OPENAI_API_KEY");
+    const model = resolve("model", "OPENAI_MODEL") ?? "openai/gpt-4o";
+    const missing = [];
+    if (!githubToken)
+        missing.push("githubToken");
+    if (!useCredits && !openaiApiKey)
+        missing.push("openaiApiKey");
+    if (missing.length > 0) {
+        return { ok: false, missing, authMode };
+    }
+    return {
+        ok: true,
+        credentials: {
+            githubToken: githubToken,
+            authMode,
+            openaiApiKey: openaiApiKey || undefined,
+            model,
+        },
+    };
+}

package/dist/credits-auth.js

@@ -0,0 +1,53 @@
+import { isCloudMode } from "./cloud-mode.js";
+export const INTEGRATIONS_TOKEN_HEADER = "x-openbot-integrations-token";
+export const CREDITS_API_KEY_PLACEHOLDER = "openbot-credits";
+/** Cloud host injects these when routing LLM calls through OpenBot Credits. */
+export function resolveCreditsAuthConfig() {
+    const baseUrl = process.env.OPENBOT_INTEGRATIONS_BASE_URL?.trim();
+    const token = process.env.OPENBOT_INTEGRATIONS_TOKEN?.trim();
+    if (!baseUrl || !token)
+        return undefined;
+    return { baseUrl: baseUrl.replace(/\/$/, ""), token };
+}
+export function creditsProviderBaseUrl(config) {
+    return `${config.baseUrl}/openai/v1`;
+}
+export function shouldUseCreditsAuth(options) {
+    if (options?.authMode === "byok")
+        return false;
+    if (options?.authMode === "credits")
+        return true;
+    return isCloudMode() && resolveCreditsAuthConfig() !== undefined;
+}
+export function isCreditsErrorMessage(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes("insufficient_credits") ||
+        lower.includes("insufficient credits") ||
+        lower.includes("402"));
+}
+export function isAuthErrorMessage(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes("api key") ||
+        lower.includes("401") ||
+        lower.includes("unauthorized") ||
+        lower.includes("authentication"));
+}
+export function isIntegrationsProviderError(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes("provider api key not configured") ||
+        (lower.includes("503") && lower.includes("provider")));
+}
+export const CREDITS_NOT_CONFIGURED_MESSAGE = "OpenBot Credits is not configured on this runtime. The cloud host must set OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN (try redeploying the workspace).";
+export const CREDITS_PROVIDER_UNAVAILABLE_MESSAGE = "OpenBot Credits could not reach OpenAI — the platform provider API key is not configured yet. Try again later or switch this agent to BYOK mode.";
+export const CREDITS_AUTH_FAILED_MESSAGE = "GitHub could not authenticate via OpenBot Credits. Check your workspace credit balance in settings, or switch this agent to BYOK mode.";
+export function creditsErrorMessage(message) {
+    if (isIntegrationsProviderError(message)) {
+        return CREDITS_PROVIDER_UNAVAILABLE_MESSAGE;
+    }
+    if (isCreditsErrorMessage(message)) {
+        return "Insufficient workspace credits. Add credits in workspace settings or switch this agent to BYOK mode.";
+    }
+    if (isAuthErrorMessage(message))
+        return CREDITS_AUTH_FAILED_MESSAGE;
+    return undefined;
+}