@nyte-ai/host 0.0.0-stage → 0.0.18

package/dist/chunks/canvas-preview-vax9ne4e.js

@@ -0,0 +1,341 @@
+import {
+  credentialStore2
+} from "./canvas-preview-518dh8by.js";
+import {
+  readErrorCode2
+} from "./canvas-preview-mgcx2b2p.js";
+import {
+  identitySigner2
+} from "./canvas-preview-5mex725c.js";
+import {
+  localGitHubAccount2
+} from "./canvas-preview-75db60xy.js";
+import {
+  localProvider2
+} from "./canvas-preview-yrfz2ak6.js";
+import {
+  importLegacyTrust2
+} from "./canvas-preview-9aqczacs.js";
+import {
+  migrateLocalWorkspaceIdentities2
+} from "./canvas-preview-4e0pxa32.js";
+import {
+  listen2
+} from "./canvas-preview-98aj5p34.js";
+import {
+  createMcpHub2
+} from "./canvas-preview-8xgt67ka.js";
+import {
+  loadPluginDirectory2,
+  pluginLoader2
+} from "./canvas-preview-s94ebwf5.js";
+import {
+  defaultSecrets2
+} from "./canvas-preview-skzwvw4d.js";
+import {
+  sqliteStore2
+} from "./canvas-preview-evh92ywd.js";
+import {
+  package_default
+} from "./canvas-preview-g3qj3y3k.js";
+
+// src/open.ts
+import { watch } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { defaultProviderAuthContext } from "@nyte-ai/ai/auth/context";
+import { FileModelsStore, nyteProviders } from "@nyte-ai/ai";
+import { createModels } from "@nyte-ai/ai/models";
+import { isJson } from "@nyte-ai/schema";
+import { serial } from "@nyte-ai/schema/serial";
+import { dev, processEnvironment } from "@nyte-ai/core";
+import { composeHost } from "@nyte-ai/core/server";
+import { readModelSelection } from "@nyte-ai/core/store";
+import approvals from "@nyte-ai/plugin/core/approvals";
+import { acpAgents } from "@nyte-ai/plugin/core/acp";
+import bashDescription from "@nyte-ai/plugin/core/bash-description";
+import browserTools from "@nyte-ai/plugin/core/browser-tools";
+import canvas from "@nyte-ai/plugin/core/canvas";
+import { claudeCodeSdk } from "@nyte-ai/plugin/core/claude-code-sdk";
+import codemode from "@nyte-ai/plugin/core/codemode";
+import openaiAstraContext from "@nyte-ai/plugin/core/openai-astra-context";
+import { openaiCompaction } from "@nyte-ai/plugin/core/openai-compaction";
+import question from "@nyte-ai/plugin/core/question";
+import rename from "@nyte-ai/plugin/core/rename";
+import telemetry from "@nyte-ai/plugin/core/telemetry";
+import webSearch from "@nyte-ai/plugin/core/web-search";
+var RELOAD_DEBOUNCE_MS = 250;
+var STORE_POLL_MS = 500;
+async function openHost2(options) {
+  const home = options.home ?? homedir();
+  const workspace = options.workspace ?? { kind: "local", path: process.cwd() };
+  if (options.store !== undefined)
+    return composeOpen(options, { home, workspace, store: options.store, owned: null });
+  const owned = await defaultStore(home);
+  try {
+    return await composeOpen(options, { home, workspace, store: owned, owned });
+  } catch (cause) {
+    await owned.close().catch(() => {
+      return;
+    });
+    throw cause;
+  }
+}
+async function defaultStore(home) {
+  await mkdir(join(home, ".nyte"), { recursive: true, mode: 448 });
+  return sqliteStore2({ path: join(home, ".nyte", "nyte.db") });
+}
+async function composeOpen(options, input) {
+  const { home, workspace, store, owned } = input;
+  const secrets = options.secrets ?? defaultSecrets2(home);
+  const description = hostDescription();
+  const given = options.plugins ?? [];
+  const usesLocalProvider = !given.some((plugin) => plugin.environment?.kind === "local");
+  const claudeCode = claudeCodeSdk();
+  const acp = acpAgents();
+  const [models, files, settings] = await Promise.all([
+    options.models ?? nyteModels({ store, secrets, home, providers: [claudeCode.provider, acp.provider] }),
+    filePlugins(home),
+    settingsSeed(home),
+    usesLocalProvider ? store.open().then(async (connection) => {
+      await migrateLocalWorkspaceIdentities2(connection);
+      await importLegacyTrust2(connection, home);
+    }) : undefined
+  ]);
+  const builtins = [
+    approvals,
+    question,
+    rename,
+    bashDescription,
+    webSearch,
+    codemode,
+    openaiCompaction(models),
+    openaiAstraContext,
+    telemetry,
+    canvas,
+    browserTools,
+    claudeCode.plugin,
+    acp.plugin
+  ];
+  const plugins = [
+    ...usesLocalProvider ? [{ id: "local", environment: localProvider2({ home, shell: options.shell }) }] : [],
+    ...builtins.filter((builtin) => !given.some((plugin) => plugin.id === builtin.id)),
+    ...given
+  ];
+  let projectDirs = async () => [];
+  const host = await composeHost({
+    ...options,
+    store,
+    workspace,
+    loadPlugins: async (paths) => pluginLoader2([...files.dirs, ...await projectDirs()])(paths),
+    models,
+    mcp: options.mcp ?? createMcpHub2({ home }),
+    github: options.github ?? (usesLocalProvider ? localGitHubAccount2({ home }) : undefined),
+    plugins: [...plugins, ...files.plugins],
+    pluginSources: files.sources,
+    secrets,
+    home,
+    description,
+    ...settings.seed === null ? {} : { seed: settings.seed },
+    ...owned === null ? {} : { poll: STORE_POLL_MS }
+  });
+  projectDirs = async () => (await host.workspaces.list()).flatMap((entry) => entry.trusted === true && ("path" in entry.target) ? [join(entry.target.path, ".nyte", "plugins")] : []);
+  for (const row of files.failed)
+    host.server.report(row);
+  if (settings.issue !== null)
+    host.server.report({
+      id: "settings",
+      source: "user",
+      path: settingsPath(home),
+      issues: [settings.issue]
+    });
+  dev("open", "host", {
+    home,
+    seedIds: Object.keys(settings.seed?.settings ?? {}).length,
+    pluginFiles: files.plugins.length + files.failed.length,
+    failedFiles: files.failed.length
+  });
+  const reported = new Map(host.server.pluginRows().filter((row) => row.path !== null && row.id === row.path).map((row) => [row.id, row]));
+  const reload = async () => {
+    const next = await filePlugins(home);
+    for (const [plugin, source] of next.sources)
+      files.sources.set(plugin, source);
+    const report = await host.plugins.replace([...plugins, ...next.plugins]);
+    const failed = [...next.failed, ...refused(next, report)];
+    for (const [id, row] of reported)
+      if (!failed.some((row) => row.id === id))
+        host.server.report({ ...row, issues: [] });
+    for (const row of failed)
+      host.server.report(row);
+    reported.clear();
+    for (const row of failed)
+      reported.set(row.id, row);
+    for (const plugin of files.sources.keys())
+      if (!host.server.loaded(plugin))
+        files.sources.delete(plugin);
+    dev("open", "plugins reloaded", {
+      generation: report.generation,
+      pluginFiles: next.plugins.length,
+      failedFiles: failed.length
+    });
+  };
+  const unwatch = watchPlugins(files.dirs, reload);
+  const listeners = new Set;
+  let identity = null;
+  const attach = async (listenOptions) => {
+    const listener = await listen2(host, {
+      describe: () => description,
+      ...listenOptions,
+      identity: listenOptions.identity ?? await (identity ??= identitySigner2(host.hostId, home))
+    });
+    listeners.add(listener);
+    dev("open", "listen", { address: listener.address });
+    return listener;
+  };
+  let closing = null;
+  const close = () => {
+    closing ??= (async () => {
+      await unwatch();
+      for (const listener of listeners)
+        await listener.close();
+      await host.close();
+      await owned?.close();
+    })();
+    return closing;
+  };
+  return { ...host, listen: attach, close, [Symbol.asyncDispose]: close };
+}
+async function nyteModels(input) {
+  const credentials = credentialStore2(input.store, input.secrets);
+  const auth = defaultProviderAuthContext();
+  const models = createModels({
+    credentials,
+    modelsStore: new FileModelsStore(join(input.home, ".nyte", "models-store.json")),
+    authContext: {
+      ...auth,
+      env: async (name) => {
+        await processEnvironment();
+        return auth.env(name);
+      }
+    },
+    catalog: { url: process.env.NYTE_MODELS_URL }
+  });
+  for (const provider of [...nyteProviders(), ...input.providers])
+    models.setProvider(provider);
+  const [stored, selected] = await Promise.all([
+    credentials.list(),
+    input.store.open().then(readModelSelection)
+  ]);
+  const restored = await models.refresh({
+    providers: [
+      ...new Set([
+        ...stored.map((row) => row.providerId),
+        ...input.providers.map((provider) => provider.id),
+        ...selected === null ? [] : [selected.provider]
+      ])
+    ],
+    allowNetwork: false
+  });
+  dev("open", "models restored", {
+    providers: stored.length,
+    failed: [...restored.errors.keys()]
+  });
+  return models;
+}
+async function filePlugins(home) {
+  const scopes = [{ source: "user", dir: join(home, ".nyte", "plugins") }];
+  const plugins = [];
+  const sources = new Map;
+  const failed = [];
+  for (const { source, dir } of scopes) {
+    const found = await loadPluginDirectory2(dir);
+    for (const { plugin, path } of found.loaded) {
+      plugins.push(plugin);
+      sources.set(plugin, { source, path });
+    }
+    for (const { path, issue } of found.failed)
+      failed.push({ id: path, source, path, issues: [issue] });
+  }
+  return { plugins, sources, dirs: scopes.map((scope) => scope.dir), failed };
+}
+function refused(files, report) {
+  return report.plugins.flatMap((outcome) => {
+    const plugin = files.plugins.find((candidate) => candidate.id === outcome.id);
+    const file = plugin === undefined ? undefined : files.sources.get(plugin);
+    return outcome.kind === "activated" || file === undefined ? [] : [{ id: file.path, source: file.source, path: file.path, issues: outcome.issues }];
+  });
+}
+function watchPlugins(dirs, reload) {
+  let timer = null;
+  const reloads = serial();
+  const run = () => {
+    timer = null;
+    reloads.run(reload).catch((error) => dev("open", "plugin reload failed", {
+      message: error instanceof Error ? error.message : String(error)
+    }));
+  };
+  const changed = () => {
+    if (timer !== null)
+      clearTimeout(timer);
+    timer = setTimeout(run, RELOAD_DEBOUNCE_MS);
+    timer.unref();
+  };
+  const watchers = dirs.flatMap((dir) => {
+    try {
+      const watcher = watch(dir, { recursive: true, persistent: false }, changed);
+      watcher.on("error", (error) => {
+        dev("open", "plugin watch failed", { dir, message: error.message });
+        watcher.close();
+      });
+      dev("open", "plugins watched", { dir });
+      return [watcher];
+    } catch (error) {
+      dev("open", "plugins unwatched", { dir, code: readErrorCode2(error) });
+      return [];
+    }
+  });
+  return async () => {
+    for (const watcher of watchers)
+      watcher.close();
+    if (timer !== null)
+      clearTimeout(timer);
+    await reloads.settled();
+  };
+}
+async function settingsSeed(home) {
+  const path = settingsPath(home);
+  const text = await readFile(path, "utf8").catch((error) => readErrorCode2(error) === "ENOENT" ? null : error instanceof Error ? error : new Error(String(error)));
+  if (text === null)
+    return { seed: null, issue: null };
+  if (text instanceof Error)
+    return {
+      seed: null,
+      issue: { severity: "warning", path: [], message: `${path} cannot be read: ${text.message}` }
+    };
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = undefined;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return {
+      seed: null,
+      issue: { severity: "warning", path: [], message: `${path} is not a JSON object.` }
+    };
+  const settings = {};
+  for (const [id, value] of Object.entries(parsed))
+    if (isJson(value))
+      settings[id] = value;
+  return { seed: { settings, path }, issue: null };
+}
+function hostDescription() {
+  return { name: hostname(), platform: process.platform, version: package_default.version };
+}
+function settingsPath(home) {
+  return join(home, ".nyte", "settings.json");
+}
+
+export { openHost2 };

package/dist/chunks/canvas-preview-wg80rbc2.js

@@ -0,0 +1,46 @@
+import {
+  readErrorCode2
+} from "./canvas-preview-mgcx2b2p.js";
+
+// src/key-file.ts
+import { link, mkdir, open, readFile, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+import { SdkError } from "@nyte-ai/schema";
+async function readKeyFile2(path, name) {
+  const bytes = await readFile(path).then((stored) => new Uint8Array(stored), (error) => {
+    if (readErrorCode2(error) === "ENOENT")
+      return mintKeyFile(path);
+    throw error;
+  }).catch((error) => {
+    throw new SdkError("unavailable", `The ${name} at ${path} cannot be read: ${error instanceof Error ? error.message : String(error)}`);
+  });
+  if (bytes.length !== 32)
+    throw new SdkError("invalid", `The ${name} at ${path} is ${bytes.length} bytes, not 32.`);
+  return bytes;
+}
+async function mintKeyFile(path) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  const temp = `${path}.${crypto.randomUUID()}`;
+  const file = await open(temp, "wx", 384);
+  try {
+    await file.writeFile(bytes);
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  try {
+    await link(temp, path);
+    return bytes;
+  } catch (error) {
+    if (readErrorCode2(error) !== "EEXIST")
+      throw error;
+    return new Uint8Array(await readFile(path));
+  } finally {
+    await unlink(temp).catch(() => {
+      return;
+    });
+  }
+}
+
+export { readKeyFile2 };