clideck 1.22.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Or Kuntzman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# CliDeck
+
+One screen for all your AI coding agents.
+
+![CliDeck dashboard](assets/clideck-themes.jpg)
+
+You're running Claude Code, Codex, and Gemini CLI in separate terminals. You switch between them constantly, forget which one finished, and lose sessions when you close the lid. CliDeck puts them all on one screen with live status, so you always know what's happening.
+
+CliDeck is a local dashboard that runs all your CLI agents in one browser tab. It tracks which agents are working, which are idle, and notifies you when they need attention. Everything runs on your machine — nothing leaves localhost.
+
+## Quick Start
+
+```bash
+npm install -g clideck
+clideck
+```
+
+Open [http://localhost:4000](http://localhost:4000). Click **+**, pick an agent, start working.
+
+Or run directly without installing:
+
+```bash
+npx clideck
+```
+
+## What You Get
+
+- **Live status** — see which agents are working and which are done, without checking each terminal
+- **Session resume** — close CliDeck, reopen it tomorrow, resume your Claude Code conversation where you left off
+- **Notifications** — browser and sound alerts the moment an agent finishes or needs input
+- **Message previews** — latest output from each agent, right in the sidebar
+- **Projects** — group sessions by project with drag-and-drop
+- **Search** — find any session by name or scroll back through transcript content
+- **Prompt Library** — save reusable prompts and paste them into any terminal by typing `//`
+- **Plugins** — ships with Voice Input and Trim Clip. Build your own with the plugin API
+- **15 themes** — dark and light built-in, plus custom theme support
+- **Zero interference** — native PTY terminals, your keystrokes go straight to the agent, nothing in between
+
+## Supported Agents
+
+CliDeck auto-detects whether each agent is working or idle:
+
+| Agent | Status detection | Setup |
+|-------|-----------------|-------|
+| **Claude Code** | Automatic | Nothing to configure |
+| **Codex** | Automatic | One-click setup in CliDeck |
+| **Gemini CLI** | Automatic | One-click setup in CliDeck |
+| **OpenCode** | Via plugin bridge | One-click setup in CliDeck |
+| **Shell** | I/O activity only | None |
+
+Claude Code works out of the box. Other agents need a one-time configuration that CliDeck walks you through.
+
+## How It Works
+
+Each agent runs in a native terminal (PTY). CliDeck receives lightweight status signals from agents via OpenTelemetry — it sees *that* an agent is working, not *what* it's working on. Your prompts and responses are never read or stored by CliDeck.
+
+OpenTelemetry runs locally between the agent and CliDeck. No data is collected, transmitted, or stored outside your machine.
+
+## Prompt Library
+
+Save prompts you use often and paste them into any terminal session instantly. Open the Prompts panel from the sidebar, click **+** to add a prompt with a name and text.
+
+To use a prompt, type `//` in any terminal — an autocomplete dropdown appears. Type a few letters to filter, arrow keys to navigate, Enter to paste. The prompt text is sent directly to the active terminal.
+
+## Platform Support
+
+Tested on **macOS** and **Windows**. Works in any modern browser. Linux: untested — if you try it, open an issue and let me know.
+
+## Documentation
+
+Full setup guides, agent configuration, and plugin development:
+
+**[Documentation](https://clideck.dev/)**
+
+## License
+
+MIT

package/activity.js

@@ -0,0 +1,56 @@
+// Per-session I/O tracking and burst detection.
+// Broadcasts rate + burst data so the frontend can derive working/idle status.
+
+let interval = null;
+const net = {};    // id → byte counters
+const stream = {}; // id → burst timing
+
+function ensure(id) {
+  if (!net[id]) net[id] = { in: 0, out: 0, prevIn: 0, prevOut: 0 };
+  if (!stream[id]) stream[id] = { lastOutAt: 0, burstStart: 0 };
+}
+
+function trackIn(id, bytes) {
+  ensure(id);
+  net[id].in += bytes;
+}
+
+function trackOut(id, data) {
+  ensure(id);
+  const now = Date.now();
+  const s = stream[id];
+  net[id].out += data.length;
+  if (now - s.lastOutAt > 2000) s.burstStart = now;
+  s.lastOutAt = now;
+}
+
+function start(sessions, broadcast) {
+  if (interval) return;
+  interval = setInterval(() => {
+    if (!sessions.size) return;
+    const now = Date.now();
+    const stats = {};
+    for (const [id] of sessions) {
+      ensure(id);
+      const n = net[id];
+      const s = stream[id];
+      const rawRateOut = n.out - n.prevOut;
+      const rawRateIn = n.in - n.prevIn;
+      n.prevOut = n.out;
+      n.prevIn = n.in;
+      const silence = s.lastOutAt ? now - s.lastOutAt : 0;
+      const burstMs = s.burstStart && silence < 2000 ? now - s.burstStart : 0;
+      stats[id] = { rawRateOut, rawRateIn, burstMs };
+    }
+    if (Object.keys(stats).length) broadcast({ type: 'stats', stats });
+  }, 1000);
+}
+
+function stop() {
+  clearInterval(interval);
+  interval = null;
+}
+
+function clear(id) { delete net[id]; delete stream[id]; }
+
+module.exports = { start, stop, trackIn, trackOut, clear };

package/agent-presets.json

@@ -0,0 +1,93 @@
+[
+  {
+    "presetId": "claude-code",
+    "name": "Claude Code",
+    "icon": "/img/claude-code.png",
+    "command": "claude",
+    "isAgent": true,
+    "canResume": true,
+    "resumeCommand": "claude --resume {{sessionId}}",
+    "sessionIdPattern": "Session ID:\\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})",
+    "outputMarker": "\u23fa",
+    "telemetryConfigPath": "Built-in (no configuration needed)",
+    "telemetryEnv": {
+      "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
+      "OTEL_LOGS_EXPORTER": "otlp",
+      "OTEL_EXPORTER_OTLP_PROTOCOL": "http/json",
+      "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:{{port}}",
+      "OTEL_LOGS_EXPORT_INTERVAL": "2000"
+    }
+  },
+  {
+    "presetId": "codex",
+    "name": "Codex",
+    "icon": "/img/codex.png",
+    "command": "codex --no-alt-screen",
+    "isAgent": true,
+    "canResume": true,
+    "resumeCommand": "codex resume {{sessionId}} --no-alt-screen",
+    "sessionIdPattern": "Session:\\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})",
+    "outputMarker": "\u2022",
+    "telemetryConfigPath": "~/.codex/config.toml",
+    "telemetryEnv": {
+      "OTEL_LOGS_EXPORTER": "otlp",
+      "OTEL_EXPORTER_OTLP_PROTOCOL": "http/json",
+      "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:{{port}}",
+      "OTEL_LOGS_EXPORT_INTERVAL": "2000"
+    },
+    "telemetrySetup": "For best experience, add to ~/.codex/config.toml:\n\n[otel]\nexporter = { otlp-http = { endpoint = \"http://localhost:{{port}}/v1/logs\", protocol = \"json\" } }",
+    "telemetryAutoSetup": {
+      "label": "Configure automatically"
+    }
+  },
+  {
+    "presetId": "gemini-cli",
+    "name": "Gemini CLI",
+    "icon": "/img/gemini.png",
+    "command": "gemini",
+    "isAgent": true,
+    "canResume": true,
+    "resumeCommand": "gemini --resume {{sessionId}}",
+    "sessionIdPattern": "Session ID:\\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})",
+    "outputMarker": "\u2726",
+    "telemetryConfigPath": "~/.gemini/settings.json",
+    "telemetryEnv": {
+      "GEMINI_TELEMETRY_ENABLED": "true",
+      "GEMINI_TELEMETRY_TARGET": "local",
+      "GEMINI_TELEMETRY_OTLP_ENDPOINT": "http://localhost:{{port}}",
+      "GEMINI_TELEMETRY_OTLP_PROTOCOL": "http"
+    },
+    "telemetrySetup": "For best experience, add to ~/.gemini/settings.json:\n\n{\n  \"telemetry\": {\n    \"enabled\": true,\n    \"target\": \"local\",\n    \"otlpEndpoint\": \"http://localhost:{{port}}/v1/logs\",\n    \"otlpProtocol\": \"http\",\n    \"logPrompts\": true\n  }\n}",
+    "telemetryAutoSetup": {
+      "label": "Configure automatically"
+    }
+  },
+  {
+    "presetId": "opencode",
+    "name": "OpenCode",
+    "icon": "/img/opencode.png",
+    "command": "opencode",
+    "isAgent": true,
+    "canResume": true,
+    "resumeCommand": "opencode --session {{sessionId}}",
+    "sessionIdPattern": "(ses_[a-zA-Z0-9]{10,})",
+    "outputMarker": "\u2502",
+    "bridge": "opencode",
+    "pluginPath": "~/.config/opencode/plugins/clideck-bridge.js",
+    "pluginSetup": "Install the CliDeck bridge plugin to enable real-time status and resume.\n\ncp opencode-plugin/clideck-bridge.js ~/.config/opencode/plugins/",
+    "telemetryAutoSetup": {
+      "label": "Install plugin"
+    }
+  },
+  {
+    "presetId": "shell",
+    "name": "Shell",
+    "icon": "terminal",
+    "command": "/bin/zsh",
+    "isAgent": false,
+    "canResume": false,
+    "resumeCommand": null,
+    "sessionIdPattern": null,
+    "outputMarker": null
+  }
+]

package/bin/clideck.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../server.js');

package/config.js

@@ -0,0 +1,96 @@
+const { readFileSync, writeFileSync, existsSync } = require('fs');
+const { join } = require('path');
+const os = require('os');
+const { DATA_DIR } = require('./paths');
+const { defaultShell, binName } = require('./utils');
+
+const CONFIG_PATH = join(DATA_DIR, 'config.json');
+
+const DEFAULTS = {
+  defaultPath: join(os.homedir(), 'Documents'),
+  commands: [
+    {
+      id: '1', label: 'Shell', icon: 'terminal', command: defaultShell, enabled: true,
+      defaultPath: '', isAgent: false, canResume: false, resumeCommand: null, sessionIdPattern: null,
+    },
+  ],
+  confirmClose: true,
+  notifySoundEnabled: true,
+  notifySound: 'soft-beep',
+  defaultTheme: 'catppuccin-mocha',
+  defaultShell,
+  prompts: [],
+  projects: [],
+};
+
+function deepCopy(obj) { return JSON.parse(JSON.stringify(obj)); }
+
+const PRESETS = JSON.parse(readFileSync(join(__dirname, 'agent-presets.json'), 'utf8'));
+for (const p of PRESETS) if (p.presetId === 'shell') p.command = defaultShell;
+
+function matchPreset(cmd) {
+  const bin = binName(cmd.command);
+  return PRESETS.find(p => binName(p.command) === bin);
+}
+
+function migrate(cfg) {
+  // Migrate profiles → defaultTheme
+  if (cfg.profiles && !cfg.defaultTheme) {
+    const defProfile = cfg.profiles.find(p => p.id === cfg.defaultProfile) || cfg.profiles[0];
+    cfg.defaultTheme = defProfile?.themeId || 'default';
+  }
+  delete cfg.profiles;
+  delete cfg.defaultProfile;
+  if (!cfg.defaultTheme || cfg.defaultTheme === 'solarized-dark') cfg.defaultTheme = 'catppuccin-mocha';
+  // Backfill and sync fields from presets
+  for (const cmd of cfg.commands) {
+    const preset = matchPreset(cmd);
+    // Icon always syncs from preset — the preset is the source of truth for logos
+    if (preset) cmd.icon = preset.icon;
+    else if (!cmd.icon) cmd.icon = 'terminal';
+    if (cmd.isAgent === undefined)          cmd.isAgent = preset?.isAgent ?? false;
+    if (cmd.canResume === undefined)        cmd.canResume = preset?.canResume ?? false;
+    if (cmd.resumeCommand === undefined)    cmd.resumeCommand = preset?.resumeCommand || null;
+    if (cmd.sessionIdPattern === undefined) cmd.sessionIdPattern = preset?.sessionIdPattern || null;
+    if (cmd.outputMarker === undefined)     cmd.outputMarker = preset?.outputMarker || null;
+    // Claude Code telemetry is built-in, always on
+    if (preset?.presetId === 'claude-code') cmd.telemetryEnabled = true;
+    else if (cmd.telemetryEnabled === undefined) cmd.telemetryEnabled = false;
+    if (cmd.telemetryStatus === undefined)  cmd.telemetryStatus = null;
+    // Sync bridge config from preset
+    if (preset?.bridge) cmd.bridge = preset.bridge;
+    // Codex: add --no-alt-screen to avoid blank screen in embedded xterm
+    if (preset?.presetId === 'codex') {
+      if (cmd.command === 'codex') cmd.command = preset.command;
+      if (cmd.resumeCommand === 'codex resume {{sessionId}}') cmd.resumeCommand = preset.resumeCommand;
+    }
+  }
+  // Auto-add any shipped presets not yet in the commands list
+  for (const preset of PRESETS) {
+    const exists = cfg.commands.some(c => matchPreset(c)?.presetId === preset.presetId);
+    if (!exists) {
+      cfg.commands.push({
+        id: crypto.randomUUID(), label: preset.name, icon: preset.icon,
+        command: preset.command, enabled: true, defaultPath: '',
+        isAgent: preset.isAgent, canResume: preset.canResume,
+        resumeCommand: preset.resumeCommand, sessionIdPattern: preset.sessionIdPattern,
+        outputMarker: preset.outputMarker || null,
+      });
+    }
+  }
+  if (!cfg.projects) cfg.projects = [];
+  return cfg;
+}
+
+function load() {
+  if (!existsSync(CONFIG_PATH)) return deepCopy(DEFAULTS);
+  try {
+    return migrate({ ...deepCopy(DEFAULTS), ...JSON.parse(readFileSync(CONFIG_PATH, 'utf8')) });
+  } catch { return deepCopy(DEFAULTS); }
+}
+
+function save(config) {
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+module.exports = { load, save };

package/handlers.js

@@ -0,0 +1,297 @@
+const { readFileSync, writeFileSync, mkdirSync, existsSync, copyFileSync, unlinkSync } = require('fs');
+const { join, dirname } = require('path');
+const os = require('os');
+const config = require('./config');
+const sessions = require('./sessions');
+const themes = require('./themes');
+const presets = JSON.parse(readFileSync(join(__dirname, 'agent-presets.json'), 'utf8'));
+const { listDirs, binName, defaultShell } = require('./utils');
+for (const p of presets) if (p.presetId === 'shell') p.command = defaultShell;
+const transcript = require('./transcript');
+const plugins = require('./plugin-loader');
+
+let cfg = config.load();
+if (detectTelemetryConfig(cfg)) config.save(cfg);
+
+function detectTelemetryConfig(c) {
+  const home = os.homedir();
+  const port = '4000';
+  let changed = false;
+  for (const cmd of c.commands || []) {
+    const bin = binName(cmd.command);
+    const preset = presets.find(p => binName(p.command) === bin);
+    if (!preset) continue;
+    let detected = false;
+    if (preset.presetId === 'claude-code') {
+      detected = true;
+    } else if (preset.presetId === 'codex') {
+      try {
+        const content = readFileSync(join(home, '.codex', 'config.toml'), 'utf8');
+        detected = content.includes('[otel]') && content.includes(`localhost:${port}`);
+      } catch {}
+    } else if (preset.presetId === 'gemini-cli') {
+      try {
+        const s = JSON.parse(readFileSync(join(home, '.gemini', 'settings.json'), 'utf8'));
+        detected = !!s.telemetry?.enabled && (s.telemetry?.otlpEndpoint || '').includes(`localhost:${port}`);
+      } catch {}
+    } else if (preset.presetId === 'opencode') {
+      const ocPlugins = join(home, '.config', 'opencode', 'plugins');
+      detected = existsSync(join(ocPlugins, 'clideck-bridge.js')) || existsSync(join(ocPlugins, 'termix-bridge.js'));
+    } else { continue; }
+    if (detected !== !!cmd.telemetryEnabled) {
+      cmd.telemetryEnabled = detected;
+      cmd.telemetryStatus = detected ? { ok: true } : null;
+      changed = true;
+    }
+  }
+  if (changed) console.log('Config: synced telemetry/plugin state from detected config files');
+  return changed;
+}
+
+function onConnection(ws) {
+  sessions.clients.add(ws);
+
+  ws.send(JSON.stringify({ type: 'config', config: cfg }));
+  ws.send(JSON.stringify({ type: 'themes', themes }));
+  ws.send(JSON.stringify({ type: 'presets', presets }));
+  ws.send(JSON.stringify({ type: 'sessions', list: sessions.list() }));
+  ws.send(JSON.stringify({ type: 'sessions.resumable', list: sessions.getResumable() }));
+  ws.send(JSON.stringify({ type: 'transcript.cache', cache: transcript.getCache() }));
+  ws.send(JSON.stringify({ type: 'plugins', list: plugins.getInfo() }));
+  sessions.sendBuffers(ws);
+
+  ws.on('message', (raw) => {
+    let msg;
+    try { msg = JSON.parse(raw); } catch { return; }
+
+    switch (msg.type) {
+      case 'create':          sessions.create(msg, ws, cfg); break;
+      case 'session.resume':  sessions.resume(msg, ws, cfg); break;
+      case 'session.restart': console.log('[handler] session.restart', msg.id); sessions.restart(msg, ws, cfg); break;
+      case 'input':                sessions.input(msg); break;
+      case 'session.statusReport':
+        if (sessions.getSessions().has(msg.id)) plugins.notifyStatus(msg.id, !!msg.working);
+        break;
+      case 'resize':               sessions.resize(msg); break;
+      case 'rename':          sessions.rename(msg); break;
+      case 'close':           sessions.close(msg); break;
+
+      case 'config.get':
+        ws.send(JSON.stringify({ type: 'config', config: cfg }));
+        break;
+
+      case 'config.update':
+        cfg = { ...cfg, ...msg.config };
+        detectTelemetryConfig(cfg);
+        config.save(cfg);
+        sessions.broadcast({ type: 'config', config: cfg });
+        break;
+
+      case 'session.theme': {
+        const ok = sessions.setTheme(msg.id, msg.themeId);
+        if (ok) sessions.broadcast({ type: 'session.theme', id: msg.id, themeId: msg.themeId });
+        break;
+      }
+
+      case 'telemetry.autosetup': {
+        const preset = presets.find(p => p.presetId === msg.presetId);
+        if (!preset?.telemetryAutoSetup) break;
+        // Only allow if caller has a live session using this preset's command
+        const liveSessions = sessions.list();
+        const hasLive = liveSessions.some(s => {
+          const cmd = cfg.commands.find(c => c.id === s.commandId);
+          return cmd && binName(cmd.command) === binName(preset.command);
+        });
+        if (!hasLive) break;
+        const result = applyTelemetryConfig(preset);
+        // Persist telemetry state in config
+        for (const cmd of cfg.commands) {
+          if (binName(cmd.command) === binName(preset.command)) {
+            cmd.telemetryEnabled = result.success;
+            cmd.telemetryStatus = result.success ? { ok: true } : { ok: false, error: result.message };
+          }
+        }
+        config.save(cfg);
+        sessions.broadcast({ type: 'config', config: cfg });
+        ws.send(JSON.stringify({
+          type: 'telemetry.autosetup.result',
+          presetId: msg.presetId,
+          success: result.success,
+          output: result.message,
+        }));
+        break;
+      }
+
+      case 'telemetry.configure': {
+        const preset = presets.find(p => p.presetId === msg.presetId);
+        if (!preset) break;
+        const enable = !!msg.enable;
+        let result;
+        if (enable) {
+          result = applyTelemetryConfig(preset);
+        } else {
+          result = removeTelemetryConfig(preset);
+        }
+        // Update all matching commands in config
+        for (const cmd of cfg.commands) {
+          if (binName(cmd.command) === binName(preset.command)) {
+            cmd.telemetryEnabled = enable && result.success;
+            cmd.telemetryStatus = enable
+              ? (result.success ? { ok: true } : { ok: false, error: result.message })
+              : null;
+          }
+        }
+        config.save(cfg);
+        sessions.broadcast({ type: 'config', config: cfg });
+        break;
+      }
+
+      case 'session.mute': {
+        const ok = sessions.setMute(msg.id, msg.muted);
+        if (ok) sessions.broadcast({ type: 'session.mute', id: msg.id, muted: !!msg.muted });
+        break;
+      }
+
+      case 'session.setProject': {
+        const ok = sessions.setProject(msg.id, msg.projectId);
+        if (ok) sessions.broadcast({ type: 'session.setProject', id: msg.id, projectId: msg.projectId });
+        break;
+      }
+
+      // Client reports latest preview text — stored in memory, persisted by auto-save
+      case 'session.setPreview':
+        sessions.setPreview(msg.id, msg.text, msg.timestamp);
+        break;
+
+      case 'project.delete': {
+        const proj = cfg.projects?.find(p => p.id === msg.id);
+        if (!proj) break;
+        // Kill all sessions in this project
+        for (const s of sessions.list()) {
+          if (s.projectId === msg.id) sessions.close({ id: s.id });
+        }
+        cfg.projects = cfg.projects.filter(p => p.id !== msg.id);
+        config.save(cfg);
+        sessions.broadcast({ type: 'config', config: cfg });
+        break;
+      }
+
+      case 'dirs.list': {
+        const target = msg.path || cfg.defaultPath;
+        const result = listDirs(target);
+        const entries = Array.isArray(result) ? result : [];
+        const error = result.error || undefined;
+        ws.send(JSON.stringify({ type: 'dirs', path: target, entries, error }));
+        break;
+      }
+
+      case 'plugin.settings.update':
+        plugins.updateSetting(msg.pluginId, msg.key, msg.value);
+        sessions.broadcast({ type: 'plugins', list: plugins.getInfo() });
+        break;
+
+      default:
+        if (msg.type?.startsWith('plugin.')) plugins.handleMessage(msg);
+        break;
+    }
+  });
+
+  ws.on('close', () => sessions.clients.delete(ws));
+}
+
+// Deterministic telemetry config writers per agent — no AI, no YOLO
+function applyTelemetryConfig(preset) {
+  const port = '4000';
+  const home = os.homedir();
+
+  try {
+    if (preset.presetId === 'codex') {
+      const configPath = join(home, '.codex', 'config.toml');
+      let content = '';
+      if (existsSync(configPath)) content = readFileSync(configPath, 'utf8');
+      if (content.includes('[otel]')) return { success: true, message: 'Already configured' };
+      const section = `\n[otel]\nexporter = { otlp-http = { endpoint = "http://localhost:${port}/v1/logs", protocol = "json" } }\n`;
+      mkdirSync(dirname(configPath), { recursive: true });
+      writeFileSync(configPath, content.trimEnd() + '\n' + section);
+      return { success: true, message: 'Added [otel] section to ~/.codex/config.toml' };
+    }
+
+    if (preset.presetId === 'gemini-cli') {
+      const configPath = join(home, '.gemini', 'settings.json');
+      let settings = {};
+      if (existsSync(configPath)) {
+        try { settings = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
+      }
+      if (settings.telemetry?.enabled && settings.telemetry?.otlpEndpoint) {
+        return { success: true, message: 'Already configured' };
+      }
+      settings.telemetry = {
+        ...settings.telemetry,
+        enabled: true,
+        target: 'local',
+        otlpEndpoint: `http://localhost:${port}/v1/logs`,
+        otlpProtocol: 'http',
+        logPrompts: true,
+      };
+      mkdirSync(dirname(configPath), { recursive: true });
+      writeFileSync(configPath, JSON.stringify(settings, null, 2) + '\n');
+      return { success: true, message: 'Added telemetry section to ~/.gemini/settings.json' };
+    }
+
+    if (preset.presetId === 'opencode') {
+      const pluginDir = join(home, '.config', 'opencode', 'plugins');
+      const src = join(__dirname, 'opencode-plugin', 'clideck-bridge.js');
+      mkdirSync(pluginDir, { recursive: true });
+      copyFileSync(src, join(pluginDir, 'clideck-bridge.js'));
+      // Remove old termix-bridge.js if present
+      const old = join(pluginDir, 'termix-bridge.js');
+      if (existsSync(old)) try { unlinkSync(old); } catch {}
+      return { success: true, message: 'Installed bridge plugin to ~/.config/opencode/plugins/' };
+    }
+
+    return { success: false, message: `No auto-setup for ${preset.presetId}` };
+  } catch (err) {
+    return { success: false, message: err.message };
+  }
+}
+
+function removeTelemetryConfig(preset) {
+  const home = os.homedir();
+
+  try {
+    if (preset.presetId === 'codex') {
+      const configPath = join(home, '.codex', 'config.toml');
+      if (!existsSync(configPath)) return { success: true, message: 'No config file to clean' };
+      let content = readFileSync(configPath, 'utf8');
+      // Remove [otel] section and everything until the next section or EOF
+      content = content.replace(/\n?\[otel\][^\[]*/, '');
+      writeFileSync(configPath, content.trimEnd() + '\n');
+      return { success: true, message: 'Removed [otel] section from ~/.codex/config.toml' };
+    }
+
+    if (preset.presetId === 'gemini-cli') {
+      const configPath = join(home, '.gemini', 'settings.json');
+      if (!existsSync(configPath)) return { success: true, message: 'No config file to clean' };
+      let settings = {};
+      try { settings = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
+      delete settings.telemetry;
+      writeFileSync(configPath, JSON.stringify(settings, null, 2) + '\n');
+      return { success: true, message: 'Removed telemetry section from ~/.gemini/settings.json' };
+    }
+
+    if (preset.presetId === 'opencode') {
+      const dir = join(home, '.config', 'opencode', 'plugins');
+      try { unlinkSync(join(dir, 'clideck-bridge.js')); } catch {}
+      try { unlinkSync(join(dir, 'termix-bridge.js')); } catch {}
+      return { success: true, message: 'Removed bridge plugin' };
+    }
+
+    return { success: false, message: `No removal logic for ${preset.presetId}` };
+  } catch (err) {
+    return { success: false, message: err.message };
+  }
+}
+
+function getConfig() { return cfg; }
+
+module.exports = { onConnection, getConfig };