dextunnel 0.1.0

package/src/lib/live-control-state.mjs

@@ -0,0 +1,107 @@
+import {
+  clearControlLease,
+  ensureControlActionAllowed,
+  renewControlLease,
+  setControlLease
+} from "./shared-room-state.mjs";
+
+export function applyLiveControlAction({
+  action = "claim",
+  clientId = null,
+  existingLease = null,
+  owner = null,
+  reason = null,
+  source = "remote",
+  threadId = null,
+  ttlMs,
+  now = Date.now()
+} = {}) {
+  const nextThreadId = String(threadId || "").trim();
+  const nextClientId = String(clientId || "").trim() || null;
+  const nextSource = source || "remote";
+
+  if (!nextThreadId) {
+    throw new Error("No live session selected.");
+  }
+
+  if (nextSource === "remote" || nextSource === "agent") {
+    ensureControlActionAllowed({
+      action,
+      clientId: nextClientId,
+      lease: existingLease,
+      source: nextSource,
+      threadId: nextThreadId,
+      now
+    });
+  }
+
+  if (action === "release") {
+    const previousLease = existingLease || null;
+    return {
+      lease: clearControlLease(existingLease, { threadId: nextThreadId, now }),
+      recordEvent: Boolean(previousLease),
+      event: previousLease
+        ? {
+            action: "release",
+            actor: nextSource,
+            actorClientId: nextClientId,
+            cause: "released",
+            owner: previousLease.owner || null,
+            ownerClientId: previousLease.ownerClientId || null,
+            ownerLabel: previousLease.ownerLabel || null,
+            reason: previousLease.reason || null,
+            source: previousLease.source || null,
+            threadId: previousLease.threadId || nextThreadId
+          }
+        : null
+    };
+  }
+
+  if (action === "renew") {
+    return {
+      lease: renewControlLease({
+        clientId: nextClientId,
+        lease: existingLease,
+        now,
+        owner: owner || nextSource,
+        reason,
+        source: nextSource,
+        threadId: nextThreadId,
+        ttlMs
+      }),
+      recordEvent: false,
+      event: null
+    };
+  }
+
+  if (action === "claim") {
+    const lease = setControlLease({
+      clientId: nextClientId,
+      now,
+      owner: owner || nextSource,
+      reason: reason || "compose",
+      source: nextSource,
+      threadId: nextThreadId,
+      ttlMs
+    });
+
+    return {
+      lease,
+      recordEvent: true,
+      event: {
+        action: "claim",
+        actor: nextSource,
+        actorClientId: nextClientId,
+        cause: "claimed",
+        owner: lease.owner || null,
+        ownerClientId: lease.ownerClientId || null,
+        ownerLabel: lease.ownerLabel || null,
+        reason: lease.reason || null,
+        source: lease.source || null,
+        threadId: lease.threadId || nextThreadId
+      }
+    };
+  }
+
+  throw new Error(`Unsupported control action: ${action}`);
+}

package/src/lib/live-payload-builder.mjs

@@ -0,0 +1,298 @@
+function isOriginEligibleEntry(entry) {
+  if (!entry) {
+    return false;
+  }
+
+  if (entry.role === "user") {
+    return true;
+  }
+
+  return entry.role === "assistant" && entry.kind !== "commentary";
+}
+
+export function createLivePayloadBuilder(deps) {
+  const {
+    advisoryParticipantForThread,
+    ADVISORY_PARTICIPANT_IDS = [],
+    bestConversationLabel,
+    bestThreadLabel,
+    buildBridgeStatus,
+    buildParticipant,
+    buildSelectedAgentRoomState,
+    buildSelectedAttachments,
+    buildSelectedCompanionState,
+    getPendingInteractionForSelectedThread,
+    liveState,
+    looksLikeTopicNoise,
+    normalizeLane,
+    projectLabel,
+    pruneAllCompanionWakeups,
+    pruneStaleSurfacePresence,
+    repoObjective,
+    selectedThreadSummary,
+    slugifyChannelName,
+    summarizeThread,
+    trimTopicText
+  } = deps;
+
+  function inferEntryLane(entry, thread) {
+    const explicitLane = normalizeLane(entry?.origin);
+    if (explicitLane) {
+      return explicitLane;
+    }
+
+    if (entry?.role !== "user") {
+      return "";
+    }
+
+    if (thread?.source === "vscode") {
+      return "desktop";
+    }
+
+    if (thread?.source === "cli") {
+      return "external";
+    }
+
+    return "";
+  }
+
+  function participantForEntry(entry, thread) {
+    const lane = inferEntryLane(entry, thread);
+
+    if (entry?.kind === "pending" || entry?.kind === "queued") {
+      return buildParticipant("remote");
+    }
+
+    if (entry?.role === "assistant" && entry?.kind === "commentary") {
+      return buildParticipant("updates");
+    }
+
+    if (entry?.role === "assistant") {
+      return buildParticipant("codex");
+    }
+
+    if (entry?.role === "user") {
+      if (lane === "remote") {
+        return buildParticipant("remote");
+      }
+
+      if (lane === "desktop") {
+        return buildParticipant("desktop");
+      }
+
+      if (lane === "oracle") {
+        return buildParticipant("oracle");
+      }
+
+      if (lane === "gemini") {
+        return buildParticipant("gemini");
+      }
+
+      if (lane === "external") {
+        return buildParticipant("user", {
+          label: "external",
+          lane: "external",
+          token: "user"
+        });
+      }
+
+      return buildParticipant("user");
+    }
+
+    if (entry?.role === "tool") {
+      return buildParticipant("tools");
+    }
+
+    return buildParticipant("system");
+  }
+
+  function buildChannelTopic(snapshot) {
+    const thread = snapshot?.thread || null;
+    const objective = repoObjective(thread?.cwd || "");
+    if (objective && !looksLikeTopicNoise(objective)) {
+      return objective;
+    }
+
+    if (thread?.preview && !looksLikeTopicNoise(thread.preview)) {
+      return trimTopicText(thread.preview);
+    }
+
+    const latestConversation = bestConversationLabel(snapshot, 120);
+    if (!latestConversation) {
+      return "";
+    }
+
+    return trimTopicText(latestConversation, 120);
+  }
+
+  function buildSelectedChannel(snapshot) {
+    const thread = snapshot?.thread || selectedThreadSummary() || null;
+    const cwd = thread?.cwd || liveState.selectedProjectCwd || process.cwd();
+    const label = bestThreadLabel(
+      {
+        ...thread,
+        cwd
+      },
+      snapshot,
+      { selected: true }
+    );
+
+    return {
+      channelId: thread?.id || liveState.selectedThreadId || null,
+      channelLabel: label,
+      channelSlug: `#${slugifyChannelName(label)}`,
+      source: thread?.source || null,
+      serverId: cwd,
+      serverLabel: projectLabel(cwd),
+      topic: buildChannelTopic(snapshot)
+    };
+  }
+
+  function buildParticipants(snapshot) {
+    const participants = new Map();
+    const threadId = snapshot?.thread?.id || null;
+
+    for (const entry of snapshot?.transcript || []) {
+      const participant = participantForEntry(entry, snapshot?.thread);
+      participants.set(participant.id, participant);
+    }
+
+    if (snapshot?.thread?.source === "vscode" && !participants.has("desktop")) {
+      participants.set("desktop", buildParticipant("desktop"));
+    }
+
+    if (!participants.has("remote")) {
+      participants.set("remote", buildParticipant("remote"));
+    }
+
+    if (!participants.has("codex")) {
+      participants.set("codex", buildParticipant("codex"));
+    }
+
+    for (const advisorId of ADVISORY_PARTICIPANT_IDS) {
+      participants.set(advisorId, advisoryParticipantForThread(advisorId, threadId));
+    }
+
+    return [...participants.values()].sort((a, b) => {
+      const orderDelta = (a.sortOrder || 999) - (b.sortOrder || 999);
+      if (orderDelta !== 0) {
+        return orderDelta;
+      }
+
+      return String(a.label || a.id || "").localeCompare(String(b.label || b.id || ""));
+    });
+  }
+
+  function applyTurnOrigins(snapshot) {
+    const threadId = snapshot?.thread?.id || null;
+    if (!threadId || !Array.isArray(snapshot?.transcript) || snapshot.transcript.length === 0) {
+      return snapshot;
+    }
+
+    const turnOrigins = liveState.turnOriginsByThreadId?.[threadId];
+    if (!turnOrigins) {
+      return snapshot;
+    }
+
+    let changed = false;
+    const transcript = snapshot.transcript.map((entry) => {
+      const origin =
+        isOriginEligibleEntry(entry) && entry.turnId
+          ? turnOrigins[entry.turnId] || null
+          : null;
+      const currentOrigin = entry.origin || null;
+
+      if (currentOrigin === origin) {
+        return entry;
+      }
+
+      changed = true;
+      if (!origin) {
+        const { origin: _origin, ...rest } = entry;
+        return rest;
+      }
+
+      return {
+        ...entry,
+        origin
+      };
+    });
+
+    if (!changed) {
+      return snapshot;
+    }
+
+    return {
+      ...snapshot,
+      transcript
+    };
+  }
+
+  function decorateSnapshot(snapshot) {
+    const withOrigins = applyTurnOrigins(snapshot);
+    const thread = withOrigins?.thread || null;
+
+    if (!thread || !Array.isArray(withOrigins?.transcript)) {
+      return withOrigins;
+    }
+
+    const transcript = withOrigins.transcript.map((entry) => {
+      const lane = inferEntryLane(entry, thread);
+      const participant = participantForEntry(entry, thread);
+
+      return {
+        ...entry,
+        lane,
+        participant
+      };
+    });
+
+    const nextSnapshot = {
+      ...withOrigins,
+      transcript
+    };
+
+    return {
+      ...nextSnapshot,
+      channel: buildSelectedChannel(nextSnapshot),
+      participants: buildParticipants(nextSnapshot)
+    };
+  }
+
+  function buildLivePayload() {
+    pruneStaleSurfacePresence();
+    pruneAllCompanionWakeups();
+    const selectedThreadSnapshot = decorateSnapshot(liveState.selectedThreadSnapshot);
+    const selectedThreadId = selectedThreadSnapshot?.thread?.id || liveState.selectedThreadId || null;
+    const selectedAttachments = buildSelectedAttachments(selectedThreadId);
+    const selectedCompanion = buildSelectedCompanionState(selectedThreadId);
+    const selectedAgentRoom = buildSelectedAgentRoomState(selectedThreadId);
+
+    return {
+      pendingInteraction: getPendingInteractionForSelectedThread(),
+      participants: selectedThreadSnapshot?.participants || [],
+      selectedAgentRoom,
+      selectedCompanion,
+      selectedAttachments,
+      selectedChannel: selectedThreadSnapshot?.channel || buildSelectedChannel(null),
+      selectedProjectCwd: liveState.selectedProjectCwd,
+      selectionSource: liveState.selectionSource,
+      selectedThreadId: liveState.selectedThreadId,
+      selectedThreadSnapshot,
+      status: buildBridgeStatus(),
+      turnDiff: liveState.turnDiff,
+      threads: liveState.threads.map(summarizeThread)
+    };
+  }
+
+  return {
+    applyTurnOrigins,
+    buildChannelTopic,
+    buildLivePayload,
+    buildParticipants,
+    buildSelectedChannel,
+    decorateSnapshot,
+    inferEntryLane,
+    participantForEntry
+  };
+}

package/src/lib/live-selection-transition-state.mjs

@@ -0,0 +1,49 @@
+import { clearControlLease } from "./shared-room-state.mjs";
+import { applySharedSelectionState } from "./shared-selection-state.mjs";
+
+export function applyLiveSelectionTransition(
+  state = {},
+  {
+    cwd = null,
+    source = "remote",
+    threadId = null,
+    threads = []
+  } = {},
+  { now = Date.now() } = {}
+) {
+  const previousThreadId = state.selectedThreadId || null;
+  const selection = applySharedSelectionState(
+    {
+      selectedProjectCwd: state.selectedProjectCwd || "",
+      selectedThreadId: previousThreadId,
+      selectedThreadSnapshot: state.selectedThreadSnapshot || null,
+      selectionSource: state.selectionSource || "remote",
+      turnDiff: state.turnDiff || null,
+      writeLock: state.writeLock || null
+    },
+    {
+      cwd,
+      source,
+      threadId,
+      threads
+    }
+  );
+
+  const interactionFlow = selection.threadChanged ? null : state.interactionFlow || null;
+  const controlLease = selection.threadChanged
+    ? clearControlLease(state.controlLease || null, { now, threadId: previousThreadId || null })
+    : state.controlLease || null;
+
+  return {
+    cleared: {
+      controlLease: selection.threadChanged && Boolean(state.controlLease),
+      interactionFlow: selection.threadChanged && Boolean(state.interactionFlow)
+    },
+    nextState: {
+      ...selection.nextState,
+      controlLease,
+      interactionFlow
+    },
+    threadChanged: selection.threadChanged
+  };
+}