start-command 0.5.3 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # start-command
 
+## 0.7.0
+
+### Minor Changes
+
+- 9e24fb5: Add --version flag to display comprehensive version and system information. Users can now run `$ --version` or `$ -v` to see the version of start-command, system details, and versions of isolation tools (screen, tmux, docker).
+
+## 0.6.0
+
+### Minor Changes
+
+- 37eb93b: Drop zellij isolation backend support, focusing on screen, tmux, and docker. Remove zellij from VALID_BACKENDS, remove runInZellij function, and update all documentation accordingly.
+
 ## 0.5.3
 
 ### Patch Changes

package/README.md

@@ -141,18 +141,17 @@ $ -i tmux -s my-session -d npm start
 | -------- | -------------------------------------- | ---------------------------------------------------------- |
 | `screen` | GNU Screen terminal multiplexer        | `apt install screen` / `brew install screen`               |
 | `tmux`   | Modern terminal multiplexer            | `apt install tmux` / `brew install tmux`                   |
-| `zellij` | Modern terminal workspace              | `cargo install zellij` / `brew install zellij`             |
 | `docker` | Container isolation (requires --image) | [Docker Installation](https://docs.docker.com/get-docker/) |
 
 #### Isolation Options
 
-| Option           | Description                                      |
-| ---------------- | ------------------------------------------------ |
-| `--isolated, -i` | Isolation backend (screen, tmux, docker, zellij) |
-| `--attached, -a` | Run in attached/foreground mode (default)        |
-| `--detached, -d` | Run in detached/background mode                  |
-| `--session, -s`  | Custom session/container name                    |
-| `--image`        | Docker image (required for docker isolation)     |
+| Option           | Description                                  |
+| ---------------- | -------------------------------------------- |
+| `--isolated, -i` | Isolation backend (screen, tmux, docker)     |
+| `--attached, -a` | Run in attached/foreground mode (default)    |
+| `--detached, -d` | Run in detached/background mode              |
+| `--session, -s`  | Custom session/container name                |
+| `--image`        | Docker image (required for docker isolation) |
 
 **Note:** Using both `--attached` and `--detached` together will result in an error - you must choose one mode.
 

package/REQUIREMENTS.md

@@ -147,7 +147,6 @@ Support two patterns for passing wrapper options:
 
 - `screen`: GNU Screen terminal multiplexer
 - `tmux`: tmux terminal multiplexer
-- `zellij`: Modern terminal workspace
 - `docker`: Docker containers (requires --image option)
 
 #### 6.4 Mode Behavior

package/docs/case-studies/issue-18/README.md

@@ -0,0 +1,343 @@
+# Case Study: Issue #18 - Missing `--version` Option Support
+
+## Executive Summary
+
+This case study documents the investigation, root cause analysis, and resolution of Issue #18, which identified the absence of a `--version` flag in the start-command CLI tool. The issue prevented users from easily determining the version of the tool and its dependencies, which is crucial for debugging and troubleshooting.
+
+## Timeline of Events
+
+### 2025-12-23 12:53:10 UTC - Issue Created
+
+- **Reporter**: @konard
+- **Issue**: [#18 - We need to ensure `start-command --version` option is supported](https://github.com/link-foundation/start/issues/18)
+- **Labels**: bug, enhancement
+
+### Initial Discovery
+
+The user attempted to run `$ --version` expecting version information but instead received unexpected behavior:
+
+```bash
+$ --version
+[2025-12-23 12:51:15.314] Starting: --version
+
+zsh 5.9 (arm64-apple-darwin24.0)
+
+[2025-12-23 12:51:15.322] Finished
+Exit code: 0
+```
+
+The command was interpreted as trying to execute `--version` as a shell command, which fell through to the default shell (`zsh`) and displayed the shell's version instead of the start-command version.
+
+### 2025-12-23 15:59:11 UTC - Issue Updated
+
+The issue was updated with additional context and requirements.
+
+## Problem Analysis
+
+### Root Cause
+
+The `start-command` CLI tool (`src/bin/cli.js`) did not have a dedicated handler for the `--version` or `-v` flags. The argument parser treated any unknown flags as potential commands, leading to:
+
+1. **Unexpected behavior**: `$ --version` executed `--version` as a shell command
+2. **Poor user experience**: No standard way to check the tool version
+3. **Debugging challenges**: Users couldn't easily verify which version they were running
+4. **Missing dependency information**: No visibility into isolation tool versions (screen, tmux, docker)
+
+### Impact Assessment
+
+**Severity**: Medium
+
+- **User Experience**: Users had no standard way to check version information
+- **Debugging**: Troubleshooting was more difficult without version info
+- **Best Practices**: Missing a fundamental CLI feature expected by users
+
+**Affected Components**:
+
+- `src/bin/cli.js` - Main CLI entry point
+- Documentation/Help text
+- CI/CD testing coverage
+
+## Investigation Process
+
+### Analysis Steps
+
+1. **Code Review** (`src/bin/cli.js:48-60`):
+   - Examined argument parsing logic
+   - Identified that only empty arguments triggered usage display
+   - No special handling for `--version` flag
+
+2. **Argument Parser Review** (`src/lib/args-parser.js`):
+   - Confirmed that wrapper options didn't include `--version`
+   - Parser passed unknown flags to command execution
+
+3. **Test Coverage Review**:
+   - Found no existing tests for version display
+   - Identified gap in CLI behavior testing
+
+4. **User Expectation Analysis**:
+   - Standard CLI tools support `--version` and `-v`
+   - Users expect version information for debugging
+   - Version info should include dependencies
+
+## Solution Design
+
+### Requirements
+
+Based on the issue description, the solution needed to:
+
+1. Support both `--version` and `-v` flags
+2. Display start-command version from package.json
+3. Show OS and system information:
+   - OS platform
+   - OS release
+   - Node.js version
+   - Architecture
+4. Display versions of isolation tools:
+   - screen
+   - tmux
+   - docker
+5. Indicate when tools are not installed
+6. Include comprehensive CI tests
+
+### Implementation Strategy
+
+1. **Version Detection** (`src/bin/cli.js:51-55`):
+   - Check for `--version` or `-v` as sole argument
+   - Call dedicated `printVersion()` function
+   - Exit with code 0
+
+2. **Version Information Display** (`src/bin/cli.js:62-106`):
+   - Read version from `package.json`
+   - Use Node.js `os` module for system info
+   - Execute version commands for each tool
+   - Handle missing tools gracefully
+
+3. **Tool Version Helper** (`src/bin/cli.js:108-129`):
+   - Generic function to check tool versions
+   - Timeout protection (5 seconds)
+   - Error handling for missing tools
+   - Return first line of version output
+
+4. **Test Coverage** (`test/cli.test.js`):
+   - Test `--version` flag
+   - Test `-v` shorthand
+   - Verify correct package version
+   - Test basic CLI behavior
+   - Ensure usage text includes `--version`
+
+## Implementation Details
+
+### Code Changes
+
+#### 1. CLI Version Handler
+
+```javascript
+// Handle --version flag
+if (args.length === 1 && (args[0] === '--version' || args[0] === '-v')) {
+  printVersion();
+  process.exit(0);
+}
+```
+
+#### 2. Version Display Function
+
+```javascript
+function printVersion() {
+  // Get package version
+  const packageJson = require('../../package.json');
+  const startCommandVersion = packageJson.version;
+
+  console.log(`start-command version: ${startCommandVersion}`);
+  console.log('');
+
+  // Get OS information
+  console.log(`OS: ${process.platform}`);
+  console.log(`OS Release: ${os.release()}`);
+  console.log(`Node Version: ${process.version}`);
+  console.log(`Architecture: ${process.arch}`);
+  console.log('');
+
+  // Check for installed isolation tools
+  console.log('Isolation tools:');
+
+  const screenVersion = getToolVersion('screen', '--version');
+  if (screenVersion) {
+    console.log(`  screen: ${screenVersion}`);
+  } else {
+    console.log('  screen: not installed');
+  }
+
+  // Similar for tmux and docker...
+}
+```
+
+#### 3. Tool Version Helper
+
+```javascript
+function getToolVersion(toolName, versionFlag) {
+  try {
+    const result = execSync(`${toolName} ${versionFlag}`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+    }).trim();
+
+    const firstLine = result.split('\n')[0];
+    return firstLine;
+  } catch {
+    return null;
+  }
+}
+```
+
+#### 4. Updated Usage Text
+
+```javascript
+console.log('  --version, -v             Show version information');
+```
+
+### Test Implementation
+
+Created `test/cli.test.js` with comprehensive test coverage:
+
+- Version flag tests (both `--version` and `-v`)
+- Package version verification
+- Basic CLI behavior tests
+- Usage text verification
+
+## Verification and Testing
+
+### Test Results
+
+All tests passed successfully:
+
+```
+✓ CLI version flag
+  ✓ should display version with --version
+  ✓ should display version with -v
+  ✓ should show correct package version
+✓ CLI basic behavior
+  ✓ should show usage when no arguments provided
+  ✓ should show usage when no command provided after --
+```
+
+Total: 71 tests passed across all test suites.
+
+### Manual Testing
+
+```bash
+$ bun src/bin/cli.js --version
+start-command version: 0.6.0
+
+OS: linux
+OS Release: 6.8.0-90-generic
+Node Version: v24.3.0
+Architecture: x64
+
+Isolation tools:
+  screen: Screen version 4.09.01 (GNU) 20-Aug-23
+  tmux: tmux 3.4
+  docker: not installed
+```
+
+## Lessons Learned
+
+### What Went Well
+
+1. **Clear Requirements**: Issue description provided specific requirements
+2. **Comprehensive Solution**: Implementation exceeded basic requirements by including dependency versions
+3. **Good Test Coverage**: Tests ensure the feature won't regress
+4. **Defensive Programming**: Tool version detection handles missing tools gracefully
+
+### Areas for Improvement
+
+1. **Earlier Detection**: This fundamental feature should have been included from the start
+2. **Pre-commit Checklist**: Could have caught this during initial development
+3. **User Feedback**: Faster response to user needs
+
+### Best Practices Applied
+
+1. **Version Information Sources**: Used package.json as single source of truth
+2. **Error Handling**: Gracefully handle missing tools with timeout protection
+3. **User Experience**: Clear, well-formatted output
+4. **Testing**: Comprehensive test coverage for new feature
+5. **Documentation**: Updated usage text to include new flag
+
+## Recommendations
+
+### Immediate Actions
+
+1. ✅ Implement `--version` flag support
+2. ✅ Add comprehensive tests
+3. ✅ Update documentation/usage text
+4. ✅ Verify all existing tests pass
+
+### Future Enhancements
+
+1. **Version Comparison**: Add ability to check for updates
+2. **JSON Output**: Support `--version --json` for machine-readable output
+3. **Detailed Mode**: Add `--version --verbose` for more detailed information
+4. **Config Info**: Include configuration file locations and settings
+
+### Process Improvements
+
+1. **Feature Checklist**: Ensure standard CLI features are in initial release:
+   - `--help` / `-h`
+   - `--version` / `-v`
+   - `--verbose` / `-v` (if not conflicting)
+   - Exit codes documentation
+2. **User Testing**: Early beta testing to catch missing features
+3. **CLI Standards**: Follow established CLI conventions
+
+## Conclusion
+
+Issue #18 highlighted the importance of implementing standard CLI features that users expect. The solution not only added the missing `--version` flag but enhanced it to provide comprehensive diagnostic information including OS details and dependency versions.
+
+This case study demonstrates the value of:
+
+- Clear issue reporting with examples
+- Thorough root cause analysis
+- Comprehensive implementation
+- Strong test coverage
+- Documentation of the investigation process
+
+The implementation is now complete and ready for production use, providing users with essential version and diagnostic information for troubleshooting.
+
+## References
+
+- **Issue**: [#18 - We need to ensure `start-command --version` option is supported](https://github.com/link-foundation/start/issues/18)
+- **Pull Request**: [#21 - Implementation of --version flag](https://github.com/link-foundation/start/pull/21)
+- **Related Files**:
+  - `src/bin/cli.js` - Main implementation
+  - `test/cli.test.js` - Test coverage
+  - `package.json` - Version source
+
+## Appendix
+
+### A. Example Output
+
+```bash
+$ $ --version
+start-command version: 0.6.0
+
+OS: linux
+OS Release: 6.8.0-90-generic
+Node Version: v24.3.0
+Architecture: x64
+
+Isolation tools:
+  screen: Screen version 4.09.01 (GNU) 20-Aug-23
+  tmux: tmux 3.4
+  docker: not installed
+```
+
+### B. Test Coverage Summary
+
+- **Total Tests**: 71
+- **New Tests Added**: 5
+- **Pass Rate**: 100%
+- **Coverage Areas**:
+  - Version flag handling
+  - Package version accuracy
+  - CLI basic behavior
+  - Usage text verification

package/docs/case-studies/issue-18/issue-comments.json

@@ -0,0 +1 @@
+[]

package/docs/case-studies/issue-18/issue-data.json

@@ -0,0 +1,7 @@
+{
+  "author": "konard",
+  "body": "```\nonard@MacBook-Pro-Konstantin ~ % --version  \nzsh: command not found: --version\nkonard@MacBook-Pro-Konstantin ~ % $ --version\n[2025-12-23 12:51:15.314] Starting: --version\n\nzsh 5.9 (arm64-apple-darwin24.0)\n\n[2025-12-23 12:51:15.322] Finished\nExit code: 0\nLog saved: /var/folders/cl/831lqjgd58v5mb_m74cfdfcw0000gn/T/start-command-1766494275314-ws2i7w.log\nkonard@MacBook-Pro-Konstantin ~ % $ --version --\nError: No command provided\nUsage: $ [options] [--] \u003ccommand\u003e [args...]\n       $ \u003ccommand\u003e [args...]\n\nOptions:\n  --isolated, -i \u003cenvironment\u003e      Run in isolated environment (screen, tmux, docker, zellij)\n  --attached, -a            Run in attached mode (foreground)\n  --detached, -d            Run in detached mode (background)\n  --session, -s \u003cname\u003e      Session name for isolation\n  --image \u003cimage\u003e           Docker image (required for docker isolation)\n\nExamples:\n  $ echo \"Hello World\"\n  $ npm test\n  $ --isolated tmux -- npm start\n  $ -i screen -d npm start\n  $ --isolated docker --image node:20 -- npm install\n\nFeatures:\n  - Logs all output to temporary directory\n  - Displays timestamps and exit codes\n  - Auto-reports failures for NPM packages (when gh is available)\n  - Natural language command aliases (via substitutions.lino)\n  - Process isolation via screen, tmux, zellij, or docker\n\nAlias examples:\n  $ install lodash npm package           -\u003e npm install lodash\n  $ install 4.17.21 version of lodash npm package -\u003e npm install lodash@4.17.21\n  $ clone https://github.com/user/repo repository -\u003e git clone https://github.com/user/repo\n```\n\nThat should be the root source of debug information.\n\nIt should display version of start-command itself, version of OS, version of screen and docker and tmux (all if installed).\n\nAlso it should be added to CI tests, so never again we will have the problem.\n\nPlease download all logs and data related about the issue to this repository, make sure we compile that data to `./docs/case-studies/issue-{id}` folder, and use it to do deep case study analysis (also make sure to search online for additional facts and data), in which we will reconstruct timeline/sequence of events, find root causes of the problem, and propose possible solutions.",
+  "createdAt": "2025-12-23T12:53:10Z",
+  "title": "We need to ensure `start-command --version` option is supported",
+  "updatedAt": "2025-12-23T15:59:11Z"
+}

package/experiments/isolation-design.md

@@ -10,11 +10,10 @@ This document outlines the design for adding process isolation support to start-
 
 1. **screen** - GNU Screen, classic session manager
 2. **tmux** - Modern terminal multiplexer
-3. **zellij** - Modern, user-friendly multiplexer
 
 ### Container Isolation
 
-4. **docker** - Docker containers
+3. **docker** - Docker containers
 
 ## Command Syntax
 
@@ -31,7 +30,7 @@ $ [wrapper-options] command [command-options]
 ### Wrapper Options
 
 - `--isolated <backend>` or `-i <backend>`: Run command in isolated environment
-  - Backends: `screen`, `tmux`, `docker`, `zellij`
+  - Backends: `screen`, `tmux`, `docker`
 - `--attached` or `-a`: Run in attached mode (foreground)
 - `--detached` or `-d`: Run in detached mode (background)
 - `--session <name>` or `-s <name>`: Name for the session (optional)
@@ -56,7 +55,7 @@ $ -i tmux -d npm start
 
 ### Attached Mode (--attached)
 
-- Default for terminal multiplexers (screen, tmux, zellij)
+- Default for terminal multiplexers (screen, tmux)
 - Command runs in foreground
 - User can interact with the terminal
 - For docker: runs with -it flags
@@ -103,16 +102,6 @@ tmux new-session -s <session> '<command>'
 tmux new-session -d -s <session> '<command>'
 ```
 
-#### Zellij
-
-```bash
-# Attached
-zellij run -- <command>
-
-# Detached (via layout file or action)
-zellij -s <session> action new-pane -- <command>
-```
-
 #### Docker
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.5.3",
+  "version": "0.7.0",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "index.js",
   "bin": {

package/src/bin/cli.js

@@ -48,11 +48,86 @@ const config = {
 // Get all arguments passed after the command
 const args = process.argv.slice(2);
 
+// Handle --version flag
+if (args.length === 1 && (args[0] === '--version' || args[0] === '-v')) {
+  printVersion();
+  process.exit(0);
+}
+
 if (args.length === 0) {
   printUsage();
   process.exit(0);
 }
 
+/**
+ * Print version information
+ */
+function printVersion() {
+  // Get package version
+  const packageJson = require('../../package.json');
+  const startCommandVersion = packageJson.version;
+
+  console.log(`start-command version: ${startCommandVersion}`);
+  console.log('');
+
+  // Get OS information
+  console.log(`OS: ${process.platform}`);
+  console.log(`OS Release: ${os.release()}`);
+  console.log(`Node Version: ${process.version}`);
+  console.log(`Architecture: ${process.arch}`);
+  console.log('');
+
+  // Check for installed isolation tools
+  console.log('Isolation tools:');
+
+  // Check screen
+  const screenVersion = getToolVersion('screen', '--version');
+  if (screenVersion) {
+    console.log(`  screen: ${screenVersion}`);
+  } else {
+    console.log('  screen: not installed');
+  }
+
+  // Check tmux
+  const tmuxVersion = getToolVersion('tmux', '-V');
+  if (tmuxVersion) {
+    console.log(`  tmux: ${tmuxVersion}`);
+  } else {
+    console.log('  tmux: not installed');
+  }
+
+  // Check docker
+  const dockerVersion = getToolVersion('docker', '--version');
+  if (dockerVersion) {
+    console.log(`  docker: ${dockerVersion}`);
+  } else {
+    console.log('  docker: not installed');
+  }
+}
+
+/**
+ * Get version of an installed tool
+ * @param {string} toolName - Name of the tool
+ * @param {string} versionFlag - Flag to get version (e.g., '--version', '-V')
+ * @returns {string|null} Version string or null if not installed
+ */
+function getToolVersion(toolName, versionFlag) {
+  try {
+    const result = execSync(`${toolName} ${versionFlag}`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+    }).trim();
+
+    // Extract version number from output
+    // Most tools output version in various formats, so we'll return the first line
+    const firstLine = result.split('\n')[0];
+    return firstLine;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Print usage information
  */
@@ -62,7 +137,7 @@ function printUsage() {
   console.log('');
   console.log('Options:');
   console.log(
-    '  --isolated, -i <environment>      Run in isolated environment (screen, tmux, docker, zellij)'
+    '  --isolated, -i <environment>      Run in isolated environment (screen, tmux, docker)'
   );
   console.log('  --attached, -a            Run in attached mode (foreground)');
   console.log('  --detached, -d            Run in detached mode (background)');
@@ -70,6 +145,7 @@ function printUsage() {
   console.log(
     '  --image <image>           Docker image (required for docker isolation)'
   );
+  console.log('  --version, -v             Show version information');
   console.log('');
   console.log('Examples:');
   console.log('  $ echo "Hello World"');
@@ -85,7 +161,7 @@ function printUsage() {
     '  - Auto-reports failures for NPM packages (when gh is available)'
   );
   console.log('  - Natural language command aliases (via substitutions.lino)');
-  console.log('  - Process isolation via screen, tmux, zellij, or docker');
+  console.log('  - Process isolation via screen, tmux, or docker');
   console.log('');
   console.log('Alias examples:');
   console.log('  $ install lodash npm package           -> npm install lodash');

package/src/lib/args-parser.js

@@ -6,7 +6,7 @@
  * 2. $ [wrapper-options] command [command-options]
  *
  * Wrapper Options:
- * --isolated, -i <backend>  Run in isolated environment (screen, tmux, docker, zellij)
+ * --isolated, -i <backend>  Run in isolated environment (screen, tmux, docker)
  * --attached, -a            Run in attached mode (foreground)
  * --detached, -d            Run in detached mode (background)
  * --session, -s <name>      Session name for isolation
@@ -20,7 +20,7 @@ const DEBUG =
 /**
  * Valid isolation backends
  */
-const VALID_BACKENDS = ['screen', 'tmux', 'docker', 'zellij'];
+const VALID_BACKENDS = ['screen', 'tmux', 'docker'];
 
 /**
  * Parse command line arguments into wrapper options and command
@@ -29,7 +29,7 @@ const VALID_BACKENDS = ['screen', 'tmux', 'docker', 'zellij'];
  */
 function parseArgs(args) {
   const wrapperOptions = {
-    isolated: null, // Isolation backend: screen, tmux, docker, zellij
+    isolated: null, // Isolation backend: screen, tmux, docker
     attached: false, // Run in attached mode
     detached: false, // Run in detached mode
     session: null, // Session name
@@ -116,7 +116,7 @@ function parseOption(args, index, options) {
       return 2;
     } else {
       throw new Error(
-        `Option ${arg} requires a backend argument (screen, tmux, docker, zellij)`
+        `Option ${arg} requires a backend argument (screen, tmux, docker)`
       );
     }
   }

package/src/lib/isolation.js

@@ -4,7 +4,6 @@
  * Provides execution of commands in various isolated environments:
  * - screen: GNU Screen terminal multiplexer
  * - tmux: tmux terminal multiplexer
- * - zellij: Modern terminal workspace
  * - docker: Docker containers
  */
 
@@ -462,87 +461,6 @@ function runInTmux(command, options = {}) {
   }
 }
 
-/**
- * Run command in Zellij
- * @param {string} command - Command to execute
- * @param {object} options - Options (session, detached)
- * @returns {Promise<{success: boolean, sessionName: string, message: string}>}
- */
-function runInZellij(command, options = {}) {
-  if (!isCommandAvailable('zellij')) {
-    return Promise.resolve({
-      success: false,
-      sessionName: null,
-      message:
-        'zellij is not installed. Install it with: cargo install zellij or brew install zellij (macOS)',
-    });
-  }
-
-  const sessionName = options.session || generateSessionName('zellij');
-  const { shell, shellArg } = getShell();
-
-  try {
-    if (options.detached) {
-      // Detached mode for zellij
-      if (DEBUG) {
-        console.log(`[DEBUG] Creating detached zellij session: ${sessionName}`);
-      }
-
-      // Create the session in background
-      execSync(
-        `zellij -s "${sessionName}" action new-tab -- ${shell} ${shellArg} "${command}" &`,
-        { stdio: 'inherit', shell: true }
-      );
-
-      return Promise.resolve({
-        success: true,
-        sessionName,
-        message: `Command started in detached zellij session: ${sessionName}\nReattach with: zellij attach ${sessionName}`,
-      });
-    } else {
-      // Attached mode: zellij -s <session> -- <shell> -c <command>
-      if (DEBUG) {
-        console.log(
-          `[DEBUG] Running: zellij -s "${sessionName}" -- ${shell} ${shellArg} "${command}"`
-        );
-      }
-
-      return new Promise((resolve) => {
-        const child = spawn(
-          'zellij',
-          ['-s', sessionName, '--', shell, shellArg, command],
-          {
-            stdio: 'inherit',
-          }
-        );
-
-        child.on('exit', (code) => {
-          resolve({
-            success: code === 0,
-            sessionName,
-            message: `Zellij session "${sessionName}" exited with code ${code}`,
-            exitCode: code,
-          });
-        });
-
-        child.on('error', (err) => {
-          resolve({
-            success: false,
-            sessionName,
-            message: `Failed to start zellij: ${err.message}`,
-          });
-        });
-      });
-    }
-  } catch (err) {
-    return Promise.resolve({
-      success: false,
-      sessionName,
-      message: `Failed to run in zellij: ${err.message}`,
-    });
-  }
-}
-
 /**
  * Run command in Docker container
  * @param {string} command - Command to execute
@@ -649,7 +567,7 @@ function runInDocker(command, options = {}) {
 
 /**
  * Run command in the specified isolation backend
- * @param {string} backend - Isolation backend (screen, tmux, docker, zellij)
+ * @param {string} backend - Isolation backend (screen, tmux, docker)
  * @param {string} command - Command to execute
  * @param {object} options - Options
  * @returns {Promise<{success: boolean, message: string}>}
@@ -660,8 +578,6 @@ function runIsolated(backend, command, options = {}) {
       return runInScreen(command, options);
     case 'tmux':
       return runInTmux(command, options);
-    case 'zellij':
-      return runInZellij(command, options);
     case 'docker':
       return runInDocker(command, options);
     default:
@@ -780,7 +696,6 @@ module.exports = {
   hasTTY,
   runInScreen,
   runInTmux,
-  runInZellij,
   runInDocker,
   runIsolated,
   // Export logging utilities for unified experience

package/test/args-parser.test.js

@@ -382,8 +382,4 @@ describe('VALID_BACKENDS', () => {
   it('should include docker', () => {
     assert.ok(VALID_BACKENDS.includes('docker'));
   });
-
-  it('should include zellij', () => {
-    assert.ok(VALID_BACKENDS.includes('zellij'));
-  });
 });

package/test/cli.test.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env bun
+/**
+ * Unit tests for the CLI
+ * Tests version flag and basic CLI behavior
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Path to the CLI script
+const CLI_PATH = path.join(__dirname, '../src/bin/cli.js');
+
+// Helper to run CLI
+function runCLI(args = []) {
+  return spawnSync('bun', [CLI_PATH, ...args], {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      START_DISABLE_AUTO_ISSUE: '1',
+      START_DISABLE_LOG_UPLOAD: '1',
+    },
+  });
+}
+
+describe('CLI version flag', () => {
+  it('should display version with --version', () => {
+    const result = runCLI(['--version']);
+
+    assert.strictEqual(result.status, 0, 'Exit code should be 0');
+
+    // Check for key elements in version output
+    assert.ok(
+      result.stdout.includes('start-command version:'),
+      'Should display start-command version'
+    );
+    assert.ok(result.stdout.includes('OS:'), 'Should display OS');
+    assert.ok(
+      result.stdout.includes('OS Release:'),
+      'Should display OS Release'
+    );
+    assert.ok(
+      result.stdout.includes('Node Version:'),
+      'Should display Node Version'
+    );
+    assert.ok(
+      result.stdout.includes('Architecture:'),
+      'Should display Architecture'
+    );
+    assert.ok(
+      result.stdout.includes('Isolation tools:'),
+      'Should display Isolation tools section'
+    );
+    assert.ok(
+      result.stdout.includes('screen:'),
+      'Should check for screen installation'
+    );
+    assert.ok(
+      result.stdout.includes('tmux:'),
+      'Should check for tmux installation'
+    );
+    assert.ok(
+      result.stdout.includes('docker:'),
+      'Should check for docker installation'
+    );
+  });
+
+  it('should display version with -v', () => {
+    const result = runCLI(['-v']);
+
+    assert.strictEqual(result.status, 0, 'Exit code should be 0');
+    assert.ok(
+      result.stdout.includes('start-command version:'),
+      'Should display start-command version'
+    );
+  });
+
+  it('should show correct package version', () => {
+    const result = runCLI(['--version']);
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8')
+    );
+
+    assert.ok(
+      result.stdout.includes(`start-command version: ${packageJson.version}`),
+      `Should display version ${packageJson.version}`
+    );
+  });
+});
+
+describe('CLI basic behavior', () => {
+  it('should show usage when no arguments provided', () => {
+    const result = runCLI([]);
+
+    assert.strictEqual(result.status, 0, 'Exit code should be 0');
+    assert.ok(result.stdout.includes('Usage:'), 'Should display usage');
+    assert.ok(
+      result.stdout.includes('--version'),
+      'Usage should mention --version flag'
+    );
+  });
+
+  it('should show usage when no command provided after --', () => {
+    const result = runCLI(['--']);
+
+    assert.strictEqual(result.status, 0, 'Exit code should be 0');
+    assert.ok(result.stdout.includes('Usage:'), 'Should display usage');
+  });
+});

package/test/isolation.test.js

@@ -76,12 +76,6 @@ describe('Isolation Module', () => {
       console.log(`  docker available: ${result}`);
       assert.ok(typeof result === 'boolean');
     });
-
-    it('should check if zellij is available', () => {
-      const result = isCommandAvailable('zellij');
-      console.log(`  zellij available: ${result}`);
-      assert.ok(typeof result === 'boolean');
-    });
   });
 
   describe('getScreenVersion', () => {
@@ -178,7 +172,6 @@ describe('Isolation Runner Error Handling', () => {
     runInScreen,
     runInTmux,
     runInDocker,
-    runInZellij,
   } = require('../src/lib/isolation');
 
   describe('runInScreen', () => {
@@ -248,23 +241,6 @@ describe('Isolation Runner Error Handling', () => {
       );
     });
   });
-
-  describe('runInZellij', () => {
-    it('should return informative error if zellij is not installed', async () => {
-      // Skip if zellij is installed
-      if (isCommandAvailable('zellij')) {
-        console.log('  Skipping: zellij is installed');
-        return;
-      }
-
-      const result = await runInZellij('echo test', { detached: true });
-      assert.strictEqual(result.success, false);
-      assert.ok(result.message.includes('zellij is not installed'));
-      assert.ok(
-        result.message.includes('cargo') || result.message.includes('brew')
-      );
-    });
-  });
 });
 
 describe('Isolation Runner with Available Backends', () => {