@nyte-ai/plugin 0.0.23 → 0.0.24

package/dist/chunks/billing-a9vqn66p.js

@@ -1,351 +0,0 @@
-import {
-  matchesRecord2,
-  parseRecord2,
-  parseStreamEvent2
-} from "./billing-0y7dfkp2.js";
-
-// examples/claude-code/turn-relay.ts
-import { createServer, request as httpRequest } from "node:http";
-import https from "node:https";
-import { randomBytes } from "node:crypto";
-class AnthropicCapture2 {
-  message;
-  complete = false;
-  error;
-  pending = "";
-  decoder = new TextDecoder;
-  argumentsByIndex = new Map;
-  onEvent;
-  constructor(onEvent) {
-    this.onEvent = onEvent;
-  }
-  feed(chunk) {
-    this.pending += this.decoder.decode(chunk, { stream: true });
-    this.consumeFrames();
-  }
-  finish() {
-    this.pending += this.decoder.decode();
-    this.consumeFrames();
-  }
-  consumeFrames() {
-    for (;; ) {
-      const match = /\r?\n\r?\n/u.exec(this.pending);
-      if (!match)
-        return;
-      const frame = this.pending.slice(0, match.index);
-      this.pending = this.pending.slice(match.index + match[0].length);
-      const data = frame.split(/\r?\n/u).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join(`
-`);
-      if (!data || data === "[DONE]")
-        continue;
-      const event = parseStreamEvent2(data);
-      if (event === undefined)
-        continue;
-      this.apply(event);
-      this.onEvent?.(event);
-    }
-  }
-  apply(event) {
-    switch (event.type) {
-      case "message_start":
-        this.message = structuredClone(event.message);
-        break;
-      case "content_block_start":
-        if (this.message)
-          this.message.content[event.index] = structuredClone(event.content_block);
-        break;
-      case "content_block_delta": {
-        const block = this.message?.content[event.index];
-        if (!block)
-          break;
-        const delta = event.delta;
-        if (delta.type === "text_delta" && block.type === "text")
-          block.text += delta.text;
-        else if (delta.type === "thinking_delta" && block.type === "thinking")
-          block.thinking += delta.thinking;
-        else if (delta.type === "signature_delta" && block.type === "thinking") {
-          block.signature = (block.signature ?? "") + delta.signature;
-        } else if (delta.type === "input_json_delta" && block.type === "tool_use") {
-          this.argumentsByIndex.set(event.index, (this.argumentsByIndex.get(event.index) ?? "") + delta.partial_json);
-        }
-        break;
-      }
-      case "content_block_stop": {
-        const block = this.message?.content[event.index];
-        if (block?.type === "tool_use" && this.argumentsByIndex.has(event.index)) {
-          const raw = this.argumentsByIndex.get(event.index) ?? "";
-          block.input = raw.trim() ? parseRecord2(raw) : {};
-          this.argumentsByIndex.delete(event.index);
-        }
-        break;
-      }
-      case "message_delta":
-        if (this.message) {
-          Object.assign(this.message, event.delta);
-          if (event.usage)
-            this.message.usage = {
-              input_tokens: this.message.usage?.input_tokens ?? 0,
-              output_tokens: this.message.usage?.output_tokens ?? 0,
-              ...this.message.usage,
-              ...event.usage
-            };
-        }
-        break;
-      case "message_stop":
-        this.complete = !!this.message?.stop_reason && this.argumentsByIndex.size === 0;
-        break;
-      case "error": {
-        const { type, message } = event.error ?? {};
-        this.error = [type, message].filter(Boolean).join(": ") || "unknown stream error";
-        break;
-      }
-    }
-  }
-}
-var STRIPPED_REQUEST_HEADERS = new Set([
-  "host",
-  "connection",
-  "content-length",
-  "transfer-encoding",
-  "proxy-authorization",
-  "proxy-connection",
-  "accept-encoding"
-]);
-var STRIPPED_RESPONSE_HEADERS = new Set(["connection", "transfer-encoding", "server", "date"]);
-
-class TurnRelay2 {
-  capture;
-  used = false;
-  denied = 0;
-  status;
-  requestId;
-  failure;
-  errorBody = Buffer.alloc(0);
-  originalRequestBody;
-  requestBody;
-  upstream;
-  prefix = `/turn/${randomBytes(32).toString("base64url")}`;
-  server;
-  sockets = new Set;
-  active = new Set;
-  cancelled = false;
-  closed = false;
-  baseUrl;
-  transformRequest;
-  requestBetas = [];
-  timeoutMs;
-  constructor(upstream = "https://api.anthropic.com", timeoutMs = 180000, onEvent, transformRequest, requestBetas = []) {
-    this.timeoutMs = timeoutMs;
-    this.upstream = new URL(upstream);
-    const loopback = ["127.0.0.1", "::1", "localhost"].includes(this.upstream.hostname);
-    if (this.upstream.protocol !== "https:" && !(this.upstream.protocol === "http:" && loopback) || this.upstream.username || this.upstream.password || this.upstream.search || this.upstream.hash) {
-      throw new Error("Claude Code upstream must be HTTPS or a loopback HTTP fixture");
-    }
-    this.capture = new AnthropicCapture2(onEvent);
-    this.transformRequest = transformRequest;
-    this.requestBetas = requestBetas;
-    this.server = createServer((request, response) => {
-      const operation = this.handle(request, response).finally(() => this.active.delete(operation));
-      this.active.add(operation);
-    });
-  }
-  beginTurn(onEvent, transformRequest, requestBetas = []) {
-    if (this.closed)
-      throw new Error("Claude Code turn relay is closed");
-    if (this.active.size > 0)
-      throw new Error("Claude Code turn relay still has an active request");
-    this.capture = new AnthropicCapture2(onEvent);
-    this.used = false;
-    this.denied = 0;
-    this.status = undefined;
-    this.requestId = undefined;
-    this.failure = undefined;
-    this.errorBody = Buffer.alloc(0);
-    this.originalRequestBody = undefined;
-    this.requestBody = undefined;
-    this.transformRequest = transformRequest;
-    this.requestBetas = requestBetas;
-    this.cancelled = false;
-  }
-  finishTurn() {
-    if (this.cancelled)
-      return;
-    this.cancelled = true;
-    for (const socket of this.sockets)
-      socket.destroy(new Error("Claude Code request aborted"));
-    this.sockets.clear();
-    this.server.closeAllConnections?.();
-  }
-  async start() {
-    await new Promise((resolve, reject) => {
-      const onError = (error) => reject(error);
-      this.server.once("error", onError);
-      this.server.listen(0, "127.0.0.1", () => {
-        this.server.off("error", onError);
-        resolve();
-      });
-    });
-    const address = this.server.address();
-    if (address === null || typeof address === "string")
-      throw new Error("Claude Code relay did not bind a TCP port");
-    this.baseUrl = `http://127.0.0.1:${address.port}${this.prefix}`;
-    return this.baseUrl;
-  }
-  errorText() {
-    if (this.capture.error)
-      return this.capture.error;
-    const text = this.errorBody.toString("utf8");
-    try {
-      const payload = parseRecord2(text);
-      return matchesRecord2(payload.error) && typeof payload.error.message === "string" ? payload.error.message : text;
-    } catch {
-      return text;
-    }
-  }
-  abort() {
-    this.finishTurn();
-  }
-  async settled() {
-    await Promise.allSettled(this.active);
-  }
-  async close() {
-    this.closed = true;
-    this.abort();
-    await new Promise((resolve) => {
-      if (!this.server.listening)
-        return resolve();
-      this.server.close(() => resolve());
-    });
-    await this.settled();
-  }
-  async handle(request, response) {
-    const requestUrl = new URL(request.url ?? "/", "http://127.0.0.1");
-    if (request.method !== "POST" || requestUrl.pathname !== `${this.prefix}/v1/messages` || request.headers.origin) {
-      response.writeHead(404).end();
-      return;
-    }
-    if (this.cancelled || this.used) {
-      this.denied += 1;
-      const body = Buffer.from(JSON.stringify({
-        type: "error",
-        error: { type: "invalid_request_error", message: "NYTE_CLAUDE_CODE_TURN_RELAY_CONSUMED" }
-      }));
-      response.writeHead(400, { "content-type": "application/json", "content-length": body.length }).end(body);
-      return;
-    }
-    this.used = true;
-    this.sockets.add(request);
-    this.sockets.add(response);
-    let upstreamRequest;
-    try {
-      let body = await this.readBody(request);
-      this.originalRequestBody = Buffer.from(body);
-      if (this.transformRequest)
-        body = this.transformRequest(body);
-      this.requestBody = Buffer.from(body);
-      if (this.cancelled)
-        return;
-      const headers = {};
-      for (const [name, value] of Object.entries(request.headers)) {
-        if (!STRIPPED_REQUEST_HEADERS.has(name.toLowerCase()) && value !== undefined)
-          headers[name] = value;
-      }
-      headers["accept-encoding"] = "identity";
-      headers["content-length"] = body.length;
-      if (this.requestBetas.length > 0) {
-        const existing = Array.isArray(headers["anthropic-beta"]) ? headers["anthropic-beta"].join(",") : String(headers["anthropic-beta"] ?? "");
-        headers["anthropic-beta"] = [
-          ...new Set([
-            ...existing.split(",").map((value) => value.trim()).filter(Boolean),
-            ...this.requestBetas
-          ])
-        ].join(",");
-      }
-      const pathPrefix = this.upstream.pathname.replace(/\/$/u, "");
-      const send = this.upstream.protocol === "https:" ? https.request : httpRequest;
-      const outgoing = send({
-        protocol: this.upstream.protocol,
-        hostname: this.upstream.hostname,
-        port: this.upstream.port || undefined,
-        method: "POST",
-        path: `${pathPrefix}/v1/messages${requestUrl.search}`,
-        headers,
-        timeout: this.timeoutMs
-      });
-      upstreamRequest = outgoing;
-      this.sockets.add(outgoing);
-      const upstreamResponse = await new Promise((resolve, reject) => {
-        outgoing.once("response", resolve);
-        outgoing.once("error", reject);
-        outgoing.end(body);
-      });
-      this.sockets.add(upstreamResponse);
-      this.status = upstreamResponse.statusCode;
-      this.requestId = String(upstreamResponse.headers["request-id"] ?? upstreamResponse.headers["x-request-id"] ?? "") || undefined;
-      const responseHeaders = {};
-      for (const [name, value] of Object.entries(upstreamResponse.headers)) {
-        if (!STRIPPED_RESPONSE_HEADERS.has(name.toLowerCase()) && value !== undefined)
-          responseHeaders[name] = value;
-      }
-      responseHeaders.connection = "close";
-      response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders);
-      for await (const rawChunk of upstreamResponse) {
-        const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
-        if (this.status === 200)
-          this.capture.feed(chunk);
-        else if (this.errorBody.length < 65536) {
-          this.errorBody = Buffer.concat([this.errorBody, chunk]).subarray(0, 65536);
-        }
-        if (!response.write(chunk))
-          await this.waitForDrain(response);
-      }
-      if (this.status === 200)
-        this.capture.finish();
-      response.end();
-    } catch (error) {
-      this.failure = error instanceof Error ? error.name : "UnknownError";
-      if (!response.headersSent)
-        response.writeHead(this.cancelled ? 499 : 502).end();
-      else
-        response.destroy();
-    } finally {
-      if (upstreamRequest)
-        this.sockets.delete(upstreamRequest);
-      this.sockets.delete(request);
-      this.sockets.delete(response);
-      upstreamRequest?.destroy();
-    }
-  }
-  async waitForDrain(response) {
-    await new Promise((resolve, reject) => {
-      const cleanup = () => {
-        response.off("drain", onDrain);
-        response.off("close", onClose);
-        response.off("error", onError);
-      };
-      const onDrain = () => {
-        cleanup();
-        resolve();
-      };
-      const onClose = () => {
-        cleanup();
-        reject(new Error("Claude Code disconnected from the turn relay"));
-      };
-      const onError = (error) => {
-        cleanup();
-        reject(error);
-      };
-      response.once("drain", onDrain);
-      response.once("close", onClose);
-      response.once("error", onError);
-    });
-  }
-  async readBody(request) {
-    const chunks = [];
-    for await (const rawChunk of request)
-      chunks.push(Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk));
-    return Buffer.concat(chunks);
-  }
-}
-
-export { AnthropicCapture2, TurnRelay2 };

package/dist/chunks/billing-cy1rg619.js

@@ -1,302 +0,0 @@
-import {
-  envFlagEnabled2
-} from "./billing-s4rrspsk.js";
-import {
-  discoveredModelSchema2
-} from "./billing-9qc0eqh4.js";
-import {
-  matchesRecord2,
-  parseRecord2
-} from "./billing-0y7dfkp2.js";
-
-// examples/claude-code/process.ts
-import { spawn } from "node:child_process";
-import { constants } from "node:fs";
-import { access } from "node:fs/promises";
-import { delimiter, extname, isAbsolute, join, resolve as resolvePath } from "node:path";
-import { createInterface } from "node:readline";
-import { Value } from "typebox/value";
-var INSTALL_HINT = "Claude Code is not installed. Install it with `npm install -g @anthropic-ai/claude-code` " + "or set NYTE_CLAUDE_CODE_COMMAND to the executable.";
-var LOGIN_HINT2 = "Claude Code is installed but not logged in. Run `claude auth login` and try again.";
-function configuredCommand2(env) {
-  return env.NYTE_CLAUDE_CODE_COMMAND || "claude";
-}
-async function executable(path) {
-  try {
-    await access(path, process.platform === "win32" ? constants.F_OK : constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolveClaudeExecutable(env = process.env) {
-  const command = configuredCommand2(env);
-  if (isAbsolute(command) || command.includes("/") || command.includes("\\")) {
-    const candidate = resolvePath(command);
-    return await executable(candidate) ? candidate : undefined;
-  }
-  const extensions = process.platform === "win32" ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").flatMap((suffix) => [suffix, suffix.toLowerCase()]) : [""];
-  for (const directory of (env.PATH || "").split(delimiter)) {
-    if (!directory)
-      continue;
-    for (const suffix of extensions) {
-      const candidate = join(directory, process.platform === "win32" && extname(command) ? command : command + suffix);
-      if (await executable(candidate))
-        return candidate;
-    }
-  }
-  return;
-}
-function withConfigDirectory(env) {
-  const output = {};
-  for (const [key, value] of Object.entries(env))
-    if (value !== undefined)
-      output[key] = value;
-  if (output.NYTE_CLAUDE_CODE_CONFIG_DIR)
-    output.CLAUDE_CONFIG_DIR = output.NYTE_CLAUDE_CODE_CONFIG_DIR;
-  return output;
-}
-async function captureProcess(command, args, env, signal, timeoutMs = 20000) {
-  signal?.throwIfAborted();
-  const child = spawnCommand2(command, args, { env, stdio: ["ignore", "pipe", "pipe"] });
-  let stdout = "";
-  let stderr = "";
-  child.stdout?.setEncoding("utf8");
-  child.stderr?.setEncoding("utf8");
-  child.stdout?.on("data", (chunk) => stdout = (stdout + chunk).slice(-1e6));
-  child.stderr?.on("data", (chunk) => stderr = (stderr + chunk).slice(-65536));
-  const abort = () => killProcessTree2(child);
-  signal?.addEventListener("abort", abort, { once: true });
-  const timer = setTimeout(abort, timeoutMs);
-  try {
-    const code = await childExit2(child);
-    signal?.throwIfAborted();
-    return { code, stdout, stderr };
-  } finally {
-    clearTimeout(timer);
-    signal?.removeEventListener("abort", abort);
-  }
-}
-async function getClaudeStatus2(envInput = process.env, signal) {
-  const env = withConfigDirectory(envInput);
-  const command = await resolveClaudeExecutable(env);
-  if (!command)
-    return { available: false, loggedIn: false, subscription: false, detail: INSTALL_HINT };
-  try {
-    const result = await captureProcess(command, ["auth", "status"], env, signal);
-    const payload = result.stdout.trim().startsWith("{") ? parseRecord2(result.stdout) : {};
-    const loggedIn = payload.loggedIn === true;
-    const plan = typeof payload.subscriptionType === "string" ? payload.subscriptionType : undefined;
-    return {
-      available: true,
-      loggedIn,
-      subscription: loggedIn && !!plan,
-      command,
-      authMethod: typeof payload.authMethod === "string" ? payload.authMethod : undefined,
-      plan,
-      detail: loggedIn ? undefined : LOGIN_HINT2
-    };
-  } catch (error) {
-    if (signal?.aborted)
-      throw error;
-    return { available: true, loggedIn: false, subscription: false, command, detail: LOGIN_HINT2 };
-  }
-}
-var READY_STATUS_TTL_MS = 60000;
-var readyStatusCache = new Map;
-async function readyClaudeCommand2(envInput, signal) {
-  const env = withConfigDirectory(envInput);
-  const key = JSON.stringify([configuredCommand2(env), env.PATH, env.HOME, env.CLAUDE_CONFIG_DIR]);
-  const cached = readyStatusCache.get(key);
-  if (cached && cached.expires > Date.now())
-    return cached.command;
-  const status = await getClaudeStatus2(env, signal);
-  if (!status.available || !status.command)
-    throw new Error(INSTALL_HINT);
-  if (!status.loggedIn) {
-    readyStatusCache.delete(key);
-    throw new Error(LOGIN_HINT2);
-  }
-  readyStatusCache.set(key, { command: status.command, expires: Date.now() + READY_STATUS_TTL_MS });
-  return status.command;
-}
-async function discoverClaudeModels2(envInput = process.env, signal, timeoutMs = 20000) {
-  signal?.throwIfAborted();
-  const env = processEnvironment2(envInput, {});
-  const command = await resolveClaudeExecutable(env);
-  if (!command)
-    throw new Error(INSTALL_HINT);
-  const args = [
-    "-p",
-    "--input-format",
-    "stream-json",
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    "--model",
-    "default",
-    "--tools",
-    "",
-    "--setting-sources",
-    "",
-    "--strict-mcp-config",
-    "--disable-slash-commands",
-    "--permission-mode",
-    "dontAsk",
-    "--permission-prompts",
-    "none",
-    "--no-session-persistence",
-    "--mcp-config",
-    JSON.stringify({ mcpServers: {} })
-  ];
-  const child = spawnCommand2(command, args, {
-    cwd: process.cwd(),
-    env,
-    detached: process.platform !== "win32",
-    windowsHide: true,
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  let stderr = "";
-  child.stderr?.setEncoding("utf8");
-  child.stderr?.on("data", (chunk) => stderr = (stderr + chunk).slice(-65536));
-  const abort = () => killProcessTree2(child);
-  signal?.addEventListener("abort", abort, { once: true });
-  let timedOut = false;
-  const timer = setTimeout(() => {
-    timedOut = true;
-    killProcessTree2(child);
-  }, timeoutMs);
-  const requestId = `nyte-models-${Date.now()}`;
-  child.stdin?.write(`${JSON.stringify({ type: "control_request", request_id: requestId, request: { subtype: "initialize" } })}
-`);
-  child.stdin?.end(`${JSON.stringify({
-    type: "user",
-    message: { role: "user", content: [{ type: "text", text: "model-catalog-probe" }] },
-    shouldQuery: false
-  })}
-`);
-  let models;
-  try {
-    if (child.stdout === null)
-      throw new Error("Claude Code stdout is unavailable");
-    const reader = createInterface({ input: child.stdout, crlfDelay: Infinity });
-    for await (const line of reader) {
-      if (!line.trim())
-        continue;
-      let event;
-      try {
-        event = parseRecord2(line);
-      } catch {
-        continue;
-      }
-      if (event.type !== "control_response")
-        continue;
-      const envelope = event.response;
-      if (!matchesRecord2(envelope))
-        continue;
-      if (envelope.request_id !== requestId || envelope.subtype !== "success")
-        continue;
-      const response = envelope.response;
-      if (matchesRecord2(response) && Array.isArray(response.models))
-        models = response.models.filter((model) => Value.Check(discoveredModelSchema2, model));
-    }
-    const exitCode = await childExit2(child);
-    signal?.throwIfAborted();
-    if (timedOut)
-      throw new Error("Claude Code model discovery timed out");
-    if (exitCode !== 0)
-      throw new Error(`Claude Code model discovery failed${stderr ? `: ${stderr.trim().slice(-500)}` : ""}`);
-    if (!models?.length)
-      throw new Error("Claude Code returned no selectable models");
-    return models;
-  } catch (error) {
-    if (timedOut)
-      throw new Error("Claude Code model discovery timed out", { cause: error });
-    throw error;
-  } finally {
-    clearTimeout(timer);
-    signal?.removeEventListener("abort", abort);
-    if (child.exitCode === null)
-      killProcessTree2(child);
-  }
-}
-function quote(value) {
-  return `"${value.replace(/"/gu, '""')}"`;
-}
-function spawnCommand2(command, args, options) {
-  if (process.platform === "win32" && /\.(?:cmd|bat)$/iu.test(command)) {
-    const comspec = options?.env?.COMSPEC || process.env.COMSPEC || "cmd.exe";
-    return spawn(comspec, ["/d", "/s", "/c", [quote(command), ...args.map(quote)].join(" ")], options);
-  }
-  return spawn(command, args, options);
-}
-function childExit2(child) {
-  return new Promise((resolve, reject) => {
-    child.once("error", reject);
-    child.once("exit", (code, signal) => {
-      if (code !== null)
-        resolve(code);
-      else
-        reject(new Error(`Claude Code exited from signal ${signal ?? "unknown"}`));
-    });
-  });
-}
-function killProcessTree2(child) {
-  if (child.exitCode !== null || child.pid === undefined)
-    return;
-  if (process.platform === "win32") {
-    const killer = spawn("taskkill", ["/F", "/T", "/PID", String(child.pid)], {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    killer.unref();
-    return;
-  }
-  try {
-    process.kill(-child.pid, "SIGKILL");
-  } catch {
-    try {
-      child.kill("SIGKILL");
-    } catch {}
-  }
-}
-function conflictingEnvironment(env) {
-  const conflicts = [
-    "ANTHROPIC_API_KEY",
-    "ANTHROPIC_AUTH_TOKEN",
-    "ANTHROPIC_BASE_URL",
-    "ANTHROPIC_FOUNDRY_API_KEY"
-  ].filter((key) => !!env[key]);
-  for (const key of [
-    "CLAUDE_CODE_USE_BEDROCK",
-    "CLAUDE_CODE_USE_VERTEX",
-    "CLAUDE_CODE_USE_FOUNDRY"
-  ]) {
-    if (envFlagEnabled2(env[key]))
-      conflicts.push(key);
-  }
-  return conflicts;
-}
-function processEnvironment2(input, extraBody) {
-  const env = withConfigDirectory({ ...process.env, ...input });
-  const conflicts = conflictingEnvironment(env);
-  if (conflicts.length) {
-    throw new Error(`Claude Code subscription provider refuses conflicting auth/backend overrides: ${conflicts.join(", ")}`);
-  }
-  delete env.CLAUDE_CODE_EXTRA_BODY;
-  Object.assign(env, {
-    ENABLE_TOOL_SEARCH: "false",
-    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
-    CLAUDE_CODE_MAX_RETRIES: "0",
-    DISABLE_AUTO_COMPACT: "1",
-    DISABLE_COMPACT: "1",
-    CLAUDE_CODE_TOTAL_TOKENS_REMINDER: "off",
-    DISABLE_TELEMETRY: "1",
-    DISABLE_ERROR_REPORTING: "1"
-  });
-  if (typeof extraBody.max_tokens === "number")
-    env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = String(extraBody.max_tokens);
-  return env;
-}
-
-export { LOGIN_HINT2, configuredCommand2, getClaudeStatus2, readyClaudeCommand2, discoverClaudeModels2, spawnCommand2, childExit2, killProcessTree2, processEnvironment2 };