状态管理

// DeepImmutable: 递归不可变类型包装
type DeepImmutable<T> =
  T extends Map<infer K, infer V>
    ? ReadonlyMap<DeepImmutable<K>, DeepImmutable<V>>
  : T extends Set<infer S>
    ? ReadonlySet<DeepImmutable<S>>
  : T extends Array<infer E>
    ? ReadonlyArray<DeepImmutable<E>>
  : T extends object
    ? { readonly [K in keyof T]: DeepImmutable<T[K]> }
  : T;

// createStore: 极简 Store 原语
interface Store<T> {
  get(): DeepImmutable<T>;
  set(updater: T | ((prev: T) => T)): void;
  subscribe(listener: (state: DeepImmutable<T>) => void): () => void;
}

function createStore<T>(initialState: T): Store<T> {
  let state = initialState;
  const listeners = new Set<
    (state: DeepImmutable<T>) => void
  >();

  return {
    get() {
      return state as DeepImmutable<T>;
    },
    set(updater) {
      const next = typeof updater === "function"
        ? (updater as (prev: T) => T)(state)
        : updater;
      if (next !== state) {
        state = next;
        const immutable = state as DeepImmutable<T>;
        for (const listener of listeners) {
          listener(immutable);
        }
      }
    },
    subscribe(listener) {
      listeners.add(listener);
      return () => listeners.delete(listener);
    }
  };
}

// AppStateStore.ts: 全局状态存储
const appStateStore = createStore<AppState>(
  initialAppState
);

// 导出便捷函数
function getAppState(): DeepImmutable<AppState> {
  return appStateStore.get();
}

function setAppState(
  updater: (prev: AppState) => AppState
): void {
  appStateStore.set(updater);
}

// AppState: 300+ 字段的全局状态类型（精简展示）
interface AppState {
  // === Core 核心 ===
  conversationId: string;
  messages: Message[];
  model: ModelName;
  currentTool: string | null;
  isLoading: boolean;
  error: string | null;
  apiKey: string;
  tokenUsage: TokenUsage;

  // === Permissions 权限 ===
  grantedPermissions: Map<string, Permission>;
  deniedPermissions: Set<string>;
  permissionMode: "default" | "auto" | "manual";
  autoApprovePatterns: string[];

  // === MCP ===
  mcpClients: Map<string, McpClient>;
  mcpTools: ToolDefinition[];
  mcpResources: Resource[];
  mcpConnectionStatus: Map<string, ConnectionStatus>;

  // === Tasks 任务 ===
  taskList: Task[];
  activeTask: Task | null;

  // === Agents 代理 ===
  activeAgents: Agent[];
  coordinatorState: CoordinatorState | null;
  swarmBackend: "iterm" | "tmux" | "in-process";

  // === Speculation 推测执行 ===
  speculationState: SpeculationState;

  // === Remote 远程 ===
  remoteSession: RemoteSession | null;
  bridgeStatus: BridgeStatus;
  jwtToken: string | null;

  // ... 更多字段 (Kairos, ComputerUse, Plugins 等)
}

// SpeculationState: 推测执行的精确状态
type SpeculationState =
  | { status: "idle" }
  | {
      status: "active";
      abort: () => void;
      startTime: number;
      messagesRef: { current: Message[] };
      writtenPathsRef: { current: Set<string> };
      boundary: SpeculationBoundary;
    };

// onChangeAppState.ts: 状态变更副作用
function registerStateEffects(
  store: Store<AppState>
): void {
  let prevState = store.get();

  store.subscribe((nextState) => {
    // model 变更 -> 重算 token 限制
    if (nextState.model !== prevState.model) {
      const limits = getModelLimits(nextState.model);
      store.set(prev => ({
        ...prev,
        tokenUsage: {
          ...prev.tokenUsage,
          maxTokens: limits.maxOutputTokens,
          contextWindow: limits.contextWindow
        }
      }));
    }

    // permissions 变更 -> 清除权限缓存
    if (
      nextState.grantedPermissions
        !== prevState.grantedPermissions
    ) {
      clearPermissionCache();
      rebuildToolPermissions(
        nextState.grantedPermissions
      );
    }

    // mcpClients 变更 -> 重新注册工具
    if (
      nextState.mcpClients !== prevState.mcpClients
    ) {
      const newTools = collectMcpTools(
        nextState.mcpClients
      );
      store.set(prev => ({
        ...prev,
        mcpTools: newTools
      }));
    }

    // speculationState 变更 -> 执行控制
    if (
      nextState.speculationState
        !== prevState.speculationState
    ) {
      if (nextState.speculationState.status === "active") {
        console.log(
          "推测执行启动 at "
          + nextState.speculationState.startTime
        );
      }
    }

    prevState = nextState;
  });
}

// selectors.ts: 派生状态
function selectAvailableTools(
  state: DeepImmutable<AppState>
): ToolDefinition[] {
  const builtinTools = getBuiltinTools();
  const mcpTools = state.mcpTools;
  const pluginTools = state.installedPlugins
    .flatMap(p => p.tools || []);

  return [...builtinTools, ...mcpTools, ...pluginTools]
    .filter(
      t => isToolPermitted(t, state.grantedPermissions)
    );
}

// bootstrap/state.ts: 全局单例（非 React）
let globalState: AppState | null = null;

function getGlobalState(): AppState {
  if (!globalState) {
    throw new Error("State not initialized");
  }
  return globalState;
}

function initGlobalState(state: AppState): void {
  globalState = state;
}