@linghun/tui 0.1.0

package/dist/chunk-4EP3TUFF.js

@@ -0,0 +1,238 @@
+// src/remote-repl-bridge-runtime.ts
+import { createHash, randomUUID } from "crypto";
+import { rm } from "fs/promises";
+import { createServer } from "net";
+import { tmpdir } from "os";
+import { join } from "path";
+var BoundedUUIDSet = class {
+  constructor(limit = 50) {
+    this.limit = limit;
+  }
+  limit;
+  order = [];
+  values = /* @__PURE__ */ new Set();
+  add(value) {
+    if (!value) return false;
+    if (this.values.has(value)) return false;
+    this.values.add(value);
+    this.order.unshift(value);
+    while (this.order.length > this.limit) {
+      const dropped = this.order.pop();
+      if (dropped) this.values.delete(dropped);
+    }
+    return true;
+  }
+  has(value) {
+    return this.values.has(value);
+  }
+  snapshot() {
+    return [...this.order];
+  }
+};
+var FlushGate = class {
+  open = true;
+  queued = 0;
+  begin() {
+    if (!this.open) {
+      this.queued += 1;
+      return false;
+    }
+    this.open = false;
+    return true;
+  }
+  end() {
+    this.open = true;
+    this.queued = 0;
+  }
+  status() {
+    return { open: this.open, queued: this.queued };
+  }
+};
+function createRemoteDedupState(limit = 50) {
+  return {
+    recentPostedUUIDs: new BoundedUUIDSet(limit),
+    initialMessageUUIDs: new BoundedUUIDSet(limit),
+    recentInboundUUIDs: new BoundedUUIDSet(limit),
+    flushGate: new FlushGate()
+  };
+}
+function createReplBridgeState(limit = 50) {
+  return { clients: [], dedup: createRemoteDedupState(limit) };
+}
+function createDefaultReplBridgeSocketPath(projectPath) {
+  const suffix = createHash("sha256").update(projectPath).digest("hex").slice(0, 12);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\linghun-repl-${suffix}`;
+  }
+  return join(tmpdir(), `linghun-repl-${suffix}.sock`);
+}
+async function startReplBridgeSocketServer(input) {
+  if (process.platform !== "win32") {
+    await rm(input.socketPath, { force: true }).catch(() => void 0);
+  }
+  const server = createServer((socket) => attachReplBridgeSocket(socket, input.bridge, input.remote));
+  await listen(server, input.socketPath);
+  return {
+    socketPath: input.socketPath,
+    close: async () => {
+      await closeServer(server);
+      if (process.platform !== "win32") {
+        await rm(input.socketPath, { force: true }).catch(() => void 0);
+      }
+    }
+  };
+}
+async function maybeRefreshJwtToken(input) {
+  if (!input.token || !input.expiresAt) {
+    return { refreshed: false, reason: "jwt metadata unavailable" };
+  }
+  const expiresAtMs = Date.parse(input.expiresAt);
+  if (!Number.isFinite(expiresAtMs)) {
+    return { refreshed: false, reason: "jwt expiresAt invalid" };
+  }
+  const refreshBeforeMs = input.refreshBeforeMs ?? 5 * 60 * 1e3;
+  const nowMs = input.nowMs ?? Date.now();
+  if (expiresAtMs - nowMs > refreshBeforeMs) {
+    return { refreshed: false, reason: "jwt still fresh" };
+  }
+  const next = await input.refresh();
+  return { refreshed: true, token: next.token, expiresAt: next.expiresAt };
+}
+function handleReplBridgeMessage(bridge, remote, message) {
+  if (!bridge.dedup.flushGate.begin()) {
+    return { status: "blocked", clientId: message.clientId, reason: "flush in progress" };
+  }
+  try {
+    return handleReplBridgeMessageInner(bridge, remote, message);
+  } finally {
+    bridge.dedup.flushGate.end();
+  }
+}
+function attachReplBridgeSocket(socket, bridge, remote) {
+  socket.setEncoding("utf8");
+  let buffer = "";
+  socket.on("data", (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split(/\r?\n/u);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      socket.write(`${JSON.stringify(handleSocketLine(trimmed, bridge, remote))}
+`);
+    }
+  });
+}
+function handleSocketLine(line, bridge, remote) {
+  try {
+    return handleReplBridgeMessage(bridge(), remote(), JSON.parse(line));
+  } catch {
+    return { status: "blocked", clientId: "unknown", reason: "invalid JSON bridge message" };
+  }
+}
+function listen(server, socketPath) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(socketPath);
+  });
+}
+function closeServer(server) {
+  return new Promise((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+function handleReplBridgeMessageInner(bridge, remote, message) {
+  if (message.type === "register") {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = findClient(bridge, message.clientId);
+    const client2 = existing ?? {
+      clientId: message.clientId,
+      registeredAt: now,
+      heartbeatAt: now,
+      active: true,
+      queue: []
+    };
+    client2.active = true;
+    client2.heartbeatAt = now;
+    if (!existing) bridge.clients.unshift(client2);
+    for (const id of message.initialMessageIds ?? []) {
+      bridge.dedup.initialMessageUUIDs.add(id);
+    }
+    return { status: "registered", clientId: message.clientId, queued: client2.queue.length };
+  }
+  const client = findClient(bridge, message.clientId);
+  if (message.type === "deregister") {
+    bridge.clients = bridge.clients.filter((item) => item.clientId !== message.clientId);
+    return { status: "deregistered", clientId: message.clientId };
+  }
+  if (!client || !client.active) {
+    return { status: "blocked", clientId: message.clientId, reason: "client not registered" };
+  }
+  if (message.type === "poll") {
+    const messages = [...client.queue];
+    return { status: "polled", clientId: message.clientId, messages };
+  }
+  if (message.type === "acknowledge") {
+    client.queue = client.queue.filter((item) => item.messageId !== message.messageId);
+    bridge.dedup.recentPostedUUIDs.add(message.messageId);
+    return { status: "acknowledged", clientId: message.clientId, messageId: message.messageId };
+  }
+  if (message.type === "heartbeat") {
+    client.heartbeatAt = message.now;
+    return { status: "heartbeat", clientId: message.clientId, now: message.now };
+  }
+  if (message.type === "stop") {
+    client.active = false;
+    return { status: "stopped", clientId: message.clientId, reason: message.reason ?? "stopped" };
+  }
+  const messageId = message.messageId ?? createLocalMessageId(message.clientId, message.text);
+  if (bridge.dedup.initialMessageUUIDs.has(messageId) || bridge.dedup.recentInboundUUIDs.has(messageId) || remote.processedMessageIds.includes(messageId)) {
+    return { status: "duplicate", clientId: message.clientId, messageId };
+  }
+  bridge.dedup.recentInboundUUIDs.add(messageId);
+  const inbound = {
+    kind: "natural_language_message",
+    channel: "local-repl",
+    messageId,
+    nonce: createHash("sha256").update(messageId).digest("hex").slice(0, 16),
+    source: "local-repl",
+    bindingUserId: message.clientId,
+    expiresAt: new Date(Date.parse(message.now ?? (/* @__PURE__ */ new Date()).toISOString()) + 6e4).toISOString(),
+    receivedAt: message.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    origin: "adapter",
+    text: message.text.trim()
+  };
+  client.queue.unshift(inbound);
+  client.queue = client.queue.slice(0, 20);
+  return { status: "accepted", clientId: message.clientId, message: inbound };
+}
+function findClient(bridge, clientId) {
+  return bridge.clients.find((client) => client.clientId === clientId);
+}
+function createLocalMessageId(clientId, text) {
+  if (!text.trim()) return `local-repl-${randomUUID().slice(0, 8)}`;
+  return `local-repl-${createHash("sha256").update(`${clientId}:${text}`).digest("hex").slice(0, 12)}`;
+}
+
+export {
+  BoundedUUIDSet,
+  FlushGate,
+  createRemoteDedupState,
+  createReplBridgeState,
+  createDefaultReplBridgeSocketPath,
+  startReplBridgeSocketServer,
+  maybeRefreshJwtToken,
+  handleReplBridgeMessage
+};

package/dist/chunk-4I2NWBOM.js

@@ -0,0 +1,117 @@
+// src/shell/output-utils.ts
+var MAX_LINES_TO_SHOW = 3;
+var PADDING_TO_PREVENT_OVERFLOW = 10;
+function getVisibleWidth(text) {
+  const withoutAnsi = text.replace(/\x1b\[[0-9;]*m/g, "");
+  return withoutAnsi.length;
+}
+function sliceAnsi(text, start, end) {
+  let visiblePos = 0;
+  let result = "";
+  let inEscape = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (char === "\x1B" && text[i + 1] === "[") {
+      inEscape = true;
+      result += char;
+      continue;
+    }
+    if (inEscape) {
+      result += char;
+      if (char === "m") {
+        inEscape = false;
+      }
+      continue;
+    }
+    if (visiblePos >= start && visiblePos < end) {
+      result += char;
+    }
+    visiblePos++;
+    if (visiblePos >= end) {
+      break;
+    }
+  }
+  return result;
+}
+function wrapText(text, wrapWidth) {
+  const lines = text.split("\n");
+  const wrappedLines = [];
+  for (const line of lines) {
+    const visibleWidth = getVisibleWidth(line);
+    if (visibleWidth <= wrapWidth) {
+      wrappedLines.push(line.trimEnd());
+    } else {
+      let position = 0;
+      while (position < visibleWidth) {
+        const chunk = sliceAnsi(line, position, position + wrapWidth);
+        wrappedLines.push(chunk.trimEnd());
+        position += wrapWidth;
+      }
+    }
+  }
+  const remainingLines = wrappedLines.length - MAX_LINES_TO_SHOW;
+  if (remainingLines === 1) {
+    return {
+      aboveTheFold: wrappedLines.slice(0, MAX_LINES_TO_SHOW + 1).join("\n").trimEnd(),
+      remainingLines: 0
+    };
+  }
+  return {
+    aboveTheFold: wrappedLines.slice(0, MAX_LINES_TO_SHOW).join("\n").trimEnd(),
+    remainingLines: Math.max(0, remainingLines)
+  };
+}
+function renderTruncatedContent(content, terminalWidth, language = "zh-CN") {
+  const trimmedContent = content.trimEnd();
+  if (!trimmedContent) {
+    return "";
+  }
+  const wrapWidth = Math.max(terminalWidth - PADDING_TO_PREVENT_OVERFLOW, 10);
+  const maxChars = MAX_LINES_TO_SHOW * wrapWidth * 4;
+  const preTruncated = trimmedContent.length > maxChars;
+  const contentForWrapping = preTruncated ? trimmedContent.slice(0, maxChars) : trimmedContent;
+  const { aboveTheFold, remainingLines } = wrapText(contentForWrapping, wrapWidth);
+  const estimatedRemaining = preTruncated ? Math.max(
+    remainingLines,
+    Math.ceil(trimmedContent.length / wrapWidth) - MAX_LINES_TO_SHOW
+  ) : remainingLines;
+  if (estimatedRemaining > 0) {
+    const expandHint = language === "zh-CN" ? "\uFF08\u6309 Ctrl+O \u5C55\u5F00\uFF09" : "(ctrl+o to expand)";
+    return `${aboveTheFold}
+\u2026 +${estimatedRemaining} ${language === "zh-CN" ? "\u884C" : "lines"} ${expandHint}`;
+  }
+  return aboveTheFold;
+}
+function tryFormatJsonLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    const formatted = JSON.stringify(parsed, null, 2);
+    return formatted;
+  } catch {
+    return line;
+  }
+}
+function tryJsonFormatContent(content) {
+  const MAX_JSON_FORMAT_LENGTH = 1e4;
+  if (content.length > MAX_JSON_FORMAT_LENGTH) {
+    return content;
+  }
+  const lines = content.split("\n");
+  return lines.map(tryFormatJsonLine).join("\n");
+}
+function isContentTruncated(content) {
+  let pos = 0;
+  for (let i = 0; i <= MAX_LINES_TO_SHOW; i++) {
+    pos = content.indexOf("\n", pos);
+    if (pos === -1) return false;
+    pos++;
+  }
+  return pos < content.length;
+}
+
+export {
+  renderTruncatedContent,
+  tryFormatJsonLine,
+  tryJsonFormatContent,
+  isContentTruncated
+};