@nyte-ai/plugin 0.0.0-stage → 0.0.19

package/dist/chunks/billing-kn3d30b4.js

@@ -0,0 +1,276 @@
+import {
+  CANVAS_GLOBAL2,
+  KIT_SPECIFIER2,
+  CANVAS_ENTRY2,
+  CANVAS_SOURCE_LIMIT2,
+  CANVAS_CODE_LIMIT2,
+  REACT_EXPORTS2,
+  JSX_RUNTIME_EXPORTS2,
+  REACT_DOM_EXPORTS2,
+  LIBRARY_EXPORTS2,
+  canvasFilesComment2,
+  KIT_EXPORTS2
+} from "./billing-bv5zr32b.js";
+
+// src/canvas/canvas-compile.ts
+import { init, parse } from "es-module-lexer";
+import { transform } from "sucrase";
+var EXTERNAL = new Map([
+  ["react", { value: `globalThis.${CANVAS_GLOBAL2}.react`, names: REACT_EXPORTS2 }],
+  [
+    "react/jsx-runtime",
+    { value: `globalThis.${CANVAS_GLOBAL2}.jsxRuntime`, names: JSX_RUNTIME_EXPORTS2 }
+  ],
+  ["react-dom", { value: `globalThis.${CANVAS_GLOBAL2}.reactDom`, names: REACT_DOM_EXPORTS2 }],
+  [KIT_SPECIFIER2, { value: `globalThis.${CANVAS_GLOBAL2}.kit`, names: KIT_EXPORTS2 }],
+  ...Object.entries(LIBRARY_EXPORTS2).map(([name, names]) => [
+    name,
+    { value: `await globalThis.${CANVAS_GLOBAL2}.library(${JSON.stringify(name)})`, names }
+  ])
+]);
+var RUNTIME_2 = new Set(["react-dom", ...Object.keys(LIBRARY_EXPORTS2)]);
+var IMPORTABLE = [...EXTERNAL.keys()].filter((name) => name !== "react/jsx-runtime").map((name) => `"${name}"`).join(", ");
+var FILE_NAME = /^(?:[\w-][\w.-]*\/)*[\w-][\w.-]*\.tsx?$/u;
+var encoder = new TextEncoder;
+var POSITION = /\((\d+):(\d+)\)\s*$/;
+function at(file, line, column, text) {
+  return { file, line, column, text };
+}
+function locate(output, offset, prefix) {
+  const before = output.slice(0, offset);
+  const line = before.split(`
+`).length;
+  const column = offset - (before.lastIndexOf(`
+`) + 1) - (line === 1 ? Math.min(prefix, offset) : 0);
+  return { line, column };
+}
+function bindings(clause) {
+  const text = clause.trim();
+  if (text === "")
+    return [];
+  const match = /^(?:([A-Za-z_$][\w$]*)\s*(?:,\s*)?)?(?:\*\s*as\s+([A-Za-z_$][\w$]*)|\{([^}]*)\})?$/u.exec(text);
+  if (match === null)
+    return;
+  const [, defaultName, namespace, named] = match;
+  const found = [];
+  if (defaultName !== undefined)
+    found.push({ imported: "default", local: defaultName });
+  if (namespace !== undefined)
+    found.push({ imported: "*", local: namespace });
+  for (const entry of (named ?? "").split(",")) {
+    const piece = entry.trim();
+    if (piece === "")
+      continue;
+    const pair = /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/u.exec(piece);
+    if (pair === null)
+      return;
+    found.push({ imported: pair[1] ?? "", local: pair[2] ?? pair[1] ?? "" });
+  }
+  return found;
+}
+function resolveFile(importer, specifier, names) {
+  const segments = importer.split("/").slice(0, -1);
+  for (const segment of specifier.split("/")) {
+    if (segment === "" || segment === ".")
+      continue;
+    if (segment !== "..") {
+      segments.push(segment);
+      continue;
+    }
+    if (segments.pop() === undefined)
+      return;
+  }
+  const path = segments.join("/");
+  const bare = path.replace(/\.jsx?$/u, "");
+  return [path, `${bare}.tsx`, `${bare}.ts`, `${path}/index.tsx`, `${path}/index.ts`].find((candidate) => names.has(candidate));
+}
+function checkFile(file, source, names, errors, externals) {
+  let output;
+  try {
+    output = transform(source, {
+      transforms: file.endsWith(".tsx") ? ["typescript", "jsx"] : ["typescript"],
+      jsxRuntime: "automatic",
+      production: true,
+      filePath: file
+    }).code;
+  } catch (error) {
+    const message = error instanceof Error ? error.message.replace(`Error transforming ${file}: `, "") : String(error);
+    const position = POSITION.exec(message);
+    errors.push(at(file, position === null ? null : Number(position[1]), position === null ? null : Number(position[2]), message.replace(POSITION, "").trim()));
+    return;
+  }
+  const [imports, exports] = parse(output, file);
+  const injected = imports[0];
+  const prefix = injected !== undefined && injected.ss === 0 && injected.n === "react/jsx-runtime" && !source.startsWith(output.slice(0, injected.se)) ? injected.se + (output[injected.se] === ";" ? 1 : 0) : 0;
+  const unit = {
+    file,
+    output,
+    exports: exports.map((entry) => entry.n),
+    edits: [],
+    wants: []
+  };
+  for (const entry of imports)
+    checkImport(unit, entry, prefix, names, errors, externals);
+  for (const found of findLinkerNames(output)) {
+    const { line, column } = locate(output, found.offset, prefix);
+    errors.push(at(file, line, column, `Rename \`${found.name}\`: the module linker owns that name in a canvas file.`));
+  }
+  return unit;
+}
+function findLinkerNames(code) {
+  const found = [];
+  const scan = /\/\/[^\n]*|\/\*[\s\S]*?\*\/|"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'|`(?:\\.|[^`\\])*`|(?<!\.\s*)(?<![\w$])(exports|require)(?![\w$])(?!\s*:)/gu;
+  for (const match of code.matchAll(scan))
+    if (match[1] !== undefined)
+      found.push({ name: match[1], offset: match.index });
+  return found;
+}
+function checkImport(unit, entry, prefix, names, errors, externals) {
+  if (entry.d === -2)
+    return;
+  const { file, output } = unit;
+  const { line, column } = locate(output, entry.ss, prefix);
+  const statement = output.slice(entry.ss, entry.se);
+  const fail = (text) => {
+    errors.push(at(file, line, column, text));
+  };
+  if (statement.startsWith("export")) {
+    fail("A canvas cannot re-export from a module; import, then export your own names.");
+    return;
+  }
+  const specifier = entry.n;
+  if (specifier === undefined) {
+    fail(`A computed import() is not available; import ${IMPORTABLE} or a canvas file by a literal name.`);
+    return;
+  }
+  const relative = specifier.startsWith("./") || specifier.startsWith("../");
+  const target = relative ? resolveFile(file, specifier, names) : undefined;
+  const external = relative ? undefined : EXTERNAL.get(specifier);
+  if (relative && target === undefined) {
+    fail(`"${specifier}" is not one of this canvas's files; pass it in \`files\`.`);
+    return;
+  }
+  if (external === undefined && target === undefined) {
+    fail(`"${specifier}" is not available. A canvas can import ${IMPORTABLE} and its own files by relative path.`);
+    return;
+  }
+  if (external !== undefined)
+    externals.add(specifier);
+  if (target !== undefined) {
+    const quoted = output[entry.s] === '"' || output[entry.s] === "'";
+    unit.edits.push({
+      start: quoted ? entry.s + 1 : entry.s,
+      end: quoted ? entry.e - 1 : entry.e,
+      text: target
+    });
+  }
+  if (entry.d >= 0)
+    return;
+  const from = statement.lastIndexOf("from");
+  const bound = bindings(from === -1 ? "" : statement.slice("import".length, from));
+  if (bound === undefined) {
+    fail("This import could not be read; write it as `import X from`, `import * as X from` or `import { a, b as c } from`.");
+    return;
+  }
+  const named = bound.filter((binding) => binding.imported !== "default" && binding.imported !== "*").map((binding) => binding.imported);
+  if (target !== undefined) {
+    unit.wants.push({
+      target,
+      specifier,
+      names: bound.some((binding) => binding.imported === "default") ? [...named, "default"] : named,
+      line,
+      column
+    });
+    return;
+  }
+  for (const name of named)
+    if (!(external?.names ?? []).includes(name))
+      fail(`"${specifier}" has no export named "${name}".`);
+}
+function link(unit) {
+  let code = unit.output;
+  for (const edit of unit.edits.toSorted((left, right) => right.start - left.start))
+    code = `${code.slice(0, edit.start)}${edit.text}${code.slice(edit.end)}`;
+  return transform(code, { transforms: ["imports"], production: true, filePath: unit.file }).code;
+}
+async function compileCanvas2(source, files = {}, limits = {}) {
+  const sourceLimit = limits.source ?? CANVAS_SOURCE_LIMIT2;
+  const codeLimit = limits.code ?? CANVAS_CODE_LIMIT2;
+  const sources = [
+    [CANVAS_ENTRY2, source],
+    ...Object.entries(files).map(([name, text]) => [name.replace(/^\.\//u, ""), text])
+  ];
+  const bytes = sources.reduce((sum, [, text]) => sum + encoder.encode(text).byteLength, 0);
+  if (bytes > sourceLimit)
+    return failed([
+      at(null, null, null, `The source is over ${kb(sourceLimit)}; render less at once.`)
+    ]);
+  const errors = [];
+  const names = new Set;
+  for (const [name = ""] of sources) {
+    if (names.has(name))
+      errors.push(at(name, null, null, name === CANVAS_ENTRY2 ? `\`files\` cannot hold ${CANVAS_ENTRY2}; that is \`source\`.` : "This file is named twice."));
+    else if (!FILE_NAME.test(name))
+      errors.push(at(name, null, null, "A canvas file is a path inside the canvas, such as `chart.tsx` or `lib/scale.ts`."));
+    names.add(name);
+  }
+  if (errors.length > 0)
+    return failed(errors);
+  await init;
+  const externals = new Set;
+  const units = sources.flatMap(([name = "", text = ""]) => {
+    const unit = checkFile(name, text, names, errors, externals);
+    return unit === undefined ? [] : [unit];
+  });
+  const exported = new Map(units.map((unit) => [unit.file, unit.exports]));
+  for (const unit of units)
+    for (const want of unit.wants)
+      for (const name of want.names)
+        if (exported.get(want.target)?.includes(name) === false)
+          errors.push(at(unit.file, want.line, want.column, name === "default" ? `"${want.specifier}" has no default export.` : `"${want.specifier}" has no export named "${name}".`));
+  if (exported.get(CANVAS_ENTRY2)?.includes("default") === false)
+    errors.push(at(CANVAS_ENTRY2, null, null, "The module must `export default` a component."));
+  if (errors.length > 0)
+    return failed(errors);
+  const code = bundle(units, externals);
+  if (encoder.encode(code).byteLength > codeLimit)
+    return failed([
+      at(null, null, null, `The compiled canvas is over ${kb(codeLimit)}; render less at once.`)
+    ]);
+  return {
+    kind: "compiled",
+    code,
+    runtime: [...externals].some((name) => RUNTIME_2.has(name)) ? 2 : 1
+  };
+}
+function bundle(units, imported) {
+  const externals = [...EXTERNAL].filter(([name]) => imported.has(name)).map(([name, external]) => `${JSON.stringify(name)}: ${external.value}`);
+  const spans = [];
+  const body = [];
+  let line = 2;
+  for (const unit of units) {
+    const code = link(unit);
+    const lines = code.split(`
+`).length;
+    spans.push([unit.file, line + 1, lines]);
+    body.push(`${JSON.stringify(unit.file)}: function (exports, require) {`, code, "},");
+    line += lines + 2;
+  }
+  return [
+    `${canvasFilesComment2(spans)}const __external = { ${externals.join(", ")} }; const __files = {`,
+    ...body,
+    "}; const __modules = new Map();",
+    "function __require(name) { if (Object.hasOwn(__external, name)) return __external[name]; let found = __modules.get(name); if (found === undefined) { found = {}; __modules.set(name, found); __files[name](found, __require); } return found; }",
+    `export default __require(${JSON.stringify(CANVAS_ENTRY2)}).default;`,
+    ""
+  ].join(`
+`);
+}
+function kb(bytes) {
+  return `${Math.round(bytes / 1024)} KB`;
+}
+function failed(errors) {
+  return { kind: "failed", errors };
+}
+
+export { compileCanvas2 };

package/dist/chunks/billing-mvc33pv6.js

@@ -0,0 +1,36 @@
+import {
+  CANVAS_CODE_LIMIT2
+} from "./billing-bv5zr32b.js";
+
+// src/canvas/schema.ts
+import { definePart } from "@nyte-ai/core";
+import { standard } from "@nyte-ai/schema";
+import { Type } from "typebox";
+var state = standard(Type.Object({
+  runtime: Type.Integer({ minimum: 1 }),
+  title: Type.String({ minLength: 1, maxLength: 120 }),
+  code: Type.String({ maxLength: CANVAS_CODE_LIMIT2 }),
+  height: Type.Union([Type.Number(), Type.Null()]),
+  error: Type.Union([Type.String(), Type.Null()])
+}));
+var actions = {
+  replace: {
+    input: standard(Type.Object({
+      runtime: Type.Integer({ minimum: 1 }),
+      title: Type.String({ minLength: 1, maxLength: 120 }),
+      code: Type.String({ maxLength: CANVAS_CODE_LIMIT2 }),
+      height: Type.Union([Type.Number(), Type.Null()])
+    }))
+  },
+  report: {
+    input: standard(Type.Object({ message: Type.String({ minLength: 1, maxLength: 2000 }) }))
+  }
+};
+var canvas2 = definePart({
+  kind: "canvas",
+  state,
+  actions,
+  fallback: (current, { id }) => `Canvas ${id}: ${current.title}.${current.error === null ? "" : ` It failed to render: ${current.error}. Fix it by calling canvas_render with canvas "${id}".`}`
+});
+
+export { canvas2 };

package/dist/chunks/billing-s4rrspsk.js

@@ -0,0 +1,7 @@
+// examples/claude-code/env.ts
+function envFlagEnabled2(value) {
+  const normalized = value?.trim().toLowerCase();
+  return !!normalized && !["0", "false", "no", "off"].includes(normalized);
+}
+
+export { envFlagEnabled2 };

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 };