clideck 1.31.6 → 1.31.8

package/bin/clideck.js

@@ -1,8 +1,58 @@
 #!/usr/bin/env node
 const args = process.argv.slice(2);
 
-if (args[0] === 'ask') {
+function usage() {
+  const version = require('../package.json').version;
+  return [
+    `CliDeck v${version}`,
+    '',
+    'Usage:',
+    '  clideck [--host <host>] [--port <port>]',
+    '  clideck agents [--json]',
+    '  clideck ask --session <name-or-id> --message <text> [--timeout 10m]',
+    '',
+    'Options:',
+    '  --host <host>     Host to bind. Default: 127.0.0.1. Use 0.0.0.0 for LAN access.',
+    '  --port <port>     Port to use. Default: 4000. Can also use CLIDECK_PORT.',
+    '  -h, --help        Show this help.',
+    '  -v, --version     Show version.',
+    '',
+    'Agent tools:',
+    '  clideck agents',
+    '    Lists active sessions in the same project as the caller session.',
+    '    Use this first when an agent needs to discover who it can ask.',
+    '',
+    '  clideck ask',
+    '    Use from inside a CliDeck session when one agent needs an answer from another session.',
+    '',
+    'Ask behavior:',
+    '  Target lookup is limited to the same project as the caller session.',
+    '  CliDeck sends the message into the real target terminal, presses Enter, waits for the',
+    '  target to finish, then prints the target agent response to stdout.',
+    '',
+    'Examples:',
+    '  clideck agents',
+    '  clideck agents --json',
+    '  clideck ask --session "Reviewer" --message "Review my changes and return only findings."',
+    '  clideck ask "research manager" "Check this plan and tell me what is missing." --timeout 15m',
+    '  cat notes.md | clideck ask --session "Docs Writer" --timeout 10m',
+    '',
+    'Notes for agents:',
+    '  Run `clideck agents` to discover available same-project sessions.',
+    '  Run `clideck ask --help` for the exact ask command contract.',
+    '  If the target name has spaces, quote it.',
+    '  If several sessions have the same name in the same project, use the session id.',
+  ].join('\n');
+}
+
+if (args[0] === 'agents') {
+  require('../clideck-agents-cli').run(args.slice(1));
+} else if (args[0] === 'ask') {
   require('../clideck-ask-cli').run(args.slice(1));
+} else if (args.includes('--help') || args.includes('-h')) {
+  console.log(usage());
+} else if (args.includes('--version') || args.includes('-v')) {
+  console.log(require('../package.json').version);
 } else {
   require('../server.js');
 }

package/clideck-agents-cli.js

@@ -0,0 +1,85 @@
+const http = require('http');
+const https = require('https');
+
+function usage() {
+  return [
+    'Usage:',
+    '  clideck agents [--json]',
+    '',
+    'Lists active CliDeck sessions in the same project as the caller session.',
+    'Use this from inside a CliDeck session before `clideck ask` to discover target names.',
+    '',
+    'Options:',
+    '  --json       Print machine-readable JSON.',
+    '  --url <url>  CliDeck server URL. Default: CLIDECK_URL or http://127.0.0.1:<port>.',
+    '  -h, --help   Show this help.',
+  ].join('\n');
+}
+
+function parseArgs(args) {
+  const port = process.env.CLIDECK_PORT || process.env.PORT || '4000';
+  const out = { json: false, url: process.env.CLIDECK_URL || `http://127.0.0.1:${port}` };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') out.json = true;
+    else if (arg === '--url') out.url = args[++i];
+    else if (arg === '--help' || arg === '-h') out.help = true;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  return out;
+}
+
+function getJson(url, callerSessionId) {
+  return new Promise((resolve, reject) => {
+    const target = new URL('/api/session/agents', url);
+    target.searchParams.set('callerSessionId', callerSessionId);
+    const client = target.protocol === 'https:' ? https : http;
+    const req = client.get(target, (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 agents failed (${res.statusCode})`);
+          err.statusCode = res.statusCode;
+          return reject(err);
+        }
+        resolve(parsed);
+      });
+    });
+    req.on('error', reject);
+  });
+}
+
+function formatAgents(agents) {
+  if (!agents.length) return 'No active sessions found in this project.';
+  return agents.map(a => {
+    const marker = a.caller ? 'self' : 'peer';
+    const status = a.working ? 'working' : 'idle';
+    const preview = a.lastPreview ? ` - ${a.lastPreview}` : '';
+    return `${a.name} (${marker}, ${a.preset}, ${status}) id=${a.id}${preview}`;
+  }).join('\n');
+}
+
+async function run(args) {
+  try {
+    const opts = parseArgs(args);
+    if (opts.help) {
+      console.log(usage());
+      return;
+    }
+    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 getJson(opts.url, callerSessionId);
+    if (opts.json) process.stdout.write(JSON.stringify(res.agents || [], null, 2) + '\n');
+    else process.stdout.write(formatAgents(res.agents || []) + '\n');
+  } catch (e) {
+    process.stderr.write(`${e.message}\n`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { run, parseArgs, formatAgents };

package/clideck-ask-cli.js

@@ -6,6 +6,19 @@ function usage() {
     'Usage:',
     '  clideck ask --session <name-or-id> --message <text> [--timeout 10m]',
     '  clideck ask <name-or-id> <message> [--timeout 10m]',
+    '  cat file.txt | clideck ask --session <name-or-id> [--timeout 10m]',
+    '',
+    'Use from inside a CliDeck session when this agent needs an answer from another active session.',
+    'Target lookup is limited to the same project as the caller session.',
+    'Run `clideck agents` first to discover available target sessions.',
+    '',
+    'Options:',
+    '  -s, --session <name-or-id>  Target session name or id.',
+    '  -m, --message <text>       Message to send. If omitted, stdin is used.',
+    '  -t, --timeout <duration>   Wait time. Examples: 30s, 10m, 1h. Default: 10m.',
+    '  --url <url>                CliDeck server URL. Default: CLIDECK_URL or local port.',
+    '  --no-progress              Do not print waiting hints to stderr.',
+    '  -h, --help                 Show this help.',
   ].join('\n');
 }
 
@@ -21,7 +34,7 @@ function parseDuration(value) {
 
 function parseArgs(args) {
   const port = process.env.CLIDECK_PORT || process.env.PORT || '4000';
-  const out = { timeoutMs: 10 * 60 * 1000, url: process.env.CLIDECK_URL || `http://127.0.0.1:${port}` };
+  const out = { timeoutMs: 10 * 60 * 1000, url: process.env.CLIDECK_URL || `http://127.0.0.1:${port}`, progress: true };
   const positional = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -32,6 +45,7 @@ function parseArgs(args) {
       if (!parsed) throw new Error('Invalid timeout value');
       out.timeoutMs = parsed;
     } else if (arg === '--url') out.url = args[++i];
+    else if (arg === '--no-progress') out.progress = false;
     else if (arg === '--help' || arg === '-h') out.help = true;
     else positional.push(arg);
   }
@@ -50,6 +64,101 @@ function readStdinIfAvailable() {
   });
 }
 
+function formatDuration(ms) {
+  const totalSeconds = Math.max(0, Math.round(ms / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) return seconds ? `${minutes}m ${seconds}s` : `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const restMinutes = minutes % 60;
+  return restMinutes ? `${hours}h ${restMinutes}m` : `${hours}h`;
+}
+
+function oneLine(text, max = 160) {
+  const compact = String(text || '').replace(/\s+/g, ' ').trim();
+  return compact.length > max ? compact.slice(0, max - 1) + '…' : compact;
+}
+
+function getJson(url, path, timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(path, url);
+    const client = target.protocol === 'https:' ? https : http;
+    const req = client.get(target, { timeout: timeoutMs }, (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 request failed (${res.statusCode})`);
+          err.statusCode = res.statusCode;
+          return reject(err);
+        }
+        resolve(parsed);
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error('CliDeck progress check timed out')));
+    req.on('error', reject);
+  });
+}
+
+function findAgent(agents, target) {
+  const text = String(target || '').trim();
+  if (!text) return null;
+  const byId = agents.filter(a => a.id === text);
+  if (byId.length === 1) return byId[0];
+  const exact = agents.filter(a => a.name === text);
+  if (exact.length === 1) return exact[0];
+  const lower = text.toLowerCase();
+  const insensitive = agents.filter(a => String(a.name || '').toLowerCase() === lower);
+  return insensitive.length === 1 ? insensitive[0] : null;
+}
+
+function startProgressHints(opts, callerSessionId) {
+  if (!opts.progress) return () => {};
+  const started = Date.now();
+  let stopped = false;
+  let lastLine = '';
+
+  const write = (line) => {
+    if (!line || line === lastLine) return;
+    lastLine = line;
+    process.stderr.write(`${line}\n`);
+  };
+
+  write(`[clideck ask] sent to "${opts.session}". waiting up to ${formatDuration(opts.timeoutMs)}. keep waiting until this command exits.`);
+
+  const tick = async () => {
+    if (stopped) return;
+    try {
+      const path = `/api/session/agents?callerSessionId=${encodeURIComponent(callerSessionId)}`;
+      const res = await getJson(opts.url, path, 4000);
+      const agent = findAgent(res.agents || [], opts.session);
+      const elapsed = formatDuration(Date.now() - started);
+      if (!agent) {
+        write(`[clideck ask] still waiting for "${opts.session}" (${elapsed} elapsed).`);
+        return;
+      }
+      const status = agent.working ? 'working' : 'idle/capturing answer';
+      const preview = oneLine(agent.lastPreview);
+      write(`[clideck ask] "${agent.name}" is ${status} (${elapsed} elapsed).${preview ? ` latest: ${preview}` : ''}`);
+    } catch {
+      const elapsed = formatDuration(Date.now() - started);
+      write(`[clideck ask] still waiting for "${opts.session}" (${elapsed} elapsed).`);
+    }
+  };
+
+  const first = setTimeout(tick, 5000);
+  const interval = setInterval(tick, 15000);
+  return () => {
+    stopped = true;
+    clearTimeout(first);
+    clearInterval(interval);
+  };
+}
+
 function postJson(url, payload, timeoutMs) {
   return new Promise((resolve, reject) => {
     const target = new URL('/api/session/ask', url);
@@ -95,12 +204,13 @@ async function run(args) {
     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 stopProgress = startProgressHints(opts, callerSessionId);
     const res = await postJson(opts.url, {
       callerSessionId,
       target: opts.session,
       message: opts.message,
       timeoutMs: opts.timeoutMs,
-    }, opts.timeoutMs);
+    }, opts.timeoutMs).finally(stopProgress);
     process.stdout.write((res.response || '').trimEnd() + '\n');
   } catch (e) {
     process.stderr.write(`${e.message}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clideck",
-  "version": "1.31.6",
+  "version": "1.31.8",
   "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/server.js

@@ -237,6 +237,12 @@ const server = http.createServer((req, res) => {
     return;
   }
 
+  // Agent discovery bridge used by the `clideck agents` CLI command.
+  if (req.method === 'GET' && req.url.startsWith('/api/session/agents')) {
+    require('./session-agents').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)`);

package/session-agents.js

@@ -0,0 +1,53 @@
+function sendJson(res, status, payload) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(payload));
+}
+
+function isLoopback(req) {
+  const addr = req.socket?.remoteAddress || '';
+  return addr === '::1' || addr === '127.0.0.1' || addr.startsWith('127.') || addr.startsWith('::ffff:127.');
+}
+
+function sameProject(a, b) {
+  return (a.projectId || null) === (b.projectId || null);
+}
+
+function listProjectAgents(callerSessionId, sessionsApi) {
+  const sessions = sessionsApi.getSessions();
+  const callerId = String(callerSessionId || '').trim();
+  const caller = sessions.get(callerId);
+  if (!caller) {
+    const err = new Error('Caller session is not active');
+    err.status = 404;
+    throw err;
+  }
+
+  return [...sessions]
+    .filter(([, s]) => sameProject(caller, s))
+    .map(([id, s]) => ({
+      id,
+      name: s.name || id.slice(0, 8),
+      preset: s.presetId || 'shell',
+      working: !!s.working,
+      lastPreview: s.lastPreview || '',
+      lastActivityAt: s.lastActivityAt || null,
+      caller: id === callerId,
+    }));
+}
+
+async function handleHttp(req, res, sessionsApi) {
+  try {
+    if (!isLoopback(req)) {
+      const err = new Error('CliDeck agents only accepts local requests');
+      err.status = 403;
+      throw err;
+    }
+    const url = new URL(req.url, 'http://127.0.0.1');
+    const agents = listProjectAgents(url.searchParams.get('callerSessionId'), sessionsApi);
+    sendJson(res, 200, { agents });
+  } catch (e) {
+    sendJson(res, e.status || 500, { error: e.message || 'CliDeck agents failed' });
+  }
+}
+
+module.exports = { handleHttp, listProjectAgents };

package/session-ask.js

@@ -78,6 +78,38 @@ function latestAgentTextSince(sessionId, sinceTs) {
   return entries.length ? entries[entries.length - 1].text : '';
 }
 
+function previewTextSince(session, sinceTs) {
+  const text = String(session?.lastPreview || '').trim();
+  if (!text) return '';
+  const ts = Date.parse(session.lastActivityAt || '');
+  return Number.isFinite(ts) && ts >= sinceTs ? text : '';
+}
+
+function latestAnswerTextSince(sessions, sessionId, sinceTs) {
+  return latestAgentTextSince(sessionId, sinceTs)
+    || previewTextSince(sessions.get(sessionId), sinceTs);
+}
+
+function askSubmitDelay(message) {
+  const len = String(message || '').length;
+  return Math.min(2500, Math.max(500, 300 + Math.ceil(len / 80) * 100));
+}
+
+function submitAskInput(sessionsApi, targetId, message) {
+  const sessions = sessionsApi.getSessions();
+  const timers = [];
+
+  sessionsApi.input({ id: targetId, data: message });
+  const delay = askSubmitDelay(message);
+  timers.push(setTimeout(() => sessionsApi.input({ id: targetId, data: '\r' }), delay));
+  timers.push(setTimeout(() => {
+    const target = sessions.get(targetId);
+    if (target && !target.working) sessionsApi.input({ id: targetId, data: '\r' });
+  }, delay + 1500));
+
+  return () => timers.forEach(clearTimeout);
+}
+
 function waitForAnswer({ sessionsApi, targetId, sinceTs, timeoutMs }) {
   const sessions = sessionsApi.getSessions();
   const target = sessions.get(targetId);
@@ -95,7 +127,7 @@ function waitForAnswer({ sessionsApi, targetId, sinceTs, timeoutMs }) {
     };
     const finish = () => {
       if (settled) return;
-      const response = latestAgentTextSince(targetId, sinceTs);
+      const response = latestAnswerTextSince(sessions, targetId, sinceTs);
       if (!response) return;
       settled = true;
       cleanup();
@@ -149,10 +181,9 @@ async function askSession(payload, sessionsApi) {
   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 cancelSubmit = submitAskInput(sessionsApi, targetId, injected);
 
-  const response = await waitForAnswer({ sessionsApi, targetId, sinceTs, timeoutMs });
+  const response = await waitForAnswer({ sessionsApi, targetId, sinceTs, timeoutMs }).finally(cancelSubmit);
   console.log(`[ask] completed ${target.name || targetId.slice(0, 8)} -> ${caller.name || callerId.slice(0, 8)}`);
   return { targetSessionId: targetId, targetName: target.name, response };
 }
@@ -168,4 +199,4 @@ async function handleHttp(req, res, sessionsApi) {
   }
 }
 
-module.exports = { handleHttp, askSession };
+module.exports = { handleHttp, askSession, askSubmitDelay };