clideck 1.30.5 → 1.30.7

package/README.md

@@ -45,14 +45,20 @@ Or just run it once with `npx clideck`. Works on macOS and Windows. Node 18+. Li
 
 **Session resume** - close the lid, reopen tomorrow, pick up where things left off. each agent's session ID is captured automatically.
 
-**Roles** - give agents reusable identities like programmer, reviewer, or product manager. prompts are injected automatically when a session starts.
-
 **Autopilot** - enable autopilot on a project, walk away. it watches for one agent to finish, hands the output to the next one, and keeps going until the work is done or blocked. this is the part that makes sleep possible. routes content verbatim, no rewriting or summarizing. fingerprints each output and tracks handoff history to guard against repeat loops. ~50 output tokens per routing decision. supports Anthropic, OpenAI, Google, Groq, xAI, Mistral, OpenRouter, Cerebras.
 
 <p align="center">
   <img src="assets/autopilot.gif" width="720" alt="Autopilot routing work between agents">
 </p>
 
+**Ask another session** - from inside any CliDeck session, an agent can consult another session in the same project and get the answer back as command output:
+
+```bash
+clideck ask --session "Reviewer" --message "Review this output and return findings." --timeout 10m
+```
+
+CliDeck injects the message into the real target terminal, submits it, waits for the target session to finish, then returns the latest response to the caller.
+
 **Mobile remote** - the agents keep running on the local machine. status, prompts, history, and replies stay available from a phone while away. E2E encrypted, no account needed.
 
 **Native terminals** - each session opens into its real terminal. keys go straight to the agent, nothing sits in the middle.

package/bin/clideck.js

@@ -1,2 +1,8 @@
 #!/usr/bin/env node
-require('../server.js');
+const args = process.argv.slice(2);
+
+if (args[0] === 'ask') {
+  require('../clideck-ask-cli').run(args.slice(1));
+} else {
+  require('../server.js');
+}

package/clideck-ask-cli.js

@@ -0,0 +1,110 @@
+const http = require('http');
+const https = require('https');
+
+function usage() {
+  return [
+    'Usage:',
+    '  clideck ask --session <name-or-id> --message <text> [--timeout 10m]',
+    '  clideck ask <name-or-id> <message> [--timeout 10m]',
+  ].join('\n');
+}
+
+function parseDuration(value) {
+  if (!value) return 10 * 60 * 1000;
+  const m = String(value).trim().match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/i);
+  if (!m) return null;
+  const n = Number(m[1]);
+  const unit = (m[2] || 'ms').toLowerCase();
+  const scale = unit === 'h' ? 3600000 : unit === 'm' ? 60000 : unit === 's' ? 1000 : 1;
+  return Math.max(1, Math.round(n * scale));
+}
+
+function parseArgs(args) {
+  const out = { timeoutMs: 10 * 60 * 1000, url: process.env.CLIDECK_URL || 'http://127.0.0.1:4000' };
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--session' || arg === '-s') out.session = args[++i];
+    else if (arg === '--message' || arg === '-m') out.message = args[++i];
+    else if (arg === '--timeout' || arg === '-t') {
+      const parsed = parseDuration(args[++i]);
+      if (!parsed) throw new Error('Invalid timeout value');
+      out.timeoutMs = parsed;
+    } else if (arg === '--url') out.url = args[++i];
+    else if (arg === '--help' || arg === '-h') out.help = true;
+    else positional.push(arg);
+  }
+  if (!out.session && positional.length) out.session = positional.shift();
+  if (!out.message && positional.length) out.message = positional.join(' ');
+  return out;
+}
+
+function readStdinIfAvailable() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+  });
+}
+
+function postJson(url, payload, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const target = new URL('/api/session/ask', url);
+    const body = JSON.stringify(payload);
+    const client = target.protocol === 'https:' ? https : http;
+    const req = client.request(target, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      timeout: timeoutMs + 5000,
+    }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        let parsed = {};
+        try { parsed = data ? JSON.parse(data) : {}; } catch {}
+        if (res.statusCode >= 400) {
+          const err = new Error(parsed.error || `CliDeck ask failed (${res.statusCode})`);
+          err.statusCode = res.statusCode;
+          return reject(err);
+        }
+        resolve(parsed);
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error('CliDeck ask timed out')));
+    req.on('error', reject);
+    req.end(body);
+  });
+}
+
+async function run(args) {
+  try {
+    const opts = parseArgs(args);
+    if (opts.help) {
+      console.log(usage());
+      return;
+    }
+    if (!opts.message) opts.message = (await readStdinIfAvailable()).trim();
+    if (!opts.session || !opts.message) throw new Error(usage());
+    const callerSessionId = process.env.CLIDECK_SESSION_ID || '';
+    if (!callerSessionId) throw new Error('CLIDECK_SESSION_ID is missing. Run this from inside a CliDeck session.');
+
+    const res = await postJson(opts.url, {
+      callerSessionId,
+      target: opts.session,
+      message: opts.message,
+      timeoutMs: opts.timeoutMs,
+    }, opts.timeoutMs);
+    process.stdout.write((res.response || '').trimEnd() + '\n');
+  } catch (e) {
+    process.stderr.write(`${e.message}\n`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { run, parseArgs, parseDuration };

package/config.js

@@ -119,6 +119,9 @@ function migrate(cfg) {
   // Backfill and sync fields from presets
   for (const cmd of cfg.commands) {
     const preset = cmd.presetId ? PRESETS.find(p => p.presetId === cmd.presetId) : matchPreset(cmd);
+    if (preset?.presetId === 'shell' && (!cmd.command || (cmd.command === '/bin/zsh' && !existsSync('/bin/zsh')))) {
+      cmd.command = defaultShell;
+    }
     // Stamp presetId for reliable lookup
     if (preset && !cmd.presetId) cmd.presetId = preset.presetId;
     // Icon always syncs from preset — the preset is the source of truth for logos

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clideck",
-  "version": "1.30.5",
+  "version": "1.30.7",
   "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": {

package/public/js/app.js

@@ -55,6 +55,9 @@ function connect() {
         state.resumable = msg.list;
         renderResumable();
         break;
+      case 'error':
+        showToast(msg.message || 'CliDeck action failed.', { type: 'error', title: 'CliDeck Error', duration: 5000 });
+        break;
       case 'sessions':
         {
           const liveIds = new Set(msg.list.map(s => s.id));

package/public/js/creator.js

@@ -104,33 +104,63 @@ function sortedPresets() {
 
 function createFromPreset(preset, sessionName, cwd, projectId) {
   // Find existing command matching this preset
-  let cmd = findCommandForPreset(preset);
-  // Auto-create the command if it doesn't exist yet
-  if (!cmd) {
-    cmd = {
-      id: crypto.randomUUID(),
-      presetId: preset.presetId,
-      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,
-      telemetryEnabled: telemetryEnabledForPreset(preset),
-      telemetryStatus: null,
-      bridge: preset.bridge,
-    };
-    state.cfg.commands.push(cmd);
-    send({ type: 'config.update', config: state.cfg });
-  }
+  const cmd = ensureCommandForPreset(preset);
   send({ type: 'create', commandId: cmd.id, name: sessionName, cwd, projectId: projectId || undefined, ...estimateSize() });
   localStorage.setItem(MRU_KEY, preset.presetId);
 }
 
+function ensureCommandForPreset(preset) {
+  let cmd = findCommandForPreset(preset);
+  if (cmd) return cmd;
+  cmd = {
+    id: crypto.randomUUID(),
+    presetId: preset.presetId,
+    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,
+    telemetryEnabled: telemetryEnabledForPreset(preset),
+    telemetryStatus: null,
+    bridge: preset.bridge,
+  };
+  state.cfg.commands.push(cmd);
+  send({ type: 'config.update', config: state.cfg });
+  return cmd;
+}
+
+function ensureShellCommand() {
+  let cmd = state.cfg.commands.find(c => c.presetId === 'shell' || (!c.isAgent && !c.presetId));
+  if (cmd) return cmd;
+  const shellPreset = state.presets.find(p => p.presetId === 'shell');
+  const command = shellPreset?.command || state.cfg.defaultShell;
+  if (!command) return null;
+  cmd = {
+    id: crypto.randomUUID(),
+    presetId: 'shell',
+    label: 'Shell',
+    icon: shellPreset?.icon || 'terminal',
+    command,
+    enabled: true,
+    defaultPath: '',
+    isAgent: false,
+    canResume: false,
+    resumeCommand: null,
+    sessionIdPattern: null,
+    outputMarker: null,
+    telemetryEnabled: false,
+    telemetryStatus: null,
+  };
+  state.cfg.commands.push(cmd);
+  send({ type: 'config.update', config: state.cfg });
+  return cmd;
+}
+
 export function openCreator() {
   // Toggle off if already open
   if (document.getElementById('session-creator')) {
@@ -273,12 +303,7 @@ export function openCreator() {
     if (setupBtn) {
       const preset = state.presets.find(p => p.presetId === setupBtn.dataset.preset);
       if (!preset) return;
-      let cmd = findCommandForPreset(preset);
-      if (!cmd) {
-        cmd = { id: crypto.randomUUID(), presetId: preset.presetId, 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, telemetryEnabled: telemetryEnabledForPreset(preset), telemetryStatus: null, bridge: preset.bridge };
-        state.cfg.commands.push(cmd);
-        send({ type: 'config.update', config: state.cfg });
-      }
+      const cmd = ensureCommandForPreset(preset);
       document.dispatchEvent(new CustomEvent('clideck:setup', { detail: { commandId: cmd.id } }));
       return;
     }
@@ -345,9 +370,16 @@ function showInstallToast(preset) {
   toast.querySelector('.add-btn').onclick = () => {
     dismiss();
     closeCreator();
+    ensureCommandForPreset(preset);
+    if (preset.telemetryAutoSetup) {
+      setTimeout(() => send({ type: 'telemetry.autosetup', presetId: preset.presetId }), 1000);
+    }
     // Find or create the shell command, then spawn a session running the install
-    const shellCmd = state.cfg.commands.find(c => c.presetId === 'shell' || (!c.isAgent && !c.presetId));
-    if (!shellCmd) return;
+    const shellCmd = ensureShellCommand();
+    if (!shellCmd) {
+      showToast('Could not find a shell command to run the installer.', { type: 'error', title: 'Install Failed' });
+      return;
+    }
     const installId = crypto.randomUUID();
     send({ type: 'create', commandId: shellCmd.id, name: `Installing ${preset.name}`, installId, ...estimateSize() });
     const handler = (e) => {

package/public/js/drag.js

@@ -21,6 +21,7 @@ export function initDrag() {
     // Project drag — grab by the header
     const projHeader = e.target.closest('.project-header');
     if (projHeader) {
+      if (document.querySelectorAll('.project-group').length <= 1) return;
       const group = projHeader.closest('.project-group');
       const rect = group.getBoundingClientRect();
       dragState = {

package/server.js

@@ -4,6 +4,14 @@ const { join, extname, resolve } = require('path');
 const { WebSocketServer } = require('ws');
 const { ensurePtyHelper } = require('./utils');
 
+function terminalLink(url, text = url) {
+  return `\u001B]8;;${url}\u0007${text}\u001B]8;;\u0007`;
+}
+
+function openUrlHint() {
+  return process.platform === 'darwin' ? 'Cmd+click to open' : 'Ctrl+click to open';
+}
+
 // --- Self-update check (runs before server starts) ---
 const currentVersion = require('./package.json').version;
 const { execFile, execSync } = require('child_process');
@@ -222,6 +230,12 @@ const server = http.createServer((req, res) => {
     return;
   }
 
+  // Session-to-session ask bridge used by the `clideck ask` CLI command.
+  if (req.method === 'POST' && req.url === '/api/session/ask') {
+    require('./session-ask').handleHttp(req, res, sessions);
+    return;
+  }
+
   // DEBUG: log any POST (agents might use /v1/traces, /v1/metrics, or other paths)
   if (req.method === 'POST') {
     // console.log(`OTLP: received POST ${req.url} (not handled)`);
@@ -280,6 +294,8 @@ process.on('SIGTERM', onShutdown);
 server.listen(PORT, HOST, () => {
   const v = require('./package.json').version;
   const url = `http://${HOST === '0.0.0.0' ? 'localhost' : HOST}:${PORT}`;
+  const clickableUrl = terminalLink(url);
+  const urlHint = openUrlHint();
   console.log(`
 \x1b[38;5;105m  ╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╸\x1b[0m
 
@@ -294,7 +310,7 @@ server.listen(PORT, HOST, () => {
 
 \x1b[38;5;245m  v${v}\x1b[0m
 
-\x1b[38;5;252m  ▸ Ready at \x1b[38;5;44m${url}\x1b[0m
+\x1b[38;5;252m  ▸ Ready at \x1b[38;5;44m${clickableUrl}\x1b[38;5;245m (${urlHint})\x1b[0m
 \x1b[38;5;245m  ▸ Stop with \x1b[38;5;252mCtrl+C\x1b[38;5;245m · Restart anytime with \x1b[38;5;252mclideck\x1b[0m
 ${HOST !== '127.0.0.1' ? '\x1b[38;5;208m  ▸ Warning: listening on ' + HOST + ' — no authentication, anyone on the network can connect\x1b[0m\n' : ''}`);
 });

package/session-ask.js

@@ -0,0 +1,171 @@
+const transcript = require('./transcript');
+
+const MAX_BODY = 2 * 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+const MAX_TIMEOUT_MS = 60 * 60 * 1000;
+
+function sendJson(res, status, payload) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(payload));
+}
+
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', chunk => {
+      body += chunk;
+      if (body.length > MAX_BODY) {
+        req.destroy();
+        reject(new Error('Request too large'));
+      }
+    });
+    req.on('end', () => {
+      try { resolve(body ? JSON.parse(body) : {}); }
+      catch { reject(new Error('Invalid JSON')); }
+    });
+    req.on('error', reject);
+  });
+}
+
+function jsonError(message, status = 400) {
+  const err = new Error(message);
+  err.status = status;
+  return err;
+}
+
+function isLoopback(req) {
+  const addr = req.socket?.remoteAddress || '';
+  return addr === '::1' || addr === '127.0.0.1' || addr.startsWith('127.') || addr.startsWith('::ffff:127.');
+}
+
+function normalizeTimeout(ms) {
+  const n = Number(ms || DEFAULT_TIMEOUT_MS);
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_TIMEOUT_MS;
+  return Math.min(Math.round(n), MAX_TIMEOUT_MS);
+}
+
+function sameProject(a, b) {
+  return (a.projectId || null) === (b.projectId || null);
+}
+
+function findTarget(sessions, callerId, caller, target) {
+  const trimmed = String(target || '').trim();
+  if (!trimmed) throw jsonError('Target session is required');
+
+  const byId = sessions.get(trimmed);
+  if (byId) {
+    if (trimmed === callerId) throw jsonError('Target session cannot be the caller session');
+    if (!sameProject(caller, byId)) throw jsonError('Target session is not in the caller project', 404);
+    return [trimmed, byId];
+  }
+
+  const sameProjectSessions = [...sessions]
+    .filter(([id, s]) => id !== callerId && sameProject(caller, s));
+  const exact = sameProjectSessions.filter(([, s]) => s.name === trimmed);
+  if (exact.length === 1) return exact[0];
+  if (exact.length > 1) throw jsonError(`Multiple sessions named "${trimmed}" in this project. Use the session id.`);
+
+  const lower = trimmed.toLowerCase();
+  const insensitive = sameProjectSessions.filter(([, s]) => String(s.name || '').toLowerCase() === lower);
+  if (insensitive.length === 1) return insensitive[0];
+  if (insensitive.length > 1) throw jsonError(`Multiple sessions named "${trimmed}" in this project. Use the session id.`);
+  throw jsonError(`No session named "${trimmed}" in this project`, 404);
+}
+
+function latestAgentTextSince(sessionId, sinceTs) {
+  const entries = transcript.getEntriesSince(sessionId, sinceTs)
+    .filter(e => e.role === 'agent' && String(e.text || '').trim());
+  return entries.length ? entries[entries.length - 1].text : '';
+}
+
+function waitForAnswer({ sessionsApi, targetId, sinceTs, timeoutMs }) {
+  const sessions = sessionsApi.getSessions();
+  const target = sessions.get(targetId);
+  let sawWorking = !!target?.working;
+  let settled = false;
+  let quietTimer = null;
+  let removeListener = null;
+  let timeout = null;
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      if (timeout) clearTimeout(timeout);
+      if (quietTimer) clearTimeout(quietTimer);
+      if (removeListener) removeListener();
+    };
+    const finish = () => {
+      if (settled) return;
+      const response = latestAgentTextSince(targetId, sinceTs);
+      if (!response) return;
+      settled = true;
+      cleanup();
+      resolve(response);
+    };
+    timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(jsonError('Timed out waiting for target session response', 504));
+    }, timeoutMs);
+
+    removeListener = sessionsApi.addBroadcastListener((msg) => {
+      if (msg.id !== targetId) return;
+      if (msg.type === 'session.status') {
+        if (msg.working) {
+          sawWorking = true;
+          return;
+        }
+        if (sawWorking) {
+          sessionsApi.broadcast({ type: 'terminal.capture', id: targetId });
+          setTimeout(finish, 700);
+        }
+      } else if (msg.type === 'output') {
+        if (quietTimer) clearTimeout(quietTimer);
+        quietTimer = setTimeout(() => {
+          if (!sessions.get(targetId)?.working) {
+            sessionsApi.broadcast({ type: 'terminal.capture', id: targetId });
+            setTimeout(finish, 700);
+          }
+        }, 2500);
+      }
+    });
+  });
+}
+
+async function askSession(payload, sessionsApi) {
+  const sessions = sessionsApi.getSessions();
+  const callerId = String(payload.callerSessionId || '').trim();
+  const caller = sessions.get(callerId);
+  if (!caller) throw jsonError('Caller session is not active', 404);
+
+  const [targetId, target] = findTarget(sessions, callerId, caller, payload.target);
+  if (target.working) throw jsonError(`Target session "${target.name}" is already working`, 409);
+
+  const message = String(payload.message || '').trim();
+  if (!message) throw jsonError('Message is required');
+
+  const timeoutMs = normalizeTimeout(payload.timeoutMs);
+  const sinceTs = Date.now();
+  const injected = `[CliDeck ask from ${caller.name || callerId.slice(0, 8)}]\n\n${message}`;
+
+  console.log(`[ask] ${caller.name || callerId.slice(0, 8)} -> ${target.name || targetId.slice(0, 8)} (${timeoutMs}ms timeout)`);
+  sessionsApi.input({ id: targetId, data: injected });
+  setTimeout(() => sessionsApi.input({ id: targetId, data: '\r' }), 150);
+
+  const response = await waitForAnswer({ sessionsApi, targetId, sinceTs, timeoutMs });
+  console.log(`[ask] completed ${target.name || targetId.slice(0, 8)} -> ${caller.name || callerId.slice(0, 8)}`);
+  return { targetSessionId: targetId, targetName: target.name, response };
+}
+
+async function handleHttp(req, res, sessionsApi) {
+  try {
+    if (!isLoopback(req)) throw jsonError('CliDeck ask only accepts local requests', 403);
+    const payload = await readJson(req);
+    const result = await askSession(payload, sessionsApi);
+    sendJson(res, 200, result);
+  } catch (e) {
+    sendJson(res, e.status || 500, { error: e.message || 'CliDeck ask failed' });
+  }
+}
+
+module.exports = { handleHttp, askSession };

package/sessions.js

@@ -24,7 +24,13 @@ let resumable = [];
 
 const broadcastListeners = [];
 
-function addBroadcastListener(fn) { broadcastListeners.push(fn); }
+function addBroadcastListener(fn) {
+  broadcastListeners.push(fn);
+  return () => {
+    const idx = broadcastListeners.indexOf(fn);
+    if (idx >= 0) broadcastListeners.splice(idx, 1);
+  };
+}
 
 function broadcast(msg) {
   const raw = JSON.stringify(msg);