@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/node/index.d.mts

@@ -0,0 +1,73 @@
+export * as Actions from "../actions/index.mjs";
+export {
+  createMemoryChatGptSubscriptionStore,
+  subscriptionRevision,
+} from "../runtime/subscription-store.mjs";
+export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
+export {
+  createTempoProvider,
+  createTempoProviderFromAccounts,
+  DEFAULT_MERCATOR_MCP_URL,
+} from "../runtime/tempo-provider.mjs";
+export type {
+  AccountsTempoProviderOptions,
+  AccountsWallet,
+  TempoProvider,
+} from "../runtime/tempo-provider.mjs";
+export type {
+  AgentEvent,
+  AgentLifecycle,
+  AgentSessionContext,
+  CompactionInstructionContext,
+  CompactionInstructionResolver,
+  CompactionItemIdentity,
+  CompactionOutcome,
+  CompactionReplacedEventPayload,
+  ChatGptCredential,
+  ChatGptCredentialSeed,
+  ChatGptLoginStatus,
+  ChatGptSubscriptionHandle,
+  ChatGptSubscriptionOptions,
+  ChatGptSubscriptionStore,
+  CostStatus,
+  CodeEvaluator,
+  CodeEvaluatorEnvironment,
+  EstimatedUsdCost,
+  HistoryContentItem,
+  HistoryItem,
+  HistorySeed,
+  PromptInput,
+  PromptItem,
+  LifecycleTurn,
+  LifecycleTurnResult,
+  ReasoningMode,
+  SessionSnapshot,
+  Thinking,
+  CustomToolFormat,
+  Tool,
+  NamedTool,
+  ToolDefinition,
+  ToolJson,
+  ToolContext,
+  SubagentToolContext,
+  ToolConfiguration,
+  ToolMap,
+  Turn,
+  TurnResult,
+  TurnUsage,
+  McpPayment,
+  McpServer,
+  McpServers,
+  MemoryChatGptSubscriptionStore,
+  MppSession,
+  SubscriptionCommitRequest,
+  SubscriptionCommitResult,
+  SubscriptionRevision,
+  SubscriptionStoredValue,
+} from "../types.mjs";
+export * as Agent from "./Agent.mjs";
+export * as ChatGptSubscription from "./ChatGptSubscription.mjs";
+export * as Subagents from "../runtime/subagents.mjs";
+export * as Transport from "./Transport.mjs";
+export * as Workspace from "./workspace.mjs";
+export * as Tools from "../tools/index.mjs";

package/vendor/nanocodex/node/index.mjs

@@ -0,0 +1,17 @@
+export * as Actions from "../actions/index.mjs";
+export {
+  createMemoryChatGptSubscriptionStore,
+  subscriptionRevision,
+} from "../runtime/subscription-store.mjs";
+export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
+export {
+  createTempoProvider,
+  createTempoProviderFromAccounts,
+  DEFAULT_MERCATOR_MCP_URL,
+} from "../runtime/tempo-provider.mjs";
+export * as Agent from "./Agent.mjs";
+export * as ChatGptSubscription from "./ChatGptSubscription.mjs";
+export * as Subagents from "../runtime/subagents.mjs";
+export * as Transport from "./Transport.mjs";
+export * as Workspace from "./workspace.mjs";
+export * as Tools from "../tools/index.mjs";

package/vendor/nanocodex/node/workspace.d.mts

@@ -0,0 +1,10 @@
+import type { Workspace, WorkspaceBackend, WorkspaceEntry } from "../runtime/workspace.mjs";
+
+export { tools } from "../runtime/workspace.mjs";
+
+export function open(options: {
+  path: string;
+  root?: string;
+}): Promise<Workspace>;
+
+export type { Workspace, WorkspaceBackend, WorkspaceEntry };

package/vendor/nanocodex/node/workspace.mjs

@@ -0,0 +1,198 @@
+import { randomUUID } from "node:crypto";
+import {
+  lstat,
+  mkdir,
+  open as openFile,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  unlink,
+} from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+
+import { createWorkspace, normalizeRelativePath, tools } from "../runtime/workspace.mjs";
+
+export { tools };
+
+export async function open(options = {}) {
+  if (typeof options.path !== "string" || !options.path) {
+    throw new TypeError("Node workspace path must be a non-empty string");
+  }
+  const directory = resolve(options.path);
+  const logicalRoot = options.root ?? "/workspace";
+  try {
+    await mkdir(directory, { recursive: true });
+  } catch (error) {
+    throw privatePathError(error, directory, logicalRoot);
+  }
+  let metadata;
+  try {
+    metadata = await lstat(directory);
+  } catch (error) {
+    throw privatePathError(error, directory, logicalRoot);
+  }
+  if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+    throw new Error("Node workspace path must be a real directory");
+  }
+  return createWorkspace({
+    root: logicalRoot,
+    backend: nodeBackend(directory, logicalRoot),
+  });
+}
+
+function nodeBackend(root, logicalRoot) {
+  const backend = {
+    async list(path, { recursive, maxEntries }) {
+      const directory = await resolveDirectory(root, path, false);
+      const output = [];
+      await listDirectory(root, directory, path, recursive, maxEntries, output);
+      return output.sort((left, right) => left.path.localeCompare(right.path));
+    },
+    async readFile(path) {
+      return new Uint8Array(await readFile(await resolveFile(root, path)));
+    },
+    async writeFile(path, contents) {
+      const { directory, name } = await resolveParent(root, path, true);
+      const target = join(directory, name);
+      await rejectSymlink(target, { displayPath: path, optional: true });
+      const temporary = join(directory, `.nanocodex-${randomUUID()}.tmp`);
+      const handle = await openFile(temporary, "wx", 0o600);
+      try {
+        await handle.writeFile(contents);
+        await handle.close();
+        await rename(temporary, target);
+      } catch (error) {
+        await handle.close().catch(() => {});
+        await unlink(temporary).catch(() => {});
+        throw error;
+      }
+    },
+    async remove(path, { recursive }) {
+      const { directory, name } = await resolveParent(root, path, false);
+      const target = join(directory, name);
+      await rejectSymlink(target, { displayPath: path });
+      await rm(target, { recursive, force: false });
+    },
+    async mkdir(path) {
+      await resolveDirectory(root, path, true);
+    },
+  };
+  return Object.fromEntries(Object.entries(backend).map(([name, operation]) => [
+    name,
+    async (...args) => {
+      try {
+        return await operation(...args);
+      } catch (error) {
+        throw privatePathError(error, root, logicalRoot);
+      }
+    },
+  ]));
+}
+
+async function listDirectory(root, directory, prefix, recursive, maxEntries, output) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    if (output.length >= maxEntries) {
+      throw new RangeError(`workspace listing exceeds ${maxEntries} entries`);
+    }
+    if (entry.isSymbolicLink()) {
+      throw new Error(`workspace refuses symbolic link: ${displayRelative(prefix, entry.name)}`);
+    }
+    const path = displayRelative(prefix, entry.name);
+    const absolute = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      output.push({ kind: "directory", path });
+      if (recursive) await listDirectory(root, absolute, path, true, maxEntries, output);
+      continue;
+    }
+    if (!entry.isFile()) throw new Error(`unsupported workspace entry: ${path}`);
+    const metadata = await lstat(absolute);
+    output.push({
+      kind: "file",
+      modifiedAt: metadata.mtimeMs,
+      path,
+      size: metadata.size,
+    });
+  }
+}
+
+async function resolveFile(root, path) {
+  const { directory, name } = await resolveParent(root, path, false);
+  const target = join(directory, name);
+  const metadata = await rejectSymlink(target, { displayPath: path });
+  if (!metadata.isFile()) throw new Error(`workspace path is not a file: ${path}`);
+  return target;
+}
+
+async function resolveParent(root, path, create) {
+  const relative = normalizeRelativePath(path);
+  const segments = relative.split("/");
+  const name = segments.pop();
+  if (!name) throw new Error("workspace file path cannot be empty");
+  return {
+    directory: await resolveDirectory(root, segments.join("/"), create),
+    name,
+  };
+}
+
+async function resolveDirectory(root, path, create) {
+  let directory = root;
+  const relative = normalizeRelativePath(path);
+  if (!relative) return directory;
+  for (const segment of relative.split("/")) {
+    directory = join(directory, segment);
+    let metadata;
+    try {
+      metadata = await lstat(directory);
+    } catch (error) {
+      if (error?.code !== "ENOENT" || !create) throw error;
+      await mkdir(directory);
+      metadata = await lstat(directory);
+    }
+    if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+      throw new Error(`workspace directory path is unsafe: ${path}`);
+    }
+  }
+  assertInside(root, directory);
+  return directory;
+}
+
+async function rejectSymlink(path, { displayPath = path, optional = false } = {}) {
+  try {
+    const metadata = await lstat(path);
+    if (metadata.isSymbolicLink()) {
+      throw new Error(`workspace refuses symbolic link: ${displayPath}`);
+    }
+    return metadata;
+  } catch (error) {
+    if (optional && error?.code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+function assertInside(root, path) {
+  const descendant = relative(root, path);
+  if (
+    !isAbsolute(root)
+    || descendant === ".."
+    || descendant.startsWith(`..${sep}`)
+    || isAbsolute(descendant)
+  ) {
+    throw new Error("workspace path escaped its root");
+  }
+}
+
+function privatePathError(error, nativeRoot, logicalRoot) {
+  if (!(error instanceof Error) || !error.message.includes(nativeRoot)) return error;
+  const sanitized = new Error(error.message.split(nativeRoot).join(logicalRoot));
+  sanitized.name = error.name;
+  for (const property of ["code", "errno", "syscall"]) {
+    if (property in error) sanitized[property] = error[property];
+  }
+  return sanitized;
+}
+
+function displayRelative(prefix, name) {
+  return prefix ? `${prefix}/${name}` : name;
+}

package/vendor/nanocodex/package.json

@@ -0,0 +1,200 @@
+{
+  "name": "nanocodex",
+  "version": "0.5.0",
+  "description": "Viem-style Node and browser bindings for the Nanocodex WASM agent",
+  "type": "module",
+  "sideEffects": [
+    "./tools/browser/browserBuffer.mjs"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.mts",
+      "import": "./index.mjs"
+    },
+    "./node": {
+      "types": "./node/index.d.mts",
+      "import": "./node/index.mjs"
+    },
+    "./node/workspace": {
+      "types": "./node/workspace.d.mts",
+      "import": "./node/workspace.mjs"
+    },
+    "./node/transport": {
+      "types": "./node/Transport.d.mts",
+      "import": "./node/Transport.mjs"
+    },
+    "./browser": {
+      "types": "./browser/index.d.mts",
+      "import": "./browser/index.mjs"
+    },
+    "./browser/workspace": {
+      "types": "./browser/workspace.d.mts",
+      "import": "./browser/workspace.mjs"
+    },
+    "./browser/transport": {
+      "types": "./browser/Transport.d.mts",
+      "import": "./browser/Transport.mjs"
+    },
+    "./browser/voice": {
+      "types": "./browser/Voice.d.mts",
+      "import": "./browser/Voice.mjs"
+    },
+    "./workspace": {
+      "types": "./runtime/workspace.d.mts",
+      "import": "./runtime/workspace.mjs"
+    },
+    "./host": {
+      "types": "./host/index.d.mts",
+      "import": "./host/index.mjs"
+    },
+    "./cloudflare": {
+      "types": "./cloudflare/index.d.mts",
+      "import": "./cloudflare/index.mjs"
+    },
+    "./cloudflare/egress": {
+      "types": "./cloudflare/egress.d.mts",
+      "import": "./cloudflare/egress.mjs"
+    },
+    "./managed": {
+      "types": "./managed/index.d.mts",
+      "import": "./managed/index.mjs"
+    },
+    "./connect": {
+      "types": "./cloud/index.d.mts",
+      "import": "./cloud/index.mjs"
+    },
+    "./connect/actions": {
+      "types": "./cloud/actions/index.d.mts",
+      "import": "./cloud/actions/index.mjs"
+    },
+    "./connect/server": {
+      "types": "./cloud/server/index.d.mts",
+      "import": "./cloud/server/index.mjs"
+    },
+    "./durability": {
+      "types": "./runtime/durability-store.d.mts",
+      "import": "./runtime/durability-store.mjs"
+    },
+    "./durability/postgres": {
+      "types": "./runtime/postgres-durability-store.d.mts",
+      "import": "./runtime/postgres-durability-store.mjs"
+    },
+    "./durability/cloudflare": {
+      "types": "./runtime/cloudflare-durability-store.d.mts",
+      "import": "./runtime/cloudflare-durability-store.mjs"
+    },
+    "./subagents": {
+      "types": "./runtime/subagents.d.mts",
+      "import": "./runtime/subagents.mjs"
+    },
+    "./tools": {
+      "types": "./tools/index.d.mts",
+      "import": "./tools/index.mjs"
+    },
+    "./tools/hosted-catalog": {
+      "types": "./tools/hostedCatalog.d.mts",
+      "import": "./tools/hostedCatalog.mjs"
+    },
+    "./tools/dataset": {
+      "types": "./tools/dataset.d.mts",
+      "import": "./tools/dataset.mjs"
+    },
+    "./tools/artifact": {
+      "types": "./tools/artifact.d.mts",
+      "import": "./tools/artifact.mjs"
+    },
+    "./tools/bash": {
+      "types": "./tools/bash.d.mts",
+      "import": "./tools/bash.mjs"
+    },
+    "./tools/ssh": {
+      "types": "./tools/ssh.d.mts",
+      "import": "./tools/ssh.mjs"
+    },
+    "./tools/repository-workspace": {
+      "types": "./tools/repository-workspace.d.mts",
+      "import": "./tools/repository-workspace.mjs"
+    },
+    "./tools/browser": {
+      "types": "./tools/browser/index.d.mts",
+      "import": "./tools/browser/index.mjs"
+    },
+    "./worker": {
+      "types": "./worker/index.d.mts",
+      "import": "./worker/index.mjs"
+    },
+    "./wasm": {
+      "types": "./wasm.d.mts",
+      "import": "./pkg-web/nanocodex_bg.wasm"
+    }
+  },
+  "files": [
+    "actions",
+    "browser",
+    "cloudflare",
+    "cloud",
+    "host",
+    "managed",
+    "node",
+    "worker",
+    "pkg-node",
+    "pkg-web",
+    "runtime",
+    "tools",
+    "internal.mjs",
+    "index.d.mts",
+    "index.mjs",
+    "wasm.d.mts",
+    "types.d.mts",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@cfworker/json-schema": "4.1.1",
+    "@eduoj/wasm-clang": "1.0.0",
+    "@microsoft/dev-tunnels-ssh": "3.12.40",
+    "@microsoft/dev-tunnels-ssh-keys": "3.12.40",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "buffer": "6.0.3",
+    "diff": "^9.0.0",
+    "isomorphic-git": "^1.41.5",
+    "minisearch": "7.2.0",
+    "mppx": "0.9.1",
+    "nanocodex-tools": "0.1.0",
+    "ox": "1.6.2",
+    "pako": "2.1.0",
+    "pyodide": "314.0.5",
+    "sprintf-js": "1.1.3",
+    "viem": "2.55.13",
+    "wata": "0.4.0",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@jitl/quickjs-wasmfile-release-asyncify": "0.32.0",
+    "binaryen": "132.0.0",
+    "hyparquet-writer": "0.16.6",
+    "pkg-pr-new": "0.0.79",
+    "quickjs-emscripten-core": "0.32.0",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gakonst/nanocodex.git",
+    "directory": "js/nanocodex"
+  },
+  "scripts": {
+    "build": "pnpm --filter nanocodex-vite run build:wasm:release",
+    "check:package": "node scripts/check-package.mjs",
+    "test": "node --test test/*.test.mjs && npm run test:performance && npm run test:typecheck && npm run check:package",
+    "test:performance": "node --expose-gc --test test/performance.bench.mjs",
+    "bench:dataset": "node scripts/dataset.bench.mjs",
+    "test:typecheck": "tsc -p test/tsconfig.json"
+  }
+}