tmuxes 0.1.7 → 0.1.9

package/client/src/types.ts

@@ -0,0 +1,93 @@
+/** Shared types — mirror of the server's REST + WS shapes. */
+
+export interface Target {
+  id: string;
+  kind: 'local' | 'ssh' | 'wsl' | 'winlocal';
+  label: string;
+  host?: string;
+  user?: string;
+  port?: number;
+  distro?: string;
+  /** Launchable shells (winlocal target only). */
+  shells?: { id: string; label: string }[];
+}
+
+export interface SessionInfo {
+  name: string;
+  windows: number;
+  attached: boolean;
+  /** unix epoch seconds */
+  created: number;
+  /** epoch seconds from tmux / native shell */
+  lastActivity?: number;
+  /** recognized agent whose hooks are driving status */
+  agentKind?: AgentKind;
+  /** current lifecycle state from agent hooks */
+  agentState?: AgentState;
+  /** why this session is asking for attention */
+  attentionReason?: AttentionReason;
+  /** hook event that last updated the state */
+  agentEvent?: string;
+  /** monotonic-ish event token for client edge detection */
+  agentNonce?: string;
+}
+
+export type AgentKind = 'claude' | 'codex';
+export type AgentState = 'running' | 'waiting' | 'idle';
+export type AttentionReason = 'decision' | 'done' | 'error';
+export type LaunchAgent = 'claude' | 'codex';
+
+export interface WindowInfo {
+  index: number;
+  name: string;
+  panes: number;
+  active: boolean;
+}
+
+export interface FileEntry {
+  name: string;
+  type: 'dir' | 'file';
+}
+
+export interface FilePreview {
+  path: string;
+  content: string;
+  truncated: boolean;
+  binary: boolean;
+}
+
+export interface SessionDirectory {
+  cwd: string;
+  path: string;
+  entries: FileEntry[];
+}
+
+/** A file opened in the right-hand viewer. */
+export interface OpenFile {
+  targetId: string;
+  session: string;
+  path: string;
+  name: string;
+}
+
+export interface Selection {
+  targetId: string;
+  session: string;
+}
+
+export type SshState = 'hostkey' | 'authfail' | 'refused' | 'timeout';
+
+export type ServerControl =
+  | { type: 'ready'; target: string; session: string }
+  | { type: 'ssh'; state: SshState; message: string }
+  | { type: 'error'; message: string }
+  | { type: 'exit'; code: number | null }
+  | { type: 'pong' };
+
+/** UI-facing connection status for the terminal panel. */
+export type ConnStatus =
+  | { kind: 'connecting' }
+  | { kind: 'connected' }
+  | { kind: 'ssh'; message: string }
+  | { kind: 'disconnected'; message: string }
+  | { kind: 'error'; message: string };

package/client/src/util.ts

@@ -0,0 +1,65 @@
+/** Mirror of the server's session-name allowlist (no '.'/':' — tmux delimiters). */
+export const SESSION_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
+export function isValidSessionName(name: string): boolean {
+  return SESSION_NAME_RE.test(name);
+}
+
+// ---------- POSIX-ish path helpers (targets are always unix-like) ----------
+
+export function joinPath(dir: string, name: string): string {
+  return dir.endsWith('/') ? dir + name : `${dir}/${name}`;
+}
+
+export function parentPath(path: string): string {
+  const trimmed = path.replace(/\/+$/, '');
+  const idx = trimmed.lastIndexOf('/');
+  if (idx <= 0) return '/';
+  return trimmed.slice(0, idx);
+}
+
+export function basename(path: string): string {
+  const trimmed = path.replace(/\/+$/, '');
+  return trimmed.slice(trimmed.lastIndexOf('/') + 1) || '/';
+}
+
+const TEXT_EXTENSIONS = new Set([
+  'txt', 'text', 'md', 'markdown', 'rst', 'log', 'csv', 'tsv',
+  'js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'json', 'jsonc', 'map',
+  'py', 'pyi', 'rb', 'go', 'rs', 'java', 'kt', 'kts', 'scala', 'clj', 'cljs',
+  'c', 'h', 'cc', 'cpp', 'cxx', 'hpp', 'hh', 'cs', 'm', 'mm', 'swift',
+  'php', 'pl', 'pm', 'lua', 'r', 'jl', 'dart', 'ex', 'exs', 'erl', 'hrl', 'hs', 'ml', 'mli',
+  'sh', 'bash', 'zsh', 'fish', 'ps1', 'bat', 'cmd',
+  'html', 'htm', 'xml', 'svg', 'css', 'scss', 'sass', 'less', 'vue', 'svelte',
+  'sql', 'graphql', 'gql', 'proto',
+  'yaml', 'yml', 'toml', 'ini', 'cfg', 'conf', 'env', 'properties', 'lock',
+  'gitignore', 'gitattributes', 'dockerignore', 'editorconfig', 'diff', 'patch',
+]);
+
+const TEXT_FILENAMES = new Set([
+  'dockerfile', 'makefile', 'readme', 'license', 'licence', 'changelog',
+  'authors', 'notice', 'copying', 'procfile', '.gitignore', '.env',
+  '.bashrc', '.zshrc', '.profile', '.vimrc', '.editorconfig',
+]);
+
+/** Heuristic: is this filename openable as text/code in the viewer? */
+export function isTextFile(name: string): boolean {
+  const lower = name.toLowerCase();
+  if (TEXT_FILENAMES.has(lower)) return true;
+  const dot = lower.lastIndexOf('.');
+  if (dot < 0) return false; // no extension and not a known name → treat as non-text
+  return TEXT_EXTENSIONS.has(lower.slice(dot + 1));
+}
+
+/** Compact relative time, e.g. "刚刚", "5m", "3h", "2d". */
+export function ago(epochSeconds: number, nowMs: number, language: 'zh' | 'en' = 'zh'): string {
+  if (!epochSeconds) return '';
+  const sec = Math.max(0, Math.floor(nowMs / 1000 - epochSeconds));
+  if (sec < 10) return language === 'zh' ? '刚刚' : 'just now';
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h`;
+  return `${Math.floor(hr / 24)}d`;
+}

package/client/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src", "vite.config.ts"]
+}

package/client/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+const API_TARGET = 'http://127.0.0.1:7420';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': { target: API_TARGET, changeOrigin: true },
+      '/ws': { target: API_TARGET, ws: true, changeOrigin: true },
+    },
+  },
+});

package/package.json

@@ -1,61 +1,28 @@
-{
-  "name": "tmuxes",
-  "version": "0.1.7",
-  "description": "Web UI to run and supervise many CLI coding agents in tmux — local, SSH, and WSL.",
-  "keywords": [
-    "tmux",
-    "terminal",
-    "xterm",
-    "ssh",
-    "wsl",
-    "web-terminal",
-    "node-pty",
-    "cli-agents"
-  ],
-  "license": "MIT",
-  "author": "f1974939505 (https://github.com/f1974939505)",
-  "homepage": "https://github.com/f1974939505/tmuxes#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/f1974939505/tmuxes.git",
-    "directory": "server"
-  },
-  "bugs": {
-    "url": "https://github.com/f1974939505/tmuxes/issues"
-  },
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "tmuxes": "bin/tmuxes.js"
-  },
-  "engines": {
-    "node": ">=22.12.0 <23"
-  },
-  "files": [
-    "dist",
-    "public",
-    "bin",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "dev": "tsx watch src/index.ts",
-    "build": "tsc -p tsconfig.json",
-    "start": "node dist/index.js",
-    "test": "vitest run",
-    "prepack": "node ../scripts/prepack.mjs"
-  },
-  "dependencies": {
-    "express": "^5.2.1",
-    "node-pty": "1.1.0",
-    "ws": "^8.21.0"
-  },
-  "devDependencies": {
-    "@types/express": "^5.0.0",
-    "@types/node": "^22.10.0",
-    "@types/ws": "^8.5.13",
-    "tsx": "^4.19.2",
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
-  }
-}
+{
+  "name": "tmuxes",
+  "version": "0.1.9",
+  "private": false,
+  "license": "MIT",
+  "description": "Dev monorepo for tmuxes — the publishable package lives in server/ (name: tmuxes).",
+  "packageManager": "npm@10.9.7",
+  "engines": {
+    "node": ">=22.12.0 <23"
+  },
+  "workspaces": [
+    "server",
+    "client"
+  ],
+  "scripts": {
+    "dev": "concurrently -n server,client -c blue,green \"npm:dev:server\" \"npm:dev:client\"",
+    "dev:server": "npm --workspace server run dev",
+    "dev:client": "npm --workspace client run dev",
+    "build": "npm --workspace client run build && npm --workspace server run build",
+    "start": "npm --workspace server run start",
+    "test": "npm --workspace server run test",
+    "pack:check": "npm pack --workspace server --dry-run",
+    "release": "npm publish --workspace server"
+  },
+  "devDependencies": {
+    "concurrently": "^9.1.0"
+  }
+}

package/scripts/prepack.mjs

@@ -0,0 +1,35 @@
+// Runs as the `tmuxes` package's prepack (npm pack / npm publish).
+// Builds the client + server and bundles the built client into server/public
+// so the published package is self-contained.
+import { execSync } from 'node:child_process';
+import { cpSync, rmSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url))); // scripts/.. = repo root
+const log = (m) => console.log(`[prepack] ${m}`);
+
+log('building client + server…');
+rmSync(join(root, 'server', 'dist'), { recursive: true, force: true });
+execSync('npm run build', { cwd: root, stdio: 'inherit' });
+
+const clientDist = join(root, 'client', 'dist');
+if (!existsSync(clientDist)) {
+  console.error('[prepack] client/dist missing after build');
+  process.exit(1);
+}
+
+const publicDir = join(root, 'server', 'public');
+rmSync(publicDir, { recursive: true, force: true });
+cpSync(clientDist, publicDir, { recursive: true });
+log('bundled client → server/public');
+
+for (const file of ['README.md', 'LICENSE']) {
+  const src = join(root, file);
+  if (existsSync(src)) {
+    cpSync(src, join(root, 'server', file));
+    log(`copied ${file}`);
+  }
+}
+
+log('done');

package/{bin → server/bin}/tmuxes.js

@@ -1,37 +1,37 @@
 #!/usr/bin/env node
-// tmuxes — web UI to manage tmux sessions (local / SSH / WSL).
-// Parses a couple of flags, sets the env the server reads, then launches it.
-
-const args = process.argv.slice(2);
-
-if (args.includes('--help') || args.includes('-h')) {
-  console.log(`tmuxes — one browser tab to run and supervise tmux sessions (local · SSH · WSL)
-
-Usage:
-  tmuxes [options]
-
-Options:
-  --port <n>     Port to listen on   (default 7420, env TMUXES_PORT)
-  --no-open      Do not open the browser
-  -h, --help     Show this help
-
-Binds to 127.0.0.1 only (no-auth local UI). Then open http://127.0.0.1:7420
-(opens automatically unless --no-open). Requires tmux on the host you connect to.`);
-  process.exit(0);
-}
-
-function flag(name) {
-  const i = args.indexOf(name);
-  return i >= 0 ? args[i + 1] : undefined;
-}
-
-const port = flag('--port');
-if (port) process.env.TMUXES_PORT = port;
-
-// Open the browser by default (the "one-click run" experience), unless the
-// user opted out or already set TMUXES_OPEN.
-if (!args.includes('--no-open') && process.env.TMUXES_OPEN === undefined) {
-  process.env.TMUXES_OPEN = '1';
-}
-
-await import('../dist/index.js');
+// tmuxes — web UI to manage tmux sessions (local / SSH / WSL).
+// Parses a couple of flags, sets the env the server reads, then launches it.
+
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`tmuxes — one browser tab to run and supervise tmux sessions (local · SSH · WSL)
+
+Usage:
+  tmuxes [options]
+
+Options:
+  --port <n>     Port to listen on   (default 7420, env TMUXES_PORT)
+  --no-open      Do not open the browser
+  -h, --help     Show this help
+
+Binds to 127.0.0.1 only (no-auth local UI). Then open http://127.0.0.1:7420
+(opens automatically unless --no-open). Requires tmux on the host you connect to.`);
+  process.exit(0);
+}
+
+function flag(name) {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+}
+
+const port = flag('--port');
+if (port) process.env.TMUXES_PORT = port;
+
+// Open the browser by default (the "one-click run" experience), unless the
+// user opted out or already set TMUXES_OPEN.
+if (!args.includes('--no-open') && process.env.TMUXES_OPEN === undefined) {
+  process.env.TMUXES_OPEN = '1';
+}
+
+await import('../dist/index.js');

package/server/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "tmuxes",
+  "version": "0.1.9",
+  "description": "Web UI to run and supervise many CLI coding agents in tmux — local, SSH, and WSL.",
+  "keywords": [
+    "tmux",
+    "terminal",
+    "xterm",
+    "ssh",
+    "wsl",
+    "web-terminal",
+    "node-pty",
+    "cli-agents"
+  ],
+  "license": "MIT",
+  "author": "f1974939505 (https://github.com/f1974939505)",
+  "homepage": "https://github.com/f1974939505/tmuxes#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/f1974939505/tmuxes.git",
+    "directory": "server"
+  },
+  "bugs": {
+    "url": "https://github.com/f1974939505/tmuxes/issues"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "tmuxes": "bin/tmuxes.js"
+  },
+  "engines": {
+    "node": ">=22.12.0 <23"
+  },
+  "files": [
+    "dist",
+    "public",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "prepack": "node ../scripts/prepack.mjs"
+  },
+  "dependencies": {
+    "express": "^5.2.1",
+    "node-pty": "1.1.0",
+    "ws": "^8.21.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.10.0",
+    "@types/ws": "^8.5.13",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}

package/server/src/agentHooks.ts

@@ -0,0 +1,120 @@
+import {
+  agentHookCommand,
+  type AgentKind,
+  type AgentState,
+  type AttentionReason,
+} from './agentState.js';
+
+interface AugmentedCommand {
+  command: string;
+  kind?: AgentKind;
+}
+
+function isDisabled(): boolean {
+  const v = process.env.TMUXES_NO_AUTOHOOK;
+  return v === '1' || v === 'true';
+}
+
+function baseName(token: string): string {
+  return (token.split(/[\\/]/).pop() || '').toLowerCase().replace(/\.(exe|cmd|bat)$/, '');
+}
+
+export function detectAgentKind(command: string): AgentKind | undefined {
+  if (isDisabled()) return undefined;
+  const trimmed = command.trim();
+  if (!trimmed) return undefined;
+
+  const m = /^(\S+)(\s+[\s\S]*)?$/.exec(trimmed);
+  if (!m) return undefined;
+  switch (baseName(m[1])) {
+    case 'claude':
+      return 'claude';
+    case 'codex':
+      return 'codex';
+    default:
+      return undefined;
+  }
+}
+
+function hook(
+  kind: AgentKind,
+  state: AgentState,
+  reason: AttentionReason | '',
+  event: string,
+) {
+  return { type: 'command', command: agentHookCommand(kind, state, reason, event) };
+}
+
+function claudeSettings(): string {
+  return JSON.stringify({
+    hooks: {
+      UserPromptSubmit: [{ hooks: [hook('claude', 'running', '', 'UserPromptSubmit')] }],
+      PreToolUse: [{ matcher: '', hooks: [hook('claude', 'running', '', 'PreToolUse')] }],
+      PostToolUse: [{ matcher: '', hooks: [hook('claude', 'running', '', 'PostToolUse')] }],
+      PermissionRequest: [
+        { matcher: '', hooks: [hook('claude', 'waiting', 'decision', 'PermissionRequest')] },
+      ],
+      Notification: [
+        {
+          matcher: 'permission_prompt',
+          hooks: [hook('claude', 'waiting', 'decision', 'Notification.permission_prompt')],
+        },
+        {
+          matcher: 'elicitation_dialog',
+          hooks: [hook('claude', 'waiting', 'decision', 'Notification.elicitation_dialog')],
+        },
+      ],
+      Stop: [{ hooks: [hook('claude', 'idle', 'done', 'Stop')] }],
+      StopFailure: [{ hooks: [hook('claude', 'idle', 'error', 'StopFailure')] }],
+      SessionEnd: [{ hooks: [hook('claude', 'idle', 'done', 'SessionEnd')] }],
+    },
+  });
+}
+
+function tomlString(v: string): string {
+  return `"${v.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function codexHookConfig(
+  event: string,
+  cmd: string,
+  opts: { matcher?: string } = {},
+): string {
+  const matcher = opts.matcher === undefined ? '' : `matcher=${tomlString(opts.matcher)},`;
+  return `hooks.${event}=[{${matcher}hooks=[{type="command",command=${tomlString(cmd)}}]}]`;
+}
+
+function codexConfigArgs(): string {
+  const configs = [
+    codexHookConfig('UserPromptSubmit', agentHookCommand('codex', 'running', '', 'UserPromptSubmit')),
+    codexHookConfig('PreToolUse', agentHookCommand('codex', 'running', '', 'PreToolUse'), {
+      matcher: '',
+    }),
+    codexHookConfig('PostToolUse', agentHookCommand('codex', 'running', '', 'PostToolUse'), {
+      matcher: '',
+    }),
+    codexHookConfig(
+      'PermissionRequest',
+      agentHookCommand('codex', 'waiting', 'decision', 'PermissionRequest'),
+      { matcher: '' },
+    ),
+    codexHookConfig('Stop', agentHookCommand('codex', 'idle', 'done', 'Stop')),
+  ];
+  return configs.map((c) => `-c '${c}'`).join(' ');
+}
+
+export function augmentAgentCommand(command: string): AugmentedCommand {
+  const kind = detectAgentKind(command);
+  if (!kind) return { command };
+
+  const trimmed = command.trim();
+  const m = /^(\S+)(\s+[\s\S]*)?$/.exec(trimmed);
+  if (!m) return { command };
+  const prog = m[1];
+  const rest = m[2] ?? '';
+
+  if (kind === 'claude') {
+    return { kind, command: `${prog} --settings '${claudeSettings()}'${rest}` };
+  }
+  return { kind, command: `${prog} ${codexConfigArgs()}${rest}` };
+}

package/server/src/agentOutput.ts

@@ -0,0 +1,36 @@
+import type { AgentKind } from './agentState.js';
+
+interface TerminalErrorPattern {
+  event: string;
+  kinds?: AgentKind[];
+  re: RegExp;
+}
+
+const ERROR_PATTERNS: TerminalErrorPattern[] = [
+  {
+    event: 'CodexStreamDisconnected',
+    kinds: ['codex'],
+    re: /stream disconnected before completion.*error sending request for url.*\/codex\/responses/i,
+  },
+  {
+    event: 'StreamDisconnected',
+    re: /stream disconnected before completion/i,
+  },
+];
+
+function normalizeTerminalText(text: string): string {
+  return text
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function classifyAgentTerminalError(text: string, kind: AgentKind): string | undefined {
+  const normalized = normalizeTerminalText(text);
+  if (!normalized) return undefined;
+  for (const pattern of ERROR_PATTERNS) {
+    if (pattern.kinds && !pattern.kinds.includes(kind)) continue;
+    if (pattern.re.test(normalized)) return pattern.event;
+  }
+  return undefined;
+}