@devmarketplacenpm/devmp 0.1.1-beta.5

package/lib/interactive-tunnel.js

@@ -0,0 +1,420 @@
+"use strict";
+
+const { createExecutor } = require("./executor");
+const { createCommandRunner } = require("./command-runner");
+const { agentWsUrl: wsUrl } = require("./routes");
+const {
+  record: recordClientVersion,
+  blockedMessage: clientBlockedMessage,
+} = require("./version");
+const { readProjectInstructions } = require("./instructions");
+
+// A /new or /compact that the server never answers must not hold the shell
+// hostage. Generous, because compaction runs a summarisation model server-side.
+const CONTROL_TIMEOUT_MS =
+  Number(process.env.DEVMP_CONTROL_TIMEOUT_MS) > 0
+    ? Number(process.env.DEVMP_CONTROL_TIMEOUT_MS)
+    : 60_000;
+
+/** Open one M4 socket that can carry many sequential turns. */
+async function connectInteractiveSession({
+  session,
+  rootDir,
+  sessionId,
+  history,
+  yes,
+  allowCommands,
+  checkpoint,
+  onSession,
+  onNotice,
+}) {
+  // Session-scoped: read once here, and the server carries them into every turn
+  // of this session rather than the client resending them each time.
+  const instructions = await readProjectInstructions(rootDir).catch(() => null);
+  if (instructions) {
+    onNotice?.(
+      `  Following ${instructions.source}${
+        instructions.truncated ? " (first 8 KB)" : ""
+      }`,
+    );
+  }
+
+  return new Promise((resolve, reject) => {
+    if (typeof WebSocket !== "function") {
+      reject(
+        new Error(
+          "Interactive sessions require Node.js 22 or newer (global WebSocket is unavailable)."
+        )
+      );
+      return;
+    }
+
+    const url = wsUrl(session.apiBaseUrl);
+    let ws;
+    try {
+      ws = new WebSocket(url);
+    } catch (error) {
+      reject(new Error(`Could not open ${url}: ${error.message}`));
+      return;
+    }
+
+    let ready = false;
+    let closed = false;
+    let currentSession = null;
+    let pendingTurn = null;
+    // /new and /compact are request/response over the same socket. Every path
+    // that can end the exchange has to settle this — a dropped socket, a server
+    // error frame, a server that never answers. An unsettled control request
+    // wedges the shell: the composer stays busy with no way back.
+    let pendingControl = null;
+
+    const executor = createExecutor({
+      rootDir,
+      yes,
+      reviewChanges: true,
+      checkpoint,
+      onFile: (path, outcome, meta = {}) =>
+        pendingTurn?.onEvent({ type: "file-local", path, outcome, ...meta }),
+    });
+    const commandRunner = createCommandRunner({
+      rootDir,
+      allowCommands,
+      onNotice,
+    });
+
+    const send = (message) => {
+      if (ws.readyState !== WebSocket.OPEN) return false;
+      ws.send(JSON.stringify(message));
+      return true;
+    };
+
+    const settleControl = (outcome) => {
+      const control = pendingControl;
+      if (!control) return false;
+      pendingControl = null;
+      clearTimeout(control.timer);
+      if (outcome.error) control.reject(outcome.error);
+      else control.resolve(outcome.value);
+      return true;
+    };
+
+    const awaitControl = (label, frame) => {
+      if (pendingTurn) {
+        return Promise.reject(new Error("Cancel the active turn first."));
+      }
+      if (pendingControl) {
+        return Promise.reject(
+          new Error("/" + pendingControl.label + " is already running.")
+        );
+      }
+      return new Promise((resolve, reject) => {
+        if (!send(frame)) {
+          reject(new Error("The agent tunnel is not connected."));
+          return;
+        }
+        const timer = setTimeout(() => {
+          settleControl({
+            error: new Error(
+              "The server did not answer /" +
+                label +
+                " within " +
+                CONTROL_TIMEOUT_MS / 1000 +
+                "s. Nothing was changed."
+            ),
+          });
+        }, CONTROL_TIMEOUT_MS);
+        timer.unref?.();
+        pendingControl = { label, resolve, reject, timer };
+      });
+    };
+
+    const api = {
+      get session() {
+        return currentSession;
+      },
+      async runTurn({
+        turnId,
+        prompt,
+        mode,
+        provider,
+        model,
+        maxFiles,
+        onEvent,
+      }) {
+        if (pendingTurn) {
+          throw new Error("A turn is already running.");
+        }
+        await checkpoint?.beginTurn({ turnId, prompt });
+        commandRunner.beginTurn();
+        return new Promise((turnResolve) => {
+          pendingTurn = { turnId, resolve: turnResolve, onEvent };
+          send({
+            type: "turn.start",
+            turnId,
+            prompt,
+            mode,
+            ...(provider ? { provider } : {}),
+            ...(model ? { model } : {}),
+            ...(maxFiles ? { maxFiles } : {}),
+          });
+        });
+      },
+      cancel(turnId) {
+        send({ type: "turn.cancel", ...(turnId ? { turnId } : {}) });
+      },
+      reset() {
+        return awaitControl("new", { type: "session.reset" });
+      },
+      /**
+       * Fold the older half of the conversation into a summary now. Refused
+       * mid-turn: it rewrites the history the running turn reasons from.
+       */
+      compact() {
+        return awaitControl("compact", { type: "session.compact" });
+      },
+      setPermissions({ overwriteAll, commandsAll }) {
+        executor.setOverwriteAll(overwriteAll);
+        commandRunner.setAllowCommands(commandsAll);
+      },
+      /** Background jobs for the shell's `/jobs` view — no socket round-trip. */
+      listJobs: () => commandRunner.listJobs(),
+      stopJob: (jobId) => commandRunner.stopJob(jobId),
+      async close() {
+        closed = true;
+        commandRunner.cancelAll();
+        settleControl({ error: new Error("Session closed.") });
+        send({ type: "session.close" });
+        // Background jobs are session-scoped: this is the point at which a
+        // still-running dev server must not be left behind. Awaited, because
+        // the escalation to SIGKILL has to land before the process exits.
+        await commandRunner.killAllJobs();
+        ws.close();
+      },
+    };
+
+    const settleTurn = async (message) => {
+      if (!pendingTurn) return;
+      const turn = pendingTurn;
+      pendingTurn = null;
+      const status =
+        message.type === "done"
+          ? "completed"
+          : message.type === "cancelled"
+          ? "cancelled"
+          : "failed";
+      let savedCheckpoint = null;
+      let checkpointError;
+      try {
+        savedCheckpoint = await checkpoint?.finishTurn(status);
+      } catch (error) {
+        checkpointError = error.message;
+      }
+      const terminal = {
+        ...message,
+        localChanges: savedCheckpoint?.changes || [],
+        checkpoint: savedCheckpoint
+          ? { id: savedCheckpoint.id, status: savedCheckpoint.status }
+          : null,
+        executedCommands: commandRunner.getTurnReport(),
+        ...(checkpointError ? { checkpointError } : {}),
+      };
+      turn.onEvent(terminal);
+      turn.resolve(terminal);
+    };
+
+    ws.onopen = () => {
+      send({
+        type: "session.start",
+        token: session.accessToken,
+        ...(sessionId ? { sessionId } : {}),
+        workspace: rootDir,
+        history: Array.isArray(history) ? history.slice(-40) : [],
+        ...(instructions
+          ? {
+              instructions: instructions.text,
+              instructionsSource: instructions.source,
+            }
+          : {}),
+      });
+    };
+
+    ws.onmessage = async (event) => {
+      let msg;
+      try {
+        const raw =
+          typeof event.data === "string" ? event.data : event.data.toString();
+        msg = JSON.parse(raw);
+      } catch {
+        return;
+      }
+
+      if (msg.type === "fs") {
+        try {
+          const payload = await executor.handle(msg.op, msg.args || {});
+          send({ type: "fsResult", id: msg.id, ok: true, ...payload });
+        } catch (error) {
+          send({
+            type: "fsResult",
+            id: msg.id,
+            ok: false,
+            message: error.message,
+          });
+        }
+        return;
+      }
+
+      // Foreground and background command frames all answer with `cmdResult`,
+      // so the server-side runner keeps one pending map keyed by request id.
+      const commandOps = {
+        cmd: () => commandRunner.handle(String(msg.command || ""), msg.id),
+        cmdStart: () => commandRunner.handleStart(String(msg.command || "")),
+        cmdCheck: () => commandRunner.handleCheck(String(msg.jobId || "")),
+        cmdStop: () => commandRunner.handleStop(String(msg.jobId || "")),
+        cmdList: () => commandRunner.handleList(),
+      };
+      if (commandOps[msg.type]) {
+        try {
+          const payload = await commandOps[msg.type]();
+          send({ type: "cmdResult", id: msg.id, ok: true, ...payload });
+        } catch (error) {
+          send({
+            type: "cmdResult",
+            id: msg.id,
+            ok: false,
+            message: error.message,
+          });
+        }
+        return;
+      }
+
+      if (msg.type === "cmdCancel") {
+        commandRunner.cancel(msg.id);
+        return;
+      }
+
+      if (msg.type === "session.ready") {
+        // The handshake is the last cheap moment to refuse: a client older
+        // than the server's minimum would otherwise fail somewhere inside a
+        // turn, where the message means nothing to the user.
+        recordClientVersion(msg.client);
+        const tooOld = clientBlockedMessage();
+        if (tooOld) {
+          try {
+            ws.close();
+          } catch {
+            /* already closing */
+          }
+          reject(new Error(tooOld));
+          return;
+        }
+        ready = true;
+        currentSession = {
+          sessionId: msg.sessionId,
+          resumed: Boolean(msg.resumed),
+          history: Array.isArray(msg.history) ? msg.history : [],
+        };
+        onSession?.(currentSession);
+        resolve(api);
+        return;
+      }
+
+      if (msg.type === "session.updated") {
+        currentSession = {
+          ...(currentSession || {}),
+          sessionId: msg.sessionId,
+          resumed: true,
+          history: Array.isArray(msg.history) ? msg.history : [],
+        };
+        onSession?.(currentSession);
+        return;
+      }
+
+      if (msg.type === "session.compacted") {
+        // The server rewrote history; adopt it wholesale so the local
+        // transcript cannot re-seed the pre-compaction version on resume.
+        currentSession = {
+          ...(currentSession || {}),
+          sessionId: msg.sessionId,
+          resumed: true,
+          history: Array.isArray(msg.history) ? msg.history : [],
+        };
+        onSession?.(currentSession);
+        settleControl({
+          value: {
+            compacted: Boolean(msg.compacted),
+            messages: currentSession.history.length,
+          },
+        });
+        return;
+      }
+
+      if (msg.type === "session.reset.done") {
+        currentSession = {
+          ...(currentSession || {}),
+          sessionId: msg.sessionId,
+          resumed: false,
+          history: [],
+        };
+        onSession?.(currentSession);
+        settleControl({ value: currentSession });
+        return;
+      }
+
+      if (msg.turnId && pendingTurn && msg.turnId !== pendingTurn.turnId) {
+        return;
+      }
+
+      if (
+        pendingTurn &&
+        (msg.type === "done" ||
+          msg.type === "error" ||
+          msg.type === "cancelled")
+      ) {
+        await settleTurn(msg);
+      } else if (pendingTurn) {
+        pendingTurn.onEvent(msg);
+      } else if (!ready && msg.type === "error") {
+        reject(new Error(msg.message || "Could not start the CLI session."));
+        ws.close();
+      } else if (msg.type === "error") {
+        // No turn is running, so a bare error frame is the server refusing the
+        // control request we are waiting on. Without this it is swallowed and
+        // /compact never returns.
+        settleControl({
+          error: new Error(msg.message || "The server rejected that command."),
+        });
+      }
+    };
+
+    ws.onerror = (event) => {
+      const message =
+        event?.message || event?.error?.message || "connection failed";
+      if (!ready) reject(new Error(`Could not reach ${url} (${message}).`));
+      if (pendingTurn) {
+        void settleTurn({ type: "error", message });
+      }
+      settleControl({ error: new Error(message) });
+    };
+
+    ws.onclose = () => {
+      commandRunner.cancelAll();
+      if (!ready && !closed)
+        reject(new Error(`The agent tunnel closed at ${url}.`));
+      if (pendingTurn) {
+        void settleTurn({
+          type: "error",
+          message: closed
+            ? "Session closed."
+            : "The agent tunnel disconnected.",
+        });
+      }
+      settleControl({
+        error: new Error(
+          closed ? "Session closed." : "The agent tunnel disconnected."
+        ),
+      });
+    };
+  });
+}
+
+module.exports = { connectInteractiveSession };