@adhdev/daemon-core 0.9.82-rc.167 → 0.9.82-rc.169

package/dist/cli-adapters/raw-terminal-io.d.ts

@@ -0,0 +1,37 @@
+import { type SessionHostEndpoint, type SessionHostRequest, type SessionHostResponse, type SessionTerminalSnapshot, type SessionTerminalState } from '@adhdev/session-host-core';
+type LowercaseLetter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type FunctionKey = 'f1' | 'f2' | 'f3' | 'f4' | 'f5' | 'f6' | 'f7' | 'f8' | 'f9' | 'f10' | 'f11' | 'f12';
+type BaseNamedKey = 'enter' | 'escape' | 'tab' | 'backspace' | 'up' | 'down' | 'left' | 'right' | 'home' | 'end' | 'pageup' | 'pagedown' | 'space' | FunctionKey;
+type ShiftNamedKey = BaseNamedKey | LowercaseLetter | `ctrl+${LowercaseLetter}` | `alt+${LowercaseLetter}`;
+export type NamedKey = BaseNamedKey | `ctrl+${LowercaseLetter}` | `alt+${LowercaseLetter}` | `shift+${ShiftNamedKey}`;
+export declare function namedKeyToAnsi(key: NamedKey | string): string;
+export declare function namedKeysToAnsi(keys: readonly (NamedKey | string)[]): string;
+export interface RawTerminalSessionHostClient {
+    connect(): Promise<void>;
+    request<T = unknown>(request: SessionHostRequest): Promise<SessionHostResponse<T>>;
+    close(): Promise<void>;
+}
+export interface RawTerminalAttachmentOptions {
+    endpoint?: SessionHostEndpoint;
+    sessionId: string;
+    mode?: 'read' | 'write';
+    clientId?: string;
+    client?: RawTerminalSessionHostClient;
+}
+export declare class RawTerminalAttachment {
+    readonly sessionId: string;
+    private readonly clientId;
+    private readonly mode;
+    private readonly client;
+    private closed;
+    private constructor();
+    static attach(options: RawTerminalAttachmentOptions): Promise<RawTerminalAttachment>;
+    readSnapshot(): Promise<SessionTerminalSnapshot>;
+    readScreenText(): Promise<string>;
+    readState(): Promise<SessionTerminalState>;
+    writeInput(text: string): Promise<void>;
+    writeKeys(keys: readonly (NamedKey | string)[]): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function withRawTerminalAttachment<T>(options: RawTerminalAttachmentOptions, operation: (attachment: RawTerminalAttachment) => Promise<T>): Promise<T>;
+export {};

package/dist/index.d.ts

@@ -123,6 +123,8 @@ export type { CliAdapter } from './cli-adapter-types.js';
 export { NodePtyTransportFactory } from './cli-adapters/pty-transport.js';
 export type { PtyRuntimeTransport, PtyTransportFactory, PtySpawnOptions } from './cli-adapters/pty-transport.js';
 export { SessionHostPtyTransportFactory } from './cli-adapters/session-host-transport.js';
+export { RawTerminalAttachment, namedKeyToAnsi, namedKeysToAnsi, withRawTerminalAttachment, } from './cli-adapters/raw-terminal-io.js';
+export type { NamedKey, RawTerminalAttachmentOptions, RawTerminalSessionHostClient } from './cli-adapters/raw-terminal-io.js';
 export type { HostedCliRuntimeDescriptor, CliTransportFactoryParams } from './commands/cli-manager.js';
 export { DEFAULT_SESSION_HOST_APP_NAME, DEFAULT_STANDALONE_SESSION_HOST_APP_NAME, resolveSessionHostAppName, resolveSessionHostAppNameResolution, } from './session-host/app-name.js';
 export type { SessionHostAppNameResolution } from './session-host/app-name.js';

package/dist/index.js

@@ -9945,6 +9945,10 @@ var init_schema_gen = __esm({
                   "type": "integer",
                   "minimum": 1,
                   "default": 2
+                },
+                "continuation_lines": {
+                  "type": "boolean",
+                  "default": false
                 }
               }
             }
@@ -12079,6 +12083,7 @@ __export(index_exports, {
   ProviderCliAdapter: () => ProviderCliAdapter,
   ProviderInstanceManager: () => ProviderInstanceManager,
   ProviderLoader: () => ProviderLoader,
+  RawTerminalAttachment: () => RawTerminalAttachment,
   STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS,
   SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory,
   SpecDriver: () => SpecDriver,
@@ -12229,6 +12234,8 @@ __export(index_exports, {
   markSetupComplete: () => markSetupComplete,
   markStaleDirectDispatches: () => markStaleDirectDispatches,
   maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv,
+  namedKeyToAnsi: () => namedKeyToAnsi,
+  namedKeysToAnsi: () => namedKeysToAnsi,
   normalizeActiveChatData: () => normalizeActiveChatData,
   normalizeChatMessage: () => normalizeChatMessage,
   normalizeChatMessageKind: () => normalizeChatMessageKind,
@@ -12309,7 +12316,8 @@ __export(index_exports, {
   validateCliProviderManifest: () => validateCliProviderManifest,
   validateMeshRefineConfig: () => validateMeshRefineConfig,
   validateMeshTaskModeRequest: () => validateMeshTaskModeRequest,
-  validateMeshWorktreeBootstrapConfig: () => validateMeshWorktreeBootstrapConfig
+  validateMeshWorktreeBootstrapConfig: () => validateMeshWorktreeBootstrapConfig,
+  withRawTerminalAttachment: () => withRawTerminalAttachment
 });
 module.exports = __toCommonJS(index_exports);
 init_repo_mesh_types();
@@ -20122,6 +20130,11 @@ function pickApprovalButton(buttons, provider) {
   }
   return { index: -1, label: "" };
 }
+function pickAutoApprovalButton(buttons) {
+  const labels = (buttons || []).map((button) => String(button || "").trim());
+  const index = labels.findIndex(Boolean);
+  return index >= 0 ? { index, label: labels[index] } : { index: -1, label: "" };
+}
 function formatAutoApprovalMessage(modalMessage, buttonLabel) {
   const lines = [`Auto-approved${buttonLabel ? `: ${buttonLabel}` : ""}`];
   const cleanMessage = String(modalMessage || "").trim();
@@ -20696,7 +20709,7 @@ ${effect.notification.body || ""}`.trim();
     }
     this.autoApproveBusy = true;
     try {
-      const { label: targetButton } = pickApprovalButton(_chatData?.activeModal?.buttons, this.provider);
+      const { label: targetButton } = pickAutoApprovalButton(_chatData?.activeModal?.buttons);
       const script = scriptFn({ action: "approve", button: targetButton, buttonText: targetButton });
       if (!script) return;
       const now = Date.now();
@@ -27162,6 +27175,10 @@ function compilePattern(ref) {
   const flags = ref.flags ?? "gm";
   return new RegExp(ref.pattern, flags.includes("g") ? flags : flags + "g");
 }
+function compileLinePattern(ref) {
+  const flags = (ref.flags ?? "m").replace(/g/g, "");
+  return new RegExp(ref.pattern, flags);
+}
 function matchState(state, sections, fullScreen, trace) {
   const haystack = sectionText(sections, state.when.section, fullScreen);
   const re = compileRegex(state.when);
@@ -27182,16 +27199,41 @@ function matchState(state, sections, fullScreen, trace) {
 function extractModal(state, sections, fullScreen, title, trace) {
   if (!state.modal_buttons) return null;
   const hay = sectionText(sections, state.modal_buttons.section, fullScreen);
-  const re = compilePattern(state.modal_buttons);
   const buttons = [];
-  let m;
-  while ((m = re.exec(hay)) !== null) {
-    const idx = Number(m[1]);
-    const label = String(m[2] ?? "").trim();
-    if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
-    if (buttons.some((b) => b.index === idx)) continue;
-    const key = state.modal_buttons.key_for_index.replace(/\{index\}/g, String(idx));
-    buttons.push({ index: idx, label, key });
+  if (state.modal_buttons.continuation_lines) {
+    const re = compileLinePattern(state.modal_buttons);
+    const lines = hay.split("\n");
+    for (let i = 0; i < lines.length; i += 1) {
+      const m = re.exec(lines[i]);
+      if (!m) continue;
+      const idx = Number(m[1]);
+      let label = String(m[2] ?? "").trim();
+      if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
+      let j = i + 1;
+      while (j < lines.length) {
+        const next = lines[j];
+        if (!next.trim()) break;
+        if (re.test(next)) break;
+        if (!/^\s+/.test(next)) break;
+        label += " " + next.trim();
+        j += 1;
+      }
+      if (buttons.some((b) => b.index === idx)) continue;
+      const key = state.modal_buttons.key_for_index.replace(/\{index\}/g, String(idx));
+      buttons.push({ index: idx, label, key });
+      i = j - 1;
+    }
+  } else {
+    const re = compilePattern(state.modal_buttons);
+    let m;
+    while ((m = re.exec(hay)) !== null) {
+      const idx = Number(m[1]);
+      const label = String(m[2] ?? "").trim();
+      if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
+      if (buttons.some((b) => b.index === idx)) continue;
+      const key = state.modal_buttons.key_for_index.replace(/\{index\}/g, String(idx));
+      buttons.push({ index: idx, label, key });
+    }
   }
   buttons.sort((a, b) => a.index - b.index);
   const minCount = state.modal_buttons.min_count ?? 2;
@@ -28699,7 +28741,7 @@ var CliProviderInstance = class {
     if (!modal || buttons.length === 0) {
       return autoApproveActive;
     }
-    const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(buttons, this.provider);
+    const { index: buttonIndex, label: buttonLabel } = pickAutoApprovalButton(buttons);
     if (buttonIndex < 0) {
       return autoApproveActive;
     }
@@ -39377,9 +39419,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,
@@ -41615,8 +41657,7 @@ var AgentStreamPoller = class {
         if (stream?.status === "waiting_approval") {
           const autoApprove = providerLoader.getSettings(stream.agentType).autoApprove !== false;
           if (autoApprove && resolvedActiveSessionId) {
-            const provider = providerLoader.getMeta(stream.agentType);
-            const { label: buttonLabel } = pickApprovalButton(stream.activeModal?.buttons, provider);
+            const { label: buttonLabel } = pickAutoApprovalButton(stream.activeModal?.buttons);
             const approved = await agentStreamManager.resolveSessionAction(cdp, resolvedActiveSessionId, "approve", buttonLabel);
             if (approved) {
               const effectId = [
@@ -47733,6 +47774,201 @@ var SessionHostPtyTransportFactory = class {
   }
 };
 
+// src/cli-adapters/raw-terminal-io.ts
+var import_crypto6 = require("crypto");
+var import_session_host_core4 = require("@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}-${(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 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";
@@ -47765,7 +48001,7 @@ function resolveSessionHostAppName(options = {}) {
 }
 
 // src/session-host/runtime-support.ts
-var import_session_host_core4 = require("@adhdev/session-host-core");
+var import_session_host_core5 = require("@adhdev/session-host-core");
 var STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
 var STARTUP_POLL_MS = 200;
 var SessionHostCompatibilityError = class extends Error {
@@ -47793,7 +48029,7 @@ async function assertRequiredRequestTypes(client, requiredRequestTypes) {
   }
 }
 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);
@@ -47815,7 +48051,7 @@ async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS, requiredRe
   throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
 }
 async function ensureSessionHostReady(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();
@@ -47823,7 +48059,7 @@ async function ensureSessionHostReady(options) {
   return endpoint;
 }
 async function listHostedCliRuntimes(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",
@@ -48698,6 +48934,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   ProviderCliAdapter,
   ProviderInstanceManager,
   ProviderLoader,
+  RawTerminalAttachment,
   STANDALONE_CDP_SCAN_INTERVAL_MS,
   SessionHostPtyTransportFactory,
   SpecDriver,
@@ -48848,6 +49085,8 @@ var V1_CONTRACT_VERSION = "1.0.0";
   markSetupComplete,
   markStaleDirectDispatches,
   maybeRunDaemonUpgradeHelperFromEnv,
+  namedKeyToAnsi,
+  namedKeysToAnsi,
   normalizeActiveChatData,
   normalizeChatMessage,
   normalizeChatMessageKind,
@@ -48928,6 +49167,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   validateCliProviderManifest,
   validateMeshRefineConfig,
   validateMeshTaskModeRequest,
-  validateMeshWorktreeBootstrapConfig
+  validateMeshWorktreeBootstrapConfig,
+  withRawTerminalAttachment
 });
 //# sourceMappingURL=index.js.map