@kirosnn/mosaic 0.71.0 → 0.73.0

package/src/mcp/toolCatalog.ts

@@ -0,0 +1,169 @@
+import { tool, type CoreTool } from 'ai';
+import type { McpToolInfo, McpServerConfig } from './types';
+import { parseSafeId } from './types';
+import { McpProcessManager } from './processManager';
+import { McpApprovalPolicy } from './approvalPolicy';
+import { jsonSchemaObjectToZodObject } from './schemaConverter';
+
+function matchGlobList(name: string, patterns: string[]): boolean {
+  for (const pattern of patterns) {
+    if (pattern === '*') return true;
+    if (pattern === name) return true;
+
+    const regex = new RegExp(
+      '^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
+    );
+    if (regex.test(name)) return true;
+  }
+  return false;
+}
+
+export class McpToolCatalog {
+  private processManager: McpProcessManager;
+  private approvalPolicy: McpApprovalPolicy;
+  private configs: McpServerConfig[];
+  private exposedTools = new Map<string, CoreTool>();
+  private toolInfoMap = new Map<string, McpToolInfo>();
+  private safeToCanonical = new Map<string, string>();
+  private canonicalToSafe = new Map<string, string>();
+
+  constructor(processManager: McpProcessManager, approvalPolicy: McpApprovalPolicy, configs: McpServerConfig[]) {
+    this.processManager = processManager;
+    this.approvalPolicy = approvalPolicy;
+    this.configs = configs;
+  }
+
+  refreshTools(serverId?: string): void {
+    if (serverId) {
+      this.refreshServerTools(serverId);
+    } else {
+      for (const config of this.configs) {
+        if (config.enabled) {
+          this.refreshServerTools(config.id);
+        }
+      }
+    }
+  }
+
+  private refreshServerTools(serverId: string): void {
+    for (const [safeId, info] of this.toolInfoMap) {
+      if (info.serverId === serverId) {
+        this.exposedTools.delete(safeId);
+        this.toolInfoMap.delete(safeId);
+        this.safeToCanonical.delete(safeId);
+        this.canonicalToSafe.delete(info.canonicalId);
+      }
+    }
+
+    const config = this.configs.find(c => c.id === serverId);
+    if (!config || !config.enabled) return;
+
+    const rawTools = this.processManager.listTools(serverId);
+
+    for (const toolInfo of rawTools) {
+      if (config.tools.deny && config.tools.deny.length > 0) {
+        if (matchGlobList(toolInfo.name, config.tools.deny)) continue;
+      }
+
+      if (config.tools.allow && config.tools.allow.length > 0) {
+        if (!matchGlobList(toolInfo.name, config.tools.allow)) continue;
+      }
+
+      const coreTool = this.convertToCoreToolDef(toolInfo, config);
+      this.exposedTools.set(toolInfo.safeId, coreTool);
+      this.toolInfoMap.set(toolInfo.safeId, toolInfo);
+      this.safeToCanonical.set(toolInfo.safeId, toolInfo.canonicalId);
+      this.canonicalToSafe.set(toolInfo.canonicalId, toolInfo.safeId);
+    }
+  }
+
+  private convertToCoreToolDef(toolInfo: McpToolInfo, config: McpServerConfig): CoreTool {
+    const schema = toolInfo.inputSchema || { type: 'object', properties: {} };
+    const zodParams = jsonSchemaObjectToZodObject(schema as Record<string, unknown>);
+
+    const pm = this.processManager;
+    const ap = this.approvalPolicy;
+    const serverConfig = config;
+
+    return tool({
+      description: toolInfo.description || `MCP tool: ${toolInfo.name} (${config.name})`,
+      parameters: zodParams,
+      execute: async (args: Record<string, unknown>) => {
+        try {
+          const approvalResult = await ap.requestMcpApproval({
+            serverId: serverConfig.id,
+            serverName: serverConfig.name,
+            toolName: toolInfo.name,
+            canonicalId: toolInfo.canonicalId,
+            args,
+            approvalMode: serverConfig.approval,
+          });
+
+          if (!approvalResult.approved) {
+            if (approvalResult.customResponse) {
+              return {
+                error: `OPERATION REJECTED BY USER with custom instructions: "${approvalResult.customResponse}"`,
+                userMessage: 'Operation cancelled by user',
+              };
+            }
+            return {
+              error: `OPERATION REJECTED BY USER: calling MCP tool ${toolInfo.canonicalId}`,
+              userMessage: 'Operation cancelled by user',
+            };
+          }
+
+          const result = await pm.callTool(serverConfig.id, toolInfo.name, args);
+
+          if (result.isError) {
+            return { error: result.content };
+          }
+
+          return result.content;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { error: `MCP tool call failed: ${message}` };
+        }
+      },
+    });
+  }
+
+  getExposedTools(): Record<string, CoreTool> {
+    const result: Record<string, CoreTool> = {};
+    for (const [safeId, coreTool] of this.exposedTools) {
+      result[safeId] = coreTool;
+    }
+    return result;
+  }
+
+  getMcpToolInfos(): McpToolInfo[] {
+    return Array.from(this.toolInfoMap.values());
+  }
+
+  getToolInfo(safeId: string): McpToolInfo | null {
+    return this.toolInfoMap.get(safeId) || null;
+  }
+
+  getSafeIdFromCanonical(canonicalId: string): string | null {
+    return this.canonicalToSafe.get(canonicalId) || null;
+  }
+
+  getCanonicalFromSafeId(safeId: string): string | null {
+    return this.safeToCanonical.get(safeId) || null;
+  }
+
+  isMcpTool(toolName: string): boolean {
+    return toolName.startsWith('mcp__');
+  }
+
+  parseMcpToolName(safeId: string): { serverId: string; toolName: string } | null {
+    return parseSafeId(safeId);
+  }
+
+  updateConfigs(configs: McpServerConfig[]): void {
+    this.configs = configs;
+  }
+
+  static mergeTools(internal: Record<string, CoreTool>, mcp: Record<string, CoreTool>): Record<string, CoreTool> {
+    return { ...internal, ...mcp };
+  }
+}

package/src/mcp/types.ts

@@ -0,0 +1,95 @@
+export interface McpTransportConfig {
+  type: 'stdio';
+}
+
+export interface McpServerConfig {
+  id: string;
+  name: string;
+  enabled: boolean;
+  transport: McpTransportConfig;
+  command: string;
+  args: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  autostart: 'startup' | 'on-demand' | 'never';
+  timeouts: {
+    initialize: number;
+    call: number;
+  };
+  limits: {
+    maxCallsPerMinute: number;
+    maxPayloadBytes: number;
+  };
+  logs: {
+    persist: boolean;
+    path?: string;
+    bufferSize: number;
+  };
+  tools: {
+    allow?: string[];
+    deny?: string[];
+  };
+  approval: McpApprovalMode;
+}
+
+export type McpApprovalMode = 'always' | 'once-per-tool' | 'once-per-server' | 'never';
+
+export type McpServerStatus = 'stopped' | 'starting' | 'running' | 'error';
+
+export interface McpServerState {
+  status: McpServerStatus;
+  pid?: number;
+  initLatencyMs?: number;
+  toolCount: number;
+  lastError?: string;
+  lastCallAt?: number;
+}
+
+export interface McpToolInfo {
+  serverId: string;
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  canonicalId: string;
+  safeId: string;
+}
+
+export type McpRiskHint = 'read' | 'write' | 'execute' | 'network' | 'unknown';
+
+export type McpApprovalScope = 'toolArgs' | 'tool' | 'server';
+
+export interface McpApprovalCacheEntry {
+  scope: McpApprovalScope;
+  key: string;
+  expiresAt: number;
+}
+
+export interface McpGlobalConfig {
+  servers: McpServerConfig[];
+}
+
+export function toCanonicalId(serverId: string, toolName: string): string {
+  return `mcp:${serverId}:${toolName}`;
+}
+
+export function toSafeId(serverId: string, toolName: string): string {
+  return `mcp__${serverId}__${toolName}`;
+}
+
+export function parseSafeId(safeId: string): { serverId: string; toolName: string } | null {
+  if (!safeId.startsWith('mcp__')) return null;
+  const parts = safeId.slice(5).split('__');
+  if (parts.length < 2) return null;
+  const toolName = parts.pop()!;
+  const serverId = parts.join('__');
+  return { serverId, toolName };
+}
+
+export function parseCanonicalId(canonicalId: string): { serverId: string; toolName: string } | null {
+  if (!canonicalId.startsWith('mcp:')) return null;
+  const parts = canonicalId.slice(4).split(':');
+  if (parts.length < 2) return null;
+  const toolName = parts.pop()!;
+  const serverId = parts.join(':');
+  return { serverId, toolName };
+}

package/src/utils/approvalBridge.ts

@@ -1,12 +1,19 @@
 export interface ApprovalRequest {
   id: string;
-  toolName: 'write' | 'edit' | 'bash';
+  toolName: string;
   preview: {
     title: string;
     content: string;
     details?: string[];
   };
   args: Record<string, unknown>;
+  mcpMeta?: {
+    serverId: string;
+    serverName: string;
+    canonicalId: string;
+    riskHint: string;
+    payloadSize: number;
+  };
 }
 
 export interface ApprovalResponse {
@@ -16,7 +23,7 @@ export interface ApprovalResponse {
 }
 
 export interface ApprovalAccepted {
-  toolName: 'write' | 'edit' | 'bash';
+  toolName: string;
   args: Record<string, unknown>;
 }
 
@@ -59,7 +66,7 @@ export function subscribeApprovalAccepted(listener: ApprovalAcceptedListener): (
   };
 }
 
-function notifyApprovalAccepted(toolName: 'write' | 'edit' | 'bash', args: Record<string, unknown>): void {
+function notifyApprovalAccepted(toolName: string, args: Record<string, unknown>): void {
   for (const listener of acceptedListeners) {
     listener({ toolName, args });
   }
@@ -70,15 +77,20 @@ export function getCurrentApproval(): ApprovalRequest | null {
 }
 
 export async function requestApproval(
-  toolName: 'write' | 'edit' | 'bash',
+  toolName: string,
   args: Record<string, unknown>,
   preview: { title: string; content: string; details?: string[] }
 ): Promise<{ approved: boolean; customResponse?: string }> {
+  const mcpMeta = (args as any).__mcpMeta;
+  const cleanArgs = { ...args };
+  delete (cleanArgs as any).__mcpMeta;
+
   const request: ApprovalRequest = {
     id: createId(),
     toolName,
     preview,
-    args,
+    args: cleanArgs,
+    ...(mcpMeta && { mcpMeta }),
   };
 
   const response = await new Promise<ApprovalResponse>((resolve, reject) => {

package/src/utils/commands/compact.ts

@@ -0,0 +1,30 @@
+import type { Command, CommandResult } from './types';
+
+export const compactCommand: Command = {
+  name: 'compact',
+  description: 'Compact the current conversation context',
+  usage: '/compact [maxTokens]',
+  execute: (args: string[]): CommandResult => {
+    let maxTokens: number | undefined;
+    if (args[0]) {
+      const parsed = Number(args[0]);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        return {
+          success: false,
+          content: 'Invalid maxTokens. Usage: /compact [maxTokens]',
+          shouldAddToHistory: false
+        };
+      }
+      maxTokens = Math.floor(parsed);
+    }
+
+    return {
+      success: true,
+      content: 'Conversation compacted.',
+      shouldAddToHistory: false,
+      shouldCompactMessages: true,
+      compactMaxTokens: maxTokens,
+      shouldClearMessages: true
+    };
+  }
+};

package/src/utils/commands/echo.ts

@@ -5,7 +5,7 @@ export const echoCommand: Command = {
   description: 'Echo the provided text back to the user',
   usage: '/echo <text>',
   aliases: ['e'],
-  execute: (args: string[], fullCommand: string): { success: boolean; content: string } => {
+  execute: (args: string[], _fullCommand: string): { success: boolean; content: string } => {
     if (args.length === 0) {
       return {
         success: false,

package/src/utils/commands/index.ts

@@ -3,12 +3,11 @@ import { commandRegistry } from './registry';
 import { echoCommand } from './echo';
 import { helpCommand } from './help';
 import { initCommand } from './init';
-import { undoCommand } from './undo';
-import { redoCommand } from './redo';
-import { sessionsCommand } from './sessions';
 import { webCommand } from './web';
 import { imageCommand } from './image';
 import { approvalsCommand } from './approvals';
+import { newCommand } from './new';
+import { compactCommand } from './compact';
 
 export { commandRegistry } from './registry';
 export type { Command, CommandResult, CommandRegistry } from './types';
@@ -63,10 +62,9 @@ export function initializeCommands(): void {
   commandRegistry.register(echoCommand);
   commandRegistry.register(helpCommand);
   commandRegistry.register(initCommand);
-  commandRegistry.register(undoCommand);
-  commandRegistry.register(redoCommand);
-  commandRegistry.register(sessionsCommand);
   commandRegistry.register(webCommand);
   commandRegistry.register(imageCommand);
   commandRegistry.register(approvalsCommand);
+  commandRegistry.register(newCommand);
+  commandRegistry.register(compactCommand);
 }

package/src/utils/commands/new.ts

@@ -0,0 +1,15 @@
+import type { Command, CommandResult } from './types';
+
+export const newCommand: Command = {
+  name: 'new',
+  description: 'Start a new chat',
+  usage: '/new',
+  aliases: ['clear'],
+  execute: (_args: string[], _fullCommand: string): CommandResult => {
+    return {
+      success: true,
+      content: 'Starting a new chat...',
+      shouldClearMessages: true
+    };
+  }
+};

package/src/utils/commands/types.ts

@@ -2,6 +2,9 @@ export interface CommandResult {
   success: boolean;
   content: string;
   shouldAddToHistory?: boolean;
+  shouldClearMessages?: boolean;
+  shouldCompactMessages?: boolean;
+  compactMaxTokens?: number;
 }
 
 export interface Command {

package/src/utils/config.ts

@@ -38,6 +38,8 @@ export interface MosaicConfig {
   model?: string;
   apiKey?: string;
   systemPrompt?: string;
+  maxSteps?: number;
+  maxContextTokens?: number;
   customProviders?: CustomProvider[];
   customModels?: { [providerId: string]: AIModel[] };
   requireApprovals?: boolean;
@@ -354,4 +356,4 @@ export function clearRecentProjects(): void {
   const config = readConfig();
   config.recentProjects = [];
   writeConfig(config);
-}
+}

package/src/utils/diffRendering.tsx

@@ -34,8 +34,6 @@ export function renderDiffLine(line: string, key: string) {
 
 export function renderInlineDiffLine(content: string) {
   const parsed = parseDiffLine(content);
-  const colors = getDiffLineColors(parsed);
-
   if (parsed.isDiffLine) {
     return (
       <>
@@ -56,6 +54,6 @@ export function renderInlineDiffLine(content: string) {
   return null;
 }
 
-export function getDiffLineBackground(content: string): string | null {
+export function getDiffLineBackground(_content: string): string | null {
   return null;
 }

package/src/utils/exploreBridge.ts

@@ -15,6 +15,7 @@ interface ExploreBridgeGlobal {
   toolCallback: ExploreToolCallback | null;
   totalExploreTokens: number;
   subscribers: Set<ExploreToolSubscriber>;
+  parentContext: string;
 }
 
 const globalKey = '__mosaic_explore_bridge__';
@@ -26,6 +27,7 @@ if (!g[globalKey]) {
     toolCallback: null,
     totalExploreTokens: 0,
     subscribers: new Set<ExploreToolSubscriber>(),
+    parentContext: '',
   };
 }
 
@@ -85,3 +87,11 @@ export function subscribeExploreTool(callback: ExploreToolSubscriber): () => voi
 export function getExploreTokens(): number {
   return state.totalExploreTokens;
 }
+
+export function setExploreContext(context: string): void {
+  state.parentContext = context;
+}
+
+export function getExploreContext(): string {
+  return state.parentContext;
+}