streamby-core 0.35.0 → 0.37.0

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 0.37.0
+
+### ⚠️ Breaking changes
+
+- **API tokens have permissions, not an access level.** The tokens made before this version no
+  longer work, and aren't listed: make new ones. There's no migration. The `api_tokens` table
+  gets its new columns at startup (`kind`, `permissions`, `createdByName`), and its old
+  `access` column becomes optional; nothing else is changed.
+- **`ApiTokenScope` changed.** It has `kind` (`'user'` or `'project'`) and `permissions`,
+  instead of `access`. `ApiTokenAccess` is gone.
+- **`createApiToken`** takes who makes the token (`{ kind, userId, username, projectId }`), and
+  `permissions` instead of `access`. `listApiTokens` and `revokeApiToken` are now
+  `listUserApiTokens` and `revokeUserApiToken`.
+- **The host's `authProvider` must handle a project's token** (see the README): it isn't a
+  user, so it must not be looked up as one. `resolveApiToken` returns its `name` to go by.
+
+### Added
+
+- **Permissions** for tokens, by resource and action: `project`, `members`, `assets`,
+  `production`, `workflow`, `exports`, `rights` and `jobs`, each with `read` and its writes
+  (`update`, `write`, `manage`, `delete` or `run`), and `projects:create` for the account.
+  Every route a token reaches needs its own permission; a route no permission covers isn't
+  reachable with a token. A user's token is still limited by its user's role in each project.
+  `PROJECT_PERMISSIONS` and `ACCOUNT_PERMISSIONS` are exported.
+- **Projects' tokens**, at `GET`, `POST` and `DELETE /projects/:id/api-tokens`, managed by the
+  project's admins only. They act on their project alone, with their permissions, and keep
+  working after whoever made them leaves it; the project's admins are notified when that
+  happens (`api_token_creator_left`). Deleting a project ends its tokens.
+- **`projects:create`**: a user's token with it creates projects, and reaches the ones it
+  creates.
+- **MCP tools** `create_project`, `delete_project`, `delete_asset`, `delete_sequence`,
+  `delete_shot` and `delete_task`. Each tool needs its permissions and is listed only for a
+  token that has them; the ones that delete are marked as destructive.
+
+## 0.36.0
+
+### Added
+
+- **MCP server** at `POST /mcp`, for agents such as Claude Code to work with StreamBy projects
+  with an API token (see the README).
+  - It takes only an API token.
+  - Its tools call the REST API with that token, so they reach exactly what the token and its
+    owner can, and writes are saved as the UI's are.
+  - **Reading tools:** projects, assets with their metadata and rights, workflow, pipelines,
+    exports, jobs, and production sequences, shots and tasks.
+  - **Writing tools**, listed only for `write` tokens: asset metadata and rights, pipelines,
+    sequences, shots and tasks.
+- **`mcp.rateLimit`** (default 120 requests a minute per token; past it, 429 with
+  `Retry-After`) and **`mcp.apiBaseUrl`** in the router config.
+- **New table: `mcp_audit`.** It's created at startup in the main database. Every tool call is
+  recorded there, with the user, token, project, tool and result, but never the arguments nor
+  the token.
+- New dependencies: `@modelcontextprotocol/sdk` and `zod`.
+
+### Fixed
+
+- **Projects can be made with PostgreSQL as the main database.** The `projects` table that
+  StreamBy creates at startup was missing columns the routes write: `public`, `category`,
+  `integrationConnections`, `distributionConnections` and `renderFarmConnections`.
+  - Making a project failed with `column "public" does not exist`.
+  - Adding service, distribution or render farm connections failed too.
+  - They're added at startup now, only where they're missing; databases that already have
+    them aren't changed.
+
 ## 0.35.0
 
 ### Added

package/README.md

@@ -102,20 +102,49 @@ createStreamByRouter({
 
 ## 🎫 API tokens
 
-Agents and services work with StreamBy as a user through API tokens, without the user's
-browser session. A user manages their own tokens (`GET`, `POST` and
-`DELETE /streamby/user/api-tokens`, only with a session). Each token has:
-
-- **an access level**: `read` (only reads) or `write` (reads and writes);
-- **the projects it reaches**: a list of project ids, or `'*'` for every project the user is a
-  member of, including ones they join later;
-- **an expiry**: 7, 30, 90 or 365 days, or none.
-
-A token is `sbt_` followed by 32 random bytes. It's shown once, when it's made. Only its
-SHA-256 hash is stored, with a short prefix to tell it apart.
+Agents and services work with StreamBy through API tokens, without a browser session. There
+are two kinds:
+
+- **A user's token** acts as its user. The user manages their own (`GET`, `POST` and
+  `DELETE /streamby/user/api-tokens`). It reaches a list of the user's projects, or `'*'` for
+  every project they're a member of, including ones they join later. It never does more than
+  its user can: their role in each project still applies.
+- **A project's token** acts on its project alone, as the project's, not as whoever made it:
+  it keeps working after they leave the project, for permanent integrations (CI, services, the
+  project's agents). Only the project's admins list, make and revoke them (`GET`, `POST` and
+  `DELETE /streamby/projects/:id/api-tokens`), and each one records who made it. When they
+  leave, the project's admins are notified that it still works. Deleting the project ends
+  its tokens.
+
+Tokens are managed only with a session: a token can't manage tokens.
+
+Each token has a name, **its permissions**, and **an expiry** (7, 30, 90 or 365 days, or
+none). It's `sbt_` followed by 32 random bytes, shown once, when it's made. Only its SHA-256
+hash is stored, with a short prefix to tell it apart.
+
+**Permissions**
+
+| Resource | Permissions | Covers |
+|---|---|---|
+| Project | `project:read`, `project:update`, `project:delete` | The project, its settings and its connections (API, database, storage, distribution, render farm), integrations and allowed origins. |
+| Members | `members:read`, `members:manage` | Listing members; inviting, changing and removing them, and searching users. |
+| Assets | `assets:read`, `assets:write`, `assets:delete` | Files and folders, upload URLs, metadata, versions, reviews and annotations, QC reports. |
+| Production | `production:read`, `production:write`, `production:delete` | Sequences, shots and tasks. |
+| Workflow | `workflow:read`, `workflow:write` | The workflow and its pipelines. |
+| Exports | `exports:read`, `exports:write` | The project's exports. |
+| Rights | `rights:read`, `rights:write` | Assets' rights. |
+| Jobs | `jobs:read`, `jobs:run` | Following jobs; starting them (transcoding, rendering, AI, publishing a deliverable). |
+| Account | `projects:create` | Creating projects. A user's token only; the token reaches what it creates. |
+
+`PROJECT_PERMISSIONS` and `ACCOUNT_PERMISSIONS` are exported. A route no permission covers
+(the user's notifications, integrations and tokens, Explore, accepting an invitation) isn't
+reachable with a token.
+
+**Resolving a token**
 
 Requests send it as `Authorization: Bearer sbt_...`. Your `authProvider` resolves it with
-`resolveApiToken` and returns its owner, with the token's scope in `apiToken`:
+`resolveApiToken`, and returns its `userId` with the token's scope in `apiToken`. A project's
+token isn't a user: its `userId` is the token's own (on its project), and it goes by its name.
 
 ```ts
 import { createStreamByRouter, resolveApiToken, API_TOKEN_PREFIX } from 'streamby-core';
@@ -127,6 +156,9 @@ createStreamByRouter({
     if (bearer?.startsWith(API_TOKEN_PREFIX)) {
       const resolved = await resolveApiToken(bearer); // null once revoked or expired
       if (!resolved) throw new Error('Invalid API token');
+      if (resolved.scope.kind === 'project') {
+        return { userId: resolved.userId, username: resolved.name, role: 'viewer', apiToken: resolved.scope };
+      }
       const user = await findUser(resolved.userId);   // your own user lookup
       return { userId: user.id, username: user.username, role: user.role, apiToken: resolved.scope };
     }
@@ -135,17 +167,114 @@ createStreamByRouter({
 });
 ```
 
-A request made with a token reaches only what the token's scope allows:
+A request made with a token goes through only when its route's permission is among the
+token's (otherwise 403), and a project outside the token's projects answers 404; the project
+list shows only the token's projects.
+
+---
+
+## 🤖 MCP server
+
+StreamBy serves an [MCP](https://modelcontextprotocol.io) server at `POST /streamby/mcp`
+(Streamable HTTP, stateless). Agents such as Claude Code use it to read and work on StreamBy
+projects with an API token (see above). It takes only an API token; a browser session gets 401.
+
+Each tool calls StreamBy's own REST API with the caller's token. So it reaches exactly what the
+token allows (and, for a user's token, what its user's role in each project allows), and a
+change is saved just like one made from the UI, which shows it when it loads the project.
+
+**Tools**
+
+A token sees only the tools whose permissions it has.
+
+| Tools | Permissions |
+|---|---|
+| `list_projects` | any token |
+| `get_project` | `project:read` |
+| `create_project` | `projects:create` |
+| `delete_project` | `project:delete` |
+| `list_assets` (by category, optionally in one storage connection, and filtered by name), `get_asset_metadata` | `assets:read` |
+| `update_asset_metadata` | `assets:write` |
+| `delete_asset` | `assets:delete` |
+| `get_asset_rights` / `set_asset_rights` | `rights:read` / `rights:write` |
+| `get_workflow`, `list_pipelines`, `get_pipeline` | `workflow:read` |
+| `create_pipeline`, `update_pipeline` | `workflow:write` |
+| `list_exports` | `project:read` and `exports:read` |
+| `get_export` | `exports:read` |
+| `get_job` | `jobs:read` |
+| `list_sequences`, `list_shots`, `list_tasks` | `production:read` |
+| `create_sequence`, `update_sequence`, `create_shot`, `update_shot`, `create_task`, `update_task` | `production:write` |
+| `delete_sequence`, `delete_shot`, `delete_task` | `production:delete` |
+
+The tools that delete are marked as destructive (`destructiveHint`), so a client can ask before
+running them.
+
+**Limits and audit**
+
+- Each token can make at most 120 requests a minute (a sliding window). Past that, StreamBy
+  answers 429 with `Retry-After`. Each instance counts its own requests. Change the limit with
+  `mcp.rateLimit`.
+- Every tool call is recorded in the `mcp_audit` table, created at startup in the main database.
+  Each row has the user (a project's token: the token itself), the token's id, the project, the
+  tool, whether it went through, the status, the error and the duration. A row never includes
+  the arguments or the token.
+
+```ts
+createStreamByRouter({
+  // ...
+  mcp: {
+    rateLimit: { requests: 120, windowMs: 60_000 }, // the default
+    // apiBaseUrl: 'http://127.0.0.1:3000/streamby', // where tools reach the REST API;
+    //   by default this same process, at the request's local port and mount path
+  },
+});
+```
+
+### Connecting from Claude Code
+
+Make an API token in StreamBy, with only the permissions the agent needs: your own
+(Settings → Security → Personal API tokens), or a project's (in the project, Settings → API
+Tokens). Keep it in an environment variable, never in a file:
 
-- a `read` token can't write;
-- a project outside the token's projects answers 404, and the project list shows only the
-  token's projects;
-- a token can't manage tokens;
-- outside a project, a token can only make a few reads (`/auth`, `/projects`, `/jobs/:jobId`,
-  `/user/subscription`, `/users/search`).
+```bash
+export STREAMBY_TOKEN=sbt_...
+```
+
+Add the server to your project's `.mcp.json`. Claude Code expands `${STREAMBY_TOKEN}` from the
+environment:
+
+```json
+{
+  "mcpServers": {
+    "streamby": {
+      "type": "http",
+      "url": "https://your-host/streamby/mcp",
+      "headers": { "Authorization": "Bearer ${STREAMBY_TOKEN}" }
+    }
+  }
+}
+```
+
+### Connecting from Claude Desktop
+
+Claude Desktop runs local (stdio) servers from `claude_desktop_config.json`. Reach StreamBy
+through [`mcp-remote`](https://www.npmjs.com/package/mcp-remote), passing the token in its
+`env`. This file holds it in plain text, so use a token with only the permissions you need,
+and an expiry:
+
+```json
+{
+  "mcpServers": {
+    "streamby": {
+      "command": "npx",
+      "args": ["mcp-remote", "https://your-host/streamby/mcp", "--header", "Authorization:${STREAMBY_AUTH}"],
+      "env": { "STREAMBY_AUTH": "Bearer sbt_..." }
+    }
+  }
+}
+```
 
-The owner's role in each project still applies on top of that. A token never does more than
-its owner can, and it stops reaching a project as soon as its owner leaves it.
+The claude.ai connector needs OAuth, which isn't available yet: it's for API tokens only for now.
 
 ---
 

package/dist/adapters/database/connectionManager.js

@@ -80,11 +80,12 @@ const ensureTablesExist = async (pool) => {
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS workflow            JSONB;
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS pipelines           JSONB DEFAULT '[]';
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "builtinBackfilledAt" TIMESTAMP WITH TIME ZONE;
-      -- Reverted: a project has no notion of a "default" database/storage connection —
-      -- each dataSourceNode/ingestNode always declares its own connection explicitly.
-      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultDatabaseId";
-      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultStorageId";
-      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultConnectionsBackfilledAt";
+      -- Written when a project is made (routes/project) and by its connection routes.
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS public              BOOLEAN DEFAULT TRUE;
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS category            TEXT;
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "integrationConnections"  JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "distributionConnections" JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "renderFarmConnections"   JSONB DEFAULT '[]';
     `);
         // Ensure dbType exists with a non-null default
         await pool.query(`
@@ -148,23 +149,53 @@ const ensureTablesExist = async (pool) => {
     `);
         console.log('✅ "user_integrations" table ensured to exist.');
         // API tokens: only their hash is kept (see services/apiTokens). Main db only, like
-        // user_integrations above.
+        // user_integrations above. A table from before tokens had a kind and permissions gets the
+        // new columns; its old tokens no longer work (they have no kind) and aren't listed.
         await pool.query(`
       CREATE TABLE IF NOT EXISTS streamby.api_tokens (
-        id            TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "userId"      VARCHAR(255) NOT NULL,
-        name          VARCHAR(255) NOT NULL,
-        prefix        VARCHAR(32) NOT NULL,
-        hash          CHAR(64) NOT NULL UNIQUE,
-        access        VARCHAR(10) NOT NULL,
-        "projectIds"  JSONB NOT NULL,
-        "createdAt"   TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "expiresAt"   TIMESTAMP WITH TIME ZONE,
-        "lastUsedAt"  TIMESTAMP WITH TIME ZONE
+        id                TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        kind              VARCHAR(10),
+        "userId"          VARCHAR(255) NOT NULL,
+        "createdByName"   VARCHAR(255),
+        name              VARCHAR(255) NOT NULL,
+        prefix            VARCHAR(32) NOT NULL,
+        hash              CHAR(64) NOT NULL UNIQUE,
+        permissions       JSONB NOT NULL DEFAULT '[]',
+        "projectIds"      JSONB NOT NULL,
+        "createdAt"       TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "expiresAt"       TIMESTAMP WITH TIME ZONE,
+        "lastUsedAt"      TIMESTAMP WITH TIME ZONE
       );
+      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS kind VARCHAR(10);
+      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS "createdByName" VARCHAR(255);
+      ALTER TABLE streamby.api_tokens ADD COLUMN IF NOT EXISTS permissions JSONB NOT NULL DEFAULT '[]';
+      DO $$ BEGIN
+        IF EXISTS (SELECT 1 FROM information_schema.columns
+                   WHERE table_schema = 'streamby' AND table_name = 'api_tokens' AND column_name = 'access') THEN
+          ALTER TABLE streamby.api_tokens ALTER COLUMN access DROP NOT NULL;
+        END IF;
+      END $$;
       CREATE INDEX IF NOT EXISTS api_tokens_userid_idx ON streamby.api_tokens ("userId");
+      CREATE INDEX IF NOT EXISTS api_tokens_kind_idx ON streamby.api_tokens (kind);
     `);
         console.log('✅ "api_tokens" table ensured to exist.');
+        // The MCP server's audit log: every tool call (see mcp/audit). Main db only.
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.mcp_audit (
+        id            TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "userId"      VARCHAR(255) NOT NULL,
+        "tokenId"     VARCHAR(255) NOT NULL,
+        "projectId"   VARCHAR(255),
+        tool          VARCHAR(100) NOT NULL,
+        ok            BOOLEAN NOT NULL,
+        status        INTEGER,
+        error         TEXT,
+        "durationMs"  INTEGER NOT NULL,
+        "createdAt"   TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+      CREATE INDEX IF NOT EXISTS mcp_audit_token_idx ON streamby.mcp_audit ("tokenId", "createdAt");
+    `);
+        console.log('✅ "mcp_audit" table ensured to exist.');
     }
     catch (error) {
         console.error('❌ Error ensuring tables exist:', error);

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { createStreamByRouter } from './middleware/createRouter';
 export { emitToUser } from './services/wsHub';
 export { createNotification } from './services/notification';
-export type { UserPlan, UserSubscription, Auth, ApiTokenScope, ApiTokenAccess } from './types';
+export type { UserPlan, UserSubscription, Auth, ApiTokenScope, ApiTokenKind, ApiTokenPermission, ProjectPermission, AccountPermission } from './types';
 export { resolveApiToken, API_TOKEN_PREFIX } from './services/apiTokens';
+export { PROJECT_PERMISSIONS, ACCOUNT_PERMISSIONS } from './services/apiTokenPermissions';
 export type { ResolvedApiToken } from './services/apiTokens';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_TOKEN_PREFIX = exports.resolveApiToken = exports.createNotification = exports.emitToUser = exports.createStreamByRouter = void 0;
+exports.ACCOUNT_PERMISSIONS = exports.PROJECT_PERMISSIONS = exports.API_TOKEN_PREFIX = exports.resolveApiToken = exports.createNotification = exports.emitToUser = exports.createStreamByRouter = void 0;
 var createRouter_1 = require("./middleware/createRouter");
 Object.defineProperty(exports, "createStreamByRouter", { enumerable: true, get: function () { return createRouter_1.createStreamByRouter; } });
 var wsHub_1 = require("./services/wsHub");
@@ -10,3 +10,6 @@ Object.defineProperty(exports, "createNotification", { enumerable: true, get: fu
 var apiTokens_1 = require("./services/apiTokens");
 Object.defineProperty(exports, "resolveApiToken", { enumerable: true, get: function () { return apiTokens_1.resolveApiToken; } });
 Object.defineProperty(exports, "API_TOKEN_PREFIX", { enumerable: true, get: function () { return apiTokens_1.API_TOKEN_PREFIX; } });
+var apiTokenPermissions_1 = require("./services/apiTokenPermissions");
+Object.defineProperty(exports, "PROJECT_PERMISSIONS", { enumerable: true, get: function () { return apiTokenPermissions_1.PROJECT_PERMISSIONS; } });
+Object.defineProperty(exports, "ACCOUNT_PERMISSIONS", { enumerable: true, get: function () { return apiTokenPermissions_1.ACCOUNT_PERMISSIONS; } });

package/dist/mcp/audit.d.ts

@@ -0,0 +1,12 @@
+import { StreamByConfig } from '../types';
+export interface McpAuditEntry {
+    userId: string;
+    tokenId: string;
+    projectId: string | null;
+    tool: string;
+    ok: boolean;
+    status: number | null;
+    error: string | null;
+    durationMs: number;
+}
+export declare function recordMcpCall(entry: McpAuditEntry, config: StreamByConfig): Promise<void>;

package/dist/mcp/audit.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordMcpCall = recordMcpCall;
+const crypto_1 = __importDefault(require("crypto"));
+const manager_1 = require("../models/manager");
+async function recordMcpCall(entry, config) {
+    try {
+        const dbType = config.databases?.find(db => db.main)?.type ?? 'nosql';
+        await (0, manager_1.getModel)('mcp_audit').create({ id: crypto_1.default.randomUUID(), ...entry, createdAt: new Date(), dbType });
+    }
+    catch (err) {
+        console.error('❌ StreamBy MCP: failed to record a tool call:', err instanceof Error ? err.message : err);
+    }
+}

package/dist/mcp/rateLimit.d.ts

@@ -0,0 +1,14 @@
+export interface RateLimit {
+    requests: number;
+    windowMs: number;
+}
+export declare const DEFAULT_MCP_RATE_LIMIT: RateLimit;
+export declare function createRateLimiter({ requests, windowMs }: RateLimit): {
+    /** Counts a request by `key`: whether it's allowed, and if not, how long until it would be. */
+    take(key: string, now?: number): {
+        allowed: true;
+    } | {
+        allowed: false;
+        retryAfterMs: number;
+    };
+};

package/dist/mcp/rateLimit.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MCP_RATE_LIMIT = void 0;
+exports.createRateLimiter = createRateLimiter;
+exports.DEFAULT_MCP_RATE_LIMIT = { requests: 120, windowMs: 60000 };
+function createRateLimiter({ requests, windowMs }) {
+    const seen = new Map();
+    return {
+        /** Counts a request by `key`: whether it's allowed, and if not, how long until it would be. */
+        take(key, now = Date.now()) {
+            const recent = (seen.get(key) ?? []).filter(at => at > now - windowMs);
+            if (recent.length >= requests) {
+                seen.set(key, recent);
+                return { allowed: false, retryAfterMs: recent[0] + windowMs - now };
+            }
+            recent.push(now);
+            seen.set(key, recent);
+            return { allowed: true };
+        },
+    };
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,15 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Auth, StreamByConfig } from '../types';
+import { ToolCall } from './tools';
+export declare const MCP_SERVER_NAME = "streamby";
+export type ApiCaller = (call: ToolCall) => Promise<{
+    status: number;
+    body: unknown;
+}>;
+/** The tools an API token may use: those whose every permission it has. */
+export declare const toolsFor: (scope: Auth["apiToken"]) => import("./tools").ToolDefinition<any>[];
+/**
+ * An MCP server for one request made with an API token (`auth`): only the tools its permissions
+ * allow. Each tool call goes to the REST API through `api`, and is recorded in the audit log.
+ */
+export declare function createMcpServer(auth: Auth, api: ApiCaller, config: StreamByConfig, version: string): McpServer;

package/dist/mcp/server.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolsFor = exports.MCP_SERVER_NAME = void 0;
+exports.createMcpServer = createMcpServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const tools_1 = require("./tools");
+const audit_1 = require("./audit");
+exports.MCP_SERVER_NAME = 'streamby';
+const errorText = (body, status) => {
+    const message = body?.message ?? body?.error;
+    return typeof message === 'string' ? message : `StreamBy answered ${status}`;
+};
+/** The tools an API token may use: those whose every permission it has. */
+const toolsFor = (scope) => tools_1.TOOLS.filter(tool => tool.permissions.every(p => !!scope?.permissions.includes(p)));
+exports.toolsFor = toolsFor;
+/**
+ * An MCP server for one request made with an API token (`auth`): only the tools its permissions
+ * allow. Each tool call goes to the REST API through `api`, and is recorded in the audit log.
+ */
+function createMcpServer(auth, api, config, version) {
+    const server = new mcp_js_1.McpServer({ name: exports.MCP_SERVER_NAME, version });
+    // A project's token acts on its project: what it does there is the project's.
+    const tokenProject = auth.apiToken?.kind === 'project' && Array.isArray(auth.apiToken.projectIds)
+        ? auth.apiToken.projectIds[0] ?? null
+        : null;
+    for (const tool of (0, exports.toolsFor)(auth.apiToken)) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.input,
+            annotations: { readOnlyHint: !tool.write, destructiveHint: !!tool.destructive, openWorldHint: false },
+        }, async (args) => {
+            const started = Date.now();
+            const projectId = tool.projectOf?.(args) ?? tokenProject;
+            let status = null;
+            try {
+                const answer = await api(tool.call(args));
+                status = answer.status;
+                const ok = status >= 200 && status < 300;
+                await (0, audit_1.recordMcpCall)({
+                    userId: auth.userId, tokenId: auth.apiToken.tokenId, projectId, tool: tool.name,
+                    ok, status, error: ok ? null : errorText(answer.body, status), durationMs: Date.now() - started,
+                }, config);
+                if (!ok)
+                    return { isError: true, content: [{ type: 'text', text: errorText(answer.body, status) }] };
+                const result = tool.pick ? tool.pick(answer.body, args) : answer.body;
+                return { content: [{ type: 'text', text: JSON.stringify(result ?? null, null, 2) }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                await (0, audit_1.recordMcpCall)({
+                    userId: auth.userId, tokenId: auth.apiToken.tokenId, projectId, tool: tool.name,
+                    ok: false, status, error: message, durationMs: Date.now() - started,
+                }, config);
+                return { isError: true, content: [{ type: 'text', text: `The call failed: ${message}` }] };
+            }
+        });
+    }
+    return server;
+}

package/dist/mcp/tools.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ApiTokenPermission } from '../services/apiTokenPermissions';
+export interface ToolCall {
+    method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+    path: string;
+    body?: unknown;
+}
+export interface ToolDefinition<S extends z.ZodRawShape = z.ZodRawShape> {
+    name: string;
+    title: string;
+    description: string;
+    permissions: ApiTokenPermission[];
+    write?: boolean;
+    destructive?: boolean;
+    input: S;
+    projectOf?: (args: z.infer<z.ZodObject<S>>) => string | undefined;
+    call: (args: z.infer<z.ZodObject<S>>) => ToolCall;
+    pick?: (data: any, args: z.infer<z.ZodObject<S>>) => unknown;
+}
+export declare const TOOLS: ToolDefinition<any>[];