clideck 1.22.2

package/opencode-bridge.js

@@ -0,0 +1,148 @@
+// OpenCode bridge — receives events from the CliDeck OpenCode plugin
+// via HTTP POST to /opencode-events.
+// Routes events to the correct CliDeck session by OpenCode session ID.
+
+// sessionId → { opencodeSessionId, cwd }
+const watchers = new Map();
+
+let broadcastFn = null;
+let sessionsFn = null;
+
+function init(broadcast, getSessions) {
+  broadcastFn = broadcast;
+  sessionsFn = getSessions;
+}
+
+function watchSession(sessionId, cwd) {
+  if (watchers.has(sessionId)) return;
+  watchers.set(sessionId, { opencodeSessionId: null, cwd });
+}
+
+function findByOcId(ocSid) {
+  for (const [sessionId, w] of watchers) {
+    if (w.opencodeSessionId === ocSid) return sessionId;
+  }
+  return null;
+}
+
+function findUnclaimed(directory) {
+  let fallback = null;
+  for (const [sessionId, w] of watchers) {
+    if (w.opencodeSessionId) continue;
+    if (directory && w.cwd && directory.startsWith(w.cwd)) return sessionId;
+    if (!fallback) fallback = sessionId;
+  }
+  return fallback;
+}
+
+// Extract OpenCode session ID from any event shape
+function extractOcSid(p) {
+  return p.sessionID
+    || p.sessionId
+    || p.info?.id
+    || p.info?.sessionID
+    || p.info?.sessionId
+    || p.part?.sessionID
+    || p.part?.sessionId
+    || p.message?.sessionID
+    || p.message?.sessionId
+    || p.session?.id
+    || null;
+}
+
+function extractDirectory(p) {
+  return p.info?.directory || p.directory || p.info?.path?.cwd || p.path?.cwd || null;
+}
+
+function claim(sessionId, ocSid) {
+  const w = watchers.get(sessionId);
+  if (!w) return;
+  w.opencodeSessionId = ocSid;
+  const sess = sessionsFn?.()?.get(sessionId);
+  if (sess && !sess.sessionToken) sess.sessionToken = ocSid;
+}
+
+function unclaimedIds() {
+  const ids = [];
+  for (const [sessionId, w] of watchers) {
+    if (!w.opencodeSessionId) ids.push(sessionId);
+  }
+  return ids;
+}
+
+function handleEvent(payload) {
+  if (!payload || !payload.event) return;
+
+  const ocSid = extractOcSid(payload);
+  let sessionId = ocSid ? findByOcId(ocSid) : null;
+
+  // Claim unclaimed watcher on session.created or session.updated
+  if (!sessionId && ocSid && (payload.event === 'session.created' || payload.event === 'session.updated')) {
+    sessionId = findUnclaimed(extractDirectory(payload));
+    if (sessionId) claim(sessionId, ocSid);
+  }
+
+  // Fallback: if there's exactly one unclaimed OpenCode watcher, attach first seen session ID.
+  // This recovers when session.created/session.updated isn't delivered in-order.
+  if (!sessionId && ocSid) {
+    const unclaimed = unclaimedIds();
+    if (unclaimed.length === 1) {
+      sessionId = unclaimed[0];
+      claim(sessionId, ocSid);
+    }
+  }
+
+  if (!sessionId) return;
+
+  // session.status → busy/idle
+  if (payload.event === 'session.status') {
+    const t = payload.status?.type;
+    if (t === 'busy') broadcastFn?.({ type: 'session.status', id: sessionId, working: true });
+    else if (t === 'idle') broadcastFn?.({ type: 'session.status', id: sessionId, working: false });
+  }
+
+  // session.idle
+  if (payload.event === 'session.idle') {
+    broadcastFn?.({ type: 'session.status', id: sessionId, working: false });
+  }
+
+  // message.part.updated with type=text → preview
+  if (payload.event === 'message.part.updated') {
+    const part = payload.part || {};
+    const text = typeof part.text === 'string'
+      ? part.text
+      : (typeof payload.delta === 'string' ? payload.delta : '');
+    const isTextual = part.type === 'text' || part.type === 'reasoning' || !!text;
+    if (isTextual && text) {
+      broadcastFn?.({ type: 'session.preview', id: sessionId, text: text.slice(0, 200) });
+    }
+  }
+
+  // message.updated fallback preview (for payloads that don't emit text part updates)
+  if (payload.event === 'message.updated') {
+    const parts = payload.info?.parts;
+    if (Array.isArray(parts)) {
+      const latest = [...parts].reverse().find(p =>
+        typeof p?.text === 'string' && (p.type === 'text' || p.type === 'reasoning')
+      );
+      if (latest?.text) {
+        broadcastFn?.({ type: 'session.preview', id: sessionId, text: latest.text.slice(0, 200) });
+      }
+    }
+  }
+
+  // session.updated → capture title, ensure token
+  if (payload.event === 'session.updated') {
+    const sess = sessionsFn?.()?.get(sessionId);
+    if (sess) {
+      if (!sess.sessionToken) sess.sessionToken = ocSid;
+      if (payload.info?.title) sess.title = payload.info.title;
+    }
+  }
+}
+
+function clear(sessionId) {
+  watchers.delete(sessionId);
+}
+
+module.exports = { init, watchSession, handleEvent, clear };

package/opencode-plugin/clideck-bridge.js

@@ -0,0 +1,24 @@
+// CliDeck bridge plugin for OpenCode
+// Forwards session events to CliDeck server via HTTP POST.
+// Install: copy to ~/.config/opencode/plugins/clideck-bridge.js
+
+const CLIDECK_URL = "http://localhost:4000/opencode-events";
+
+function post(payload) {
+  fetch(CLIDECK_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  }).catch(() => {});
+}
+
+export const CliDeckBridge = async () => {
+  return {
+    event: async ({ event }) => {
+      const t = event.type;
+      if (t.startsWith("session.") || t.startsWith("message.")) {
+        post({ event: t, ...event.properties });
+      }
+    },
+  };
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "clideck",
+  "version": "1.22.2",
+  "description": "One screen for all your AI coding agents — run, monitor, and manage multiple CLI agents from a single browser tab",
+  "main": "server.js",
+  "bin": {
+    "clideck": "bin/clideck.js"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "build:css": "tailwindcss -i src/input.css -o public/tailwind.css --minify",
+    "prepublishOnly": "npm run build:css"
+  },
+  "keywords": [
+    "terminal",
+    "cli",
+    "ai",
+    "agent",
+    "claude",
+    "codex",
+    "gemini",
+    "opencode",
+    "dashboard",
+    "multiplexer",
+    "xterm"
+  ],
+  "author": "Or Kuntzman",
+  "license": "MIT",
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rustykuntz/clideck.git"
+  },
+  "homepage": "https://clideck.dev/",
+  "dependencies": {
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "node-pty": "^1.1.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "tailwindcss": "^3.4.19"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/paths.js

@@ -0,0 +1,41 @@
+const { join } = require('path');
+const { mkdirSync, existsSync, copyFileSync, cpSync, readdirSync } = require('fs');
+const os = require('os');
+
+const DATA_DIR = join(os.homedir(), '.clideck');
+const LEGACY_DIR = __dirname;
+const OLD_DATA_DIR = join(os.homedir(), '.termix');
+mkdirSync(DATA_DIR, { recursive: true });
+
+// Migrate from ~/.termix/ to ~/.clideck/ (one-time rename migration)
+if (existsSync(OLD_DATA_DIR)) {
+  for (const file of readdirSync(OLD_DATA_DIR, { withFileTypes: true })) {
+    const src = join(OLD_DATA_DIR, file.name);
+    const dest = join(DATA_DIR, file.name);
+    if (existsSync(dest)) continue;
+    try { cpSync(src, dest, { recursive: true }); } catch {}
+  }
+}
+
+// Migrate legacy files from project root to ~/.clideck/ (one-time on upgrade)
+const MIGRATE_FILES = ['config.json', 'sessions.json', 'custom-themes.json'];
+for (const file of MIGRATE_FILES) {
+  const src = join(LEGACY_DIR, file);
+  const dest = join(DATA_DIR, file);
+  if (existsSync(src) && !existsSync(dest)) {
+    try { copyFileSync(src, dest); } catch {}
+  }
+}
+// Migrate transcript JSONL files
+const legacyTranscripts = join(LEGACY_DIR, 'data', 'transcripts');
+const newTranscripts = join(DATA_DIR, 'transcripts');
+if (existsSync(legacyTranscripts) && !existsSync(newTranscripts)) {
+  mkdirSync(newTranscripts, { recursive: true });
+  try {
+    for (const f of readdirSync(legacyTranscripts)) {
+      copyFileSync(join(legacyTranscripts, f), join(newTranscripts, f));
+    }
+  } catch {}
+}
+
+module.exports = { DATA_DIR };

package/plugin-loader.js

@@ -0,0 +1,285 @@
+const { readdirSync, readFileSync, existsSync, mkdirSync, cpSync } = require('fs');
+const { join, sep } = require('path');
+const { DATA_DIR } = require('./paths');
+
+const PLUGINS_DIR = join(DATA_DIR, 'plugins');
+mkdirSync(PLUGINS_DIR, { recursive: true });
+
+// Seed bundled plugins — copy if missing, update if bundled version is newer
+const BUNDLED_DIR = join(__dirname, 'plugins');
+if (existsSync(BUNDLED_DIR)) {
+  for (const entry of readdirSync(BUNDLED_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const target = join(PLUGINS_DIR, entry.name);
+    if (!existsSync(target)) {
+      cpSync(join(BUNDLED_DIR, entry.name), target, { recursive: true });
+      console.log(`[plugin] seeded ${entry.name}`);
+    } else {
+      try {
+        const bundledManifest = JSON.parse(readFileSync(join(BUNDLED_DIR, entry.name, 'clideck-plugin.json'), 'utf8'));
+        const installedManifestFile = existsSync(join(target, 'clideck-plugin.json')) ? join(target, 'clideck-plugin.json') : join(target, 'termix-plugin.json');
+        const installedManifest = JSON.parse(readFileSync(installedManifestFile, 'utf8'));
+        if (bundledManifest.version !== installedManifest.version) {
+          cpSync(join(BUNDLED_DIR, entry.name), target, { recursive: true });
+          console.log(`[plugin] updated ${entry.name} ${installedManifest.version} → ${bundledManifest.version}`);
+        }
+      } catch {}
+    }
+  }
+}
+
+const plugins = new Map();
+const inputHooks = [];
+const outputHooks = [];
+const statusHooks = [];
+const sessionStatus = new Map(); // sessionId → boolean (dedup multi-client reports)
+const frontendHandlers = new Map();
+let broadcastFn = null;
+let sessionsFn = null;
+let getConfigFn = null;
+let saveConfigFn = null;
+const settingsChangeHandlers = new Map(); // pluginId → [fn]
+
+function removeHooks(pluginId) {
+  for (const arr of [inputHooks, outputHooks, statusHooks]) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+      if (arr[i].pluginId === pluginId) arr.splice(i, 1);
+    }
+  }
+  for (const key of frontendHandlers.keys()) {
+    if (key.startsWith(`plugin.${pluginId}.`)) frontendHandlers.delete(key);
+  }
+  settingsChangeHandlers.delete(pluginId);
+}
+
+function init(broadcast, getSessions, getConfig, saveConfig) {
+  broadcastFn = broadcast;
+  sessionsFn = getSessions;
+  getConfigFn = getConfig;
+  saveConfigFn = saveConfig;
+
+  for (const entry of readdirSync(PLUGINS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dir = join(PLUGINS_DIR, entry.name);
+    const entryFile = join(dir, 'index.js');
+    if (!existsSync(entryFile)) continue;
+
+    let manifest = { id: entry.name, name: entry.name, version: '0.0.0' };
+    const manifestFile = existsSync(join(dir, 'clideck-plugin.json')) ? join(dir, 'clideck-plugin.json') : join(dir, 'termix-plugin.json');
+    if (existsSync(manifestFile)) {
+      try { manifest = { ...manifest, ...JSON.parse(readFileSync(manifestFile, 'utf8')) }; }
+      catch (e) { console.error(`[plugin:${entry.name}] bad manifest: ${e.message}`); continue; }
+    }
+    // Validate settings shape
+    if (manifest.settings != null) {
+      if (!Array.isArray(manifest.settings)) {
+        console.error(`[plugin:${entry.name}] manifest.settings must be an array, ignoring`);
+        manifest.settings = [];
+      } else {
+        manifest.settings = manifest.settings.filter(s =>
+          s && typeof s === 'object' && typeof s.key === 'string' && s.key
+        );
+      }
+    }
+
+    if (plugins.has(manifest.id)) {
+      console.error(`[plugin:${manifest.id}] duplicate ID, skipping ${dir}`);
+      continue;
+    }
+
+    const state = { manifest, dir, shutdownFns: [], actions: [] };
+    plugins.set(manifest.id, state);
+
+    try {
+      const mod = require(entryFile);
+      if (typeof mod.init === 'function') mod.init(buildApi(manifest.id, dir, state));
+      console.log(`[plugin] ${manifest.name} v${manifest.version}`);
+    } catch (e) {
+      console.error(`[plugin:${manifest.id}] init failed: ${e.message}`);
+      removeHooks(manifest.id);
+      plugins.delete(manifest.id);
+    }
+  }
+}
+
+function buildApi(pluginId, pluginDir, state) {
+  return {
+    version: 1,
+    pluginId,
+    pluginDir,
+
+    onSessionInput(fn) { inputHooks.push({ pluginId, fn }); },
+    onSessionOutput(fn) { outputHooks.push({ pluginId, fn }); },
+    onStatusChange(fn) { statusHooks.push({ pluginId, fn }); },
+
+    sendToFrontend(event, data = {}) {
+      broadcastFn?.({ ...data, type: `plugin.${pluginId}.${event}` });
+    },
+    onFrontendMessage(event, fn) {
+      frontendHandlers.set(`plugin.${pluginId}.${event}`, fn);
+    },
+
+    getSession(id) {
+      const s = sessionsFn?.()?.get(id);
+      if (!s) return null;
+      return { id, name: s.name, cwd: s.cwd, commandId: s.commandId, themeId: s.themeId, projectId: s.projectId };
+    },
+    getSessions() {
+      const sessions = sessionsFn?.();
+      if (!sessions) return [];
+      return [...sessions].map(([id, s]) => ({
+        id, name: s.name, cwd: s.cwd, commandId: s.commandId, themeId: s.themeId, projectId: s.projectId,
+      }));
+    },
+
+    addToolbarAction(opts) { state.actions.push({ ...opts, pluginId, slot: 'toolbar' }); },
+
+    getSetting(key) {
+      const cfg = getConfigFn?.();
+      const defaults = {};
+      for (const s of state.manifest.settings || []) defaults[s.key] = s.default;
+      return cfg?.pluginSettings?.[pluginId]?.[key] ?? defaults[key];
+    },
+    getSettings() {
+      const cfg = getConfigFn?.();
+      const result = {};
+      for (const s of state.manifest.settings || []) result[s.key] = s.default;
+      return { ...result, ...cfg?.pluginSettings?.[pluginId] };
+    },
+    onSettingsChange(fn) {
+      if (!settingsChangeHandlers.has(pluginId)) settingsChangeHandlers.set(pluginId, []);
+      settingsChangeHandlers.get(pluginId).push(fn);
+    },
+
+    onShutdown(fn) { state.shutdownFns.push(fn); },
+    log(msg) { console.log(`[plugin:${pluginId}] ${msg}`); },
+  };
+}
+
+function transformInput(id, data) {
+  if (!inputHooks.length) return data;
+  let result = data;
+  for (const h of inputHooks) {
+    try {
+      const out = h.fn(id, result);
+      if (typeof out === 'string') result = out;
+    } catch (e) { console.error(`[plugin:${h.pluginId}] input error: ${e.message}`); }
+  }
+  return result;
+}
+
+function notifyOutput(id, data) {
+  for (const h of outputHooks) {
+    try { h.fn(id, data); }
+    catch (e) { console.error(`[plugin:${h.pluginId}] output error: ${e.message}`); }
+  }
+}
+
+function notifyStatus(id, working) {
+  if (sessionStatus.get(id) === working) return;
+  sessionStatus.set(id, working);
+  for (const h of statusHooks) {
+    try { h.fn(id, working); }
+    catch (e) { console.error(`[plugin:${h.pluginId}] status error: ${e.message}`); }
+  }
+}
+
+function updateSetting(pluginId, key, value) {
+  // Validate plugin exists (also prevents __proto__ pollution — Map lookup returns undefined)
+  const plugin = plugins.get(pluginId);
+  if (!plugin) return;
+  // Validate key is declared in manifest
+  const settingDef = (plugin.manifest.settings || []).find(s => s.key === key);
+  if (!settingDef) return;
+  // Type-coerce/validate value against manifest type
+  const coerced = coerceSetting(settingDef, value);
+  if (coerced === undefined) return;
+
+  const cfg = getConfigFn?.();
+  if (!cfg) return;
+  if (!cfg.pluginSettings) cfg.pluginSettings = Object.create(null);
+  if (!cfg.pluginSettings[pluginId]) cfg.pluginSettings[pluginId] = Object.create(null);
+  cfg.pluginSettings[pluginId][key] = coerced;
+  saveConfigFn?.(cfg);
+  const fns = settingsChangeHandlers.get(pluginId) || [];
+  for (const fn of fns) {
+    try { fn(key, coerced); }
+    catch (e) { console.error(`[plugin:${pluginId}] settings handler error: ${e.message}`); }
+  }
+}
+
+function coerceSetting(def, value) {
+  switch (def.type) {
+    case 'toggle': return !!value;
+    case 'number': {
+      const n = Number(value);
+      if (!Number.isFinite(n)) return undefined;
+      if (def.min != null && n < def.min) return undefined;
+      if (def.max != null && n > def.max) return undefined;
+      return n;
+    }
+    case 'select': {
+      const opts = (def.options || []).map(o => String(typeof o === 'object' ? o.value : o));
+      const s = String(value);
+      return opts.includes(s) ? s : undefined;
+    }
+    default: return String(value);
+  }
+}
+
+function handleMessage(msg) {
+  const fn = frontendHandlers.get(msg.type);
+  if (!fn) return false;
+  try { fn(msg); }
+  catch (e) { console.error(`[plugin] handler error for ${msg.type}: ${e.message}`); }
+  return true;
+}
+
+function getInfo() {
+  const cfg = getConfigFn?.();
+  return [...plugins.values()].map(p => ({
+    id: p.manifest.id,
+    name: p.manifest.name,
+    version: p.manifest.version,
+    settings: p.manifest.settings || [],
+    settingValues: cfg?.pluginSettings?.[p.manifest.id] || {},
+    actions: p.actions,
+    hasClient: existsSync(join(p.dir, 'client.js')),
+  }));
+}
+
+function resolveFile(urlPath) {
+  const m = urlPath.match(/^\/plugins\/([^/]+)\/(.+)$/);
+  if (!m) return null;
+  const [, id, rest] = m;
+  const plugin = plugins.get(id);
+  if (!plugin) return null;
+  let file, allowed;
+  if (rest === 'client.js') {
+    file = join(plugin.dir, 'client.js');
+    allowed = plugin.dir;
+  } else {
+    allowed = join(plugin.dir, 'public');
+    file = join(allowed, rest);
+  }
+  if (!file.startsWith(allowed + sep)) return null;
+  if (!existsSync(file)) return null;
+  return file;
+}
+
+function shutdown() {
+  for (const [id, p] of plugins) {
+    for (const fn of p.shutdownFns) {
+      try { fn(); }
+      catch (e) { console.error(`[plugin:${id}] shutdown error: ${e.message}`); }
+    }
+  }
+}
+
+function clearStatus(id) { sessionStatus.delete(id); }
+
+module.exports = {
+  init, shutdown,
+  transformInput, notifyOutput, notifyStatus, clearStatus,
+  handleMessage, updateSetting, getInfo, resolveFile,
+};

package/plugins/trim-clip/clideck-plugin.json

@@ -0,0 +1,13 @@
+{
+  "id": "trim-clip",
+  "name": "Trim Clip",
+  "version": "1.1.0",
+  "settings": [
+    {
+      "key": "enabled",
+      "label": "Enabled",
+      "type": "toggle",
+      "default": true
+    }
+  ]
+}

package/plugins/trim-clip/client.js

@@ -0,0 +1,31 @@
+let enabled = true;
+let btnEl = null;
+
+export function init(api) {
+  api.onMessage('settings', (msg) => {
+    enabled = msg.enabled !== false;
+    if (btnEl) btnEl.style.display = enabled ? '' : 'none';
+  });
+  api.send('getSettings');
+
+  btnEl = api.addToolbarButton({
+    title: 'Trim & Copy',
+    icon: '<svg class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="6" cy="6" r="3"/><circle cx="6" cy="18" r="3"/><path d="M20 4 8.12 15.88M14.47 14.48 20 20M8.12 8.12 12 12"/></svg>',
+    async onClick() {
+      const text = api.getTerminalSelection();
+      if (!text || !text.trim()) { api.toast('Select text to copy & trim', { type: 'warn' }); return; }
+      const trimmed = text
+        .split('\n')
+        .map(l => l.trimEnd())
+        .join('\n')
+        .replace(/^\n+/, '').replace(/\n+$/, '');
+      try {
+        await navigator.clipboard.writeText(trimmed);
+        const saved = text.length - trimmed.length;
+        api.toast(saved ? `Copied & trimmed ${saved} char${saved !== 1 ? 's' : ''}` : 'Copied', { type: 'success' });
+      } catch {
+        api.toast('Clipboard access denied — allow it in browser site settings', { type: 'error' });
+      }
+    }
+  });
+}

package/plugins/trim-clip/index.js

@@ -0,0 +1,10 @@
+module.exports = {
+  init(api) {
+    api.onFrontendMessage('getSettings', () => {
+      api.sendToFrontend('settings', api.getSettings());
+    });
+    api.onSettingsChange(() => {
+      api.sendToFrontend('settings', api.getSettings());
+    });
+  }
+};

package/plugins/voice-input/clideck-plugin.json

@@ -0,0 +1,49 @@
+{
+  "id": "voice-input",
+  "name": "Voice Input",
+  "version": "1.1.0",
+  "settings": [
+    {
+      "key": "enabled",
+      "label": "Enabled",
+      "type": "toggle",
+      "default": false
+    },
+    {
+      "key": "backend",
+      "label": "ASR Backend",
+      "type": "select",
+      "default": "openai",
+      "options": ["openai", "local"],
+      "description": "OpenAI Whisper (remote) or local MLX model (macOS)"
+    },
+    {
+      "key": "openaiApiKey",
+      "label": "OpenAI API Key",
+      "type": "text",
+      "default": "",
+      "description": "Required for OpenAI backend"
+    },
+    {
+      "key": "language",
+      "label": "Language",
+      "type": "select",
+      "default": "auto",
+      "options": ["auto", "en", "es", "fr", "de", "it", "pt", "nl", "ja", "ko", "zh", "ar", "hi", "ru", "pl", "tr", "sv", "da", "fi", "no", "he", "uk", "el", "cs", "ro", "hu", "th", "vi", "id"]
+    },
+    {
+      "key": "hotkey",
+      "label": "Record Key",
+      "type": "text",
+      "default": "F4",
+      "description": "Key to start/stop recording (e.g. F4, F8)"
+    },
+    {
+      "key": "replacementsFile",
+      "label": "Replacements File",
+      "type": "text",
+      "default": "",
+      "description": "Path to text replacements file (wrong => correct per line)"
+    }
+  ]
+}