tmux-team 1.0.0 → 2.0.0-alpha.1

package/src/commands/talk.ts

@@ -0,0 +1,261 @@
+// ─────────────────────────────────────────────────────────────
+// talk command - send message to agent(s)
+// ─────────────────────────────────────────────────────────────
+
+import type { Context } from '../types.js';
+import type { WaitResult } from '../types.js';
+import { ExitCodes } from '../exits.js';
+import { colors } from '../ui.js';
+import crypto from 'crypto';
+import { cleanupState, clearActiveRequest, setActiveRequest } from '../state.js';
+
+function sleepMs(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function makeRequestId(): string {
+  return `req_${Date.now().toString(36)}_${crypto.randomBytes(3).toString('hex')}`;
+}
+
+function makeNonce(): string {
+  return crypto.randomBytes(2).toString('hex');
+}
+
+function renderWaitLine(agent: string, elapsedSeconds: number): string {
+  const s = Math.max(0, Math.floor(elapsedSeconds));
+  return `⏳ Waiting for ${agent}... (${s}s)`;
+}
+
+/**
+ * Build the final message with optional preamble.
+ * Format: [SYSTEM: <preamble>]\n\n<message>
+ */
+function buildMessage(message: string, agentName: string, ctx: Context): string {
+  const { config, flags } = ctx;
+
+  // Skip preamble if disabled or --no-preamble flag
+  if (config.preambleMode === 'disabled' || flags.noPreamble) {
+    return message;
+  }
+
+  // Get agent-specific preamble
+  const agentConfig = config.agents[agentName];
+  const preamble = agentConfig?.preamble;
+
+  if (!preamble) {
+    return message;
+  }
+
+  return `[SYSTEM: ${preamble}]\n\n${message}`;
+}
+
+export async function cmdTalk(ctx: Context, target: string, message: string): Promise<void> {
+  const { ui, config, tmux, flags, exit } = ctx;
+  const waitEnabled = Boolean(flags.wait) || config.mode === 'wait';
+
+  if (waitEnabled && target === 'all') {
+    ui.error("Wait mode is not supported with 'all' yet. Send to one agent at a time.");
+    exit(ExitCodes.ERROR);
+  }
+
+  if (target === 'all') {
+    const agents = Object.entries(config.paneRegistry);
+    if (agents.length === 0) {
+      ui.error("No agents configured. Use 'tmux-team add' first.");
+      exit(ExitCodes.CONFIG_MISSING);
+    }
+
+    if (flags.delay && flags.delay > 0) {
+      await sleepMs(flags.delay * 1000);
+    }
+
+    const results: { agent: string; pane: string; status: string }[] = [];
+
+    for (const [name, data] of agents) {
+      try {
+        // Build message with preamble, then apply Gemini filter
+        let msg = buildMessage(message, name, ctx);
+        if (name === 'gemini') msg = msg.replace(/!/g, '');
+        tmux.send(data.pane, msg);
+        results.push({ agent: name, pane: data.pane, status: 'sent' });
+        if (!flags.json) {
+          console.log(`${colors.green('→')} Sent to ${colors.cyan(name)} (${data.pane})`);
+        }
+      } catch {
+        results.push({ agent: name, pane: data.pane, status: 'failed' });
+        if (!flags.json) {
+          ui.warn(`Failed to send to ${name}`);
+        }
+      }
+    }
+
+    if (flags.json) {
+      ui.json({ target: 'all', results });
+    }
+    return;
+  }
+
+  // Single agent
+  if (!config.paneRegistry[target]) {
+    const available = Object.keys(config.paneRegistry).join(', ');
+    ui.error(`Agent '${target}' not found. Available: ${available || 'none'}`);
+    exit(ExitCodes.PANE_NOT_FOUND);
+  }
+
+  const pane = config.paneRegistry[target].pane;
+
+  if (flags.delay && flags.delay > 0) {
+    await sleepMs(flags.delay * 1000);
+  }
+
+  if (!waitEnabled) {
+    try {
+      // Build message with preamble, then apply Gemini filter
+      let msg = buildMessage(message, target, ctx);
+      if (target === 'gemini') msg = msg.replace(/!/g, '');
+      tmux.send(pane, msg);
+
+      if (flags.json) {
+        ui.json({ target, pane, status: 'sent' });
+      } else {
+        console.log(`${colors.green('→')} Sent to ${colors.cyan(target)} (${pane})`);
+      }
+      return;
+    } catch {
+      ui.error(`Failed to send to pane ${pane}. Is tmux running?`);
+      exit(ExitCodes.ERROR);
+    }
+  }
+
+  // Wait mode
+  const timeoutSeconds = flags.timeout ?? config.defaults.timeout;
+  const pollIntervalSeconds = Math.max(0.1, config.defaults.pollInterval);
+  const captureLines = config.defaults.captureLines;
+
+  const requestId = makeRequestId();
+  const nonce = makeNonce();
+  const marker = `{tmux-team-end:${nonce}}`;
+
+  // Build message with preamble, then append nonce instruction
+  const messageWithPreamble = buildMessage(message, target, ctx);
+  const fullMessage = `${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${marker}]`;
+
+  // Best-effort cleanup and soft-lock warning
+  const state = cleanupState(ctx.paths, 60 * 60); // 1 hour TTL
+  const existing = state.requests[target];
+  if (existing && !flags.json && !flags.force) {
+    ui.warn(
+      `Another recent wait request exists for '${target}' (id: ${existing.id}). Results may interleave.`
+    );
+  }
+
+  let baseline = '';
+  try {
+    baseline = tmux.capture(pane, captureLines);
+  } catch {
+    ui.error(`Failed to capture pane ${pane}. Is tmux running?`);
+    exit(ExitCodes.ERROR);
+  }
+
+  setActiveRequest(ctx.paths, target, { id: requestId, nonce, pane, startedAtMs: Date.now() });
+
+  const startedAt = Date.now();
+  let lastNonTtyLogAt = 0;
+  const isTTY = process.stdout.isTTY && !flags.json;
+
+  const onSigint = (): void => {
+    clearActiveRequest(ctx.paths, target, requestId);
+    if (!flags.json) process.stdout.write('\n');
+    ui.error('Interrupted.');
+    exit(ExitCodes.ERROR);
+  };
+
+  process.once('SIGINT', onSigint);
+
+  try {
+    const msg = target === 'gemini' ? fullMessage.replace(/!/g, '') : fullMessage;
+    tmux.send(pane, msg);
+
+    while (true) {
+      const elapsedSeconds = (Date.now() - startedAt) / 1000;
+      if (elapsedSeconds >= timeoutSeconds) {
+        clearActiveRequest(ctx.paths, target, requestId);
+        if (flags.json) {
+          // Single JSON output with error field (don't call ui.error separately)
+          ui.json({
+            target,
+            pane,
+            status: 'timeout',
+            error: `Timed out waiting for ${target} after ${Math.floor(timeoutSeconds)}s`,
+            requestId,
+            nonce,
+            marker,
+          });
+          exit(ExitCodes.TIMEOUT);
+        }
+        if (isTTY) {
+          process.stdout.write('\r' + ' '.repeat(80) + '\r');
+        }
+        ui.error(`Timed out waiting for ${target} after ${Math.floor(timeoutSeconds)}s.`);
+        exit(ExitCodes.TIMEOUT);
+      }
+
+      if (!flags.json) {
+        if (isTTY) {
+          process.stdout.write('\r' + renderWaitLine(target, elapsedSeconds));
+        } else {
+          const now = Date.now();
+          if (now - lastNonTtyLogAt >= 5000) {
+            lastNonTtyLogAt = now;
+            console.error(
+              `[tmux-team] Waiting for ${target} (${Math.floor(elapsedSeconds)}s elapsed)`
+            );
+          }
+        }
+      }
+
+      await sleepMs(pollIntervalSeconds * 1000);
+
+      let output = '';
+      try {
+        output = tmux.capture(pane, captureLines);
+      } catch {
+        clearActiveRequest(ctx.paths, target, requestId);
+        ui.error(`Failed to capture pane ${pane}. Is tmux running?`);
+        exit(ExitCodes.ERROR);
+      }
+
+      const markerIndex = output.indexOf(marker);
+      if (markerIndex === -1) continue;
+
+      let startIndex = 0;
+      const baselineIndex = baseline ? output.lastIndexOf(baseline) : -1;
+      if (baselineIndex !== -1) {
+        startIndex = baselineIndex + baseline.length;
+      }
+
+      const response = output.slice(startIndex, markerIndex).trim();
+
+      if (!flags.json && isTTY) {
+        process.stdout.write('\r' + ' '.repeat(80) + '\r');
+      } else if (!flags.json) {
+        // Ensure the next output starts on a new line
+        process.stdout.write('\n');
+      }
+
+      clearActiveRequest(ctx.paths, target, requestId);
+
+      const result: WaitResult = { requestId, nonce, marker, response };
+      if (flags.json) {
+        ui.json({ target, pane, status: 'completed', ...result });
+      } else {
+        console.log(colors.cyan(`─── Response from ${target} (${pane}) ───`));
+        console.log(response);
+      }
+      return;
+    }
+  } finally {
+    process.removeListener('SIGINT', onSigint);
+    clearActiveRequest(ctx.paths, target, requestId);
+  }
+}

package/src/commands/update.ts

@@ -0,0 +1,47 @@
+// ─────────────────────────────────────────────────────────────
+// update command - modify agent config
+// ─────────────────────────────────────────────────────────────
+
+import type { Context } from '../types.js';
+import { ExitCodes } from '../exits.js';
+import { saveLocalConfig } from '../config.js';
+
+export function cmdUpdate(
+  ctx: Context,
+  name: string,
+  options: { pane?: string; remark?: string }
+): void {
+  const { ui, config, paths, flags, exit } = ctx;
+
+  if (!config.paneRegistry[name]) {
+    ui.error(`Agent '${name}' not found. Use 'tmux-team add' to create.`);
+    exit(ExitCodes.PANE_NOT_FOUND);
+  }
+
+  if (!options.pane && !options.remark) {
+    ui.error('No updates specified. Use --pane or --remark.');
+    exit(ExitCodes.ERROR);
+  }
+
+  const updates: string[] = [];
+
+  if (options.pane) {
+    config.paneRegistry[name].pane = options.pane;
+    updates.push(`pane → ${options.pane}`);
+  }
+
+  if (options.remark) {
+    config.paneRegistry[name].remark = options.remark;
+    updates.push(`remark updated`);
+  }
+
+  saveLocalConfig(paths, config.paneRegistry);
+
+  if (flags.json) {
+    ui.json({ updated: name, ...options });
+  } else {
+    for (const update of updates) {
+      ui.success(`Updated '${name}': ${update}`);
+    }
+  }
+}

package/src/config.test.ts

@@ -0,0 +1,246 @@
+// ─────────────────────────────────────────────────────────────
+// Config Tests - XDG path resolution and config hierarchy
+// ─────────────────────────────────────────────────────────────
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { resolveGlobalDir, resolvePaths, loadConfig, ConfigParseError } from './config.js';
+
+// Mock fs and os modules
+vi.mock('fs');
+vi.mock('os');
+
+describe('resolveGlobalDir', () => {
+  const mockHome = '/home/testuser';
+
+  beforeEach(() => {
+    vi.mocked(os.homedir).mockReturnValue(mockHome);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    // Clear environment variables
+    delete process.env.TMUX_TEAM_HOME;
+    delete process.env.XDG_CONFIG_HOME;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('uses TMUX_TEAM_HOME when set (highest priority)', () => {
+    process.env.TMUX_TEAM_HOME = '/custom/tmux-team';
+    expect(resolveGlobalDir()).toBe('/custom/tmux-team');
+  });
+
+  it('uses XDG_CONFIG_HOME when set', () => {
+    process.env.XDG_CONFIG_HOME = '/custom/config';
+    expect(resolveGlobalDir()).toBe('/custom/config/tmux-team');
+  });
+
+  it('uses ~/.config/tmux-team when directory exists', () => {
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      return p === path.join(mockHome, '.config', 'tmux-team');
+    });
+    expect(resolveGlobalDir()).toBe(path.join(mockHome, '.config', 'tmux-team'));
+  });
+
+  it('uses legacy ~/.tmux-team when it exists and XDG does not', () => {
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      return p === path.join(mockHome, '.tmux-team');
+    });
+    expect(resolveGlobalDir()).toBe(path.join(mockHome, '.tmux-team'));
+  });
+
+  it('defaults to XDG style (~/.config/tmux-team) for new installs', () => {
+    // Neither path exists
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    expect(resolveGlobalDir()).toBe(path.join(mockHome, '.config', 'tmux-team'));
+  });
+
+  it('prefers path with config.json when both XDG and legacy exist', () => {
+    const xdgPath = path.join(mockHome, '.config', 'tmux-team');
+    const legacyPath = path.join(mockHome, '.tmux-team');
+    const legacyConfig = path.join(legacyPath, 'config.json');
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      // Both dirs exist, but only legacy has config.json
+      if (p === xdgPath || p === legacyPath) return true;
+      if (p === legacyConfig) return true;
+      return false;
+    });
+
+    expect(resolveGlobalDir()).toBe(legacyPath);
+  });
+
+  it('prefers XDG when both exist and both have config.json', () => {
+    const xdgPath = path.join(mockHome, '.config', 'tmux-team');
+    const legacyPath = path.join(mockHome, '.tmux-team');
+    const xdgConfig = path.join(xdgPath, 'config.json');
+    const legacyConfig = path.join(legacyPath, 'config.json');
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      // Both dirs exist with config.json
+      if (p === xdgPath || p === legacyPath) return true;
+      if (p === xdgConfig || p === legacyConfig) return true;
+      return false;
+    });
+
+    expect(resolveGlobalDir()).toBe(xdgPath);
+  });
+
+  it('prefers XDG when only XDG has config.json', () => {
+    const xdgPath = path.join(mockHome, '.config', 'tmux-team');
+    const legacyPath = path.join(mockHome, '.tmux-team');
+    const xdgConfig = path.join(xdgPath, 'config.json');
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      if (p === xdgPath || p === legacyPath) return true;
+      if (p === xdgConfig) return true;
+      return false;
+    });
+
+    expect(resolveGlobalDir()).toBe(xdgPath);
+  });
+});
+
+describe('resolvePaths', () => {
+  const mockHome = '/home/testuser';
+  const mockCwd = '/projects/myapp';
+
+  beforeEach(() => {
+    vi.mocked(os.homedir).mockReturnValue(mockHome);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    delete process.env.TMUX_TEAM_HOME;
+    delete process.env.XDG_CONFIG_HOME;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns correct path structure', () => {
+    const paths = resolvePaths(mockCwd);
+
+    expect(paths.globalDir).toBe(path.join(mockHome, '.config', 'tmux-team'));
+    expect(paths.globalConfig).toBe(path.join(mockHome, '.config', 'tmux-team', 'config.json'));
+    expect(paths.localConfig).toBe(path.join(mockCwd, 'tmux-team.json'));
+    expect(paths.stateFile).toBe(path.join(mockHome, '.config', 'tmux-team', 'state.json'));
+  });
+
+  it('uses TMUX_TEAM_HOME for global paths', () => {
+    process.env.TMUX_TEAM_HOME = '/custom/path';
+    const paths = resolvePaths(mockCwd);
+
+    expect(paths.globalDir).toBe('/custom/path');
+    expect(paths.globalConfig).toBe('/custom/path/config.json');
+    expect(paths.stateFile).toBe('/custom/path/state.json');
+  });
+});
+
+describe('loadConfig', () => {
+  const mockPaths = {
+    globalDir: '/home/test/.config/tmux-team',
+    globalConfig: '/home/test/.config/tmux-team/config.json',
+    localConfig: '/projects/myapp/tmux-team.json',
+    stateFile: '/home/test/.config/tmux-team/state.json',
+  };
+
+  beforeEach(() => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns default config when no config files exist', () => {
+    const config = loadConfig(mockPaths);
+
+    expect(config.mode).toBe('polling');
+    expect(config.preambleMode).toBe('always');
+    expect(config.defaults.timeout).toBe(60);
+    expect(config.defaults.pollInterval).toBe(1);
+    expect(config.defaults.captureLines).toBe(100);
+    expect(config.agents).toEqual({});
+    expect(config.paneRegistry).toEqual({});
+  });
+
+  it('loads and merges global config', () => {
+    const globalConfig = {
+      mode: 'wait',
+      preambleMode: 'disabled',
+      defaults: { timeout: 120 },
+      agents: { claude: { preamble: 'Be helpful' } },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.globalConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(globalConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.mode).toBe('wait');
+    expect(config.preambleMode).toBe('disabled');
+    expect(config.defaults.timeout).toBe(120);
+    expect(config.defaults.pollInterval).toBe(1); // Default preserved
+    expect(config.agents.claude?.preamble).toBe('Be helpful');
+  });
+
+  it('loads local pane registry from tmux-team.json', () => {
+    const localConfig = {
+      claude: { pane: '1.0', remark: 'Main assistant' },
+      codex: { pane: '1.1' },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.paneRegistry.claude?.pane).toBe('1.0');
+    expect(config.paneRegistry.claude?.remark).toBe('Main assistant');
+    expect(config.paneRegistry.codex?.pane).toBe('1.1');
+  });
+
+  it('merges both global and local config', () => {
+    const globalConfig = {
+      agents: { claude: { preamble: 'Be brief' } },
+    };
+    const localConfig = {
+      claude: { pane: '1.0' },
+    };
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockImplementation((p) => {
+      if (p === mockPaths.globalConfig) return JSON.stringify(globalConfig);
+      if (p === mockPaths.localConfig) return JSON.stringify(localConfig);
+      return '';
+    });
+
+    const config = loadConfig(mockPaths);
+
+    expect(config.agents.claude?.preamble).toBe('Be brief');
+    expect(config.paneRegistry.claude?.pane).toBe('1.0');
+  });
+
+  it('throws ConfigParseError on invalid JSON in config file', () => {
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.globalConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue('{ invalid json }');
+
+    expect(() => loadConfig(mockPaths)).toThrow(ConfigParseError);
+  });
+
+  it('ConfigParseError includes file path and cause', () => {
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.globalConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue('not json');
+
+    try {
+      loadConfig(mockPaths);
+      expect.fail('Should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(ConfigParseError);
+      const parseError = err as ConfigParseError;
+      expect(parseError.filePath).toBe(mockPaths.globalConfig);
+      expect(parseError.cause).toBeDefined();
+    }
+  });
+});