@opulcloud/mcp 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer } from './server.js';
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('OpulCloud MCP running');
+}
+main().catch((e) => { console.error(e); process.exit(1); });

package/dist/client.js

@@ -0,0 +1,44 @@
+const URL = process.env.OPULCLOUD_API_URL ?? 'https://opulcloud-gateway.hasnu-dxb1.workers.dev/v1';
+const KEY = process.env.OPULCLOUD_API_KEY;
+const AGENT = process.env.OPULCLOUD_AGENT_ID;
+if (!KEY)
+    throw new Error('OPULCLOUD_API_KEY required');
+async function req(path, init) {
+    const res = await fetch(`${URL}${path}`, {
+        ...init,
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${KEY}`,
+            'X-OpulCloud-Agent-Id': AGENT ?? '',
+            ...init?.headers,
+        },
+    });
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({ error: { message: `HTTP ${res.status}` } }));
+        throw new Error(err.error?.message ?? `HTTP ${res.status}`);
+    }
+    return res.json();
+}
+export const client = {
+    memory: {
+        add: (b) => req('/memory', { method: 'POST', body: JSON.stringify(b) }),
+        search: (b) => req('/memory/search', { method: 'POST', body: JSON.stringify(b) }),
+        list: () => req('/memory'),
+    },
+    traces: {
+        list: (p) => req(`/traces?${new URLSearchParams(p ?? {})}`),
+        get: (id) => req(`/traces/${id}`),
+        replay: (id) => req(`/replay/${id}`, { method: 'POST' }),
+    },
+    agents: {
+        list: () => req('/agents'),
+        get: (id) => req(`/agents/${id}`),
+    },
+    usage: {
+        get: (since) => req(`/usage${since ? `?since=${since}` : ''}`),
+    },
+    db: {
+        tables: () => req('/db/tables'),
+        query: (sql) => req('/db/query', { method: 'POST', body: JSON.stringify({ sql }) }),
+    },
+};

package/dist/server.js

@@ -0,0 +1,15 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerMemoryTools } from './tools/memory.js';
+import { registerTraceTools } from './tools/traces.js';
+import { registerAgentTools } from './tools/agents.js';
+import { registerUsageTools } from './tools/usage.js';
+import { registerDbTools } from './tools/db.js';
+export function createServer() {
+    const s = new McpServer({ name: 'opulcloud', version: '0.1.0' });
+    registerMemoryTools(s);
+    registerTraceTools(s);
+    registerAgentTools(s);
+    registerUsageTools(s);
+    registerDbTools(s);
+    return s;
+}

package/dist/tools/agents.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+export function registerAgentTools(server) {
+    server.tool('agents_list', 'List all registered agents in your OpulCloud workspace.', {}, async () => {
+        const res = await client.agents.list();
+        const formatted = res.data
+            .map((a) => `${a.agent_id} · ${a.name ?? '—'} · ${a.total_traces ?? 0} traces`)
+            .join('\n');
+        return {
+            content: [{ type: 'text', text: formatted || 'No agents registered.' }],
+        };
+    });
+    server.tool('agents_get', 'Get details about a specific agent.', { agent_id: z.string() }, async ({ agent_id }) => {
+        const res = await client.agents.get(agent_id);
+        return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    });
+}

package/dist/tools/db.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+export function registerDbTools(server) {
+    server.tool('db_tables', 'List all database tables in your OpulCloud workspace.', {}, async () => {
+        const res = await client.db.tables();
+        return {
+            content: [{ type: 'text', text: res.data.map((t) => t.name).join('\n') }],
+        };
+    });
+    server.tool('db_query', 'Run a read-only SQL query (SELECT only).', { sql: z.string() }, async ({ sql }) => {
+        const res = await client.db.query(sql);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(res.rows, null, 2) }],
+        };
+    });
+}

package/dist/tools/memory.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+export function registerMemoryTools(server) {
+    server.tool('memory_add', 'Store a general memory or user preference', {
+        content: z.string(),
+        kind: z.enum(['episodic', 'semantic', 'procedural', 'working']).default('episodic'),
+    }, async ({ content, kind }) => {
+        const r = await client.memory.add({ content, kind });
+        return { content: [{ type: 'text', text: `Stored ${r.data.id}` }] };
+    });
+    server.tool('memory_search', 'Search memory for relevant context or rules', {
+        query: z.string(),
+        limit: z.number().default(5)
+    }, async ({ query, limit }) => {
+        const r = await client.memory.search({ query, limit });
+        const out = r.data.map((m, i) => `${i + 1}. ${m.content}`).join('\n');
+        return { content: [{ type: 'text', text: out || 'No matches' }] };
+    });
+    // 🚀 NEW: Project Memory (Context Injection for Cursor/Claude)
+    server.tool('project_rule_add', 'Add a strict architectural rule for this codebase (e.g., "Always use pnpm", "Never use raw SQL")', {
+        rule: z.string(),
+    }, async ({ rule }) => {
+        // We store it as 'procedural' so it stands out from normal chat memories
+        const r = await client.memory.add({ content: `[PROJECT RULE] ${rule}`, kind: 'procedural' });
+        return { content: [{ type: 'text', text: `✅ Architectural rule saved: "${rule}"` }] };
+    });
+}

package/dist/tools/traces.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+export function registerTraceTools(server) {
+    server.tool('traces_list', 'List traces', { limit: z.number().default(20) }, async ({ limit }) => {
+        const r = await client.traces.list({ limit: String(limit) });
+        const out = r.data.map((t) => `${t.id} · ${t.model_alias} · ${t.latency_ms}ms`).join('\n');
+        return { content: [{ type: 'text', text: out || 'No traces' }] };
+    });
+    server.tool('traces_replay', 'Replay a trace', { id: z.string() }, async ({ id }) => {
+        const r = await client.traces.replay(id);
+        return { content: [{ type: 'text', text: JSON.stringify(r.data, null, 2) }] };
+    });
+}

package/dist/tools/usage.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { client } from '../client.js';
+export function registerUsageTools(server) {
+    server.tool('usage_summary', 'Get usage summary for the workspace (tokens, cost, daily breakdown).', { since: z.string().optional() }, async ({ since }) => {
+        const res = await client.usage.get(since);
+        const summary = (res.summary ?? [])
+            .map((s) => `${s.event_type}: ${s.total_quantity} · $${s.total_cost ?? 0}`)
+            .join('\n');
+        return {
+            content: [{ type: 'text', text: summary || 'No usage yet.' }],
+        };
+    });
+}

package/package.json

@@ -1,6 +1,24 @@
 {
   "name": "@opulcloud/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "opulcloud-mcp": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.