@adhdev/daemon-standalone 0.9.82-rc.167 → 0.9.82-rc.168

package/dist/index.js

@@ -7700,6 +7700,7 @@ var require_dist2 = __commonJS({
       "acquire_write",
       "release_write",
       "get_snapshot",
+      "get_terminal_snapshot",
       "clear_session_buffer",
       "update_session_meta",
       "get_host_diagnostics",
@@ -46907,6 +46908,7 @@ ${lastSnapshot}`;
       ProviderCliAdapter: () => ProviderCliAdapter,
       ProviderInstanceManager: () => ProviderInstanceManager,
       ProviderLoader: () => ProviderLoader,
+      RawTerminalAttachment: () => RawTerminalAttachment,
       STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS2,
       SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory2,
       SpecDriver: () => SpecDriver,
@@ -47057,6 +47059,8 @@ ${lastSnapshot}`;
       markSetupComplete: () => markSetupComplete,
       markStaleDirectDispatches: () => markStaleDirectDispatches,
       maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv2,
+      namedKeyToAnsi: () => namedKeyToAnsi,
+      namedKeysToAnsi: () => namedKeysToAnsi,
       normalizeActiveChatData: () => normalizeActiveChatData,
       normalizeChatMessage: () => normalizeChatMessage,
       normalizeChatMessageKind: () => normalizeChatMessageKind,
@@ -47137,7 +47141,8 @@ ${lastSnapshot}`;
       validateCliProviderManifest: () => validateCliProviderManifest,
       validateMeshRefineConfig: () => validateMeshRefineConfig,
       validateMeshTaskModeRequest: () => validateMeshTaskModeRequest,
-      validateMeshWorktreeBootstrapConfig: () => validateMeshWorktreeBootstrapConfig
+      validateMeshWorktreeBootstrapConfig: () => validateMeshWorktreeBootstrapConfig,
+      withRawTerminalAttachment: () => withRawTerminalAttachment2
     });
     module2.exports = __toCommonJS2(index_exports);
     init_repo_mesh_types();
@@ -73995,9 +74000,9 @@ ${e?.stderr || ""}`
               });
               let node;
               if (meshRecord.inline) {
-                const { randomUUID: randomUUID10 } = await import("crypto");
+                const { randomUUID: randomUUID11 } = await import("crypto");
                 node = {
-                  id: `node_${randomUUID10().replace(/-/g, "")}`,
+                  id: `node_${randomUUID11().replace(/-/g, "")}`,
                   workspace: result.worktreePath,
                   repoRoot: result.worktreePath,
                   daemonId: sourceNode.daemonId,
@@ -82310,6 +82315,199 @@ data: ${JSON.stringify(msg.data)}
         });
       }
     };
+    var import_crypto6 = require("crypto");
+    var import_session_host_core4 = require_dist2();
+    var BASE_KEY_SEQUENCES = {
+      enter: "\r",
+      escape: "\x1B",
+      tab: "	",
+      backspace: "\x7F",
+      up: "\x1B[A",
+      down: "\x1B[B",
+      right: "\x1B[C",
+      left: "\x1B[D",
+      home: "\x1B[H",
+      end: "\x1B[F",
+      pageup: "\x1B[5~",
+      pagedown: "\x1B[6~",
+      space: " ",
+      f1: "\x1BOP",
+      f2: "\x1BOQ",
+      f3: "\x1BOR",
+      f4: "\x1BOS",
+      f5: "\x1B[15~",
+      f6: "\x1B[17~",
+      f7: "\x1B[18~",
+      f8: "\x1B[19~",
+      f9: "\x1B[20~",
+      f10: "\x1B[21~",
+      f11: "\x1B[23~",
+      f12: "\x1B[24~"
+    };
+    var SHIFTED_CSI_KEYS = {
+      up: "\x1B[1;2A",
+      down: "\x1B[1;2B",
+      right: "\x1B[1;2C",
+      left: "\x1B[1;2D",
+      home: "\x1B[1;2H",
+      end: "\x1B[1;2F",
+      pageup: "\x1B[5;2~",
+      pagedown: "\x1B[6;2~",
+      f1: "\x1B[1;2P",
+      f2: "\x1B[1;2Q",
+      f3: "\x1B[1;2R",
+      f4: "\x1B[1;2S",
+      f5: "\x1B[15;2~",
+      f6: "\x1B[17;2~",
+      f7: "\x1B[18;2~",
+      f8: "\x1B[19;2~",
+      f9: "\x1B[20;2~",
+      f10: "\x1B[21;2~",
+      f11: "\x1B[23;2~",
+      f12: "\x1B[24;2~"
+    };
+    function isLowercaseLetter(value) {
+      return /^[a-z]$/.test(value);
+    }
+    function encodeControlLetter(letter) {
+      return String.fromCharCode(letter.charCodeAt(0) - 96);
+    }
+    function encodeShiftedKey(key) {
+      if (isLowercaseLetter(key)) return key.toUpperCase();
+      if (key.startsWith("ctrl+") && isLowercaseLetter(key.slice(5))) {
+        return encodeControlLetter(key.slice(5));
+      }
+      if (key.startsWith("alt+") && isLowercaseLetter(key.slice(4))) {
+        return `\x1B${key.slice(4).toUpperCase()}`;
+      }
+      if (key === "tab") return "\x1B[Z";
+      if (key in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key];
+      if (key in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key];
+      throw new Error(`Unsupported named key: shift+${key}`);
+    }
+    function namedKeyToAnsi(key) {
+      const normalized = String(key || "").trim().toLowerCase();
+      if (normalized in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[normalized];
+      if (normalized.startsWith("ctrl+") && isLowercaseLetter(normalized.slice(5))) {
+        return encodeControlLetter(normalized.slice(5));
+      }
+      if (normalized.startsWith("alt+") && isLowercaseLetter(normalized.slice(4))) {
+        return `\x1B${normalized.slice(4)}`;
+      }
+      if (normalized.startsWith("shift+")) return encodeShiftedKey(normalized.slice(6));
+      throw new Error(`Unsupported named key: ${key}`);
+    }
+    function namedKeysToAnsi(keys) {
+      if (!Array.isArray(keys)) throw new Error("keys must be an array");
+      return keys.map(namedKeyToAnsi).join("");
+    }
+    var RawTerminalAttachment = class _RawTerminalAttachment {
+      constructor(sessionId, clientId, mode, client) {
+        this.sessionId = sessionId;
+        this.clientId = clientId;
+        this.mode = mode;
+        this.client = client;
+      }
+      closed = false;
+      static async attach(options) {
+        const sessionId = String(options.sessionId || "").trim();
+        if (!sessionId) throw new Error("sessionId is required");
+        const mode = options.mode || "read";
+        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto6.randomUUID)().slice(0, 8)}`;
+        const client = options.client || new import_session_host_core4.SessionHostClient({ endpoint: options.endpoint });
+        await client.connect();
+        const attachResponse = await client.request({
+          type: "attach_session",
+          payload: {
+            sessionId,
+            clientId,
+            clientType: "web",
+            readOnly: mode === "read"
+          }
+        });
+        if (!attachResponse.success) {
+          await client.close().catch(() => {
+          });
+          throw new Error(attachResponse.error || `Failed to attach terminal session ${sessionId}`);
+        }
+        if (mode === "write") {
+          const ownerResponse = await client.request({
+            type: "acquire_write",
+            payload: {
+              sessionId,
+              clientId,
+              ownerType: "user",
+              force: true
+            }
+          });
+          if (!ownerResponse.success) {
+            await client.request({
+              type: "detach_session",
+              payload: { sessionId, clientId }
+            }).catch(() => ({ success: false }));
+            await client.close().catch(() => {
+            });
+            throw new Error(ownerResponse.error || `Failed to acquire terminal session ${sessionId}`);
+          }
+        }
+        return new _RawTerminalAttachment(sessionId, clientId, mode, client);
+      }
+      async readSnapshot() {
+        const response = await this.client.request({
+          type: "get_terminal_snapshot",
+          payload: { sessionId: this.sessionId }
+        });
+        if (!response.success || !response.result) {
+          throw new Error(response.error || `Terminal screen unavailable for ${this.sessionId}`);
+        }
+        return response.result;
+      }
+      async readScreenText() {
+        return (await this.readSnapshot()).text;
+      }
+      async readState() {
+        return (await this.readSnapshot()).state;
+      }
+      async writeInput(text) {
+        if (this.mode !== "write") throw new Error("Raw terminal attachment is read-only");
+        const response = await this.client.request({
+          type: "send_input",
+          payload: {
+            sessionId: this.sessionId,
+            clientId: this.clientId,
+            data: text
+          }
+        });
+        if (!response.success) throw new Error(response.error || `Failed to write terminal input to ${this.sessionId}`);
+      }
+      async writeKeys(keys) {
+        await this.writeInput(namedKeysToAnsi(keys));
+      }
+      async close() {
+        if (this.closed) return;
+        this.closed = true;
+        if (this.mode === "write") {
+          await this.client.request({
+            type: "release_write",
+            payload: { sessionId: this.sessionId, clientId: this.clientId }
+          }).catch(() => ({ success: false }));
+        }
+        await this.client.request({
+          type: "detach_session",
+          payload: { sessionId: this.sessionId, clientId: this.clientId }
+        }).catch(() => ({ success: false }));
+        await this.client.close().catch(() => {
+        });
+      }
+    };
+    async function withRawTerminalAttachment2(options, operation) {
+      const attachment = await RawTerminalAttachment.attach(options);
+      try {
+        return await operation(attachment);
+      } finally {
+        await attachment.close();
+      }
+    }
     var DEFAULT_SESSION_HOST_APP_NAME = "adhdev";
     var DEFAULT_STANDALONE_SESSION_HOST_APP_NAME = "adhdev-standalone";
     function getReservedStandaloneNamespaceWarning() {
@@ -82339,7 +82537,7 @@ data: ${JSON.stringify(msg.data)}
     function resolveSessionHostAppName(options = {}) {
       return resolveSessionHostAppNameResolution2(options).appName;
     }
-    var import_session_host_core4 = require_dist2();
+    var import_session_host_core5 = require_dist2();
     var STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS2;
     var STARTUP_POLL_MS = 200;
     var SessionHostCompatibilityError = class extends Error {
@@ -82367,7 +82565,7 @@ data: ${JSON.stringify(msg.data)}
       }
     }
     async function canConnect(endpoint, requiredRequestTypes = []) {
-      const client = new import_session_host_core4.SessionHostClient({ endpoint });
+      const client = new import_session_host_core5.SessionHostClient({ endpoint });
       try {
         await client.connect();
         await assertRequiredRequestTypes(client, requiredRequestTypes);
@@ -82389,7 +82587,7 @@ data: ${JSON.stringify(msg.data)}
       throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
     }
     async function ensureSessionHostReady2(options) {
-      const endpoint = (0, import_session_host_core4.getDefaultSessionHostEndpoint)(options.appName || "adhdev");
+      const endpoint = (0, import_session_host_core5.getDefaultSessionHostEndpoint)(options.appName || "adhdev");
       const requiredRequestTypes = options.requiredRequestTypes || [];
       if (await canConnect(endpoint, requiredRequestTypes)) return endpoint;
       options.spawnHost();
@@ -82397,7 +82595,7 @@ data: ${JSON.stringify(msg.data)}
       return endpoint;
     }
     async function listHostedCliRuntimes2(endpoint) {
-      const client = new import_session_host_core4.SessionHostClient({ endpoint });
+      const client = new import_session_host_core5.SessionHostClient({ endpoint });
       try {
         const response = await client.request({
           type: "list_sessions",
@@ -83396,7 +83594,7 @@ async function ensureSessionHostReady() {
       appName: SESSION_HOST_APP_NAME,
       spawnHost,
       timeoutMs: SESSION_HOST_START_TIMEOUT_MS,
-      requiredRequestTypes: ["delete_session"]
+      requiredRequestTypes: ["delete_session", "get_terminal_snapshot"]
     });
   } catch (error48) {
     stopSessionHost();
@@ -83404,7 +83602,7 @@ async function ensureSessionHostReady() {
       appName: SESSION_HOST_APP_NAME,
       spawnHost,
       timeoutMs: SESSION_HOST_START_TIMEOUT_MS,
-      requiredRequestTypes: ["delete_session"]
+      requiredRequestTypes: ["delete_session", "get_terminal_snapshot"]
     }).catch((retryError) => {
       const initialMessage = error48 instanceof Error ? error48.message : String(error48);
       const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);
@@ -83805,6 +84003,109 @@ async function getWorkspaceSocketInfo(workspaceName) {
 
 // src/index.ts
 var import_daemon_core4 = __toESM(require_dist3());
+
+// src/raw-terminal-http.ts
+function parseRawTerminalPath(pathname) {
+  const match = /^\/api\/v1\/sessions\/([^/]+)\/(screen|state|input|keys)$/.exec(pathname);
+  if (!match) return null;
+  try {
+    const sessionId = decodeURIComponent(match[1]).trim();
+    return sessionId ? { sessionId, action: match[2] } : null;
+  } catch {
+    return null;
+  }
+}
+function isRawTerminalApiPath(pathname) {
+  return parseRawTerminalPath(pathname) !== null;
+}
+function isLoopbackAddress(address) {
+  if (!address) return false;
+  const normalized = address.toLowerCase().split("%", 1)[0];
+  return normalized === "127.0.0.1" || normalized.startsWith("127.") || normalized === "::1" || normalized === "::ffff:127.0.0.1" || normalized.startsWith("::ffff:127.");
+}
+function isLoopbackRequest(req) {
+  return isLoopbackAddress(req.socket.remoteAddress);
+}
+async function readJsonBody(req) {
+  return await new Promise((resolve2, reject) => {
+    let body = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      body += chunk;
+      if (body.length > 64 * 1024) reject(new Error("Request body too large"));
+    });
+    req.on("end", () => {
+      try {
+        resolve2(body ? JSON.parse(body) : {});
+      } catch (error48) {
+        reject(error48);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function writeJson(res, statusCode, value) {
+  res.writeHead(statusCode, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(value));
+}
+function errorStatus(error48) {
+  const message = error48 instanceof Error ? error48.message : String(error48);
+  if (/Unknown session/i.test(message)) return 404;
+  if (/not running|unavailable/i.test(message)) return 409;
+  if (/Unsupported named key|keys must|text must|JSON|body too large/i.test(message)) return 400;
+  return 500;
+}
+async function handleRawTerminalHttpRequest(options) {
+  const { req, res, parsedUrl, service } = options;
+  const route = parseRawTerminalPath(parsedUrl.pathname);
+  if (!route) return false;
+  if (!isLoopbackRequest(req)) {
+    writeJson(res, 403, { error: "Raw terminal API is available only from localhost." });
+    return true;
+  }
+  const method = req.method || "GET";
+  try {
+    if (route.action === "screen" && method === "GET") {
+      const format = parsedUrl.searchParams.get("format") || "text";
+      if (format !== "text") {
+        writeJson(res, 400, { error: "Phase 2 supports only format=text." });
+        return true;
+      }
+      const text = await service.readScreen(route.sessionId);
+      res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end(text);
+      return true;
+    }
+    if (route.action === "state" && method === "GET") {
+      writeJson(res, 200, await service.readState(route.sessionId));
+      return true;
+    }
+    if (route.action === "input" && method === "POST") {
+      const body = await readJsonBody(req);
+      if (typeof body.text !== "string") throw new Error("text must be a string");
+      await service.writeInput(route.sessionId, body.text);
+      writeJson(res, 200, { success: true });
+      return true;
+    }
+    if (route.action === "keys" && method === "POST") {
+      const body = await readJsonBody(req);
+      if (!Array.isArray(body.keys) || !body.keys.every((key) => typeof key === "string")) {
+        throw new Error("keys must be an array of named key strings");
+      }
+      await service.writeKeys(route.sessionId, body.keys);
+      writeJson(res, 200, { success: true });
+      return true;
+    }
+    writeJson(res, 405, { error: "Method not allowed" });
+    return true;
+  } catch (error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    writeJson(res, errorStatus(error48), { error: message });
+    return true;
+  }
+}
+
+// src/index.ts
 var DEFAULT_PORT = 3847;
 var STATUS_INTERVAL = 2e3;
 var CHAT_OUTPUT_ACTIVITY_HOT_MS = import_daemon_core4.DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS;
@@ -84027,6 +84328,27 @@ var StandaloneServer = class {
   devServer = null;
   sessionHostEndpoint = null;
   sessionHostControl = null;
+  rawTerminalService() {
+    const endpoint = this.sessionHostEndpoint || void 0;
+    return {
+      readScreen: (sessionId) => (0, import_daemon_core2.withRawTerminalAttachment)(
+        { endpoint, sessionId, mode: "read" },
+        (attachment) => attachment.readScreenText()
+      ),
+      readState: (sessionId) => (0, import_daemon_core2.withRawTerminalAttachment)(
+        { endpoint, sessionId, mode: "read" },
+        (attachment) => attachment.readState()
+      ),
+      writeInput: (sessionId, text) => (0, import_daemon_core2.withRawTerminalAttachment)(
+        { endpoint, sessionId, mode: "write" },
+        (attachment) => attachment.writeInput(text)
+      ),
+      writeKeys: (sessionId, keys) => (0, import_daemon_core2.withRawTerminalAttachment)(
+        { endpoint, sessionId, mode: "write" },
+        (attachment) => attachment.writeKeys(keys)
+      )
+    };
+  }
   isRecoverableSessionHostError(error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
     return message.includes("ECONNREFUSED") || message.includes("ENOENT") || message.includes("Session host socket unavailable");
@@ -84589,6 +84911,19 @@ var StandaloneServer = class {
       return;
     }
     const apiPath = url2.startsWith("/api/v1/") ? url2.slice(7) : null;
+    if (isRawTerminalApiPath(parsedUrl.pathname)) {
+      void handleRawTerminalHttpRequest({
+        req,
+        res,
+        parsedUrl,
+        service: this.rawTerminalService()
+      }).catch((error48) => {
+        if (res.headersSent) return;
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error48?.message || String(error48) }));
+      });
+      return;
+    }
     if (apiPath === "/status" && method === "GET") {
       const status = this.getStatus(getSharedSnapshot());
       res.writeHead(200, { "Content-Type": "application/json" });