moeba-claude-channel 0.0.1

package/dist/moeba-channel.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+/**
+ * Moeba Channel for Claude Code
+ *
+ * Two-way bridge: Moeba app users ↔ Claude Code session.
+ * Authenticates via OAuth on startup, connects via SSE, replies via HTTP.
+ *
+ * Usage:
+ *   npx @moeba/claude-channel
+ *
+ * On first run, opens browser for Google/Apple sign-in before connecting.
+ * Credentials are cached per project at ~/.moeba/channel-<project>.json
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { createServer } from 'http';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { execSync, exec } from 'child_process';
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const MOEBA_API_URL = (process.env.MOEBA_API_URL ||
+    'https://moeba-api-999642860678.africa-south1.run.app').replace(/\/$/, '');
+const MOEBA_AUTH_URL = process.env.MOEBA_AUTH_URL || 'https://admin.moeba.co.za';
+// Detect project name from git repo or directory name
+function detectProjectName() {
+    try {
+        const repoName = execSync('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return repoName.split('/').pop() || 'default';
+    }
+    catch {
+        return process.cwd().split('/').pop() || 'default';
+    }
+}
+const PROJECT_NAME = process.env.MOEBA_PROJECT || detectProjectName();
+const PROJECT_SLUG = PROJECT_NAME.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+const CREDENTIALS_PATH = join(homedir(), '.moeba', `channel-${PROJECT_SLUG}.json`);
+// ---------------------------------------------------------------------------
+// Credential storage
+// ---------------------------------------------------------------------------
+function loadCredentials() {
+    try {
+        if (!existsSync(CREDENTIALS_PATH))
+            return null;
+        return JSON.parse(readFileSync(CREDENTIALS_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveCredentials(c) {
+    const dir = join(homedir(), '.moeba');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(CREDENTIALS_PATH, JSON.stringify(c, null, 2));
+}
+// ---------------------------------------------------------------------------
+// OAuth flow — opens browser, receives Firebase token via localhost callback
+// ---------------------------------------------------------------------------
+function authenticate() {
+    return new Promise((resolve, reject) => {
+        const callbackPort = 9876;
+        const httpServer = createServer(async (req, res) => {
+            const url = new URL(req.url, `http://localhost:${callbackPort}`);
+            if (url.pathname === '/callback') {
+                const firebaseIdToken = url.searchParams.get('token');
+                if (!firebaseIdToken) {
+                    res.writeHead(400);
+                    res.end('Missing token parameter');
+                    return;
+                }
+                try {
+                    const response = await fetch(`${MOEBA_API_URL}/channel/auth`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ firebaseIdToken, projectName: PROJECT_NAME }),
+                    });
+                    if (!response.ok) {
+                        const err = await response.text();
+                        res.writeHead(500);
+                        res.end(`Auth failed: ${err}`);
+                        reject(new Error(`Channel auth failed: ${err}`));
+                        return;
+                    }
+                    const data = (await response.json());
+                    const newCreds = {
+                        token: data.token,
+                        email: data.email,
+                        businessId: data.businessId,
+                        agentId: data.agentId,
+                        connectionId: data.connectionId,
+                        agentApiKey: data.agentApiKey,
+                        projectName: PROJECT_NAME,
+                    };
+                    saveCredentials(newCreds);
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(`
+            <html><body style="font-family:system-ui;text-align:center;padding:60px">
+              <h2>Connected to Moeba!</h2>
+              <p>You can close this tab and return to Claude Code.</p>
+            </body></html>
+          `);
+                    httpServer.close();
+                    resolve(newCreds);
+                }
+                catch (err) {
+                    res.writeHead(500);
+                    res.end(`Error: ${err.message}`);
+                    reject(err);
+                }
+                return;
+            }
+            res.writeHead(404);
+            res.end('Not found');
+        });
+        httpServer.listen(callbackPort, '127.0.0.1', () => {
+            const authUrl = `${MOEBA_AUTH_URL}/channel-login?redirect=http://localhost:${callbackPort}/callback`;
+            console.error(`\n🔑 Sign in to Moeba: ${authUrl}\n`);
+            const cmd = process.platform === 'darwin'
+                ? 'open'
+                : process.platform === 'win32'
+                    ? 'start'
+                    : 'xdg-open';
+            exec(`${cmd} "${authUrl}"`);
+        });
+        setTimeout(() => {
+            httpServer.close();
+            reject(new Error('Authentication timed out after 2 minutes'));
+        }, 120_000);
+    });
+}
+// ---------------------------------------------------------------------------
+// SSE client — connects to Moeba and receives messages
+// ---------------------------------------------------------------------------
+function connectSSE(c, mcp) {
+    const url = `${MOEBA_API_URL}/api/channel/events?connectionId=${c.connectionId}`;
+    let reconnectDelay = 1000;
+    async function connect() {
+        try {
+            console.error('Connecting to Moeba SSE...');
+            const response = await fetch(url, {
+                headers: { Authorization: `Bearer ${c.token}` },
+            });
+            if (!response.ok) {
+                console.error(`SSE connection failed: ${response.status}`);
+                scheduleReconnect();
+                return;
+            }
+            console.error('Connected to Moeba — listening for messages');
+            reconnectDelay = 1000;
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                let eventType = '';
+                let eventData = '';
+                for (const line of lines) {
+                    if (line.startsWith('event: ')) {
+                        eventType = line.slice(7);
+                    }
+                    else if (line.startsWith('data: ')) {
+                        eventData = line.slice(6);
+                    }
+                    else if (line === '' && eventType && eventData) {
+                        if (eventType === 'message') {
+                            try {
+                                const event = JSON.parse(eventData);
+                                const content = event.message?.text || '';
+                                const meta = {
+                                    sender_email: event.senderEmail || '',
+                                    sender_name: event.senderName || '',
+                                    connection_id: event.connectionId || c.connectionId,
+                                    conversation_id: event.conversationId || '',
+                                };
+                                if (event.type === 'action') {
+                                    meta.type = 'action';
+                                }
+                                mcp
+                                    .notification({
+                                    method: 'notifications/claude/channel',
+                                    params: { content, meta },
+                                })
+                                    .catch((err) => console.error('Notification failed:', err.message));
+                            }
+                            catch { }
+                        }
+                        else if (eventType === 'connected') {
+                            console.error('SSE stream established');
+                        }
+                        eventType = '';
+                        eventData = '';
+                    }
+                }
+            }
+            console.error('SSE stream ended');
+            scheduleReconnect();
+        }
+        catch (err) {
+            console.error(`SSE error: ${err.message}`);
+            scheduleReconnect();
+        }
+    }
+    function scheduleReconnect() {
+        console.error(`Reconnecting in ${reconnectDelay / 1000}s...`);
+        setTimeout(connect, reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 2, 30_000);
+    }
+    connect();
+}
+// ---------------------------------------------------------------------------
+// Main — authenticate first, then connect MCP
+// ---------------------------------------------------------------------------
+async function main() {
+    // 1. Authenticate (cached or browser OAuth) — before MCP connects
+    let creds = loadCredentials();
+    if (!creds) {
+        console.error('No Moeba credentials found — opening browser to sign in...');
+        creds = await authenticate();
+    }
+    console.error(`Authenticated as ${creds.email} (project: ${PROJECT_NAME})`);
+    // 2. Create MCP channel server
+    const mcp = new Server({ name: 'moeba', version: '0.0.1' }, {
+        capabilities: {
+            experimental: { 'claude/channel': {} },
+            tools: {},
+        },
+        instructions: `Messages from Moeba users arrive as <channel source="moeba" ...>.
+Each message has attributes: sender_email, sender_name, connection_id, conversation_id.
+
+When you receive a message:
+1. Read and understand the user's request
+2. Take whatever actions are needed (read files, run commands, etc.)
+3. Send progress updates via moeba_progress while working on longer tasks
+4. Reply using moeba_reply with the connection_id from the message tag
+
+Keep replies concise and helpful. The user is chatting from a mobile app.`,
+    });
+    // 3. Register tools
+    mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: 'moeba_reply',
+                description: 'Send a reply message back to the Moeba user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        connection_id: {
+                            type: 'string',
+                            description: 'The connection_id from the inbound <channel> tag',
+                        },
+                        text: {
+                            type: 'string',
+                            description: 'The message to send back',
+                        },
+                    },
+                    required: ['connection_id', 'text'],
+                },
+            },
+            {
+                name: 'moeba_progress',
+                description: 'Show a typing/progress indicator while working on a task',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        connection_id: {
+                            type: 'string',
+                            description: 'The connection_id from the inbound <channel> tag',
+                        },
+                        text: {
+                            type: 'string',
+                            description: 'Progress text (e.g. "Reading files...")',
+                        },
+                    },
+                    required: ['connection_id', 'text'],
+                },
+            },
+        ],
+    }));
+    mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const { name, arguments: args } = req.params;
+        if (name === 'moeba_reply' || name === 'moeba_progress') {
+            const { connection_id, text } = args;
+            const body = {
+                connectionId: connection_id,
+                message: { text },
+            };
+            if (name === 'moeba_progress') {
+                body.type = 'progress';
+            }
+            const response = await fetch(`${MOEBA_API_URL}/api/agent/send`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Moeba-Agent-Key': creds.agentApiKey,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errText = await response.text();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Failed: ${response.status} ${errText}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: name === 'moeba_progress' ? 'Progress updated' : 'Sent',
+                    },
+                ],
+            };
+        }
+        throw new Error(`Unknown tool: ${name}`);
+    });
+    // 4. Connect MCP to Claude Code
+    await mcp.connect(new StdioServerTransport());
+    // 5. Start SSE listener
+    connectSSE(creds, mcp);
+    console.error('Moeba channel ready — waiting for messages');
+}
+main().catch((err) => {
+    console.error('Fatal:', err.message);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "moeba-claude-channel",
+  "version": "0.0.1",
+  "description": "Claude Code channel for Moeba — chat with Claude Code from the Moeba app",
+  "type": "module",
+  "main": "dist/moeba-channel.js",
+  "bin": {
+    "moeba-channel": "dist/moeba-channel.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "claude-code",
+    "mcp",
+    "moeba",
+    "channel",
+    "ai-agent"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/moeba-co/moeba"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.0",
+    "@types/node": "^20.0.0"
+  }
+}