better-dsh 0.2.3 → 0.2.4-b

package/lib/lsp-server-registry-XU6aHSqZ.js

@@ -0,0 +1,3 @@
+import { a as primaryServerForFile, c as serversForFile, i as installServer, n as findWorkspaceRoot, o as resolveCommandPath, r as installHintFor, s as serverByName, t as clearCommandProbeCache } from "./lsp-server-registry-946ysdqg.js";
+
+export { clearCommandProbeCache, findWorkspaceRoot, installHintFor, installServer, primaryServerForFile, resolveCommandPath, serverByName, serversForFile };

package/lib/mobile/plugin.d.ts

@@ -0,0 +1,29 @@
+import { r as MobileConfig } from "../web-trust-CgpBoFv3.js";
+import { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+//#region src/mobile/plugin.d.ts
+
+/** Cordis plugin name. */
+declare const name = "dashr-mobile";
+/**
+ * No static injects: `webServer` is composed conditionally inside
+ * {@link apply}, so the row loads (dormant) in compositions without one.
+ */
+declare const inject: string[];
+declare const Config: z<Required<MobileConfig>>;
+/**
+ * Mount the mobile-leg injection: one `webserver/index-inject` listener
+ * pushing the rendered row.
+ * @param ctx - host plugin context.
+ * @param config - the row config.
+ */
+declare function apply(ctx: Context, config: MobileConfig | undefined): void;
+declare const _default: {
+  name: string;
+  inject: string[];
+  Config: z<Required<MobileConfig>>;
+  apply: typeof apply;
+};
+//#endregion
+export { Config, apply, _default as default, inject, name };

package/lib/mobile/plugin.js

@@ -0,0 +1,54 @@
+import { r as buildMobileScript } from "../web-trust-BO66y72w.js";
+import { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+//#region src/mobile/plugin.ts
+/** Cordis plugin name. */
+const name = "dashr-mobile";
+/**
+* No static injects: `webServer` is composed conditionally inside
+* {@link apply}, so the row loads (dormant) in compositions without one.
+*/
+const inject = [];
+/**
+* Row config schema — the mobile knobs, moved verbatim from the pre-split
+* `dashr-repl` Config (2026-09-11 mobile wave + zoomGuard changes).
+*/
+const MOBILE_CONFIG = z.object({
+	enabled: z.boolean().default(true),
+	swipeDistancePx: z.natural().min(8).default(40),
+	dominanceRatio: z.number().min(1).default(1.3),
+	leftEdgeBandPx: z.natural().min(8).default(120),
+	rightZoneRatio: z.number().min(.05).max(.9).default(.25),
+	swipeVelocityPxPerMs: z.number().min(0).default(.15),
+	zoomGuard: z.union(["meta", "off"]).default("meta")
+});
+const Config = MOBILE_CONFIG;
+/**
+* Mount the mobile-leg injection: one `webserver/index-inject` listener
+* pushing the rendered row.
+* @param ctx - host plugin context.
+* @param config - the row config.
+*/
+function apply(ctx, config) {
+	const mobile = config;
+	ctx.inject(["webServer"], () => {
+		ctx.on("webserver/index-inject", (table) => {
+			const text = buildMobileScript(mobile);
+			if (text !== void 0) table.push({
+				kind: "script",
+				placement: "head",
+				text
+			});
+		});
+	});
+}
+var plugin_default = {
+	name,
+	inject,
+	Config,
+	apply
+};
+
+//#endregion
+export { Config, apply, plugin_default as default, inject, name };

package/lib/native-capture-x_Hos2e8.js

@@ -0,0 +1,68 @@
+//#region src/native-capture.ts
+/** Tool names the chassis/wrappers shadow and delegate back to. */
+const NATIVE_TOOL_NAMES = [
+	"read",
+	"write",
+	"grep",
+	"glob"
+];
+/**
+* Per-agent capture cache. An agent's inherited tool surface is captured
+* once, before its own layer gains the wrappers and before the wire mask
+* restricts it; the WeakMap keeps the snapshot alive with the agent and
+* makes repeated session starts cheap.
+*/
+const captured = /* @__PURE__ */ new WeakMap();
+/** The projected wrapper triple per agent, cached beside the full snapshot. */
+const projections = /* @__PURE__ */ new WeakMap();
+/**
+* Snapshot EVERY tool `agent` can see, before any wrapper registers or any
+* restriction lands: enumerate `ctx.tools.schemas(agent)` (the agent's
+* pre-mask visible projection) and resolve each name through
+* `ctx.tools.get(name, agent)`.
+*
+* MUST run at `agent/session-start` BEFORE (a) the URL-aware wrappers
+* register on the agent's own scope layer and (b) the wire-mask
+* `tools.restrict({deny})` call — after either, names this snapshot exists
+* to preserve (the shadowed natives, the masked delegation tools) read as
+* the wrapper or as absent. (b) is guaranteed structurally: the mask
+* listener's first step is this call (see the module comment). (a) holds
+* because the wrappers register inside the same listener body that captures.
+* A definition that fails to resolve is skipped,
+* not thrown: the snapshot serves best-effort internal delegation.
+*
+* @returns the cached full snapshot for `agent` (stable across recalls).
+*/
+function captureAllTools(ctx, agent) {
+	const cached = captured.get(agent);
+	if (cached !== void 0) return cached;
+	const all = /* @__PURE__ */ new Map();
+	for (const schema of ctx.tools.schemas(agent)) try {
+		const definition = ctx.tools.get(schema.name, agent);
+		if (definition !== void 0) all.set(schema.name, definition);
+	} catch {}
+	captured.set(agent, all);
+	return all;
+}
+/**
+* Capture the native `write`/`grep`/`glob` definitions as `agent` sees them,
+* projected out of the full snapshot ({@link captureAllTools}).
+*
+* MUST be called before the URL-aware wrappers register on the agent's own
+* scope layer (see the module comment); the result is cached per agent.
+*/
+function captureNativeTools(ctx, agent) {
+	const cachedProjection = projections.get(agent);
+	if (cachedProjection !== void 0) return cachedProjection;
+	const all = captureAllTools(ctx, agent);
+	const set = {};
+	for (const name of NATIVE_TOOL_NAMES) {
+		const definition = all.get(name);
+		if (definition !== void 0) set[name] = definition;
+	}
+	projections.set(agent, set);
+	return set;
+}
+
+//#endregion
+export { captureNativeTools as n, captureAllTools as t };

package/lib/py-sdk-Chvy92MB.js

@@ -0,0 +1,178 @@
+import { Context, Service } from "@deepseek-ai/cordis";
+
+//#region src/vendored/repl-runtime.ts
+/**
+* Binding globals EVERY backend refuses because SOME backend owns the slot in
+* the program's namespace: `console` (the worker's log capture), and
+* `__dsh_main__`/`__builtins__`/`__name__` (the Python backend's bootstrap
+* wrapper and seeded module globals; see upstream's Agent Note
+* `2026-07-31-code-runtime-portable-identifier-seam.md` in the dsh monorepo),
+* and `__debug__`. One shared set — rather than each backend refusing only its
+* own slots — keeps the portability promise real: a namespace list valid on
+* one backend is valid on all, so a caller cannot pick a name that works on
+* the worker and collides on Python (or vice versa). `__name__` et al. ARE
+* valid portable identifiers, so the identifier rule on
+* `CodeBindingNamespace.global` never rejects them — hence this explicit set.
+* (Error members differ: {@link DUNDER_MEMBER} refuses every dunder form
+* wholesale; binding globals refuse only the names listed here.) `__debug__`
+* is listed for a different reason than a collision: CPython compiles a bare
+* `__debug__` reference to the constant `True` and rejects any assignment to
+* the name at COMPILE time, so an injected global under that name is
+* unreachable from the program — accepted by validation, unusable on the
+* Python backend, which is exactly the split the shared set exists to prevent.
+*/
+const RESERVED_BINDING_GLOBALS = new Set([
+	"console",
+	"__dsh_main__",
+	"__builtins__",
+	"__name__",
+	"__debug__"
+]);
+/**
+* `CodeBindingErrorClass.memberNameProperty` names EVERY backend refuses, as
+* one shared contract so a request valid on one backend is valid on all. The
+* JS `Error` exclusions (`name`, `message`, `stack`) and Python's
+* exception-protocol members (`args`, `with_traceback`, `add_note`) are
+* listed by name; dunder-form names (`__x__`, non-empty middle) are refused
+* wholesale — several are constrained CPython descriptors whose `setattr`
+* raises while constructing the rejection, and the exact set is an interpreter
+* version detail. Any other non-empty own property name is accepted everywhere.
+*/
+const RESERVED_ERROR_MEMBERS = new Set([
+	"name",
+	"message",
+	"stack",
+	"args",
+	"with_traceback",
+	"add_note"
+]);
+/**
+* Dunder form (`__x__`, non-empty middle): object-protocol slots in Python,
+* refused as {@link RESERVED_ERROR_MEMBERS | error members} on every backend.
+*/
+const DUNDER_MEMBER = /^__.+__$/;
+/**
+* Reserved words of every portable target language (ECMAScript ∪ Python),
+* refused as {@link CodeBindingNamespace.global} / error-class names by all
+* backends. Python is a portability target here even though only the
+* TypeScript worker has a published backend. The portable-identifier contract
+* promises a namespace list valid on one backend is valid on every backend; a
+* per-language check would let `lambda` pass the TypeScript backend and fail
+* the Python one. Extending the seam with a new language means widening this
+* union (a breaking review of existing binding names, by design).
+*/
+const PORTABLE_RESERVED_WORDS = new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield",
+	"let",
+	"static",
+	"implements",
+	"interface",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"arguments",
+	"eval",
+	"False",
+	"None",
+	"True",
+	"and",
+	"as",
+	"assert",
+	"async",
+	"def",
+	"del",
+	"elif",
+	"except",
+	"from",
+	"global",
+	"is",
+	"lambda",
+	"nonlocal",
+	"not",
+	"or",
+	"pass",
+	"raise",
+	"match",
+	"type",
+	"_"
+]);
+/**
+* Registers one `ctx.replRuntime` implementation. Program, budget, abort, and substrate
+* failures resolve in {@link CodeRunResult}; only Service Definition contract misuse rejects. Implementations bridge
+* structured-cloneable bindings, materialize each declared namespace rejection
+* class, treat programs as hostile peers — budget, interrupt, and substrate
+* semantics apply per program and are unchanged by this seam's statefulness —
+* share one persistent per-session user namespace across runs (state
+* codification across runs IS the product; this replaces upstream's
+* isolate-runs-from-one-another clause), and terminate and await in-flight
+* runs during disposal.
+*/
+var ReplRuntime = class extends Service {
+	constructor(ctx) {
+		super(ctx, "replRuntime");
+	}
+};
+
+//#endregion
+//#region src/py-sdk.ts
+/** The language-portable identifier subset the seam accepts as a binding global (mirrors the runtime's private rule). */
+const PORTABLE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Whether a tool name can be bound as a `tool` member — the ONE
+* policy the bridge's binding loop (src/index.ts) applies, so the
+* bindings never promise a name the kernel does
+* not bind. Strictly narrower than the runtime's validation: the
+* language-portable identifier subset (`[A-Za-z_][A-Za-z0-9_]*`, ASCII — a
+* non-ASCII XID name is legal CPython but not portable, so the runtime
+* refuses it as a binding global), minus
+* every portable reserved word (ECMAScript ∪ Python — `type` and `match`
+* are legal Python but reserved on the seam), minus the seam's reserved
+* binding globals (`console`, dunders), minus underscore-leading names
+* (kernel-shim prefix plus the call-site hazards; not callable as taught
+* flat globals). The runtime's `validateBindings` remains the authoritative
+* backstop: everything this accepts, it accepts.
+*/
+function isFlatBindableName(name) {
+	return PORTABLE_IDENTIFIER.test(name) && !name.startsWith("_") && !PORTABLE_RESERVED_WORDS.has(name) && !RESERVED_BINDING_GLOBALS.has(name);
+}
+
+//#endregion
+export { RESERVED_ERROR_MEMBERS as a, RESERVED_BINDING_GLOBALS as i, DUNDER_MEMBER as n, ReplRuntime as o, PORTABLE_RESERVED_WORDS as r, isFlatBindableName as t };

package/lib/py-sdk.d.ts

@@ -1,2 +1,19 @@
-import { a as renderReplBridgeInstructions, i as isFlatBindableName, n as REPL_BRIDGE_CATALOG_MODE, o as renderToolsSdkPy, r as ReplBridgeCatalogMode, t as DASHRSdkSchema } from "./py-sdk-BCaOGYz7.js";
-export { DASHRSdkSchema, REPL_BRIDGE_CATALOG_MODE, ReplBridgeCatalogMode, isFlatBindableName, renderReplBridgeInstructions, renderToolsSdkPy };
+//#region src/py-sdk.d.ts
+/**
+ * Whether a tool name can be bound as a `tool` member — the ONE
+ * policy the bridge's binding loop (src/index.ts) applies, so the
+ * bindings never promise a name the kernel does
+ * not bind. Strictly narrower than the runtime's validation: the
+ * language-portable identifier subset (`[A-Za-z_][A-Za-z0-9_]*`, ASCII — a
+ * non-ASCII XID name is legal CPython but not portable, so the runtime
+ * refuses it as a binding global), minus
+ * every portable reserved word (ECMAScript ∪ Python — `type` and `match`
+ * are legal Python but reserved on the seam), minus the seam's reserved
+ * binding globals (`console`, dunders), minus underscore-leading names
+ * (kernel-shim prefix plus the call-site hazards; not callable as taught
+ * flat globals). The runtime's `validateBindings` remains the authoritative
+ * backstop: everything this accepts, it accepts.
+ */
+declare function isFlatBindableName(name: string): boolean;
+//#endregion
+export { isFlatBindableName };

package/lib/py-sdk.js

@@ -1,3 +1,3 @@
-import { i as renderToolsSdkPy, n as isFlatBindableName, r as renderReplBridgeInstructions, t as REPL_BRIDGE_CATALOG_MODE } from "./py-sdk-CbgYiX8O.js";
+import { t as isFlatBindableName } from "./py-sdk-Chvy92MB.js";
 
-export { REPL_BRIDGE_CATALOG_MODE, isFlatBindableName, renderReplBridgeInstructions, renderToolsSdkPy };
+export { isFlatBindableName };

package/lib/remote/plugin.d.ts

@@ -0,0 +1,24 @@
+import { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+//#region src/remote/plugin.d.ts
+
+declare const name = "dashr-remote";
+declare const inject: string[];
+/** 运行参数旋钮（Ruling P18）：无别名表面——容器一律显式 'docker:' / 'incus:' 前缀。 */
+interface RemoteRowConfig {
+  execTimeoutSec: number;
+  idleTtlSec: number;
+  maxOutputChars: number;
+}
+declare const Config: z<RemoteRowConfig>;
+/** MUST stay an arrow（RM0 plugin.ts 同注：function 声明会被 cordis 当构造器 new 掉，返回的 disposer 丢失）。 */
+declare const apply: (ctx: Context, config: RemoteRowConfig) => (() => void);
+declare const _default: {
+  name: string;
+  inject: string[];
+  Config: z<RemoteRowConfig>;
+  apply: (ctx: Context, config: RemoteRowConfig) => (() => void);
+};
+//#endregion
+export { Config, RemoteRowConfig, apply, _default as default, inject, name };