@nemus-cli/nemus 0.2.1

package/src/commands/create.ts

@@ -0,0 +1,196 @@
+import { Command } from 'commander';
+import { WORKSPACES_DIR } from '../utils/config';
+import * as path from 'path';
+import { verifyGhAuth, fetchOrgRepos, displayAuthInstructions } from '../utils/github';
+import { promptRepositorySelection, promptWorkspaceName, confirmWorkspaceCreation, type RepoSelection } from '../utils/prompts';
+import { cloneRepositories, reportCloneResults } from '../utils/git-operations';
+import { warnIfGhqMissing } from '../utils/ghq-integration';
+import { createMetadata, saveMetadata } from '../utils/workspace-meta';
+import { generateClaudeContext } from '../utils/claude-integration';
+import { logInfo, logSuccess, logError, logStep } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { printBanner } from '../utils/banner';
+import { validateWorkspaceName, checkWorkspaceExists, sanitizeWorkspaceName, resolveWorkspaceNameConflict } from '../utils/validation';
+import { getGlobalOpts, parseList } from '../utils/command-helpers';
+import { resolveRepoSpecs } from '../utils/repo-resolver';
+
+export function registerCreateCommand(parent: Command) {
+  parent
+    .command('create')
+    .alias('c')
+    .description('Create a new workspace')
+    .option('-w, --workspace <name>', 'Workspace name')
+    .option('-r, --repos <repos>', 'Comma-separated repository names. Use repo:suffix to add the same repo more than once under a separate folder, e.g. casper:cas-101 -> casper-cas-101')
+    .option('--prompt <prompt>', 'Original prompt that triggered workspace creation (saved to metadata)')
+    .option('--allow-empty', 'Create the workspace with no repositories (e.g. investigate-first: the agent adds repos later)')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      await handleCreate({ ...opts, ...globalOpts });
+    });
+}
+
+async function handleCreate(opts: {
+  workspace?: string;
+  repos?: string;
+  prompt?: string;
+  allowEmpty?: boolean;
+  forceRefresh: boolean;
+  yes: boolean;
+}) {
+  printBanner();
+
+  try {
+    // Step 1: Verify gh CLI authentication
+    logStep(1, 6, 'Verifying GitHub CLI authentication...');
+    const isAuthenticated = await verifyGhAuth();
+
+    if (!isAuthenticated) {
+      logError('GitHub CLI is not authenticated');
+      displayAuthInstructions();
+      process.exit(1);
+    }
+
+    logSuccess('GitHub CLI authenticated');
+
+    // Investigate-first empty workspace: no repos to resolve, so skip the org
+    // catalog fetch entirely — otherwise an empty/failed catalog would abort
+    // creation on the guard below even though we need no repos.
+    const investigateEmpty = !!opts.allowEmpty && !opts.repos;
+
+    // Step 2: Fetch repositories (only when we actually need to resolve repos)
+    let repos: Awaited<ReturnType<typeof fetchOrgRepos>> = [];
+    if (!investigateEmpty) {
+      logStep(2, 6, 'Fetching repositories...');
+      repos = await fetchOrgRepos({ forceRefresh: opts.forceRefresh });
+
+      if (repos.length === 0) {
+        logError('No repositories found');
+        process.exit(1);
+      }
+    }
+
+    // Step 3: Select repositories
+    logStep(3, 6, 'Select repositories to clone...');
+    let selectedEntries: RepoSelection[];
+
+    if (investigateEmpty) {
+      // Investigate-first: start with no repos; the in-session agent discovers
+      // and adds the relevant repos itself.
+      logInfo('Creating an empty workspace (no repositories) — repos can be added later.');
+      selectedEntries = [];
+    } else if (opts.repos) {
+      const repoSpecs = parseList(opts.repos);
+      const { resolved, notFound, invalidSuffix } = resolveRepoSpecs(repoSpecs, repos);
+
+      if (invalidSuffix.length > 0) {
+        logError(`Invalid instance suffix in: ${invalidSuffix.join(', ')}`);
+        logInfo('Use repo:suffix (e.g. casper:cas-101). Suffix may contain letters, numbers, hyphens, underscores.');
+        process.exit(1);
+      }
+
+      // Warn about fuzzy-resolved names so the user knows what was used
+      for (const r of resolved) {
+        if (!r.exact) {
+          logInfo(`Repo "${r.input}" not found exactly — using "${colorize(r.repo.name, 'cyan')}" (best match)`);
+        }
+      }
+
+      if (notFound.length > 0) {
+        logError(`Repositories not found: ${notFound.join(', ')}`);
+        process.exit(1);
+      }
+
+      selectedEntries = resolved.map(r => ({ repo: r.repo, directoryName: r.directoryName }));
+    } else {
+      selectedEntries = await promptRepositorySelection(repos);
+    }
+
+    if (selectedEntries.length === 0 && !opts.allowEmpty) {
+      logInfo('No repositories selected');
+      return;
+    }
+
+    // Step 4: Get workspace name
+    logStep(4, 6, 'Configure workspace...');
+    let workspaceName: string;
+
+    if (opts.workspace) {
+      workspaceName = sanitizeWorkspaceName(opts.workspace);
+      const nameError = validateWorkspaceName(workspaceName);
+      if (nameError !== true) {
+        logError(typeof nameError === 'string' ? nameError : 'Invalid workspace name');
+        process.exit(1);
+      }
+      const exists = await checkWorkspaceExists(workspaceName);
+      if (exists) {
+        const resolved = await resolveWorkspaceNameConflict(workspaceName, selectedEntries.map(e => e.directoryName));
+        logInfo(`Workspace "${workspaceName}" already exists — using "${colorize(resolved, 'cyan')}" instead.`);
+        workspaceName = resolved;
+      }
+    } else {
+      workspaceName = await promptWorkspaceName();
+      // Auto-resolve conflict in case the interactively chosen name already exists
+      // (the prompt validates format but not uniqueness at this point)
+      const interactiveExists = await checkWorkspaceExists(workspaceName);
+      if (interactiveExists) {
+        const resolved = await resolveWorkspaceNameConflict(workspaceName, selectedEntries.map(e => e.directoryName));
+        logInfo(`Workspace "${workspaceName}" already exists — using "${colorize(resolved, 'cyan')}" instead.`);
+        workspaceName = resolved;
+      }
+    }
+
+    // Step 5: Confirm
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+    if (!opts.yes) {
+      const confirmed = await confirmWorkspaceCreation(workspaceName, selectedEntries.length, workspacePath);
+      if (!confirmed) {
+        logInfo('Operation cancelled');
+        return;
+      }
+    }
+
+    // Step 6: Clone repositories
+    logStep(5, 6, 'Creating workspace...');
+    const { mkdir } = await import('fs/promises');
+    await mkdir(workspacePath, { recursive: true });
+
+    if (selectedEntries.length > 0) await warnIfGhqMissing();
+    const results = await cloneRepositories(selectedEntries, workspacePath);
+    reportCloneResults(results);
+
+    // Step 7: Save metadata & generate context
+    logStep(6, 6, 'Saving workspace metadata...');
+    const metadata = createMetadata(workspaceName, results, { prompt: opts.prompt });
+    await saveMetadata(workspacePath, metadata);
+
+    const successfulRepos = results
+      .filter(r => r.status === 'success')
+      .map(r => r.repo);
+
+    // Generate context + .mcp.json even for an empty (investigate-first)
+    // workspace, so the in-session agent lands with the MCP tools (search-repos
+    // / update-workspace) needed to discover and add repos.
+    if (successfulRepos.length > 0 || opts.allowEmpty) {
+      await generateClaudeContext(workspacePath, workspaceName, successfulRepos, metadata);
+    }
+
+    logSuccess(`Workspace "${colorize(workspaceName, 'cyan')}" created successfully!`);
+
+    // Write workspace path to temp file for shell integration auto-CD
+    const { writeFile } = await import('fs/promises');
+    const os = await import('os');
+    const tempFile = path.join(os.homedir(), '.workspace-last-created');
+    try {
+      await writeFile(tempFile, workspacePath, 'utf-8');
+    } catch {
+      // Non-critical — shell integration CD won't work but workspace was created
+    }
+
+  } catch (error) {
+    logError('Failed to create workspace');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/dashboard/hook-handler.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+/**
+ * Hook handler for Claude Code hooks.
+ * Invoked via ~/.claude/settings.json hooks — reads JSON from stdin,
+ * maps the event to an agent status, and writes to state file.
+ *
+ * Status model:
+ *   idle    — agent is not working (new, finished, waiting for input)
+ *   working — agent is actively processing (thinking, calling tools)
+ *   waiting — agent needs user action (permission approval)
+ *   stopped — session ended
+ *
+ * Event mapping:
+ *   SessionStart      → idle     (session opened, not working yet)
+ *   UserPromptSubmit  → working  (user sent prompt, agent starts)
+ *   PreToolUse        → working  (agent calling a tool)
+ *   PostToolUse       → working  (tool done, agent still processing)
+ *   Notification:
+ *     permission_prompt → waiting (needs user to approve tool use)
+ *     idle_prompt       → idle    (agent finished, waiting for input)
+ *   Stop              → idle     (agent finished its turn)
+ *   SessionEnd        → stopped  (session ended)
+ *
+ * IMPORTANT: Must never write to stderr or throw — always exit 0.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { AgentState, AgentStatus } from '../../types/dashboard';
+import { readAgentState, writeAgentState, ensureStateDir } from '../../utils/agent-state';
+import { WORKSPACES_DIR } from '../../utils/config';
+
+function main() {
+  try {
+    const args = process.argv.slice(2);
+    const eventIdx = args.indexOf('--event');
+    const event = eventIdx >= 0 ? args[eventIdx + 1] : null;
+
+    if (!event) {
+      process.exit(0);
+    }
+
+    let input: any;
+    try {
+      const raw = fs.readFileSync('/dev/stdin', 'utf-8');
+      input = JSON.parse(raw);
+    } catch {
+      process.exit(0);
+    }
+
+    const sessionId = input.session_id;
+    if (!sessionId || !/^[a-zA-Z0-9\-]{1,100}$/.test(sessionId)) {
+      process.exit(0); // reject missing or invalid session IDs
+    }
+
+    ensureStateDir();
+
+    let newStatus: AgentStatus;
+    switch (event) {
+      case 'SessionStart':
+        newStatus = 'idle';
+        break;
+      case 'UserPromptSubmit':
+        newStatus = 'working';
+        break;
+      case 'PreToolUse':
+        newStatus = 'working';
+        break;
+      case 'PostToolUse':
+        newStatus = 'working';
+        break;
+      case 'Notification': {
+        const notifType = input.notification_type || '';
+        if (notifType === 'permission_prompt') {
+          newStatus = 'waiting'; // needs user to approve
+        } else if (notifType === 'idle_prompt') {
+          newStatus = 'idle'; // just idle, not a special state
+        } else {
+          process.exit(0);
+        }
+        break;
+      }
+      case 'Stop':
+        newStatus = 'idle';
+        break;
+      case 'SessionEnd':
+        newStatus = 'stopped';
+        break;
+      default:
+        process.exit(0);
+    }
+
+    const now = new Date().toISOString();
+
+    const existing = readAgentState(sessionId);
+    if (existing) {
+      existing.status = newStatus;
+      existing.lastUpdatedAt = now;
+      // Always update PID — handles resumed sessions where the old
+      // process is dead but session ID is reused with a new process
+      existing.pid = process.ppid || existing.pid;
+      writeAgentState(existing);
+      process.exit(0);
+    }
+
+    // New session — infer workspace from cwd
+    const cwd = input.cwd || process.cwd();
+    let workspace = 'unknown';
+    let workspacePath = cwd;
+
+    const workspacesDir = WORKSPACES_DIR;
+    if (cwd.startsWith(workspacesDir + path.sep) || cwd === workspacesDir) {
+      const relative = cwd.slice(workspacesDir.length + 1);
+      const parts = relative.split(path.sep);
+      if (parts[0]) {
+        workspace = parts[0];
+        workspacePath = path.join(workspacesDir, workspace);
+      }
+    }
+
+    const state: AgentState = {
+      sessionId,
+      workspace,
+      workspacePath,
+      pid: process.ppid || 0,
+      status: newStatus,
+      startedAt: now,
+      lastUpdatedAt: now,
+    };
+
+    writeAgentState(state);
+    process.exit(0);
+  } catch {
+    process.exit(0);
+  }
+}
+
+main();

package/src/commands/dashboard/index.ts

@@ -0,0 +1,248 @@
+import { Command } from 'commander';
+import { execFileSync, spawnSync } from 'child_process';
+import * as path from 'path';
+import { logError, logInfo, logSuccess } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import { areDashboardHooksInstalled, installDashboardHooks, uninstallDashboardHooks } from '../../utils/dashboard-hooks';
+import { DASHBOARD_DEFAULTS } from '../../types/dashboard';
+import { readAllAgentStates, removeAgentState } from '../../utils/agent-state';
+import { getAgentPanes, findPaneForAgent, resetLayout } from '../../utils/tmux-dashboard';
+import { getPrimaryAgent } from '../../utils/agent-config';
+
+const { sessionName, sidebarWidthPercent } = DASHBOARD_DEFAULTS;
+
+function isTmuxAvailable(): boolean {
+  try {
+    execFileSync('which', ['tmux'], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isInsideTmux(): boolean {
+  return !!process.env.TMUX;
+}
+
+export function registerDashboardCommand(parent: Command) {
+  parent
+    .command('dashboard')
+    .alias('dash')
+    .description('Launch multi-agent management dashboard')
+    .option('--install-hooks', 'Install Claude status hooks without launching dashboard')
+    .option('--uninstall-hooks', 'Remove dashboard hooks from Claude settings')
+    .option('--list', 'List running agents as JSON (non-interactive)')
+    .option('--status', 'Show agent status summary (non-interactive)')
+    .option('--kill <sessionId>', 'Kill agent by session ID (non-interactive)')
+    .option('--launch <workspace>', 'Launch a new agent in a workspace (non-interactive)')
+    .action(async (opts) => {
+      await handleDashboard(opts);
+    });
+}
+
+async function handleDashboard(opts: {
+  installHooks?: boolean;
+  uninstallHooks?: boolean;
+  list?: boolean;
+  status?: boolean;
+  kill?: string;
+  launch?: string;
+}) {
+  // Handle hook-only commands
+  if (opts.installHooks) {
+    installDashboardHooks();
+    logSuccess('Dashboard hooks installed in ~/.claude/settings.json');
+    return;
+  }
+
+  if (opts.uninstallHooks) {
+    uninstallDashboardHooks();
+    logSuccess('Dashboard hooks removed from ~/.claude/settings.json');
+    return;
+  }
+
+  // --list: print running agents as JSON
+  if (opts.list) {
+    const agents = readAllAgentStates().filter(a => a.status !== 'stopped');
+    console.log(JSON.stringify(agents, null, 2));
+    return;
+  }
+
+  // --status: human-readable status summary
+  if (opts.status) {
+    const agents = readAllAgentStates().filter(a => a.status !== 'stopped');
+    if (agents.length === 0) {
+      console.log('No agents running.');
+      return;
+    }
+    for (const a of agents) {
+      console.log(`${colorize(a.workspace, 'cyan')}  ${colorize(a.status, 'yellow')}  ${a.sessionId.slice(0, 8)}`);
+    }
+    return;
+  }
+
+  // --kill: kill agent by session ID
+  if (opts.kill) {
+    const sessionId = opts.kill;
+    const agents = readAllAgentStates();
+    const agent = agents.find(a => a.sessionId === sessionId || a.sessionId.startsWith(sessionId));
+    if (!agent) {
+      logError(`No agent found with session ID: ${sessionId}`);
+      process.exit(1);
+    }
+    // Try to kill the tmux pane if dashboard is running
+    const panes = getAgentPanes();
+    const pane = findPaneForAgent(agent, panes);
+    if (pane) {
+      spawnSync('tmux', ['kill-pane', '-t', `${sessionName}:0.${pane.index}`], { stdio: 'pipe' });
+      setTimeout(() => resetLayout(), 100);
+    } else {
+      // Kill the process directly (guard: pid 0 would kill entire process group)
+      if (agent.pid > 0) {
+        try { process.kill(agent.pid); } catch { /* already dead */ }
+      }
+    }
+    removeAgentState(agent.sessionId);
+    logSuccess(`Killed agent: ${agent.workspace} (${agent.sessionId.slice(0, 8)})`);
+    return;
+  }
+
+  // --launch: launch a new agent in a workspace
+  if (opts.launch) {
+    const workspaceName = opts.launch;
+    const { listWorkspaces } = await import('../../utils/workspace-meta');
+    const workspaces = await listWorkspaces();
+    const ws = workspaces.find(w => w.name === workspaceName);
+    if (!ws) {
+      logError(`Workspace not found: ${workspaceName}`);
+      logInfo(`Available: ${workspaces.map(w => w.name).join(', ')}`);
+      process.exit(1);
+    }
+    // Check if dashboard is running by verifying the session exists
+    const sessionCheck = spawnSync('tmux', ['has-session', '-t', sessionName], { stdio: 'pipe' });
+    if (sessionCheck.status === 0) {
+      // Dashboard running — split a pane
+      spawnSync('tmux', [
+        'split-window', '-t', `${sessionName}:0`, '-h',
+        '-c', ws.path,
+        getPrimaryAgent().launchCommand,
+      ], { stdio: 'pipe' });
+      spawnSync('tmux', ['select-layout', '-t', sessionName, 'main-vertical'], { stdio: 'pipe' });
+      spawnSync('tmux', ['resize-pane', '-t', `${sessionName}:0.0`, '-x', '32'], { stdio: 'pipe' });
+      logSuccess(`Launched agent in workspace: ${workspaceName}`);
+    } else {
+      logInfo(`Dashboard not running. Start it with: w dash`);
+    }
+    return;
+  }
+
+  // Check tmux for interactive dashboard
+  if (!isTmuxAvailable()) {
+    logError('tmux is required for the agent dashboard');
+    console.log(colorize('Install tmux: brew install tmux', 'gray'));
+    process.exit(1);
+  }
+
+  // Auto-install hooks if not present
+  if (!areDashboardHooksInstalled()) {
+    installDashboardHooks();
+    logInfo('Installed dashboard hooks in ~/.claude/settings.json');
+  }
+
+  // Check if dashboard session already exists — reconnect if so
+  const sessionExists = spawnSync('tmux', [
+    'has-session', '-t', sessionName,
+  ], { stdio: 'pipe' }).status === 0;
+
+  if (sessionExists) {
+    logInfo('Reconnecting to existing dashboard session...');
+    if (isInsideTmux()) {
+      spawnSync('tmux', ['switch-client', '-t', sessionName], { stdio: 'inherit' });
+    } else {
+      spawnSync('tmux', ['attach-session', '-t', sessionName], { stdio: 'inherit' });
+    }
+    logSuccess('Dashboard session ended');
+    return;
+  }
+
+  // Resolve paths to compiled scripts
+  const sidebarScript = path.join(__dirname, 'sidebar.js');
+
+  // Create tmux session with sidebar in the left pane
+  const newSessionResult = spawnSync('tmux', [
+    'new-session', '-d', '-s', sessionName,
+    '-x', '200', '-y', '50',
+    `node "${sidebarScript}"`,
+  ], { stdio: 'pipe' });
+
+  if (newSessionResult.status !== 0) {
+    logError('Failed to create tmux session');
+    const stderr = newSessionResult.stderr?.toString();
+    if (stderr) logError(stderr);
+    process.exit(1);
+  }
+
+  // Split right pane (80%) with placeholder message
+  spawnSync('tmux', [
+    'split-window', '-h', '-t', sessionName,
+    '-p', String(100 - sidebarWidthPercent),
+    'bash', '-c',
+    'echo ""; echo "  No agents running."; echo "  Press n in the sidebar to launch an agent."; echo ""; sleep infinity',
+  ], { stdio: 'pipe' });
+
+  // Focus the sidebar pane (left)
+  spawnSync('tmux', ['select-pane', '-t', `${sessionName}:0.0`], { stdio: 'pipe' });
+
+  // ── Session-scoped key bindings ──
+  // Use set-hook to add bindings only while this session is active and
+  // restore them on detach — avoids polluting global tmux key tables.
+  // prefix + M → focus sidebar + reset layout (M chosen to avoid overriding standard keys)
+  spawnSync('tmux', [
+    'set-hook', '-t', sessionName, 'session-created',
+    `bind-key -T prefix M run-shell "tmux select-layout -t ${sessionName} main-vertical \\\\; resize-pane -t ${sessionName}:0.0 -x 32 \\\\; select-pane -t ${sessionName}:0.0"`,
+  ], { stdio: 'pipe' });
+
+  // Bind immediately for the current session
+  spawnSync('tmux', [
+    'bind-key', '-T', 'prefix', 'M',
+    'run-shell',
+    `tmux select-layout -t ${sessionName} main-vertical \\; resize-pane -t ${sessionName}:0.0 -x 32 \\; select-pane -t ${sessionName}:0.0`,
+  ], { stdio: 'pipe' });
+
+  // Unbind prefix+M when the dashboard session ends (cleanup)
+  spawnSync('tmux', [
+    'set-hook', '-t', sessionName, 'session-closed',
+    'unbind-key -T prefix M',
+  ], { stdio: 'pipe' });
+
+  // ── Status bar ──
+  spawnSync('tmux', [
+    'set-option', '-t', sessionName,
+    'status-left', ' 🤖 Agent Dashboard ',
+  ], { stdio: 'pipe' });
+  spawnSync('tmux', [
+    'set-option', '-t', sessionName,
+    'status-right', ' prefix+M:sidebar/reset  q:detach  Q:quit ',
+  ], { stdio: 'pipe' });
+  spawnSync('tmux', [
+    'set-option', '-t', sessionName,
+    'status-style', 'bg=colour235,fg=colour255',
+  ], { stdio: 'pipe' });
+
+  // Enable mouse support for pane selection
+  spawnSync('tmux', [
+    'set-option', '-t', sessionName,
+    'mouse', 'on',
+  ], { stdio: 'pipe' });
+
+  logInfo('Launching agent dashboard...');
+
+  // Attach to the session
+  if (isInsideTmux()) {
+    spawnSync('tmux', ['switch-client', '-t', sessionName], { stdio: 'inherit' });
+  } else {
+    spawnSync('tmux', ['attach-session', '-t', sessionName], { stdio: 'inherit' });
+  }
+
+  logSuccess('Agent dashboard session ended');
+}

package/src/commands/dashboard/launcher.ts

@@ -0,0 +1,42 @@
+import { spawnSync } from 'child_process';
+import { DASHBOARD_DEFAULTS } from '../../types/dashboard';
+
+const { sessionName } = DASHBOARD_DEFAULTS;
+
+/**
+ * Launch an agent in the dashboard by spawning a new tmux pane.
+ * Kills any placeholder pane (sleep infinity), splits a new pane,
+ * and rebalances the layout.
+ *
+ * @param workspacePath - absolute path to the workspace directory
+ * @param command - shell command to run in the new pane (e.g. 'claude' or 'claude --resume <id> --fork-session')
+ */
+export function launchAgentPane(workspacePath: string, command: string): void {
+  // Kill placeholder pane (sleep infinity) if present
+  const paneResult = spawnSync('tmux', [
+    'list-panes', '-t', sessionName, '-F',
+    '#{pane_index} #{pane_current_command}',
+  ], { stdio: 'pipe' });
+
+  if (paneResult.stdout) {
+    const lines = paneResult.stdout.toString().trim().split('\n');
+    for (const line of lines) {
+      const parts = line.split(' ');
+      if (parts[0] !== '0' && parts.slice(1).join(' ').includes('sleep')) {
+        spawnSync('tmux', ['kill-pane', '-t', `${sessionName}:0.${parts[0]}`], { stdio: 'pipe' });
+        break;
+      }
+    }
+  }
+
+  // Create a new pane for the agent
+  spawnSync('tmux', [
+    'split-window', '-t', `${sessionName}:0`, '-h',
+    '-c', workspacePath,
+    command,
+  ], { stdio: 'pipe' });
+
+  // Rebalance layout: sidebar left, agents stacked right
+  spawnSync('tmux', ['select-layout', '-t', sessionName, 'main-vertical'], { stdio: 'pipe' });
+  spawnSync('tmux', ['resize-pane', '-t', `${sessionName}:0.0`, '-x', '32'], { stdio: 'pipe' });
+}