mixdog 0.9.171 → 0.9.172

package/src/tui/session/live-share/owner.mjs

@@ -0,0 +1,235 @@
+/**
+ * src/tui/session/live-share/owner.mjs - owner leg: named-pipe / unix-socket
+ * server bound to ONE session id, pushing frame-batched deltas to attached
+ * viewers and relaying their submit/abort frames into the owner queue.
+ */
+import { createServer } from 'node:net';
+import { unlinkSync } from 'node:fs';
+import { attachLineReader, destroyQuietly, frameLine } from './wire.mjs';
+import { EMPTY_BASELINE, baselineOf, deltaFrame, fullFrame } from './delta.mjs';
+import { createRetryTimer } from './retry.mjs';
+
+function isSubmitFrame(frame) {
+  return (
+    frame.t === 'submit' &&
+    ((typeof frame.text === 'string' && frame.text.trim()) ||
+      typeof frame.prompt === 'string' ||
+      Array.isArray(frame.prompt))
+  );
+}
+
+function unlinkQuietly(path) {
+  if (process.platform === 'win32' || !path) return;
+  try {
+    unlinkSync(path);
+  } catch {
+    /* never created / already gone */
+  }
+}
+
+export function createOwnerLeg({
+  ownerSessionId,
+  socketPathFor,
+  getPublishedState,
+  onRemoteSubmit,
+  onRemoteAbort,
+  isDisposed,
+  retryMinMs,
+  retryMaxMs,
+}) {
+  let server = null;
+  let serverId = '';
+  let serverPath = '';
+  const sockets = new Set();
+  let baseline = EMPTY_BASELINE;
+  const retry = createRetryTimer({
+    minMs: retryMinMs,
+    maxMs: retryMaxMs,
+    shouldStart: (id) => !isDisposed() && !server && String(ownerSessionId() || '') === id,
+    start: (id) => startServer(id),
+  });
+
+  const broadcast = (frame) => {
+    if (sockets.size === 0) return;
+    const line = frameLine(frame);
+    for (const socket of sockets) {
+      try {
+        socket.write(line);
+      } catch {
+        /* per-socket close handles it */
+      }
+    }
+  };
+
+  // This pipe is bound to ONE session id (serverId). When the surface changes
+  // session identity — /new, /clear, a resume of another session, a context
+  // switch — the published store frames stop describing the session this pipe
+  // represents. Pushing them anyway handed a co-open viewer an empty (or
+  // foreign) transcript until the close/promote path restored it, which is the
+  // flash seen in the desktop app when the terminal ran /new. Frames are
+  // DROPPED without re-baselining, so a pipe that keeps its id (/clear) still
+  // ships the post-reset delta once the reset settles; a pipe whose id changed
+  // is torn down by the next ensure().
+  const frameStale = () => Boolean(serverId) && String(ownerSessionId() || '') !== serverId;
+
+  // Runs on every frame-batched publish. With no viewers it only re-baselines.
+  const onPublish = () => {
+    const st = getPublishedState();
+    if (!server || sockets.size === 0) {
+      baseline = baselineOf(st, '');
+      return;
+    }
+    if (frameStale()) return;
+    const next = deltaFrame(baseline, st);
+    baseline = next.baseline;
+    if (next.frame) broadcast(next.frame);
+  };
+
+  const acceptSubmit = (socket, frame) => {
+    // Optional submission metadata (additive, old viewers omit it): the
+    // originating surface's submission id must survive the pipe so its
+    // optimistic user row releases when the SAME id settles in the
+    // owner's transcript (user: 방금 친 메세지가 2개 남는다).
+    const id = typeof frame.id === 'string' && frame.id.trim() ? frame.id : undefined;
+    const submittedAt = Number(frame.submittedAt);
+    const prompt = frame.prompt ?? frame.text;
+    const delivered =
+      onRemoteSubmit(prompt, {
+        ...(frame.options && typeof frame.options === 'object' ? frame.options : {}),
+        ...(id ? { id } : {}),
+        ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt: Math.round(submittedAt) } : {}),
+      }) !== false;
+    // Acknowledge the verdict (additive: viewers without ack tokens are
+    // unaffected). A refusal travels back as ok:false so the sender
+    // re-delivers instead of assuming the prompt landed.
+    const ackId = typeof frame.ack === 'string' && frame.ack.trim() ? frame.ack : '';
+    if (!ackId) return;
+    try {
+      socket.write(frameLine({ t: 'submit-ack', ack: ackId, ok: delivered }));
+    } catch {
+      /* close handles it; the sender's ack timeout re-delivers */
+    }
+  };
+
+  const handleViewerFrame = (socket, frame) => {
+    if (isSubmitFrame(frame)) {
+      acceptSubmit(socket, frame);
+    } else if (frame.t === 'abort') {
+      // Viewer stop button: interrupt the owner's active turn here — the
+      // viewer process has no turn of its own to cancel.
+      onRemoteAbort?.();
+    } else if (frame.t === 'sync') {
+      if (frameStale()) return;
+      try {
+        socket.write(frameLine(fullFrame(serverId, getPublishedState())));
+      } catch {
+        /* close handles */
+      }
+    }
+  };
+
+  const attachViewer = (socket) => {
+    socket.setNoDelay?.(true);
+    sockets.add(socket);
+    const cleanup = () => sockets.delete(socket);
+    socket.on('close', cleanup);
+    socket.on('error', () => {
+      cleanup();
+      destroyQuietly(socket);
+    });
+    attachLineReader(
+      socket,
+      (frame) => handleViewerFrame(socket, frame),
+      () => destroyQuietly(socket)
+    );
+    try {
+      // Connected mid-reset: this state belongs to another session, and a
+      // baseline taken from it would desync every later delta. Drop the
+      // socket — the viewer's own retry finds the rebound pipe (or promotes).
+      if (frameStale()) {
+        destroyQuietly(socket);
+        return;
+      }
+      const st = getPublishedState();
+      baseline = baselineOf(st);
+      socket.write(frameLine(fullFrame(serverId, st)));
+    } catch {
+      destroyQuietly(socket);
+    }
+  };
+
+  const stopServer = () => {
+    retry.clear();
+    retry.reset();
+    if (!server) {
+      serverId = '';
+      serverPath = '';
+      return;
+    }
+    try {
+      broadcast({ t: 'close' });
+    } catch {
+      /* sockets closing anyway */
+    }
+    for (const socket of sockets) destroyQuietly(socket);
+    sockets.clear();
+    const closing = server;
+    server = null;
+    try {
+      closing.close();
+    } catch {
+      /* already closed */
+    }
+    unlinkQuietly(serverPath);
+    serverId = '';
+    serverPath = '';
+  };
+
+  // EADDRINUSE (another live owner) or a transient listen failure: retry
+  // with a short bounded backoff while this surface still owns the id.
+  const retryAfterListenFailure = (id) => {
+    server = null;
+    serverId = '';
+    serverPath = '';
+    retry.schedule(id);
+  };
+
+  const startServer = (id) => {
+    if (isDisposed() || server || !id) return;
+    retry.clear();
+    const path = socketPathFor(id);
+    const next = createServer(attachViewer);
+    next.on('error', () => {
+      if (server === next) retryAfterListenFailure(id);
+      try {
+        next.close();
+      } catch {
+        /* already closed */
+      }
+    });
+    next.on('listening', () => {
+      if (server !== next) return;
+      retry.clear();
+      retry.reset();
+    });
+    unlinkQuietly(path);
+    server = next;
+    serverId = id;
+    serverPath = path;
+    try {
+      next.listen(path);
+    } catch {
+      retryAfterListenFailure(id);
+    }
+  };
+
+  // Reconcile against the session this surface currently owns ('' = none).
+  const ensure = (ownerId) => {
+    if (retry.id() && retry.id() !== ownerId) retry.clear();
+    if (!ownerId && retry.pending()) retry.clear();
+    if (serverId && serverId !== ownerId) stopServer();
+    if (ownerId && !server && !retry.pending()) startServer(ownerId);
+  };
+
+  return { ensure, stop: stopServer, onPublish };
+}

package/src/tui/session/live-share/retry.mjs

@@ -0,0 +1,39 @@
+/**
+ * src/tui/session/live-share/retry.mjs - bounded exponential retry timer for
+ * pipe opens, keyed by the session id the pending retry belongs to.
+ */
+export function createRetryTimer({ minMs, maxMs, shouldStart, start }) {
+  let timer = null;
+  let id = '';
+  let delayMs = minMs;
+
+  function clear() {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    id = '';
+  }
+
+  function schedule(target) {
+    const next = String(target || '');
+    if (!next || timer || !shouldStart(next)) return;
+    const delay = delayMs;
+    delayMs = Math.min(maxMs, Math.max(minMs, delayMs * 2));
+    id = next;
+    timer = setTimeout(() => {
+      timer = null;
+      id = '';
+      if (shouldStart(next)) start(next);
+    }, delay);
+    timer.unref?.();
+  }
+
+  return {
+    id: () => id,
+    pending: () => Boolean(timer),
+    clear,
+    reset: () => {
+      delayMs = minMs;
+    },
+    schedule,
+  };
+}

package/src/tui/session/live-share/viewer/submit-acks.mjs

@@ -0,0 +1,65 @@
+/**
+ * live-share/viewer/submit-acks.mjs - submit delivery tracking. A pipe write
+ * only proves the bytes left this process: the owner can REFUSE the prompt
+ * (disposed / itself attached) and the socket can die before it is read.
+ * Every submit therefore carries an ack token, and an unacknowledged one is
+ * reported to the caller so it can re-deliver through the durable spool
+ * instead of losing the message.
+ */
+import { frameLine } from '../wire.mjs';
+
+const SUBMIT_ACK_TIMEOUT_MS = 2_000;
+
+/** The submit frame for `prompt`, tagged with its ack token. */
+export function submitFrame(prompt, meta, ackId) {
+  const id = meta && meta.id != null && String(meta.id).trim() ? String(meta.id) : undefined;
+  const submittedAt = Number(meta?.submittedAt);
+  const displayText = String(
+    meta?.displayText ?? meta?.options?.displayText ?? (typeof prompt === 'string' ? prompt : '')
+  );
+  return frameLine({
+    t: 'submit',
+    text: displayText,
+    prompt,
+    ...(meta?.options && typeof meta.options === 'object' ? { options: meta.options } : {}),
+    ack: ackId,
+    ...(id ? { id } : {}),
+    ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt: Math.round(submittedAt) } : {}),
+  });
+}
+
+export function createSubmitAcks() {
+  const pending = new Map();
+  let seq = 0;
+
+  function nextAckId() {
+    seq += 1;
+    return `ack-${process.pid}-${Date.now()}-${seq}`;
+  }
+
+  function settle(ackId, delivered) {
+    const entry = pending.get(ackId);
+    if (!entry) return;
+    pending.delete(ackId);
+    clearTimeout(entry.timer);
+    if (delivered) return;
+    try {
+      entry.onUndelivered?.();
+    } catch {
+      /* fallback is best-effort */
+    }
+  }
+
+  /** Written, not yet delivered: an owner that never acknowledges triggers re-delivery. */
+  function track(ackId, onUndelivered) {
+    const timer = setTimeout(() => settle(ackId, false), SUBMIT_ACK_TIMEOUT_MS);
+    timer.unref?.();
+    pending.set(ackId, { timer, onUndelivered });
+  }
+
+  function failAll() {
+    for (const ackId of [...pending.keys()]) settle(ackId, false);
+  }
+
+  return { nextAckId, settle, track, failAll };
+}

package/src/tui/session/live-share/viewer/sync-waiters.mjs

@@ -0,0 +1,53 @@
+/**
+ * live-share/viewer/sync-waiters.mjs - callers waiting for the owner's atomic
+ * full frame of one session, plus the throttled desync-recovery request.
+ */
+import { frameLine } from '../wire.mjs';
+
+// Desync-recovery `sync` requests are throttled so a corrupt stream cannot
+// make the owner serialize full transcripts every frame.
+const SYNC_REQUEST_MIN_INTERVAL_MS = 500;
+
+export function createSyncWaiters() {
+  const waiters = new Set();
+  let lastSyncRequestAt = 0;
+
+  /** Resolve every waiter on `id` with `synced`. */
+  function settle(id, synced) {
+    for (const waiter of waiters) {
+      if (waiter.id === id) waiter.finish(synced);
+    }
+  }
+
+  /** A promise that settles when `id` is fully synced, or false on timeout. */
+  function wait(id, timeoutMs) {
+    return new Promise((resolve) => {
+      const waiter = { id, timer: null, finish: null };
+      waiter.finish = (synced) => {
+        if (!waiters.delete(waiter)) return;
+        if (waiter.timer) clearTimeout(waiter.timer);
+        resolve(synced === true);
+      };
+      waiters.add(waiter);
+      waiter.timer = setTimeout(() => waiter.finish(false), Math.max(1, Number(timeoutMs) || 750));
+      waiter.timer.unref?.();
+    });
+  }
+
+  function requestSync(socket) {
+    const now = Date.now();
+    if (now - lastSyncRequestAt < SYNC_REQUEST_MIN_INTERVAL_MS) return;
+    lastSyncRequestAt = now;
+    try {
+      socket.write(frameLine({ t: 'sync' }));
+    } catch {
+      /* close handles */
+    }
+  }
+
+  function failAll() {
+    for (const waiter of waiters) waiter.finish(false);
+  }
+
+  return { settle, wait, requestSync, failAll };
+}

package/src/tui/session/live-share/viewer.mjs

@@ -0,0 +1,190 @@
+/**
+ * src/tui/session/live-share/viewer.mjs - viewer leg: pipe client that
+ * mirrors owner deltas into the local store, tracks full-sync and submit-ack
+ * delivery, and sends submit/abort frames back to the owner. viewer/:
+ * sync-waiters (full-frame barrier + throttled resync), submit-acks
+ * (delivery tokens and the durable re-delivery fallback).
+ */
+import { connect } from 'node:net';
+import { attachLineReader, destroyQuietly, frameLine } from './wire.mjs';
+import { createMirror } from './mirror.mjs';
+import { createRetryTimer } from './retry.mjs';
+import { createSyncWaiters } from './viewer/sync-waiters.mjs';
+import { createSubmitAcks, submitFrame } from './viewer/submit-acks.mjs';
+
+export function createViewerLeg({
+  viewerSessionId,
+  socketPathFor,
+  viewerApply,
+  onOwnerClosed,
+  isDisposed,
+  reconcile,
+  retryMinMs,
+  retryMaxMs,
+}) {
+  // The pipe client for the attached session: `up` flips on connect, and
+  // `syncedId` once the owner's atomic full frame has replaced the disk restore.
+  const link = { socket: null, id: '', up: false, syncedId: '' };
+  const sync = createSyncWaiters();
+  const acks = createSubmitAcks();
+  const mirror = createMirror(viewerApply);
+  const retry = createRetryTimer({
+    minMs: retryMinMs,
+    maxMs: retryMaxMs,
+    shouldStart: (id) => !isDisposed() && !link.socket && String(viewerSessionId() || '') === id,
+    start: (id) => startClient(id),
+  });
+
+  const resetLink = () => {
+    link.socket = null;
+    link.id = '';
+    link.up = false;
+    link.syncedId = '';
+  };
+
+  const waitForSync = (id, timeoutMs = 1500) => {
+    const target = String(id || '');
+    if (!target) return Promise.resolve(false);
+    reconcile();
+    if (link.up && link.id === target && link.syncedId === target) {
+      return Promise.resolve(true);
+    }
+    return sync.wait(target, timeoutMs);
+  };
+
+  const stopClient = () => {
+    retry.clear();
+    retry.reset();
+    const closing = link.socket;
+    const closingId = link.id;
+    const wasUp = link.up;
+    resetLink();
+    if (closingId) sync.settle(closingId, false);
+    if (closing) destroyQuietly(closing);
+    // Deliberate teardown (session switch / role change / dispose) destroys
+    // the socket AFTER link.up is already false, so the socket's close
+    // handler sees wasUp=false and never clears the mirror. Clear it here:
+    // otherwise the owner's mirrored busy/spinner/queue leaks into the next
+    // resumed session as a frozen working indicator (user report: finished
+    // session shows a spinner + stop button after switching away from a
+    // busy live-attached session).
+    if (wasUp) mirror.clearLiveState();
+  };
+
+  const onFrame = (socket, id, frame) => {
+    if (link.socket !== socket) return false;
+    if (frame.t === 'close') return true;
+    // Delivery verdicts are session-independent: settle them before the
+    // session-scope guard, so a submit acknowledged during a session switch
+    // is not counted as lost (and re-sent as a duplicate).
+    if (frame.t === 'submit-ack') {
+      acks.settle(String(frame.ack || ''), frame.ok !== false);
+      return false;
+    }
+    if (viewerSessionId() !== id) return false;
+    try {
+      const synced = mirror.applyFrame(frame);
+      if (!synced) sync.requestSync(socket);
+      // A connected socket is not an entry boundary: the viewer must wait
+      // until the owner's atomic full frame has replaced the stale disk
+      // restore. Desktop resume holds its renderer publication on this
+      // barrier, preventing "last user message first, whole turn later".
+      if (frame.t === 'full') {
+        link.syncedId = id;
+        sync.settle(id, true);
+      }
+    } catch {
+      sync.requestSync(socket);
+    }
+    return false;
+  };
+
+  const startClient = (id) => {
+    if (isDisposed() || link.socket || !id) return;
+    retry.clear();
+    let socket;
+    try {
+      socket = connect(socketPathFor(id));
+    } catch {
+      retry.schedule(id);
+      return;
+    }
+    link.socket = socket;
+    link.id = id;
+    link.up = false;
+    link.syncedId = '';
+    socket.setNoDelay?.(true);
+    socket.on('connect', () => {
+      if (link.socket !== socket) return;
+      link.up = true;
+      retry.clear();
+      retry.reset();
+    });
+    const down = (ownerClosed) => {
+      const wasCurrent = link.socket === socket;
+      const wasUp = link.up && wasCurrent;
+      if (wasCurrent) resetLink();
+      // Anything still awaiting an ack died with this socket: report it as
+      // undelivered so the caller re-delivers durably.
+      if (wasCurrent) acks.failAll();
+      destroyQuietly(socket);
+      if (wasUp) mirror.clearLiveState();
+      // A live link that dropped means the owner ended or crashed: nudge the
+      // promotion path instead of waiting for the next store-mtime change.
+      if (wasUp) onOwnerClosed?.(id, ownerClosed);
+      if (wasCurrent) retry.schedule(id);
+    };
+    socket.on('error', () => down(false));
+    socket.on('close', () => down(false));
+    attachLineReader(
+      socket,
+      (frame) => {
+        if (onFrame(socket, id, frame)) down(true);
+      },
+      () => down(false)
+    );
+  };
+
+  // Reconcile against the session this surface is attached to ('' = none).
+  const ensure = (attachId) => {
+    if (retry.id() && retry.id() !== attachId) retry.clear();
+    if (!attachId && retry.pending()) retry.clear();
+    if (link.id && link.id !== attachId) stopClient();
+    if (attachId && !link.socket && !retry.pending()) startClient(attachId);
+  };
+
+  const sendSubmit = (prompt, meta = null) => {
+    if (!link.up || !link.socket) return false;
+    const ackId = acks.nextAckId();
+    const onUndelivered = typeof meta?.onUndelivered === 'function' ? meta.onUndelivered : null;
+    try {
+      link.socket.write(submitFrame(prompt, meta, ackId));
+    } catch {
+      return false;
+    }
+    // Written, not yet delivered. The caller gets its synchronous `true`
+    // (the store contract), and an owner that never acknowledges — refusal,
+    // crash, half-open pipe — triggers the durable re-delivery instead of
+    // silently eating the prompt.
+    if (onUndelivered) acks.track(ackId, onUndelivered);
+    return true;
+  };
+
+  const sendAbort = () => {
+    if (!link.up || !link.socket) return false;
+    try {
+      link.socket.write(frameLine({ t: 'abort' }));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const dispose = () => {
+    acks.failAll();
+    stopClient();
+    sync.failAll();
+  };
+
+  return { ensure, connected: () => link.up, waitForSync, sendSubmit, sendAbort, dispose };
+}

package/src/tui/session/live-share/wire.mjs

@@ -0,0 +1,41 @@
+/**
+ * src/tui/session/live-share/wire.mjs - newline-delimited JSON framing shared
+ * by the owner pipe server and the viewer client.
+ */
+const MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+
+export function frameLine(frame) {
+  return `${JSON.stringify(frame)}\n`;
+}
+
+export function destroyQuietly(socket) {
+  try {
+    socket.destroy();
+  } catch {
+    /* already gone */
+  }
+}
+
+export function attachLineReader(socket, onFrame, onOverflow) {
+  let buffer = '';
+  socket.on('data', (chunk) => {
+    buffer += chunk;
+    if (buffer.length > MAX_BUFFER_BYTES) {
+      buffer = '';
+      onOverflow?.();
+      return;
+    }
+    for (let index = buffer.indexOf('\n'); index >= 0; index = buffer.indexOf('\n')) {
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      if (!line.trim()) continue;
+      let frame = null;
+      try {
+        frame = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (frame && typeof frame === 'object') onFrame(frame);
+    }
+  });
+}