@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/tools/browser/browserSprintf.mjs

@@ -0,0 +1,4 @@
+import sprintfJs from "sprintf-js";
+
+export const { sprintf, vsprintf } = sprintfJs;
+export default sprintfJs;

package/vendor/nanocodex/tools/browser/browserSsh.mjs

@@ -0,0 +1,201 @@
+import { Buffer } from "./browserBuffer.mjs";
+import { CancellationTokenSource, CommandRequestMessage, SshAuthenticationType, SshClientSession, SshSessionConfiguration, WebSocketStream, } from "./devTunnelsSshBrowser.mjs";
+import { importKey } from "@microsoft/dev-tunnels-ssh-keys";
+import { defineCommand } from "../../../nanocodex-tools/tools/just-bash-browser.mjs";
+export function createSshCommand(filesystem) {
+    return defineCommand("ssh", async (args, context) => {
+        if (args[0] === "--help")
+            return ok(`${usage()}\n`);
+        const parsed = parseArguments(args);
+        if ("error" in parsed)
+            return fail(`${parsed.error}\n`, 2);
+        if (String(context.stdin)) {
+            return fail("ssh: piped stdin is not supported by the browser WebSocket transport\n", 2);
+        }
+        try {
+            return await executeSsh(parsed, filesystem, context);
+        }
+        catch (error) {
+            return fail(`ssh: ${error instanceof Error ? error.message : String(error)}\n`, 255);
+        }
+    });
+}
+async function executeSsh(args, filesystem, context) {
+    const keyPath = filesystem.resolvePath(context.cwd, args.identityFile);
+    const keySource = await filesystem.readFile(keyPath);
+    const privateKey = await importKey(keySource);
+    const websocket = new WebSocket(args.endpoint);
+    websocket.binaryType = "arraybuffer";
+    const cancellation = new CancellationTokenSource();
+    const abort = () => {
+        cancellation.cancel();
+        websocket.close(1000, "command cancelled");
+    };
+    context.signal?.addEventListener("abort", abort, { once: true });
+    const session = new SshClientSession(new SshSessionConfiguration());
+    const authentication = session.onAuthenticating((event) => {
+        if (event.authenticationType !== SshAuthenticationType.serverPublicKey || !event.publicKey) {
+            event.authenticationPromise = Promise.resolve(null);
+            return;
+        }
+        event.authenticationPromise = authenticateHost(event.publicKey, args.hostKeySha256, args.acceptUnknownHost);
+    });
+    try {
+        await waitForWebSocket(websocket, context.signal);
+        await session.connect(new WebSocketStream(websocket), cancellation.token);
+        const authenticated = await session.authenticate({
+            username: args.username,
+            publicKeys: [privateKey],
+        }, cancellation.token);
+        if (!authenticated)
+            throw new Error("authentication failed");
+        const channel = await session.openChannel("session", cancellation.token);
+        let stdout = "";
+        let stderr = "";
+        channel.onDataReceived((data) => {
+            stdout += data.toString("utf8");
+            channel.adjustWindow(data.length);
+        });
+        channel.onExtendedDataReceived((event) => {
+            stderr += event.data.toString("utf8");
+            channel.adjustWindow(event.data.length);
+        });
+        const closed = new Promise((resolve) => channel.onClosed(resolve));
+        const request = new CommandRequestMessage();
+        request.command = args.command;
+        request.wantReply = true;
+        if (!await channel.request(request, cancellation.token)) {
+            throw new Error("remote server rejected the command");
+        }
+        const result = await closed;
+        if (result.error)
+            throw result.error;
+        if (result.exitSignal)
+            stderr += `ssh: remote command exited on ${result.exitSignal}\n`;
+        return { stdout, stderr, exitCode: result.exitStatus ?? (result.exitSignal ? 128 : 0) };
+    }
+    finally {
+        context.signal?.removeEventListener("abort", abort);
+        authentication.dispose();
+        privateKey.dispose();
+        session.dispose();
+        cancellation.dispose();
+        if (websocket.readyState === WebSocket.OPEN)
+            websocket.close(1000, "command complete");
+    }
+}
+async function authenticateHost(publicKey, expected, acceptUnknown) {
+    if (acceptUnknown)
+        return {};
+    const bytes = await publicKey.getPublicKeyBytes();
+    if (!bytes || !expected)
+        return null;
+    const keyBytes = new Uint8Array(bytes.byteLength);
+    keyBytes.set(bytes);
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", keyBytes));
+    let binary = "";
+    for (const byte of digest)
+        binary += String.fromCharCode(byte);
+    const actual = btoa(binary).replace(/=+$/, "");
+    const normalized = expected.replace(/^SHA256:/, "").replace(/=+$/, "");
+    return actual === normalized ? {} : null;
+}
+function parseArguments(args) {
+    if (!args.length)
+        return { error: usage() };
+    let username = "";
+    let identityFile = "";
+    let hostKeySha256;
+    let acceptUnknownHost = false;
+    let index = 0;
+    for (; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--") {
+            index += 1;
+            break;
+        }
+        if (!arg.startsWith("-"))
+            break;
+        if (arg === "-l" || arg === "-i" || arg === "-o") {
+            const value = args[++index];
+            if (!value)
+                return { error: `ssh: ${arg} requires an argument` };
+            if (arg === "-l")
+                username = value;
+            else if (arg === "-i")
+                identityFile = value;
+            else if (value === "StrictHostKeyChecking=no")
+                acceptUnknownHost = true;
+            else if (value.startsWith("HostKeySHA256="))
+                hostKeySha256 = value.slice("HostKeySHA256=".length);
+            else
+                return { error: `ssh: unsupported browser option '${value}'` };
+            continue;
+        }
+        return { error: `ssh: unsupported browser option '${arg}'` };
+    }
+    const endpointText = args[index++];
+    if (!endpointText)
+        return { error: usage() };
+    let endpoint;
+    try {
+        endpoint = new URL(endpointText);
+    }
+    catch {
+        return { error: "ssh: endpoint must be a ws:// or wss:// URL" };
+    }
+    if (!["ws:", "wss:"].includes(endpoint.protocol) || endpoint.username || endpoint.password) {
+        return { error: "ssh: endpoint must be a credential-free ws:// or wss:// URL" };
+    }
+    if (!username)
+        return { error: "ssh: -l USER is required" };
+    if (!identityFile)
+        return { error: "ssh: -i PRIVATE_KEY is required" };
+    if (!hostKeySha256 && !acceptUnknownHost) {
+        return { error: "ssh: provide -o HostKeySHA256=SHA256:... or explicitly -o StrictHostKeyChecking=no" };
+    }
+    const commandArgs = args.slice(index);
+    if (!commandArgs.length)
+        return { error: "ssh: an explicit remote command is required (interactive PTYs are unavailable)" };
+    return {
+        endpoint,
+        username,
+        identityFile,
+        command: commandArgs.map(shellQuote).join(" "),
+        hostKeySha256,
+        acceptUnknownHost,
+    };
+}
+function shellQuote(value) {
+    return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function waitForWebSocket(websocket, signal) {
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            websocket.removeEventListener("open", onOpen);
+            websocket.removeEventListener("error", onError);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        const onOpen = () => { cleanup(); resolve(); };
+        const onError = () => { cleanup(); reject(new Error("WebSocket connection failed")); };
+        const onAbort = () => { cleanup(); reject(signal?.reason ?? new Error("command cancelled")); };
+        websocket.addEventListener("open", onOpen, { once: true });
+        websocket.addEventListener("error", onError, { once: true });
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
+    });
+}
+function usage() {
+    return [
+        "usage: ssh -l USER -i PRIVATE_KEY (-o HostKeySHA256=SHA256:... |",
+        "           -o StrictHostKeyChecking=no) wss://SSH-GATEWAY -- COMMAND [ARG...]",
+        "Browser SSH requires a server-provided WebSocket carrying raw SSH; browsers cannot open TCP port 22.",
+    ].join("\n");
+}
+function fail(stderr, exitCode) {
+    return { stdout: "", stderr, exitCode };
+}
+function ok(stdout) {
+    return { stdout, stderr: "", exitCode: 0 };
+}

package/vendor/nanocodex/tools/browser/browserZlib.mjs

@@ -0,0 +1,136 @@
+import { Buffer } from "./browserBuffer.mjs";
+import { Deflate, Inflate, constants as pakoConstants } from "pako";
+
+const DEFAULT_CHUNK_BYTES = 64 * 1024;
+
+export const constants = Object.freeze({
+  Z_BEST_COMPRESSION: pakoConstants.Z_BEST_COMPRESSION,
+  Z_BEST_SPEED: pakoConstants.Z_BEST_SPEED,
+  Z_DEFAULT_COMPRESSION: pakoConstants.Z_DEFAULT_COMPRESSION,
+});
+
+export const {
+  Z_BEST_COMPRESSION,
+  Z_BEST_SPEED,
+  Z_DEFAULT_COMPRESSION,
+} = constants;
+
+export function gzipSync(input, options = undefined) {
+  const bytes = inputBytes(input);
+  const normalized = compressionOptions(options);
+  return transform(
+    new Deflate({ ...normalized.pako, gzip: true, chunkSize: normalized.chunkSize }),
+    bytes,
+    normalized.maxOutputLength,
+  );
+}
+
+export function gunzipSync(input, options = undefined) {
+  const bytes = inputBytes(input);
+  const normalized = compressionOptions(options);
+  return transform(
+    new Inflate({ ...normalized.pako, chunkSize: normalized.chunkSize }),
+    bytes,
+    normalized.maxOutputLength,
+  );
+}
+
+function transform(stream, input, maxOutputLength) {
+  const chunks = [];
+  let outputLength = 0;
+  stream.onData = (chunk) => {
+    const nextLength = outputLength + chunk.byteLength;
+    if (!Number.isSafeInteger(nextLength) || nextLength > maxOutputLength) {
+      throw bufferTooLarge(maxOutputLength);
+    }
+    chunks.push(chunk);
+    outputLength = nextLength;
+  };
+  stream.push(input, true);
+  if (stream.err) throw zlibError(stream.err, stream.msg);
+  if (chunks.length === 0) return Buffer.alloc(0);
+  if (chunks.length === 1) {
+    const [chunk] = chunks;
+    return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  }
+  return Buffer.concat(
+    chunks.map((chunk) => Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)),
+    outputLength,
+  );
+}
+
+function compressionOptions(options) {
+  if (options !== undefined && (options === null || typeof options !== "object")) {
+    throw invalidOptions(options);
+  }
+  const { maxOutputLength, ...pako } = options ?? {};
+  const maximum = validateMaxOutputLength(maxOutputLength);
+  return {
+    maxOutputLength: maximum,
+    // pako emits incrementally at this boundary. For a very small caller limit,
+    // ask it to stop at the first byte beyond that limit instead of materializing
+    // the complete decompressed payload before the compatibility layer sees it.
+    chunkSize: Math.max(2, Math.min(DEFAULT_CHUNK_BYTES, Math.floor(maximum) + 1)),
+    pako,
+  };
+}
+
+function validateMaxOutputLength(value) {
+  if (value === undefined || Number.isNaN(value)) return Number.MAX_SAFE_INTEGER;
+  if (typeof value !== "number") {
+    const error = new TypeError(
+      `The "options.maxOutputLength" property must be of type number. Received type ${typeof value}`,
+    );
+    error.code = "ERR_INVALID_ARG_TYPE";
+    throw error;
+  }
+  if (!Number.isFinite(value) || value < 1 || value > Number.MAX_SAFE_INTEGER) {
+    const error = new RangeError(
+      `The value of "options.maxOutputLength" is out of range. It must be >= 1 and <= ${Number.MAX_SAFE_INTEGER}. Received ${value}`,
+    );
+    error.code = "ERR_OUT_OF_RANGE";
+    throw error;
+  }
+  return value;
+}
+
+function inputBytes(input) {
+  if (typeof input === "string") return new TextEncoder().encode(input);
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  if (input instanceof ArrayBuffer || isSharedArrayBuffer(input)) {
+    return new Uint8Array(input);
+  }
+  const received = input === null ? "null" : typeof input;
+  const error = new TypeError(
+    `The "buffer" argument must be of type string or an instance of Buffer, TypedArray, DataView, or ArrayBuffer. Received ${received}`,
+  );
+  error.code = "ERR_INVALID_ARG_TYPE";
+  throw error;
+}
+
+function isSharedArrayBuffer(input) {
+  return typeof SharedArrayBuffer !== "undefined" && input instanceof SharedArrayBuffer;
+}
+
+function invalidOptions(options) {
+  const error = new TypeError(
+    `The "options" argument must be of type object. Received ${options === null ? "null" : typeof options}`,
+  );
+  error.code = "ERR_INVALID_ARG_TYPE";
+  return error;
+}
+
+function bufferTooLarge(maximum) {
+  const error = new RangeError(`Cannot create a Buffer larger than ${maximum} bytes`);
+  error.code = "ERR_BUFFER_TOO_LARGE";
+  return error;
+}
+
+function zlibError(errno, message) {
+  const error = new Error(message || "zlib operation failed");
+  error.code = errno === pakoConstants.Z_DATA_ERROR ? "Z_DATA_ERROR" : "Z_BUF_ERROR";
+  error.errno = errno;
+  return error;
+}

package/vendor/nanocodex/tools/browser/compiler.worker.mjs

@@ -0,0 +1,160 @@
+/// <reference lib="webworker" />
+import { API } from "@eduoj/wasm-clang";
+import { installBrowserEgressFetch } from "./browserEgress.mjs";
+let apiPromise;
+let workerFetch;
+let diagnostics = "";
+const knownDirectories = new WeakMap();
+const workerScope = globalThis.self;
+workerScope?.addEventListener("message", (event) => {
+    const message = event.data;
+    if (message.type === "initialize") {
+        workerFetch = installBrowserEgressFetch({
+            ...message.egress,
+            fetch: globalThis.fetch,
+        });
+        return;
+    }
+    if (message.type !== "compile" || typeof message.id !== "number")
+        return;
+    void compile(message.id, message.input);
+});
+async function compile(id, input) {
+    diagnostics = "";
+    try {
+        const api = await runtime();
+        await api.ready;
+        const bytes = await compileInput(api, id, input);
+        const result = {
+            stdout: "",
+            stderr: diagnostics,
+            exitCode: 0,
+            output: bytes,
+        };
+        workerScope.postMessage({ id, result }, [bytes.buffer]);
+    }
+    catch (error) {
+        workerScope.postMessage({
+            id,
+            result: {
+                stdout: "",
+                stderr: `${diagnostics}${error instanceof Error ? error.message : String(error)}\n`,
+                exitCode: 1,
+            },
+        });
+    }
+}
+export async function compileInput(api, id, input) {
+    const prefix = `.nanocodex-runs/run-${id}`;
+    try {
+        addDirectories(api, [`${prefix}/.keep`, ...input.files.map((file) => `${prefix}/${file.path}`)]);
+        for (const file of input.files)
+            api.memfs.addFile(`${prefix}/${file.path}`, file.contents);
+        addDirectories(api, [`${prefix}/objects/.keep`]);
+        const objects = [];
+        for (let index = 0; index < input.sources.length; index += 1) {
+            const relativeSource = workspaceRelative(input.sources[index]);
+            const file = input.files.find((candidate) => candidate.path === relativeSource);
+            if (!file)
+                throw new Error(`input file not found: ${relativeSource}`);
+            const source = `${prefix}/${relativeSource}`;
+            const object = `${prefix}/objects/${index}.o`;
+            await api.compile({
+                input: source,
+                contents: file.contents,
+                obj: object,
+                opt: input.optimize,
+                clangFlags: ["-triple", "wasm32-unknown-wasi"],
+            });
+            objects.push(object);
+        }
+        const generated = input.compileOnly
+            ? objects[0]
+            : await link(api, objects, prefix);
+        return api.memfs.getFileContents(generated).slice();
+    }
+    finally {
+        removeRun(api.memfs, prefix);
+    }
+}
+async function runtime() {
+    if (!apiPromise) {
+        if (!workerFetch)
+            throw new Error("compiler worker egress was not initialized");
+        apiPromise = Promise.resolve(new API({
+            hostWrite: (message) => diagnostics += message,
+            readBuffer: async (url) => {
+                const response = await workerFetch(url);
+                if (!response.ok)
+                    throw new Error(`compiler asset failed: HTTP ${response.status}`);
+                return response.arrayBuffer();
+            },
+            compileStreaming: async (url) => {
+                const response = await workerFetch(url);
+                if (!response.ok)
+                    throw new Error(`compiler asset failed: HTTP ${response.status}`);
+                return WebAssembly.compile(await response.arrayBuffer());
+            },
+        }));
+    }
+    return apiPromise;
+}
+async function link(api, objects, prefix) {
+    const output = `${prefix}/output.wasm`;
+    const libdir = "lib/wasm32-wasi";
+    const lld = await api.getModule(api.cdnUrl + api.lldFilename);
+    await api.run(lld, "wasm-ld", "--no-threads", "--export-dynamic", "-z", "stack-size=1048576", `-L${libdir}`, `${libdir}/crt1.o`, ...objects, "-lc", "-lc++", "-lc++abi", "-lcanvas", "-o", output);
+    return output;
+}
+function addDirectories(api, paths) {
+    const known = directoriesFor(api.memfs);
+    const directories = new Set();
+    for (const path of paths) {
+        const parts = path.split("/").slice(0, -1);
+        for (let index = 1; index <= parts.length; index += 1) {
+            directories.add(parts.slice(0, index).join("/"));
+        }
+    }
+    for (const directory of [...directories].sort()) {
+        if (known.has(directory))
+            continue;
+        api.memfs.addDirectory(directory);
+        known.add(directory);
+    }
+}
+function removeRun(memfs, prefix) {
+    try {
+        memfs.mem.check();
+        const pathBuffer = memfs.exports.GetPathBuf();
+        memfs.mem.write(pathBuffer, prefix);
+        const previousHostMemory = memfs.hostMem_;
+        memfs.hostMem = memfs.mem;
+        let errno;
+        try {
+            errno = memfs.exports.path_unlink_file(3, pathBuffer, prefix.length);
+        }
+        finally {
+            memfs.hostMem = previousHostMemory;
+        }
+        if (errno !== 0 && errno !== 44)
+            throw new Error(`compiler memfs cleanup failed with WASI errno ${errno}`);
+    }
+    finally {
+        const known = directoriesFor(memfs);
+        for (const directory of known) {
+            if (directory === prefix || directory.startsWith(`${prefix}/`))
+                known.delete(directory);
+        }
+    }
+}
+function directoriesFor(memfs) {
+    let directories = knownDirectories.get(memfs);
+    if (!directories) {
+        directories = new Set();
+        knownDirectories.set(memfs, directories);
+    }
+    return directories;
+}
+function workspaceRelative(path) {
+    return path.replace(/^\/workspace\//, "").replace(/^\/+/, "");
+}

package/vendor/nanocodex/tools/browser/devTunnelsSshBrowser.mjs

@@ -0,0 +1,13 @@
+// Browser-only barrel for dev-tunnels-ssh. The upstream CommonJS root eagerly
+// evaluates Node stream classes even though its crypto implementation correctly
+// selects Web Crypto. Export only the browser-safe protocol surface we use.
+export { SshAlgorithms, Encryption, ECDsa, Rsa, } from "@microsoft/dev-tunnels-ssh/algorithms/sshAlgorithms.js";
+export { SshDataReader } from "@microsoft/dev-tunnels-ssh/io/sshData.js";
+export { DerReader, DerWriter } from "@microsoft/dev-tunnels-ssh/io/derData.js";
+export { BigInt } from "@microsoft/dev-tunnels-ssh/io/bigInt.js";
+export { CancellationToken, CancellationTokenSource, } from "@microsoft/dev-tunnels-ssh/util/cancellation.js";
+export { CommandRequestMessage } from "@microsoft/dev-tunnels-ssh/messages/connectionMessages.js";
+export { SshAuthenticationType } from "@microsoft/dev-tunnels-ssh/events/sshAuthenticatingEventArgs.js";
+export { SshClientSession } from "@microsoft/dev-tunnels-ssh/sshClientSession.js";
+export { SshSessionConfiguration } from "@microsoft/dev-tunnels-ssh/sshSessionConfiguration.js";
+export { WebSocketStream } from "@microsoft/dev-tunnels-ssh/streams.js";