tmuxes 0.1.9 → 0.1.10

package/client/src/api.ts

@@ -1,130 +0,0 @@
-import type {
-  FileEntry,
-  FilePreview,
-  LaunchAgent,
-  SessionDirectory,
-  SessionInfo,
-  Target,
-  WindowInfo,
-} from './types';
-
-async function request<T>(path: string, init?: RequestInit): Promise<T> {
-  const res = await fetch(path, {
-    headers: { 'Content-Type': 'application/json' },
-    ...init,
-  });
-  if (!res.ok) {
-    let message = `${res.status} ${res.statusText}`;
-    try {
-      const body = (await res.json()) as { error?: string };
-      if (body.error) message = body.error;
-    } catch {
-      /* non-JSON error body */
-    }
-    throw new ApiError(res.status, message);
-  }
-  if (res.status === 204) return undefined as T;
-  return (await res.json()) as T;
-}
-
-export class ApiError extends Error {
-  constructor(
-    public status: number,
-    message: string,
-  ) {
-    super(message);
-    this.name = 'ApiError';
-  }
-}
-
-export const api = {
-  getTargets(): Promise<{ targets: Target[] }> {
-    return request('/api/targets');
-  },
-  getSessions(targetId: string): Promise<{ sessions: SessionInfo[] }> {
-    return request(`/api/targets/${encodeURIComponent(targetId)}/sessions`);
-  },
-  createSession(
-    targetId: string,
-    body: { name?: string; command?: string; shell?: string },
-  ): Promise<{ name: string }> {
-    return request(`/api/targets/${encodeURIComponent(targetId)}/sessions`, {
-      method: 'POST',
-      body: JSON.stringify(body),
-    });
-  },
-  renameSession(targetId: string, name: string, newName: string): Promise<{ name: string }> {
-    return request(
-      `/api/targets/${encodeURIComponent(targetId)}/sessions/${encodeURIComponent(name)}`,
-      { method: 'PATCH', body: JSON.stringify({ newName }) },
-    );
-  },
-  killSession(targetId: string, name: string): Promise<void> {
-    return request(
-      `/api/targets/${encodeURIComponent(targetId)}/sessions/${encodeURIComponent(name)}`,
-      { method: 'DELETE' },
-    );
-  },
-  launchAgent(targetId: string, name: string, agent: LaunchAgent): Promise<{ ok: true }> {
-    return request(
-      `/api/targets/${encodeURIComponent(targetId)}/sessions/${encodeURIComponent(name)}/agent`,
-      { method: 'POST', body: JSON.stringify({ agent }) },
-    );
-  },
-  getWindows(targetId: string, name: string): Promise<{ windows: WindowInfo[] }> {
-    return request(
-      `/api/targets/${encodeURIComponent(targetId)}/sessions/${encodeURIComponent(name)}/windows`,
-    );
-  },
-  getCwd(targetId: string, name: string): Promise<{ cwd: string }> {
-    return request(
-      `/api/targets/${encodeURIComponent(targetId)}/sessions/${encodeURIComponent(name)}/cwd`,
-    );
-  },
-  listFiles(targetId: string, session: string, path: string): Promise<{ path: string; entries: FileEntry[] }> {
-    return request(
-      `/api/targets/${encodeURIComponent(targetId)}/files?session=${encodeURIComponent(session)}&path=${encodeURIComponent(path)}`,
-    );
-  },
-  getSessionFiles(targetId: string, session: string, path?: string): Promise<SessionDirectory> {
-    const qs = path === undefined ? '' : `?path=${encodeURIComponent(path)}`;
-    return request(
-      `/api/targets/${encodeURIComponent(targetId)}/sessions/${encodeURIComponent(session)}/files${qs}`,
-    );
-  },
-  getFile(targetId: string, session: string, path: string): Promise<FilePreview> {
-    return request(
-      `/api/targets/${encodeURIComponent(targetId)}/file?session=${encodeURIComponent(session)}&path=${encodeURIComponent(path)}`,
-    );
-  },
-  saveFile(targetId: string, session: string, path: string, content: string): Promise<{ ok: true }> {
-    return request(`/api/targets/${encodeURIComponent(targetId)}/file`, {
-      method: 'PUT',
-      body: JSON.stringify({ session, path, content }),
-    });
-  },
-  getFolders(targetId: string): Promise<{ folders: unknown[]; assign: Record<string, unknown> }> {
-    return request(`/api/targets/${encodeURIComponent(targetId)}/folders`);
-  },
-  saveFolders(
-    targetId: string,
-    payload: { folders: unknown[]; assign: Record<string, string> },
-  ): Promise<{ ok: true }> {
-    return request(`/api/targets/${encodeURIComponent(targetId)}/folders`, {
-      method: 'PUT',
-      body: JSON.stringify(payload),
-    });
-  },
-};
-
-/** Build the WebSocket URL for an interactive attach (same-origin). */
-export function terminalSocketUrl(targetId: string, session: string, cols: number, rows: number): string {
-  const proto = location.protocol === 'https:' ? 'wss' : 'ws';
-  const params = new URLSearchParams({
-    target: targetId,
-    session,
-    cols: String(cols),
-    rows: String(rows),
-  });
-  return `${proto}://${location.host}/ws?${params.toString()}`;
-}

package/client/src/attention.tsx

@@ -1,157 +0,0 @@
-import {
-  createContext,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-  type ReactNode,
-} from 'react';
-import { useSettings } from './settings';
-import type { AttentionReason } from './types';
-
-/** Tracks sessions that need attention after an agent hook event and delivers
- *  the notification: a sidebar highlight, a short sound, and a flashing tab
- *  title while the tab is in the background. */
-interface AttentionApi {
-  /** Current badge reason for a session, if any. */
-  reasonFor: (targetId: string, session: string) => AttentionReason | undefined;
-  /** Raise attention for a session. */
-  fire: (targetId: string, session: string, reason: AttentionReason) => void;
-  /** A session became active again — drop its badge. */
-  clearAlert: (targetId: string, session: string) => void;
-  /** The user is now looking at this session — acknowledge its alert. */
-  setActive: (targetId: string | null, session: string | null) => void;
-}
-
-const AttentionContext = createContext<AttentionApi | null>(null);
-
-const keyOf = (targetId: string, session: string) => `${targetId}\u0000${session}`;
-
-let audioCtx: AudioContext | null = null;
-function playPing(): void {
-  try {
-    const Ctor = window.AudioContext ?? (window as unknown as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;
-    if (!Ctor) return;
-    audioCtx ??= new Ctor();
-    const ctx = audioCtx;
-    if (ctx.state === 'suspended') void ctx.resume();
-    const osc = ctx.createOscillator();
-    const gain = ctx.createGain();
-    osc.connect(gain);
-    gain.connect(ctx.destination);
-    osc.type = 'sine';
-    osc.frequency.value = 880;
-    const t = ctx.currentTime;
-    gain.gain.setValueAtTime(0.0001, t);
-    gain.gain.exponentialRampToValueAtTime(0.18, t + 0.01);
-    gain.gain.exponentialRampToValueAtTime(0.0001, t + 0.28);
-    osc.start(t);
-    osc.stop(t + 0.3);
-  } catch {
-    /* audio not available / blocked before a gesture — ignore */
-  }
-}
-
-export function AttentionProvider({ children }: { children: ReactNode }) {
-  const { settings } = useSettings();
-  const [alerts, setAlerts] = useState<Record<string, AttentionReason>>({});
-  const activeKey = useRef<string | null>(null);
-  // Keep the latest sound preference readable inside async callbacks.
-  const soundOn = useRef(settings.notifySound);
-  soundOn.current = settings.notifySound;
-
-  const fire = useCallback<AttentionApi['fire']>((targetId, session, reason) => {
-    if (!settings.notifyAttention) return;
-    const key = keyOf(targetId, session);
-    // The user is already watching this session in the foreground — no need.
-    if (key === activeKey.current && !document.hidden) return;
-
-    setAlerts((prev) => ({ ...prev, [key]: reason }));
-    if (soundOn.current) playPing();
-  }, [settings.notifyAttention]);
-
-  const clearAlert = useCallback<AttentionApi['clearAlert']>((targetId, session) => {
-    const key = keyOf(targetId, session);
-    setAlerts((prev) => {
-      if (!(key in prev)) return prev;
-      const next = { ...prev };
-      delete next[key];
-      return next;
-    });
-  }, []);
-
-  const setActive = useCallback<AttentionApi['setActive']>((targetId, session) => {
-    const key = targetId && session ? keyOf(targetId, session) : null;
-    activeKey.current = key;
-    if (!key) return;
-    setAlerts((prev) => {
-      if (!(key in prev)) return prev;
-      const next = { ...prev };
-      delete next[key];
-      return next;
-    });
-  }, []);
-
-  const reasonFor = useCallback<AttentionApi['reasonFor']>(
-    (targetId, session) => alerts[keyOf(targetId, session)],
-    [alerts],
-  );
-
-  // Flash the tab title while there are pending alerts and the tab is hidden.
-  useEffect(() => {
-    const count = Object.keys(alerts).length;
-    const base = 'tmuxes';
-    if (count === 0) {
-      document.title = base;
-      return;
-    }
-    let on = false;
-    const render = () => {
-      if (document.hidden) {
-        on = !on;
-        document.title = on ? `🔔 (${count}) ${base}` : base;
-      } else {
-        document.title = base;
-      }
-    };
-    render();
-    const id = window.setInterval(render, 1000);
-    const onVis = () => {
-      if (!document.hidden) {
-        // Foreground again: stop flashing; acknowledge whatever is being viewed.
-        document.title = base;
-        if (activeKey.current) {
-          const key = activeKey.current;
-          setAlerts((prev) => {
-            if (!(key in prev)) return prev;
-            const next = { ...prev };
-            delete next[key];
-            return next;
-          });
-        }
-      } else {
-        render();
-      }
-    };
-    document.addEventListener('visibilitychange', onVis);
-    return () => {
-      window.clearInterval(id);
-      document.removeEventListener('visibilitychange', onVis);
-      document.title = base;
-    };
-  }, [alerts]);
-
-  const value = useMemo<AttentionApi>(
-    () => ({ reasonFor, fire, clearAlert, setActive }),
-    [reasonFor, fire, clearAlert, setActive],
-  );
-  return <AttentionContext.Provider value={value}>{children}</AttentionContext.Provider>;
-}
-
-export function useAttention(): AttentionApi {
-  const ctx = useContext(AttentionContext);
-  if (!ctx) throw new Error('useAttention must be used within AttentionProvider');
-  return ctx;
-}

package/client/src/components/FileExplorer.tsx

@@ -1,156 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-import type { FileEntry, OpenFile, Selection } from '../types';
-import { api, ApiError } from '../api';
-import { basename, isTextFile, joinPath, parentPath } from '../util';
-import { useI18n } from '../i18n';
-
-interface Props {
-  selection: Selection | null;
-  openFile: OpenFile | null;
-  /** Native shell sessions have no tmux cwd — disables the file browser. */
-  enabled: boolean;
-  /** Pause automatic polling after SSH errors to avoid repeated failed attempts. */
-  pauseOnError: boolean;
-  onOpenFile: (file: OpenFile) => void;
-}
-
-const POLL_MS = 3000;
-
-function samePath(a: string | null, b: string | null): boolean {
-  if (!a || !b) return false;
-  const clean = (p: string) => (p === '/' ? p : p.replace(/\/+$/, ''));
-  return clean(a) === clean(b);
-}
-
-/** Bottom of the sidebar: the files/folders of the selected session's current
- *  working directory. Follows the session's cwd until you navigate away. */
-export function FileExplorer({ selection, openFile, enabled, pauseOnError, onOpenFile }: Props) {
-  const { t } = useI18n();
-  const [cwd, setCwd] = useState<string | null>(null);
-  const [manualPath, setManualPath] = useState<string | null>(null);
-  const [entries, setEntries] = useState<FileEntry[]>([]);
-  const [error, setError] = useState<string | null>(null);
-  const pollingPaused = useRef(false);
-
-  const path = manualPath ?? cwd;
-  const following = manualPath === null;
-  const targetId = selection?.targetId;
-  const session = selection?.session;
-
-  // New selection → re-follow that session's cwd.
-  useEffect(() => {
-    setManualPath(null);
-    setCwd(null);
-    setEntries([]);
-    setError(null);
-    pollingPaused.current = false;
-  }, [targetId, session]);
-
-  const tick = useCallback(async () => {
-    if (pollingPaused.current) return;
-    if (!targetId || !session) return;
-    try {
-      const { cwd: latest, entries } = await api.getSessionFiles(
-        targetId,
-        session,
-        manualPath ?? undefined,
-      );
-      setCwd(latest);
-      setEntries(entries);
-      setError(null);
-    } catch (e) {
-      setError(e instanceof ApiError ? e.message : t.cannotListDirectory);
-      if (pauseOnError) pollingPaused.current = true;
-    }
-  }, [targetId, session, manualPath, pauseOnError, t.cannotListDirectory]);
-
-  const manualReconnect = useCallback(() => {
-    pollingPaused.current = false;
-    setError(null);
-    void tick();
-  }, [tick]);
-
-  useEffect(() => {
-    if (!targetId || !session || !enabled) return;
-    void tick();
-    const id = window.setInterval(() => void tick(), POLL_MS);
-    return () => window.clearInterval(id);
-  }, [targetId, session, enabled, tick]);
-
-  if (!selection) {
-    return (
-      <div className="explorer">
-        <div className="explorer-empty">{t.selectSessionForFiles}</div>
-      </div>
-    );
-  }
-
-  if (!enabled) {
-    return (
-      <div className="explorer">
-        <div className="explorer-empty">{t.fileBrowserUnavailable}</div>
-      </div>
-    );
-  }
-
-  const navigate = (entry: FileEntry) => {
-    if (!path) return;
-    const full = joinPath(path, entry.name);
-    if (entry.type === 'dir') {
-      setManualPath(full);
-    } else if (isTextFile(entry.name)) {
-      onOpenFile({ targetId: selection.targetId, session: selection.session, path: full, name: entry.name });
-    }
-  };
-
-  const atRoot = samePath(path, cwd);
-
-  return (
-    <div className="explorer">
-      <div className="explorer-head">
-        <span className="explorer-path" title={path ?? ''}>
-          {path ? basename(path) : '…'}
-        </span>
-        <span className="explorer-actions">
-          {!following && (
-            <button title={t.backToSessionDirectory} onClick={() => setManualPath(null)}>
-              ⌂
-            </button>
-          )}
-          <button title={t.upOneLevel} disabled={!path || path === '/' || atRoot} onClick={() => path && setManualPath(parentPath(path))}>
-            ↑
-          </button>
-        </span>
-      </div>
-      {error && (
-        <div className="error-line">
-          <span>{error}</span>
-          {pauseOnError && (
-            <button onClick={manualReconnect}>
-              {t.reconnect}
-            </button>
-          )}
-        </div>
-      )}
-      <div className="explorer-list">
-        {entries.map((e) => {
-          const openable = e.type === 'dir' || isTextFile(e.name);
-          const isOpen =
-            openFile?.targetId === selection.targetId && path && openFile.path === joinPath(path, e.name);
-          return (
-            <div
-              key={e.name}
-              className={`file-row ${e.type} ${openable ? '' : 'disabled'} ${isOpen ? 'open' : ''}`}
-              onClick={() => openable && navigate(e)}
-              title={e.name}
-            >
-              <span className="file-icon">{e.type === 'dir' ? '📁' : isTextFile(e.name) ? '📄' : '▫'}</span>
-              <span className="file-name">{e.name}</span>
-            </div>
-          );
-        })}
-        {entries.length === 0 && !error && <div className="explorer-empty">{t.emptyDirectory}</div>}
-      </div>
-    </div>
-  );
-}

package/client/src/components/FileViewer.tsx

@@ -1,194 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-import type { FilePreview, OpenFile } from '../types';
-import { api, ApiError } from '../api';
-import { useSettings } from '../settings';
-import { useI18n } from '../i18n';
-
-interface Props {
-  file: OpenFile;
-  onClose: () => void;
-}
-
-/** New undo checkpoint after this idle gap, so a burst of typing collapses
- *  into a single undo step. */
-const COALESCE_MS = 500;
-
-/** Read-only preview + editor for a text file. Editable only when the file is
- *  text and was not truncated (saving a truncated preview would lose data). */
-export function FileViewer({ file, onClose }: Props) {
-  const { settings } = useSettings();
-  const { t } = useI18n();
-  const taRef = useRef<HTMLTextAreaElement>(null);
-  const lastEditRef = useRef(0);
-
-  const [preview, setPreview] = useState<FilePreview | null>(null);
-  const [loadError, setLoadError] = useState<string | null>(null);
-  const [loading, setLoading] = useState(true);
-
-  const [text, setText] = useState('');
-  const [baseline, setBaseline] = useState('');
-  const [past, setPast] = useState<string[]>([]);
-  const [future, setFuture] = useState<string[]>([]);
-  const [saving, setSaving] = useState(false);
-  const [saveError, setSaveError] = useState<string | null>(null);
-
-  const editable = !!preview && !preview.binary && !preview.truncated;
-  const dirty = editable && text !== baseline;
-
-  // Load (or reload) the file.
-  useEffect(() => {
-    let cancelled = false;
-    setLoading(true);
-    setLoadError(null);
-    setSaveError(null);
-    setPreview(null);
-    setPast([]);
-    setFuture([]);
-    lastEditRef.current = 0;
-    api
-      .getFile(file.targetId, file.session, file.path)
-      .then((p) => {
-        if (cancelled) return;
-        setPreview(p);
-        setText(p.content);
-        setBaseline(p.content);
-      })
-      .catch((e) => {
-        if (!cancelled) setLoadError(e instanceof ApiError ? e.message : t.failedReadFile);
-      })
-      .finally(() => {
-        if (!cancelled) setLoading(false);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [file.targetId, file.session, file.path, t.failedReadFile]);
-
-  const onType = (next: string) => {
-    const now = Date.now();
-    if (now - lastEditRef.current > COALESCE_MS) {
-      setPast((p) => [...p, text]); // checkpoint = value at start of this burst
-      setFuture([]);
-    }
-    lastEditRef.current = now;
-    setText(next);
-  };
-
-  // Flat functional updates (no nested setState) so the handlers are
-  // StrictMode-safe; past/future/text come from the current render.
-  const undo = () => {
-    if (past.length === 0) return;
-    const prev = past[past.length - 1];
-    setFuture((f) => [...f, text]);
-    setPast((p) => p.slice(0, -1));
-    setText(prev);
-    lastEditRef.current = 0;
-  };
-
-  const redo = () => {
-    if (future.length === 0) return;
-    const next = future[future.length - 1];
-    setPast((p) => [...p, text]);
-    setFuture((f) => f.slice(0, -1));
-    setText(next);
-    lastEditRef.current = 0;
-  };
-
-  const save = async () => {
-    if (!editable || !dirty || saving) return;
-    setSaving(true);
-    setSaveError(null);
-    try {
-      await api.saveFile(file.targetId, file.session, file.path, text);
-      setBaseline(text);
-    } catch (e) {
-      setSaveError(e instanceof ApiError ? e.message : t.saveFailed);
-    } finally {
-      setSaving(false);
-    }
-  };
-
-  const onKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
-    const mod = e.metaKey || e.ctrlKey;
-    const k = e.key.toLowerCase();
-    if (mod && k === 's') {
-      e.preventDefault();
-      void save();
-    } else if (mod && k === 'z' && !e.shiftKey) {
-      e.preventDefault();
-      undo();
-    } else if (mod && (k === 'y' || (k === 'z' && e.shiftKey))) {
-      e.preventDefault();
-      redo();
-    } else if (e.key === 'Tab') {
-      e.preventDefault();
-      const ta = taRef.current;
-      if (!ta) return;
-      const start = ta.selectionStart;
-      const end = ta.selectionEnd;
-      onType(text.slice(0, start) + '  ' + text.slice(end));
-      requestAnimationFrame(() => {
-        ta.selectionStart = ta.selectionEnd = start + 2;
-      });
-    }
-  };
-
-  const requestClose = () => {
-    if (dirty && !confirm(t.discardUnsaved)) return;
-    onClose();
-  };
-
-  return (
-    <div className="viewer">
-      <div className="viewer-head">
-        <span className="viewer-name" title={file.path}>
-          {dirty && <span className="dirty-dot" title={t.unsavedChanges}>●</span>}
-          {file.name}
-        </span>
-        <span className="viewer-path">{file.path}</span>
-        <div className="viewer-head-spacer" />
-        {editable && (
-          <>
-            <button onClick={undo} disabled={past.length === 0} title={t.undo}>
-              ↶
-            </button>
-            <button onClick={redo} disabled={future.length === 0} title={t.redo}>
-              ↷
-            </button>
-            <button className="primary" onClick={() => void save()} disabled={!dirty || saving} title={t.saveShortcut}>
-              {saving ? t.saving : t.save}
-            </button>
-          </>
-        )}
-        {preview?.truncated && <span className="viewer-note">{t.truncatedReadOnly}</span>}
-        <button onClick={requestClose} title={t.closeFile}>
-          ✕
-        </button>
-      </div>
-
-      {saveError && <div className="viewer-msg error">{saveError}</div>}
-
-      <div className="viewer-body">
-        {loading && <div className="viewer-msg">{t.loading}</div>}
-        {loadError && <div className="viewer-msg error">{loadError}</div>}
-        {preview && preview.binary && <div className="viewer-msg">{t.binaryNotShown}</div>}
-        {preview && !preview.binary && editable && (
-          <textarea
-            ref={taRef}
-            className="viewer-editor"
-            style={{ fontSize: settings.viewerFontSize }}
-            value={text}
-            spellCheck={false}
-            onChange={(e) => onType(e.target.value)}
-            onKeyDown={onKeyDown}
-          />
-        )}
-        {preview && !preview.binary && !editable && (
-          <pre className="viewer-pre" style={{ fontSize: settings.viewerFontSize }}>
-            {preview.content}
-          </pre>
-        )}
-      </div>
-    </div>
-  );
-}