@wong2kim/wmux 1.0.0 → 1.0.1

package/src/preload/preload.ts

@@ -1,108 +0,0 @@
-import { contextBridge, ipcRenderer } from 'electron';
-import { IPC } from '../shared/constants';
-
-const electronAPI = {
-  pty: {
-    create: (options?: { shell?: string; cwd?: string; cols?: number; rows?: number }) =>
-      ipcRenderer.invoke(IPC.PTY_CREATE, options),
-    write: (id: string, data: string) =>
-      ipcRenderer.invoke(IPC.PTY_WRITE, id, data),
-    resize: (id: string, cols: number, rows: number) =>
-      ipcRenderer.invoke(IPC.PTY_RESIZE, id, cols, rows),
-    dispose: (id: string) =>
-      ipcRenderer.invoke(IPC.PTY_DISPOSE, id),
-    onData: (callback: (id: string, data: string) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, id: string, data: string) => callback(id, data);
-      ipcRenderer.on(IPC.PTY_DATA, listener);
-      return () => { ipcRenderer.removeListener(IPC.PTY_DATA, listener); };
-    },
-    onExit: (callback: (id: string, exitCode: number) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, id: string, exitCode: number) => callback(id, exitCode);
-      ipcRenderer.on(IPC.PTY_EXIT, listener);
-      return () => { ipcRenderer.removeListener(IPC.PTY_EXIT, listener); };
-    },
-  },
-  shell: {
-    list: () => ipcRenderer.invoke(IPC.SHELL_LIST) as Promise<{ name: string; path: string; args?: string[] }[]>,
-  },
-  session: {
-    save: (data: unknown) => ipcRenderer.invoke(IPC.SESSION_SAVE, data),
-    load: () => ipcRenderer.invoke(IPC.SESSION_LOAD),
-  },
-  settings: {
-    setToastEnabled: (enabled: boolean) => ipcRenderer.send(IPC.TOAST_ENABLED, enabled),
-  },
-  notification: {
-    onNew: (callback: (ptyId: string, data: { type: string; title: string; body: string }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, ptyId: string, data: { type: string; title: string; body: string }) =>
-        callback(ptyId, data);
-      ipcRenderer.on(IPC.NOTIFICATION, listener);
-      return () => { ipcRenderer.removeListener(IPC.NOTIFICATION, listener); };
-    },
-    onCwdChanged: (callback: (ptyId: string, cwd: string) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, ptyId: string, cwd: string) =>
-        callback(ptyId, cwd);
-      ipcRenderer.on(IPC.CWD_CHANGED, listener);
-      return () => { ipcRenderer.removeListener(IPC.CWD_CHANGED, listener); };
-    },
-  },
-  metadata: {
-    request: (ptyId: string) =>
-      ipcRenderer.invoke(IPC.METADATA_REQUEST, ptyId),
-    onUpdate: (callback: (ptyId: string, data: { gitBranch?: string; cwd?: string; listeningPorts?: number[] }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, ptyId: string, data: { gitBranch?: string; cwd?: string; listeningPorts?: number[] }) =>
-        callback(ptyId, data);
-      ipcRenderer.on(IPC.METADATA_UPDATE, listener);
-      return () => { ipcRenderer.removeListener(IPC.METADATA_UPDATE, listener); };
-    },
-  },
-  rpc: {
-    onCommand: (
-      callback: (requestId: string, method: string, params: Record<string, unknown>) => void,
-    ) => {
-      const listener = (
-        _event: Electron.IpcRendererEvent,
-        requestId: string,
-        method: string,
-        params: Record<string, unknown>,
-      ) => callback(requestId, method, params);
-      ipcRenderer.on(IPC.RPC_COMMAND, listener);
-      return () => { ipcRenderer.removeListener(IPC.RPC_COMMAND, listener); };
-    },
-    respond: (requestId: string, result: unknown) =>
-      ipcRenderer.send(`${IPC.RPC_RESPONSE}:${requestId}`, result),
-  },
-  updater: {
-    checkForUpdates: () =>
-      ipcRenderer.invoke(IPC.UPDATE_CHECK) as Promise<{ status: string }>,
-    installUpdate: () =>
-      ipcRenderer.invoke(IPC.UPDATE_INSTALL),
-    onUpdateAvailable: (callback: (data: { status: string; releaseName?: string }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, data: { status: string; releaseName?: string }) =>
-        callback(data);
-      ipcRenderer.on(IPC.UPDATE_AVAILABLE, listener);
-      return () => { ipcRenderer.removeListener(IPC.UPDATE_AVAILABLE, listener); };
-    },
-    onUpdateNotAvailable: (callback: (data: { status: string }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, data: { status: string }) =>
-        callback(data);
-      ipcRenderer.on(IPC.UPDATE_NOT_AVAILABLE, listener);
-      return () => { ipcRenderer.removeListener(IPC.UPDATE_NOT_AVAILABLE, listener); };
-    },
-    onUpdateError: (callback: (data: { status: string; message: string }) => void) => {
-      const listener = (_event: Electron.IpcRendererEvent, data: { status: string; message: string }) =>
-        callback(data);
-      ipcRenderer.on(IPC.UPDATE_ERROR, listener);
-      return () => { ipcRenderer.removeListener(IPC.UPDATE_ERROR, listener); };
-    },
-  },
-};
-
-contextBridge.exposeInMainWorld('electronAPI', electronAPI);
-
-contextBridge.exposeInMainWorld('clipboardAPI', {
-  writeText: (text: string) => ipcRenderer.invoke(IPC.CLIPBOARD_WRITE, text),
-  readText: () => ipcRenderer.invoke(IPC.CLIPBOARD_READ) as Promise<string>,
-});
-
-export type ElectronAPI = typeof electronAPI;

package/src/renderer/App.tsx

@@ -1,5 +0,0 @@
-import AppLayout from './components/Layout/AppLayout';
-
-export default function App() {
-  return <AppLayout />;
-}

package/src/renderer/components/Browser/BrowserPanel.tsx

@@ -1,219 +0,0 @@
-import { useRef, useState, useEffect, useCallback } from 'react';
-import BrowserToolbar from './BrowserToolbar';
-import { useT } from '../../hooks/useT';
-
-// ---------------------------------------------------------------------------
-// Declare the webview element for TypeScript
-// ---------------------------------------------------------------------------
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace JSX {
-    interface IntrinsicElements {
-      webview: React.DetailedHTMLProps<
-        React.HTMLAttributes<Electron.WebviewTag> & {
-          src?: string;
-          partition?: string;
-          allowpopups?: string;
-          disablewebsecurity?: string;
-          preload?: string;
-          useragent?: string;
-          nodeintegration?: string;
-          webpreferences?: string;
-        },
-        Electron.WebviewTag
-      >;
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Props
-// ---------------------------------------------------------------------------
-
-interface BrowserPanelProps {
-  surfaceId: string;
-  initialUrl: string;
-  isActive: boolean;
-  onClose: () => void;
-}
-
-// ---------------------------------------------------------------------------
-// Component
-// ---------------------------------------------------------------------------
-
-export default function BrowserPanel({ surfaceId, initialUrl, isActive, onClose }: BrowserPanelProps) {
-  const t = useT();
-  const webviewRef = useRef<Electron.WebviewTag>(null);
-  const [currentUrl, setCurrentUrl] = useState(initialUrl);
-  const [isLoading, setIsLoading] = useState(false);
-  const [canGoBack, setCanGoBack] = useState(false);
-  const [canGoForward, setCanGoForward] = useState(false);
-  const [pageTitle, setPageTitle] = useState(() => t('browser.title'));
-  const [isReady, setIsReady] = useState(false);
-
-  // Update nav state from webview
-  const updateNavState = useCallback(() => {
-    const wv = webviewRef.current;
-    if (!wv) return;
-    try {
-      setCanGoBack(wv.canGoBack());
-      setCanGoForward(wv.canGoForward());
-    } catch {
-      // Webview may not be ready yet
-    }
-  }, []);
-
-  // Attach webview event listeners once ready
-  useEffect(() => {
-    const wv = webviewRef.current;
-    if (!wv) return;
-
-    const onDomReady = () => {
-      setIsReady(true);
-      updateNavState();
-    };
-
-    const onStartLoading = () => {
-      setIsLoading(true);
-    };
-
-    const onStopLoading = () => {
-      setIsLoading(false);
-      updateNavState();
-    };
-
-    const onDidNavigate = (e: Electron.DidNavigateEvent) => {
-      setCurrentUrl(e.url);
-      updateNavState();
-    };
-
-    const onDidNavigateInPage = (e: Electron.DidNavigateInPageEvent) => {
-      setCurrentUrl(e.url);
-      updateNavState();
-    };
-
-    const onTitleUpdated = (e: Electron.PageTitleUpdatedEvent) => {
-      setPageTitle(e.title || t('browser.title'));
-    };
-
-    wv.addEventListener('dom-ready', onDomReady);
-    wv.addEventListener('did-start-loading', onStartLoading);
-    wv.addEventListener('did-stop-loading', onStopLoading);
-    wv.addEventListener('did-navigate', onDidNavigate as EventListener);
-    wv.addEventListener('did-navigate-in-page', onDidNavigateInPage as EventListener);
-    wv.addEventListener('page-title-updated', onTitleUpdated as EventListener);
-
-    return () => {
-      wv.removeEventListener('dom-ready', onDomReady);
-      wv.removeEventListener('did-start-loading', onStartLoading);
-      wv.removeEventListener('did-stop-loading', onStopLoading);
-      wv.removeEventListener('did-navigate', onDidNavigate as EventListener);
-      wv.removeEventListener('did-navigate-in-page', onDidNavigateInPage as EventListener);
-      wv.removeEventListener('page-title-updated', onTitleUpdated as EventListener);
-    };
-  }, [updateNavState]);
-
-  // F12 opens DevTools for the webview
-  useEffect(() => {
-    if (!isActive) return;
-    const handler = (e: KeyboardEvent) => {
-      if (e.key === 'F12') {
-        e.preventDefault();
-        handleOpenDevTools();
-      }
-    };
-    window.addEventListener('keydown', handler);
-    return () => window.removeEventListener('keydown', handler);
-  }, [isActive]);
-
-  const handleNavigate = useCallback((url: string) => {
-    const wv = webviewRef.current;
-    if (!wv) return;
-    if (isReady) {
-      wv.loadURL(url);
-    } else {
-      // If not ready yet, just update src attribute
-      wv.setAttribute('src', url);
-    }
-    setCurrentUrl(url);
-  }, [isReady]);
-
-  const handleBack = useCallback(() => {
-    webviewRef.current?.goBack();
-  }, []);
-
-  const handleForward = useCallback(() => {
-    webviewRef.current?.goForward();
-  }, []);
-
-  const handleRefresh = useCallback(() => {
-    webviewRef.current?.reload();
-  }, []);
-
-  const handleOpenDevTools = useCallback(() => {
-    try {
-      webviewRef.current?.openDevTools();
-    } catch {
-      // May not be available in all contexts
-    }
-  }, []);
-
-  return (
-    <div
-      className="flex flex-col h-full w-full overflow-hidden"
-      style={{
-        position: 'absolute',
-        inset: 0,
-        display: isActive ? 'flex' : 'none',
-      }}
-    >
-      {/* Title bar strip showing page title */}
-      <div
-        className="flex items-center gap-2 px-3 py-0.5 shrink-0"
-        style={{ backgroundColor: '#11111b', borderBottom: '1px solid var(--bg-base)' }}
-      >
-        {isLoading && (
-          <span className="w-1.5 h-1.5 rounded-full bg-[var(--accent-blue)] animate-pulse shrink-0" />
-        )}
-        <span
-          className="text-xs text-[var(--text-subtle)] truncate"
-          style={{ fontFamily: 'ui-monospace, monospace' }}
-          title={pageTitle}
-        >
-          {pageTitle}
-        </span>
-      </div>
-
-      {/* Toolbar */}
-      <BrowserToolbar
-        currentUrl={currentUrl}
-        isLoading={isLoading}
-        canGoBack={canGoBack}
-        canGoForward={canGoForward}
-        isActive={isActive}
-        onNavigate={handleNavigate}
-        onBack={handleBack}
-        onForward={handleForward}
-        onRefresh={handleRefresh}
-        onOpenDevTools={handleOpenDevTools}
-        onClose={onClose}
-      />
-
-      {/* WebView */}
-      <div className="flex-1 relative overflow-hidden" style={{ backgroundColor: 'var(--bg-base)' }}>
-        <webview
-          ref={webviewRef as React.RefObject<Electron.WebviewTag>}
-          src={initialUrl}
-          partition="persist:browser"
-          data-surface-id={surfaceId}
-          style={{
-            width: '100%',
-            height: '100%',
-            display: 'flex',
-          }}
-        />
-      </div>
-    </div>
-  );
-}

package/src/renderer/components/Browser/BrowserToolbar.tsx

@@ -1,253 +0,0 @@
-import { useRef, useState, useCallback, useEffect } from 'react';
-import { useT } from '../../hooks/useT';
-
-// ---------------------------------------------------------------------------
-// SVG Icon components
-// ---------------------------------------------------------------------------
-
-function IconBack() {
-  return (
-    <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <polyline points="9,2 4,7 9,12" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round" />
-    </svg>
-  );
-}
-
-function IconForward() {
-  return (
-    <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <polyline points="5,2 10,7 5,12" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round" />
-    </svg>
-  );
-}
-
-function IconRefresh() {
-  return (
-    <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <path d="M12 7A5 5 0 1 1 7 2" stroke="currentColor" strokeWidth="1.4" strokeLinecap="round" />
-      <polyline points="7,0.5 9.5,2.5 7,4.5" stroke="currentColor" strokeWidth="1.4" strokeLinecap="round" strokeLinejoin="round" />
-    </svg>
-  );
-}
-
-function IconDevTools() {
-  return (
-    <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <rect x="1" y="1" width="12" height="12" rx="1.5" stroke="currentColor" strokeWidth="1.2" />
-      <line x1="1" y1="4.5" x2="13" y2="4.5" stroke="currentColor" strokeWidth="1.2" />
-      <polyline points="3.5,7 5.5,9 3.5,11" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" strokeLinejoin="round" />
-      <line x1="7" y1="11" x2="10.5" y2="11" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" />
-    </svg>
-  );
-}
-
-function IconClose() {
-  return (
-    <svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <line x1="2" y1="2" x2="10" y2="10" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />
-      <line x1="10" y1="2" x2="2" y2="10" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />
-    </svg>
-  );
-}
-
-function IconLock() {
-  return (
-    <svg width="11" height="11" viewBox="0 0 11 11" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <rect x="1.5" y="4.5" width="8" height="5.5" rx="1" stroke="currentColor" strokeWidth="1.2" />
-      <path d="M3.5 4.5V3a2 2 0 0 1 4 0v1.5" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" />
-    </svg>
-  );
-}
-
-// ---------------------------------------------------------------------------
-// BrowserToolbar props
-// ---------------------------------------------------------------------------
-
-interface BrowserToolbarProps {
-  currentUrl: string;
-  isLoading: boolean;
-  canGoBack: boolean;
-  canGoForward: boolean;
-  isActive: boolean;
-  onNavigate: (url: string) => void;
-  onBack: () => void;
-  onForward: () => void;
-  onRefresh: () => void;
-  onOpenDevTools: () => void;
-  onClose: () => void;
-}
-
-// ---------------------------------------------------------------------------
-// Component
-// ---------------------------------------------------------------------------
-
-export default function BrowserToolbar({
-  currentUrl,
-  isLoading,
-  canGoBack,
-  canGoForward,
-  isActive,
-  onNavigate,
-  onBack,
-  onForward,
-  onRefresh,
-  onOpenDevTools,
-  onClose,
-}: BrowserToolbarProps) {
-  const t = useT();
-  const [inputValue, setInputValue] = useState(currentUrl);
-  const [isFocused, setIsFocused] = useState(false);
-  const inputRef = useRef<HTMLInputElement>(null);
-
-  // Sync display URL when not focused
-  useEffect(() => {
-    if (!isFocused) {
-      setInputValue(currentUrl);
-    }
-  }, [currentUrl, isFocused]);
-
-  // Ctrl+L focuses the URL bar — only register when this browser panel is active
-  useEffect(() => {
-    if (!isActive) return;
-    const handler = (e: KeyboardEvent) => {
-      if (e.ctrlKey && !e.shiftKey && !e.altKey && e.key === 'l') {
-        e.preventDefault();
-        inputRef.current?.focus();
-        inputRef.current?.select();
-      }
-    };
-    window.addEventListener('keydown', handler);
-    return () => window.removeEventListener('keydown', handler);
-  }, [isActive]);
-
-  const handleSubmit = useCallback((e: React.FormEvent) => {
-    e.preventDefault();
-    const raw = inputValue.trim();
-    if (!raw) return;
-    // Normalize: add protocol if missing
-    let url = raw;
-    if (!/^https?:\/\//i.test(url) && !/^about:/i.test(url)) {
-      // If it looks like a domain, add https://; otherwise treat as search
-      if (/^[\w-]+(\.[\w-]+)+([\/?#].*)?$/.test(url)) {
-        url = `https://${url}`;
-      } else {
-        url = `https://www.google.com/search?q=${encodeURIComponent(url)}`;
-      }
-    }
-    setInputValue(url);
-    onNavigate(url);
-    inputRef.current?.blur();
-  }, [inputValue, onNavigate]);
-
-  const isSecure = currentUrl.startsWith('https://');
-
-  const btnBase = 'flex items-center justify-center w-6 h-6 rounded transition-colors duration-100';
-  const btnEnabled = `${btnBase} text-[var(--text-sub2)] hover:text-[var(--text-main)] hover:bg-[var(--bg-surface)] cursor-pointer`;
-  const btnDisabled = `${btnBase} text-[var(--bg-overlay)] cursor-default`;
-
-  return (
-    <div
-      className="flex items-center gap-1.5 px-2 py-1.5 shrink-0"
-      style={{ backgroundColor: 'var(--bg-mantle)', borderBottom: '1px solid var(--bg-surface)' }}
-    >
-      {/* Back */}
-      <button
-        className={canGoBack ? btnEnabled : btnDisabled}
-        onClick={canGoBack ? onBack : undefined}
-        title={t('browser.back')}
-        tabIndex={-1}
-      >
-        <IconBack />
-      </button>
-
-      {/* Forward */}
-      <button
-        className={canGoForward ? btnEnabled : btnDisabled}
-        onClick={canGoForward ? onForward : undefined}
-        title={t('browser.forward')}
-        tabIndex={-1}
-      >
-        <IconForward />
-      </button>
-
-      {/* Refresh */}
-      <button
-        className={btnEnabled}
-        onClick={onRefresh}
-        title={t('browser.reload')}
-        tabIndex={-1}
-      >
-        <span className={isLoading ? 'animate-spin' : ''}>
-          <IconRefresh />
-        </span>
-      </button>
-
-      {/* URL bar */}
-      <form className="flex-1 min-w-0" onSubmit={handleSubmit}>
-        <div
-          className="flex items-center gap-1.5 px-2.5 py-1 rounded-md"
-          style={{
-            backgroundColor: isFocused ? 'var(--bg-base)' : '#11111b',
-            border: `1px solid ${isFocused ? 'var(--accent-blue)' : 'var(--bg-surface)'}`,
-            transition: 'border-color 0.15s',
-          }}
-        >
-          {/* Lock icon */}
-          <span className={isSecure ? 'text-[var(--accent-green)]' : 'text-[var(--text-muted)]'} style={{ flexShrink: 0 }}>
-            <IconLock />
-          </span>
-
-          {/* Loading indicator */}
-          {isLoading && (
-            <span className="w-1.5 h-1.5 rounded-full bg-[var(--accent-blue)] animate-pulse shrink-0" />
-          )}
-
-          <input
-            ref={inputRef}
-            type="text"
-            value={inputValue}
-            onChange={(e) => setInputValue(e.target.value)}
-            onFocus={() => {
-              setIsFocused(true);
-              inputRef.current?.select();
-            }}
-            onBlur={() => {
-              setIsFocused(false);
-              setInputValue(currentUrl);
-            }}
-            onKeyDown={(e) => {
-              if (e.key === 'Escape') {
-                setInputValue(currentUrl);
-                inputRef.current?.blur();
-              }
-            }}
-            className="flex-1 min-w-0 bg-transparent text-[var(--text-main)] text-xs outline-none"
-            style={{ fontFamily: 'ui-monospace, monospace' }}
-            spellCheck={false}
-            autoComplete="off"
-          />
-        </div>
-      </form>
-
-      {/* DevTools */}
-      <button
-        className={btnEnabled}
-        onClick={onOpenDevTools}
-        title={t('browser.devToolsTooltip')}
-        tabIndex={-1}
-      >
-        <IconDevTools />
-      </button>
-
-      {/* Close */}
-      <button
-        className={`${btnBase} text-[var(--text-sub2)] hover:text-[var(--accent-red)] hover:bg-[#3b1e1e] cursor-pointer`}
-        onClick={onClose}
-        title={t('browser.close')}
-        tabIndex={-1}
-      >
-        <IconClose />
-      </button>
-    </div>
-  );
-}

package/src/renderer/components/Company/ApprovalDialog.tsx

@@ -1,3 +0,0 @@
-export default function ApprovalDialog() {
-  return null;
-}

package/src/renderer/components/Company/CompanyView.tsx

@@ -1,7 +0,0 @@
-interface CompanyViewProps {
-  onClose: () => void;
-}
-
-export default function CompanyView({ onClose }: CompanyViewProps) {
-  return null;
-}

package/src/renderer/components/Company/MessageFeedPanel.tsx

@@ -1,3 +0,0 @@
-export default function MessageFeedPanel() {
-  return null;
-}