@clastres/groundcontrol 0.1.13 → 0.1.14

package/daemon.mjs

@@ -22,7 +22,7 @@ import { createRequire } from 'node:module';
 
 const execFileP = promisify(execFile);
 
-const VERSION = '0.1.13';
+const VERSION = '0.1.14';
 const PACKAGE = '@clastres/groundcontrol';
 
 // ---------- config / pairing ----------
@@ -821,7 +821,7 @@ function canInject(tty) {
 }
 
 // Returns the method used, or null if no terminal path was found.
-async function injectNow(tty, text) {
+async function injectNow(tty, text, returns = 2) {
   const dev = `/dev/${tty}`;
   const apps = terminalApps();
   const clean = text.replace(/\r?\n/g, ' ').trim();
@@ -854,7 +854,41 @@ async function injectNow(tty, text) {
 end tell`);
     if (r === 'ok') {
       await sleep(150);
-      await osascript(`tell application "iTerm2"
+      await pressEnter(tty, 'iterm');
+      return 'iterm';
+    }
+  }
+  if (apps.terminal) {
+    // do script always ends the text with its own newline, so the text and a
+    // Return arrive as one chunk and Claude Code takes them as a paste. Past
+    // about 40 characters that paste also swallows the next bare Return,
+    // whatever the delay: measured on 2.1.295, a 72 character prompt sat in
+    // the input box until a second Return. A Return on an empty box does
+    // nothing, so short prompts that already went through are safe. A menu
+    // is not an empty box, so the caller asks for fewer around one.
+    const r = await osascript(findTabScript('Terminal', dev, `do script "${escapeAS(clean)}" in tb`));
+    if (r === 'ok') {
+      for (let i = 0; i < returns; i++) {
+        await sleep(200);
+        await pressEnter(tty, 'terminal');
+      }
+      return 'terminal';
+    }
+  }
+  return null;
+}
+
+/// A bare Return into the terminal that hosts tty, through the same route the
+/// prompt took.
+async function pressEnter(tty, method) {
+  const dev = `/dev/${tty}`;
+  if (method === 'tmux') {
+    const pane = terminalApps().tmuxPanes.get(dev);
+    if (!pane) return false;
+    try { execFileSync('tmux', ['send-keys', '-t', pane, 'Enter'], { stdio: 'ignore' }); return true; } catch { return false; }
+  }
+  if (method === 'iterm') {
+    return await osascript(`tell application "iTerm2"
   repeat with w in windows
     repeat with tb in tabs of w
       repeat with s in sessions of tb
@@ -865,27 +899,28 @@ end tell`);
       end repeat
     end repeat
   end repeat
-end tell`);
-      return 'iterm';
-    }
-  }
-  if (apps.terminal) {
-    const r = await osascript(findTabScript('Terminal', dev, `do script "${escapeAS(clean)}" in tb`));
-    if (r === 'ok') {
-      await sleep(200);
-      await osascript(findTabScript('Terminal', dev, 'do script "" in tb'));
-      return 'terminal';
-    }
+end tell`) === 'ok';
   }
-  return null;
+  if (method === 'terminal') return await osascript(findTabScript('Terminal', dev, 'do script "" in tb')) === 'ok';
+  return false;
 }
 
 // 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.
+// interleave into one run on prompt and a stray Enter. `watch` is called as
+// the slot opens, so it sees the session as this prompt finds it rather than
+// before the one queued ahead of it. It may return how many Returns to send
+// and a check, which runs inside the slot, so a follow up Return cannot land
+// on the next prompt's text.
 const injecting = new Map(); // tty -> tail of its queue
-function injectPrompt(tty, text) {
-  const run = (injecting.get(tty) || Promise.resolve()).then(() => injectNow(tty, text));
+function injectPrompt(tty, text, watch) {
+  const run = (injecting.get(tty) || Promise.resolve()).then(async () => {
+    let plan = {};
+    try { plan = watch?.() || {}; } catch {}
+    const method = await injectNow(tty, text, plan.returns);
+    if (method && plan.check) { try { await plan.check(method); } catch {} }
+    return method;
+  });
   const tail = run.catch(() => null);
   injecting.set(tty, tail);
   tail.then(() => { if (injecting.get(tty) === tail) injecting.delete(tty); });
@@ -955,6 +990,41 @@ function readMessages(sessionId, maxBytes = 512 * 1024, limit = 80) {
   return out.slice(-limit);
 }
 
+// The terminal taking the keys is not Claude taking the prompt: a Return
+// swallowed by a paste leaves the text in the input box, and the phone used
+// to hear ok for it. An idle session writes a prompt to its journal the moment
+// it is submitted, so look for it there, press Return once more if it is
+// missing, and report through `result.landed` if it still is. Leaving idle
+// counts too: a queued prompt or a slow prompt hook journals nothing yet, and
+// a status that has not caught up with the prompt ahead must not read as a
+// lost one. Claude's own dialog and a slash command's picker take every
+// Return as a choice, so those keep the one Return they always got.
+const claudeStatus = (sessionId) => readClaudeSessions().find((s) => s.id === sessionId)?.rawStatus || null;
+const lastUserId = (sessionId) => readMessages(sessionId).findLast((m) => m.role === 'user')?.id || null;
+async function promptLanded(sessionId, before, ms = 2500) {
+  for (let waited = 0; waited < ms; waited += 250) {
+    await sleep(250);
+    if (lastUserId(sessionId) !== before || claudeStatus(sessionId) !== 'idle') return true;
+  }
+  return false;
+}
+function promptWatch(session, text, result) {
+  return () => {
+    const status = claudeStatus(session.id);
+    if (text.trim().startsWith('/') || status === 'waiting') return { returns: 1 };
+    if (status !== 'idle') return {};
+    const before = lastUserId(session.id);
+    return {
+      check: async (how) => {
+        if (await promptLanded(session.id, before)) return;
+        console.log(`[daemon] ${session.name} did not take the prompt, pressing Return again`);
+        await pressEnter(session.tty, how);
+        result.landed = await promptLanded(session.id, before);
+      },
+    };
+  };
+}
+
 function readClaudeSessions() {
   const sessions = [];
   let files = [];
@@ -2333,7 +2403,19 @@ async function handleCommand(cmd) {
 
     // Preferred path: type into the real terminal so the desktop updates live.
     if (session.live) {
-      const method = await injectPrompt(session.tty, cmd.text);
+      const result = { landed: true };
+      const method = await injectPrompt(session.tty, cmd.text, promptWatch(session, cmd.text, result));
+      if (method && !result.landed) {
+        console.log(`[daemon] prompt typed into ${session.name} via ${method} but never submitted`);
+        toPhone({
+          type: 'promptResult', sessionId: cmd.sessionId, ok: false,
+          error: 'Typed into the terminal on your Mac, but Claude did not take it. It may be waiting in the input box there.',
+        });
+        // Pressed by hand on the Mac, it still reaches the phone.
+        watchTranscript(cmd.sessionId, 'prompt');
+        sendSnapshot(true);
+        return;
+      }
       if (method) {
         console.log(`[daemon] injected prompt into ${session.name} via ${method}`);
         toPhone({ type: 'promptResult', sessionId: cmd.sessionId, ok: true, text: '' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clastres/groundcontrol",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "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/terminal-submit.mjs

@@ -0,0 +1,138 @@
+// A prompt typed into Terminal.app has to be submitted, not left in the input
+// box. On 2026-10-11 a 72 character prompt from the phone sat there unsent:
+// do script sends the text with its own newline, Claude Code takes that as a
+// paste, and the paste swallows the one Return that followed. Lift the real
+// injection code out of daemon.mjs and run it against a fake Terminal.
+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 from = '// Returns the method used, or null if no terminal path was found.';
+const start = src.indexOf(from);
+const end = src.indexOf('const headlessActive = new Set();', start);
+if (start < 0 || end < 0) throw new Error('could not locate the injection code in daemon.mjs');
+
+let failures = 0;
+const check = (label, cond, detail = '') => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}${detail ? `  ${detail}` : ''}`);
+  if (!cond) failures++;
+};
+
+const load = (scripts) => new Function(
+  'terminalApps', 'execFileSync', 'execSync', 'sleep', 'osascript', 'escapeAS', 'findTabScript',
+  `${src.slice(start, end)}
+   return { injectPrompt, pressEnter };`,
+)(
+  () => ({ tmuxPanes: new Map(), terminal: true, iterm: false }),
+  () => { throw new Error('no tmux here'); },
+  () => { throw new Error('no shell'); },
+  async () => {},
+  async (script) => { scripts.push(script.match(/do script "(.*)" in tb/)?.[1] ?? script); return 'ok'; },
+  (s) => s,
+  (app, dev, action) => action,
+);
+
+{
+  const scripts = [];
+  const { injectPrompt } = load(scripts);
+  const method = await injectPrompt('ttys005', 'Do we have pstack installed? Do you need it or do you have enough tools?');
+  check('a Terminal.app session is typed into through Terminal', method === 'terminal', `got ${method}`);
+  check('the text is followed by two bare Returns, enough to get past the paste',
+    scripts.length === 3 && scripts[1] === '' && scripts[2] === '', JSON.stringify(scripts));
+}
+
+{
+  // The session is read as this prompt's slot opens, after the prompt ahead
+  // of it went in, and the follow up check runs inside the slot: its extra
+  // Return must land before the next prompt is typed, not on top of it.
+  const scripts = [];
+  const { injectPrompt, pressEnter } = load(scripts);
+  const watch = (label) => () => { scripts.push(`WATCH ${label}`); return { check: async (how) => { scripts.push('CHECK'); await pressEnter('ttys005', how); } }; };
+  await Promise.all([injectPrompt('ttys005', 'FIRST', watch('1')), injectPrompt('ttys005', 'SECOND', watch('2'))]);
+  check('each prompt is watched from its own slot, with the extra Return before the next prompt',
+    scripts.join(',') === 'WATCH 1,FIRST,,,CHECK,,WATCH 2,SECOND,,,CHECK,', scripts.join(','));
+  let survived = true;
+  try {
+    await injectPrompt('ttys005', 'THIRD', () => ({ check: async () => { throw new Error('boom'); } }));
+    await injectPrompt('ttys005', 'FOURTH', () => { throw new Error('boom'); });
+  } catch { survived = false; }
+  check('a failing check does not turn a typed prompt into an error', survived);
+}
+
+{
+  // Fewer Returns where a Return is a choice: Claude's own dialog, a picker.
+  const scripts = [];
+  const { injectPrompt } = load(scripts);
+  await injectPrompt('ttys005', '/model', () => ({ returns: 1 }));
+  check('a slash command or an open dialog gets the one Return it always got',
+    scripts.length === 2 && scripts[1] === '', JSON.stringify(scripts));
+}
+
+// ---------- the handler's watch: is the prompt really in? ----------
+{
+  const wStart = src.indexOf('// The terminal taking the keys is not Claude taking the prompt');
+  const wEnd = src.indexOf('function readClaudeSessions()', wStart);
+  if (wStart < 0 || wEnd < 0) throw new Error('could not locate the prompt watch in daemon.mjs');
+  // A fake Claude: its status and journal change on cue as Returns are pressed.
+  const rig = ({ status = 'idle', onEnter = () => {} } = {}) => {
+    const st = { status, ids: ['u1'], enters: 0 };
+    const api = new Function(
+      'readClaudeSessions', 'readMessages', 'sleep', 'pressEnter', 'console',
+      `${src.slice(wStart, wEnd)}
+       return { promptWatch };`,
+    )(
+      () => [{ id: 's1', rawStatus: st.status }],
+      () => st.ids.map((id) => ({ role: 'user', id })),
+      async () => {},
+      async () => { st.enters++; onEnter(st); return true; },
+      { log() {} },
+    );
+    return { st, watch: (text = 'Do we have pstack installed? Do you need it or do you have enough tools?') => {
+      const result = { landed: true };
+      return { result, plan: api.promptWatch({ id: 's1', name: 'test', tty: 'ttys005' }, text, result)() };
+    } };
+  };
+
+  {
+    const { st, watch } = rig();
+    const { result, plan } = watch();
+    await plan.check('terminal');
+    check('a prompt stuck in the box gets one more Return, then is reported as not taken',
+      st.enters === 1 && result.landed === false, `enters ${st.enters}, landed ${result.landed}`);
+  }
+  {
+    const { st, watch } = rig({ onEnter: (x) => x.ids.push('u2') });
+    const { result, plan } = watch();
+    await plan.check('terminal');
+    check('one that the extra Return submits counts as landed', st.enters === 1 && result.landed === true);
+  }
+  {
+    const { st, watch } = rig();
+    const { result, plan } = watch();
+    st.ids.push('u2');
+    await plan.check('terminal');
+    check('one that went straight in gets no extra Return', st.enters === 0 && result.landed === true);
+  }
+  {
+    // The status file lags the prompt ahead by about a tenth of a second,
+    // so this one was read as idle and then got queued: nothing journaled.
+    const { st, watch } = rig();
+    const { result, plan } = watch();
+    st.status = 'busy';
+    await plan.check('terminal');
+    check('one queued behind a turn that just started is not called lost', st.enters === 0 && result.landed === true);
+  }
+  const plans = {
+    busy: rig({ status: 'busy' }).watch().plan,
+    waiting: rig({ status: 'waiting' }).watch().plan,
+    slash: rig().watch('/model').plan,
+  };
+  check('a busy session is typed into as usual with nothing to check', !plans.busy.check && plans.busy.returns === undefined);
+  check('Claude\'s own dialog gets one Return and no check', plans.waiting.returns === 1 && !plans.waiting.check);
+  check('a slash command gets one Return and no check', plans.slash.returns === 1 && !plans.slash.check);
+}
+
+console.log(failures ? `\n${failures} check(s) failed` : '\nall checks passed');
+process.exit(failures ? 1 : 0);