mixdog 1.2.2 → 1.2.4

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

@@ -1,254 +0,0 @@
-/**
- * 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, reconcileLeg } 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 */
-  }
-}
-
-// Sockets this process still serves. A process that exits without closing its
-// sessions (daemon shutdown, tray Quit) must not leave them behind in /tmp.
-const servedSocketPaths = new Set();
-let exitCleanupInstalled = false;
-function serveSocketPath(path) {
-  if (process.platform === 'win32' || !path) return;
-  servedSocketPaths.add(path);
-  if (exitCleanupInstalled) return;
-  exitCleanupInstalled = true;
-  process.once('exit', () => {
-    for (const served of servedSocketPaths) unlinkQuietly(served);
-    servedSocketPaths.clear();
-  });
-}
-
-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);
-    servedSocketPaths.delete(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;
-    serveSocketPath(path);
-    try {
-      next.listen(path);
-    } catch {
-      retryAfterListenFailure(id);
-    }
-  };
-
-  // Reconcile against the session this surface currently owns ('' = none).
-  const ensure = (ownerId) =>
-    reconcileLeg(ownerId, {
-      retry,
-      legId: () => serverId,
-      legUp: () => Boolean(server),
-      stop: stopServer,
-      start: startServer,
-    });
-
-  return { ensure, stop: stopServer, onPublish };
-}

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

@@ -1,54 +0,0 @@
-/**
- * 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,
-  };
-}
-
-/**
- * Reconcile one live-share leg (the owner's pipe server, the viewer's client)
- * against the session it should serve/follow — '' = none. A retry aimed at
- * another session is dropped, a leg bound to another session is stopped, and a
- * leg is (re)started only when nothing is up and no retry is already pending.
- * `legId`/`legUp` are read lazily because both callers keep them in mutable
- * closure state.
- */
-export function reconcileLeg(targetId, { retry, legId, legUp, stop, start }) {
-  if (retry.id() && retry.id() !== targetId) retry.clear();
-  if (!targetId && retry.pending()) retry.clear();
-  if (legId() && legId() !== targetId) stop();
-  if (targetId && !legUp() && !retry.pending()) start(targetId);
-}

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

@@ -1,32 +0,0 @@
-/**
- * src/tui/session/live-share/viewer/frame-router.mjs - where one owner frame
- * goes: submit-ack verdicts, the mirrored state, and the full-frame sync
- * barrier. Returns true when the frame ends the link (owner close).
- */
-export function routeViewerFrame(frame, { socket, id, link, sync, acks, mirror, viewerSessionId }) {
-  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;
-}

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

@@ -1,108 +0,0 @@
-/**
- * src/tui/session/live-share/viewer/pipe-client.mjs - the viewer's socket
- * lifecycle: connect, frame routing into the mirror, teardown, and the retry
- * timer that owns re-connection. The link record it mutates is the viewer
- * leg's, so waitForSync/sendSubmit read the same `up`/`syncedId` state.
- */
-import { connect } from 'node:net';
-import { attachLineReader, destroyQuietly } from '../wire.mjs';
-import { createRetryTimer } from '../retry.mjs';
-import { routeViewerFrame } from './frame-router.mjs';
-
-export function createPipeClient({
-  link,
-  sync,
-  acks,
-  mirror,
-  viewerSessionId,
-  socketPathFor,
-  onOwnerClosed,
-  isDisposed,
-  retryMinMs,
-  retryMaxMs,
-}) {
-  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 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();
-  };
-
-  // Frame routing: viewer/frame-router.mjs.
-  const onFrame = (socket, id, frame) =>
-    routeViewerFrame(frame, { socket, id, link, sync, acks, mirror, viewerSessionId });
-
-  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)
-    );
-  };
-
-  return { retry, startClient, stopClient };
-}

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

@@ -1,65 +0,0 @@
-/**
- * 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

@@ -1,53 +0,0 @@
-/**
- * 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

@@ -1,99 +0,0 @@
-/**
- * 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 { frameLine } from './wire.mjs';
-import { createMirror } from './mirror.mjs';
-import { reconcileLeg } from './retry.mjs';
-import { createPipeClient } from './viewer/pipe-client.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);
-  // Socket lifecycle (connect, frame routing, teardown, retry): viewer/pipe-client.mjs.
-  const { retry, startClient, stopClient } = createPipeClient({
-    link,
-    sync,
-    acks,
-    mirror,
-    viewerSessionId,
-    socketPathFor,
-    onOwnerClosed,
-    isDisposed,
-    retryMinMs,
-    retryMaxMs,
-  });
-
-  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);
-  };
-
-  // Reconcile against the session this surface is attached to ('' = none).
-  const ensure = (attachId) =>
-    reconcileLeg(attachId, {
-      retry,
-      legId: () => link.id,
-      legUp: () => Boolean(link.socket),
-      stop: stopClient,
-      start: startClient,
-    });
-
-  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 };
-}