@meetopenbot/github 0.0.1 → 0.1.1

package/dist/index.js

@@ -1,110 +1,40 @@
 import { definePlugin, shouldHandleInvoke, agentOutput, uiWidget, } from '@meetopenbot/plugin-sdk';
-import { Octokit } from '@octokit/rest';
-import { generateText, stepCountIs, tool } from 'ai';
-import { createOpenAI } from '@ai-sdk/openai';
-import { z } from 'zod';
-const listReposSchema = z.object({
-    limit: z.number().optional().describe('Maximum number of repositories to return'),
-    visibility: z.enum(['all', 'public', 'private']).optional().describe('Filter by repository visibility'),
-    sort: z.enum(['created', 'updated', 'pushed', 'full_name']).optional().describe('How to sort the repositories'),
-});
-const getRepoSchema = z.object({
-    owner: z.string().describe('The owner of the repository (user or organization)'),
-    repo: z.string().describe('The name of the repository'),
-});
-const createRepoSchema = z.object({
-    name: z.string().describe('The name of the repository'),
-    org: z.string().optional().describe('The organization to create the repository in. If not provided, it will be created for the authenticated user.'),
-    description: z.string().optional().describe('A short description of the repository'),
-    private: z.boolean().optional().describe('Whether the repository is private'),
-    autoInit: z.boolean().optional().describe('Whether to create an initial commit with an empty README'),
-});
-export default definePlugin({
-    id: 'github',
-    name: 'GitHub',
-    description: 'Manage your GitHub repositories',
-    configSchema: {
-        type: 'object',
-        properties: {
-            githubToken: {
-                type: 'string',
-                description: 'GitHub Personal Access Token',
-                format: 'password',
-            },
-            openaiApiKey: {
-                type: 'string',
-                description: 'OpenAI API Key (optional if provided via environment)',
-                format: 'password',
-            },
-        },
-        required: ['githubToken'],
-    },
-    toolDefinitions: {
-        list_repos: {
-            description: 'List repositories for the authenticated user',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    limit: { type: 'number', description: 'Maximum number of repositories to return' },
-                    visibility: { type: 'string', enum: ['all', 'public', 'private'], description: 'Filter by repository visibility' },
-                    sort: { type: 'string', enum: ['created', 'updated', 'pushed', 'full_name'], description: 'How to sort the repositories' },
+import { runGithubAgent } from './agent.js';
+import { isCloudMode } from './cloud-mode.js';
+import { CREDITS_NOT_CONFIGURED_MESSAGE, creditsErrorMessage, resolveCreditsAuthConfig, } from './credits-auth.js';
+import { formatMissingCredentials, GITHUB_TOKEN_VAR, readGithubConfig, resolveGithubCredentials, } from './config.js';
+const GITHUB_TOKEN_WIDGET_ID = 'github-token-form';
+const githubPluginConfigSchema = {
+    type: 'object',
+    properties: {
+        ...(isCloudMode()
+            ? {
+                authMode: {
+                    type: 'string',
+                    description: 'Credits uses your workspace credit balance via OpenBot. BYOK uses `OPENAI_API_KEY` from workspace settings.',
+                    enum: ['credits', 'byok'],
+                    default: 'credits',
                 },
-            },
+            }
+            : {}),
+        githubToken: {
+            type: 'string',
+            description: 'GitHub Personal Access Token',
+            format: 'password',
         },
-        get_repo: {
-            description: 'Get details of a specific repository',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    owner: { type: 'string', description: 'The owner of the repository' },
-                    repo: { type: 'string', description: 'The name of the repository' },
-                },
-                required: ['owner', 'repo'],
-            },
-        },
-        create_repo: {
-            description: 'Create a new repository',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'The name of the repository' },
-                    org: { type: 'string', description: 'The organization to create the repository in' },
-                    description: { type: 'string', description: 'A short description of the repository' },
-                    private: { type: 'boolean', description: 'Whether the repository is private' },
-                    autoInit: { type: 'boolean', description: 'Whether to create an initial commit with an empty README' },
-                },
-                required: ['name'],
-            },
+        model: {
+            type: 'string',
+            description: 'OpenAI model for GitHub agent invocations',
+            default: 'openai/gpt-4o',
         },
     },
+};
+export default definePlugin({
+    name: 'GitHub',
+    description: 'Manage GitHub repositories, issues, and pull requests',
+    configSchema: githubPluginConfigSchema,
     factory: (context) => {
-        const getCredentials = async () => {
-            const config = context.config;
-            const env = process.env;
-            const variables = await context.storage.getVariables();
-            const getVal = (key, envKey) => {
-                if (config[key])
-                    return config[key];
-                if (env[envKey])
-                    return env[envKey];
-                const v = variables[envKey];
-                return typeof v === 'string' ? v : v?.value;
-            };
-            return {
-                githubToken: config.githubToken,
-                openaiApiKey: getVal('openaiApiKey', 'OPENAI_API_KEY'),
-            };
-        };
-        const getOctokit = (githubToken) => {
-            return new Octokit({
-                auth: githubToken,
-                headers: {
-                    'X-GitHub-Api-Version': '2022-11-28',
-                },
-            });
-        };
         return (builder) => {
-            // Handle agent:invoke for natural language queries
             builder.on('agent:invoke', async function* (event) {
                 if (!shouldHandleInvoke(event, context.agentId))
                     return;
@@ -112,272 +42,103 @@ export default definePlugin({
                 const threadId = event.meta?.threadId;
                 if (!userMessage)
                     return;
-                const { githubToken, openaiApiKey } = await getCredentials();
-                if (!openaiApiKey) {
+                const githubConfig = readGithubConfig(context.config);
+                const auth = await resolveGithubCredentials(githubConfig, context.storage);
+                if (!auth.ok) {
+                    if (auth.missing.includes('githubToken')) {
+                        yield uiWidget({
+                            agentId: context.agentId,
+                            threadId,
+                            widget: {
+                                kind: 'form',
+                                widgetId: GITHUB_TOKEN_WIDGET_ID,
+                                title: 'GitHub Access Token',
+                                description: 'Enter a GitHub Personal Access Token with repo scope to continue.',
+                                fields: [
+                                    {
+                                        id: 'githubToken',
+                                        label: 'GitHub Access Token',
+                                        type: 'password',
+                                        placeholder: 'ghp_...',
+                                        required: true,
+                                    },
+                                ],
+                                submitLabel: 'Save Token',
+                            },
+                        });
+                        return;
+                    }
                     yield agentOutput({
                         agentId: context.agentId,
-                        content: 'I need an OpenAI API key to help you manage GitHub. Please provide it below:',
+                        content: formatMissingCredentials(auth.missing, auth.authMode),
                         threadId,
                     });
-                    yield uiWidget({
+                    return;
+                }
+                if (auth.credentials.authMode === 'credits' &&
+                    !resolveCreditsAuthConfig()) {
+                    yield agentOutput({
                         agentId: context.agentId,
+                        content: CREDITS_NOT_CONFIGURED_MESSAGE,
                         threadId,
-                        widget: {
-                            kind: 'form',
-                            widgetId: 'github-config-form',
-                            title: 'OpenAI Configuration',
-                            description: 'Enter your OpenAI API key to get started.',
-                            fields: [
-                                {
-                                    id: 'openaiApiKey',
-                                    label: 'OpenAI API Key',
-                                    type: 'text',
-                                    placeholder: 'sk-...',
-                                    required: true,
-                                },
-                            ],
-                            submitLabel: 'Save Configuration',
-                        },
                     });
                     return;
                 }
-                const octokit = getOctokit(githubToken);
-                const openai = createOpenAI({ apiKey: openaiApiKey });
                 try {
-                    const { text, steps } = await generateText({
-                        model: openai('gpt-4o'),
-                        stopWhen: stepCountIs(5),
-                        system: `You are a GitHub management assistant. Help users manage their repositories.
-- Use list_repos to see the authenticated user's repositories.
-- Use get_repo to get details about a repository.
-- Use create_repo to create a new repository.
-When a tool requires an owner and repo, parse them from the "owner/repo" format the user provides.
-If a tool returns an error, explain it to the user or try an alternative approach if appropriate.
-Be concise and helpful.`,
+                    for await (const chunk of runGithubAgent({
                         prompt: userMessage,
-                        tools: {
-                            list_repos: tool({
-                                description: 'List repositories for the authenticated user',
-                                inputSchema: listReposSchema,
-                                execute: async ({ limit, visibility, sort }) => {
-                                    try {
-                                        const result = await octokit.repos.listForAuthenticatedUser({
-                                            per_page: limit || 20,
-                                            visibility: visibility || 'all',
-                                            sort: sort || 'updated',
-                                        });
-                                        return result.data;
-                                    }
-                                    catch (error) {
-                                        return { error: error.message, status: error.status };
-                                    }
-                                },
-                            }),
-                            get_repo: tool({
-                                description: 'Get details of a specific repository',
-                                inputSchema: getRepoSchema,
-                                execute: async ({ owner, repo }) => {
-                                    try {
-                                        const result = await octokit.repos.get({ owner, repo });
-                                        return result.data;
-                                    }
-                                    catch (error) {
-                                        return { error: error.message, status: error.status };
-                                    }
-                                },
-                            }),
-                            create_repo: tool({
-                                description: 'Create a new repository',
-                                inputSchema: createRepoSchema,
-                                execute: async ({ name, org, description, private: isPrivate, autoInit }) => {
-                                    try {
-                                        const params = {
-                                            name,
-                                            description,
-                                            private: isPrivate,
-                                            auto_init: autoInit,
-                                        };
-                                        const result = org
-                                            ? await octokit.repos.createInOrg({ ...params, org })
-                                            : await octokit.repos.createForAuthenticatedUser(params);
-                                        return result.data;
-                                    }
-                                    catch (error) {
-                                        return {
-                                            error: error.message,
-                                            status: error.status,
-                                            details: error.response?.data,
-                                        };
-                                    }
-                                },
-                            }),
-                        },
-                    });
-                    if (text.trim()) {
+                        githubToken: auth.credentials.githubToken,
+                        authMode: auth.credentials.authMode,
+                        openaiApiKey: auth.credentials.openaiApiKey,
+                        model: auth.credentials.model,
+                    })) {
+                        if (chunk.kind === 'widget') {
+                            yield uiWidget({
+                                agentId: context.agentId,
+                                threadId,
+                                widget: chunk.widget,
+                                meta: event.meta,
+                            });
+                            continue;
+                        }
                         yield agentOutput({
                             agentId: context.agentId,
-                            content: text,
+                            content: chunk.content,
                             threadId,
+                            meta: event.meta,
                         });
                     }
-                    for (const step of steps) {
-                        for (const toolResult of step.toolResults) {
-                            if (toolResult.toolName === 'list_repos') {
-                                const repos = toolResult.output;
-                                yield uiWidget({
-                                    agentId: context.agentId,
-                                    threadId,
-                                    widget: {
-                                        kind: 'list',
-                                        title: 'GitHub Repositories',
-                                        items: (repos || []).map((r) => ({
-                                            id: String(r.id),
-                                            label: r.full_name,
-                                            description: r.description || (r.private ? 'Private' : 'Public'),
-                                            status: 'done',
-                                        })),
-                                    },
-                                });
-                            }
-                        }
-                    }
                 }
                 catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    const creditsMessage = auth.credentials.authMode === 'credits'
+                        ? creditsErrorMessage(message)
+                        : undefined;
                     yield agentOutput({
                         agentId: context.agentId,
-                        content: `I encountered an error: ${error.message}`,
+                        content: (creditsMessage ?? message)
+                            ? `I encountered an error: ${creditsMessage ?? message}`
+                            : 'GitHub agent failed for an unknown reason. Please try again.',
                         threadId,
                     });
                 }
             });
             builder.on('client:ui:widget:response', async function* (event) {
-                if (event.data?.widgetId !== 'github-config-form')
+                if (event.data?.widgetId !== GITHUB_TOKEN_WIDGET_ID)
                     return;
-                const { openaiApiKey } = event.data.values || {};
-                if (openaiApiKey) {
-                    await context.storage.createVariable({
-                        key: 'OPENAI_API_KEY',
-                        value: openaiApiKey,
-                        secret: true,
-                    });
-                    yield agentOutput({
-                        agentId: context.agentId,
-                        content: "OpenAI API key saved! I'm now ready to help you with GitHub.",
-                        threadId: event.meta?.threadId,
-                    });
-                }
-            });
-            // Handle tool calls
-            builder.on('action:list_repos', async function* (event) {
-                const { githubToken } = await getCredentials();
-                const octokit = getOctokit(githubToken);
-                const { limit, visibility, sort } = (event.data || {});
-                try {
-                    const result = await octokit.repos.listForAuthenticatedUser({
-                        per_page: limit || 20,
-                        visibility: visibility || 'all',
-                        sort: sort || 'updated',
-                    });
-                    yield uiWidget({
-                        agentId: context.agentId,
-                        threadId: event.meta?.threadId,
-                        widget: {
-                            kind: 'list',
-                            title: 'GitHub Repositories',
-                            items: result.data.map((r) => ({
-                                id: String(r.id),
-                                label: r.full_name,
-                                description: r.description || (r.private ? 'Private' : 'Public'),
-                                status: 'done',
-                            })),
-                        },
-                    });
-                    yield {
-                        type: 'action:list_repos:result',
-                        data: {
-                            ...result.data,
-                            output: `Successfully listed ${result.data.length} repositories.`,
-                        },
-                        meta: event.meta,
-                    };
-                }
-                catch (error) {
-                    yield {
-                        type: 'action:list_repos:result',
-                        data: {
-                            error: error.message,
-                            status: error.status,
-                            details: error.response?.data,
-                            output: `Failed to list repositories: ${error.message}`,
-                        },
-                        meta: event.meta,
-                    };
-                }
-            });
-            builder.on('action:get_repo', async function* (event) {
-                const { githubToken } = await getCredentials();
-                const octokit = getOctokit(githubToken);
-                const { owner, repo } = (event.data || {});
-                try {
-                    const result = await octokit.repos.get({ owner, repo });
-                    yield {
-                        type: 'action:get_repo:result',
-                        data: {
-                            ...result.data,
-                            output: `Successfully retrieved details for ${owner}/${repo}.`,
-                        },
-                        meta: event.meta,
-                    };
-                }
-                catch (error) {
-                    yield {
-                        type: 'action:get_repo:result',
-                        data: {
-                            error: error.message,
-                            status: error.status,
-                            details: error.response?.data,
-                            output: `Failed to get repository ${owner}/${repo}: ${error.message}`,
-                        },
-                        meta: event.meta,
-                    };
-                }
-            });
-            builder.on('action:create_repo', async function* (event) {
-                console.log('action:create_repo', event);
-                const { githubToken } = await getCredentials();
-                const octokit = getOctokit(githubToken);
-                const { name, org, description, private: isPrivate, autoInit } = (event.data || {});
-                try {
-                    const params = {
-                        name,
-                        description,
-                        private: isPrivate,
-                        auto_init: autoInit,
-                    };
-                    const result = org
-                        ? await octokit.repos.createInOrg({ ...params, org })
-                        : await octokit.repos.createForAuthenticatedUser(params);
-                    yield {
-                        type: 'action:create_repo:result',
-                        data: {
-                            ...result.data,
-                            output: `Successfully created repository ${result.data.full_name}.`,
-                        },
-                        meta: event.meta,
-                    };
-                }
-                catch (error) {
-                    yield {
-                        type: 'action:create_repo:result',
-                        data: {
-                            error: error.message,
-                            status: error.status,
-                            details: error.response?.data,
-                            output: `Failed to create repository ${name}: ${error.message}`,
-                        },
-                        meta: event.meta,
-                    };
-                }
+                const githubToken = event.data.values?.githubToken;
+                if (typeof githubToken !== 'string' || !githubToken.trim())
+                    return;
+                await context.storage.createVariable({
+                    key: GITHUB_TOKEN_VAR,
+                    value: githubToken.trim(),
+                    secret: true,
+                });
+                yield agentOutput({
+                    agentId: context.agentId,
+                    content: 'GitHub access token saved. Retry your last request.',
+                    threadId: event.meta?.threadId,
+                });
             });
         };
     },

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/package.json

@@ -1,27 +1,39 @@
 {
   "name": "@meetopenbot/github",
-  "version": "0.0.1",
-  "description": "Manage your GitHub repositories, issues, and pull requests from OpenBot",
+  "version": "0.1.1",
+  "description": "Manage GitHub repositories, issues, and pull requests from OpenBot",
   "type": "module",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
+  "main": "./dist/index.js",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@ai-sdk/openai": "^3.0.64",
-    "@meetopenbot/plugin-sdk": "^0.1.2",
-    "@octokit/rest": "^22.0.0",
-    "ai": "^6.0.185",
-    "zod": "^4.4.3"
+    "@ai-sdk/mcp": "^2.0.14",
+    "@ai-sdk/openai": "^4.0.15",
+    "ai": "^7.0.29",
+    "@meetopenbot/plugin-sdk": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
     "ts-node": "^10.9.2",
     "typescript": "^6.0.3"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && node ../../scripts/write-plugin-declaration.mjs",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "typecheck": "tsc --noEmit",
+    "test": "node --experimental-strip-types --test src/diff.test.ts"
   }
 }