npm - hjworktree-cli - Versions diffs - 2.0.0 - Mend

hjworktree-cli 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (68) hide show

package/.context-snapshots/context-snapshot-20260106-110353.md +66 -0
package/.context-snapshots/context-snapshot-20260106-110441.md +66 -0
package/.context-snapshots/context-snapshot-20260106-220000.md +99 -0
package/AGENTS.md +29 -0
package/CLAUDE.md +88 -0
package/bin/cli.js +85 -0
package/dist/server/index.d.ts +6 -0
package/dist/server/index.d.ts.map +1 -0
package/dist/server/index.js +64 -0
package/dist/server/index.js.map +1 -0
package/dist/server/routes/api.d.ts +3 -0
package/dist/server/routes/api.d.ts.map +1 -0
package/dist/server/routes/api.js +101 -0
package/dist/server/routes/api.js.map +1 -0
package/dist/server/services/gitService.d.ts +13 -0
package/dist/server/services/gitService.d.ts.map +1 -0
package/dist/server/services/gitService.js +84 -0
package/dist/server/services/gitService.js.map +1 -0
package/dist/server/services/worktreeService.d.ts +17 -0
package/dist/server/services/worktreeService.d.ts.map +1 -0
package/dist/server/services/worktreeService.js +161 -0
package/dist/server/services/worktreeService.js.map +1 -0
package/dist/server/socketHandlers.d.ts +4 -0
package/dist/server/socketHandlers.d.ts.map +1 -0
package/dist/server/socketHandlers.js +118 -0
package/dist/server/socketHandlers.js.map +1 -0
package/dist/shared/constants.d.ts +10 -0
package/dist/shared/constants.d.ts.map +1 -0
package/dist/shared/constants.js +31 -0
package/dist/shared/constants.js.map +1 -0
package/dist/shared/types/index.d.ts +67 -0
package/dist/shared/types/index.d.ts.map +1 -0
package/dist/shared/types/index.js +3 -0
package/dist/shared/types/index.js.map +1 -0
package/dist/web/assets/index-C61yAbey.css +32 -0
package/dist/web/assets/index-WEdVUKxb.js +53 -0
package/dist/web/assets/index-WEdVUKxb.js.map +1 -0
package/dist/web/index.html +16 -0
package/package.json +63 -0
package/server/index.ts +75 -0
package/server/routes/api.ts +108 -0
package/server/services/gitService.ts +91 -0
package/server/services/worktreeService.ts +181 -0
package/server/socketHandlers.ts +157 -0
package/shared/constants.ts +35 -0
package/shared/types/index.ts +92 -0
package/tsconfig.json +20 -0
package/web/index.html +15 -0
package/web/src/App.tsx +65 -0
package/web/src/components/Layout/Header.tsx +29 -0
package/web/src/components/Layout/LeftNavBar.tsx +67 -0
package/web/src/components/Layout/MainLayout.tsx +23 -0
package/web/src/components/Layout/StepContainer.tsx +71 -0
package/web/src/components/Setup/AgentSelector.tsx +27 -0
package/web/src/components/Setup/BranchSelector.tsx +28 -0
package/web/src/components/Setup/SetupPanel.tsx +32 -0
package/web/src/components/Setup/WorktreeCountSelector.tsx +30 -0
package/web/src/components/Steps/AgentStep.tsx +20 -0
package/web/src/components/Steps/BranchStep.tsx +20 -0
package/web/src/components/Steps/WorktreeStep.tsx +41 -0
package/web/src/components/Terminal/TerminalPanel.tsx +113 -0
package/web/src/components/Terminal/XTerminal.tsx +203 -0
package/web/src/hooks/useSocket.ts +80 -0
package/web/src/main.tsx +10 -0
package/web/src/stores/useAppStore.ts +348 -0
package/web/src/styles/global.css +695 -0
package/web/tsconfig.json +23 -0
package/web/vite.config.ts +32 -0

package/dist/web/index.html ADDED Viewed

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>hjWorktree CLI</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+  <script type="module" crossorigin src="/assets/index-WEdVUKxb.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-C61yAbey.css">
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,63 @@
+{
+  "name": "hjworktree-cli",
+  "version": "2.0.0",
+  "description": "Web-based git worktree parallel AI coding agent runner",
+  "type": "module",
+  "main": "dist/server/index.js",
+  "bin": {
+    "hjWorktree": "./bin/cli.js"
+  },
+  "scripts": {
+    "dev": "concurrently \"npm run dev:server\" \"npm run dev:web\"",
+    "dev:server": "tsx watch server/index.ts",
+    "dev:web": "vite --config web/vite.config.ts",
+    "build": "npm run build:server && npm run build:web",
+    "build:server": "tsc",
+    "build:web": "vite build --config web/vite.config.ts",
+    "start": "node dist/server/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "git",
+    "worktree",
+    "ai",
+    "codex",
+    "claude",
+    "gemini",
+    "parallel",
+    "terminal",
+    "web"
+  ],
+  "author": "hyungju-lee <beegizee1220@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.21.0",
+    "node-pty": "^1.0.0",
+    "open": "^10.1.0",
+    "simple-git": "^3.27.0",
+    "socket.io": "^4.7.5"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.10.5",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.5",
+    "@vitejs/plugin-react": "^4.3.4",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/xterm": "^5.5.0",
+    "concurrently": "^9.1.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "socket.io-client": "^4.7.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "vite": "^6.0.7",
+    "zustand": "^5.0.2"
+  }
+}

package/server/index.ts ADDED Viewed

@@ -0,0 +1,75 @@
+import express from 'express';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import cors from 'cors';
+import { setupSocketHandlers, killAllSessions } from './socketHandlers.js';
+import { apiRouter } from './routes/api.js';
+import { DEFAULT_PORT, APP_NAME, APP_VERSION } from '../shared/constants.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const app = express();
+const httpServer = createServer(app);
+const io = new Server(httpServer, {
+  cors: {
+    origin: '*',
+    methods: ['GET', 'POST']
+  }
+});
+const PORT = parseInt(process.env.PORT || String(DEFAULT_PORT), 10);
+const CWD = process.env.CWD || process.cwd();
+// Middleware
+app.use(cors());
+app.use(express.json());
+// Serve static files from the web build directory
+const webDir = path.join(__dirname, '../web');
+app.use(express.static(webDir));
+// API routes
+app.use('/api', apiRouter(CWD));
+// Socket.IO handlers
+setupSocketHandlers(io, CWD);
+// Fallback to index.html for SPA routing
+app.get('*', (req, res) => {
+  res.sendFile(path.join(webDir, 'index.html'));
+});
+// Graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\nShutting down...');
+  killAllSessions();
+  process.exit(0);
+});
+process.on('SIGTERM', () => {
+  console.log('\nShutting down...');
+  killAllSessions();
+  process.exit(0);
+});
+// Start server
+httpServer.listen(PORT, () => {
+  console.log(`
+╔════════════════════════════════════════════╗
+║                                            ║
+║   ${APP_NAME} v${APP_VERSION}                  ║
+║                                            ║
+║   Server running at:                       ║
+║   http://localhost:${PORT}                    ║
+║                                            ║
+║   Working directory:                       ║
+║   ${CWD.substring(0, 38)}${CWD.length > 38 ? '...' : ''}
+║                                            ║
+╚════════════════════════════════════════════╝
+  `);
+});
+export { app, httpServer, io };

package/server/routes/api.ts ADDED Viewed

@@ -0,0 +1,108 @@
+import { Router, Request, Response } from 'express';
+import { GitService } from '../services/gitService.js';
+import { WorktreeService } from '../services/worktreeService.js';
+import type { CreateWorktreesRequest } from '../../shared/types/index.js';
+export function apiRouter(cwd: string): Router {
+  const router = Router();
+  const gitService = new GitService(cwd);
+  const worktreeService = new WorktreeService(cwd);
+  // Get project info
+  router.get('/info', async (req: Request, res: Response) => {
+    try {
+      const isGitRepo = await gitService.isGitRepository();
+      const currentBranch = isGitRepo ? await gitService.getCurrentBranch() : null;
+      res.json({
+        cwd,
+        isGitRepository: isGitRepo,
+        currentBranch,
+      });
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  });
+  // Get branches
+  router.get('/branches', async (req: Request, res: Response) => {
+    try {
+      // Fetch latest from remote first
+      await gitService.fetch();
+      const branches = await gitService.getBranches();
+      res.json(branches);
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  });
+  // Get worktrees
+  router.get('/worktrees', async (req: Request, res: Response) => {
+    try {
+      const worktrees = await worktreeService.listWorktrees();
+      res.json(worktrees);
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  });
+  // Create worktrees
+  router.post('/worktrees', async (req: Request, res: Response) => {
+    try {
+      const { branch, count } = req.body as CreateWorktreesRequest;
+      if (!branch || !count || count < 1) {
+        res.status(400).json({ error: 'Invalid request: branch and count are required' });
+        return;
+      }
+      const worktrees = await worktreeService.createMultipleWorktrees(branch, count);
+      res.json({ worktrees });
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  });
+  // Delete a worktree
+  router.delete('/worktrees/:name', async (req: Request, res: Response) => {
+    try {
+      const { name } = req.params;
+      const worktrees = await worktreeService.listWorktrees();
+      const worktree = worktrees.find(wt => wt.name === name);
+      if (!worktree) {
+        res.status(404).json({ error: 'Worktree not found' });
+        return;
+      }
+      await worktreeService.removeWorktree(worktree.path);
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  });
+  // Delete all worktrees
+  router.delete('/worktrees', async (req: Request, res: Response) => {
+    try {
+      await worktreeService.removeAllWorktrees();
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  });
+  return router;
+}

package/server/services/gitService.ts ADDED Viewed

@@ -0,0 +1,91 @@
+import { simpleGit, SimpleGit } from 'simple-git';
+import type { Branch } from '../../shared/types/index.js';
+import { BRANCH_POLL_INTERVAL } from '../../shared/constants.js';
+export class GitService {
+  private git: SimpleGit;
+  private cwd: string;
+  constructor(cwd: string = process.cwd()) {
+    this.cwd = cwd;
+    this.git = simpleGit(cwd);
+  }
+  async isGitRepository(): Promise<boolean> {
+    try {
+      await this.git.status();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getBranches(): Promise<Branch[]> {
+    const branchSummary = await this.git.branch(['-a']);
+    const branches: Branch[] = [];
+    const localBranchNames = new Set<string>();
+    // First pass: collect local branches
+    for (const [name, data] of Object.entries(branchSummary.branches)) {
+      if (!name.startsWith('remotes/')) {
+        localBranchNames.add(name);
+        branches.push({
+          name,
+          isCurrent: data.current,
+          isRemote: false,
+        });
+      }
+    }
+    // Second pass: add remote branches that don't have local counterparts
+    for (const [name] of Object.entries(branchSummary.branches)) {
+      if (name.startsWith('remotes/origin/')) {
+        const localName = name.replace('remotes/origin/', '');
+        // Skip HEAD reference and branches that exist locally
+        if (localName !== 'HEAD' && !localBranchNames.has(localName)) {
+          branches.push({
+            name: localName,
+            isCurrent: false,
+            isRemote: true,
+          });
+        }
+      }
+    }
+    // Sort: current first, then local, then remote, alphabetically within each group
+    return branches.sort((a, b) => {
+      if (a.isCurrent) return -1;
+      if (b.isCurrent) return 1;
+      if (!a.isRemote && b.isRemote) return -1;
+      if (a.isRemote && !b.isRemote) return 1;
+      return a.name.localeCompare(b.name);
+    });
+  }
+  async getCurrentBranch(): Promise<string> {
+    const status = await this.git.status();
+    return status.current || 'HEAD';
+  }
+  async fetch(): Promise<void> {
+    try {
+      await this.git.fetch(['--prune']);
+    } catch {
+      // Silently fail fetch - might not have remote configured
+    }
+  }
+  getCwd(): string {
+    return this.cwd;
+  }
+}
+// Singleton instance
+let gitServiceInstance: GitService | null = null;
+export function getGitService(cwd?: string): GitService {
+  if (!gitServiceInstance || (cwd && gitServiceInstance.getCwd() !== cwd)) {
+    gitServiceInstance = new GitService(cwd);
+  }
+  return gitServiceInstance;
+}

package/server/services/worktreeService.ts ADDED Viewed

@@ -0,0 +1,181 @@
+import { simpleGit, SimpleGit } from 'simple-git';
+import path from 'path';
+import fs from 'fs/promises';
+import type { Worktree } from '../../shared/types/index.js';
+export class WorktreeService {
+  private git: SimpleGit;
+  private rootDir: string;
+  private createdWorktrees: Set<string> = new Set();
+  constructor(cwd: string = process.cwd()) {
+    this.rootDir = cwd;
+    this.git = simpleGit(cwd);
+  }
+  async listWorktrees(): Promise<Worktree[]> {
+    const result = await this.git.raw(['worktree', 'list', '--porcelain']);
+    const worktrees: Worktree[] = [];
+    const entries = result.trim().split('\n\n').filter(Boolean);
+    for (const entry of entries) {
+      const lines = entry.split('\n');
+      const worktreePath = lines.find((l) => l.startsWith('worktree '))?.replace('worktree ', '');
+      const branchLine = lines.find((l) => l.startsWith('branch '));
+      const branch = branchLine?.replace('branch refs/heads/', '');
+      if (worktreePath) {
+        worktrees.push({
+          path: worktreePath,
+          branch: branch || 'detached',
+          name: path.basename(worktreePath),
+        });
+      }
+    }
+    return worktrees;
+  }
+  async createWorktree(baseBranch: string, index: number): Promise<Worktree> {
+    const worktreeName = `${baseBranch}-project-${index}`;
+    // Create worktree in parent directory of the main repo
+    const worktreePath = path.join(path.dirname(this.rootDir), worktreeName);
+    const newBranchName = worktreeName;
+    // Check if directory already exists
+    try {
+      await fs.access(worktreePath);
+      // Directory exists, try to remove it first
+      await this.removeWorktree(worktreePath);
+    } catch {
+      // Directory doesn't exist, which is good
+    }
+    // Check if branch already exists
+    try {
+      const branches = await this.git.branch();
+      if (branches.all.includes(newBranchName)) {
+        // Branch exists, delete it first
+        await this.git.branch(['-D', newBranchName]);
+      }
+    } catch {
+      // Branch doesn't exist, which is good
+    }
+    // Create worktree with new branch based on the selected branch
+    await this.git.raw(['worktree', 'add', '-b', newBranchName, worktreePath, baseBranch]);
+    this.createdWorktrees.add(worktreePath);
+    return {
+      path: worktreePath,
+      branch: newBranchName,
+      name: worktreeName,
+    };
+  }
+  async createMultipleWorktrees(baseBranch: string, count: number): Promise<Worktree[]> {
+    const worktrees: Worktree[] = [];
+    const createdPaths: string[] = [];
+    try {
+      for (let i = 1; i <= count; i++) {
+        const worktree = await this.createWorktree(baseBranch, i);
+        worktrees.push(worktree);
+        createdPaths.push(worktree.path);
+      }
+      return worktrees;
+    } catch (error) {
+      // Rollback: remove already created worktrees
+      console.error(`Failed to create worktree ${createdPaths.length + 1}, rolling back...`);
+      for (const worktreePath of createdPaths) {
+        try {
+          await this.removeWorktree(worktreePath);
+        } catch (rollbackError) {
+          console.error(`Failed to rollback worktree: ${worktreePath}`, rollbackError);
+        }
+      }
+      throw error;
+    }
+  }
+  async removeWorktree(worktreePath: string): Promise<void> {
+    const branchName = path.basename(worktreePath);
+    try {
+      // 1. Force remove worktree
+      await this.git.raw(['worktree', 'remove', worktreePath, '--force']);
+    } catch {
+      // 2. If worktree remove fails, try to remove directory manually
+      try {
+        await fs.rm(worktreePath, { recursive: true, force: true });
+      } catch {
+        // Ignore errors
+      }
+    }
+    // 3. CRITICAL: Prune orphan worktree references
+    try {
+      await this.git.raw(['worktree', 'prune']);
+    } catch {
+      // Ignore prune errors
+    }
+    // 4. Now we can safely delete the branch
+    try {
+      await this.git.branch(['-D', branchName]);
+    } catch {
+      // Branch deletion failure is acceptable
+    }
+    this.createdWorktrees.delete(worktreePath);
+  }
+  async removeAllWorktrees(): Promise<void> {
+    const worktrees = await this.listWorktrees();
+    // Filter out the main worktree (usually the first one / the main repo)
+    const additionalWorktrees = worktrees.filter(wt => wt.path !== this.rootDir);
+    for (const worktree of additionalWorktrees) {
+      try {
+        await this.removeWorktree(worktree.path);
+      } catch (error) {
+        console.error(`Failed to remove worktree: ${worktree.path}`, error);
+      }
+    }
+  }
+  async cleanup(): Promise<void> {
+    // Remove all worktrees created in this session
+    for (const worktreePath of this.createdWorktrees) {
+      try {
+        await this.removeWorktree(worktreePath);
+      } catch (error) {
+        console.error(`Failed to cleanup worktree: ${worktreePath}`, error);
+      }
+    }
+    this.createdWorktrees.clear();
+  }
+  getCreatedWorktrees(): string[] {
+    return Array.from(this.createdWorktrees);
+  }
+  getRootDir(): string {
+    return this.rootDir;
+  }
+}
+// Singleton instance
+let worktreeServiceInstance: WorktreeService | null = null;
+export function getWorktreeService(cwd?: string): WorktreeService {
+  if (!worktreeServiceInstance || (cwd && worktreeServiceInstance.getRootDir() !== cwd)) {
+    worktreeServiceInstance = new WorktreeService(cwd);
+  }
+  return worktreeServiceInstance;
+}

package/server/socketHandlers.ts ADDED Viewed

@@ -0,0 +1,157 @@
+import { Server, Socket } from 'socket.io';
+import * as pty from 'node-pty';
+import type { IPty } from 'node-pty';
+import type {
+  TerminalCreateData,
+  TerminalInputData,
+  TerminalResizeData,
+  TerminalKillData,
+  AgentId
+} from '../shared/types/index.js';
+import { AI_AGENTS } from '../shared/constants.js';
+interface TerminalSession {
+  pty: IPty;
+  worktreePath: string;
+  agentType: AgentId;
+  socketId: string;
+}
+const sessions = new Map<string, TerminalSession>();
+function getAgentCommand(agentType: AgentId): string {
+  const agent = AI_AGENTS.find(a => a.id === agentType);
+  return agent?.command || 'bash';
+}
+function getShell(): string {
+  return process.platform === 'win32' ? 'powershell.exe' : process.env.SHELL || '/bin/bash';
+}
+export function setupSocketHandlers(io: Server, cwd: string) {
+  io.on('connection', (socket: Socket) => {
+    console.log(`Client connected: ${socket.id}`);
+    // Terminal create
+    socket.on('terminal:create', async (data: TerminalCreateData) => {
+      const { sessionId, worktreePath, agentType } = data;
+      console.log(`Creating terminal session: ${sessionId} at ${worktreePath} with ${agentType}`);
+      try {
+        const shell = getShell();
+        const agentCommand = getAgentCommand(agentType);
+        const ptyProcess = pty.spawn(shell, [], {
+          name: 'xterm-256color',
+          cols: 120,
+          rows: 30,
+          cwd: worktreePath,
+          env: {
+            ...process.env,
+            TERM: 'xterm-256color',
+            FORCE_COLOR: '1',
+            COLORTERM: 'truecolor',
+          } as Record<string, string>,
+        });
+        sessions.set(sessionId, {
+          pty: ptyProcess,
+          worktreePath,
+          agentType,
+          socketId: socket.id,
+        });
+        // Send output to client
+        ptyProcess.onData((output: string) => {
+          socket.emit('terminal:output', { sessionId, data: output });
+        });
+        // Handle PTY exit
+        ptyProcess.onExit(({ exitCode }) => {
+          console.log(`Terminal session ${sessionId} exited with code ${exitCode}`);
+          socket.emit('terminal:exit', { sessionId, exitCode });
+          sessions.delete(sessionId);
+        });
+        // Start the AI agent after a short delay
+        setTimeout(() => {
+          ptyProcess.write(`${agentCommand}\r`);
+        }, 500);
+        socket.emit('terminal:created', { sessionId });
+      } catch (error) {
+        console.error(`Failed to create terminal session: ${sessionId}`, error);
+        socket.emit('terminal:error', {
+          sessionId,
+          error: error instanceof Error ? error.message : 'Unknown error'
+        });
+      }
+    });
+    // Terminal input
+    socket.on('terminal:input', (data: TerminalInputData) => {
+      const { sessionId, data: input } = data;
+      const session = sessions.get(sessionId);
+      if (session) {
+        session.pty.write(input);
+      }
+    });
+    // Terminal resize
+    socket.on('terminal:resize', (data: TerminalResizeData) => {
+      const { sessionId, cols, rows } = data;
+      const session = sessions.get(sessionId);
+      if (session) {
+        session.pty.resize(cols, rows);
+      }
+    });
+    // Terminal kill
+    socket.on('terminal:kill', (data: TerminalKillData) => {
+      const { sessionId } = data;
+      const session = sessions.get(sessionId);
+      if (session) {
+        console.log(`Killing terminal session: ${sessionId}`);
+        session.pty.kill();
+        sessions.delete(sessionId);
+      }
+    });
+    // Broadcast input to all terminals
+    socket.on('terminal:broadcast', (data: { data: string }) => {
+      const socketSessions = Array.from(sessions.entries())
+        .filter(([, session]) => session.socketId === socket.id);
+      for (const [sessionId, session] of socketSessions) {
+        session.pty.write(data.data);
+      }
+    });
+    // Disconnect handling
+    socket.on('disconnect', () => {
+      console.log(`Client disconnected: ${socket.id}`);
+      // Kill all sessions owned by this socket
+      const socketSessions = Array.from(sessions.entries())
+        .filter(([, session]) => session.socketId === socket.id);
+      for (const [sessionId, session] of socketSessions) {
+        console.log(`Killing orphaned terminal session: ${sessionId}`);
+        session.pty.kill();
+        sessions.delete(sessionId);
+      }
+    });
+  });
+}
+export function killAllSessions(): void {
+  for (const [sessionId, session] of sessions) {
+    console.log(`Killing terminal session: ${sessionId}`);
+    session.pty.kill();
+  }
+  sessions.clear();
+}