@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-VAUOM3IN.mjs

@@ -0,0 +1,298 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  APEv2Parser
+} from "./chunk-NBTUWMGP.mjs";
+import {
+  trimRightNull
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  BasicParser,
+  StringType,
+  UINT8,
+  textDecode
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/id3v1/ID3v1Parser.js
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:ID3v1"), Genres = [
+  "Blues",
+  "Classic Rock",
+  "Country",
+  "Dance",
+  "Disco",
+  "Funk",
+  "Grunge",
+  "Hip-Hop",
+  "Jazz",
+  "Metal",
+  "New Age",
+  "Oldies",
+  "Other",
+  "Pop",
+  "R&B",
+  "Rap",
+  "Reggae",
+  "Rock",
+  "Techno",
+  "Industrial",
+  "Alternative",
+  "Ska",
+  "Death Metal",
+  "Pranks",
+  "Soundtrack",
+  "Euro-Techno",
+  "Ambient",
+  "Trip-Hop",
+  "Vocal",
+  "Jazz+Funk",
+  "Fusion",
+  "Trance",
+  "Classical",
+  "Instrumental",
+  "Acid",
+  "House",
+  "Game",
+  "Sound Clip",
+  "Gospel",
+  "Noise",
+  "Alt. Rock",
+  "Bass",
+  "Soul",
+  "Punk",
+  "Space",
+  "Meditative",
+  "Instrumental Pop",
+  "Instrumental Rock",
+  "Ethnic",
+  "Gothic",
+  "Darkwave",
+  "Techno-Industrial",
+  "Electronic",
+  "Pop-Folk",
+  "Eurodance",
+  "Dream",
+  "Southern Rock",
+  "Comedy",
+  "Cult",
+  "Gangsta Rap",
+  "Top 40",
+  "Christian Rap",
+  "Pop/Funk",
+  "Jungle",
+  "Native American",
+  "Cabaret",
+  "New Wave",
+  "Psychedelic",
+  "Rave",
+  "Showtunes",
+  "Trailer",
+  "Lo-Fi",
+  "Tribal",
+  "Acid Punk",
+  "Acid Jazz",
+  "Polka",
+  "Retro",
+  "Musical",
+  "Rock & Roll",
+  "Hard Rock",
+  "Folk",
+  "Folk/Rock",
+  "National Folk",
+  "Swing",
+  "Fast-Fusion",
+  "Bebob",
+  "Latin",
+  "Revival",
+  "Celtic",
+  "Bluegrass",
+  "Avantgarde",
+  "Gothic Rock",
+  "Progressive Rock",
+  "Psychedelic Rock",
+  "Symphonic Rock",
+  "Slow Rock",
+  "Big Band",
+  "Chorus",
+  "Easy Listening",
+  "Acoustic",
+  "Humour",
+  "Speech",
+  "Chanson",
+  "Opera",
+  "Chamber Music",
+  "Sonata",
+  "Symphony",
+  "Booty Bass",
+  "Primus",
+  "Porn Groove",
+  "Satire",
+  "Slow Jam",
+  "Club",
+  "Tango",
+  "Samba",
+  "Folklore",
+  "Ballad",
+  "Power Ballad",
+  "Rhythmic Soul",
+  "Freestyle",
+  "Duet",
+  "Punk Rock",
+  "Drum Solo",
+  "A Cappella",
+  "Euro-House",
+  "Dance Hall",
+  "Goa",
+  "Drum & Bass",
+  "Club-House",
+  "Hardcore",
+  "Terror",
+  "Indie",
+  "BritPop",
+  "Negerpunk",
+  "Polsk Punk",
+  "Beat",
+  "Christian Gangsta Rap",
+  "Heavy Metal",
+  "Black Metal",
+  "Crossover",
+  "Contemporary Christian",
+  "Christian Rock",
+  "Merengue",
+  "Salsa",
+  "Thrash Metal",
+  "Anime",
+  "JPop",
+  "Synthpop",
+  "Abstract",
+  "Art Rock",
+  "Baroque",
+  "Bhangra",
+  "Big Beat",
+  "Breakbeat",
+  "Chillout",
+  "Downtempo",
+  "Dub",
+  "EBM",
+  "Eclectic",
+  "Electro",
+  "Electroclash",
+  "Emo",
+  "Experimental",
+  "Garage",
+  "Global",
+  "IDM",
+  "Illbient",
+  "Industro-Goth",
+  "Jam Band",
+  "Krautrock",
+  "Leftfield",
+  "Lounge",
+  "Math Rock",
+  "New Romantic",
+  "Nu-Breakz",
+  "Post-Punk",
+  "Post-Rock",
+  "Psytrance",
+  "Shoegaze",
+  "Space Rock",
+  "Trop Rock",
+  "World Music",
+  "Neoclassical",
+  "Audiobook",
+  "Audio Theatre",
+  "Neue Deutsche Welle",
+  "Podcast",
+  "Indie Rock",
+  "G-Funk",
+  "Dubstep",
+  "Garage Rock",
+  "Psybient"
+], Iid3v1Token = {
+  len: 128,
+  /**
+   * @param buf Buffer possibly holding the 128 bytes ID3v1.1 metadata header
+   * @param off Offset in buffer in bytes
+   * @returns ID3v1.1 header if first 3 bytes equals 'TAG', otherwise null is returned
+   */
+  get: (buf, off) => {
+    let header = new Id3v1StringType(3).get(buf, off);
+    return header === "TAG" ? {
+      header,
+      title: new Id3v1StringType(30).get(buf, off + 3),
+      artist: new Id3v1StringType(30).get(buf, off + 33),
+      album: new Id3v1StringType(30).get(buf, off + 63),
+      year: new Id3v1StringType(4).get(buf, off + 93),
+      comment: new Id3v1StringType(28).get(buf, off + 97),
+      // ID3v1.1 separator for track
+      zeroByte: UINT8.get(buf, off + 127),
+      // track: ID3v1.1 field added by Michael Mutschler
+      track: UINT8.get(buf, off + 126),
+      genre: UINT8.get(buf, off + 127)
+    } : null;
+  }
+}, Id3v1StringType = class {
+  constructor(len) {
+    this.len = len, this.stringType = new StringType(len, "latin1");
+  }
+  get(buf, off) {
+    let value = this.stringType.get(buf, off);
+    return value = trimRightNull(value), value = value.trim(), value.length > 0 ? value : void 0;
+  }
+}, ID3v1Parser = class _ID3v1Parser extends BasicParser {
+  constructor(metadata, tokenizer, options) {
+    super(metadata, tokenizer, options), this.apeHeader = options.apeHeader;
+  }
+  static getGenre(genreIndex) {
+    if (genreIndex < Genres.length)
+      return Genres[genreIndex];
+  }
+  async parse() {
+    if (!this.tokenizer.fileInfo.size) {
+      debug("Skip checking for ID3v1 because the file-size is unknown");
+      return;
+    }
+    this.apeHeader && this.tokenizer.supportsRandomAccess() && (this.tokenizer.setPosition(this.apeHeader.offset), await new APEv2Parser(this.metadata, this.tokenizer, this.options).parseTags(this.apeHeader.footer));
+    let offset = this.tokenizer.fileInfo.size - Iid3v1Token.len;
+    if (this.tokenizer.position > offset) {
+      debug("Already consumed the last 128 bytes");
+      return;
+    }
+    let header = await this.tokenizer.readToken(Iid3v1Token, offset);
+    if (header) {
+      debug("ID3v1 header found at: pos=%s", this.tokenizer.fileInfo.size - Iid3v1Token.len);
+      let props = ["title", "artist", "album", "comment", "track", "year"];
+      for (let id of props)
+        header[id] && header[id] !== "" && await this.addTag(id, header[id]);
+      let genre = _ID3v1Parser.getGenre(header.genre);
+      genre && await this.addTag("genre", genre);
+    } else
+      debug("ID3v1 header not found at: pos=%s", this.tokenizer.fileInfo.size - Iid3v1Token.len);
+  }
+  async addTag(id, value) {
+    await this.metadata.addTag("ID3v1", id, value);
+  }
+};
+async function hasID3v1Header(tokenizer) {
+  if (tokenizer.fileInfo.size >= 128) {
+    let tag = new Uint8Array(3), position = tokenizer.position;
+    return await tokenizer.readBuffer(tag, { position: tokenizer.fileInfo.size - 128 }), tokenizer.setPosition(position), textDecode(tag, "latin1") === "TAG";
+  }
+  return !1;
+}
+
+export {
+  Genres,
+  ID3v1Parser,
+  hasID3v1Header
+};

package/dist/chunks/chunk-VMHTYDH4.mjs

@@ -0,0 +1,172 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  __export
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/shared/utils/mcp-config.ts
+var mcp_config_exports = {};
+__export(mcp_config_exports, {
+  MCP_EXECUTABLE_IDENTITY_FIELDS: () => MCP_EXECUTABLE_IDENTITY_FIELDS,
+  buildEnvSchemaFromKeys: () => buildEnvSchemaFromKeys,
+  buildHeaderEnvSchemaFromEntries: () => buildHeaderEnvSchemaFromEntries,
+  buildMcpServerConfigFromRegistration: () => buildMcpServerConfigFromRegistration,
+  deriveRegistrationTestPlan: () => deriveRegistrationTestPlan,
+  getMcpRegistrationEnvKeys: () => getMcpRegistrationEnvKeys,
+  isRegistrationAgentVisible: () => isRegistrationAgentVisible,
+  isSensitiveMcpHeader: () => isSensitiveMcpHeader,
+  mcpCredentialNamespace: () => mcpCredentialNamespace,
+  mcpCredentialRef: () => mcpCredentialRef,
+  pinServerConfigToRegistration: () => pinServerConfigToRegistration,
+  reconcileHostApprovedRegistrations: () => reconcileHostApprovedRegistrations,
+  registrationSourceIdentity: () => registrationSourceIdentity,
+  sameExecutableIdentity: () => sameExecutableIdentity,
+  suggestedAgentVisible: () => suggestedAgentVisible
+});
+function sourcePackage(source) {
+  let s = source;
+  return s.npm_package ?? s.npmPackage ?? s.pypi_package ?? s.pypiPackage;
+}
+function mcpCredentialNamespace(source) {
+  return sourcePackage(source) ?? source.name;
+}
+function mcpCredentialRef(source, key) {
+  return `mcp:${mcpCredentialNamespace(source)}:${key}`;
+}
+function isSensitiveMcpHeader(header) {
+  let normalized = header.trim().toLowerCase();
+  return normalized === "authorization" || normalized === "proxy-authorization" || normalized === "x-api-key" || normalized === "api-key" || normalized === "apikey" || normalized === "x-auth-token" || normalized === "x-access-token" || normalized.includes("token") || normalized.includes("secret") || normalized.includes("credential");
+}
+function buildEnvSchemaFromKeys(source, keys, scope, requiredKeys = keys) {
+  let required = new Set(requiredKeys);
+  return [...new Set(keys.filter(Boolean))].map((key) => ({
+    key,
+    scope,
+    required: required.has(key) || void 0,
+    credential_ref: scope === "app" ? mcpCredentialRef(source, key) : void 0
+  }));
+}
+function buildHeaderEnvSchemaFromEntries(source, entries, appScoped = !0) {
+  return entries.filter((entry) => entry.header && entry.env).map((entry) => ({
+    header: entry.header,
+    env: entry.env,
+    required: !0,
+    credential_ref: appScoped ? mcpCredentialRef(source, entry.env) : void 0
+  }));
+}
+function getMcpRegistrationEnvKeys(registration) {
+  return [.../* @__PURE__ */ new Set([
+    ...(registration.env ?? []).map((entry) => entry.key).filter(Boolean),
+    ...registration.bearerTokenEnvVar ? [registration.bearerTokenEnvVar] : [],
+    ...(registration.headerEnv ?? []).map((entry) => entry.value).filter(Boolean)
+  ])];
+}
+function buildMcpServerConfigFromRegistration(registration) {
+  let isHttp = registration.type === "http" || !!registration.url, serverCfg = {
+    name: registration.name,
+    transport: isHttp ? "http" : "stdio"
+  };
+  if (isHttp) {
+    serverCfg.url = registration.url, serverCfg.source = registration.url ? `http:${registration.url}` : "http";
+    let staticHeaders = {};
+    for (let { key, value } of registration.headers ?? [])
+      key && value && !isSensitiveMcpHeader(key) && (staticHeaders[key] = value);
+    Object.keys(staticHeaders).length && (serverCfg.headers = staticHeaders), registration.headerEnv?.length && (serverCfg.header_env = buildHeaderEnvSchemaFromEntries(
+      registration,
+      registration.headerEnv.map(({ key, value }) => ({ header: key, env: value })),
+      (registration.credentialStorage ?? "app") !== "agent"
+    )), registration.oauth ? serverCfg.oauth = !0 : registration.bearerTokenEnvVar && (serverCfg.bearer_token_env_var = registration.bearerTokenEnvVar);
+  } else registration.npmPackage ? (serverCfg.source = `npm:${registration.npmPackage}`, serverCfg.npm_package = registration.npmPackage) : registration.pypiPackage ? (serverCfg.source = `uvx:${registration.pypiPackage}`, serverCfg.pypi_package = registration.pypiPackage) : (serverCfg.source = "custom", serverCfg.command = registration.command, serverCfg.args = registration.args);
+  isHttp || (registration.command && (serverCfg.command = registration.command), registration.args?.length && (serverCfg.args = registration.args));
+  let envKeys = getMcpRegistrationEnvKeys(registration);
+  if (envKeys.length) {
+    let scope = (registration.credentialStorage ?? "app") === "agent" ? "agent" : "app";
+    scope === "agent" && (serverCfg.env_keys = envKeys), serverCfg.env_schema = buildEnvSchemaFromKeys(registration, envKeys, scope);
+  }
+  return registration.toolCallTimeout && (serverCfg.tool_call_timeout_ms = registration.toolCallTimeout * 1e3), !isHttp && registration.runLocation && (serverCfg.run_location = registration.runLocation), registration.credentialFiles?.length && (serverCfg.credential_files = registration.credentialFiles.map((f) => ({
+    path: f.path,
+    ...f.required !== void 0 ? { required: f.required } : {},
+    ...f.writeBack !== void 0 ? { write_back: f.writeBack } : {}
+  }))), serverCfg;
+}
+function pinServerConfigToRegistration(connCfg, registration) {
+  let canonical = buildMcpServerConfigFromRegistration(registration), agentEnvSchema = (connCfg.env_schema ?? []).filter((e) => e.scope === "agent"), mergedEnvSchema = [
+    ...canonical.env_schema ?? [],
+    ...agentEnvSchema.filter(
+      (a) => !(canonical.env_schema ?? []).some((c) => c.key === a.key && c.scope === a.scope)
+    )
+  ];
+  return {
+    ...canonical,
+    // Agent-owned state kept from the .adf copy:
+    env: connCfg.env,
+    env_keys: connCfg.env_keys,
+    available_tools: connCfg.available_tools,
+    restricted: connCfg.restricted,
+    ...mergedEnvSchema.length ? { env_schema: mergedEnvSchema } : {}
+  };
+}
+function suggestedAgentVisible(reg) {
+  return reg.type === "http" || !!reg.url ? !0 : reg.runLocation !== "host";
+}
+function isRegistrationAgentVisible(reg) {
+  return reg.agentVisible ?? suggestedAgentVisible(reg);
+}
+var MCP_EXECUTABLE_IDENTITY_FIELDS = ["type", "url", "command", "args", "npmPackage", "pypiPackage"];
+function sameExecutableIdentity(a, b) {
+  let argsA = a.args ?? [], argsB = b.args ?? [];
+  return a.type === b.type && a.url === b.url && a.command === b.command && a.npmPackage === b.npmPackage && a.pypiPackage === b.pypiPackage && argsA.length === argsB.length && argsA.every((arg, i) => arg === argsB[i]);
+}
+function deriveRegistrationTestPlan(reg, opts) {
+  if (reg.type === "http" || !!reg.url) {
+    let notes2 = reg.oauth ? ["Interactive OAuth sign-in runs in a browser during this test."] : [];
+    return { location: "remote http", authMode: reg.oauth ? "run" : "none", materializeFiles: !1, notes: notes2 };
+  }
+  if (reg.runLocation === "host") {
+    if (!opts?.hostAccessEnabled) {
+      let notes2 = ["Host access is disabled app-wide \u2014 this test ran in the shared container. Enable host access in Settings \u2192 Compute to test on the host."];
+      return reg.auth && notes2.push("Authorization for containerized servers happens per-agent when an agent attaches this server."), { location: "shared container", authMode: reg.auth ? "skip" : "none", materializeFiles: !1, notes: notes2 };
+    }
+    return {
+      location: "host",
+      authMode: reg.auth ? "run" : "none",
+      materializeFiles: !0,
+      notes: []
+    };
+  }
+  let notes = [];
+  return reg.auth && notes.push("Authorization for containerized servers happens per-agent when an agent attaches this server."), reg.credentialFiles?.length && notes.push("Credential files for containerized servers are captured per-agent at attach; this test verifies the package launches and lists tools."), { location: "shared container", authMode: reg.auth ? "skip" : "none", materializeFiles: !1, notes };
+}
+function registrationSourceIdentity(reg) {
+  return reg.type === "http" || reg.url ? reg.url ? `http:${reg.url}` : "http" : reg.npmPackage ? `npm:${reg.npmPackage}` : reg.pypiPackage ? `uvx:${reg.pypiPackage}` : "custom";
+}
+function reconcileHostApprovedRegistrations(prev, next, approved, approvedSources) {
+  let result = [...approved], sources = { ...approvedSources ?? {} }, prevByName = new Map(prev.filter((r) => r.name).map((r) => [r.name, r])), nextByName = new Map(next.filter((r) => r.name).map((r) => [r.name, r])), add = (name, reg) => {
+    result.includes(name) || result.push(name), sources[name] = registrationSourceIdentity(reg);
+  }, remove = (name) => {
+    let i = result.indexOf(name);
+    i >= 0 && result.splice(i, 1), delete sources[name];
+  };
+  for (let [name, reg] of nextByName) {
+    let wasHost = prevByName.get(name)?.runLocation === "host", isHost = reg.runLocation === "host" && reg.type !== "http";
+    isHost && !wasHost ? add(name, reg) : !isHost && wasHost ? remove(name) : isHost && wasHost && result.includes(name) && (sources[name] = registrationSourceIdentity(reg));
+  }
+  for (let [name, reg] of prevByName)
+    !nextByName.has(name) && reg.runLocation === "host" && remove(name);
+  return { approved: result, sources };
+}
+
+export {
+  mcpCredentialRef,
+  isSensitiveMcpHeader,
+  buildEnvSchemaFromKeys,
+  buildHeaderEnvSchemaFromEntries,
+  buildMcpServerConfigFromRegistration,
+  pinServerConfigToRegistration,
+  isRegistrationAgentVisible,
+  mcp_config_exports
+};

package/dist/chunks/chunk-VZS54AA5.mjs

@@ -0,0 +1,200 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  setWriteTap,
+  writeTerminal
+} from "./chunk-7XYNI52E.mjs";
+
+// src/main/tui/app/selection.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function clampCell(cell, b) {
+  return { x: clamp(cell.x, b.x0, b.x1 - 1), y: clamp(cell.y, b.y0, b.y1 - 1) };
+}
+function before(a, b) {
+  return a.y < b.y || a.y === b.y && a.x <= b.x;
+}
+function selectionRows(sel) {
+  let a = clampCell(sel.anchor, sel.bounds), f = clampCell(sel.focus, sel.bounds), [start, end] = before(a, f) ? [a, f] : [f, a], rows = [];
+  for (let y = start.y; y <= end.y; y++)
+    rows.push({ y, x0: y === start.y ? start.x : sel.bounds.x0, x1: y === end.y ? end.x + 1 : sel.bounds.x1 });
+  return rows;
+}
+function rowText(screen2, y, x0, x1) {
+  let out = "";
+  for (let x = Math.max(0, x0); x < Math.min(screen2.cols, x1); x++) out += screen2.cell(x, y);
+  return out;
+}
+function selectionText(sel, screen2) {
+  let lines = selectionRows(sel).map((r) => rowText(screen2, r.y, r.x0, r.x1).replace(/\s+$/, ""));
+  for (; lines.length > 0 && lines[0] === ""; ) lines.shift();
+  for (; lines.length > 0 && lines[lines.length - 1] === ""; ) lines.pop();
+  let indents = lines.filter((l) => l.trim()).map((l) => l.length - l.trimStart().length), common = indents.length > 0 ? Math.min(...indents) : 0;
+  return lines.map((l) => l.slice(common)).join(`
+`);
+}
+var WORD = /[\p{L}\p{N}_\-./\\:@~+%#?=&]/u;
+function wordAt(screen2, at, b) {
+  let isWord = (x) => {
+    let ch = screen2.cell(x, at.y);
+    return ch === "" || WORD.test(ch);
+  }, here = screen2.cell(at.x, at.y);
+  if (!WORD.test(here) && here !== "") return { anchor: at, focus: at, bounds: b };
+  let x0 = at.x, x1 = at.x;
+  for (; x0 > b.x0 && isWord(x0 - 1); ) x0--;
+  for (; x1 < b.x1 - 1 && isWord(x1 + 1); ) x1++;
+  for (; x1 > x0 && /[.:,?]/.test(screen2.cell(x1, at.y)); ) x1--;
+  return { anchor: { x: x0, y: at.y }, focus: { x: x1, y: at.y }, bounds: b };
+}
+function lineAt(at, b) {
+  return { anchor: { x: b.x0, y: at.y }, focus: { x: b.x1 - 1, y: at.y }, bounds: b };
+}
+var MULTI_CLICK_MS = 450;
+function createMouseController(deps) {
+  let press = null, last = null, current = null, show = (sel) => {
+    !sel && !current || (current = sel, deps.highlight(sel));
+  };
+  return {
+    selection: () => current,
+    clear: () => show(null),
+    handle(event) {
+      if (event.kind === "press" && event.button === 2) {
+        show(null), deps.rightClick(event);
+        return;
+      }
+      if (event.kind === "press" && event.button === 0) {
+        if (show(null), press = null, deps.pressHandled(event)) {
+          last = null;
+          return;
+        }
+        let now = deps.now(), count = last && last.x === event.x && last.y === event.y && now - last.at <= MULTI_CLICK_MS ? Math.min(3, last.count + 1) : 1;
+        last = { x: event.x, y: event.y, at: now, count };
+        let bounds = deps.paneAt(event.x, event.y);
+        press = { event, bounds, count, dragging: !1 };
+        let screen2 = deps.screen();
+        count === 2 && screen2 ? show(wordAt(screen2, event, bounds)) : count === 3 && show(lineAt(event, bounds));
+        return;
+      }
+      if (press) {
+        if (event.kind === "drag") {
+          let focus = clampCell(event, press.bounds);
+          if (!press.dragging && focus.x === press.event.x && focus.y === press.event.y) return;
+          press.dragging = !0, last = null, show({ anchor: clampCell(press.event, press.bounds), focus, bounds: press.bounds });
+          return;
+        }
+        if (event.kind === "release") {
+          let done = press;
+          if (press = null, done.dragging || done.count > 1) {
+            let screen2 = deps.screen(), text = current && screen2 ? selectionText(current, screen2) : "";
+            text && deps.copy(text);
+            return;
+          }
+          deps.click(done.event);
+        }
+      }
+    }
+  };
+}
+
+// src/main/tui/app/screen.ts
+var screen = null, highlight = null, repaint = null, painted = !1, paintQueued = !1;
+function getScreenText() {
+  return screen;
+}
+function setScreenText(next) {
+  screen = next;
+}
+function setRepaint(fn) {
+  repaint = fn;
+}
+function currentHighlight() {
+  return highlight;
+}
+var SAVE = "\x1B7", RESTORE = "\x1B8";
+function highlightSequence(sel, text) {
+  let seq = "";
+  for (let row of selectionRows(sel)) {
+    let cells = "";
+    for (let x = row.x0; x < row.x1 && x < text.cols; x++) cells += text.cell(x, row.y);
+    cells && (seq += `\x1B[${row.y + 1};${row.x0 + 1}H\x1B[7m${cells}\x1B[27m`);
+  }
+  return seq ? `${SAVE}${seq}\x1B[0m${RESTORE}` : "";
+}
+function cellsUnder(sel, text) {
+  return selectionRows(sel).map((row) => {
+    let cells = "";
+    for (let x = row.x0; x < row.x1 && x < text.cols; x++) cells += text.cell(x, row.y);
+    return cells;
+  }).join(`
+`);
+}
+var snapshot = "";
+function paint() {
+  if (paintQueued = !1, !highlight || !screen) return;
+  if (cellsUnder(highlight, screen) !== snapshot) {
+    setHighlight(null);
+    return;
+  }
+  let seq = highlightSequence(highlight, screen);
+  seq && writeTerminal(seq) && (painted = !0);
+}
+function setHighlight(sel) {
+  if (highlight = sel, sel) {
+    snapshot = screen ? cellsUnder(sel, screen) : "", paint();
+    return;
+  }
+  painted && (painted = !1, repaint?.());
+}
+function queuePaint() {
+  !highlight || paintQueued || (paintQueued = !0, setImmediate(paint));
+}
+var MirrorScreen = class {
+  constructor(term) {
+    this.term = term;
+  }
+  term;
+  get cols() {
+    return this.term.cols;
+  }
+  get rows() {
+    return this.term.rows;
+  }
+  cell(x, y) {
+    let buffer = this.term.buffer.active, cell = buffer.getLine(buffer.viewportY + y)?.getCell(x);
+    return cell ? cell.getWidth() === 0 ? "" : cell.getChars() || " " : " ";
+  }
+};
+async function installScreenMirror(stdout) {
+  let mod = await import("./xterm-headless-YF53XWXE.mjs"), Terminal = mod.Terminal ?? mod.default?.Terminal;
+  if (!Terminal) return () => {
+  };
+  let term = new Terminal({ cols: stdout.columns || 80, rows: stdout.rows || 24, scrollback: 0, allowProposedApi: !0, logLevel: "off" });
+  screen = new MirrorScreen(term);
+  let onResize = () => {
+    try {
+      term.resize(stdout.columns || 80, stdout.rows || 24);
+    } catch {
+    }
+  };
+  return stdout.on("resize", onResize), setWriteTap((data) => {
+    term.write(data, queuePaint);
+  }), () => {
+    setWriteTap(null), stdout.off("resize", onResize), screen = null, highlight = null, painted = !1, term.dispose();
+  };
+}
+
+export {
+  createMouseController,
+  getScreenText,
+  setScreenText,
+  setRepaint,
+  currentHighlight,
+  highlightSequence,
+  setHighlight,
+  installScreenMirror
+};