@kirosnn/mosaic 0.71.0 → 0.74.0

package/src/mcp/types.ts

@@ -0,0 +1,116 @@
+export interface McpTransportConfig {
+  type: 'stdio';
+}
+
+export interface McpServerConfig {
+  id: string;
+  name: string;
+  enabled: boolean;
+  native?: 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;
+  toolApproval?: Record<string, 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 };
+}
+
+export const NATIVE_SERVER_IDS = new Set(['navigation']);
+
+export function isNativeMcpServer(serverId: string): boolean {
+  return NATIVE_SERVER_IDS.has(serverId);
+}
+
+export function isNativeMcpTool(safeId: string): boolean {
+  const parsed = parseSafeId(safeId);
+  if (!parsed) return false;
+  return NATIVE_SERVER_IDS.has(parsed.serverId);
+}
+
+export function getNativeMcpToolName(safeId: string): string | null {
+  const parsed = parseSafeId(safeId);
+  if (!parsed) return null;
+  if (!NATIVE_SERVER_IDS.has(parsed.serverId)) return null;
+  return parsed.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;
+}