mixdog 1.2.2 → 1.2.4

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

@@ -1,44 +0,0 @@
-/**
- * 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 = '';
-  // Decode as a stream: a multibyte character split across chunks must not
-  // turn into U+FFFD when the raw Buffers are concatenated as strings.
-  socket.setEncoding?.('utf8');
-  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);
-    }
-  });
-}

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

@@ -1,154 +0,0 @@
-/**
- * src/tui/session/live-share.mjs — real-time cross-surface session mirroring.
- *
- * OWNER leg: hosts a local named-pipe (win32) / unix-socket server for the
- * session it owns and pushes frame-batched transcript deltas (items /
- * streaming tail / spinner) to attached viewers. Push-only: zero polling,
- * idle cost is one open listener.
- * VIEWER leg: connects to the owner's pipe and mirrors those deltas into the
- * local session runtime store, so streaming output appears live on every co-open
- * surface (desktop <-> terminal). Viewer submits travel over the same pipe
- * into the owner's normal submit queue (concurrent input from both sides is
- * serialized there); the durable pending spool remains the fallback when the
- * pipe is down. Ownership/promotion semantics are unchanged — the pipe is a
- * transport, never a second writer.
- */
-import { createHash } from 'node:crypto';
-import { join } from 'node:path';
-import { createOwnerLeg } from './live-share/owner.mjs';
-import { createViewerLeg } from './live-share/viewer.mjs';
-
-// A unix socket path is a fixed sun_path buffer: 104 bytes on macOS and the
-// BSDs, 108 on Linux, NUL included. A desktop session id alone is 64 hex, so
-// the path beside its session file runs past the macOS limit and listen()
-// failed there for every desktop session.
-const UNIX_SOCKET_PATH_MAX_BYTES = 103;
-
-// Session entry is latency-sensitive: the owner pipe can be a few event-loop
-// turns behind the viewer resume. Retry locally instead of waiting for the
-// coarse 3s session runtime safety tick.
-const LIVE_CONNECT_RETRY_MIN_MS = 10;
-const LIVE_CONNECT_RETRY_MAX_MS = 160;
-
-export function liveSharePipePath(sessionId, sessionFilePath) {
-  if (process.platform === 'win32') return `\\\\.\\pipe\\mixdog-live-${sessionId}`;
-  const beside = `${sessionFilePath}.live.sock`;
-  if (Buffer.byteLength(beside) <= UNIX_SOCKET_PATH_MAX_BYTES) return beside;
-  // Owner and viewer derive the same short name from the same session file.
-  // /tmp, not os.tmpdir(): TMPDIR is itself long on macOS and may differ
-  // between the desktop daemon and a terminal, which would split the pair.
-  const digest = createHash('sha256').update(beside).digest('hex').slice(0, 24);
-  return join('/tmp', `mixdog-live-${process.getuid()}-${digest}.sock`);
-}
-
-export function createLiveShare({
-  ownerSessionId,
-  viewerSessionId,
-  socketPathFor,
-  getPublishedState,
-  listeners,
-  onRemoteSubmit,
-  onRemoteAbort,
-  onOwnerClosed,
-  viewerApply,
-  viewerRetryMinMs = LIVE_CONNECT_RETRY_MIN_MS,
-  viewerRetryMaxMs = LIVE_CONNECT_RETRY_MAX_MS,
-}) {
-  let disposed = false;
-  const isDisposed = () => disposed;
-  const clientRetryMinimumMs = Math.max(
-    LIVE_CONNECT_RETRY_MIN_MS,
-    Number(viewerRetryMinMs) || LIVE_CONNECT_RETRY_MIN_MS
-  );
-  const clientRetryMaximumMs = Math.max(clientRetryMinimumMs, Number(viewerRetryMaxMs) || LIVE_CONNECT_RETRY_MAX_MS);
-
-  const owner = createOwnerLeg({
-    ownerSessionId,
-    socketPathFor,
-    getPublishedState,
-    onRemoteSubmit,
-    onRemoteAbort,
-    isDisposed,
-    retryMinMs: LIVE_CONNECT_RETRY_MIN_MS,
-    retryMaxMs: LIVE_CONNECT_RETRY_MAX_MS,
-  });
-  const viewer = createViewerLeg({
-    viewerSessionId,
-    socketPathFor,
-    viewerApply,
-    onOwnerClosed,
-    isDisposed,
-    reconcile: () => ensureShare(),
-    retryMinMs: clientRetryMinimumMs,
-    retryMaxMs: clientRetryMaximumMs,
-  });
-  listeners.add(owner.onPublish);
-
-  // Reconciles both legs against the current session role. Failed pipe opens
-  // continue through the local retry timers; the session runtime's 3s call is
-  // only a safety net, never the normal connection cadence.
-  const ensureShare = () => {
-    if (disposed) return;
-    const ownerId = String(ownerSessionId() || '');
-    const attachId = ownerId ? '' : String(viewerSessionId() || '');
-    owner.ensure(ownerId);
-    viewer.ensure(attachId);
-  };
-
-  return {
-    ensure: ensureShare,
-    viewerConnected: viewer.connected,
-    waitForViewerSync: viewer.waitForSync,
-    sendSubmit: viewer.sendSubmit,
-    sendAbort: viewer.sendAbort,
-    dispose() {
-      disposed = true;
-      listeners.delete(owner.onPublish);
-      owner.stop();
-      viewer.dispose();
-    },
-  };
-}
-
-/**
- * ONE viewer-submit intake for EVERY session runtime entry point. The TUI store calls
- * submit(); the daemon awaits submitAsync() (session-service prefers it).
- * Wrapping only one of them let the other path enqueue the prompt on the VIEWER
- * session runtime, so that surface rendered its own local user row beside the owner's
- * mirrored one — the same message twice on screen
- * (user: 데스크탑에서만 입력이 두 개로 들어간다).
- *
- * `spool(submissionId)` is the durable fallback. The submission id is minted
- * here when the caller has none, so the pipe frame and the spool entry carry
- * the SAME identity and the owner reuses it for the settled user row — which is
- * what releases the submitting surface's optimistic bubble.
- */
-export function forwardViewerSubmit({ prompt = null, text, options = {}, share, spool, pid = process.pid }) {
-  const value = String(text || '').trim();
-  const content = prompt ?? value;
-  if (!value && !(Array.isArray(content) && content.length > 0)) return false;
-  // Reconcile first so a session that became attachable this event-loop turn
-  // takes the instant pipe path instead of the durable detour.
-  try {
-    share.ensure?.();
-  } catch {
-    /* durable fallback below */
-  }
-  const submissionId =
-    options.id != null && String(options.id).trim() ? String(options.id).trim() : `view-submit-${pid}-${Date.now()}`;
-  const deliverDurably = () => spool?.(submissionId) === true;
-  // A pipe WRITE is not a delivery: the owner may refuse the prompt and the
-  // socket may die between write and read, so an unacknowledged submit is
-  // re-delivered through the spool — late, never lost.
-  if (
-    share.sendSubmit(content, {
-      id: submissionId,
-      submittedAt: options.submittedAt,
-      displayText: value,
-      options,
-      onUndelivered: deliverDurably,
-    })
-  )
-    return true;
-  return deliverDurably();
-}

package/src/tui/session/shared-dir-watch.mjs

@@ -1,69 +0,0 @@
-/**
- * src/tui/session/shared-dir-watch.mjs - one fs.watch handle per directory for
- * the whole process, shared by every subscriber and reference-counted.
- *
- * Every session runtime watches the data directory for the pending spool. On
- * Windows libuv resolves each directory-watch notification's long path
- * (GetLongPathNameW: NtOpenFile / NtQueryDirectoryFileEx / NtClose) on the loop
- * thread once PER HANDLE, so N sessions with N handles on the busiest
- * directory turned each spool write into N synchronous path lookups and
- * produced 100-800 ms event-loop stalls. One shared handle does that work once
- * and fans the (event, filename) pair out to each subscriber, which keeps its
- * own filtering. The last release closes the handle.
- */
-import { watch as fsWatch } from 'node:fs';
-import { resolve } from 'node:path';
-
-export function createSharedDirWatch(watchImpl = fsWatch) {
-  const entries = new Map();
-
-  function closeEntry(key, entry) {
-    if (entries.get(key) === entry) entries.delete(key);
-    try {
-      entry.watcher.close();
-    } catch {
-      /* already closed */
-    }
-  }
-
-  function openEntry(key) {
-    const subscribers = new Set();
-    const watcher = watchImpl(key, { persistent: false }, (event, filename) => {
-      for (const subscriber of [...subscribers]) {
-        try {
-          subscriber.listener(event, filename);
-        } catch {
-          /* one subscriber must not starve the others */
-        }
-      }
-    });
-    const entry = { watcher, subscribers };
-    // An erroring handle is dropped exactly like the old per-session watcher:
-    // its subscribers fall back to their poll tick; a later subscribe reopens.
-    watcher.on?.('error', () => closeEntry(key, entry));
-    entries.set(key, entry);
-    return entry;
-  }
-
-  /**
-   * Subscribe `listener(event, filename)` to `dir`. Throws like fs.watch when
-   * the directory cannot be watched. Returns an idempotent release function.
-   */
-  function subscribe(dir, listener) {
-    const key = resolve(dir);
-    const entry = entries.get(key) || openEntry(key);
-    const subscriber = { listener };
-    entry.subscribers.add(subscriber);
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      entry.subscribers.delete(subscriber);
-      if (entry.subscribers.size === 0) closeEntry(key, entry);
-    };
-  }
-
-  return { subscribe, watchedCount: () => entries.size };
-}
-
-export const sharedDirWatch = createSharedDirWatch();