@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/chunks/billing-svrhh5a5.js

@@ -0,0 +1,307 @@
+import {
+  MIRROR_TOOL2,
+  emptyMessage2,
+  mirrorClass2,
+  toolText2,
+  Translator2
+} from "./billing-9nn3yp18.js";
+
+// src/acp/thread.ts
+import { posix } from "node:path";
+import { createAssistantMessageEventStream } from "@nyte-ai/ai";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+class Inbox {
+  #items = [];
+  #waiter;
+  #ended = false;
+  push(item) {
+    this.#items.push(item);
+    this.#wake();
+  }
+  end() {
+    this.#ended = true;
+    this.#wake();
+  }
+  async next() {
+    while (this.#items.length === 0 && !this.#ended)
+      await new Promise((resolve) => this.#waiter = resolve);
+    return this.#items.shift();
+  }
+  #wake() {
+    const waiter = this.#waiter;
+    this.#waiter = undefined;
+    waiter?.();
+  }
+}
+var input = Type.Record(Type.String(), Type.Unknown());
+function answer(choice, options) {
+  const kinds = choice === "allow" ? ["allow_once"] : choice === "reject" ? ["reject_once", "reject_always"] : [];
+  const option = kinds.flatMap((kind) => options.filter((entry) => entry.kind === kind))[0];
+  return option === undefined ? { outcome: { outcome: "cancelled" } } : { outcome: { outcome: "selected", optionId: option.optionId } };
+}
+function guardedFirst(cwd, paths) {
+  const root = posix.resolve(cwd);
+  const inside = (path) => {
+    const target = posix.resolve(root, path);
+    return target === root || target.startsWith(`${root}/`);
+  };
+  return [...paths.filter((path) => !inside(path)), ...paths.filter(inside)];
+}
+function stopReason(response) {
+  switch (response.stopReason) {
+    case "max_tokens":
+    case "max_turn_requests":
+      return "length";
+    case "refusal":
+      return "error";
+    case "cancelled":
+      return "aborted";
+    default:
+      return "stop";
+  }
+}
+
+class AcpThread2 {
+  prefix;
+  #channel;
+  #events = new Inbox;
+  #tools = new Map;
+  #permissions = new Map;
+  #recordings = new Map;
+  #changes = new Set;
+  #queue = [];
+  #running = false;
+  #failure;
+  constructor(prefix, channel) {
+    this.prefix = prefix;
+    this.#channel = channel;
+  }
+  get closed() {
+    return this.#failure !== undefined;
+  }
+  send(blocks) {
+    if (this.#running)
+      this.#queue.push(blocks);
+    else
+      this.#start(blocks);
+  }
+  update(update) {
+    switch (update.sessionUpdate) {
+      case "agent_message_chunk":
+        if (update.content.type === "text")
+          this.#events.push({ kind: "text", text: update.content.text });
+        break;
+      case "agent_thought_chunk":
+        if (update.content.type === "text")
+          this.#events.push({ kind: "thinking", text: update.content.text });
+        break;
+      case "tool_call":
+      case "tool_call_update":
+        this.#see(update);
+        break;
+      default:
+        break;
+    }
+    this.#changed();
+  }
+  async permission(request) {
+    const id = request.toolCall.toolCallId;
+    this.#see(request.toolCall);
+    if (this.#failure !== undefined)
+      return answer("cancelled", request.options);
+    const asking = new AbortController;
+    this.#permissions.set(id, asking);
+    this.#changed();
+    try {
+      const recorded = await Promise.race([
+        this.#recording(id).promise,
+        new Promise((resolve) => asking.signal.addEventListener("abort", () => resolve("cancelled"), { once: true }))
+      ]);
+      if (recorded !== "recording")
+        return answer(recorded === "skipped" ? "reject" : "cancelled", request.options);
+      const args = this.#arguments(id);
+      const name = args.kind === "other" ? args.title : args.kind;
+      const verdict = await this.#channel.approve({ name, class: mirrorClass2(args) }, asking.signal);
+      if (asking.signal.aborted)
+        return answer("cancelled", request.options);
+      return answer(verdict.kind === "allow" ? "allow" : "reject", request.options);
+    } finally {
+      this.#permissions.delete(id);
+      this.#changed();
+    }
+  }
+  recording(id) {
+    this.#recording(id).resolve("recording");
+  }
+  skip(id) {
+    if (this.#tools.has(id))
+      this.#recording(id).resolve("skipped");
+  }
+  respond(model, signal, tools = true) {
+    const stream = createAssistantMessageEventStream();
+    const output = emptyMessage2(model);
+    const translator = new Translator2(model, output, stream);
+    const abort = () => {
+      this.cancel();
+      this.#events.push({ kind: "aborted" });
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    (async () => {
+      try {
+        stream.push({ type: "start", partial: output });
+        let reason;
+        while (reason === undefined) {
+          const event = await this.#events.next();
+          if (event === undefined)
+            throw this.#failure ?? new Error("The agent stopped.");
+          if (event.kind === "aborted")
+            throw new Error("Request was aborted");
+          if (event.kind === "text")
+            translator.text(event.text);
+          else if (event.kind === "thinking")
+            translator.thinking(event.text);
+          else if (event.kind === "tool" && !tools)
+            this.skip(event.id);
+          else if (event.kind === "tool") {
+            translator.call(this.#mirror(event.id));
+            reason = "toolUse";
+          } else {
+            translator.end();
+            if (event.response.usage !== undefined && event.response.usage !== null)
+              translator.usage(event.response.usage);
+            output.rawStopReason = event.response.stopReason;
+            const mapped = stopReason(event.response);
+            if (mapped === "aborted")
+              throw new Error("Request was aborted");
+            if (mapped === "error")
+              throw new Error("The agent refused to complete the request.");
+            reason = mapped;
+          }
+        }
+        output.stopReason = reason;
+        stream.push({ type: "done", reason, message: output });
+      } catch (error) {
+        output.stopReason = signal?.aborted === true ? "aborted" : "error";
+        output.errorMessage = error instanceof Error ? error.message : String(error);
+        stream.push({ type: "error", reason: output.stopReason, error: output });
+      } finally {
+        signal?.removeEventListener("abort", abort);
+        stream.end();
+      }
+    })();
+    return stream;
+  }
+  async result(id, signal) {
+    const settled = () => {
+      const status = this.#tools.get(id)?.status;
+      return status === "completed" || status === "failed" || !this.#running || [...this.#permissions.keys()].some((other) => other !== id);
+    };
+    while (!settled() && this.#failure === undefined) {
+      if (signal.aborted) {
+        this.cancel();
+        signal.throwIfAborted();
+      }
+      await new Promise((resolve) => {
+        const done = () => {
+          this.#changes.delete(done);
+          signal.removeEventListener("abort", done);
+          resolve();
+        };
+        this.#changes.add(done);
+        signal.addEventListener("abort", done, { once: true });
+      });
+    }
+    const tool = this.#tools.get(id);
+    if (tool === undefined)
+      throw this.#failure ?? new Error("The agent did not report this call.");
+    return { text: toolText2(tool.content, tool.rawOutput), failed: tool.status === "failed" };
+  }
+  cancel() {
+    this.#queue.length = 0;
+    for (const asking of this.#permissions.values())
+      asking.abort();
+    if (this.#running)
+      this.#channel.cancel();
+  }
+  close(reason = new Error("The agent's session closed.")) {
+    if (this.#failure !== undefined)
+      return;
+    this.cancel();
+    this.#failure = reason;
+    this.#events.end();
+    this.#changed();
+  }
+  #start(blocks) {
+    this.#running = true;
+    this.#channel.prompt(blocks).then((response) => {
+      const next = response.stopReason === "cancelled" ? undefined : this.#queue.shift();
+      if (next !== undefined) {
+        this.#start(next);
+        return;
+      }
+      this.#running = false;
+      this.#events.push({ kind: "stop", response });
+      this.#changed();
+    }, (error) => {
+      this.#running = false;
+      this.close(error instanceof Error ? error : new Error(String(error)));
+    });
+  }
+  #see(update) {
+    const known = this.#tools.get(update.toolCallId);
+    const tool = known ?? {
+      title: "Tool",
+      kind: "other",
+      status: "pending",
+      input: {},
+      paths: [],
+      content: [],
+      rawOutput: undefined
+    };
+    tool.title = update.title ?? tool.title;
+    tool.kind = update.kind ?? tool.kind;
+    tool.status = update.status ?? tool.status;
+    tool.input = Value.Check(input, update.rawInput) ? update.rawInput : tool.input;
+    tool.paths = update.locations?.map((location) => location.path) ?? tool.paths;
+    tool.content = update.content ?? tool.content;
+    tool.rawOutput = update.rawOutput ?? tool.rawOutput;
+    if (known !== undefined)
+      return;
+    this.#tools.set(update.toolCallId, tool);
+    this.#events.push({ kind: "tool", id: update.toolCallId });
+  }
+  #arguments(id) {
+    const tool = this.#tools.get(id);
+    return {
+      thread: this.prefix,
+      id,
+      title: tool?.title ?? "Tool",
+      kind: tool?.kind ?? "other",
+      input: tool?.input ?? {},
+      paths: guardedFirst(this.#channel.cwd, tool?.paths ?? [])
+    };
+  }
+  #mirror(id) {
+    return {
+      type: "toolCall",
+      id: `${this.prefix}${id}`,
+      name: MIRROR_TOOL2,
+      arguments: this.#arguments(id)
+    };
+  }
+  #recording(id) {
+    const known = this.#recordings.get(id);
+    if (known !== undefined)
+      return known;
+    const created = Promise.withResolvers();
+    this.#recordings.set(id, created);
+    return created;
+  }
+  #changed() {
+    for (const change of this.#changes)
+      change();
+  }
+}
+
+export { AcpThread2 };

package/dist/chunks/billing-sxc70w72.js

@@ -0,0 +1,161 @@
+import {
+  CANVAS_RUNTIME2,
+  CANVAS_MAX_HEIGHT2,
+  initializeResult2,
+  renderNotification2,
+  clampCanvasHeight2
+} from "./billing-bv5zr32b.js";
+
+// src/canvas/canvas-preview.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var CANVAS_PREVIEW_WIDTHS2 = { chat: 808, phone: 358 };
+var WIDTH_NAMES = { chat: "the chat column", phone: "a phone" };
+var SETTLE_TIMEOUT_MS = 8000;
+var SETTLE_QUIET_MS = 400;
+var CONSOLE_KEPT = 40;
+var settled = Type.Object({
+  height: Type.Number(),
+  errors: Type.Array(Type.Object({
+    phase: Type.Union([Type.Literal("load"), Type.Literal("render")]),
+    message: Type.String(),
+    stack: Type.Optional(Type.String())
+  })),
+  console: Type.Array(Type.Object({ level: Type.String(), text: Type.String() }))
+});
+function hostContext(theme) {
+  return {
+    theme,
+    styles: { variables: { "--nyte-custom-hue": "250", "--nyte-custom-chroma-scale": "0" } },
+    displayMode: "inline",
+    platform: "desktop",
+    deviceCapabilities: { touch: false, hover: true }
+  };
+}
+function installHarness(setup) {
+  if ("__nytePreview" in globalThis)
+    return true;
+  if (!("__nyteCanvas" in globalThis))
+    return false;
+  const state = {
+    height: 0,
+    changed: 0,
+    errors: new Array,
+    console: new Array
+  };
+  const text = (value) => {
+    if (typeof value === "string")
+      return value;
+    if (value instanceof Error)
+      return value.stack ?? String(value);
+    try {
+      return JSON.stringify(value) ?? String(value);
+    } catch {
+      return String(value);
+    }
+  };
+  for (const level of ["log", "info", "warn", "error", "debug"]) {
+    const original = console[level].bind(console);
+    console[level] = (...values) => {
+      if (state.console.length < setup.consoleKept)
+        state.console.push({ level, text: values.map(text).join(" ").slice(0, 2000) });
+      original(...values);
+    };
+  }
+  this.addEventListener("message", (event) => {
+    const data = event.data;
+    if (typeof data !== "object" || data === null || !("method" in data))
+      return;
+    const params = "params" in data && typeof data.params === "object" ? data.params : null;
+    if (data.method === "ui/notifications/initialized")
+      this.postMessage(setup.render, "*");
+    if (data.method === "ui/notifications/size-changed" && params !== null && "height" in params && typeof params.height === "number") {
+      state.height = params.height;
+      state.changed = performance.now();
+    }
+    if (data.method === "notifications/message" && params !== null && "data" in params)
+      state.errors.push(params.data);
+  });
+  Object.defineProperty(globalThis, "__nytePreview", {
+    value: {
+      settle: () => new Promise((resolve) => {
+        const since = performance.now();
+        const check = () => {
+          const now = performance.now();
+          const quiet = now - Math.max(state.changed, since) > setup.quietMs;
+          if (quiet && (state.height > 0 || state.errors.length > 0) || now - since > setup.timeoutMs)
+            resolve({ height: state.height, errors: state.errors, console: state.console });
+          else
+            setTimeout(check, 50);
+        };
+        check();
+      })
+    }
+  });
+  this.postMessage(setup.initialize, "*");
+  return true;
+}
+function harness(request) {
+  const setup = {
+    initialize: initializeResult2(1, { name: "nyte-preview", version: String(CANVAS_RUNTIME2) }, hostContext(request.theme)),
+    render: renderNotification2(request.module),
+    quietMs: SETTLE_QUIET_MS,
+    timeoutMs: SETTLE_TIMEOUT_MS,
+    consoleKept: CONSOLE_KEPT
+  };
+  return `(${installHarness.toString()}).call(globalThis, ${JSON.stringify(setup)})`;
+}
+async function settle(page) {
+  const answer = await page.evaluate("globalThis.__nytePreview.settle()");
+  if (!Value.Check(settled, answer))
+    throw new Error("The canvas preview harness answered something unreadable.");
+  return answer;
+}
+async function runCanvasPreview2(page, request) {
+  const { chat, phone } = CANVAS_PREVIEW_WIDTHS2;
+  await page.resize(chat, 900);
+  const install = harness(request);
+  let attempts = 0;
+  while (await page.evaluate(install) !== true) {
+    attempts += 1;
+    if (attempts > 50)
+      throw new Error("The canvas shell did not start in the preview.");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  const wide = await settle(page);
+  await page.resize(chat, clampCanvasHeight2(wide.height > 0 ? wide.height : 240));
+  const narrow = await settle(page);
+  const png = await page.capture();
+  await page.resize(phone, 900);
+  const last = await settle(page);
+  return {
+    png,
+    heights: { chat: narrow.height, phone: last.height },
+    errors: last.errors.map((error) => ({ ...error, stack: error.stack ?? null })),
+    console: last.console
+  };
+}
+function describeCanvasPreview2(report) {
+  const heights = ["chat", "phone"].map((width) => {
+    const height = report.heights[width];
+    const scrolls = height > CANVAS_MAX_HEIGHT2 ? `, so it scrolls past ${CANVAS_MAX_HEIGHT2} px` : "";
+    return `At ${CANVAS_PREVIEW_WIDTHS2[width]} px wide (${WIDTH_NAMES[width]}) it is ${height} px tall${scrolls}.`;
+  });
+  const errors = report.errors.length === 0 ? ["No errors."] : [
+    `Errors (${report.errors.length}):`,
+    ...report.errors.map((error) => `- ${error.phase}: ${error.message}`)
+  ];
+  const logs = report.console.length === 0 ? [] : [
+    `Console (${report.console.length}):`,
+    ...report.console.map((entry) => `- [${entry.level}] ${entry.text}`)
+  ];
+  return [
+    "Preview only; the user has not seen it. The screenshot is the chat-column render.",
+    ...heights,
+    ...errors,
+    ...logs
+  ].join(`
+`);
+}
+
+export { CANVAS_PREVIEW_WIDTHS2, runCanvasPreview2, describeCanvasPreview2 };

package/dist/chunks/billing-t1qrxe16.js

@@ -0,0 +1,41 @@
+// examples/claude-code/inert-mcp.ts
+var INERT_MCP_SOURCE2 = `#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { createInterface } from "node:readline";
+
+const manifestPath = process.argv[2];
+if (!manifestPath) process.exit(2);
+const tools = JSON.parse(await readFile(manifestPath, "utf8"));
+const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+for await (const line of lines) {
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch {
+    continue;
+  }
+
+  let result = {};
+  if (request.method === "initialize") {
+    result = {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {} },
+      serverInfo: { name: "nyte-inert-tool-inventory", version: "1" },
+    };
+  } else if (request.method === "tools/list") {
+    result = { tools };
+  } else if (request.method === "tools/call") {
+    result = {
+      isError: true,
+      content: [{ type: "text", text: "Denied: Claude Code tools are inert; only Nyte executes tools." }],
+    };
+  }
+
+  if (request.id !== undefined) {
+    process.stdout.write(\`\${JSON.stringify({ jsonrpc: "2.0", id: request.id, result })}\\n\`);
+  }
+}
+`;
+
+export { INERT_MCP_SOURCE2 };

package/dist/chunks/billing-tzr3cebf.js

@@ -0,0 +1,20 @@
+import {
+  envFlagEnabled2
+} from "./billing-s4rrspsk.js";
+
+// examples/claude-code/billing.ts
+var ALLOW_USAGE_CREDITS_ENV = "NYTE_CLAUDE_CODE_ALLOW_USAGE_CREDITS";
+var USAGE_CREDITS_REJECTION = /third-party apps now draw from your extra usage|out of extra usage|draws? from your usage credits/iu;
+function usageCreditsAllowed2(env) {
+  return envFlagEnabled2(env[ALLOW_USAGE_CREDITS_ENV]);
+}
+function usageCreditsChargeError2(info) {
+  return new Error("Claude Code billing: this request was charged to Claude usage credits instead of your plan limits " + `(rate limit status ${info.status ?? "unknown"}${info.rateLimitType ? `, ${info.rateLimitType}` : ""}). ` + "Nyte stopped so further requests are not charged. To stay on plan limits only, turn off usage credits at " + `claude.ai/settings/usage. To allow usage credits, set ${ALLOW_USAGE_CREDITS_ENV}=1.`);
+}
+function describeUsageCreditsRejection2(message) {
+  if (!USAGE_CREDITS_REJECTION.test(message))
+    return;
+  return "Claude Code billing: Anthropic did not accept this request on your Claude plan limits and wants to charge " + "it to usage credits. This happens when your plan limit is used up, or when Anthropic classifies the " + "request as third-party app usage. Nyte will not retry it. Original error: " + message;
+}
+
+export { usageCreditsAllowed2, usageCreditsChargeError2, describeUsageCreditsRejection2 };

package/dist/chunks/billing-wmcbg6fw.js

@@ -0,0 +1,52 @@
+import {
+  MIRROR_TOOL2
+} from "./billing-9nn3yp18.js";
+
+// src/acp/transcript.ts
+var RESULT_LIMIT = 2000;
+function text(content) {
+  return typeof content === "string" ? content : content.map((block) => block.type === "text" ? block.text : `[${block.mimeType}]`).join("");
+}
+function messageKey2(message) {
+  if (message.role === "user")
+    return `u:${text(message.content)}`;
+  if (message.role === "toolResult")
+    return `t:${message.toolCallId}`;
+  if (message.role === "system")
+    return "s";
+  return `a:${message.content.flatMap((block) => block.type === "toolCall" ? [block.id] : []).join(",")}`;
+}
+function userBlocks2(message, images) {
+  if (typeof message.content === "string")
+    return [{ type: "text", text: message.content }];
+  return message.content.map((block) => block.type === "text" ? { type: "text", text: block.text } : images ? { type: "image", data: block.data, mimeType: block.mimeType } : { type: "text", text: `(${block.mimeType} image omitted)` });
+}
+function transcriptText2(messages) {
+  return messages.flatMap((message) => {
+    if (message.role === "user")
+      return [`User:
+${text(message.content)}`];
+    if (message.role === "toolResult")
+      return [
+        `Tool result (${message.toolName}):
+${text(message.content).slice(0, RESULT_LIMIT)}`
+      ];
+    if (message.role !== "assistant" || message.stopReason === "error")
+      return [];
+    const said = message.content.flatMap((block) => {
+      if (block.type === "text")
+        return [block.text];
+      if (block.type !== "toolCall")
+        return [];
+      const title = block.name === MIRROR_TOOL2 ? block.arguments.title : undefined;
+      return [`[${typeof title === "string" ? title : block.name}]`];
+    });
+    return said.length === 0 ? [] : [`Assistant:
+${said.join(`
+`)}`];
+  }).join(`
+
+`);
+}
+
+export { messageKey2, userBlocks2, transcriptText2 };