@kirosnn/mosaic 0.0.91 → 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>;
 }
 
@@ -28,6 +35,11 @@ let listeners = new Set<ApprovalListener>();
 let acceptedListeners = new Set<ApprovalAcceptedListener>();
 let pendingResolve: ((response: ApprovalResponse) => void) | null = null;
 let pendingReject: ((reason?: any) => void) | null = null;
+let queuedRequests: {
+  request: ApprovalRequest;
+  resolve: (response: ApprovalResponse) => void;
+  reject: (reason?: any) => void;
+}[] = [];
 
 function notify(): void {
   for (const listener of listeners) {
@@ -54,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 });
   }
@@ -65,27 +77,32 @@ 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 }> {
-  if (pendingResolve) {
-    throw new Error('An approval request is already pending');
-  }
+  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 }),
   };
 
-  currentRequest = request;
-  notify();
-
   const response = await new Promise<ApprovalResponse>((resolve, reject) => {
+    if (pendingResolve) {
+      queuedRequests.push({ request, resolve, reject });
+      return;
+    }
+
+    currentRequest = request;
     pendingResolve = resolve;
     pendingReject = reject;
+    notify();
   });
 
   return { approved: response.approved, customResponse: response.customResponse };
@@ -114,6 +131,14 @@ export function respondApproval(approved: boolean, customResponse?: string): voi
   }
 
   resolve(response);
+
+  const next = queuedRequests.shift();
+  if (next) {
+    currentRequest = next.request;
+    pendingResolve = next.resolve;
+    pendingReject = next.reject;
+    notify();
+  }
 }
 
 export function cancelApproval(): void {
@@ -126,4 +151,12 @@ export function cancelApproval(): void {
   notify();
 
   reject(new Error('Interrupted by user'));
-}
+
+  const next = queuedRequests.shift();
+  if (next) {
+    currentRequest = next.request;
+    pendingResolve = next.resolve;
+    pendingReject = next.reject;
+    notify();
+  }
+}

package/src/utils/approvalModeBridge.ts

@@ -0,0 +1,17 @@
+import { shouldRequireApprovals } from './config'
+
+type ApprovalModeListener = (requireApprovals: boolean) => void
+
+const listeners = new Set<ApprovalModeListener>()
+
+export function subscribeApprovalMode(listener: ApprovalModeListener): () => void {
+  listeners.add(listener)
+  listener(shouldRequireApprovals())
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+export function emitApprovalMode(requireApprovals: boolean): void {
+  listeners.forEach((listener) => listener(requireApprovals))
+}

package/src/utils/commands/approvals.ts

@@ -0,0 +1,48 @@
+import type { Command } from './types'
+import { getCurrentApproval, respondApproval } from '../approvalBridge'
+import { shouldRequireApprovals, setRequireApprovals } from '../config'
+import { notifyNotification } from '../notificationBridge'
+import { emitApprovalMode } from '../approvalModeBridge'
+
+export const approvalsCommand: Command = {
+  name: 'approvals',
+  description: 'Toggle approval prompts for agent changes',
+  usage: '/approvals on|off|toggle|status',
+  aliases: ['approval', 'autoapprove', 'auto-approve'],
+  execute: (args: string[]) => {
+    const raw = args[0]?.toLowerCase()
+    const current = shouldRequireApprovals()
+    let next = current
+
+    if (!raw || raw === 'toggle') {
+      next = !current
+    } else if (raw === 'on' || raw === 'true' || raw === 'yes') {
+      next = true
+    } else if (raw === 'off' || raw === 'false' || raw === 'no') {
+      next = false
+    } else if (raw === 'status') {
+      return {
+        success: true,
+        content: current ? 'Approvals are enabled.' : 'Auto-approve is enabled.'
+      }
+    } else {
+      return {
+        success: false,
+        content: 'Usage: /approvals on|off|toggle|status'
+      }
+    }
+
+    setRequireApprovals(next)
+    if (!next && getCurrentApproval()) {
+      respondApproval(true)
+    }
+    emitApprovalMode(next)
+
+    notifyNotification(next ? 'Approvals enabled.' : 'Auto-approve enabled.', 'info', 2500)
+
+    return {
+      success: true,
+      content: next ? 'Approvals enabled.' : 'Auto-approve enabled.'
+    }
+  }
+}

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/image.ts

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync, statSync } from "fs";
+import { basename } from "path";
+import type { Command } from "./types";
+import { guessImageMimeType } from "../images";
+import { emitImageCommand, canUseImages } from "../imageBridge";
+
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+function parseImagePath(fullCommand: string): string {
+  const trimmed = fullCommand.trim();
+  const without = trimmed.replace(/^\/(image|img)\s+/i, "");
+  return without.trim();
+}
+
+export const imageCommand: Command = {
+  name: "image",
+  description: "Attach an image for the next message",
+  usage: "/image <path> | /image clear",
+  aliases: ["img"],
+  execute: (args, fullCommand) => {
+    const first = args[0]?.toLowerCase();
+    if (!first) {
+      return {
+        success: false,
+        content: "Usage: /image <path> | /image clear",
+        shouldAddToHistory: false
+      };
+    }
+
+    if (first === "clear") {
+      emitImageCommand({ type: "clear" });
+      return {
+        success: true,
+        content: "Image list cleared.",
+        shouldAddToHistory: false
+      };
+    }
+
+    if (!canUseImages()) {
+      return {
+        success: false,
+        content: "Images are not supported by the current model.",
+        shouldAddToHistory: false
+      };
+    }
+
+    const path = parseImagePath(fullCommand);
+    if (!path) {
+      return {
+        success: false,
+        content: "Missing image path.",
+        shouldAddToHistory: false
+      };
+    }
+
+    if (!existsSync(path)) {
+      return {
+        success: false,
+        content: "File not found.",
+        shouldAddToHistory: false
+      };
+    }
+
+    const stat = statSync(path);
+    if (!stat.isFile()) {
+      return {
+        success: false,
+        content: "Not a file.",
+        shouldAddToHistory: false
+      };
+    }
+
+    if (stat.size > MAX_IMAGE_BYTES) {
+      return {
+        success: false,
+        content: "Image too large (max 10 MB).",
+        shouldAddToHistory: false
+      };
+    }
+
+    const name = basename(path);
+    const mimeType = guessImageMimeType(name);
+    if (!mimeType.startsWith("image/")) {
+      return {
+        success: false,
+        content: "Unsupported image type.",
+        shouldAddToHistory: false
+      };
+    }
+
+    const data = readFileSync(path).toString("base64");
+    emitImageCommand({
+      type: "add",
+      image: {
+        id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        name,
+        mimeType,
+        data,
+        size: stat.size
+      }
+    });
+
+    return {
+      success: true,
+      content: `Image attached: ${name}`,
+      shouldAddToHistory: false
+    };
+  }
+};

package/src/utils/commands/index.ts

@@ -3,10 +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';
@@ -61,8 +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);
-}
+}