@assistkick/create 1.21.0 → 1.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistkick/create",
-  "version": "1.21.0",
+  "version": "1.23.0",
   "description": "Scaffold assistkick-product-system into any project",
   "type": "module",
   "bin": {

package/templates/assistkick-product-system/packages/backend/src/routes/mcp_config.ts

@@ -1,8 +1,11 @@
 /**
  * MCP config routes — per-user MCP server configuration management.
- * GET    /api/mcp-config           — get all configs for the authenticated user
- * PUT    /api/mcp-config/:type     — upsert a config (type = localhost | remote)
- * DELETE /api/mcp-config/:type     — delete a config
+ * All endpoints accept an optional ?projectId query param to scope configs to a project.
+ * Without projectId, configs are global (user-level).
+ *
+ * GET    /api/mcp-config?projectId=...         — get configs for the authenticated user
+ * PUT    /api/mcp-config/:type?projectId=...   — upsert a config (type = localhost | remote)
+ * DELETE /api/mcp-config/:type?projectId=...   — delete a config
  */
 
 import { Router } from 'express';
@@ -16,16 +19,15 @@ interface McpConfigRoutesDeps {
 export const createMcpConfigRoutes = ({ mcpConfigService, log }: McpConfigRoutesDeps): Router => {
   const router: Router = Router();
 
-  // GET /api/mcp-config — list all configs for the authenticated user
+  // GET /api/mcp-config?projectId=...
   router.get('/', async (req, res) => {
     const userId = (req as any).user?.id;
-    if (!userId) {
-      res.status(401).json({ error: 'Unauthorized' });
-      return;
-    }
+    if (!userId) { res.status(401).json({ error: 'Unauthorized' }); return; }
+
+    const projectId = (req.query.projectId as string) || null;
 
     try {
-      const configs = await mcpConfigService.getAllConfigs(userId);
+      const configs = await mcpConfigService.getAllConfigs(userId, projectId);
       res.json({ configs });
     } catch (err: any) {
       log('MCP_CONFIG', `List configs failed: ${err.message}`);
@@ -33,15 +35,13 @@ export const createMcpConfigRoutes = ({ mcpConfigService, log }: McpConfigRoutes
     }
   });
 
-  // PUT /api/mcp-config/:type — upsert a config
+  // PUT /api/mcp-config/:type?projectId=...
   router.put('/:type', async (req, res) => {
     const userId = (req as any).user?.id;
-    if (!userId) {
-      res.status(401).json({ error: 'Unauthorized' });
-      return;
-    }
+    if (!userId) { res.status(401).json({ error: 'Unauthorized' }); return; }
 
     const configType = req.params.type;
+    const projectId = (req.query.projectId as string) || (req.body.projectId as string) || null;
     const { mcpServersJson } = req.body;
 
     if (!mcpServersJson || typeof mcpServersJson !== 'string') {
@@ -50,7 +50,7 @@ export const createMcpConfigRoutes = ({ mcpConfigService, log }: McpConfigRoutes
     }
 
     try {
-      const config = await mcpConfigService.upsertConfig(userId, configType, mcpServersJson);
+      const config = await mcpConfigService.upsertConfig(userId, configType, mcpServersJson, projectId);
       res.json({ config });
     } catch (err: any) {
       log('MCP_CONFIG', `Upsert config failed: ${err.message}`);
@@ -62,18 +62,16 @@ export const createMcpConfigRoutes = ({ mcpConfigService, log }: McpConfigRoutes
     }
   });
 
-  // DELETE /api/mcp-config/:type — delete a config
+  // DELETE /api/mcp-config/:type?projectId=...
   router.delete('/:type', async (req, res) => {
     const userId = (req as any).user?.id;
-    if (!userId) {
-      res.status(401).json({ error: 'Unauthorized' });
-      return;
-    }
+    if (!userId) { res.status(401).json({ error: 'Unauthorized' }); return; }
 
     const configType = req.params.type;
+    const projectId = (req.query.projectId as string) || null;
 
     try {
-      const deleted = await mcpConfigService.deleteConfig(userId, configType);
+      const deleted = await mcpConfigService.deleteConfig(userId, configType, projectId);
       if (!deleted) {
         res.status(404).json({ error: 'Config not found' });
         return;

package/templates/assistkick-product-system/packages/backend/src/services/chat_cli_bridge.ts

@@ -33,8 +33,8 @@ export interface SpawnOptions {
   allowedTools?: string[];
   /** Compacted conversation context to prepend to the system prompt */
   continuationContext?: string;
-  /** Inline MCP config JSON string to pass via --mcp-config */
-  mcpConfigJson?: string;
+  /** Path to a temporary MCP config JSON file to pass via --mcp-config */
+  mcpConfigPath?: string;
   onEvent: (event: Record<string, unknown>) => void;
 }
 
@@ -92,9 +92,9 @@ export class ChatCliBridge {
       }
     }
 
-    // MCP server configuration (inline JSON string)
-    if (options.mcpConfigJson) {
-      args.push('--mcp-config', options.mcpConfigJson);
+    // MCP server configuration (temp file path)
+    if (options.mcpConfigPath) {
+      args.push('--mcp-config', options.mcpConfigPath);
     }
 
     // Prompt via stdin

package/templates/assistkick-product-system/packages/backend/src/services/chat_ws_handler.ts

@@ -30,6 +30,9 @@ import type { ChatMessageRepository } from './chat_message_repository.js';
 import type { ChatSessionService } from './chat_session_service.js';
 import type { TitleGeneratorService } from './title_generator_service.js';
 import type { McpConfigService } from './mcp_config_service.js';
+import { writeFileSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 export interface ChatWsHandlerDeps {
   wss: WebSocketServer;
@@ -425,15 +428,18 @@ export class ChatWsHandler {
       }
     }
 
-    // Build inline MCP config JSON for this spawn (if user has MCP servers configured)
-    let mcpConfigJson: string | undefined;
+    // Build MCP config temp file for this spawn (if user has MCP servers configured)
+    let mcpConfigPath: string | undefined;
+    let mcpConfigContent: string | undefined;
     const userId = this.wsUserIds.get(ws);
     if (userId && this.mcpConfigService) {
       try {
-        const mergedServers = await this.mcpConfigService.buildMergedConfig(userId);
+        const mergedServers = await this.mcpConfigService.buildMergedConfig(userId, projectId);
         if (mergedServers) {
-          mcpConfigJson = JSON.stringify({ mcpServers: mergedServers });
-          this.log('CHAT_WS', `MCP config: ${Object.keys(mergedServers).length} server(s) for user ${userId}`);
+          mcpConfigContent = JSON.stringify({ mcpServers: mergedServers }, null, 2);
+          mcpConfigPath = join(tmpdir(), `mcp-${claudeSessionId}.json`);
+          writeFileSync(mcpConfigPath, mcpConfigContent, 'utf-8');
+          this.log('CHAT_WS', `MCP config for user ${userId}: ${mcpConfigContent}`);
         }
       } catch (err: any) {
         this.log('CHAT_WS', `Failed to build MCP config: ${err.message}`);
@@ -449,7 +455,7 @@ export class ChatWsHandler {
         permissionMode,
         allowedTools: msg.allowedTools,
         continuationContext,
-        mcpConfigJson,
+        mcpConfigPath,
         onEvent: (event) => {
           // Forward to current WS (may have been re-attached after disconnect)
           const currentWs = this.sessionToWs.get(claudeSessionId);
@@ -542,6 +548,11 @@ export class ChatWsHandler {
 
       completion
         .then((result) => {
+          // Clean up MCP config temp file
+          if (mcpConfigPath) {
+            try { unlinkSync(mcpConfigPath); } catch { /* already deleted */ }
+          }
+
           // Look up the current WS — may differ from the original if client reconnected
           const currentWs = this.sessionToWs.get(claudeSessionId);
           if (currentWs) {
@@ -581,6 +592,7 @@ export class ChatWsHandler {
               const parts: string[] = [];
               if (result.stderr) parts.push(result.stderr);
               if (result.stdoutNonJsonLines) parts.push(result.stdoutNonJsonLines);
+              if (mcpConfigContent) parts.push(`MCP config passed: ${mcpConfigContent}`);
               errorDetail = parts.length > 0
                 ? parts.join('\n')
                 : `CLI exited with code ${result.exitCode}`;

package/templates/assistkick-product-system/packages/backend/src/services/mcp_config_service.ts

@@ -1,11 +1,13 @@
 /**
  * McpConfigService — CRUD operations for per-user MCP server configurations.
- * Each user has two config slots: 'localhost' (for local dev) and 'remote' (for Docker/cloud).
+ * Each user has two config slots per scope: 'localhost' (local dev) and 'remote' (Docker/cloud).
+ * Configs can be global (projectId=null) or project-scoped (projectId set).
  * Uses deterministic IDs to enforce uniqueness at the PK level.
  */
 
-import {eq} from 'drizzle-orm';
+import {eq, and, isNull, or} from 'drizzle-orm';
 import {userMcpConfigs} from '@assistkick/shared/db/schema.js';
+import {existsSync} from 'node:fs';
 
 interface McpConfigServiceDeps {
   getDb: () => any;
@@ -15,6 +17,7 @@ interface McpConfigServiceDeps {
 export interface McpConfigRecord {
   id: string;
   userId: string;
+  projectId: string | null;
   configType: string;
   mcpServersJson: string;
   createdAt: string;
@@ -25,33 +28,38 @@ export class McpConfigService {
   private readonly getDb: () => any;
   private readonly log: McpConfigServiceDeps['log'];
 
-  constructor({ getDb, log }: McpConfigServiceDeps) {
+  constructor({getDb, log}: McpConfigServiceDeps) {
     this.getDb = getDb;
     this.log = log;
   }
 
-  /** Generate a deterministic ID to enforce (userId, configType) uniqueness. */
-  private makeId = (userId: string, configType: string): string => {
-    return `mcpcfg_${userId}_${configType}`;
+  /** Generate a deterministic ID to enforce (userId, projectId, configType) uniqueness. */
+  private makeId = (userId: string, configType: string, projectId?: string | null): string => {
+    const scope = projectId || 'global';
+    return `mcpcfg_${userId}_${scope}_${configType}`;
   };
 
-  /** Get all MCP configs for a user (localhost + remote). */
-  getAllConfigs = async (userId: string): Promise<McpConfigRecord[]> => {
+  /** Get all MCP configs for a user at a given scope. */
+  getAllConfigs = async (userId: string, projectId?: string | null): Promise<McpConfigRecord[]> => {
     const db = this.getDb();
-    return db.select().from(userMcpConfigs).where(eq(userMcpConfigs.userId, userId));
+    const scopeCondition = projectId
+      ? eq(userMcpConfigs.projectId, projectId)
+      : isNull(userMcpConfigs.projectId);
+    return db.select().from(userMcpConfigs).where(
+      and(eq(userMcpConfigs.userId, userId), scopeCondition),
+    );
   };
 
-  /** Get a single config by user and type. */
-  getConfig = async (userId: string, configType: string): Promise<McpConfigRecord | null> => {
+  /** Get a single config by user, scope, and type. */
+  getConfig = async (userId: string, configType: string, projectId?: string | null): Promise<McpConfigRecord | null> => {
     const db = this.getDb();
-    const id = this.makeId(userId, configType);
+    const id = this.makeId(userId, configType, projectId);
     const [row] = await db.select().from(userMcpConfigs).where(eq(userMcpConfigs.id, id));
     return row || null;
   };
 
   /** Create or update a config. Validates JSON before storing. */
-  upsertConfig = async (userId: string, configType: string, mcpServersJson: string): Promise<McpConfigRecord> => {
-    // Validate JSON
+  upsertConfig = async (userId: string, configType: string, mcpServersJson: string, projectId?: string | null): Promise<McpConfigRecord> => {
     try {
       JSON.parse(mcpServersJson);
     } catch {
@@ -63,22 +71,23 @@ export class McpConfigService {
     }
 
     const db = this.getDb();
-    const id = this.makeId(userId, configType);
+    const id = this.makeId(userId, configType, projectId);
     const now = new Date().toISOString();
 
-    const existing = await this.getConfig(userId, configType);
+    const existing = await this.getConfig(userId, configType, projectId);
 
     if (existing) {
       await db.update(userMcpConfigs)
-        .set({ mcpServersJson, updatedAt: now })
+        .set({mcpServersJson, updatedAt: now})
         .where(eq(userMcpConfigs.id, id));
-      this.log('MCP_CONFIG', `Updated ${configType} config for user ${userId}`);
-      return { ...existing, mcpServersJson, updatedAt: now };
+      this.log('MCP_CONFIG', `Updated ${configType} config for user ${userId} (project: ${projectId || 'global'})`);
+      return {...existing, mcpServersJson, updatedAt: now};
     }
 
     const record: McpConfigRecord = {
       id,
       userId,
+      projectId: projectId || null,
       configType,
       mcpServersJson,
       createdAt: now,
@@ -86,37 +95,51 @@ export class McpConfigService {
     };
 
     await db.insert(userMcpConfigs).values(record);
-    this.log('MCP_CONFIG', `Created ${configType} config for user ${userId}`);
+    this.log('MCP_CONFIG', `Created ${configType} config for user ${userId} (project: ${projectId || 'global'})`);
     return record;
   };
 
   /** Delete a config. */
-  deleteConfig = async (userId: string, configType: string): Promise<boolean> => {
+  deleteConfig = async (userId: string, configType: string, projectId?: string | null): Promise<boolean> => {
     const db = this.getDb();
-    const id = this.makeId(userId, configType);
-    const existing = await this.getConfig(userId, configType);
+    const id = this.makeId(userId, configType, projectId);
+    const existing = await this.getConfig(userId, configType, projectId);
     if (!existing) return false;
 
     await db.delete(userMcpConfigs).where(eq(userMcpConfigs.id, id));
-    this.log('MCP_CONFIG', `Deleted ${configType} config for user ${userId}`);
+    this.log('MCP_CONFIG', `Deleted ${configType} config for user ${userId} (project: ${projectId || 'global'})`);
     return true;
   };
 
   /**
-   * Build a merged mcpServers object for a user based on the current environment.
+   * Build a merged mcpServers object for a user + project based on the current environment.
+   * Merges global configs first, then project-specific configs on top (project overrides global).
    * In Docker: only remote configs are included.
    * Locally: both localhost and remote configs are merged.
    */
-  buildMergedConfig = async (userId: string): Promise<Record<string, unknown> | null> => {
-    const configs = await this.getAllConfigs(userId);
+  buildMergedConfig = async (userId: string, projectId?: string | null): Promise<Record<string, unknown> | null> => {
+    const db = this.getDb();
+
+    // Load global + project-scoped configs in one query
+    const condition = projectId
+      ? and(
+          eq(userMcpConfigs.userId, userId),
+          or(isNull(userMcpConfigs.projectId), eq(userMcpConfigs.projectId, projectId)),
+        )
+      : and(eq(userMcpConfigs.userId, userId), isNull(userMcpConfigs.projectId));
+
+    const configs: McpConfigRecord[] = await db.select().from(userMcpConfigs).where(condition);
     if (configs.length === 0) return null;
 
-    const isDocker = process.env.DOCKER === '1'
-      || (await import('node:fs')).existsSync('/.dockerenv');
+    const isDocker = process.env.DOCKER === '1' || existsSync('/.dockerenv');
 
     const merged: Record<string, unknown> = {};
 
-    for (const cfg of configs) {
+    // Apply global configs first, then project-specific (so project overrides global)
+    const globalConfigs = configs.filter(c => !c.projectId);
+    const projectConfigs = configs.filter(c => !!c.projectId);
+
+    for (const cfg of [...globalConfigs, ...projectConfigs]) {
       if (isDocker && cfg.configType === 'localhost') continue;
 
       try {

package/templates/assistkick-product-system/packages/frontend/src/api/client.ts

@@ -943,16 +943,18 @@ export class ApiClient {
 
   // --- MCP Config ---
 
-  /** Fetch all MCP configs for the authenticated user. */
-  getMcpConfigs = async (): Promise<{ configs: Array<{ id: string; userId: string; configType: string; mcpServersJson: string; createdAt: string; updatedAt: string }> }> => {
-    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/mcp-config`);
+  /** Fetch MCP configs for the authenticated user. Pass projectId for project-scoped, omit for global. */
+  getMcpConfigs = async (projectId?: string | null): Promise<{ configs: Array<{ id: string; userId: string; projectId: string | null; configType: string; mcpServersJson: string; createdAt: string; updatedAt: string }> }> => {
+    const qs = projectId ? `?projectId=${encodeURIComponent(projectId)}` : '';
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/mcp-config${qs}`);
     if (!resp.ok) throw new Error(`Failed to fetch MCP configs: ${resp.status}`);
     return resp.json();
   };
 
-  /** Save (create or update) an MCP config for the authenticated user. */
-  saveMcpConfig = async (configType: 'localhost' | 'remote', mcpServersJson: string): Promise<{ config: any }> => {
-    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/mcp-config/${configType}`, {
+  /** Save (create or update) an MCP config. Pass projectId for project-scoped, omit for global. */
+  saveMcpConfig = async (configType: 'localhost' | 'remote', mcpServersJson: string, projectId?: string | null): Promise<{ config: any }> => {
+    const qs = projectId ? `?projectId=${encodeURIComponent(projectId)}` : '';
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/mcp-config/${configType}${qs}`, {
       method: 'PUT',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ mcpServersJson }),
@@ -964,9 +966,10 @@ export class ApiClient {
     return resp.json();
   };
 
-  /** Delete an MCP config for the authenticated user. */
-  deleteMcpConfig = async (configType: 'localhost' | 'remote'): Promise<void> => {
-    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/mcp-config/${configType}`, {
+  /** Delete an MCP config. Pass projectId for project-scoped, omit for global. */
+  deleteMcpConfig = async (configType: 'localhost' | 'remote', projectId?: string | null): Promise<void> => {
+    const qs = projectId ? `?projectId=${encodeURIComponent(projectId)}` : '';
+    const resp = await this.fetchWithRefresh(`${this.baseUrl}/api/mcp-config/${configType}${qs}`, {
       method: 'DELETE',
     });
     if (!resp.ok) {

package/templates/assistkick-product-system/packages/frontend/src/components/McpConfigModal.tsx

@@ -1,18 +1,21 @@
 /**
  * McpConfigModal — Modal dialog for editing per-user MCP server configurations.
- * Two tabs: Localhost (for local dev) and Remote (for Docker/cloud deployments).
+ * Scope toggle: Global (user-level) or Project (project-scoped).
+ * Two tabs per scope: Localhost (local dev only) and Remote (all environments).
  * Each tab has a JSON textarea editor with validation and save functionality.
  */
 
-import { useCallback, useEffect, useState } from 'react';
-import { X } from 'lucide-react';
-import { apiClient } from '../api/client';
+import {useCallback, useEffect, useState} from 'react';
+import {Globe, X} from 'lucide-react';
+import {apiClient} from '../api/client';
+import {useProjectStore} from '../stores/useProjectStore';
 
 interface McpConfigModalProps {
   onClose: () => void;
 }
 
 type ConfigTab = 'localhost' | 'remote';
+type Scope = 'global' | 'project';
 
 const PLACEHOLDER_CONFIG = JSON.stringify(
   {
@@ -24,10 +27,18 @@ const PLACEHOLDER_CONFIG = JSON.stringify(
   2,
 );
 
-export function McpConfigModal({ onClose }: McpConfigModalProps) {
+export function McpConfigModal({onClose}: McpConfigModalProps) {
+  const selectedProjectId = useProjectStore((s) => s.selectedProjectId);
+
+  const [scope, setScope] = useState<Scope>('global');
   const [activeTab, setActiveTab] = useState<ConfigTab>('localhost');
-  const [localhostJson, setLocalhostJson] = useState('{}');
-  const [remoteJson, setRemoteJson] = useState('{}');
+
+  // Separate state for global and project configs
+  const [globalLocalhostJson, setGlobalLocalhostJson] = useState('{}');
+  const [globalRemoteJson, setGlobalRemoteJson] = useState('{}');
+  const [projectLocalhostJson, setProjectLocalhostJson] = useState('{}');
+  const [projectRemoteJson, setProjectRemoteJson] = useState('{}');
+
   const [saving, setSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [success, setSuccess] = useState<string | null>(null);
@@ -36,11 +47,22 @@ export function McpConfigModal({ onClose }: McpConfigModalProps) {
   useEffect(() => {
     const load = async () => {
       try {
-        const { configs } = await apiClient.getMcpConfigs();
-        for (const cfg of configs) {
+        // Load global configs
+        const {configs: globalConfigs} = await apiClient.getMcpConfigs();
+        for (const cfg of globalConfigs) {
           const formatted = JSON.stringify(JSON.parse(cfg.mcpServersJson), null, 2);
-          if (cfg.configType === 'localhost') setLocalhostJson(formatted);
-          if (cfg.configType === 'remote') setRemoteJson(formatted);
+          if (cfg.configType === 'localhost') setGlobalLocalhostJson(formatted);
+          if (cfg.configType === 'remote') setGlobalRemoteJson(formatted);
+        }
+
+        // Load project configs if a project is selected
+        if (selectedProjectId) {
+          const {configs: projectConfigs} = await apiClient.getMcpConfigs(selectedProjectId);
+          for (const cfg of projectConfigs) {
+            const formatted = JSON.stringify(JSON.parse(cfg.mcpServersJson), null, 2);
+            if (cfg.configType === 'localhost') setProjectLocalhostJson(formatted);
+            if (cfg.configType === 'remote') setProjectRemoteJson(formatted);
+          }
         }
       } catch (err: any) {
         setError(`Failed to load configs: ${err.message}`);
@@ -49,10 +71,24 @@ export function McpConfigModal({ onClose }: McpConfigModalProps) {
       }
     };
     load();
-  }, []);
+  }, [selectedProjectId]);
+
+  const getCurrentJson = (): string => {
+    if (scope === 'global') return activeTab === 'localhost' ? globalLocalhostJson : globalRemoteJson;
+    return activeTab === 'localhost' ? projectLocalhostJson : projectRemoteJson;
+  };
 
-  const currentJson = activeTab === 'localhost' ? localhostJson : remoteJson;
-  const setCurrentJson = activeTab === 'localhost' ? setLocalhostJson : setRemoteJson;
+  const setCurrentJson = (value: string) => {
+    if (scope === 'global') {
+      if (activeTab === 'localhost') setGlobalLocalhostJson(value);
+      else setGlobalRemoteJson(value);
+    } else {
+      if (activeTab === 'localhost') setProjectLocalhostJson(value);
+      else setProjectRemoteJson(value);
+    }
+  };
+
+  const currentJson = getCurrentJson();
 
   const validateJson = useCallback((json: string): string | null => {
     try {
@@ -67,7 +103,7 @@ export function McpConfigModal({ onClose }: McpConfigModalProps) {
   }, []);
 
   const handleSave = useCallback(async () => {
-    const jsonToSave = activeTab === 'localhost' ? localhostJson : remoteJson;
+    const jsonToSave = getCurrentJson();
     const validationError = validateJson(jsonToSave);
     if (validationError) {
       setError(validationError);
@@ -78,16 +114,20 @@ export function McpConfigModal({ onClose }: McpConfigModalProps) {
     setError(null);
     setSuccess(null);
 
+    const projectId = scope === 'project' ? selectedProjectId : null;
+
     try {
-      await apiClient.saveMcpConfig(activeTab, jsonToSave);
-      setSuccess(`${activeTab === 'localhost' ? 'Localhost' : 'Remote'} config saved`);
+      await apiClient.saveMcpConfig(activeTab, jsonToSave, projectId);
+      const scopeLabel = scope === 'project' ? 'Project' : 'Global';
+      const typeLabel = activeTab === 'localhost' ? 'localhost' : 'remote';
+      setSuccess(`${scopeLabel} ${typeLabel} config saved`);
       setTimeout(() => setSuccess(null), 3000);
     } catch (err: any) {
       setError(err.message);
     } finally {
       setSaving(false);
     }
-  }, [activeTab, localhostJson, remoteJson, validateJson]);
+  }, [scope, activeTab, selectedProjectId, globalLocalhostJson, globalRemoteJson, projectLocalhostJson, projectRemoteJson, validateJson]);
 
   const handleKeyDown = useCallback(
     (e: React.KeyboardEvent) => {
@@ -105,7 +145,9 @@ export function McpConfigModal({ onClose }: McpConfigModalProps) {
   return (
     <div
       className="fixed inset-0 z-50 flex items-center justify-center bg-black/60"
-      onClick={(e) => { if (e.target === e.currentTarget) onClose(); }}
+      onClick={(e) => {
+        if (e.target === e.currentTarget) onClose();
+      }}
       onKeyDown={handleKeyDown}
     >
       <div className="bg-surface border border-edge rounded-lg shadow-xl w-[640px] max-h-[80vh] flex flex-col">
@@ -121,11 +163,63 @@ export function McpConfigModal({ onClose }: McpConfigModalProps) {
           </button>
         </div>
 
+        {/* Scope toggle */}
+        <div className="flex items-center gap-1 px-4 py-2 border-b border-edge">
+          <span className="text-[11px] text-content-muted mr-2">Scope:</span>
+          <button
+            type="button"
+            className={`h-6 px-2.5 rounded text-[11px] font-mono transition-colors ${
+              scope === 'global'
+                ? 'bg-accent text-white'
+                : 'text-content-muted bg-transparent border border-edge hover:bg-surface-raised'
+            }`}
+            onClick={() => {
+              setScope('global');
+              setError(null);
+              setSuccess(null);
+            }}
+          >
+            Global
+          </button>
+          <button
+            type="button"
+            className={`h-6 px-2.5 rounded text-[11px] font-mono transition-colors ${
+              scope === 'project'
+                ? 'bg-accent text-white'
+                : 'text-content-muted bg-transparent border border-edge hover:bg-surface-raised'
+            }`}
+            onClick={() => {
+              setScope('project');
+              setError(null);
+              setSuccess(null);
+            }}
+            disabled={!selectedProjectId}
+            title={selectedProjectId ? `Project: ${selectedProjectId}` : 'No project selected'}
+          >
+            Project
+          </button>
+          {scope === 'project' && selectedProjectId && (
+            <span className="text-[10px] text-content-muted ml-1 font-mono truncate max-w-[200px]">
+              {selectedProjectId}
+            </span>
+          )}
+        </div>
+
         {/* Description */}
         <div className="px-4 py-2 text-[11px] text-content-muted border-b border-edge">
-          Configure MCP servers for your chat sessions. <strong>Localhost</strong> servers are only
-          used in local development. <strong>Remote</strong> servers are used in all environments
-          (local + Docker).
+          {scope === 'global' ? (
+            <>
+              <strong>Global</strong> configs apply to all projects for your user.{' '}
+              Project-specific configs are merged on top (project overrides global).
+            </>
+          ) : (
+            <>
+              <strong>Project</strong> configs only apply to this project and override global configs
+              with the same server name.
+            </>
+          )}
+          {' '}<strong>Localhost</strong> servers are excluded in Docker.{' '}
+          <strong>Remote</strong> servers are used everywhere.
         </div>
 
         {/* Tabs */}
@@ -139,7 +233,11 @@ export function McpConfigModal({ onClose }: McpConfigModalProps) {
                   ? 'text-accent border-b-2 border-accent bg-surface-alt'
                   : 'text-content-muted hover:text-content hover:bg-surface-raised'
               }`}
-              onClick={() => { setActiveTab(tab); setError(null); setSuccess(null); }}
+              onClick={() => {
+                setActiveTab(tab);
+                setError(null);
+                setSuccess(null);
+              }}
             >
               {tab === 'localhost' ? 'Localhost' : 'Remote'}
             </button>
@@ -167,12 +265,13 @@ export function McpConfigModal({ onClose }: McpConfigModalProps) {
                 placeholder={PLACEHOLDER_CONFIG}
                 spellCheck={false}
               />
-              {jsonError && (
-                <p className="text-[11px] text-error mt-1">{jsonError}</p>
-              )}
+              {jsonError && <p className="text-[11px] text-error mt-1">{jsonError}</p>}
               <p className="text-[10px] text-content-muted mt-1.5">
-                Enter the content of the <code className="bg-surface-raised px-1 rounded">mcpServers</code> object.
-                Example: <code className="bg-surface-raised px-1 rounded">{'{ "jetbrains": { "url": "http://localhost:6637/sse" } }'}</code>
+                Enter the content of the{' '}
+                <code className="bg-surface-raised px-1 rounded">mcpServers</code> object. Example:{' '}
+                <code className="bg-surface-raised px-1 rounded">
+                  {'{ "jetbrains": { "url": "http://localhost:6637/sse" } }'}
+                </code>
               </p>
             </>
           )}

package/templates/assistkick-product-system/packages/shared/db/migrations/0002_noisy_maelstrom.sql

@@ -0,0 +1 @@
+ALTER TABLE `user_mcp_configs` ADD `project_id` text;