@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/chunks/billing-bv5zr32b.js

@@ -0,0 +1,369 @@
+import {
+  CANVAS_LIBRARIES2
+} from "./billing-zfpm2rt0.js";
+
+// src/canvas/canvas-protocol.ts
+var CANVAS_RUNTIME2 = 2;
+var CANVAS_GLOBAL2 = "__nyteCanvas";
+var KIT_SPECIFIER2 = "nyte/canvas";
+var CANVAS_ENTRY2 = "main.tsx";
+var CANVAS_SOURCE_LIMIT2 = 65536;
+var CANVAS_CODE_LIMIT2 = 196608;
+var CANVAS_MIN_HEIGHT2 = 48;
+var CANVAS_MAX_HEIGHT2 = 2000;
+var CANVAS_MIN_HEIGHT_HINT2 = 80;
+var CANVAS_DEFAULT_HEIGHT2 = 80;
+var REACT_EXPORTS2 = [
+  "Activity",
+  "Children",
+  "Component",
+  "Fragment",
+  "Profiler",
+  "PureComponent",
+  "StrictMode",
+  "Suspense",
+  "ViewTransition",
+  "addTransitionType",
+  "cache",
+  "cloneElement",
+  "createContext",
+  "createElement",
+  "createRef",
+  "forwardRef",
+  "isValidElement",
+  "lazy",
+  "memo",
+  "startTransition",
+  "use",
+  "useActionState",
+  "useCallback",
+  "useContext",
+  "useDebugValue",
+  "useDeferredValue",
+  "useEffect",
+  "useEffectEvent",
+  "useId",
+  "useImperativeHandle",
+  "useInsertionEffect",
+  "useLayoutEffect",
+  "useMemo",
+  "useOptimistic",
+  "useReducer",
+  "useRef",
+  "useState",
+  "useSyncExternalStore",
+  "useTransition"
+];
+var JSX_RUNTIME_EXPORTS2 = ["Fragment", "jsx", "jsxs"];
+var REACT_DOM_EXPORTS2 = ["createPortal", "flushSync"];
+var LIBRARY_EXPORTS2 = Object.fromEntries(Object.entries(CANVAS_LIBRARIES2).map(([name, library]) => [name, library.exports.split(" ")]));
+var LIBRARY_VERSIONS2 = Object.fromEntries(Object.entries(CANVAS_LIBRARIES2).map(([name, library]) => [name, library.version]));
+var FILES_COMMENT = /^\/\*nyte-canvas-files:(\[[^\n]*?\])\*\//u;
+function canvasFilesComment2(spans) {
+  return `/*nyte-canvas-files:${JSON.stringify(spans)}*/`;
+}
+function locateCanvasStack2(code, stack) {
+  const comment = FILES_COMMENT.exec(code);
+  if (comment === null)
+    return;
+  const spans = parseSpans(comment[1] ?? "");
+  for (const frame of stack.matchAll(/blob:[^\s)]+:(\d+):\d+/gu)) {
+    const line = Number(frame[1]);
+    const span = spans.find(([, start, lines]) => line >= start && line < start + lines);
+    if (span !== undefined)
+      return `${span[0]}:${line - span[1] + 1}`;
+  }
+  return;
+}
+function parseSpans(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed.flatMap((entry) => Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "number" && typeof entry[2] === "number" ? [[entry[0], entry[1], entry[2]]] : []) : [];
+  } catch {
+    return [];
+  }
+}
+var TINTS2 = [
+  "blue",
+  "pink",
+  "orange",
+  "teal",
+  "red",
+  "yellow",
+  "purple",
+  "green",
+  "gray",
+  "brown"
+];
+var KIT2 = {
+  Stack: '{ direction?: "row" | "column" = "column", gap?: 0 | 1 | 2 | 3 | 4 | 6 = 2 (×4 px), align?: "start" | "center" | "end" | "stretch", justify?: "start" | "center" | "end" | "between", wrap?: boolean, children }: flex layout',
+  Grid: '{ columns?: number | "auto" = "auto", minWidth?: number = 160 (px, with "auto"), gap?: 0 | 1 | 2 | 3 | 4 | 6 = 2, children }: equal columns',
+  Divider: "{}: a hairline",
+  Heading: "{ level?: 1 | 2 | 3 = 2, children }",
+  Text: '{ size?: "xs" | "sm" | "base" | "lg", tone?: "primary" | "secondary" | "tertiary", weight?: "normal" | "medium" | "semibold", mono?: boolean, truncate?: boolean, align?: "start" | "center" | "end", children }',
+  Code: "{ block?: boolean, children: string }: monospace, inline or a block",
+  Stat: '{ label: string, value: ReactNode, detail?: ReactNode, tone?: "neutral" | "success" | "warning" | "danger" }: a labelled number',
+  Badge: '{ tone?: "neutral" | "info" | "success" | "warning" | "danger", children }',
+  Meter: '{ value: number, max?: number = 100, label?: string, tone?: "primary" | "success" | "warning" | "danger" = "primary" }: a thin filled bar with the value beside the label',
+  Table: '{ columns: { key: string, label: ReactNode, align?: "start" | "end", width?: number | string }[], rows: Record<string, ReactNode>[], caption?: string }: rows are keyed by column key; a cell can hold a Sparkline or a Badge',
+  Callout: '{ tone?: "info" | "success" | "warning" | "danger", title?: string, children }',
+  Card: "{ title?: ReactNode, actions?: ReactNode, padding?: 0 | 2 | 3 | 4 = 4, children }: an elevated bordered surface",
+  StackedBars: "{ label: string, series: { key: string, label: string, tint: Tint }[], buckets: { key: string, label: string, values: number[] }[], format: (value: number) => string, height?: number = 88, ticks?: number = 5 }: compact stacked bars without axes, a readout on pointer or arrow keys; the numbers live in the copy around it. Preferred beside a Stat or a heading figure",
+  Sparkline: "{ values: number[], tint?: Tint, label?: string, width?: number = 72, height?: number = 20 }: a row's trend scaled to its own peak, for a Table cell beside the row's number",
+  LineChart: '{ series: { id: string, data: { x: number | string, y: number }[], tint?: Tint }[], height?: number = 240, xFormat?: (x) => string, yFormat?: (y) => string, curve?: "linear" | "monotone" | "step", area?: boolean, legend?: boolean }: a full chart with axes and a readout',
+  BarChart: '{ data: Record<string, number | string>[], keys: (string | { key: string, label?: string, tint?: Tint })[], indexBy: string, height?: number = 240, layout?: "vertical" | "horizontal", mode?: "grouped" | "stacked" = "stacked", valueFormat?: (value: number) => string, legend?: boolean }: a full chart with axes and a readout with the total',
+  PieChart: "{ data: { id: string, value: number, label?: string, tint?: Tint }[], height?: number = 240, donut?: boolean, valueFormat?: (value: number) => string, legend?: boolean }",
+  Button: '{ variant?: "solid" | "outline" | "ghost" | "pill" | "chip", size?: "2xs" | "xs" | "sm" | "md" | "lg" | "xl", tone?: "neutral" | "primary" | "success" | "warning" | "danger", loading?: boolean, disabled?: boolean, onClick, children }',
+  Tabs: "Tabs.Root { value?, defaultValue?, onValueChange? } > Tabs.List { children: Tabs.Tab { value, children }[] } + Tabs.Panel { value, children }",
+  Select: "Select { value?, defaultValue?, onValueChange? } > SelectTrigger { children: <SelectValue /> } + SelectContent { children: SelectItem[] }",
+  SelectTrigger: "see Select",
+  SelectValue: "see Select",
+  SelectContent: "see Select",
+  SelectItem: "{ value: string, children }",
+  ToggleGroup: "{ value?: string[], defaultValue?: string[], onValueChange?: (value: string[]) => void, multiple?: boolean, children: Toggle[] }",
+  Toggle: "{ value: string, size?: as Button, tone?: as Button, children }",
+  Switch: "{ label: string, checked?, defaultChecked?, onCheckedChange?: (checked: boolean) => void, disabled? }",
+  Checkbox: "{ checked?, defaultChecked?, indeterminate?, onCheckedChange?: (checked: boolean) => void, disabled? }",
+  Slider: "Slider.Root { value?, defaultValue?, onValueChange?, min?, max?, step? } > Slider.Control > Slider.Track > Slider.Indicator + Slider.Thumb",
+  Tooltip: "Tooltip > TooltipTrigger { render?: ReactElement, children } + TooltipContent { side?, children }",
+  TooltipTrigger: "see Tooltip",
+  TooltipContent: "see Tooltip",
+  Collapsible: "Collapsible.Root { open?, defaultOpen?, onOpenChange? } > Collapsible.Trigger { children } + Collapsible.Panel { children }",
+  Kbd: "{ keys: string[] }",
+  Spinner: "{}",
+  useColorScheme: '(): "light" | "dark"'
+};
+var KIT_EXPORTS2 = Object.keys(KIT2);
+var CANVAS_VARIABLES2 = [
+  "--nyte-custom-hue",
+  "--nyte-custom-chroma-scale",
+  "--nyte-font-family-sans",
+  "--nyte-font-family-mono",
+  "--nyte-font-size-base",
+  "--nyte-font-size-code",
+  "--nyte-letter-spacing-lg",
+  "--nyte-font-smoothing",
+  "--nyte-moz-font-smoothing",
+  "--nyte-reduce-transparency"
+];
+var CANVAS_PROTOCOL_VERSION2 = "2026-01-26";
+var INITIALIZE = "ui/initialize";
+var INITIALIZED = "ui/notifications/initialized";
+var SIZE_CHANGED = "ui/notifications/size-changed";
+var OPEN_LINK = "ui/open-link";
+var LOG_MESSAGE = "notifications/message";
+var HOST_CONTEXT_CHANGED = "ui/notifications/host-context-changed";
+var RENDER = "nyte/notifications/render";
+function initializeRequest2(id, runtime) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    method: INITIALIZE,
+    params: {
+      protocolVersion: CANVAS_PROTOCOL_VERSION2,
+      appInfo: { name: "nyte-canvas", version: String(runtime) },
+      appCapabilities: {}
+    }
+  };
+}
+function initializedNotification2() {
+  return { jsonrpc: "2.0", method: INITIALIZED, params: {} };
+}
+function sizeChangedNotification2(height) {
+  return { jsonrpc: "2.0", method: SIZE_CHANGED, params: { height } };
+}
+function openLinkRequest2(id, url) {
+  return { jsonrpc: "2.0", id, method: OPEN_LINK, params: { url } };
+}
+function errorNotification2(error) {
+  return {
+    jsonrpc: "2.0",
+    method: LOG_MESSAGE,
+    params: {
+      level: "error",
+      logger: "nyte-canvas",
+      data: {
+        phase: error.phase,
+        message: error.message,
+        ...error.stack === undefined ? {} : { stack: error.stack }
+      }
+    }
+  };
+}
+function initializeResult2(id, hostInfo, hostContext) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    result: {
+      protocolVersion: CANVAS_PROTOCOL_VERSION2,
+      hostInfo,
+      hostCapabilities: {},
+      hostContext: contextJson(hostContext)
+    }
+  };
+}
+function renderNotification2(module) {
+  return {
+    jsonrpc: "2.0",
+    method: RENDER,
+    params: { runtime: module.runtime, code: module.code, title: module.title }
+  };
+}
+function hostContextChangedNotification2(context) {
+  return { jsonrpc: "2.0", method: HOST_CONTEXT_CHANGED, params: contextJson(context) };
+}
+function openLinkResult2(id, isError = false) {
+  return { jsonrpc: "2.0", id, result: isError ? { isError: true } : {} };
+}
+function readShellMessage2(data) {
+  const message = envelope(data);
+  if (message === undefined)
+    return;
+  const { id, method, params } = message;
+  if (method === INITIALIZE && id !== undefined) {
+    const info = record(params?.["appInfo"]);
+    const runtime = info === undefined ? NaN : Number(info["version"]);
+    return Number.isInteger(runtime) && runtime > 0 ? { kind: "initialize", id, runtime } : undefined;
+  }
+  if (method === INITIALIZED)
+    return { kind: "initialized" };
+  if (method === SIZE_CHANGED) {
+    const height = params?.["height"];
+    return typeof height === "number" && Number.isFinite(height) && height > 0 ? { kind: "size", height } : undefined;
+  }
+  if (method === OPEN_LINK && id !== undefined) {
+    const url = linkHref(params?.["url"]);
+    return url === undefined ? undefined : { kind: "open-link", id, url };
+  }
+  if (method === LOG_MESSAGE) {
+    const payload = record(params?.["data"]);
+    const phase = payload?.["phase"];
+    const text = payload?.["message"];
+    const stack = payload?.["stack"];
+    if (params?.["level"] !== "error" || phase !== "load" && phase !== "render" || typeof text !== "string")
+      return;
+    return { kind: "error", phase, message: text, stack: typeof stack === "string" ? stack : null };
+  }
+  return;
+}
+function readHostMessage2(data) {
+  const message = envelope(data);
+  if (message === undefined)
+    return;
+  const { id, method, params, result } = message;
+  if (method === undefined && id !== undefined && result !== undefined) {
+    if (result["hostContext"] === undefined)
+      return { kind: "open-link-result", id, isError: result["isError"] === true };
+    const info = record(result["hostInfo"]);
+    const context = readContext(result["hostContext"]);
+    const name = info?.["name"];
+    const version = info?.["version"];
+    if (context === undefined || typeof version !== "string" || name !== "nyte-desktop" && name !== "nyte-web" && name !== "nyte-ios" && name !== "nyte-preview")
+      return;
+    return { kind: "initialize-result", id, hostInfo: { name, version }, hostContext: context };
+  }
+  if (method === RENDER) {
+    const runtime = params?.["runtime"];
+    const code = params?.["code"];
+    const title = params?.["title"];
+    return Number.isInteger(runtime) && typeof runtime === "number" && runtime > 0 && typeof code === "string" && typeof title === "string" ? { kind: "render", module: { runtime, code, title } } : undefined;
+  }
+  if (method === HOST_CONTEXT_CHANGED) {
+    const context = readPartialContext(params);
+    return context === undefined ? undefined : { kind: "context-changed", context };
+  }
+  return;
+}
+function clampCanvasHeight2(height) {
+  return Math.min(CANVAS_MAX_HEIGHT2, Math.max(CANVAS_MIN_HEIGHT2, Math.round(height)));
+}
+function sanitizeCanvasVariables2(variables) {
+  const allowed = CANVAS_VARIABLES2;
+  return Object.fromEntries(Object.entries(variables).filter(([name]) => allowed.includes(name)).map(([name, value]) => [name, value.replace(/[;{}<>]/g, "")]));
+}
+function contextJson(context) {
+  return {
+    ...context.theme === undefined ? {} : { theme: context.theme },
+    ...context.styles === undefined ? {} : { styles: { variables: context.styles.variables } },
+    ...context.displayMode === undefined ? {} : { displayMode: context.displayMode },
+    ...context.platform === undefined ? {} : { platform: context.platform },
+    ...context.deviceCapabilities === undefined ? {} : {
+      deviceCapabilities: {
+        touch: context.deviceCapabilities.touch,
+        hover: context.deviceCapabilities.hover
+      }
+    }
+  };
+}
+function readPartialContext(value) {
+  const params = record(value);
+  if (params === undefined)
+    return;
+  const theme = params["theme"];
+  const styles = record(params["styles"]);
+  const variables = styles === undefined ? undefined : record(styles["variables"]);
+  const platform = params["platform"];
+  const capabilities = record(params["deviceCapabilities"]);
+  const touch = capabilities?.["touch"];
+  const hover = capabilities?.["hover"];
+  if (theme !== undefined && theme !== "light" && theme !== "dark")
+    return;
+  if (styles !== undefined && variables === undefined)
+    return;
+  if (params["displayMode"] !== undefined && params["displayMode"] !== "inline")
+    return;
+  if (platform !== undefined && platform !== "desktop" && platform !== "web" && platform !== "mobile")
+    return;
+  if (capabilities !== undefined && (typeof touch !== "boolean" || typeof hover !== "boolean"))
+    return;
+  return {
+    ...theme === undefined ? {} : { theme },
+    ...variables === undefined ? {} : { styles: { variables: sanitizeCanvasVariables2(stringEntries(variables)) } },
+    ...params["displayMode"] === undefined ? {} : { displayMode: "inline" },
+    ...platform === undefined ? {} : { platform },
+    ...typeof touch !== "boolean" || typeof hover !== "boolean" ? {} : { deviceCapabilities: { touch, hover } }
+  };
+}
+function readContext(value) {
+  const partial = readPartialContext(value);
+  return partial?.theme !== undefined && partial.styles !== undefined && partial.displayMode !== undefined && partial.platform !== undefined && partial.deviceCapabilities !== undefined ? {
+    theme: partial.theme,
+    styles: partial.styles,
+    displayMode: partial.displayMode,
+    platform: partial.platform,
+    deviceCapabilities: partial.deviceCapabilities
+  } : undefined;
+}
+function envelope(data) {
+  const message = record(data);
+  if (message === undefined || message["jsonrpc"] !== "2.0")
+    return;
+  const id = message["id"];
+  const method = message["method"];
+  if (method !== undefined && typeof method !== "string")
+    return;
+  return {
+    id: typeof id === "string" || typeof id === "number" ? id : undefined,
+    method,
+    params: record(message["params"]),
+    result: record(message["result"])
+  };
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : undefined;
+}
+function stringEntries(value) {
+  return Object.fromEntries(Object.entries(value).flatMap(([name, text]) => typeof text === "string" ? [[name, text]] : []));
+}
+function linkHref(value) {
+  if (typeof value !== "string" || value === "")
+    return;
+  const scheme = /^([a-z][a-z\d+-]*):/iu.exec(value)?.[1]?.toLowerCase();
+  if (scheme === undefined)
+    return value;
+  if (scheme !== "http" && scheme !== "https")
+    return;
+  return URL.parse(value)?.href;
+}
+
+export { CANVAS_RUNTIME2, CANVAS_GLOBAL2, KIT_SPECIFIER2, CANVAS_ENTRY2, CANVAS_SOURCE_LIMIT2, CANVAS_CODE_LIMIT2, CANVAS_MIN_HEIGHT2, CANVAS_MAX_HEIGHT2, CANVAS_MIN_HEIGHT_HINT2, CANVAS_DEFAULT_HEIGHT2, REACT_EXPORTS2, JSX_RUNTIME_EXPORTS2, REACT_DOM_EXPORTS2, LIBRARY_EXPORTS2, LIBRARY_VERSIONS2, canvasFilesComment2, locateCanvasStack2, TINTS2, KIT2, KIT_EXPORTS2, CANVAS_VARIABLES2, CANVAS_PROTOCOL_VERSION2, initializeRequest2, initializedNotification2, sizeChangedNotification2, openLinkRequest2, errorNotification2, initializeResult2, renderNotification2, hostContextChangedNotification2, openLinkResult2, readShellMessage2, readHostMessage2, clampCanvasHeight2, sanitizeCanvasVariables2 };

package/dist/chunks/billing-cy1rg619.js

@@ -0,0 +1,302 @@
+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 };