relay-ide 0.1.0

package/README.md

@@ -0,0 +1,259 @@
+# relay-ide
+
+Control Claude Code from your phone or any browser — manage multiple terminal sessions across repos and worktrees with a mobile-friendly web UI.
+
+## Prerequisites
+
+| Dependency                                                            | Why                                                                              |
+| --------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| **[Node.js 24+](https://nodejs.org/)**                                | Runtime for the server                                                           |
+| **[Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)** | Default coding agent — must be in your `PATH`                                    |
+| **[Codex CLI](https://github.com/openai/codex)**                      | _Optional_ — alternative coding agent. Install if you want to use Codex sessions |
+| **[GitHub CLI (`gh`)](https://cli.github.com/)**                      | _Optional_ — required for the **PRs tab**. Run `gh auth login` after installing. |
+
+## Getting Started
+
+### 1. Install
+
+```bash
+npm install -g relay-ide
+```
+
+### 2. Start the server
+
+```bash
+relay-ide --bg
+```
+
+This installs a persistent background service (launchd on macOS, systemd on Linux) that starts on login and restarts on crash. See [Background Service](#background-service) for more options.
+
+Or run in the foreground:
+
+```bash
+relay-ide
+```
+
+### 3. Set your PIN
+
+Open `http://localhost:3456` in your browser. On first visit you'll be prompted to create a PIN that protects access to your Claude sessions.
+
+If you started the server in the foreground, you can set the PIN in the terminal instead.
+
+### 4. Add your project directories
+
+Click **Settings** in the app to add root directories — these are parent folders that contain your git repos (scanned one level deep).
+
+You can also edit `~/.config/relay-ide/config.json` directly:
+
+```json
+{
+  "rootDirs": ["/home/you/projects", "/home/you/work"]
+}
+```
+
+### 5. Access from your phone
+
+Relay IDE binds to `0.0.0.0` by default, but you should **not** expose it to the public internet. Use [Tailscale](https://tailscale.com/) for a private encrypted connection between your devices — see [Remote Access](#remote-access) below.
+
+## Remote Access
+
+The recommended way to access Relay IDE from another device (phone, tablet, laptop) is [Tailscale](https://tailscale.com/), which creates a private encrypted network using WireGuard.
+
+1. **Install Tailscale** on your computer and on your phone/tablet
+   - macOS: `brew install tailscale` or download from [tailscale.com/download](https://tailscale.com/download)
+   - Linux: follow the [install guide](https://tailscale.com/download/linux)
+   - iOS/Android: install the Tailscale app from your app store
+
+2. **Sign in** to the same Tailscale account on both devices
+
+3. **Find your computer's Tailscale IP** — run `tailscale ip` or check the admin console (looks like `100.x.y.z`)
+
+4. **Open the app** on your phone at `http://100.x.y.z:3456`
+
+Your traffic is encrypted end-to-end, no ports are exposed to the internet, and only devices on your Tailscale network can reach the server.
+
+> **Alternatives:** [Cloudflare Tunnel](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) or [ngrok](https://ngrok.com/) also work, but they expose your server to the public internet and rely on the PIN as your only defense.
+
+## Platform Support
+
+Tested on **macOS** and **Linux**. Windows is not currently tested — file watching and PTY spawning may behave differently.
+
+## CLI Usage
+
+```
+Usage: relay-ide [options]
+       relay-ide <command>
+
+Commands:
+  update             Update to the latest version from npm
+  install            Install as a background service (survives reboot)
+  uninstall          Stop and remove the background service
+  status             Show whether the service is running
+  worktree           Manage git worktrees (wraps git worktree)
+    add [path] [-b branch] [--yolo]   Create worktree and launch Claude
+    remove <path>                      Forward to git worktree remove
+    list                               Forward to git worktree list
+  pin                Manage authentication PIN
+    reset              Reset the PIN (interactive, requires TTY)
+
+Options:
+  --bg               Shortcut: install and start as background service
+  --port <port>      Override server port (default: 3456)
+  --host <host>      Override bind address (default: 0.0.0.0)
+  --config <path>    Path to config.json (default: ~/.config/relay-ide/config.json)
+  --yolo             With 'worktree add': pass --dangerously-skip-permissions to Claude
+  --version, -v      Show version
+  --help, -h         Show this help
+```
+
+## Background Service
+
+Run as a persistent service that starts on login and restarts on crash:
+
+```bash
+relay-ide --bg
+```
+
+Or with custom options:
+
+```bash
+relay-ide install --port 4000
+```
+
+Manage the service:
+
+```bash
+relay-ide status      # Check if running
+relay-ide uninstall   # Stop and remove
+```
+
+- **macOS**: Uses launchd (`~/Library/LaunchAgents/`)
+- **Linux**: Uses systemd user units (`~/.config/systemd/user/`)
+- **Logs (macOS)**: `~/.config/relay-ide/logs/`
+- **Logs (Linux)**: `journalctl --user -u relay-ide -f`
+
+## Configuration
+
+Config is stored at `~/.config/relay-ide/config.json` (created on first run).
+
+When running from source, it uses `./config.json` in the project root instead.
+
+| Field           | Default   | Description                                                    |
+| --------------- | --------- | -------------------------------------------------------------- |
+| `host`          | `0.0.0.0` | Bind address                                                   |
+| `port`          | `3456`    | Server port                                                    |
+| `cookieTTL`     | `24h`     | Auth cookie lifetime (e.g. `30m`, `12h`, `7d`)                 |
+| `rootDirs`      | `[]`      | Directories containing your git repos (scanned one level deep) |
+| `claudeCommand` | `claude`  | Path to the Claude Code CLI binary                             |
+| `claudeArgs`    | `[]`      | Extra arguments passed to every session                        |
+| `defaultAgent`  | `claude`  | Default coding agent CLI (`claude` or `codex`)                 |
+
+Root directories can also be managed from the **Settings** button in the app.
+
+### PIN Management
+
+The PIN hash is stored in config under `pinHash`.
+
+**Reset via CLI** (recommended):
+
+```bash
+relay-ide pin reset
+```
+
+This requires an interactive terminal. You'll be asked to verify your current PIN (if set), then enter a new one.
+
+**Reset manually:**
+
+1. Delete the `pinHash` field from `~/.config/relay-ide/config.json`
+2. Restart the server (`relay-ide uninstall && relay-ide --bg`)
+3. Open the web UI and set a new PIN
+
+## Features
+
+### Session Management
+
+- **Multi-agent support** — choose between Claude Code and Codex as the coding agent per session, with a configurable default in Settings
+- **Repo sessions** — click any idle repo to instantly open Claude with `--continue` (no dialog), or start fresh from the new-session dialog
+- **Branch-aware worktrees** — create worktrees from new or existing branches with a type-to-search branch picker
+- **Worktree isolation** — each worktree session runs in its own git worktree under `.worktrees/`
+- **Resume sessions** — click inactive worktrees to reconnect with `--continue`
+- **Persistent session names** — display names, branch names, and timestamps survive server restarts
+- **Scrollback buffer** — reconnect to a session and see prior output
+- **Yolo mode** — skip permission prompts with `--dangerously-skip-permissions` (per-session pill button)
+- **Worktree cleanup** — delete inactive worktrees via the trash pill button (removes worktree, prunes refs, deletes branch)
+
+### Pull Requests
+
+- **Pull requests tab** — view your open PRs (authored and review-requested) via `gh` CLI, organized in collapsible per-repo groups with count badges, Author/Reviewer filter, and one-click session creation from any PR branch
+
+### GitHub Webhooks (real-time PR / CI updates)
+
+By default the app polls GitHub every 30 seconds for PR and CI status. Connect a webhook for instant updates instead:
+
+1. **Connect GitHub** — open **Settings → Integrations → GitHub** and authorise the OAuth App. This requests the `repo` and `admin:repo_hook` scopes so the app can manage webhooks on your behalf.
+2. **Set up webhooks** — open **Settings → Integrations → Webhooks**. Click **Setup Webhook** next to any repo. The app creates a GitHub webhook pointing at a [smee.io](https://smee.io/) proxy channel and starts a local smee client to relay events.
+3. **Verify** — the webhook panel shows a health indicator (last event timestamp). Once connected, polling stops for that repo and updates arrive in real time.
+
+> No public server is required. The smee.io proxy forwards GitHub webhook payloads to your local instance over a persistent SSE connection.
+
+### UI
+
+- **Tabbed sidebar** — switch between Repos, Worktrees, and PRs views with shared filters and item counts
+- **Sidebar filters** — filter by root directory, repo, or text search
+- **Inline actions** — pill buttons on session cards for rename, YOLO, worktree creation, and delete (hover on desktop, long-press on mobile)
+- **Resizable sidebar** — drag the sidebar edge to resize; collapse/expand with a button (persisted to localStorage)
+- **Responsive layout** — works on desktop and mobile with slide-out sidebar
+- **Touch toolbar** — mobile-friendly buttons for special keys (hidden on desktop)
+- **Clipboard image paste** — paste screenshots directly into remote terminal sessions (macOS clipboard + xclip on Linux)
+
+### Settings
+
+- **Full-screen Settings dialog** — redesigned as a scrollable full-screen modal with a table-of-contents drawer for quick section navigation
+- **GitHub integration** — connect via OAuth App (Device Flow) for PR data, CI status, and webhook management
+- **Webhook management** — self-service webhook CRUD per repo with smee.io proxy, health state, and auto-provision backfill
+- **Jira integration** — connect Jira and configure project mappings for the org dashboard tickets panel
+
+### Operations
+
+- **PIN-protected access** with rate limiting
+- **Real-time updates** — worktree changes on disk are pushed to the browser instantly via WebSocket
+- **Smart polling** — falls back to 30-second polling for repos without webhooks; switches off automatically once a webhook is active
+- **Update notifications** — toast notification when a new version is available, with one-click update
+- **CLI self-update** — `relay-ide update` to update from npm
+
+## Architecture
+
+TypeScript + ESM backend (Express + node-pty + WebSocket) compiled to `dist/`. Svelte 5 frontend (runes + Vite) compiled to `dist/frontend/`.
+
+```
+relay-ide/
+├── bin/
+│   └── relay-ide.ts  # CLI entry point
+├── server/
+│   ├── index.ts        # Express server, REST API routes
+│   ├── sessions.ts     # PTY session manager (node-pty)
+│   ├── ws.ts           # WebSocket relay (PTY ↔ browser)
+│   ├── watcher.ts      # File watcher for .worktrees/ changes
+│   ├── auth.ts         # PIN hashing, verification, rate limiting
+│   ├── config.ts       # Config loading/saving, worktree metadata
+│   ├── clipboard.ts    # System clipboard operations (image paste)
+│   ├── service.ts      # Background service management (launchd/systemd)
+│   └── types.ts        # Shared TypeScript interfaces
+├── frontend/
+│   └── src/
+│       ├── components/  # Svelte 5 components (Sidebar, Terminal, SessionList, etc.)
+│       ├── lib/state/   # Reactive state modules (.svelte.ts)
+│       ├── lib/api.ts   # REST API client
+│       ├── lib/ws.ts    # WebSocket connection management
+│       ├── lib/types.ts # Frontend TypeScript interfaces
+│       ├── lib/utils.ts # Shared utilities (path display, time formatting, device detection)
+│       └── lib/actions.ts # Svelte actions (scroll-on-hover, longpress-click)
+├── test/               # Unit tests (node:test)
+├── dist/               # Compiled output (gitignored)
+├── config.example.json
+└── package.json
+```
+
+## License
+
+MIT

package/dist/bin/claude-remote-cli.js

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+/* eslint-disable no-console -- CLI entry point, user-facing stdout/stderr output */
+import path from 'node:path';
+import fs from 'node:fs';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import * as service from '../server/service.js';
+import { DEFAULTS } from '../server/config.js';
+import { createLogger } from '../server/logger.js';
+const execFileAsync = promisify(execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const logger = createLogger('cli');
+function execErrorMessage(err, fallback) {
+    const e = err;
+    return (e.stderr || e.message || fallback).trimEnd();
+}
+// Parse CLI flags
+const args = process.argv.slice(2);
+if (args.includes('--help') || args.includes('-h')) {
+    logger.info(`Usage: claude-remote-cli [options]
+       claude-remote-cli <command>
+
+Commands:
+  update             Update to the latest version from npm
+  install            Install as a background service (survives reboot)
+  uninstall          Stop and remove the background service
+  status             Show whether the service is running
+  worktree           Manage git worktrees (wraps git worktree)
+    add [path] [-b branch] [--yolo]   Create worktree and launch Claude
+    remove <path>                      Forward to git worktree remove
+    list                               Forward to git worktree list
+  browser            Open an HTML file in the remote viewer
+    <path>             Path to HTML file
+  pin                Manage authentication PIN
+    reset              Reset the PIN (interactive, requires TTY)
+
+Options:
+  --bg               Shortcut: install and start as background service
+  --port <port>      Override server port (default: 3456)
+  --host <host>      Override bind address (default: 0.0.0.0)
+  --config <path>    Path to config.json (default: ~/.config/claude-remote-cli/config.json)
+  --debug-log        Enable SDK event debug logging to ~/.config/claude-remote-cli/debug/
+  --yolo             With 'worktree add': pass --dangerously-skip-permissions to Claude
+  --version, -v      Show version
+  --help, -h         Show this help`);
+    process.exit(0);
+}
+if (args.includes('--version') || args.includes('-v')) {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+    console.log(pkg.version);
+    process.exit(0);
+}
+function getArg(flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
+function resolveConfigPath() {
+    const explicit = getArg('--config');
+    if (explicit)
+        return explicit;
+    return path.join(service.CONFIG_DIR, 'config.json');
+}
+function runServiceCommand(fn) {
+    try {
+        fn();
+    }
+    catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+const command = args[0];
+if (command === 'update') {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+        logger.info(`Current version: ${pkg.version}`);
+        const configPath = resolveConfigPath();
+        let channel = 'stable';
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (config.updateChannel === 'nightly' ||
+                config.updateChannel === 'stable') {
+                channel = config.updateChannel;
+            }
+        }
+        const tag = channel === 'nightly' ? 'nightly' : 'latest';
+        logger.info(`Updating claude-remote-cli from ${channel} channel...`);
+        await execFileAsync('npm', ['install', '-g', `claude-remote-cli@${tag}`]);
+        const updatedPkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+        if (updatedPkg.version === pkg.version) {
+            logger.info(`Already on the latest version (${pkg.version}).`);
+        }
+        else {
+            logger.info(`Updated to ${updatedPkg.version}.`);
+            if (service.isInstalled()) {
+                logger.info('Background service detected — restarting...');
+                service.uninstall();
+                service.install({
+                    configPath: resolveConfigPath(),
+                    port: getArg('--port') ?? String(DEFAULTS.port),
+                    host: getArg('--host') ?? DEFAULTS.host,
+                });
+                logger.info('Service restarted.');
+            }
+        }
+    }
+    catch (e) {
+        logger.error(`Update failed: ${e.message}`);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+if (command === 'worktree') {
+    const wtArgs = args.slice(1);
+    const subCommand = wtArgs[0];
+    if (!subCommand) {
+        logger.error('Usage: claude-remote-cli worktree <add|remove|list> [options]');
+        process.exit(1);
+    }
+    if (subCommand !== 'add') {
+        try {
+            const result = await execFileAsync('git', ['worktree', ...wtArgs]);
+            if (result.stdout)
+                console.log(result.stdout.trimEnd());
+        }
+        catch (err) {
+            logger.error(execErrorMessage(err, 'git worktree failed'));
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    // Handle 'add' -- strip --yolo, determine path, forward to git, then launch claude
+    const hasYolo = wtArgs.includes('--yolo');
+    const gitWtArgs = wtArgs.filter(function (a) {
+        return a !== '--yolo';
+    });
+    const addSubArgs = gitWtArgs.slice(1);
+    let targetDir;
+    const bIdx = gitWtArgs.indexOf('-b');
+    const branchForDefault = bIdx !== -1 && bIdx + 1 < gitWtArgs.length
+        ? gitWtArgs[bIdx + 1]
+        : undefined;
+    if (addSubArgs.length === 0 || addSubArgs[0].startsWith('-')) {
+        let repoRoot;
+        try {
+            const result = await execFileAsync('git', [
+                'rev-parse',
+                '--show-toplevel',
+            ]);
+            repoRoot = result.stdout.trim();
+        }
+        catch {
+            logger.error('Not inside a git repository.');
+            process.exit(1);
+        }
+        const dirName = branchForDefault
+            ? branchForDefault.replace(/\//g, '-')
+            : 'worktree-' + Date.now().toString(36);
+        targetDir = path.join(repoRoot, '.worktrees', dirName);
+        gitWtArgs.splice(1, 0, targetDir);
+    }
+    else {
+        targetDir = path.resolve(addSubArgs[0]);
+    }
+    try {
+        const result = await execFileAsync('git', ['worktree', ...gitWtArgs]);
+        if (result.stdout)
+            console.log(result.stdout.trimEnd());
+    }
+    catch (err) {
+        logger.error(execErrorMessage(err, 'git worktree add failed'));
+        process.exit(1);
+    }
+    logger.info(`Worktree created at ${targetDir}`);
+    const claudeArgs = [];
+    if (hasYolo)
+        claudeArgs.push('--dangerously-skip-permissions');
+    logger.info(`Launching claude${hasYolo ? ' (yolo mode)' : ''} in ${targetDir}...`);
+    const child = spawn('claude', claudeArgs, {
+        cwd: targetDir,
+        stdio: 'inherit',
+        env: { ...process.env, CLAUDECODE: undefined },
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 0);
+    });
+    // Block until child exits via the handler above
+    await new Promise(() => { });
+}
+if (command === 'pin') {
+    const subCommand = args[1];
+    if (subCommand !== 'reset') {
+        logger.error('Usage: claude-remote-cli pin reset');
+        process.exit(1);
+    }
+    if (!process.stdin.isTTY) {
+        logger.error('PIN reset requires an interactive terminal.');
+        process.exit(1);
+    }
+    const configPath = resolveConfigPath();
+    if (!fs.existsSync(configPath)) {
+        logger.error('No config file found. Run claude-remote-cli first to create one.');
+        process.exit(1);
+    }
+    const { loadConfig: loadCfg, saveConfig: saveCfg } = await import('../server/config.js');
+    const { hashPin, verifyPin } = await import('../server/auth.js');
+    const config = loadCfg(configPath);
+    const readline = await import('node:readline');
+    function prompt(query, hidden = false) {
+        return new Promise((resolve) => {
+            if (hidden) {
+                process.stdout.write(query);
+                const stdin = process.stdin;
+                const wasRaw = stdin.isRaw;
+                if (stdin.setRawMode)
+                    stdin.setRawMode(true);
+                let value = '';
+                const onData = (ch) => {
+                    const c = ch.toString('utf8');
+                    if (c === '\n' || c === '\r') {
+                        if (stdin.setRawMode)
+                            stdin.setRawMode(wasRaw ?? false);
+                        stdin.removeListener('data', onData);
+                        process.stdout.write('\n');
+                        resolve(value);
+                    }
+                    else if (c === '\u007f' || c === '\b') {
+                        if (value.length > 0) {
+                            value = value.slice(0, -1);
+                            process.stdout.write('\b \b');
+                        }
+                    }
+                    else if (c >= ' ') {
+                        value += c;
+                        process.stdout.write('*');
+                    }
+                };
+                stdin.on('data', onData);
+            }
+            else {
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                rl.question(query, (answer) => {
+                    rl.close();
+                    resolve(answer);
+                });
+            }
+        });
+    }
+    // If PIN exists, optionally verify current PIN.
+    // Skipping is intentional: local shell access is proof of ownership
+    // (the user could edit the config file directly to delete pinHash).
+    if (config.pinHash) {
+        const current = await prompt('Current PIN (press Enter to skip): ', true);
+        if (current) {
+            const valid = await verifyPin(current, config.pinHash);
+            if (!valid) {
+                logger.error('Current PIN is incorrect.');
+                process.exit(1);
+            }
+        }
+    }
+    const newPin = await prompt('New PIN: ', true);
+    if (!newPin || newPin.length < 4) {
+        logger.error('PIN must be at least 4 characters.');
+        process.exit(1);
+    }
+    const confirmPin = await prompt('Confirm new PIN: ', true);
+    if (newPin !== confirmPin) {
+        logger.error('PINs do not match.');
+        process.exit(1);
+    }
+    config.pinHash = await hashPin(newPin);
+    saveCfg(configPath, config);
+    logger.info('PIN updated successfully. All existing sessions will need to re-authenticate.');
+    process.exit(0);
+}
+if (command === 'install' ||
+    command === 'uninstall' ||
+    command === 'status' ||
+    args.includes('--bg')) {
+    if (command === 'uninstall') {
+        runServiceCommand(() => {
+            service.uninstall();
+        });
+    }
+    else if (command === 'status') {
+        runServiceCommand(() => {
+            const st = service.status();
+            if (!st.installed) {
+                logger.info('Service is not installed.');
+            }
+            else if (st.running) {
+                logger.info('Service is installed and running.');
+            }
+            else {
+                logger.info('Service is installed but not running.');
+            }
+        });
+    }
+    else {
+        runServiceCommand(() => {
+            service.install({
+                configPath: resolveConfigPath(),
+                port: getArg('--port') ?? String(DEFAULTS.port),
+                host: getArg('--host') ?? DEFAULTS.host,
+            });
+        });
+    }
+}
+if (command === 'browser') {
+    const browserArgs = args.slice(1);
+    if (browserArgs.includes('--help') ||
+        browserArgs.includes('-h') ||
+        browserArgs.length === 0) {
+        logger.error(`Usage: claude-remote-cli browser <path>
+
+Opens an HTML file in the remote browser viewer tab.
+
+Arguments:
+  <path>    Path to HTML file (absolute or relative)
+
+Environment:
+  CLAUDE_REMOTE_PORT            Server port (default: 3456)
+  CLAUDE_REMOTE_BROWSER_TOKEN   Auth token for browser tab API`);
+        process.exit(browserArgs.includes('--help') || browserArgs.includes('-h') ? 0 : 1);
+    }
+    const filePath = path.resolve(browserArgs[0]);
+    if (!fs.existsSync(filePath)) {
+        logger.error(`Error: file not found: ${filePath}`);
+        process.exit(1);
+    }
+    const port = process.env['CLAUDE_REMOTE_PORT'] ?? String(DEFAULTS.port);
+    const token = process.env['CLAUDE_REMOTE_BROWSER_TOKEN'] ?? '';
+    if (!token) {
+        logger.error('Error: CLAUDE_REMOTE_BROWSER_TOKEN not set. Are you running inside a claude-remote-cli session?');
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/browser-tabs`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ path: filePath }),
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            logger.error(`Error: server returned ${res.status}: ${body}`);
+            process.exit(1);
+        }
+        const data = (await res.json());
+        if (data.refreshed) {
+            logger.info(`Refreshed: ${filePath}`);
+        }
+        else {
+            logger.info(`Opened: ${filePath}`);
+        }
+        process.exit(0);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.error(`Error: could not connect to server on port ${port}: ${msg}`);
+        process.exit(1);
+    }
+}
+const configPath = resolveConfigPath();
+const configDir = path.dirname(configPath);
+// Ensure config directory exists
+if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+}
+// Pass config path and CLI overrides to the server
+process.env['CLAUDE_REMOTE_CONFIG'] = configPath;
+const portArg = getArg('--port');
+if (portArg !== undefined)
+    process.env['CLAUDE_REMOTE_PORT'] = portArg;
+const hostArg = getArg('--host');
+if (hostArg !== undefined)
+    process.env['CLAUDE_REMOTE_HOST'] = hostArg;
+if (args.includes('--debug-log'))
+    process.env['CLAUDE_REMOTE_DEBUG_LOG'] = '1';
+await import('../server/index.js');