@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/chunks/billing-k2p1t25n.js

@@ -0,0 +1,109 @@
+// src/acp/registry.ts
+import { constants } from "node:fs";
+import { access, readFile, realpath } from "node:fs/promises";
+import { basename, delimiter, dirname, join } from "node:path";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var launch = {
+  args: Type.Optional(Type.Array(Type.String())),
+  env: Type.Optional(Type.Record(Type.String(), Type.String()))
+};
+var registryAgent = Type.Object({
+  id: Type.String({ minLength: 1 }),
+  name: Type.String({ minLength: 1 }),
+  distribution: Type.Object({
+    binary: Type.Optional(Type.Record(Type.String(), Type.Object({ cmd: Type.String({ minLength: 1 }), ...launch }))),
+    npx: Type.Optional(Type.Object({ package: Type.String({ minLength: 1 }), ...launch }))
+  })
+});
+var registry = Type.Object({ agents: Type.Array(Type.Unknown()) });
+var packageBin = Type.Object({
+  bin: Type.Union([Type.String(), Type.Record(Type.String(), Type.String())])
+});
+var PACKAGE = /^(@?[^@]+)@[^@]+$/;
+function registryEntries2(document) {
+  return Value.Check(registry, document) ? document.agents : [];
+}
+function platformTarget() {
+  const os = process.platform === "win32" ? "windows" : process.platform;
+  const arch = process.arch === "arm64" ? "aarch64" : process.arch === "x64" ? "x86_64" : process.arch;
+  return `${os}-${arch}`;
+}
+async function executable(path) {
+  try {
+    await access(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findOnPath(name, path) {
+  const names = process.platform === "win32" ? [`${name}.exe`, `${name}.cmd`, name] : [name];
+  for (const dir of path.split(delimiter))
+    for (const candidate of names)
+      if (dir !== "" && await executable(join(dir, candidate)))
+        return join(dir, candidate);
+  return;
+}
+async function resolved(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return;
+  }
+}
+async function globalBin(spec, path) {
+  const name = PACKAGE.exec(spec)?.[1] ?? spec;
+  const npx = await findOnPath("npx", path);
+  if (npx === undefined)
+    return;
+  const bin = dirname(npx);
+  const windows = process.platform === "win32";
+  const modules = windows ? join(bin, "node_modules") : join(dirname(bin), "lib", "node_modules");
+  const root = join(modules, name);
+  let manifest;
+  try {
+    manifest = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+  } catch {
+    return;
+  }
+  if (!Value.Check(packageBin, manifest))
+    return;
+  const [command, target] = typeof manifest.bin === "string" ? [basename(name), manifest.bin] : Object.entries(manifest.bin).find(([key]) => key !== "") ?? [];
+  if (command === undefined || target === undefined)
+    return;
+  if (windows) {
+    const shim = join(bin, `${command}.cmd`);
+    const text = await readFile(shim, "utf8").catch(() => "");
+    return text.includes(`node_modules\\${name.replaceAll("/", "\\")}\\`) ? shim : undefined;
+  }
+  const linked = join(bin, command);
+  const [from, to] = await Promise.all([resolved(linked), resolved(join(root, target))]);
+  return from !== undefined && from === to && await executable(linked) ? linked : undefined;
+}
+async function installed(agent, path) {
+  const binary = agent.distribution.binary?.[platformTarget()];
+  if (binary !== undefined) {
+    const command = await findOnPath(basename(binary.cmd).replace(/\.exe$/, ""), path);
+    if (command !== undefined)
+      return {
+        id: agent.id,
+        name: agent.name,
+        command,
+        args: binary.args ?? [],
+        env: binary.env ?? {}
+      };
+  }
+  const npx = agent.distribution.npx;
+  if (npx === undefined)
+    return;
+  const command = await globalBin(npx.package, path);
+  return command === undefined ? undefined : { id: agent.id, name: agent.name, command, args: npx.args ?? [], env: npx.env ?? {} };
+}
+async function installedAgents2(entries, path) {
+  const agents = entries.filter((entry) => Value.Check(registryAgent, entry));
+  const found = await Promise.all(agents.map((agent) => installed(agent, path)));
+  return found.filter((agent) => agent !== undefined);
+}
+
+export { registryEntries2, installedAgents2 };

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