@lamplitisles/dsh-nanocodex 0.1.0-beta.0

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

@@ -0,0 +1,18 @@
+export {
+  createMemoryChatGptSubscriptionStore,
+  subscriptionRevision,
+} from "../runtime/subscription-store.mjs";
+export type {
+  ChatGptCredential,
+  ChatGptCredentialSeed,
+  ChatGptLoginStatus,
+  ChatGptSubscriptionHandle,
+  ChatGptSubscriptionOptions,
+  ChatGptSubscriptionStore,
+  MemoryChatGptSubscriptionStore,
+  SubscriptionCommitRequest,
+  SubscriptionCommitResult,
+  SubscriptionRevision,
+  SubscriptionStoredValue,
+} from "../types.mjs";
+export * as ChatGptSubscription from "./ChatGptSubscription.mjs";

package/vendor/nanocodex/worker/index.mjs

@@ -0,0 +1,5 @@
+export {
+  createMemoryChatGptSubscriptionStore,
+  subscriptionRevision,
+} from "../runtime/subscription-store.mjs";
+export * as ChatGptSubscription from "./ChatGptSubscription.mjs";

package/vendor/nanocodex-tools/README.md

@@ -0,0 +1,65 @@
+# nanocodex-tools
+
+Reusable, platform-neutral JavaScript tools for Nanocodex agents: the common
+tool router and Code Mode runtime, attachment and hosted-tool protocols,
+durable-memory parsing and ranking, artifact and dataset tools, persistent
+workspace adaptation, a bounded Just Bash runtime, Git/GitHub compatibility
+commands, repository materialization, and workspace-backed SSH composition.
+Session-search parsing, retrieval policy, and bounded model-visible projections
+are exposed through the dedicated `nanocodex-tools/session` entrypoint.
+
+`nanocodex-tools/x` exports the native `browseX({ fetch })` tool, its request
+validator, and `X_API` discovery metadata. Hosts inject transport to the
+[Nanocodex X Worker](../x-api/README.md); provider access stays in that Worker.
+
+Hosts own persistence, network policy, credentials, and socket transports and
+inject those capabilities through the package's narrow interfaces.
+
+Application tools may provide a provider-native `definition` in addition to
+the convenience `description`, `parameters`, and `outputSchema` fields. Use a
+`type: "custom"` definition for a grammar-constrained free-form tool; its
+handler receives the exact input string and the usual `ToolContext`:
+
+```js
+const applyPatch = {
+  description: "Apply one patch through the host-owned workspace.",
+  definition: {
+    type: "custom",
+    description: "Apply one patch through the host-owned workspace.",
+    format: {
+      type: "grammar",
+      syntax: "lark",
+      definition: 'start: "patch"',
+    },
+  },
+  handler(input, context) {
+    return applyPatchInHost(input, context);
+  },
+};
+```
+
+The router canonicalizes the definition name from the containing map key or
+`NamedTool.name`. `ToolDefinition`, `CustomToolFormat`, and `ToolJson` are
+exported types for hosts that want to annotate this shape directly. Nanocodex
+executes completed custom calls once; history, snapshots, and resumed sessions
+retain their call and output items without replaying the handler.
+
+`nanocodex` owns the Rust/WASM agent runtime and composes WASM, workspace, and
+MCP adapters around these capabilities. It imports and reexports this package's
+JS-only host capabilities; `nanocodex-tools` never imports `nanocodex`.
+
+Cloudflare Workers may supply Durable Object persistence and WebSocket
+registries to the hosted-tools core, but Cloudflare bindings, account authority,
+Connect grants, and storage schemas remain owned by those Workers.
+
+`nanocodex-tools/node` supplies native `exec_command` and `write_stdin` pipe
+sessions for explicitly authorized desktop/Node Hands. Processes use an explicit
+workspace cwd and a small environment allowlist, and sessions are fenced by the
+calling agent. The workspace is not an OS sandbox; hosts must make the native
+authority clear and use a VM for isolation. Closing the runtime terminates owned
+processes. This entrypoint imports Node APIs and must not be bundled into Workers
+or browser applications.
+
+Native Node Hands retain unread command output in private temporary files. Reply
+budgets control each poll, without discarding older output. Files are removed
+when fully consumed or when their owning session or Hand is closed.

package/vendor/nanocodex-tools/dist/hosted/app-tool-catalog.d.ts

@@ -0,0 +1,7 @@
+import type { HostedToolCatalogEntry } from "./protocol.js";
+export declare function isAppToolCatalogDigest(value: unknown): value is `0x${string}`;
+export declare function hostedToolCatalogEntryAllowed(grant: Readonly<{
+    grantId: string;
+    mcpIds: readonly string[];
+    appToolCatalogDigest?: `0x${string}`;
+}> | undefined, hostConnectGrantId: string | undefined, hostAppToolCatalogDigest: string | undefined, entry: HostedToolCatalogEntry): boolean;

package/vendor/nanocodex-tools/dist/hosted/app-tool-catalog.js

@@ -0,0 +1,14 @@
+export function isAppToolCatalogDigest(value) {
+    return typeof value === "string" && /^0x[0-9a-f]{64}$/.test(value);
+}
+export function hostedToolCatalogEntryAllowed(grant, hostConnectGrantId, hostAppToolCatalogDigest, entry) {
+    if (grant === undefined)
+        return hostConnectGrantId === undefined;
+    if (hostConnectGrantId !== grant.grantId)
+        return false;
+    const match = /^mcp:([A-Za-z0-9_-]{43})$/.exec(entry.provider);
+    if (match !== null)
+        return grant.mcpIds.includes(match[1]);
+    return grant.appToolCatalogDigest !== undefined
+        && hostAppToolCatalogDigest === grant.appToolCatalogDigest;
+}

package/vendor/nanocodex-tools/dist/hosted/broker-core.d.ts

@@ -0,0 +1,172 @@
+import { type HostedToolCallOutcome, type HostedToolCatalogEntry, type HostedMachine } from "./protocol.js";
+import type { ToolContext } from "../../tools/types.mjs";
+export declare const HOSTED_MACHINE_TOOL_NAMES: readonly ["exec_command", "write_stdin", "preview"];
+/**
+ * Marks the one case where an attached source is known to be absent before a
+ * durable admission. The unified ToolRouter may then select the exact
+ * same-name cloud contract. It must never infer this from an outcome message:
+ * every other unavailable, cancellation, timeout, and ambiguous outcome is
+ * pinned to the attached source and is final.
+ */
+export declare const HOSTED_TOOLS_PRE_ADMISSION_UNAVAILABLE: unique symbol;
+export type HostedToolsCallState = "admitted" | "dispatched" | "completed" | "unavailable" | "ambiguous" | "cancelled";
+export type HostedToolsStateRow = {
+    route_id: string;
+    generation: number;
+    host_id: string | null;
+    lease_id: string | null;
+    lease_expires_at: number;
+    catalog_json: string | null;
+};
+export type HostedToolsCallRow = {
+    call_id: string;
+    session_id: string;
+    source_call_id: string;
+    host_id: string;
+    lease_id: string;
+    generation: number;
+    model: string;
+    name: string;
+    input_json: string;
+    output_token_budget: number;
+    output_byte_budget: number;
+    deadline_at: number;
+    cancel_requested: number;
+    state: HostedToolsCallState;
+    result_json: string | null;
+    receipt_json: string | null;
+};
+export type HostedToolsSocket = {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+};
+export type HostedToolsBrokerCoreContext = Readonly<{
+    accept(socket: HostedToolsSocket): void;
+    sockets(): HostedToolsSocket[];
+    readAttachment(socket: HostedToolsSocket): unknown;
+    writeAttachment(socket: HostedToolsSocket, value: unknown): void;
+}>;
+export type HostedToolsProviderDefinition = Readonly<HostedToolCatalogEntry>;
+export type HostedToolsInvokeRequest = Readonly<{
+    sessionId: string;
+    callId: string;
+    model: string;
+    input: Record<string, unknown> | string;
+    outputTokenBudget: number;
+    outputByteBudget?: number;
+    deadlineAt?: number;
+    signal?: AbortSignal;
+}>;
+export type HostedToolsPreparedTool = Readonly<{
+    routeToken: string;
+    connectGrantId?: string;
+    appToolCatalogDigest?: string;
+    canonicalName: string;
+    machine?: HostedMachine;
+    entry: HostedToolCatalogEntry;
+    invoke(request: HostedToolsInvokeRequest): Promise<HostedToolsInvocationOutcome>;
+}>;
+export type HostedToolsCodeDefinition = HostedToolCatalogEntry["definition"] & {
+    defer_loading: true;
+};
+export type HostedToolsCatalogCandidate = Readonly<Omit<HostedToolCatalogEntry, "definition"> & {
+    definition: HostedToolsCodeDefinition;
+}>;
+export type HostedToolsCatalogValidator = (definitions: readonly HostedToolsCatalogCandidate[]) => true;
+export type HostedToolsCodeTool = Readonly<{
+    name: string;
+    parallelSafe: boolean;
+    /** Opaque immutable route identity for trusted broker-to-broker relays. */
+    routeToken?: string;
+    handler(input: unknown, context: HostedToolsInvocationContext): Promise<unknown>;
+}>;
+export type HostedToolsInvocationContext = Readonly<Pick<ToolContext, "sessionId" | "callId"> & Partial<Pick<ToolContext, "parentCallId" | "model" | "signal" | "subagent">>>;
+export type HostedToolsAuthorizationContext = Pick<ToolContext, "sessionId" | "subagent">;
+export type HostedMachineToolName = (typeof HOSTED_MACHINE_TOOL_NAMES)[number];
+export interface HostedToolsDynamicProvider {
+    definitions(): readonly HostedToolsCodeDefinition[];
+    resolve(name: string): HostedToolsCodeTool | undefined;
+    /** Installed by the owning ToolRouter to reject non-parity catalogs before ACK. */
+    setCatalogValidator(validator: HostedToolsCatalogValidator | undefined): void;
+}
+/** Injectable durable call ledger boundary; the production default is Durable Object SQLite. */
+export interface HostedToolsBrokerPersistence {
+    initialize(now: number): readonly HostedToolsStateRow[];
+    transaction<T>(callback: () => T): T;
+    states(): readonly HostedToolsStateRow[];
+    state(routeId: string): HostedToolsStateRow | undefined;
+    replaceHost(row: HostedToolsStateRow): void;
+    clearHost(leaseId: string, generation: number): void;
+    clearCatalog(leaseId: string, generation: number): void;
+    call(callId: string): HostedToolsCallRow | undefined;
+    callBySource(sessionId: string, sourceCallId: string): HostedToolsCallRow | undefined;
+    insertCall(row: HostedToolsCallRow, now: number): void;
+    markCancelRequested(callId: string, now: number): HostedToolsCallRow | undefined;
+    transitionCall(callId: string, from: readonly HostedToolsCallState[], state: HostedToolsCallState, resultJson: string, now: number): HostedToolsCallRow | undefined;
+    recordLateReceipt(callId: string, receiptJson: string, now: number): HostedToolsCallRow | undefined;
+    markGenerationAmbiguous(leaseId: string, generation: number, resultJson: string, now: number): void;
+    activeCallCount(leaseId: string, generation: number): number;
+    generationCallCount(leaseId: string, generation: number): number;
+    pruneReceipts(limit: number): void;
+}
+export type HostedToolsBrokerCoreOptions = Readonly<{
+    now?: () => number;
+    randomUUID?: () => string;
+    maxInFlight?: number;
+    maxCallsPerGeneration?: number;
+    persistence: HostedToolsBrokerPersistence;
+    /** Resume exact live hibernated sockets instead of forcing every route to reconnect. */
+    resumeRetainedSockets?: boolean;
+    onCatalogChanged?: (definitions: readonly HostedToolsProviderDefinition[]) => void;
+    entryAllowed?: (entry: HostedToolCatalogEntry, connectGrantId?: string, appToolCatalogDigest?: string, context?: HostedToolsAuthorizationContext) => boolean;
+    renewLeasedAttachment?: (renewal: HostedToolsLeasedAttachmentRenewal) => Promise<number | undefined>;
+}>;
+export type HostedToolsLeasedAttachmentPolicy = Readonly<{
+    expectedAttachmentId: string;
+    maximumLeaseExpiresAt: number;
+    fixedRouteId: string;
+    renewalToken: string;
+}>;
+export type HostedToolsLeasedAttachmentRenewal = Readonly<{
+    expectedAttachmentId: string;
+    fixedRouteId: string;
+    renewalToken: string;
+}>;
+/** Owns one reverse-tool attachment over an injected socket and durable ledger. */
+export declare class HostedToolsBrokerCore {
+    #private;
+    readonly context: HostedToolsBrokerCoreContext;
+    constructor(context: HostedToolsBrokerCoreContext, options: HostedToolsBrokerCoreOptions);
+    owns(socket: HostedToolsSocket): boolean;
+    message(socket: HostedToolsSocket, message: string): Promise<void>;
+    close(socket: HostedToolsSocket, reason: string): void;
+    shutdown(reason: string): void;
+    /** Fences one attachment only when its exact durable route is still current. */
+    revokeRoute(routeId: string, reason: string): boolean;
+    isReady(): boolean;
+    hasPendingCalls(): boolean;
+    provider(): HostedToolsDynamicProvider;
+    /** Resolves one canonical machine primitive against its exact admitted attachment generation. */
+    machineTool(machineId: string, name: HostedMachineToolName, context?: HostedToolsAuthorizationContext): HostedToolsCodeTool | undefined;
+    /** Resolves one canonical machine primitive only on the named durable route. */
+    machineToolOnRoute(routeId: string, machineId: string, name: HostedMachineToolName, context?: HostedToolsAuthorizationContext): HostedToolsCodeTool | undefined;
+    /** Returns one live machine only when its exact durable route still owns it. */
+    machineOnRoute(routeId: string, machineId: string): HostedMachine | undefined;
+    /** Returns the live, non-secret user-machine snapshot for the account-owned host. */
+    machines(): readonly HostedMachine[];
+    accept(socket: HostedToolsSocket, sessionId: string, allowedMcpIds?: readonly string[], appToolCatalogDigest?: `0x${string}`, connectGrantId?: string, leasedAttachment?: HostedToolsLeasedAttachmentPolicy): void;
+    handles(socket: HostedToolsSocket): boolean;
+    webSocketMessage(socket: HostedToolsSocket, message: string | ArrayBuffer): Promise<void>;
+    webSocketClose(socket: HostedToolsSocket, code: number, reason: string): void;
+    webSocketError(socket: HostedToolsSocket): void;
+    /** May be called by an owning alarm; normal reads and call timers also expire leases lazily. */
+    expire(): void;
+    cancel(callId: string): boolean;
+}
+export declare function hostedToolsUnavailable(message: string): HostedToolCallOutcome;
+type HostedToolsInvocationOutcome = HostedToolCallOutcome & {
+    [HOSTED_TOOLS_PRE_ADMISSION_UNAVAILABLE]?: true;
+};
+export declare function hostedToolsAmbiguous(message: string): HostedToolCallOutcome;
+export {};