@clastres/groundcontrol 0.1.12 → 0.1.13

package/daemon.mjs

@@ -22,7 +22,7 @@ import { createRequire } from 'node:module';
 
 const execFileP = promisify(execFile);
 
-const VERSION = '0.1.12';
+const VERSION = '0.1.13';
 const PACKAGE = '@clastres/groundcontrol';
 
 // ---------- config / pairing ----------
@@ -84,6 +84,16 @@ const LOG_FILE = path.join(CONF_DIR, 'daemon.log');
 const THIS_FILE = fs.realpathSync(fileURLToPath(import.meta.url));
 const runsFromServiceDir = THIS_FILE.startsWith(SERVICE_DIR + path.sep);
 
+// The service log had no times, so a run of "stale relay link" lines could not
+// be told apart: a Mac waking from sleep, or a link failing every minute.
+// Only daemon lines, and only in the service, so the setup output stays clean.
+if (runsFromServiceDir) {
+  const plain = console.log.bind(console);
+  console.log = (first, ...rest) => (typeof first === 'string' && first.startsWith('[daemon]')
+    ? plain(`${new Date().toISOString()} ${first}`, ...rest)
+    : plain(first, ...rest));
+}
+
 const launchctl = (args) => {
   try { return execSync(`launchctl ${args}`, { stdio: 'pipe' }).toString(); }
   catch (e) { return (e.stdout?.toString() || '') + (e.stderr?.toString() || ''); }
@@ -811,7 +821,7 @@ function canInject(tty) {
 }
 
 // Returns the method used, or null if no terminal path was found.
-async function injectPrompt(tty, text) {
+async function injectNow(tty, text) {
   const dev = `/dev/${tty}`;
   const apps = terminalApps();
   const clean = text.replace(/\r?\n/g, ' ').trim();
@@ -870,6 +880,18 @@ end tell`);
   return null;
 }
 
+// One injection per terminal at a time. Each is two writes with a pause
+// between them (the text, then Enter), so two prompts landing together would
+// interleave into one run on prompt and a stray Enter.
+const injecting = new Map(); // tty -> tail of its queue
+function injectPrompt(tty, text) {
+  const run = (injecting.get(tty) || Promise.resolve()).then(() => injectNow(tty, text));
+  const tail = run.catch(() => null);
+  injecting.set(tty, tail);
+  tail.then(() => { if (injecting.get(tty) === tail) injecting.delete(tty); });
+  return run;
+}
+
 const headlessActive = new Set(); // sessionIds with a headless --resume in flight
 
 const transcriptCache = new Map(); // sessionId -> file path
@@ -926,7 +948,9 @@ function readMessages(sessionId, maxBytes = 512 * 1024, limit = 80) {
     if (role !== 'user' && role !== 'assistant') continue;
     const text = extractText(e.message).trim();
     if (!text || /^(<system-reminder>|<command-name>|<local-command|<command-message|\[Request interrupted|\[SYSTEM NOTIFICATION)/.test(text)) continue;
-    out.push({ role, text: text.slice(0, 4000), ts: e.timestamp || null });
+    // uuid is Claude Code's own id for the line, stable for as long as the
+    // journal lives. The phone keys its rows on it; text is no identity.
+    out.push({ role, text: text.slice(0, 4000), ts: e.timestamp || null, ...(e.uuid ? { id: e.uuid } : {}) });
   }
   return out.slice(-limit);
 }
@@ -1506,8 +1530,63 @@ const askPayload = (ask, queued) => ({
   detail: ask.detail,
   at: ask.at,
   queued,
+  // ALWAYS only means something when Claude Code offered a rule to save.
+  // Apps before 0.1.11 ignore this and always show the button.
+  canAlways: ask.suggestions.length > 0,
+  ...(ask.questions ? { questions: ask.questions } : {}),
 });
 
+/// AskUserQuestion is a picker, not a yes or no. Allowing it without answers
+/// lets Claude carry on with nothing chosen, so the phone gets the questions
+/// themselves and answers them through updatedInput. Clipped, because every
+/// byte rides the relay and lands on a phone screen.
+function questionsOf(tool, input) {
+  if (tool !== 'AskUserQuestion' || !Array.isArray(input?.questions)) return null;
+  const qs = questionSources(input)
+    .map((q) => ({
+      question: q.question.slice(0, 600),
+      header: typeof q.header === 'string' ? q.header.slice(0, 40) : '',
+      multiSelect: q.multiSelect === true,
+      // choice is the default; text and number have no options to tap.
+      kind: typeof q.kind === 'string' ? q.kind : 'choice',
+      options: (Array.isArray(q.options) ? q.options : [])
+        .filter((o) => o && typeof o.label === 'string' && o.label)
+        .slice(0, 8)
+        .map((o) => ({
+          label: o.label.slice(0, 200),
+          description: typeof o.description === 'string' ? o.description.slice(0, 300) : '',
+        })),
+    }));
+  return qs.length ? qs : null;
+}
+
+/// The questions as Claude Code wrote them, in the order the phone sees them.
+/// Answers go back keyed by these full texts: the phone only ever sees a
+/// clipped copy, and Claude looks each answer up by the exact question.
+function questionSources(input) {
+  return (Array.isArray(input?.questions) ? input.questions : [])
+    .filter((q) => q && typeof q.question === 'string' && q.question)
+    .slice(0, 6);
+}
+
+/// The phone's picks, checked against the questions it was shown. Keys are
+/// the question text, which is how Claude Code looks them up; a multi select
+/// arrives as several labels and goes back joined, the way Claude's own
+/// picker reports it.
+function answersFor(ask, raw) {
+  if (!ask.questions || !raw || typeof raw !== 'object') return null;
+  const full = questionSources(ask.input);
+  const out = {};
+  ask.questions.forEach((q, i) => {
+    const v = raw[q.question];
+    const picked = (Array.isArray(v) ? v : [v])
+      .filter((x) => typeof x === 'string' && x.trim())
+      .map((x) => x.trim().slice(0, 2000));
+    if (picked.length) out[full[i]?.question ?? q.question] = picked.join(', ');
+  });
+  return Object.keys(out).length ? out : null;
+}
+
 function readSessions() {
   const sessions = [...readClaudeSessions(), ...readCodexSessions(), ...readKimiSessions()];
   const known = new Set(sessions.map((s) => s.id));
@@ -1691,6 +1770,12 @@ function summarizeTool(tool, input) {
       return { line: clip(i.url, 300), detail: clip(i.prompt, 300) };
     case 'WebSearch':
       return { line: clip(i.query, 300), detail: '' };
+    case 'AskUserQuestion': {
+      // The questions travel on their own (questionsOf); the line is just the
+      // first one, for older apps and the crew list.
+      const qs = Array.isArray(i.questions) ? i.questions : [];
+      return { line: clip(qs[0]?.question || 'Claude has a question', 300), detail: '' };
+    }
     default: {
       // Unknown or MCP tools: show whichever field reads most like a target,
       // and fall back to the whole input.
@@ -1716,6 +1801,13 @@ function settleAsk(ask, decision, outcome, note) {
   ask.done = true;
   clearTimeout(ask.holdTimer);
   dropAsk(ask);
+  // A hook that is already gone cannot take the answer. Saying "allowed" to
+  // the phone then would be a lie: the session never got it.
+  if (decision && (ask.socket.destroyed || !ask.socket.writable)) {
+    outcome = 'gone';
+    note = 'the session stopped waiting before your answer arrived';
+    decision = null;
+  }
   try { ask.socket.write(JSON.stringify({ decision: decision || null }) + '\n'); } catch {}
   try { ask.socket.end(); } catch {}
   console.log(`[daemon] permission ${ask.tool} ${outcome}${note ? `: ${note}` : ''}`);
@@ -1740,6 +1832,14 @@ function onPermissionRequest(req, socket) {
     tool: req.toolName || 'tool',
     line,
     detail,
+    // Kept whole for AskUserQuestion, whose answer is the same input with the
+    // answers added. Never sent to the phone as is.
+    input: req.toolInput && typeof req.toolInput === 'object' ? req.toolInput : {},
+    questions: questionsOf(req.toolName, req.toolInput),
+    // What Claude Code would save if you picked "don't ask again" on the Mac.
+    // ALWAYS on the phone sends these back as updatedPermissions; without
+    // them there is no rule to save, so the button is hidden.
+    suggestions: Array.isArray(req.permissionSuggestions) ? req.permissionSuggestions : [],
     cwd: req.cwd || '',
     at: Date.now(),
     socket,
@@ -2003,10 +2103,19 @@ function sendSnapshot(force = false) {
     return;
   }
   for (const s of sessions) if (s.rawStatus) lastRawStatus.set(s.id, s.rawStatus);
+  // A session that left the fleet takes its status with it. Kept, an idle from
+  // its last turn would read as "answered on the Mac" for the next request.
+  const present = new Set(sessions.map((s) => s.id));
+  for (const id of lastRawStatus.keys()) if (!present.has(id)) lastRawStatus.delete(id);
   const host = hostState();
   // Host state joins the dedupe key, otherwise flipping approvals on would not
-  // reach a phone whose session list happened not to change.
-  const json = JSON.stringify([sessions.map(({ lastMessage, ...s }) => ({ ...s, last: lastMessage?.text?.slice(0, 120) })), host]);
+  // reach a phone whose session list happened not to change. The last message
+  // is keyed on its time, role and length as well as its opening: two replies
+  // that start alike would otherwise look like one and the second never sent.
+  const json = JSON.stringify([sessions.map(({ lastMessage, ...s }) => ({
+    ...s,
+    last: lastMessage && [lastMessage.ts, lastMessage.role, lastMessage.text?.length, lastMessage.text?.slice(0, 120)],
+  })), host]);
   if (!force && json === lastSnapshotJson) return;
   lastSnapshotJson = json;
   if (ws?.readyState === 1) {
@@ -2042,33 +2151,58 @@ function watchTranscript(sessionId, holder = 'legacy', now = Date.now()) {
   if (holder === 'legacy') lapsedLegacy.delete(sessionId);
   const until = now + leaseFor(holder);
   const entry = watchers.get(sessionId);
-  if (entry) {
+  // A journal that was replaced or moved leaves the old watch listening to a
+  // file nobody writes. Renewals are the moment to notice and start over.
+  if (entry && !watchStale(sessionId, entry)) {
     entry.leases.set(holder, Math.max(until, entry.leases.get(holder) || 0));
     return 'renewed';
   }
+  const leases = entry ? entry.leases : new Map();
+  if (entry) closeWatch(sessionId, entry);
+  leases.set(holder, Math.max(until, leases.get(holder) || 0));
   const file = findTranscript(sessionId);
   if (!file) return null;
-  const next = { watcher: null, debounce: null, leases: new Map([[holder, until]]) };
+  const next = { watcher: null, debounce: null, firstAt: 0, file, ino: inodeOf(file), leases };
+  const push = () => {
+    clearTimeout(next.debounce);
+    next.debounce = null;
+    next.firstAt = 0;
+    toPhone({ type: 'transcript', sessionId, messages: readMessages(sessionId) });
+  };
   try {
-    // Journals are appended to, so watching the file is enough.
+    // Journals are appended to, so watching the file is enough. Debounced so
+    // a burst of writes is one read, but never for longer than a second: a
+    // turn that keeps writing would otherwise reach the phone only once it
+    // stopped, which is the chat that looks frozen while the Mac is busy.
     next.watcher = fs.watch(file, () => {
+      const t = Date.now();
+      if (!next.firstAt) next.firstAt = t;
       clearTimeout(next.debounce);
-      next.debounce = setTimeout(() => {
-        toPhone({ type: 'transcript', sessionId, messages: readMessages(sessionId) });
-      }, 250);
+      if (t - next.firstAt >= TRANSCRIPT_MAX_WAIT_MS) return push();
+      next.debounce = setTimeout(push, 250);
     });
+    next.watcher.on?.('error', () => closeWatch(sessionId, next, { keepIntent: true }));
     watchers.set(sessionId, next);
     console.log(`[daemon] watching transcript ${sessionId.slice(0, 8)}`);
     return 'created';
   } catch { return null; }
 }
 
+const TRANSCRIPT_MAX_WAIT_MS = 1000;
+const inodeOf = (file) => { try { return fs.statSync(file).ino; } catch { return 0; } };
+function watchStale(sessionId, entry) {
+  if (!entry.watcher) return true;
+  const file = findTranscript(sessionId);
+  return !!file && (file !== entry.file || inodeOf(file) !== entry.ino);
+}
+
 /// Keep an existing lease alive without starting a watch nobody asked for,
 /// except the one an older app's open chat lost to the clock.
 function renewWatch(sessionId, holder, now = Date.now()) {
   const entry = watchers.get(sessionId);
   if (entry?.leases.has(holder)) {
-    entry.leases.set(holder, now + leaseFor(holder));
+    if (watchStale(sessionId, entry)) watchTranscript(sessionId, holder, now);
+    else entry.leases.set(holder, now + leaseFor(holder));
     return;
   }
   if (holder === 'legacy' && lapsedLegacy.has(sessionId)) watchTranscript(sessionId, 'legacy', now);
@@ -2082,10 +2216,14 @@ function unwatchTranscript(sessionId, holder = 'legacy') {
   if (!entry.leases.size) closeWatch(sessionId, entry);
 }
 
-function closeWatch(sessionId, entry) {
+/// keepIntent leaves the leases in place with no watcher behind them, so the
+/// next renewal or getTranscript starts a fresh one instead of the chat going
+/// quiet for good after one watcher error.
+function closeWatch(sessionId, entry, { keepIntent = false } = {}) {
   clearTimeout(entry.debounce);
   try { entry.watcher?.close(); } catch {}
-  watchers.delete(sessionId);
+  entry.watcher = null;
+  if (!keepIntent && watchers.get(sessionId) === entry) watchers.delete(sessionId);
 }
 
 function expireWatches(now = Date.now()) {
@@ -2137,19 +2275,40 @@ async function handleCommand(cmd) {
       error: result.ok ? '' : (result.reason || 'could not change the setting'),
       host: hostState(),
     });
-  } else if (cmd.type === 'approve' || cmd.type === 'deny') {
+  } else if (cmd.type === 'approve' || cmd.type === 'deny' || cmd.type === 'answer') {
     const ask = cmd.askId ? pendingAsks.get(cmd.askId) : null;
     if (!ask) {
       // Answered on the Mac, expired, or the session moved on while the tap
-      // was in flight. Tell the phone so the card clears instead of hanging.
-      return toPhone({
+      // was in flight. Tell the phone so the card clears instead of hanging,
+      // and send the fleet with it: the phone draws the card from the
+      // snapshot, and a deduped one would never come.
+      toPhone({
         type: 'askResolved', askId: cmd.askId || '', sessionId: cmd.sessionId || '',
         outcome: 'gone', note: 'that request is no longer waiting',
       });
+      sendSnapshot(true);
+      return;
     }
-    if (cmd.type === 'approve') {
-      settleAsk(ask, { behavior: 'allow', ...(cmd.always ? { alwaysAllow: true } : {}) },
-        'allowed', cmd.always ? 'from the phone, and always from now on' : 'from the phone');
+    if (cmd.type === 'answer') {
+      const answers = answersFor(ask, cmd.answers);
+      if (!answers) {
+        // Nothing usable picked. Leave the request held; the card stays up.
+        return toPhone({ type: 'askResolved', askId: ask.id, sessionId: ask.sessionId, outcome: 'invalid', note: 'pick an answer first' });
+      }
+      settleAsk(ask, { behavior: 'allow', updatedInput: { ...ask.input, answers } },
+        'answered', 'from the phone');
+    } else if (cmd.type === 'approve' && ask.questions) {
+      // An app too old to show the choices can only say yes, and yes with no
+      // answer is a question skipped. Hand it back so it gets a real answer.
+      settleAsk(ask, null, 'released', 'this needs a choice, update the app or pick it');
+    } else if (cmd.type === 'approve') {
+      // Claude Code reads only behavior, updatedInput and updatedPermissions.
+      // Up to 0.1.12 ALWAYS sent alwaysAllow, which it drops, so the next
+      // matching call asked again. The suggestions are the exact rules it
+      // would have saved from its own "don't ask again" option.
+      const always = cmd.always === true && ask.suggestions.length > 0;
+      settleAsk(ask, { behavior: 'allow', ...(always ? { updatedPermissions: ask.suggestions } : {}) },
+        'allowed', always ? 'from the phone, and always from now on' : 'from the phone');
     } else {
       const reason = (cmd.text || '').trim();
       settleAsk(ask, { behavior: 'deny', message: reason || 'Denied from the Ground Control app.' },

package/hook.mjs

@@ -92,6 +92,9 @@ sock.on('connect', () => {
     cwd: payload.cwd || '',
     permissionMode: payload.permission_mode || '',
     permissionContext: payload.permission_context || null,
+    // The rules Claude Code would save for "don't ask again". ALWAYS on the
+    // phone hands these back; without them it has nothing to save.
+    permissionSuggestions: Array.isArray(payload.permission_suggestions) ? payload.permission_suggestions : [],
   }) + '\n');
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clastres/groundcontrol",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "See and command your coding agents from your iPhone. Pairs the Ground Control app with Claude Code, Codex and Kimi sessions running on this Mac, end to end encrypted.",
   "bin": {
     "groundcontrol": "bin/groundcontrol.mjs"

package/test/questions.mjs

@@ -0,0 +1,67 @@
+// Claude's question picker (AskUserQuestion) reaches the phone as questions,
+// and the phone's picks go back as the answers Claude Code reads from
+// updatedInput. Before this, the phone showed ALLOW and DENY for a question,
+// and allowing it let Claude carry on with nothing chosen.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DAEMON = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'daemon.mjs');
+const src = fs.readFileSync(DAEMON, 'utf8');
+const start = src.indexOf('/// The phone-facing shape of a held request.');
+const end = src.indexOf('function readSessions() {');
+if (start < 0 || end < 0 || end < start) throw new Error('could not locate the question helpers in daemon.mjs');
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+const { askPayload, questionsOf, answersFor } = new Function(
+  `${src.slice(start, end)}\n return { askPayload, questionsOf, answersFor };`,
+)();
+
+const input = {
+  questions: [
+    { question: 'Which database?', header: 'DB', multiSelect: false,
+      options: [{ label: 'Postgres', description: 'the usual' }, { label: 'SQLite' }] },
+    { question: 'Which extras?', header: 'Extras', multiSelect: true,
+      options: [{ label: 'Auth' }, { label: 'Billing' }, { label: 'Search' }] },
+  ],
+};
+
+const qs = questionsOf('AskUserQuestion', input);
+check('a question picker becomes questions for the phone', qs?.length === 2 && qs[0].options.length === 2);
+check('options keep their descriptions', qs[0].options[0].description === 'the usual');
+check('multi select survives', qs[1].multiSelect === true);
+check('any other tool has no questions', questionsOf('Bash', { command: 'ls' }) === null);
+check('a malformed input has none either', questionsOf('AskUserQuestion', { questions: 'nope' }) === null);
+
+const ask = { id: 'a1', tool: 'AskUserQuestion', line: 'Which database?', detail: '', at: 1, input, questions: qs, suggestions: [] };
+const payload = askPayload(ask, 1);
+check('the payload carries the questions', payload.questions === qs);
+check('and no ALWAYS without a rule to save', payload.canAlways === false);
+check('a request with a suggested rule offers ALWAYS',
+  askPayload({ ...ask, questions: null, suggestions: [{ type: 'addRules' }] }, 1).canAlways === true);
+check('a plain request sends no questions key', !('questions' in askPayload({ ...ask, questions: null }, 1)));
+
+const answers = answersFor(ask, { 'Which database?': 'Postgres', 'Which extras?': ['Auth', 'Search'] });
+check('a single pick answers by question text', answers?.['Which database?'] === 'Postgres');
+check('several picks go back joined', answers?.['Which extras?'] === 'Auth, Search');
+check('a question the phone was never shown is ignored',
+  !('Other?' in (answersFor(ask, { 'Which database?': 'SQLite', 'Other?': 'x' }) || {})));
+check('nothing picked is no answer at all', answersFor(ask, { 'Which database?': '  ' }) === null);
+const long = 'Why? '.repeat(200);
+const longInput = { questions: [{ question: long, options: [{ label: 'Because' }] }] };
+const longQs = questionsOf('AskUserQuestion', longInput);
+const longAnswers = answersFor({ input: longInput, questions: longQs }, { [longQs[0].question]: 'Because' });
+check('a long question is clipped for the phone', longQs[0].question.length === 600);
+check('but answered under its full text, which is what Claude looks up', longAnswers?.[long] === 'Because');
+check('free text is taken as is', answersFor(ask, { 'Which database?': 'MySQL, honestly' })?.['Which database?'] === 'MySQL, honestly');
+
+if (failures) {
+  console.log(`\n${failures} check(s) failed`);
+  process.exit(1);
+}
+console.log('\nall checks passed');

package/test/review-fixes.mjs

@@ -57,6 +57,21 @@ const check = (label, cond, detail = '') => {
     () => { throw new Error('shell'); },
     async () => {}, async () => 'notfound', (s) => s,
   )('ttys009', '-t is not a flag here');
+  // Two prompts at once into one terminal must not interleave.
+  const order = [];
+  const serial = new Function(
+    'terminalApps', 'execFileSync', 'execSync', 'sleep', 'osascript', 'escapeAS',
+    `${slice('// Returns the method used, or null if no terminal path was found.', 'const headlessActive = new Set();')}
+     return injectPrompt;`,
+  )(
+    () => ({ tmuxPanes: new Map([['/dev/ttys009', '%3']]), terminal: false, iterm: false }),
+    (file, args) => { order.push(args.includes('-l') ? args.at(-1) : 'Enter'); return Buffer.from(''); },
+    () => { throw new Error('shell'); },
+    () => new Promise((r) => setTimeout(r, 20)), async () => 'notfound', (s) => s,
+  );
+  await Promise.all([serial('ttys009', 'FIRST'), serial('ttys009', 'SECOND')]);
+  check('two prompts into one terminal go in one after the other',
+    order.join(',') === 'FIRST,Enter,SECOND,Enter', order.join(','));
   check('a prompt starting with a dash is not read as a tmux option',
     dashed[0]?.indexOf('--') === dashed[0]?.length - 2, JSON.stringify(dashed[0]));
 }
@@ -234,6 +249,36 @@ const check = (label, cond, detail = '') => {
   unwatchTranscript('s6', 'legacy');
   renewWatch('s6', 'legacy', now + 1000);
   check('a chat that was closed is not reopened by a later fetch', !watchers.has('s6'));
+
+  // A watcher that errors (journal replaced, volume hiccup) must not leave
+  // the chat silent for good: the next renewal starts a fresh one.
+  watchTranscript('s7', a, now);
+  const first = opened[opened.length - 1];
+  watchers.get('s7').watcher = null;          // what an 'error' leaves behind
+  check('a renewal after a watcher error watches again', watchTranscript('s7', a, now) === 'created'
+    && opened[opened.length - 1] !== first && watchers.has('s7'));
+  watchers.get('s7').watcher = null;
+  renewWatch('s7', a, now);
+  check('so does asking for the log', !!watchers.get('s7').watcher);
+}
+
+// ---------- a turn that never stops writing still streams ----------
+{
+  const opened = [];
+  const fakeFs = { watch(file, cb) { const w = { cb, close() {} }; opened.push(w); return w; } };
+  const sent = [];
+  const api = new Function('fs', 'findTranscript', 'readMessages', 'toPhone',
+    `${slice('const WATCH_LEASE_MS', 'async function handleCommand(cmd) {')}
+     return { watchTranscript };`,
+  )(fakeFs, (id) => `/tmp/${id}.jsonl`, () => [], (m) => sent.push(m));
+  api.watchTranscript('busy', 'phone:x');
+  const realNow = Date.now;
+  let t = realNow();
+  Date.now = () => t;
+  try {
+    for (let i = 0; i < 30; i++) { t += 100; opened[0].cb(); }   // a write every 100 ms for 3 s
+  } finally { Date.now = realNow; }
+  check('continuous writes reach the phone while they last, not only after', sent.length >= 2, `${sent.length} push(es) in 3 s`);
 }
 
 // ---------- the approvals socket comes back after a local takeover ----------