@adhdev/daemon-core 0.9.82-rc.166 → 0.9.82-rc.168

package/dist/index.mjs

@@ -3694,6 +3694,20 @@ function hasDispatchAfterTerminal(meshId, sessionId, terminalId) {
   }
   return false;
 }
+function hasUnterminalDirectDispatchLedgerEntry(meshId, sessionId) {
+  const entries = readLedgerEntries(meshId, { tail: 200 });
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.sessionId !== sessionId) continue;
+    if (entry.kind === "task_completed" || entry.kind === "task_failed" || entry.kind === "task_stalled") {
+      return false;
+    }
+    if (entry.kind === "task_dispatched" && entry.payload?.source === "direct") {
+      return true;
+    }
+  }
+  return false;
+}
 function buildLongGeneratingCompletionReconciliation(args) {
   const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
   const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
@@ -4561,7 +4575,7 @@ function setupMeshEventForwarding(components) {
     if (coordinatorMeshId) {
       try {
         const activeDispatches = getActiveDirectDispatches(coordinatorMeshId);
-        if (activeDispatches.some((d) => d.sessionId === instanceId)) {
+        if (activeDispatches.some((d) => d.sessionId === instanceId) || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, instanceId)) {
           meshIdFromDirectDispatch = coordinatorMeshId;
         }
       } catch {
@@ -6398,12 +6412,14 @@ function scopeLines(spec, lines, questionIndex) {
 function extractButtons(spec, lines, windowStart, windowEnd) {
   const buttonRe = compile3(spec.buttonPattern, spec.buttonFlags ?? "m");
   const out = [];
+  const labelGroup = Number.isInteger(spec.buttonLabelGroup) && (spec.buttonLabelGroup ?? 0) > 0 ? spec.buttonLabelGroup : 1;
   let i = windowStart;
   while (i < windowEnd) {
     const line = lines[i];
     const m = buttonRe.exec(line);
-    if (m && m[1]) {
-      let label = m[1].trim();
+    const captured = m?.[labelGroup] ?? (labelGroup === 1 && m && m.length > 2 ? m[m.length - 1] : void 0);
+    if (m && captured) {
+      let label = captured.trim();
       if (spec.continuationLines) {
         let j = i + 1;
         while (j < windowEnd) {
@@ -28100,7 +28116,7 @@ var CliProviderInstance = class {
     };
   }
   getSessionModalState(sessionId) {
-    const adapterStatus = this.adapter.getStatus({ allowParse: false });
+    const adapterStatus = this.adapter.getStatus({ allowParse: true });
     const autoApproveActive = adapterStatus.status === "waiting_approval" && this.shouldAutoApprove();
     const visibleStatus = autoApproveActive ? "generating" : adapterStatus.status;
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
@@ -31638,6 +31654,7 @@ function validateControl(control, errors) {
 }
 
 // src/providers/provider-loader.ts
+init_external_sources();
 function registerProviderScriptRootSafely(root) {
   if (!root || typeof root !== "string") return;
   try {
@@ -31895,11 +31912,7 @@ var ProviderLoader = class _ProviderLoader {
           this.log(`Loaded ${externalCount} external providers (legacy unnamed source)`);
         }
       } else {
-        const {
-          loadProvidersActive: loadProvidersActive2,
-          resolveActiveSource: resolveActiveSource2
-        } = (init_external_sources(), __toCommonJS(external_sources_exports));
-        const activeFile = loadProvidersActive2();
+        const activeFile = loadProvidersActive();
         let totalLoaded = 0;
         const ambiguousTypes = [];
         for (const sourceEntry of rootEntries) {
@@ -31914,7 +31927,7 @@ var ProviderLoader = class _ProviderLoader {
         for (const [type] of this.providers) {
           const prov = this.providers.get(type);
           if (!prov) continue;
-          const resolved = resolveActiveSource2(prov.category, type, activeFile);
+          const resolved = resolveActiveSource(prov.category, type, activeFile);
           if (resolved.candidates.length <= 1) continue;
           if (resolved.ambiguous) {
             ambiguousTypes.push({ type, chosen: resolved.source ?? "?", candidates: resolved.candidates });
@@ -39072,9 +39085,9 @@ var DaemonCommandRouter = class {
           });
           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,
@@ -47430,6 +47443,203 @@ var SessionHostPtyTransportFactory = class {
   }
 };
 
+// src/cli-adapters/raw-terminal-io.ts
+import { randomUUID as randomUUID10 } from "crypto";
+import {
+  SessionHostClient as SessionHostClient2
+} from "@adhdev/session-host-core";
+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}-${randomUUID10().slice(0, 8)}`;
+    const client = options.client || new SessionHostClient2({ 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 withRawTerminalAttachment(options, operation) {
+  const attachment = await RawTerminalAttachment.attach(options);
+  try {
+    return await operation(attachment);
+  } finally {
+    await attachment.close();
+  }
+}
+
 // src/session-host/app-name.ts
 var DEFAULT_SESSION_HOST_APP_NAME = "adhdev";
 var DEFAULT_STANDALONE_SESSION_HOST_APP_NAME = "adhdev-standalone";
@@ -47463,7 +47673,7 @@ function resolveSessionHostAppName(options = {}) {
 
 // src/session-host/runtime-support.ts
 import {
-  SessionHostClient as SessionHostClient2,
+  SessionHostClient as SessionHostClient3,
   getDefaultSessionHostEndpoint
 } from "@adhdev/session-host-core";
 var STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
@@ -47493,7 +47703,7 @@ async function assertRequiredRequestTypes(client, requiredRequestTypes) {
   }
 }
 async function canConnect(endpoint, requiredRequestTypes = []) {
-  const client = new SessionHostClient2({ endpoint });
+  const client = new SessionHostClient3({ endpoint });
   try {
     await client.connect();
     await assertRequiredRequestTypes(client, requiredRequestTypes);
@@ -47523,7 +47733,7 @@ async function ensureSessionHostReady(options) {
   return endpoint;
 }
 async function listHostedCliRuntimes(endpoint) {
-  const client = new SessionHostClient2({ endpoint });
+  const client = new SessionHostClient3({ endpoint });
   try {
     const response = await client.request({
       type: "list_sessions",
@@ -48397,6 +48607,7 @@ export {
   ProviderCliAdapter,
   ProviderInstanceManager,
   ProviderLoader,
+  RawTerminalAttachment,
   STANDALONE_CDP_SCAN_INTERVAL_MS,
   SessionHostPtyTransportFactory,
   SpecDriver,
@@ -48547,6 +48758,8 @@ export {
   markSetupComplete,
   markStaleDirectDispatches,
   maybeRunDaemonUpgradeHelperFromEnv,
+  namedKeyToAnsi,
+  namedKeysToAnsi,
   normalizeActiveChatData,
   normalizeChatMessage,
   normalizeChatMessageKind,
@@ -48627,6 +48840,7 @@ export {
   validateCliProviderManifest,
   validateMeshRefineConfig,
   validateMeshTaskModeRequest,
-  validateMeshWorktreeBootstrapConfig
+  validateMeshWorktreeBootstrapConfig,
+  withRawTerminalAttachment
 };
 //# sourceMappingURL=index.mjs.map