@prismatic-io/lux 0.0.2-preview.29 → 0.0.2-preview.30

package/src/core/agent-environment.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+
+export const InheritEnvironmentSchema = z.union([z.array(z.string().min(1)), z.literal(true)]);
+export type InheritEnvironment = z.infer<typeof InheritEnvironmentSchema>;
+
+const nativeEnvironment = new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "LANG",
+  "LANGUAGE",
+  "TERM",
+  "COLORTERM",
+  "NO_COLOR",
+  "FORCE_COLOR",
+  "CI",
+  "TZ",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_CACHE_HOME",
+  "XDG_STATE_HOME",
+  "CODEX_HOME",
+  "CLAUDE_CONFIG_DIR",
+  "CLAUDE_SECURESTORAGE_CONFIG_DIR",
+  "GROK_HOME",
+  "SYSTEMROOT",
+  "WINDIR",
+  "COMSPEC",
+  "PATHEXT",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "USERPROFILE",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "USERNAME",
+]);
+
+export const agentEnvironment = (
+  parent: NodeJS.ProcessEnv,
+  inherit: InheritEnvironment = true,
+  overrides?: NodeJS.ProcessEnv,
+): Record<string, string> => {
+  const selected =
+    inherit === true
+      ? { ...parent }
+      : Object.fromEntries(
+          Object.entries(parent).filter(
+            ([name]) =>
+              nativeEnvironment.has(name.toUpperCase()) ||
+              name.startsWith("LC_") ||
+              inherit.includes(name),
+          ),
+        );
+  return Object.fromEntries(
+    Object.entries({ ...selected, ...overrides }).filter(
+      (entry): entry is [string, string] => entry[1] !== undefined,
+    ),
+  );
+};

package/src/core/command-verification.ts

@@ -0,0 +1,74 @@
+import { chmod, lstat, mkdir, mkdtemp, readdir, realpath, rm, symlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { Run } from "./run.js";
+import { copyRegularFileNoFollow } from "./secure-copy.js";
+
+const executionWorkspaces = new WeakMap<Run, string>();
+
+/** Internal: live execution state is deliberately absent from persisted run evidence. */
+export const bindRunExecutionWorkspace = (run: Run, root: string): void => {
+  executionWorkspaces.set(run, resolve(root));
+};
+
+export const runExecutionWorkspace = (run: Run): string | undefined => executionWorkspaces.get(run);
+
+const within = (root: string, path: string): boolean => {
+  const rel = relative(root, path);
+  return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+};
+
+/** A disposable command tree preserves dependencies without exposing host symlink targets. */
+export const copyCommandWorkspace = async (
+  source: string,
+  signal?: AbortSignal,
+): Promise<{
+  root: string;
+  close: () => Promise<void>;
+}> => {
+  const sourceRoot = await realpath(source);
+  if (!(await lstat(source)).isDirectory() || (await lstat(source)).isSymbolicLink()) {
+    throw new Error(`verification workspace must be a real directory: ${source}`);
+  }
+  const root = await mkdtemp(join(tmpdir(), "lux-command-verification-"));
+  const close = () => rm(root, { recursive: true, force: true });
+  let entries = 0;
+  const copy = async (directory: string): Promise<void> => {
+    if (!within(sourceRoot, await realpath(directory))) {
+      throw new Error(`verification directory escapes its workspace: ${directory}`);
+    }
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      signal?.throwIfAborted();
+      if (++entries > 100_000) throw new Error("verification workspace exceeds 100000 entries");
+      if (directory === sourceRoot && entry.name === ".lux-claude") continue;
+      const path = join(directory, entry.name);
+      const target = join(root, relative(sourceRoot, path));
+      const metadata = await lstat(path);
+      if (metadata.isSymbolicLink()) {
+        const resolved = await realpath(path);
+        if (!within(sourceRoot, resolved)) {
+          throw new Error(`verification symlink escapes its workspace: ${path}`);
+        }
+        await symlink(
+          relative(dirname(target), join(root, relative(sourceRoot, resolved))),
+          target,
+        );
+      } else if (metadata.isDirectory()) {
+        await mkdir(target, { mode: (metadata.mode & 0o777) | 0o700 });
+        await copy(path);
+        await chmod(target, metadata.mode & 0o777);
+      } else if (metadata.isFile()) {
+        await copyRegularFileNoFollow(sourceRoot, path, target);
+      } else {
+        throw new Error(`verification workspace contains an unsupported entry: ${path}`);
+      }
+    }
+  };
+  try {
+    await copy(sourceRoot);
+    return { root, close };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+};

package/src/core/driver.ts

@@ -13,6 +13,8 @@ export const ArtifactSchema = z.object({
    * Consumers resolve `path` against this before falling back to the default.
    */
   root: z.exactOptional(z.string()),
+  /** Assigned by Lux against fixture bytes frozen before the subject starts. */
+  origin: z.exactOptional(z.enum(["generated", "modified", "fixture"])),
   contentType: z.exactOptional(z.string()),
   size: z.exactOptional(z.number()),
   meta: z.exactOptional(z.record(z.string(), z.unknown())),
@@ -72,6 +74,8 @@ export interface AgentDriver {
    * responsible for stopping background writers before this promise resolves.
    */
   collect(): Promise<Artifact[]>;
+  /** Optional quiesced full execution tree for private command verification, until close. */
+  verificationWorkspace?(): Promise<string | undefined>;
   close(): Promise<void>;
 }
 

package/src/core/index.ts

@@ -1,5 +1,6 @@
 export * from "./action-events.js";
 export * from "./agent-activity.js";
+export * from "./agent-environment.js";
 export * from "./agent-events.js";
 export * from "./annotation.js";
 export * from "./answerer.js";
@@ -7,6 +8,7 @@ export * from "./artifact-evidence.js";
 export * from "./artifact-snapshot.js";
 export * from "./assertion.js";
 export * from "./case.js";
+export * from "./command-verification.js";
 export * from "./conversation-turn.js";
 export * from "./driver.js";
 export * from "./driver-metrics.js";

package/src/core/model-cli.ts

@@ -1,6 +1,11 @@
 import { rm } from "node:fs/promises";
 import { temporaryDirectory } from "tempy";
 import { z } from "zod";
+import {
+  agentEnvironment,
+  type InheritEnvironment,
+  InheritEnvironmentSchema,
+} from "./agent-environment.js";
 import { exec } from "./exec.js";
 import {
   defaultCatalogEffort,
@@ -62,6 +67,8 @@ export const HarnessModelConfigSchema = z
     provider: ModelCliProviderSchema,
     model: z.string().min(1),
     command: z.string().optional(),
+    inheritEnv: InheritEnvironmentSchema.optional(),
+    env: z.record(z.string(), z.string()).optional(),
     reasoningEffort: ReasoningEffortSchema.optional(),
   })
   .strict()
@@ -93,6 +100,8 @@ export const mergeHarnessModelConfig = (
 
 export type ModelCliOptions = {
   provider: ModelCliProvider;
+  inheritEnv?: InheritEnvironment | undefined;
+  env?: Record<string, string> | undefined;
   command?: string | undefined;
   model?: string | undefined;
   reasoningEffort?: ReasoningEffort | undefined;
@@ -169,7 +178,9 @@ const runClaude = async (
         // empty value disables user/project/local settings for this one-shot.
         "--setting-sources",
         "",
-        ...(process.env.ANTHROPIC_API_KEY ? ["--bare"] : []),
+        ...(agentEnvironment(process.env, options.inheritEnv, options.env).ANTHROPIC_API_KEY
+          ? ["--bare"]
+          : []),
         "--settings",
         JSON.stringify({ disableAllHooks: true }),
         "--system-prompt",
@@ -180,7 +191,7 @@ const runClaude = async (
         timeoutMs: options.timeoutMs,
         cwd: workspace,
         env: {
-          ...process.env,
+          ...agentEnvironment(process.env, options.inheritEnv, options.env),
           CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
           CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
           CLAUDE_CODE_SKIP_PROMPT_HISTORY: "1",
@@ -252,6 +263,7 @@ const runCodex = async (
       input,
       timeoutMs: options.timeoutMs,
       cwd: modelCwd,
+      env: agentEnvironment(process.env, options.inheritEnv, options.env),
       ...(options.signal ? { signal: options.signal } : {}),
     });
     if (result.timedOut) throw new Error(`model call timed out after ${options.timeoutMs}ms`);

package/src/drivers/antigravity/config.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { InheritEnvironmentSchema } from "../../core/agent-environment.js";
 import { DurationSchema } from "../../core/duration.js";
 import { antigravityCatalog, applyCatalogEffort } from "../../core/index.js";
 
@@ -37,6 +38,7 @@ export const AntigravityDriverConfigSchema = z
     reuseKeychain: z.boolean().default(false),
     cwd: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),
+    inheritEnv: InheritEnvironmentSchema.optional(),
     extraArgs: z.array(z.string()).optional(),
     idleTimeout: DurationSchema.default("10 minutes"),
     maxLineBytes: z.number().positive().default(10_000_000),

package/src/drivers/antigravity/runtime.ts

@@ -2,6 +2,7 @@ import { chmod, copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promise
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
 import { temporaryDirectory } from "tempy";
+import { agentEnvironment } from "../../core/agent-environment.js";
 import { exec } from "../../core/exec.js";
 import { captureAntigravityArtifacts } from "./artifacts.js";
 import type { AntigravityDriverConfig } from "./config.js";
@@ -16,7 +17,10 @@ export const prepareAntigravityRuntime = async (
 }> => {
   if (config.permissionMode === "inherit")
     return {
-      env: config.env,
+      env:
+        config.inheritEnv === undefined
+          ? config.env
+          : agentEnvironment(process.env, config.inheritEnv, config.env),
       collect: async (destination) => {
         if (isolatedHome) await captureAntigravityArtifacts(isolatedHome, destination);
       },
@@ -74,7 +78,9 @@ export const prepareAntigravityRuntime = async (
     }
     return {
       env: {
-        ...config.env,
+        ...(config.inheritEnv === undefined
+          ? config.env
+          : agentEnvironment(process.env, config.inheritEnv, config.env)),
         HOME: runtimeHome,
         ...(process.platform === "win32" ? { USERPROFILE: runtimeHome } : {}),
       },