spectrum-ts 1.4.0 → 1.5.0

package/dist/providers/terminal/index.js

@@ -1,842 +1,8 @@
 import {
-  asVoice
-} from "../../chunk-B4MHPWPZ.js";
-import {
-  UnsupportedError,
-  asAttachment,
-  asContact,
-  asCustom,
-  definePlatform,
-  fromVCard,
-  reactionSchema,
-  toVCard
-} from "../../chunk-LH4YEBG3.js";
-
-// src/providers/terminal/index.ts
-import { spawn } from "child_process";
-import { createServer } from "net";
-import { inspect } from "util";
-import z from "zod";
-
-// src/providers/terminal/protocol.ts
-var HEADER_TERMINATOR = Buffer.from("\r\n\r\n");
-var CONTENT_LENGTH = "content-length:";
-function encode(message) {
-  const body = Buffer.from(JSON.stringify(message), "utf8");
-  const header = Buffer.from(`Content-Length: ${body.byteLength}\r
-\r
-`);
-  const out = new Uint8Array(header.byteLength + body.byteLength);
-  out.set(header, 0);
-  out.set(body, header.byteLength);
-  return out;
-}
-var Decoder = class {
-  buf = Buffer.alloc(0);
-  push(chunk) {
-    this.buf = this.buf.length === 0 ? Buffer.from(chunk) : Buffer.concat([this.buf, chunk]);
-    const out = [];
-    for (; ; ) {
-      const msg = this.readOne();
-      if (!msg) {
-        break;
-      }
-      out.push(msg);
-    }
-    return out;
-  }
-  readOne() {
-    const end = this.buf.indexOf(HEADER_TERMINATOR);
-    if (end < 0) {
-      return null;
-    }
-    const header = this.buf.subarray(0, end).toString("utf8");
-    let len = -1;
-    for (const line of header.split("\r\n")) {
-      if (line.toLowerCase().startsWith(CONTENT_LENGTH)) {
-        const n = Number.parseInt(line.slice(CONTENT_LENGTH.length).trim(), 10);
-        if (!Number.isFinite(n) || n < 0) {
-          throw new Error("invalid Content-Length");
-        }
-        len = n;
-      }
-    }
-    if (len < 0) {
-      throw new Error("missing Content-Length header");
-    }
-    const bodyStart = end + HEADER_TERMINATOR.length;
-    const bodyEnd = bodyStart + len;
-    if (this.buf.length < bodyEnd) {
-      return null;
-    }
-    const body = this.buf.subarray(bodyStart, bodyEnd).toString("utf8");
-    this.buf = this.buf.subarray(bodyEnd);
-    return JSON.parse(body);
-  }
-};
-var RpcSession = class {
-  decoder = new Decoder();
-  nextId = 1;
-  pending = /* @__PURE__ */ new Map();
-  onNotify = null;
-  onClose = null;
-  closed = false;
-  socket;
-  constructor(socket) {
-    this.socket = socket;
-    socket.on("data", (chunk) => this.handle(chunk));
-    socket.on("close", () => this.shutdown());
-    socket.on("error", () => this.shutdown());
-  }
-  handleNotifications(h) {
-    this.onNotify = h;
-  }
-  onClosed(h) {
-    this.onClose = h;
-  }
-  async request(method, params, timeoutMs) {
-    if (this.closed) {
-      throw new Error("session closed");
-    }
-    const id = this.nextId++;
-    const msg = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      let timer;
-      const done = () => {
-        settled = true;
-        if (timer) {
-          clearTimeout(timer);
-        }
-      };
-      this.pending.set(id, {
-        resolve: (v) => {
-          if (settled) {
-            return;
-          }
-          done();
-          resolve(v);
-        },
-        reject: (e) => {
-          if (settled) {
-            return;
-          }
-          done();
-          reject(e);
-        }
-      });
-      if (timeoutMs !== void 0 && timeoutMs >= 0) {
-        timer = setTimeout(() => {
-          if (settled) {
-            return;
-          }
-          settled = true;
-          this.pending.delete(id);
-          reject(new Error(`rpc ${method} timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-        timer.unref?.();
-      }
-      try {
-        this.socket.write(encode(msg));
-      } catch (err) {
-        if (settled) {
-          return;
-        }
-        done();
-        this.pending.delete(id);
-        reject(err);
-      }
-    });
-  }
-  notify(method, params) {
-    if (this.closed) {
-      return;
-    }
-    const msg = { jsonrpc: "2.0", method, params };
-    try {
-      this.socket.write(encode(msg));
-    } catch {
-    }
-  }
-  close() {
-    this.shutdown();
-  }
-  handle(chunk) {
-    let msgs;
-    try {
-      msgs = this.decoder.push(chunk);
-    } catch {
-      this.shutdown();
-      return;
-    }
-    for (const m of msgs) {
-      if ("id" in m && "method" in m) {
-        continue;
-      }
-      if ("id" in m) {
-        const p = this.pending.get(m.id);
-        if (!p) {
-          continue;
-        }
-        this.pending.delete(m.id);
-        if (m.error) {
-          p.reject(new Error(m.error.message));
-        } else {
-          p.resolve(m.result);
-        }
-      } else if ("method" in m) {
-        try {
-          this.onNotify?.(m.method, m.params);
-        } catch {
-        }
-      }
-    }
-  }
-  shutdown() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    for (const p of this.pending.values()) {
-      p.reject(new Error("session closed"));
-    }
-    this.pending.clear();
-    try {
-      this.socket.end();
-    } catch {
-    }
-    try {
-      this.socket.destroy();
-    } catch {
-    }
-    this.onClose?.();
-  }
-};
-
-// src/providers/terminal/resolve-binary.ts
-import { createHash, randomBytes } from "crypto";
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var DEFAULT_VERSION = "0.1.4";
-var REPO = "photon-hq/tuichat";
-var VERSION_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
-var DOWNLOAD_TIMEOUT_MS = 3e4;
-function targetSuffix() {
-  const key = `${process.platform}-${process.arch}`;
-  const map = {
-    "darwin-arm64": "darwin-arm64",
-    "darwin-x64": "darwin-x64",
-    "linux-x64": "linux-x64",
-    "linux-arm64": "linux-arm64",
-    "win32-x64": "windows-x64"
-  };
-  const t = map[key];
-  if (!t) {
-    throw new Error(`tuichat: unsupported platform/arch: ${key}`);
-  }
-  return t;
-}
-function cacheDir(version) {
-  if (process.platform === "win32") {
-    const base = process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local");
-    return join(base, "tuichat", `v${version}`);
-  }
-  if (process.platform === "darwin") {
-    return join(homedir(), "Library", "Caches", "tuichat", `v${version}`);
-  }
-  const xdg = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
-  return join(xdg, "tuichat", `v${version}`);
-}
-var LINE_SPLIT = /\r?\n/;
-var CHECKSUM_LINE = /^([a-f0-9]{64})\s+\*?(\S+)$/;
-function parseChecksums(text) {
-  const out = {};
-  for (const line of text.split(LINE_SPLIT)) {
-    const m = line.match(CHECKSUM_LINE);
-    if (m?.[1] && m[2]) {
-      out[m[2]] = m[1];
-    }
-  }
-  return out;
-}
-async function downloadVerified(version, filename) {
-  const base = `https://github.com/${REPO}/releases/download/v${version}`;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
-  let sumsRes;
-  let binRes;
-  try {
-    [sumsRes, binRes] = await Promise.all([
-      fetch(`${base}/SHA256SUMS`, { signal: controller.signal }),
-      fetch(`${base}/${filename}`, { signal: controller.signal })
-    ]);
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortError") {
-      throw new Error(
-        `tuichat: timed out fetching v${version} release assets after ${DOWNLOAD_TIMEOUT_MS}ms`
-      );
-    }
-    throw err;
-  } finally {
-    clearTimeout(timer);
-  }
-  if (!sumsRes.ok) {
-    throw new Error(
-      `tuichat: failed to fetch SHA256SUMS (v${version}): HTTP ${sumsRes.status}`
-    );
-  }
-  if (!binRes.ok) {
-    throw new Error(
-      `tuichat: failed to fetch ${filename} (v${version}): HTTP ${binRes.status}`
-    );
-  }
-  const expected = parseChecksums(await sumsRes.text())[filename];
-  if (!expected) {
-    throw new Error(
-      `tuichat: no checksum for ${filename} in SHA256SUMS (v${version})`
-    );
-  }
-  const bytes = Buffer.from(await binRes.arrayBuffer());
-  const actual = createHash("sha256").update(bytes).digest("hex");
-  if (actual !== expected) {
-    throw new Error(
-      `tuichat: checksum mismatch for ${filename} (expected ${expected}, got ${actual})`
-    );
-  }
-  return bytes;
-}
-function writeBinary(path, bytes) {
-  const tmpPath = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-  try {
-    writeFileSync(tmpPath, bytes);
-    if (process.platform !== "win32") {
-      chmodSync(tmpPath, 493);
-    }
-    renameSync(tmpPath, path);
-  } catch (err) {
-    const renameErr = err;
-    try {
-      unlinkSync(tmpPath);
-    } catch {
-    }
-    if (process.platform === "win32" && renameErr.code === "EEXIST" && existsSync(path)) {
-      return;
-    }
-    throw err;
-  }
-}
-async function resolveTuichatBinary(options = {}) {
-  const override = process.env.TUICHAT_BINARY;
-  if (override) {
-    if (!existsSync(override)) {
-      throw new Error(`tuichat: TUICHAT_BINARY=${override} does not exist`);
-    }
-    return override;
-  }
-  const version = options.version ?? process.env.TUICHAT_VERSION ?? DEFAULT_VERSION;
-  if (!VERSION_RE.test(version)) {
-    throw new Error(
-      `tuichat: invalid version "${version}" \u2014 expected semver like 0.1.4`
-    );
-  }
-  const target = targetSuffix();
-  const ext = target.startsWith("windows") ? ".exe" : "";
-  const filename = `tuichat-${target}${ext}`;
-  const dir = cacheDir(version);
-  const path = join(dir, filename);
-  if (!options.force && existsSync(path)) {
-    return path;
-  }
-  const bytes = await downloadVerified(version, filename);
-  mkdirSync(dir, { recursive: true });
-  writeBinary(path, bytes);
-  return path;
-}
-
-// src/providers/terminal/index.ts
-var SHUTDOWN_TIMEOUT_MS = 2e3;
-var SPAWN_CONNECT_TIMEOUT_MS = 1e4;
-var INITIALIZE_TIMEOUT_MS = 1e4;
-var commandSchema = z.object({
-  name: z.string().regex(/^\/[A-Za-z0-9_-]+$/, "command must start with /"),
-  description: z.string().optional()
-});
-var LOG_LEVELS = ["log", "info", "warn", "error", "debug"];
-function installConsoleHijack(session) {
-  const originals = {};
-  let forwarding = false;
-  for (const level of LOG_LEVELS) {
-    originals[level] = console[level].bind(console);
-    console[level] = (...args) => {
-      if (forwarding) {
-        originals[level](...args);
-        return;
-      }
-      forwarding = true;
-      try {
-        const text = args.map(
-          (a) => typeof a === "string" ? a : inspect(a, { depth: 3, colors: false })
-        ).join(" ");
-        session.notify("log", { level, text });
-      } finally {
-        forwarding = false;
-      }
-    };
-  }
-  return {
-    restore: () => {
-      for (const level of LOG_LEVELS) {
-        console[level] = originals[level];
-      }
-    }
-  };
-}
-function generateChatId(client) {
-  while (client.knownChats.has(`chat-${client.nextChatIndex}`)) {
-    client.nextChatIndex += 1;
-  }
-  const id = `chat-${client.nextChatIndex}`;
-  client.nextChatIndex += 1;
-  client.knownChats.add(id);
-  return id;
-}
-function makeEventQueue() {
-  const queue = [];
-  const waiters = [];
-  let closed = false;
-  const drain = () => {
-    while (waiters.length > 0) {
-      waiters.shift()?.({ value: void 0, done: true });
-    }
-  };
-  const iter = {
-    [Symbol.asyncIterator]() {
-      return {
-        next() {
-          if (closed && queue.length === 0) {
-            return Promise.resolve({ value: void 0, done: true });
-          }
-          const buffered = queue.shift();
-          if (buffered !== void 0) {
-            return Promise.resolve({ value: buffered, done: false });
-          }
-          return new Promise((resolve) => waiters.push(resolve));
-        },
-        // return() fires when the consumer's for-await-of loop breaks or
-        // when Spectrum.stop() calls iterator.return() upstream. Without
-        // this, a pending next() would hang forever because no further
-        // push/close is coming. Close + drain so shutdown is always prompt.
-        return() {
-          closed = true;
-          drain();
-          return Promise.resolve({ value: void 0, done: true });
-        }
-      };
-    }
-  };
-  return {
-    iter,
-    push(v) {
-      if (closed) {
-        return;
-      }
-      const w = waiters.shift();
-      if (w) {
-        w({ value: v, done: false });
-      } else {
-        queue.push(v);
-      }
-    },
-    close() {
-      closed = true;
-      drain();
-    }
-  };
-}
-async function spawnClient(options) {
-  const binary = await resolveTuichatBinary();
-  const server = createServer();
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen({ host: "127.0.0.1", port: 0 }, () => {
-      server.off("error", reject);
-      resolve();
-    });
-  });
-  const addr = server.address();
-  if (!addr || typeof addr === "string") {
-    server.close();
-    throw new Error("tuichat: failed to bind adapter listener");
-  }
-  const host = "127.0.0.1";
-  const port = addr.port;
-  const proc = spawn(binary, ["--connect", `${host}:${port}`], {
-    stdio: "inherit"
-  });
-  proc.unref();
-  proc.once("exit", (code) => {
-    if (code !== 0 && code !== null) {
-      process.stderr.write(`[tuichat] subprocess exited with code ${code}
-`);
-    }
-  });
-  const socket = await new Promise((resolve, reject) => {
-    let settled = false;
-    const cleanup = () => {
-      clearTimeout(timer);
-      server.off("connection", onConnect);
-      server.off("error", onServerError);
-      proc.off("error", onProcError);
-      proc.off("exit", onProcExit);
-    };
-    const fail = (err, killProc) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      server.close();
-      if (killProc && !proc.killed) {
-        try {
-          proc.kill();
-        } catch {
-        }
-      }
-      reject(err);
-    };
-    const succeed = (sock) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      server.close();
-      resolve(sock);
-    };
-    const onConnect = (sock) => succeed(sock);
-    const onServerError = (err) => fail(err, true);
-    const onProcError = (err) => fail(err, false);
-    const onProcExit = (code, signal) => fail(
-      new Error(
-        `tuichat: subprocess exited before connecting (code=${code ?? "null"}, signal=${signal ?? "null"})`
-      ),
-      false
-    );
-    const timer = setTimeout(() => {
-      fail(
-        new Error(
-          `tuichat: subprocess did not connect within ${SPAWN_CONNECT_TIMEOUT_MS}ms`
-        ),
-        true
-      );
-    }, SPAWN_CONNECT_TIMEOUT_MS);
-    server.once("connection", onConnect);
-    server.once("error", onServerError);
-    proc.once("error", onProcError);
-    proc.once("exit", onProcExit);
-  });
-  const session = new RpcSession(socket);
-  const eventsQ = makeEventQueue();
-  session.handleNotifications((method, params) => {
-    if (method === "streamEnd") {
-      eventsQ.close();
-      return;
-    }
-    if (method === "message") {
-      eventsQ.push({
-        kind: "message",
-        value: params
-      });
-      return;
-    }
-    if (method === "reaction") {
-      eventsQ.push({
-        kind: "reaction",
-        value: params
-      });
-      return;
-    }
-  });
-  let hijack;
-  session.onClosed(() => {
-    hijack?.restore();
-    eventsQ.close();
-  });
-  try {
-    await session.request(
-      "initialize",
-      {
-        commands: options.commands,
-        clientInfo: { name: "spectrum-ts", version: "terminal-provider" }
-      },
-      INITIALIZE_TIMEOUT_MS
-    );
-  } catch (err) {
-    session.close();
-    try {
-      proc.kill("SIGTERM");
-    } catch {
-    }
-    throw err;
-  }
-  hijack = installConsoleHijack(session);
-  return {
-    hijack,
-    proc,
-    session,
-    events: eventsQ.iter,
-    knownChats: /* @__PURE__ */ new Set(),
-    nextChatIndex: 1
-  };
-}
-function parseTimestamp(s) {
-  const t = Date.parse(s);
-  return Number.isNaN(t) ? /* @__PURE__ */ new Date() : new Date(t);
-}
-function buildOutboundRecord(result, content, spaceId) {
-  return {
-    id: result.id,
-    content,
-    space: { id: spaceId },
-    timestamp: parseTimestamp(result.timestamp)
-  };
-}
-function reactionTargetFromProtocol(reaction) {
-  const target = {
-    id: reaction.messageId,
-    content: asCustom({ terminal_type: "reaction-target", stub: true }),
-    sender: { id: "__unknown__" },
-    space: { id: reaction.spaceId },
-    timestamp: parseTimestamp(reaction.timestamp)
-  };
-  return target;
-}
-function reactionContentFromProtocol(reaction) {
-  return reactionSchema.parse({
-    type: "reaction",
-    emoji: reaction.reaction,
-    target: reactionTargetFromProtocol(reaction)
-  });
-}
-async function spectrumToProtocol(content) {
-  if (content.type === "text" || content.type === "custom") {
-    return content;
-  }
-  if (content.type === "attachment") {
-    const buf = await content.read();
-    return {
-      type: "attachment",
-      name: content.name,
-      mimeType: content.mimeType,
-      size: content.size,
-      bytes: buf.toString("base64")
-    };
-  }
-  if (content.type === "voice") {
-    const buf = await content.read();
-    return {
-      type: "voice",
-      name: content.name,
-      mimeType: content.mimeType,
-      size: content.size,
-      bytes: buf.toString("base64")
-    };
-  }
-  if (content.type === "contact") {
-    return {
-      type: "contact",
-      name: content.name ? {
-        formatted: content.name.formatted,
-        first: content.name.first,
-        last: content.name.last
-      } : void 0,
-      vcard: await toVCard(content)
-    };
-  }
-  throw UnsupportedError.content(
-    content.type,
-    "terminal"
-  );
-}
-function protocolToSpectrum(p) {
-  if (p.type === "text" || p.type === "custom") {
-    return p;
-  }
-  if (p.type === "attachment" || p.type === "voice") {
-    const path = p.path;
-    const bytesB64 = p.bytes;
-    let cached;
-    const readBytes = () => {
-      if (cached) {
-        return cached;
-      }
-      if (bytesB64) {
-        cached = Promise.resolve(Buffer.from(bytesB64, "base64"));
-      } else if (path) {
-        cached = import("fs/promises").then((m) => m.readFile(path));
-      } else {
-        cached = Promise.reject(
-          new Error(`${p.type} has neither path nor bytes`)
-        );
-      }
-      return cached;
-    };
-    const stream = async () => {
-      if (path) {
-        const [{ createReadStream }, { Readable }] = await Promise.all([
-          import("fs"),
-          import("stream")
-        ]);
-        return Readable.toWeb(
-          createReadStream(path)
-        );
-      }
-      const buf = await readBytes();
-      return new ReadableStream({
-        start(ctrl) {
-          ctrl.enqueue(new Uint8Array(buf));
-          ctrl.close();
-        }
-      });
-    };
-    if (p.type === "attachment") {
-      return asAttachment({
-        name: p.name,
-        mimeType: p.mimeType,
-        size: p.size,
-        read: readBytes,
-        stream
-      });
-    }
-    return asVoice({
-      name: p.name,
-      mimeType: p.mimeType,
-      size: p.size,
-      read: readBytes,
-      stream
-    });
-  }
-  if (p.type === "contact") {
-    if (p.vcard) {
-      try {
-        return asContact(fromVCard(p.vcard));
-      } catch {
-      }
-    }
-    return asContact({ name: p.name });
-  }
-  return { type: "custom", raw: p };
-}
-var terminal = definePlatform("terminal", {
-  config: z.object({
-    commands: z.array(commandSchema).optional()
-  }),
-  // Declaring a message schema is how extras survive Spectrum's buildMessage
-  // filter — without it, unknown fields on the yielded message are stripped.
-  message: {
-    schema: z.object({
-      replyTo: z.object({ messageId: z.string() }).optional()
-    })
-  },
-  lifecycle: {
-    createClient: async ({ config }) => {
-      return await spawnClient({ commands: config.commands });
-    },
-    destroyClient: async ({ client }) => {
-      client.hijack.restore();
-      try {
-        await client.session.request(
-          "shutdown",
-          void 0,
-          SHUTDOWN_TIMEOUT_MS
-        );
-      } catch {
-      }
-      client.session.close();
-      try {
-        client.proc.kill("SIGTERM");
-      } catch {
-      }
-    }
-  },
-  user: {
-    resolve: async ({ input }) => ({
-      id: input.userID
-    })
-  },
-  space: {
-    params: z.object({ id: z.string().optional() }),
-    resolve: async ({ client, input }) => {
-      const id = input.params?.id ?? generateChatId(client);
-      client.knownChats.add(id);
-      await client.session.request("ensureSpace", { id });
-      return { id };
-    }
-  },
-  events: {
-    async *messages({ client }) {
-      for await (const evt of client.events) {
-        if (evt.kind === "message") {
-          const msg = evt.value;
-          client.knownChats.add(msg.spaceId);
-          yield {
-            id: msg.id,
-            content: protocolToSpectrum(msg.content),
-            sender: { id: msg.senderId },
-            space: { id: msg.spaceId },
-            timestamp: parseTimestamp(msg.timestamp),
-            // replyTo is a terminal-specific extra — agents inspect via a
-            // cast until Spectrum's message model grows first-class support.
-            ...msg.replyTo ? { replyTo: msg.replyTo } : {}
-          };
-          continue;
-        }
-        const r = evt.value;
-        client.knownChats.add(r.spaceId);
-        yield {
-          id: `reaction:${r.messageId}:${r.reaction}:${r.timestamp}`,
-          content: reactionContentFromProtocol(r),
-          sender: { id: r.senderId },
-          space: { id: r.spaceId },
-          timestamp: parseTimestamp(r.timestamp)
-        };
-      }
-    }
-  },
-  actions: {
-    send: async ({ client, content, space }) => {
-      const proto = await spectrumToProtocol(content);
-      const result = await client.session.request("send", { spaceId: space.id, content: proto });
-      return buildOutboundRecord(result, content, space.id);
-    },
-    startTyping: async ({ client, space }) => {
-      await client.session.request("startTyping", { spaceId: space.id });
-    },
-    stopTyping: async ({ client, space }) => {
-      await client.session.request("stopTyping", { spaceId: space.id });
-    },
-    reactToMessage: async ({ client, space, target, reaction }) => {
-      await client.session.request("reactToMessage", {
-        spaceId: space.id,
-        messageId: target.id,
-        reaction
-      });
-    },
-    replyToMessage: async ({ client, space, messageId, content }) => {
-      const proto = await spectrumToProtocol(content);
-      const result = await client.session.request("replyToMessage", { spaceId: space.id, messageId, content: proto });
-      return buildOutboundRecord(result, content, space.id);
-    }
-  }
-});
+  terminal
+} from "../../chunk-NIIJ6U34.js";
+import "../../chunk-B4MHPWPZ.js";
+import "../../chunk-LH4YEBG3.js";
 export {
   terminal
 };