@wong2kim/wmux 1.0.0

package/src/renderer/i18n/locales/zh.ts

@@ -0,0 +1,155 @@
+export const zh = {
+  // Sidebar
+  'sidebar.workspaces': '工作区',
+  'sidebar.newWorkspace': '新建工作区',
+  'sidebar.newWorkspaceTooltip': '新建工作区 (Ctrl+N)',
+  'sidebar.hideTooltip': '隐藏侧边栏 (Ctrl+B)',
+  'sidebar.expandTooltip': '展开侧边栏 (Ctrl+B)',
+  'sidebar.unreadCount': '{count} 条未读',
+
+  // Workspace
+  'workspace.agentRunning': '智能体运行中',
+  'workspace.agentComplete': '智能体已完成',
+  'workspace.agentError': '智能体错误',
+  'workspace.agentWaiting': '智能体等待中',
+  'workspace.agentIdle': '智能体空闲',
+  'workspace.close': '关闭工作区',
+
+  // Pane
+  'pane.empty': '空面板',
+  'pane.splitRight': '向右分割',
+  'pane.splitDown': '向下分割',
+
+  // Surface
+  'surface.terminal': '终端',
+  'surface.closeTab': '关闭标签',
+
+  // Search
+  'search.placeholder': '搜索...',
+  'search.prevTooltip': '上一个结果 (Shift+Enter)',
+  'search.nextTooltip': '下一个结果 (Enter)',
+  'search.closeTooltip': '关闭 (ESC)',
+
+  // Notification
+  'notification.title': '通知',
+  'notification.markAllRead': '全部已读',
+  'notification.clear': '清除',
+  'notification.empty': '暂无通知',
+  'notification.toggle': 'Ctrl+I 切换',
+
+  // Command palette
+  'palette.placeholder': '输入命令...',
+  'palette.noResults': '未找到结果:',
+  'palette.navigate': '导航',
+  'palette.select': '选择',
+  'palette.close': '关闭',
+  'palette.cmd.toggleSidebar': '切换侧边栏',
+  'palette.cmd.newWorkspace': '新建工作区',
+  'palette.cmd.newSurface': '新建界面',
+  'palette.cmd.splitRight': '向右分割',
+  'palette.cmd.splitDown': '向下分割',
+  'palette.cmd.showNotifications': '显示通知',
+  'palette.cmd.openSettings': '打开设置',
+  'palette.cmd.openBrowser': '打开浏览器',
+  'palette.catWorkspace': '工作区',
+  'palette.catSurface': '界面',
+  'palette.catCommand': '命令',
+
+  // Terminal
+  'terminal.exited': '进程已退出，代码 {code}',
+  'terminal.exitedBracket': '[进程已退出，代码 {code}]',
+  'terminal.copied': '已复制!',
+
+  // Browser
+  'browser.urlPlaceholder': '输入URL...',
+  'browser.back': '后退',
+  'browser.forward': '前进',
+  'browser.reload': '刷新',
+  'browser.close': '关闭',
+  'browser.devToolsTooltip': '打开开发者工具 (F12)',
+  'browser.title': '浏览器',
+
+  // VI copy mode
+  'viCopy.mode': '-- 复制模式 --',
+  'viCopy.visual': '-- 可视 --',
+
+  // StatusBar
+  'statusBar.company': '公司',
+  'statusBar.session': '会话: {min}分钟',
+  'statusBar.settingsTooltip': '设置 (Ctrl+,)',
+
+  // Settings
+  'settings.title': '设置',
+  'settings.language': '语言',
+  'settings.sound': '通知声音',
+  'settings.soundOn': '开启',
+  'settings.soundOff': '关闭',
+  'settings.checkUpdate': '检查更新',
+  'settings.checking': '检查中...',
+  'settings.upToDate': '已是最新版本',
+  'settings.updateAvailable': '有可用更新',
+  'settings.close': '关闭',
+  'settings.shortcuts': '键盘快捷键',
+  'settings.tabGeneral': '常规',
+  'settings.tabAppearance': '外观',
+  'settings.tabNotifications': '通知',
+  'settings.tabShortcuts': '快捷键',
+  'settings.tabAbout': '关于',
+  'settings.terminal': '终端',
+  'settings.defaultShell': '默认 Shell',
+  'settings.scrollbackLines': '回滚行数',
+  'settings.scrollbackDesc': '终端缓冲区保留行数',
+  'settings.updates': '更新',
+  'settings.wmuxUpdates': 'wmux 更新',
+  'settings.updateFailed': '检查更新失败',
+  'settings.lastCheckedNever': '上次检查：从未',
+  'settings.installUpdate': '安装更新',
+  'settings.retryCheck': '重新检查',
+  'settings.fontSize': '字体大小',
+  'settings.fontSizeRange': '范围 12~24',
+  'settings.fontFamily': '字体族',
+  'settings.fontFamilyDesc': '终端等宽字体',
+  'settings.layout': '布局',
+  'settings.sidebarPosition': '侧边栏位置',
+  'settings.sidebarPositionDesc': '终端区域的左侧或右侧',
+  'settings.sidebarLeft': '左',
+  'settings.sidebarRight': '右',
+  'settings.updateReady': '更新已准备就绪',
+  'settings.checkFailed': '检查失败',
+  'settings.unknownError': '未知错误',
+  'settings.notificationBehavior': '通知行为',
+  'settings.soundDesc': 'Web Audio API — 无需外部文件',
+  'settings.toast': '弹出通知',
+  'settings.toastDesc': '代理完成时显示弹出通知',
+  'settings.ring': '光环动画',
+  'settings.ringDesc': '未读通知窗格的脉冲边框',
+  'settings.sc.toggleSidebar': '切换侧边栏',
+  'settings.sc.splitHorizontal': '水平分割面板',
+  'settings.sc.splitVertical': '垂直分割面板',
+  'settings.sc.newWorkspace': '新建工作区',
+  'settings.sc.closePane': '关闭面板/工作区',
+  'settings.sc.searchTerminal': '在终端中搜索',
+  'settings.sc.commandPalette': '命令面板',
+  'settings.sc.toggleNotifications': '切换通知面板',
+  'settings.sc.viCopyMode': 'Vi 复制模式',
+  'settings.sc.renameWorkspace': '重命名工作区',
+  'settings.sc.highlightPane': '高亮活动面板',
+  'settings.shortcutsNotAvailable': '快捷键自定义暂不可用。',
+  'settings.aboutTagline': 'Windows 原生 AI 代理终端',
+  'settings.builtWith': '构建工具',
+  'settings.links': '链接',
+  'settings.githubRepo': 'GitHub 仓库',
+  'settings.toggleHint': 'Ctrl+, 切换',
+
+  // Custom keybindings
+  'settings.customKeybindings': '自定义快捷键',
+  'settings.kb.add': '添加快捷键',
+  'settings.kb.key': '按键',
+  'settings.kb.label': '名称',
+  'settings.kb.command': '命令',
+  'settings.kb.sendEnter': '发送回车',
+  'settings.kb.pressKey': '请按下按键...',
+  'settings.kb.conflict': '与内置快捷键冲突',
+  'settings.kb.delete': '删除',
+  'settings.kb.noBindings': '暂无自定义快捷键',
+} as const;

package/src/renderer/index.tsx

@@ -0,0 +1,6 @@
+import { createRoot } from 'react-dom/client';
+import App from './App';
+import './styles/globals.css';
+
+const root = createRoot(document.getElementById('root')!);
+root.render(<App />);

package/src/renderer/stores/index.ts

@@ -0,0 +1,19 @@
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+import { createWorkspaceSlice, type WorkspaceSlice } from './slices/workspaceSlice';
+import { createPaneSlice, type PaneSlice } from './slices/paneSlice';
+import { createSurfaceSlice, type SurfaceSlice } from './slices/surfaceSlice';
+import { createUISlice, type UISlice } from './slices/uiSlice';
+import { createNotificationSlice, type NotificationSlice } from './slices/notificationSlice';
+
+export type StoreState = WorkspaceSlice & PaneSlice & SurfaceSlice & UISlice & NotificationSlice;
+
+export const useStore = create<StoreState>()(
+  immer((...args) => ({
+    ...createWorkspaceSlice(...args),
+    ...createPaneSlice(...args),
+    ...createSurfaceSlice(...args),
+    ...createUISlice(...args),
+    ...createNotificationSlice(...args),
+  }))
+);

package/src/renderer/stores/slices/notificationSlice.ts

@@ -0,0 +1,56 @@
+import type { StateCreator } from 'zustand';
+import type { StoreState } from '../index';
+import type { Notification } from '../../../shared/types';
+import { generateId } from '../../../shared/types';
+
+export interface NotificationSlice {
+  notifications: Notification[];
+  addNotification: (notification: Omit<Notification, 'id' | 'timestamp' | 'read'>) => void;
+  markRead: (id: string) => void;
+  markAllReadForWorkspace: (workspaceId: string) => void;
+  clearNotifications: () => void;
+}
+
+export const createNotificationSlice: StateCreator<StoreState, [['zustand/immer', never]], [], NotificationSlice> = (set) => ({
+  notifications: [],
+
+  addNotification: (notification) => set((state: StoreState) => {
+    state.notifications.push({
+      ...notification,
+      id: generateId('notif'),
+      timestamp: Date.now(),
+      read: false,
+    });
+    // 500개 초과 시 읽은 오래된 알림 제거
+    if (state.notifications.length > 500) {
+      const readOld = state.notifications.findIndex((n) => n.read);
+      if (readOld !== -1) {
+        state.notifications.splice(readOld, 1);
+      } else {
+        // 모두 unread면 가장 오래된 것 제거
+        state.notifications.shift();
+      }
+    }
+    // Update workspace metadata lastNotification
+    const ws = state.workspaces.find((w) => w.id === notification.workspaceId);
+    if (ws) {
+      if (!ws.metadata) ws.metadata = {};
+      ws.metadata.lastNotification = Date.now();
+    }
+  }),
+
+  markRead: (id) => set((state: StoreState) => {
+    const notif = state.notifications.find((n) => n.id === id);
+    if (notif) notif.read = true;
+  }),
+
+  markAllReadForWorkspace: (workspaceId) => set((state: StoreState) => {
+    for (const n of state.notifications) {
+      if (n.workspaceId === workspaceId) n.read = true;
+    }
+  }),
+
+  clearNotifications: () => set((state: StoreState) => {
+    state.notifications = [];
+  }),
+});

package/src/renderer/stores/slices/paneSlice.ts

@@ -0,0 +1,141 @@
+import type { StateCreator } from 'zustand';
+import type { StoreState } from '../index';
+import type { Pane, PaneLeaf, PaneBranch, Workspace } from '../../../shared/types';
+import { createLeafPane, generateId } from '../../../shared/types';
+
+export interface PaneSlice {
+  splitPane: (paneId: string, direction: 'horizontal' | 'vertical') => void;
+  closePane: (paneId: string) => void;
+  setActivePane: (paneId: string) => void;
+  focusPaneDirection: (direction: 'up' | 'down' | 'left' | 'right') => void;
+}
+
+function findPane(root: Pane, id: string): Pane | null {
+  if (root.id === id) return root;
+  if (root.type === 'branch') {
+    for (const child of root.children) {
+      const found = findPane(child, id);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function findParent(root: Pane, id: string): PaneBranch | null {
+  if (root.type === 'branch') {
+    for (const child of root.children) {
+      if (child.id === id) return root;
+      const found = findParent(child, id);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function collectLeafIds(pane: Pane): string[] {
+  if (pane.type === 'leaf') return [pane.id];
+  return pane.children.flatMap(collectLeafIds);
+}
+
+function getLeafPanes(root: Pane): PaneLeaf[] {
+  if (root.type === 'leaf') return [root];
+  return root.children.flatMap(getLeafPanes);
+}
+
+export const createPaneSlice: StateCreator<StoreState, [['zustand/immer', never]], [], PaneSlice> = (set, get) => ({
+  splitPane: (paneId, direction) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+
+    const targetPane = findPane(ws.rootPane, paneId);
+    if (!targetPane || targetPane.type !== 'leaf') return;
+
+    const newPane = createLeafPane();
+    const branch: PaneBranch = {
+      id: generateId('pane'),
+      type: 'branch',
+      direction,
+      children: [{ ...targetPane }, newPane],
+      sizes: [50, 50],
+    };
+
+    // Replace target with branch
+    const parent = findParent(ws.rootPane, paneId);
+    if (parent) {
+      const idx = parent.children.findIndex((c) => c.id === paneId);
+      if (idx !== -1) {
+        parent.children[idx] = branch;
+      }
+    } else {
+      // Target is the root
+      ws.rootPane = branch;
+    }
+
+    ws.activePaneId = newPane.id;
+  }),
+
+  closePane: (paneId) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+
+    const parent = findParent(ws.rootPane, paneId);
+    if (!parent) {
+      // Can't close root pane, but can clear its surfaces
+      return;
+    }
+
+    const idx = parent.children.findIndex((c) => c.id === paneId);
+    if (idx === -1) return;
+
+    parent.children.splice(idx, 1);
+
+    if (parent.children.length === 1) {
+      // Collapse: replace parent with the remaining child
+      const remaining = parent.children[0];
+      const grandParent = findParent(ws.rootPane, parent.id);
+      if (grandParent) {
+        const parentIdx = grandParent.children.findIndex((c) => c.id === parent.id);
+        if (parentIdx !== -1) {
+          grandParent.children[parentIdx] = remaining;
+        }
+      } else {
+        // Parent was root
+        ws.rootPane = remaining;
+      }
+    }
+
+    // Update active pane
+    const leaves = getLeafPanes(ws.rootPane);
+    if (leaves.length > 0 && !leaves.some((l) => l.id === ws.activePaneId)) {
+      ws.activePaneId = leaves[0].id;
+    }
+  }),
+
+  setActivePane: (paneId) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+    if (findPane(ws.rootPane, paneId)) {
+      ws.activePaneId = paneId;
+    }
+  }),
+
+  focusPaneDirection: (_direction) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+
+    const leaves = getLeafPanes(ws.rootPane);
+    if (leaves.length <= 1) return;
+
+    const currentIdx = leaves.findIndex((l) => l.id === ws.activePaneId);
+    if (currentIdx === -1) return;
+
+    // Simple round-robin navigation for now
+    let nextIdx: number;
+    if (_direction === 'right' || _direction === 'down') {
+      nextIdx = (currentIdx + 1) % leaves.length;
+    } else {
+      nextIdx = (currentIdx - 1 + leaves.length) % leaves.length;
+    }
+    ws.activePaneId = leaves[nextIdx].id;
+  }),
+});

package/src/renderer/stores/slices/surfaceSlice.ts

@@ -0,0 +1,122 @@
+import type { StateCreator } from 'zustand';
+import type { StoreState } from '../index';
+import type { Pane, PaneLeaf, Surface, Workspace } from '../../../shared/types';
+import { createSurface, generateId } from '../../../shared/types';
+
+export interface SurfaceSlice {
+  addSurface: (paneId: string, ptyId: string, shell: string, cwd: string) => void;
+  addBrowserSurface: (paneId: string, url?: string) => void;
+  closeSurface: (paneId: string, surfaceId: string) => void;
+  setActiveSurface: (paneId: string, surfaceId: string) => void;
+  nextSurface: (paneId: string) => void;
+  prevSurface: (paneId: string) => void;
+  updateSurfacePtyId: (paneId: string, surfaceId: string, ptyId: string) => void;
+  updateSurfaceTitle: (surfaceId: string, title: string) => void;
+}
+
+function findLeafPane(root: Pane, id: string): PaneLeaf | null {
+  if (root.id === id && root.type === 'leaf') return root;
+  if (root.type === 'branch') {
+    for (const child of root.children) {
+      const found = findLeafPane(child, id);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+export const createSurfaceSlice: StateCreator<StoreState, [['zustand/immer', never]], [], SurfaceSlice> = (set) => ({
+  addSurface: (paneId, ptyId, shell, cwd) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+    const pane = findLeafPane(ws.rootPane, paneId);
+    if (!pane) return;
+    const surface = createSurface(ptyId, shell, cwd);
+    pane.surfaces.push(surface);
+    pane.activeSurfaceId = surface.id;
+  }),
+
+  addBrowserSurface: (paneId, url) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+    const pane = findLeafPane(ws.rootPane, paneId);
+    if (!pane) return;
+    const surface: Surface = {
+      id: generateId('surface'),
+      ptyId: '',
+      title: 'Browser',
+      shell: '',
+      cwd: '',
+      surfaceType: 'browser',
+      browserUrl: url || 'https://google.com',
+    };
+    pane.surfaces.push(surface);
+    pane.activeSurfaceId = surface.id;
+  }),
+
+  closeSurface: (paneId, surfaceId) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+    const pane = findLeafPane(ws.rootPane, paneId);
+    if (!pane) return;
+
+    const idx = pane.surfaces.findIndex((s) => s.id === surfaceId);
+    if (idx === -1) return;
+
+    pane.surfaces.splice(idx, 1);
+    if (pane.activeSurfaceId === surfaceId) {
+      pane.activeSurfaceId = pane.surfaces[Math.min(idx, pane.surfaces.length - 1)]?.id || '';
+    }
+  }),
+
+  setActiveSurface: (paneId, surfaceId) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+    const pane = findLeafPane(ws.rootPane, paneId);
+    if (!pane) return;
+    if (pane.surfaces.some((s) => s.id === surfaceId)) {
+      pane.activeSurfaceId = surfaceId;
+    }
+  }),
+
+  nextSurface: (paneId) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+    const pane = findLeafPane(ws.rootPane, paneId);
+    if (!pane || pane.surfaces.length <= 1) return;
+    const idx = pane.surfaces.findIndex((s) => s.id === pane.activeSurfaceId);
+    pane.activeSurfaceId = pane.surfaces[(idx + 1) % pane.surfaces.length].id;
+  }),
+
+  prevSurface: (paneId) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+    const pane = findLeafPane(ws.rootPane, paneId);
+    if (!pane || pane.surfaces.length <= 1) return;
+    const idx = pane.surfaces.findIndex((s) => s.id === pane.activeSurfaceId);
+    pane.activeSurfaceId = pane.surfaces[(idx - 1 + pane.surfaces.length) % pane.surfaces.length].id;
+  }),
+
+  updateSurfacePtyId: (paneId, surfaceId, ptyId) => set((state: StoreState) => {
+    const ws = state.workspaces.find((w: Workspace) => w.id === state.activeWorkspaceId);
+    if (!ws) return;
+    const pane = findLeafPane(ws.rootPane, paneId);
+    if (!pane) return;
+    const surface = pane.surfaces.find((s) => s.id === surfaceId);
+    if (surface) surface.ptyId = ptyId;
+  }),
+
+  updateSurfaceTitle: (surfaceId, title) => set((state: StoreState) => {
+    for (const ws of state.workspaces) {
+      const updateInPane = (pane: Pane): boolean => {
+        if (pane.type === 'leaf') {
+          const surface = pane.surfaces.find((s) => s.id === surfaceId);
+          if (surface) { surface.title = title; return true; }
+          return false;
+        }
+        return pane.children.some(updateInPane);
+      };
+      if (updateInPane(ws.rootPane)) return;
+    }
+  }),
+});