@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex-tools/dist/workspace.d.ts

@@ -0,0 +1,45 @@
+import type { Workspace } from "../tools/types.mjs";
+type ComputerDirent = Readonly<{
+    name: string;
+    size: number;
+    mtime: number;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+}>;
+type ComputerStat = Readonly<{
+    size: number;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+}>;
+/** Minimal storage interface needed to expose a persistent Nanocodex workspace. */
+export type WorkspaceStorageClient = Readonly<{
+    fs: {
+        lstat(path: string): Promise<ComputerStat>;
+        readdir(path: string, options?: {
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }): Promise<ComputerDirent[]>;
+        readFile(path: string, options?: {
+            byteOffset?: number | undefined;
+            byteLength?: number | undefined;
+        }): Promise<ReadableStream<Uint8Array>>;
+        writeFile(path: string, contents: Uint8Array): Promise<void>;
+        mkdir(path: string, options?: {
+            recursive?: boolean | undefined;
+        }): Promise<void>;
+        rm(path: string, options?: {
+            recursive?: boolean | undefined;
+            force?: boolean | undefined;
+        }): Promise<void>;
+    };
+}>;
+/**
+ * Adapts a persistent filesystem client to Nanocodex's host-generic workspace
+ * contract. Callers mount the returned handle into a bounded tool runtime.
+ */
+export declare function createWorkspaceFilesystem(workspace: WorkspaceStorageClient, options?: {
+    maxFileBytes?: number | undefined;
+}): Promise<Workspace>;
+export {};

package/vendor/nanocodex-tools/dist/workspace.js

@@ -0,0 +1,237 @@
+const ROOT = "/workspace";
+const DEFAULT_MAX_ENTRIES = Infinity;
+const DEFAULT_MAX_FILE_BYTES = Infinity;
+/**
+ * Adapts a persistent filesystem client to Nanocodex's host-generic workspace
+ * contract. Callers mount the returned handle into a bounded tool runtime.
+ */
+export async function createWorkspaceFilesystem(workspace, options = {}) {
+    const maxFileBytes = positiveInteger(options.maxFileBytes, DEFAULT_MAX_FILE_BYTES, "maxFileBytes");
+    await ensureRoot(workspace.fs);
+    return createFilesystem(workspace.fs, maxFileBytes);
+}
+function createFilesystem(fs, maxFileBytes) {
+    return Object.freeze({
+        root: ROOT,
+        async list(path = ".", options = {}) {
+            const directory = resolvePath(path);
+            const recursive = options.recursive === true;
+            const maxEntries = positiveInteger(options.maxEntries, DEFAULT_MAX_ENTRIES, "maxEntries");
+            await requireSafePath(fs, directory, "directory");
+            const entries = [];
+            const pending = [directory];
+            while (pending.length > 0) {
+                const current = pending.shift();
+                let offset = 0;
+                for (;;) {
+                    const children = await fs.readdir(current, { limit: 1_000, offset });
+                    if (!children.length)
+                        break;
+                    for (const child of children) {
+                        const childPath = resolveChild(current, child.name);
+                        requireSupportedEntry(child, childPath);
+                        entries.push(Object.freeze({
+                            kind: child.isDirectory ? "directory" : "file",
+                            modifiedAt: child.mtime,
+                            path: childPath,
+                            ...(child.isFile ? { size: child.size } : {}),
+                        }));
+                        if (entries.length > maxEntries)
+                            throw new RangeError(`workspace listing exceeds ${maxEntries} entries`);
+                        if (recursive && child.isDirectory)
+                            pending.push(childPath);
+                    }
+                    offset += children.length;
+                }
+                if (!recursive)
+                    break;
+            }
+            return entries.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+        },
+        async readFile(path) {
+            const target = resolvePath(path);
+            const stat = await requireSafePath(fs, target, "file");
+            if (stat.size > maxFileBytes) {
+                throw new RangeError(`workspace file exceeds the ${maxFileBytes}-byte read bound`);
+            }
+            const stream = await fs.readFile(target, { byteOffset: 0, byteLength: stat.size + 1 });
+            return readExactlyBounded(stream, stat.size, maxFileBytes);
+        },
+        async writeFile(path, contents) {
+            const target = resolvePath(path);
+            if (target === ROOT)
+                throw new Error("cannot write the workspace root as a file");
+            const bytes = toBytes(contents);
+            if (bytes.byteLength > maxFileBytes) {
+                throw new RangeError(`workspace file exceeds the ${maxFileBytes}-byte write bound`);
+            }
+            const parent = parentPath(target);
+            await requireSafeAncestors(fs, parent);
+            await fs.mkdir(parent, { recursive: true });
+            await requireSafePath(fs, parent, "directory");
+            const existing = await optionalLstat(fs, target);
+            if (existing)
+                requireSafeStat(existing, target, "file");
+            await fs.writeFile(target, bytes);
+        },
+        async mkdir(path) {
+            const target = resolvePath(path);
+            await requireSafeAncestors(fs, target);
+            await fs.mkdir(target, { recursive: true });
+            await requireSafePath(fs, target, "directory");
+        },
+        async remove(path, options = {}) {
+            const target = resolvePath(path);
+            if (target === ROOT)
+                throw new Error("cannot remove the workspace root");
+            await requireSafePath(fs, target);
+            await fs.rm(target, { recursive: options.recursive === true, force: false });
+        },
+    });
+}
+async function ensureRoot(fs) {
+    const existing = await optionalLstat(fs, ROOT);
+    if (!existing)
+        await fs.mkdir(ROOT, { recursive: true });
+    await requireSafePath(fs, ROOT, "directory");
+}
+async function requireSafeAncestors(fs, target) {
+    for (const candidate of pathPrefixes(target)) {
+        const stat = await optionalLstat(fs, candidate);
+        if (!stat)
+            return;
+        requireSafeStat(stat, candidate, "directory");
+    }
+}
+async function requireSafePath(fs, target, kind) {
+    let result;
+    for (const candidate of pathPrefixes(target)) {
+        result = await fs.lstat(candidate);
+        requireSafeStat(result, candidate, candidate === target ? kind : "directory");
+    }
+    if (!result)
+        throw new Error(`invalid workspace path: ${target}`);
+    return result;
+}
+function requireSafeStat(stat, path, kind) {
+    if (stat.isSymbolicLink) {
+        throw new Error(`symbolic links are not supported by the Nanocodex workspace: ${path}`);
+    }
+    if (!stat.isFile && !stat.isDirectory) {
+        throw new Error(`unsupported workspace entry: ${path}`);
+    }
+    if (kind === "directory" && !stat.isDirectory)
+        throw new Error(`not a directory: ${path}`);
+    if (kind === "file" && !stat.isFile)
+        throw new Error(`not a file: ${path}`);
+}
+function requireSupportedEntry(entry, path) {
+    requireSafeStat(entry, path);
+}
+async function optionalLstat(fs, path) {
+    try {
+        return await fs.lstat(path);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+function pathPrefixes(path) {
+    if (path === ROOT)
+        return [ROOT];
+    const relative = path.slice(ROOT.length + 1);
+    const prefixes = [ROOT];
+    let current = ROOT;
+    for (const segment of relative.split("/")) {
+        current += `/${segment}`;
+        prefixes.push(current);
+    }
+    return prefixes;
+}
+function resolvePath(path) {
+    if (typeof path !== "string")
+        throw new TypeError("workspace path must be a string");
+    if (path.includes("\0"))
+        throw new TypeError("workspace path cannot contain NUL");
+    if (path.includes("\\"))
+        throw new TypeError("workspace paths must use forward slashes");
+    let relative = path;
+    if (path.startsWith("/")) {
+        if (path !== ROOT && !path.startsWith(`${ROOT}/`)) {
+            throw new Error(`workspace path must stay within ${ROOT}`);
+        }
+        relative = path.slice(ROOT.length);
+    }
+    const segments = [];
+    for (const segment of relative.split("/")) {
+        if (!segment || segment === ".")
+            continue;
+        if (segment === "..")
+            throw new Error(`workspace path must stay within ${ROOT}`);
+        segments.push(segment);
+    }
+    return segments.length === 0 ? ROOT : `${ROOT}/${segments.join("/")}`;
+}
+function resolveChild(parent, name) {
+    if (!name || name.includes("/") || name.includes("\\") || name === "." || name === "..") {
+        throw new Error(`invalid workspace entry name: ${JSON.stringify(name)}`);
+    }
+    return resolvePath(`${parent}/${name}`);
+}
+function parentPath(path) {
+    return path.slice(0, path.lastIndexOf("/")) || ROOT;
+}
+async function readExactlyBounded(stream, expectedBytes, maxBytes) {
+    const reader = stream.getReader();
+    const output = new Uint8Array(expectedBytes);
+    let offset = 0;
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            if (!(value instanceof Uint8Array))
+                throw new TypeError("workspace read returned non-byte data");
+            if (offset + value.byteLength > expectedBytes || offset + value.byteLength > maxBytes) {
+                await reader.cancel("workspace file changed or exceeded its read bound");
+                throw new RangeError(`workspace file changed or exceeds the ${maxBytes}-byte read bound`);
+            }
+            output.set(value, offset);
+            offset += value.byteLength;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (offset !== expectedBytes) {
+        throw new Error(`workspace file changed while reading: expected ${expectedBytes} bytes, received ${offset}`);
+    }
+    return output;
+}
+function toBytes(value) {
+    if (typeof value === "string")
+        return new TextEncoder().encode(value);
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    throw new TypeError("workspace contents must be a string or byte array");
+}
+function positiveInteger(value, fallback, name) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError(`${name} must be positive`);
+    }
+    return value;
+}
+function isMissing(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const value = error;
+    return value.code === "ENOENT"
+        || (typeof value.message === "string" && /ENOENT|not found|no such/i.test(value.message));
+}

package/vendor/nanocodex-tools/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "nanocodex-tools",
+  "version": "0.1.0",
+  "description": "Platform-neutral JavaScript tools for Nanocodex agents",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./node": {
+      "types": "./tools/nodeProcess.d.mts",
+      "import": "./tools/nodeProcess.mjs"
+    },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./artifact": {
+      "types": "./tools/artifact.d.mts",
+      "import": "./tools/artifact.mjs"
+    },
+    "./attachment": "./tools/attachment.mjs",
+    "./bash": {
+      "types": "./tools/bash.d.mts",
+      "import": "./tools/bash.mjs"
+    },
+    "./dataset": {
+      "types": "./tools/dataset.d.mts",
+      "import": "./tools/dataset.mjs"
+    },
+    "./execution-contract": {
+      "types": "./tools/execution-contract.d.mts",
+      "import": "./tools/execution-contract.mjs"
+    },
+    "./just-bash/browser": {
+      "types": "./tools/just-bash-browser.d.mts",
+      "import": "./tools/just-bash-browser.mjs"
+    },
+    "./memory": {
+      "types": "./dist/memory.d.ts",
+      "import": "./dist/memory.js"
+    },
+    "./session": {
+      "types": "./dist/session.d.ts",
+      "import": "./dist/session.js"
+    },
+    "./named-tool": {
+      "types": "./tools/namedTool.d.mts",
+      "import": "./tools/namedTool.mjs"
+    },
+    "./hosted-catalog": {
+      "types": "./tools/hostedCatalog.d.mts",
+      "import": "./tools/hostedCatalog.mjs"
+    },
+    "./internal/hosted-machine": {
+      "types": "./tools/hostedMachine.d.mts",
+      "import": "./tools/hostedMachine.mjs"
+    },
+    "./hosted": {
+      "types": "./dist/hosted/index.d.ts",
+      "import": "./dist/hosted/index.js"
+    },
+    "./repository-workspace": {
+      "types": "./tools/repository-workspace.d.mts",
+      "import": "./tools/repository-workspace.mjs"
+    },
+    "./ssh": {
+      "types": "./tools/ssh.d.mts",
+      "import": "./tools/ssh.mjs"
+    },
+    "./standard": "./tools/standard.mjs",
+    "./standard-descriptions": "./tools/standardDescriptions.mjs",
+    "./runtime/code-runtime": "./runtime/code-runtime.mjs",
+    "./runtime/tool-configuration": "./runtime/tool-configuration.mjs",
+    "./runtime/tool-router": "./runtime/tool-router.mjs",
+    "./runtime/utf8": "./runtime/utf8.mjs",
+    "./workspace": {
+      "types": "./tools/workspace.d.mts",
+      "import": "./tools/workspace.mjs"
+    },
+    "./x": {
+      "types": "./tools/x.d.mts",
+      "import": "./tools/x.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "runtime",
+    "tools",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@microsoft/dev-tunnels-ssh": "3.12.40",
+    "@microsoft/dev-tunnels-ssh-keys": "3.12.40",
+    "buffer": "6.0.3",
+    "hyparquet": "1.28.2",
+    "hyparquet-compressors": "1.1.1",
+    "isomorphic-git": "^1.41.5",
+    "just-bash": "^3.4.0",
+    "modern-tar": "0.7.7"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gakonst/nanocodex.git",
+    "directory": "js/nanocodex-tools"
+  },
+  "scripts": {
+    "clean": "node --eval \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "typecheck": "tsc --noEmit"
+  }
+}