@volter/twin-world 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/twin-world",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "World configs for twins: boot named local runtimes, allocate ports, generate world.env/instance.json, and run apps against fake-key twin worlds.",
   "keywords": [
     "twin",

package/src/cli.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -588,7 +589,8 @@ async function main(): Promise<void> {
         caFile = join(mkdtempSync(join(tmpdir(), 'volter-attach-')), 'ca.pem');
         writeFileSync(caFile, manifest.ca);
       }
-      const injectPath = resolvePath(import.meta.dir, '../../control-plane/inject.cjs');
+      // The injector ships with @volter/twin (installed or workspace-linked); the sibling path is the bare checkout's.
+      const injectPath = (() => { try { return fileURLToPath(import.meta.resolve('@volter/twin/inject')); } catch { return resolvePath(import.meta.dir, '../../control-plane/inject.cjs'); } })();
       const env = remoteAttachEnv(manifest, { injectPath, ...(caFile === undefined ? {} : { caFile }) });
       const result = spawnSync(command[0]!, command.slice(1), { env: { ...process.env, ...env }, stdio: 'inherit' });
       process.exit(result.status ?? 1);

package/src/runtime.ts

@@ -329,6 +329,24 @@ const CONTROL_PLANE_EGRESS_ENV = [
   'all_proxy',
 ];
 
+/** The process's environment as the world admits it: what `stripEnv` names stays outside. */
+export function admittedEnv(strip: string[] | undefined, env: NodeJS.ProcessEnv = process.env): Record<string, string> {
+  const out: Record<string, string> = {};
+  const rules = (strip ?? []).map((s): { prefix: string } | { name: string } => (s.endsWith('*') ? { prefix: s.slice(0, -1) } : { name: s }));
+  for (const [k, v] of Object.entries(env)) {
+    if (v === undefined) continue;
+    if (rules.some((r) => ('prefix' in r ? k.startsWith(r.prefix) : k === r.name))) continue;
+    out[k] = v;
+  }
+  return out;
+}
+// The strip list of a running world, for `env`/`attach`: its config is the one the instance recorded.
+function stripEnvOf(instanceEnv: Record<string, string>): string[] | undefined {
+  const path = instanceEnv.VOLTER_WORLD_CONFIG;
+  if (!path) return undefined;
+  try { return (JSON.parse(readFileSync(path, 'utf8')) as { stripEnv?: string[] }).stripEnv; } catch { return undefined; }
+}
+
 function serviceProcessEnv(
   config: WorldConfig,
   service: WorldServiceConfig,
@@ -336,7 +354,7 @@ function serviceProcessEnv(
   port: number,
 ): Record<string, string> {
   const env: Record<string, string> = {
-    ...process.env,
+    ...admittedEnv(config.stripEnv),
     ...(config.env ?? {}),
     ...worldEnv,
     PORT: String(port),
@@ -645,6 +663,7 @@ async function startExternalService(
   service: WorldServiceConfig,
   paths: { root: string; logs: string },
   worldEnv: Record<string, string>,
+  stripEnv?: string[],
 ): Promise<WorldServiceInstance> {
   const external = service.external;
   if (!external) throw new Error(`External service "${service.id}" is missing its external config`);
@@ -653,7 +672,7 @@ async function startExternalService(
   // External commands see the accumulated world env (process.env + earlier services' discovered/
   // injected vars), so a later external can consume an earlier service's connection info.
   const env: NodeJS.ProcessEnv = {
-    ...process.env,
+    ...admittedEnv(stripEnv),
     ...worldEnv,
     ...(service.env ?? {}),
     VOLTER_WORLD_SERVICE_ID: service.id,
@@ -737,7 +756,7 @@ async function startService(
   worldEnv: Record<string, string>,
   paths: { root: string; instance: string; logs: string; data: string },
 ): Promise<WorldServiceInstance> {
-  if (service.type === 'external') return startExternalService(service, paths, worldEnv);
+  if (service.type === 'external') return startExternalService(service, paths, worldEnv, config.stripEnv);
   if (!service.command) throw new Error(`Service "${service.id}" must define command`);
   const port = service.port === undefined || service.port === 'auto' ? await allocatePort() : service.port;
   const serviceDataDir = join(paths.data, service.id);
@@ -862,7 +881,7 @@ async function startColocatedServices(
   const out = openPrivateLog(log, 'a');
   // The host is world infrastructure, not an app process — same egress hygiene as controlPlane
   // services (no injector preload, no ambient proxy): its twins SERVE, they don't call vendors.
-  const env: Record<string, string> = { ...process.env as Record<string, string>, ...(config.env ?? {}), ...worldEnv };
+  const env: Record<string, string> = { ...admittedEnv(config.stripEnv), ...(config.env ?? {}), ...worldEnv };
   for (const key of CONTROL_PLANE_EGRESS_ENV) delete env[key];
   const child = spawn(process.execPath, args, {
     cwd: paths.root,
@@ -2106,7 +2125,7 @@ function worldAttachedCommandEnv(name: string, root: string): { instance: Return
     if (sealed) throw new Error(`sealed world "${name}": attachment proxy failed; refusing to run the command (${error instanceof Error ? error.message : String(error)})`);
     // Keep env-only redirect if the ambient proxy cannot start.
   }
-  return { instance: status, env: { ...process.env, ...status.env, ...proxyEnv } };
+  return { instance: status, env: { ...admittedEnv(stripEnvOf(status.env)), ...status.env, ...proxyEnv } };
 }
 
 export function runWithWorldEnv(name: string, command: string[], root = process.cwd(), options: { cwd?: string } = {}): number {

package/src/schema.ts

@@ -207,6 +207,11 @@ export type WorldConfig = {
    * `isolation` option overrides it per boot. */
   isolation?: WorldIsolation;
   env?: Record<string, string>;
+  /** Variables of the process that runs the world which never enter it — a name, or a prefix ending in `*`
+   * (`HERMES_*`). The world seals what leaves over the wire; this seals what comes in through the environment:
+   * whatever steered the outer process (an agent's worker pinning its board and run) must not steer what runs
+   * inside, whose state is the world's own. Applied to every service the world starts and to `env`/`attach`. */
+  stripEnv?: string[];
   services: WorldServiceConfig[];
   share?: WorldShareConfig;
   actors?: Record<string, unknown>;
@@ -431,6 +436,9 @@ export function assertWorldConfig(value: unknown, path: string): WorldConfig {
       }
     }
   }
+  if (config.stripEnv !== undefined && (!Array.isArray(config.stripEnv) || config.stripEnv.some((s) => typeof s !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*\*?$/.test(s)))) {
+    throw new Error(`World config stripEnv must be a list of variable names or prefixes ending in * in ${path}`);
+  }
   const ids = new Set<string>();
   for (const service of config.services as Partial<WorldServiceConfig>[]) {
     if (!service || typeof service !== 'object') throw new Error(`Invalid service in ${path}`);