@veris-ai/daytona 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -8,14 +8,12 @@ export type { EgressMode, NetworkParams, NetworkPlan } from './network';
 export { buildNetwork, vendorHosts, twinHosts, directTwinHosts, dataPlaneHosts } from './network';
 export type { ServiceInfo as VerisServiceInfo, RouteEntry, TwinSandbox } from './control-plane';
 export { ControlPlane } from './control-plane';
-export { CA_CERT_PATH, SYSTEM_BUNDLE, VERIS_BUNDLE, VERIS_CA_FILE, NODE_TRUST_FLAG, BUNDLED_CA_FILES, BUNDLED_CA_PATCH_SCRIPT, nodeOptionsWithTrust, vendoredTrustEnv, trustPrelude, } from './trust';
+export { CA_CERT_PATH, SYSTEM_BUNDLE, VERIS_BUNDLE, VERIS_CA_FILE, NODE_TRUST_FLAG, NODE_PROXY_PRELOAD, NODE_PROXY_FLAG, BUNDLED_CA_FILES, BUNDLED_CA_PATCH_SCRIPT, nodeOptionsWithTrust, nodeOptionsWithProxy, verisNodeOptions, nodeProxyPreloadScript, vendoredTrustEnv, trustPrelude, } from './trust';
 export { gatewayIps, gatewayProxyUrl, patchBundledCas } from './gateway';
 export { DEFAULT_API_BASE, profilePath, resolveVerisCredentials, requireVerisCredentials, missingKeyMessage, } from './profile';
 export type { VerisCredentials, ResolveOpts, ProfileFile } from './profile';
 export { DAYTONA_API_URL, DELETE_SANDBOXES, daytonaApiUrl, fetchDaytonaKey, canDeleteSandboxes, cannotTeardownWarning, } from './daytona-key';
 export type { DaytonaKeyInfo } from './daytona-key';
-export { isPermissionDenied, sandboxBrakes, teardownRefusedMessage } from './teardown';
-export type { RefusedTeardown } from './teardown';
 export { fetchManual, assertHttpControlPlane } from './state';
 export { VerisError, MissingCredentialsError, VerisGatewayUnreachableError, VerisGatewayNotOfferedError, ReceiptIntegrityError, VerisUntouchedError, TwinExpiredError, SnapshotUnsupportedError, UnsupportedOperationError, } from './errors';
 export type { VerisErrorPhase } from './errors';

package/dist/index.js

@@ -524,9 +524,38 @@ function bundledCaPatchScript() {
 }
 var NODE_TRUST_FLAG = "--use-openssl-ca";
 function nodeOptionsWithTrust(existing) {
+  return appendFlag(existing, NODE_TRUST_FLAG);
+}
+var NODE_PROXY_PRELOAD = "/tmp/veris-node-proxy.cjs";
+var NODE_PROXY_FLAG = `--require ${NODE_PROXY_PRELOAD}`;
+function nodeProxyPreloadScript() {
+  return [
+    `// Preloaded by @veris-ai/daytona through NODE_OPTIONS=--require.`,
+    `// Gives every http(s).Agent the proxy environment, which Node applies only`,
+    `// to its global agents under NODE_USE_ENV_PROXY=1. An SDK that builds its own`,
+    `// Agent would otherwise dial the vendor directly, which this sandbox cannot.`,
+    `for (const mod of [require("http"), require("https")]) {`,
+    `  const Base = mod.Agent`,
+    `  mod.Agent = class Agent extends Base {`,
+    `    constructor(options) {`,
+    `      super({ proxyEnv: process.env, ...(options || {}) })`,
+    `    }`,
+    `  }`,
+    `}`,
+    ``
+  ].join("\n");
+}
+function nodeOptionsWithProxy(existing) {
+  return appendFlag(existing, NODE_PROXY_FLAG);
+}
+function verisNodeOptions(existing, opts = {}) {
+  const withProxy = nodeOptionsWithProxy(existing);
+  return opts.trust === false ? withProxy : nodeOptionsWithTrust(withProxy);
+}
+function appendFlag(existing, flag) {
   const base = (existing ?? "").trim();
-  if (base.split(/\s+/).includes(NODE_TRUST_FLAG)) return base;
-  return base ? `${base} ${NODE_TRUST_FLAG}` : NODE_TRUST_FLAG;
+  if (base === flag || base.startsWith(`${flag} `) || base.endsWith(` ${flag}`) || base.includes(` ${flag} `)) return base;
+  return base ? `${base} ${flag}` : flag;
 }
 var CA_INSTALL_CMD = [
   "update-ca-certificates",
@@ -599,6 +628,7 @@ function assertProxyUrl(raw) {
 async function installCa(sandbox, caPem) {
   await sandbox.fs.uploadFile(Buffer.from(caPem, "utf8"), VERIS_CA_FILE);
   await sandbox.fs.uploadFile(Buffer.from(bundledCaPatchScript(), "utf8"), BUNDLED_CA_PATCH_SCRIPT);
+  await installNodeProxyPreload(sandbox);
   const script = [
     `chmod 0644 ${VERIS_CA_FILE}`,
     // Public roots first so they keep working; ours appended. `cat` of a
@@ -624,6 +654,9 @@ async function installCa(sandbox, caPem) {
     );
   }
 }
+async function installNodeProxyPreload(sandbox) {
+  await sandbox.fs.uploadFile(Buffer.from(nodeProxyPreloadScript(), "utf8"), NODE_PROXY_PRELOAD);
+}
 async function patchBundledCas(sandbox) {
   const r = await sh(sandbox, `sh ${BUNDLED_CA_PATCH_SCRIPT}`, 180).catch((e) => ({ exitCode: 1, result: String(e) }));
   return (r.result ?? "").split("\n").filter((line) => line.startsWith(BUNDLED_CA_PATCHED_MARKER)).map((line) => line.slice(BUNDLED_CA_PATCHED_MARKER.length).trim()).filter(Boolean);
@@ -916,7 +949,7 @@ function requireVerisCredentials(opts = {}) {
 }
 
 // src/version.ts
-var SDK_VERSION = true ? "0.3.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "0.4.0" : "0.0.0-dev";
 
 // src/daytona.ts
 var LABEL = {
@@ -994,9 +1027,12 @@ var Daytona = class extends BaseDaytona {
       const verisManaged = {
         ...v.installCa !== false ? sanitizeTrustEnv(void 0) : {},
         // Node reads none of the variables above once Daytona has overwritten
-        // them; the flag makes it read OpenSSL's store, which the CA install
-        // fills. Appended, not replaced: a caller's own NODE_OPTIONS keep working.
-        ...v.installCa !== false ? { NODE_OPTIONS: nodeOptionsWithTrust(rest.envVars?.NODE_OPTIONS) } : {},
+        // them; the trust flag makes it read OpenSSL's store, which the CA
+        // install fills. The preload gives every http(s).Agent the proxy
+        // environment, which NODE_USE_ENV_PROXY below reaches only for the
+        // global ones. Appended, not replaced: a caller's own NODE_OPTIONS keep
+        // working.
+        NODE_OPTIONS: verisNodeOptions(rest.envVars?.NODE_OPTIONS, { trust: v.installCa !== false }),
         // Node ignores HTTPS_PROXY unless told to, and Daytona blocks anything
         // that dials out directly — so without this every plain `https.get`
         // and `fetch` in Node 24+ dies with ECONNRESET instead of reaching
@@ -1039,7 +1075,8 @@ var Daytona = class extends BaseDaytona {
       });
     }
     try {
-      await installCa(sandbox, credential.ca_pem);
+      if (v.installCa !== false) await installCa(sandbox, credential.ca_pem);
+      else await installNodeProxyPreload(sandbox);
       await probeCanary(sandbox, credential.canary_host, twin.id);
     } catch (err) {
       await sandbox.delete().catch(() => {
@@ -1258,38 +1295,6 @@ var DELETE_PERMISSION_FIX = 'create a key with the "delete sandboxes" permission
 function cannotTeardownWarning(key, autoStopMinutes, autoDeleteMinutes) {
   return `DAYTONA_API_KEY ${describeKey(key)} lacks \`${DELETE_SANDBOXES}\`, so \`veris-daytona teardown\` will be refused for the sandbox about to be created, and \`run\` cannot delete its own. The box still stops after ${autoStopMinutes} idle minutes and is deleted ${autoDeleteMinutes} minutes after it stops. For a teardown that works, ${DELETE_PERMISSION_FIX} and use it instead.`;
 }
-
-// src/teardown.ts
-var TEARDOWN_USAGE = `usage: veris-daytona teardown <daytona-sandbox-id>
-
-Deletes the Daytona sandbox. The id is the one \`veris-daytona provision\`
-printed as daytonaSandboxId \u2014 not the Veris twin's id.
-
-The twin follows the rule it was created under: one this package created is
-deleted with the sandbox, one it attached to (\`provision\`, or \`run --sandbox\`)
-is yours and is left running. Which of the two happened is printed.
-
-needs: DAYTONA_API_KEY with the ${DELETE_SANDBOXES} permission \u2014 a key made with
-"write sandboxes" alone is refused, and the refusal says when Daytona will stop
-and delete the box on its own. To reach a twin that must be deleted, a Veris
-key too: VERIS_API_KEY, or the profile \`veris login\` saved.
-
-exit code: 0 when the sandbox is deleted; 1 when there is no such sandbox, or
-the key may not delete one.`;
-function isPermissionDenied(e) {
-  return typeof e === "object" && e !== null && e.statusCode === 403;
-}
-function sandboxBrakes(r) {
-  const stop = r.autoStopMinutes && r.autoStopMinutes > 0 ? `stops after ${r.autoStopMinutes} idle minutes` : "never stops on its own";
-  const del = r.autoDeleteMinutes === void 0 || r.autoDeleteMinutes < 0 ? "is never auto-deleted" : r.autoDeleteMinutes === 0 ? "is deleted as soon as it stops" : `is deleted ${r.autoDeleteMinutes} minutes after it stops`;
-  const destroy = r.expiresAt ? `, and is destroyed at ${r.expiresAt} whatever state it is in` : "";
-  return `${stop} and ${del}${destroy}`;
-}
-function teardownRefusedMessage(r) {
-  const key = r.key ? `this DAYTONA_API_KEY ${describeKey(r.key)} lacks the \`${DELETE_SANDBOXES}\` permission` : `Daytona answered 403 (Access denied), which is what a DAYTONA_API_KEY without the \`${DELETE_SANDBOXES}\` permission gets \u2014 the key's own record could not be read to confirm it`;
-  const twin = r.twinId === void 0 ? "" : r.ownsTwin ? ` Its twin ${r.twinId} was deleted before Daytona refused, so nothing is left on the Veris side.` : ` Twin ${r.twinId} is yours and was not touched.`;
-  return `Daytona refused to delete sandbox ${r.sandboxId}: ${key}. The sandbox is still there: it ${sandboxBrakes(r)}.${twin} To delete it sooner, ${DELETE_PERMISSION_FIX}, then run \`veris-daytona teardown ${r.sandboxId}\` with it \u2014 or delete the sandbox in the Daytona dashboard.`;
-}
 export {
   BUNDLED_CA_FILES,
   BUNDLED_CA_PATCH_SCRIPT,
@@ -1300,6 +1305,8 @@ export {
   DELETE_SANDBOXES,
   Daytona,
   MissingCredentialsError,
+  NODE_PROXY_FLAG,
+  NODE_PROXY_PRELOAD,
   NODE_TRUST_FLAG,
   ReceiptIntegrityError,
   SDK_VERSION,
@@ -1325,20 +1332,20 @@ export {
   fetchManual,
   gatewayIps,
   gatewayProxyUrl,
-  isPermissionDenied,
   isVerisSandbox,
   missingKeyMessage,
+  nodeOptionsWithProxy,
   nodeOptionsWithTrust,
+  nodeProxyPreloadScript,
   patchBundledCas,
   profilePath,
   requireVerisCredentials,
   resolveVerisCredentials,
-  sandboxBrakes,
-  teardownRefusedMessage,
   trustPrelude,
   twinHosts,
   vendorHosts,
   vendoredTrustEnv,
+  verisNodeOptions,
   verisOwnsTwin,
   verisTwinId
 };