@tangle-network/agent-provider-cli-bridge 2.0.5 → 2.0.6

package/README.md

@@ -200,6 +200,7 @@ The endpoint holds only a scheme, a host, and an explicit port; userinfo, path,
 
 `@tangle-network/agent-provider-cli-bridge/sandbox` turns a vendor sandbox that runs CLI Bridge into an `AgentEnvironmentProvider`.
 The vendor adapter implements `BridgeSandboxVendor`: `create`, `connect`, `list`, and per sandbox `exec`, `spawn`, `read`, `write`, `endpoint`, `status` and `destroy`.
+A vendor whose command call runs to completion, as Daytona's and computesdk's do, builds `exec` from `markedExec` and `spawn` from `envFileLaunch`.
 `createBridgeSandboxProvider({ vendor, router: { key } })` does the rest:
 
 - It refuses every create field the vendor cannot honor with an `EnvironmentProviderError` that names the field, before any vendor call, and validates the profile with the materializer the Bridge in the box uses.

package/dist/sandbox/index.d.ts

@@ -2,5 +2,6 @@ export { createBridgeSandboxProvider, BRIDGE_RUN_TAG } from "./provider.js";
 export type { BridgeSandboxProviderOptions } from "./provider.js";
 export type { BridgeSandbox, BridgeSandboxCreateRequest, BridgeSandboxSummary, BridgeSandboxVendor, BridgeVendorSupport, } from "./vendor.js";
 export { validateBoxProfile } from "./refusal.js";
+export { envFileLaunch, markedExec, untilAborted } from "./shell.js";
 export { BOX_HARNESSES, BOX_HOME, BOX_PINS, BOX_TEMPLATE_NAME, BOX_WORKSPACE_DIR, BRIDGE_PORT, boxHarnessVersion, } from "./box.js";
 export { renderBoxDockerfile } from "./image.js";

package/dist/sandbox/index.js

@@ -1,4 +1,5 @@
 export { createBridgeSandboxProvider, BRIDGE_RUN_TAG } from "./provider.js";
 export { validateBoxProfile } from "./refusal.js";
+export { envFileLaunch, markedExec, untilAborted } from "./shell.js";
 export { BOX_HARNESSES, BOX_HOME, BOX_PINS, BOX_TEMPLATE_NAME, BOX_WORKSPACE_DIR, BRIDGE_PORT, boxHarnessVersion, } from "./box.js";
 export { renderBoxDockerfile } from "./image.js";

package/dist/sandbox/provider.js

@@ -3,6 +3,7 @@ import { posix } from "node:path";
 import { Agent, fetch as undiciFetch } from "undici";
 import { canonicalAgentProfileDigest, TANGLE_ROUTER_DEFAULT_ROOT_URL, } from "@tangle-network/agent-interface";
 import { AgentEnvironmentGetOptionsSchema, AgentTurnInputSchema, EnvironmentProviderError, } from "@tangle-network/agent-interface/environment-provider";
+import { shellQuote } from "@tangle-network/agent-core/node";
 import { harnessModelSupportFor } from "@tangle-network/cli-agent-registry";
 import { createCliBridgeProvider, defaultCliBridgeCapabilities } from "../index.js";
 import { BOX_WORKSPACE_DIR, BRIDGE_PORT, BRIDGE_START_COMMAND, bridgeProcessEnv, boxHarness, boxHarnessVersion, } from "./box.js";
@@ -214,12 +215,11 @@ async function cloneRepository(sandbox, input, secrets) {
     if (repoUrl === undefined)
         return;
     const gitRef = input.workspace?.gitRef;
-    const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
     const command = [
-        `rm -rf ${quote(BOX_WORKSPACE_DIR)}/.git`,
-        `git clone ${quote(repoUrl)} ${quote(BOX_WORKSPACE_DIR)}.clone`,
-        ...(gitRef === undefined ? [] : [`git -C ${quote(BOX_WORKSPACE_DIR)}.clone checkout ${quote(gitRef)}`]),
-        `cp -a ${quote(BOX_WORKSPACE_DIR)}.clone/. ${quote(BOX_WORKSPACE_DIR)}/ && rm -rf ${quote(BOX_WORKSPACE_DIR)}.clone`,
+        `rm -rf ${shellQuote(BOX_WORKSPACE_DIR)}/.git`,
+        `git clone ${shellQuote(repoUrl)} ${shellQuote(BOX_WORKSPACE_DIR)}.clone`,
+        ...(gitRef === undefined ? [] : [`git -C ${shellQuote(BOX_WORKSPACE_DIR)}.clone checkout ${shellQuote(gitRef)}`]),
+        `cp -a ${shellQuote(BOX_WORKSPACE_DIR)}.clone/. ${shellQuote(BOX_WORKSPACE_DIR)}/ && rm -rf ${shellQuote(BOX_WORKSPACE_DIR)}.clone`,
     ].join(" && ");
     const result = await sandbox.exec(command, { timeoutMs: 600_000, ...signalOption(input.signal) });
     if (result.exitCode !== 0) {
@@ -227,7 +227,7 @@ async function cloneRepository(sandbox, input, secrets) {
     }
 }
 async function ensureDirectory(sandbox, directory) {
-    const result = await sandbox.exec(`mkdir -p '${directory.replace(/'/g, `'\\''`)}'`, { timeoutMs: 30_000 });
+    const result = await sandbox.exec(`mkdir -p ${shellQuote(directory)}`, { timeoutMs: 30_000 });
     if (result.exitCode !== 0) {
         throw new EnvironmentProviderError("provision_failed", `cannot create workspace directory ${directory}: ${result.stderr.trim().slice(0, 200)}`, { path: "workspace.cwd" });
     }

package/dist/sandbox/shell.d.ts

@@ -0,0 +1,16 @@
+import { type ExecRequest, type ExecResult } from "@tangle-network/agent-interface/environment-provider";
+/** Exec over a run-to-completion command call: a timeout or abort kills every process carrying the exec's marker, so the remote work stops too. */
+export declare function markedExec(command: string, options: ExecRequest | undefined, provider: string, run: (script: string, signal: AbortSignal) => Promise<ExecResult>): Promise<ExecResult>;
+/** The Bridge's credentials go to a file in a directory only the box user can open, sourced and deleted before exec, so no value enters an argv. */
+export declare function envFileLaunch(command: string, { cwd, env }: {
+    cwd?: string;
+    env: Record<string, string>;
+}): {
+    prepare: string;
+    file: string;
+    content: string;
+    launch: string;
+    cleanup: string;
+};
+/** For an SDK that takes no AbortSignal: an abort settles the call at once, and `late` receives a result that arrives afterwards. */
+export declare function untilAborted<T>(pending: Promise<T>, signal: AbortSignal | undefined, late?: (value: T) => Promise<unknown>): Promise<T>;

package/dist/sandbox/shell.js

@@ -0,0 +1,50 @@
+import { randomBytes } from "node:crypto";
+import { shellQuote } from "@tangle-network/agent-core/node";
+import { EnvironmentProviderError } from "@tangle-network/agent-interface/environment-provider";
+/** Exec over a run-to-completion command call: a timeout or abort kills every process carrying the exec's marker, so the remote work stops too. */
+export async function markedExec(command, options, provider, run) {
+    options?.signal?.throwIfAborted();
+    const marker = randomBytes(6).toString("hex");
+    const env = Object.entries(options?.env ?? {}).map(([key, value]) => `export ${key}=${shellQuote(value)}; `).join("");
+    const ended = new AbortController();
+    const timer = options?.timeoutMs === undefined ? undefined : setTimeout(() => ended.abort(new EnvironmentProviderError("timeout", `exec exceeded ${options.timeoutMs} ms`, { provider })), options.timeoutMs);
+    const signal = options?.signal === undefined ? ended.signal : AbortSignal.any([options.signal, ended.signal]);
+    try {
+        return await run(`export TBOX_EXEC=${marker}; ${env}${options?.cwd === undefined ? "" : `cd ${shellQuote(options.cwd)} && `}${command}`, signal);
+    }
+    catch (error) {
+        if (signal.aborted)
+            await run(`for p in /proc/[0-9]*; do grep -qz 'TBOX_EXEC=${marker}' "$p/environ" 2>/dev/null && kill -9 "\${p#/proc/}" 2>/dev/null; done; true`, AbortSignal.timeout(30_000)).catch(() => undefined);
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** The Bridge's credentials go to a file in a directory only the box user can open, sourced and deleted before exec, so no value enters an argv. */
+export function envFileLaunch(command, { cwd, env }) {
+    const dir = `/tmp/tbox-${randomBytes(8).toString("hex")}`;
+    return {
+        prepare: `umask 077 && mkdir ${dir}`,
+        file: `${dir}/env`,
+        content: Object.entries(env).map(([key, value]) => `export ${key}=${shellQuote(value)}\n`).join(""),
+        launch: `. ${dir}/env && rm -rf ${dir} && ${cwd === undefined ? "" : `cd ${shellQuote(cwd)} && `}exec ${command} >/tmp/bridge.log 2>&1`,
+        cleanup: `rm -rf ${dir}`,
+    };
+}
+/** For an SDK that takes no AbortSignal: an abort settles the call at once, and `late` receives a result that arrives afterwards. */
+export async function untilAborted(pending, signal, late) {
+    if (signal === undefined)
+        return pending;
+    signal.throwIfAborted();
+    let onAbort = () => undefined;
+    const aborted = new Promise((_, reject) => signal.addEventListener("abort", (onAbort = () => reject(signal.reason)), { once: true }));
+    try {
+        return await Promise.race([pending, aborted]);
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+        if (signal.aborted && late !== undefined)
+            void pending.then(late).catch(() => undefined);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-provider-cli-bridge",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "AgentEnvironmentProvider adapter for cli-bridge retained sessions and one-shot turns",
   "type": "module",
   "license": "MIT",
@@ -31,60 +31,16 @@
     "registry": "https://registry.npmjs.org"
   },
   "files": [
-    "dist/index.d.ts",
-    "dist/index.js",
-    "dist/environment-identity.d.ts",
-    "dist/environment-identity.js",
-    "dist/capability-discovery.d.ts",
-    "dist/capability-discovery.js",
-    "dist/context-transfer.d.ts",
-    "dist/context-transfer.js",
-    "dist/interaction-response.d.ts",
-    "dist/interaction-response.js",
-    "dist/observation.d.ts",
-    "dist/observation.js",
-    "dist/provider-options.d.ts",
-    "dist/provider-options.js",
-    "dist/retained-canonical-event.d.ts",
-    "dist/retained-canonical-event.js",
-    "dist/retained-control.d.ts",
-    "dist/retained-control.js",
-    "dist/retained-environment.d.ts",
-    "dist/retained-environment.js",
-    "dist/retained-event-cursor.d.ts",
-    "dist/retained-event-cursor.js",
-    "dist/retained-execution.d.ts",
-    "dist/retained-execution.js",
-    "dist/retained-native.d.ts",
-    "dist/retained-native.js",
-    "dist/retained-run-state.d.ts",
-    "dist/retained-run-state.js",
-    "dist/retained-stream.d.ts",
-    "dist/retained-stream.js",
-    "dist/transport.d.ts",
-    "dist/transport.js",
-    "dist/wire.d.ts",
-    "dist/wire.js",
-    "dist/sandbox/index.d.ts",
-    "dist/sandbox/index.js",
-    "dist/sandbox/box.d.ts",
-    "dist/sandbox/box.js",
-    "dist/sandbox/image.d.ts",
-    "dist/sandbox/image.js",
-    "dist/sandbox/provider.d.ts",
-    "dist/sandbox/provider.js",
-    "dist/sandbox/refusal.d.ts",
-    "dist/sandbox/refusal.js",
-    "dist/sandbox/vendor.d.ts",
-    "dist/sandbox/vendor.js",
+    "dist",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
+    "@tangle-network/agent-core": "^1.0.2",
     "@tangle-network/agent-interface": "^5.10.12",
-    "undici": "8.12.3",
     "@tangle-network/agent-profile-materialize": "1.1.4",
-    "@tangle-network/cli-agent-registry": "^0.14.0"
+    "@tangle-network/cli-agent-registry": "^0.14.0",
+    "undici": "8.12.3"
   },
   "devDependencies": {
     "@tangle-network/agent-provider-testkit": "0.12.4",