@lamplitisles/dsh-nanocodex 0.1.0-beta.0

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

@@ -0,0 +1,114 @@
+/// <reference lib="webworker" />
+import { loadPyodide } from "pyodide";
+import { installBrowserEgressFetch } from "./browserEgress.mjs";
+const PYODIDE_INDEX_URL = "https://cdn.jsdelivr.net/pyodide/v314.0.5/full/";
+let workspaceRoot;
+let egress;
+let runtimePromise;
+self.addEventListener("message", (event) => {
+    const message = event.data;
+    if (message.type === "initialize") {
+        workspaceRoot = message.workspaceRoot;
+        egress = message.egress;
+        return;
+    }
+    if (message.type !== "execute" || typeof message.id !== "number")
+        return;
+    void execute(message.id, message.input);
+});
+async function execute(id, input) {
+    try {
+        const parsed = input;
+        const { pyodide, nativeFs } = await runtime();
+        await nativeFs.syncfs();
+        let stdout = "";
+        let stderr = "";
+        let stdinOffset = 0;
+        pyodide.setStdout({ batched: (line) => stdout += `${line}\n` });
+        pyodide.setStderr({ batched: (line) => stderr += `${line}\n` });
+        pyodide.setStdin({
+            stdin: () => {
+                if (stdinOffset >= input.stdin.length)
+                    return null;
+                const newline = input.stdin.indexOf("\n", stdinOffset);
+                const end = newline < 0 ? input.stdin.length : newline + 1;
+                const chunk = input.stdin.slice(stdinOffset, end);
+                stdinOffset = end;
+                return chunk;
+            },
+            autoEOF: true,
+        });
+        const globals = pyodide.toPy({
+            argv: parsed.argv,
+            cwd: input.cwd,
+            source: parsed.source ?? "",
+            hasSource: parsed.source !== null,
+            filename: parsed.filename,
+            moduleName: parsed.moduleName ?? "",
+            hasModule: parsed.moduleName !== null,
+        });
+        try {
+            await pyodide.runPythonAsync(PYTHON_LAUNCHER, { globals });
+            await nativeFs.syncfs();
+            self.postMessage({ id, result: { stdout, stderr, exitCode: 0 } });
+        }
+        catch (error) {
+            await nativeFs.syncfs().catch(() => undefined);
+            self.postMessage({
+                id,
+                result: {
+                    stdout,
+                    stderr: `${stderr}${formatPythonError(error)}\n`,
+                    exitCode: pythonExitCode(error),
+                },
+            });
+        }
+        finally {
+            globals.destroy();
+        }
+    }
+    catch (error) {
+        self.postMessage({ id, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+async function runtime() {
+    if (!runtimePromise) {
+        runtimePromise = (async () => {
+            if (!workspaceRoot)
+                throw new Error("Python worker was not initialized");
+            if (!egress)
+                throw new Error("Python worker egress was not initialized");
+            installBrowserEgressFetch({
+                ...egress,
+                fetch: globalThis.fetch,
+            });
+            const pyodide = await loadPyodide({ indexURL: PYODIDE_INDEX_URL });
+            const nativeFs = await pyodide.mountNativeFS("/workspace", workspaceRoot);
+            return { pyodide, nativeFs };
+        })();
+    }
+    return runtimePromise;
+}
+function formatPythonError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.trim() || "Python execution failed";
+}
+function pythonExitCode(error) {
+    const match = /SystemExit:\s*(\d+)/.exec(error instanceof Error ? error.message : String(error));
+    return match ? Number(match[1]) : 1;
+}
+const PYTHON_LAUNCHER = `
+import os
+import runpy
+import sys
+
+os.chdir(cwd)
+sys.argv = list(argv)
+if hasModule:
+    runpy.run_module(moduleName, run_name="__main__", alter_sys=True)
+elif hasSource:
+    scope = {"__name__": "__main__", "__file__": filename}
+    exec(compile(source, filename, "exec"), scope, scope)
+else:
+    runpy.run_path(filename, run_name="__main__")
+`;

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

@@ -0,0 +1,197 @@
+import "./browserBuffer.mjs";
+import git from "isomorphic-git";
+import http from "isomorphic-git/http/web";
+import { createOpfsGitFs, openOpfsGitFs, openOpfsWorkspaceRoot } from "./opfsGit.mjs";
+export const THREAD_GIT_DIRECTORY = "/workspace";
+export const THREAD_GIT_AUTHOR = { name: "Nanocodex", email: "agent@nanocodex.dev" };
+const directory = THREAD_GIT_DIRECTORY;
+const author = THREAD_GIT_AUTHOR;
+const configuredRemotePath = "nanocodex.remote";
+export function browserThread(threadId, origin) {
+    if (!/^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/.test(threadId)) {
+        throw new Error("invalid browser thread id");
+    }
+    const baseUrl = new URL(origin);
+    const shareUrl = new URL("/", baseUrl);
+    shareUrl.searchParams.set("thread", threadId);
+    return {
+        id: threadId,
+        workspaceName: `nanocodex-thread-${threadId}`,
+        repositoryName: `thread-${threadId}`,
+        branch: "nanocodex",
+        remoteUrl: `${baseUrl.origin}/git/thread-${threadId}`,
+        shareUrl: shareUrl.toString(),
+    };
+}
+export async function initializeThreadGit(thread) {
+    return inspectThreadGit(thread, async (fs) => {
+        return status(fs, thread);
+    });
+}
+/** Ensures the repository exists without scanning its complete worktree. */
+export function prepareThreadGit(thread) {
+    return inspectPreparedThreadGit(thread, (rawFs, workspaceRoot) => ({ rawFs, workspaceRoot }));
+}
+export function inspectThreadGit(thread, inspect) {
+    return inspectPreparedThreadGit(thread, (rawFs) => inspect(rawFs));
+}
+async function inspectPreparedThreadGit(thread, inspect) {
+    return withThreadGitLock(thread, async () => {
+        const workspaceRoot = await openOpfsWorkspaceRoot(thread.workspaceName);
+        const fs = createOpfsGitFs(workspaceRoot);
+        if (!(await exists(fs, `${directory}/.git/config`))) {
+            await initializeOrRestore(fs, thread);
+        }
+        await configureRemote(fs, thread);
+        return inspect(fs, workspaceRoot);
+    });
+}
+export async function threadGitStatus(thread) {
+    return withThreadGitLock(thread, async () => {
+        const fs = await openOpfsGitFs(thread.workspaceName);
+        if (!(await exists(fs, `${directory}/.git/config`)))
+            await initializeOrRestore(fs, thread);
+        return status(fs, thread);
+    });
+}
+export async function commitAndPushThread(thread, message = "Update workspace", notificationSource) {
+    return withThreadGitLock(thread, async () => {
+        const fs = await openOpfsGitFs(thread.workspaceName);
+        if (!(await exists(fs, `${directory}/.git/config`)))
+            await initializeOrRestore(fs, thread);
+        await configureRemote(fs, thread);
+        const matrix = await git.statusMatrix({ fs, dir: directory });
+        const changed = matrix.filter(([, headStatus, workdirStatus]) => headStatus !== workdirStatus);
+        for (const [filepath, , workdirStatus] of changed) {
+            if (workdirStatus === 0)
+                await git.remove({ fs, dir: directory, filepath });
+            else
+                await git.add({ fs, dir: directory, filepath });
+        }
+        if (changed.length > 0) {
+            await git.commit({ fs, dir: directory, message: message.trim() || "Update workspace", author });
+        }
+        const head = await resolveHead(fs);
+        if (!head)
+            throw new Error("Create at least one workspace file before the first push");
+        await git.push({
+            fs,
+            http,
+            dir: directory,
+            remote: "origin",
+            ref: thread.branch,
+            remoteRef: thread.branch,
+        });
+        const next = await status(fs, thread);
+        notifyThreadGitChanged(thread, notificationSource);
+        return next;
+    });
+}
+export async function pullThread(thread, notificationSource) {
+    return withThreadGitLock(thread, async () => {
+        const fs = await openOpfsGitFs(thread.workspaceName);
+        if (!(await exists(fs, `${directory}/.git/config`)))
+            await initializeOrRestore(fs, thread);
+        await configureRemote(fs, thread);
+        const refs = await remoteRefs(thread);
+        if (!refs.some((ref) => ref.ref === thread.branch || ref.ref === `refs/heads/${thread.branch}`)) {
+            throw new Error("This thread has not been pushed yet");
+        }
+        if (await resolveHead(fs)) {
+            await git.pull({ fs, http, dir: directory, remote: "origin", ref: thread.branch, author });
+        }
+        else {
+            await restoreRemote(fs, thread);
+        }
+        const next = await status(fs, thread);
+        notifyThreadGitChanged(thread, notificationSource);
+        return next;
+    });
+}
+export function subscribeThreadGitChanges(thread, listener) {
+    if (typeof BroadcastChannel === "undefined")
+        return () => undefined;
+    const channel = new BroadcastChannel(`nanocodex-git-${thread.id}`);
+    channel.addEventListener("message", (event) => {
+        const source = event.data != null && typeof event.data === "object" &&
+            typeof event.data.source === "string"
+            ? event.data.source
+            : undefined;
+        listener(source);
+    });
+    return () => channel.close();
+}
+export function notifyThreadGitChanged(thread, source) {
+    if (typeof BroadcastChannel === "undefined")
+        return;
+    const channel = new BroadcastChannel(`nanocodex-git-${thread.id}`);
+    channel.postMessage({ type: "changed", source });
+    channel.close();
+}
+async function initializeOrRestore(fs, thread) {
+    const refs = await remoteRefs(thread);
+    await git.init({ fs, dir: directory, defaultBranch: thread.branch });
+    await configureRemote(fs, thread);
+    if (refs.some((ref) => ref.ref === thread.branch || ref.ref === `refs/heads/${thread.branch}`)) {
+        await restoreRemote(fs, thread);
+    }
+}
+async function restoreRemote(fs, thread) {
+    const fetched = await git.fetch({
+        fs,
+        http,
+        dir: directory,
+        remote: "origin",
+        ref: thread.branch,
+        singleBranch: true,
+    });
+    const oid = fetched.fetchHead;
+    if (!oid)
+        throw new Error("The thread remote did not return a branch head");
+    await git.writeRef({ fs, dir: directory, ref: `refs/heads/${thread.branch}`, value: oid, force: true });
+    await git.checkout({ fs, dir: directory, ref: thread.branch, force: true });
+}
+async function configureRemote(fs, thread) {
+    if (await git.getConfig({ fs, dir: directory, path: configuredRemotePath }) === thread.remoteUrl)
+        return;
+    await git.addRemote({ fs, dir: directory, remote: "origin", url: thread.remoteUrl, force: true });
+    await git.setConfig({ fs, dir: directory, path: `branch.${thread.branch}.remote`, value: "origin" });
+    await git.setConfig({
+        fs,
+        dir: directory,
+        path: `branch.${thread.branch}.merge`,
+        value: `refs/heads/${thread.branch}`,
+    });
+    await git.setConfig({ fs, dir: directory, path: "user.name", value: author.name });
+    await git.setConfig({ fs, dir: directory, path: "user.email", value: author.email });
+    await git.setConfig({ fs, dir: directory, path: configuredRemotePath, value: thread.remoteUrl });
+}
+async function status(fs, thread) {
+    const matrix = await git.statusMatrix({ fs, dir: directory });
+    return {
+        branch: thread.branch,
+        head: await resolveHead(fs),
+        changes: matrix
+            .filter(([, headStatus, workdirStatus, stageStatus]) => headStatus !== workdirStatus || headStatus !== stageStatus)
+            .map(([filepath]) => filepath),
+        remoteUrl: thread.remoteUrl,
+    };
+}
+async function remoteRefs(thread) {
+    return git.listServerRefs({ http, url: thread.remoteUrl, protocolVersion: 2, prefix: "refs/heads/" });
+}
+async function resolveHead(fs) {
+    return git.resolveRef({ fs, dir: directory, ref: "HEAD" }).catch(() => undefined);
+}
+async function exists(fs, path) {
+    return fs.promises.stat(path).then(() => true, () => false);
+}
+export async function withThreadGitLock(thread, operation, signal) {
+    if (!navigator.locks) {
+        throw new Error("This browser must support Web Locks to safely share the OPFS Git repository");
+    }
+    const name = `nanocodex-git-${thread.id}`;
+    return signal
+        ? navigator.locks.request(name, { signal }, operation)
+        : navigator.locks.request(name, operation);
+}

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

@@ -0,0 +1,5 @@
+export default class UnsupportedNodeRsa {
+    constructor() {
+        throw new Error("node-rsa is unavailable in browsers; Web Crypto must be used");
+    }
+}

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

@@ -0,0 +1,83 @@
+const THREAD_STORAGE_KEY = "nanocodex-thread-id";
+const THREAD_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
+let browserThread;
+const workspaces = new Map();
+export function getBrowserThread() {
+    if (browserThread)
+        return browserThread;
+    const url = new URL(window.location.href);
+    const requested = url.searchParams.get("thread")?.toLowerCase();
+    let retained;
+    try {
+        retained = window.localStorage.getItem(THREAD_STORAGE_KEY)?.toLowerCase();
+    }
+    catch {
+        retained = undefined;
+    }
+    const id = requested && THREAD_PATTERN.test(requested)
+        ? requested
+        : retained && THREAD_PATTERN.test(retained)
+            ? retained
+            : crypto.randomUUID();
+    try {
+        window.localStorage.setItem(THREAD_STORAGE_KEY, id);
+    }
+    catch {
+        // The query parameter remains the durable/shareable thread identity.
+    }
+    if (url.searchParams.get("thread") !== id) {
+        url.searchParams.set("thread", id);
+        window.history.replaceState(window.history.state, "", url);
+    }
+    browserThread = {
+        id,
+        workspaceName: `nanocodex-thread-${id}`,
+        repositoryName: `thread-${id}`,
+        branch: "nanocodex",
+        remoteUrl: `${window.location.origin}/git/thread-${id}`,
+        shareUrl: url.toString(),
+    };
+    return browserThread;
+}
+export function selectBrowserThread(threadId) {
+    const id = threadId?.toLowerCase();
+    if (typeof id !== "string" || !THREAD_PATTERN.test(id))
+        throw new TypeError("browser thread id must be a UUID");
+    const url = new URL(window.location.href);
+    url.searchParams.set("thread", id);
+    try { window.localStorage.setItem(THREAD_STORAGE_KEY, id); }
+    catch { /* The URL remains authoritative. */ }
+    if (window.location.href !== url.toString())
+        window.history.replaceState(window.history.state, "", url);
+    browserThread = {
+        id,
+        workspaceName: `nanocodex-thread-${id}`,
+        repositoryName: `thread-${id}`,
+        branch: "nanocodex",
+        remoteUrl: `${window.location.origin}/git/thread-${id}`,
+        shareUrl: url.toString(),
+    };
+    return browserThread;
+}
+export function openKernelWorkspace() {
+    return openThreadWorkspace(getBrowserThread().id);
+}
+export function openThreadWorkspace(threadId) {
+    const name = `nanocodex-thread-${threadId}`;
+    let workspace = workspaces.get(name);
+    workspace ??= import("nanocodex/browser/workspace")
+        .then((module) => module.open({ name }))
+        .catch((error) => {
+        workspaces.delete(name);
+        throw error;
+    });
+    workspaces.set(name, workspace);
+    return workspace;
+}
+export function subscribeThreadWorkspaceChanges(threadId, listener) {
+    if (typeof BroadcastChannel === "undefined")
+        return () => undefined;
+    const channel = new BroadcastChannel(`nanocodex-git-${threadId}`);
+    channel.addEventListener("message", listener);
+    return () => channel.close();
+}

package/vendor/nanocodex/tools/dataset.d.mts

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/dataset.d.mts";

package/vendor/nanocodex/tools/dataset.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/dataset.mjs";

package/vendor/nanocodex/tools/datasetContract.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/datasetContract.mjs";

package/vendor/nanocodex/tools/datasetEngine.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/datasetEngine.mjs";

package/vendor/nanocodex/tools/hostedCatalog.d.mts

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/hostedCatalog.d.mts";

package/vendor/nanocodex/tools/hostedCatalog.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/hostedCatalog.mjs";

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

@@ -0,0 +1,49 @@
+import type { NamedTool } from "../types.mjs";
+import type { Workspace } from "../runtime/workspace.mjs";
+export * from "./artifact.mjs";
+export type JsonToolOptions = Readonly<{
+  /** Defaults to the same-origin `/api/tools/web-search` or image route. */
+  url?: string | URL | undefined;
+  fetch?: typeof globalThis.fetch | undefined;
+  headers?: Readonly<Record<string, string>> | undefined;
+}>;
+
+export type ImageGenerationOptions = JsonToolOptions & Readonly<{
+  recentImages?(sessionId: string, count: number): string[];
+  rememberImage?(sessionId: string, imageUrl: string): void;
+  workspace?: Readonly<{ readFile(path: string): Promise<Uint8Array> }> | undefined;
+}>;
+
+/** The standard web search tool with its complete runtime JSON Schema. */
+export function web(options?: JsonToolOptions): NamedTool;
+
+/** The standard image generation/editing tool. */
+export function imageGeneration(options?: ImageGenerationOptions): NamedTool;
+
+/** Reads supported image formats from a caller-owned workspace. */
+export function viewImage(options: {
+  workspace: Pick<Workspace, "readFile">;
+}): NamedTool;
+
+/** A session-scoped planning tool. */
+export function updatePlan(): NamedTool;
+
+export { dataset } from "./dataset.mjs";
+export type { DatasetOptions } from "./dataset.mjs";
+export { justBash } from "./bash.mjs";
+export type { JustBashNetworkOptions, JustBashRuntime } from "./bash.mjs";
+export { materializeRepositoryWorkspace } from "./repository-workspace.mjs";
+export type {
+  RepositoryWorkspaceDescriptor,
+  RepositoryWorkspaceFetch,
+  RepositoryWorkspaceRemote,
+} from "./repository-workspace.mjs";
+export { createTools } from "./Tools.mjs";
+export type {
+  AttachmentClient,
+  AttachmentSocket,
+  AttachmentTarget,
+  AttachmentTransport,
+  Tools,
+} from "./Tools.mjs";
+export type { HostedMachine } from "./hostedCatalog.mjs";

package/vendor/nanocodex/tools/index.mjs

@@ -0,0 +1,19 @@
+export {
+  ARTIFACT_DIRECTORY,
+  ArtifactStore,
+  artifact,
+  artifactPath,
+  artifactToolDefinition,
+  createArtifactTool,
+  parseArtifactDocument,
+} from "./artifact.mjs";
+export {
+  imageGeneration,
+  updatePlan,
+  viewImage,
+  web,
+} from "./standard.mjs";
+export { dataset } from "./dataset.mjs";
+export { justBash } from "./bash.mjs";
+export { materializeRepositoryWorkspace } from "./repository-workspace.mjs";
+export { createTools } from "./Tools.mjs";

package/vendor/nanocodex/tools/namedTool.mjs

@@ -0,0 +1 @@
+export { namedTool } from "../../nanocodex-tools/tools/namedTool.mjs";

package/vendor/nanocodex/tools/repository-workspace.d.mts

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/repository-workspace.d.mts";

package/vendor/nanocodex/tools/repository-workspace.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/repository-workspace.mjs";

package/vendor/nanocodex/tools/ssh.d.mts

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/ssh.d.mts";

package/vendor/nanocodex/tools/ssh.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/ssh.mjs";

package/vendor/nanocodex/tools/standard.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/standard.mjs";

package/vendor/nanocodex/tools/standardDescriptions.mjs

@@ -0,0 +1 @@
+export * from "../../nanocodex-tools/tools/standardDescriptions.mjs";