@tangle-network/agent-app 0.46.8 → 0.46.10

package/dist/sandbox/index.d.ts

@@ -340,9 +340,76 @@ export declare function sandboxToolPath(options: SandboxToolPathOptions & {
 }): string;
 /** Build file mounts for sandbox tools based on provided options and tool configurations */
 export declare function buildSandboxToolFileMounts(options: BuildSandboxToolFileMountsOptions): AgentProfileFileMount[];
-/** Build a shell script that sets up and exports the sandbox tool binary directory in user profiles */
+/**
+ * Build the `SANDBOX_TOOL_BIN_DIRS` entry that puts these apps' tool bin dirs on
+ * a sandbox PATH. Declare it in the same box env as the mounts from
+ * {@link buildSandboxToolFileMounts}: the mounts place the executables, this
+ * places the directory that makes a bare tool name resolve.
+ *
+ * Every sandbox PATH builder appends these directories at the TAIL, after the
+ * Nix, npm, and image entries, so a tool never shadows a platform or system
+ * binary of the same name. That placement is identical for a non-interactive
+ * exec, a sidecar-spawned CLI, and an SSH shell, which is why this variable and
+ * not a shell rc file is the mechanism: an exec reads no rc file, and the SSH
+ * shell environment assigns PATH absolutely.
+ *
+ * Entries come from {@link sandboxToolBinDir}, so the value can never name a
+ * directory the mounts did not use — a caller that hand-writes the literal
+ * instead drifts silently the moment a base dir changes. Order is preserved,
+ * and two apps that resolve to one directory collapse to the FIRST position it
+ * appeared in.
+ *
+ * A `:` in a resolved bin dir throws here. The character separates entries both
+ * in this variable and in PATH itself, so such a directory is unrepresentable
+ * rather than merely awkward: joining it would split one absolute path into a
+ * leading path and a relative remainder, and the runtime rejects a relative
+ * segment by failing the whole box. Throwing names the offending directory
+ * instead.
+ *
+ * The consuming half lives in agent-dev-container: `resolveSandboxToolBinDirs`
+ * parses this value and every PATH builder appends it at the tail — sidecar
+ * exec and PTY through `packages/shared/src/cache-env.ts`, an SSH session
+ * through `packages/shared/src/ssh-bootstrap.ts`, and a spawned CLI through
+ * `packages/sdk-cli-runner/src/cli-process.ts`, each with its own tests. This
+ * package has no sandbox runtime, so tail placement is pinned there, not here.
+ */
+export declare function buildSandboxToolBinDirsEnv(apps: readonly SandboxToolPathOptions[]): {
+    SANDBOX_TOOL_BIN_DIRS: string;
+};
+/**
+ * Build a shell script that creates the sandbox tool binary directory.
+ * {@link buildSandboxToolBinDirsEnv}, not this script, puts that directory on a
+ * sandbox PATH.
+ *
+ * The `mkdir -p` makes the directory exist before a tool mount lands in it.
+ */
+export declare function buildSandboxToolBinDirScript(options: SandboxToolPathOptions): string;
+/** Build a shell script that creates the sandbox tool binary directory.
+ *
+ *  @deprecated Renamed to {@link buildSandboxToolBinDirScript}, and the script
+ *  no longer appends the bin dir to PATH in `~/.profile`, `~/.bashrc` and
+ *  `~/.zshrc`. Those edits never reached the contexts that run a tool: an exec
+ *  and a spawned CLI read no rc file, and the SSH shell assigns PATH
+ *  absolutely, which discards an appended entry. Put the directory on PATH with
+ *  {@link buildSandboxToolBinDirsEnv} instead. This name forwards to the new
+ *  one so an existing import keeps resolving; removal is a major.
+ */
 export declare function buildSandboxToolPathSetupScript(options: SandboxToolPathOptions): string;
-/** Resolve the sandbox environment PATH setup by executing the configuration script with given options */
+/**
+ * Create the sandbox tool binary directory in a running box.
+ * {@link buildSandboxToolBinDirsEnv}, not this call, puts it on a sandbox PATH.
+ */
+export declare function ensureSandboxToolBinDir(box: SandboxInstance, options: SandboxToolPathOptions): Promise<Outcome<void>>;
+/** Create the sandbox tool binary directory in a running box.
+ *
+ *  @deprecated Renamed to {@link ensureSandboxToolBinDir}, and the call no
+ *  longer appends the bin dir to PATH in `~/.profile`, `~/.bashrc` and
+ *  `~/.zshrc`. Those edits never reached the contexts that run a tool: an exec
+ *  and a spawned CLI read no rc file, and the SSH shell assigns PATH
+ *  absolutely, which discards an appended entry. Put the directory on PATH with
+ *  {@link buildSandboxToolBinDirsEnv} instead. This name forwards to the new
+ *  one so an existing import keeps resolving; removal is a major.
+ */
 export declare function runSandboxToolPathSetup(box: SandboxInstance, options: SandboxToolPathOptions): Promise<Outcome<void>>;
 /** Split profile files into inline deferred files and a lean profile without them */
 export declare function splitDeferredProfileFiles(profile: AgentProfile): {

package/dist/sandbox/index.js

@@ -28,6 +28,8 @@ import {
   attachReasoningEffort,
   buildAppToolMcpServers,
   buildProductEgressPolicy,
+  buildSandboxToolBinDirScript,
+  buildSandboxToolBinDirsEnv,
   buildSandboxToolFileMounts,
   buildSandboxToolPathSetupScript,
   classifySeveredStream,
@@ -41,6 +43,7 @@ import {
   deleteSecret,
   detectInteractiveQuestion,
   driveSandboxTurn,
+  ensureSandboxToolBinDir,
   ensureWorkspaceSandbox,
   flattenHistory,
   formatSandboxProvisioningSupportDetails,
@@ -88,7 +91,7 @@ import {
   workspaceSandboxRecoveryMessage,
   workspaceSandboxRecoveryRecommendedActions,
   writeProfileFilesToBox
-} from "../chunk-MA2RIIIH.js";
+} from "../chunk-3HBH5GFN.js";
 import "../chunk-TH7L265V.js";
 import "../chunk-LWSJK546.js";
 import "../chunk-P5PIAQVS.js";
@@ -127,6 +130,8 @@ export {
   attachReasoningEffort,
   buildAppToolMcpServers,
   buildProductEgressPolicy,
+  buildSandboxToolBinDirScript,
+  buildSandboxToolBinDirsEnv,
   buildSandboxToolFileMounts,
   buildSandboxToolPathSetupScript,
   classifySeveredStream,
@@ -140,6 +145,7 @@ export {
   deleteSecret,
   detectInteractiveQuestion,
   driveSandboxTurn,
+  ensureSandboxToolBinDir,
   ensureWorkspaceSandbox,
   flattenHistory,
   formatSandboxProvisioningSupportDetails,

package/dist/studio-react/composer-persistence.d.ts

@@ -0,0 +1,12 @@
+import type { ModelOptionValue } from '../studio';
+import type { ComposerType } from './studio-composer';
+export interface PersistedComposerSelections {
+    v: 1;
+    type: ComposerType;
+    selectedModels: Partial<Record<ComposerType, string>>;
+    /** Option values are model-specific: two models in one lane may publish
+     *  different enums for the same parameter. */
+    optionsByModel: Record<string, Record<string, ModelOptionValue>>;
+}
+export declare function loadComposerSelections(workspaceId: string): PersistedComposerSelections | null;
+export declare function saveComposerSelections(workspaceId: string, snapshot: PersistedComposerSelections): void;

package/dist/studio-react/index.js

@@ -685,6 +685,58 @@ function optionValueLabel(param, value) {
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
 
+// src/studio-react/composer-persistence.ts
+var COMPOSER_TYPES = ["image", "video", "speech"];
+function storageKey(workspaceId) {
+  return `studio-composer:${workspaceId}`;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isComposerType(value) {
+  return COMPOSER_TYPES.some((type) => type === value);
+}
+function isOptionValue(value) {
+  return typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function parseSelections(value) {
+  if (!isPlainObject(value) || value.v !== 1 || !isComposerType(value.type)) return null;
+  if (!isPlainObject(value.selectedModels) || !isPlainObject(value.optionsByModel)) return null;
+  const selectedModels = {};
+  for (const type of COMPOSER_TYPES) {
+    const modelId = value.selectedModels[type];
+    if (typeof modelId === "string") selectedModels[type] = modelId;
+  }
+  const optionsByModel = {};
+  for (const [modelId, rawOptions] of Object.entries(value.optionsByModel)) {
+    if (!isPlainObject(rawOptions)) continue;
+    const options = {};
+    for (const [param, optionValue] of Object.entries(rawOptions)) {
+      if (isOptionValue(optionValue)) options[param] = optionValue;
+    }
+    optionsByModel[modelId] = options;
+  }
+  return { v: 1, type: value.type, selectedModels, optionsByModel };
+}
+function loadComposerSelections(workspaceId) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.getItem(storageKey(workspaceId));
+    return raw === null ? null : parseSelections(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function saveComposerSelections(workspaceId, snapshot) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(storageKey(workspaceId), JSON.stringify(snapshot));
+  } catch {
+  }
+}
+
 // src/studio-react/studio-composer.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var SEGMENTS = [
@@ -760,8 +812,26 @@ function StudioComposer({
   const [referenceImageUrl, setReferenceImageUrl] = useState3(null);
   const [isSubmitting, setIsSubmitting] = useState3(false);
   const [error, setError] = useState3(null);
+  const [hydratedWorkspaceId, setHydratedWorkspaceId] = useState3(null);
   const submitLockRef = useRef2(false);
   const bandRef = useRef2(null);
+  const hydratedRef = useRef2(false);
+  const persistedOptionsRef = useRef2({});
+  useEffect3(() => {
+    hydratedRef.current = false;
+    setHydratedWorkspaceId(null);
+    if (!workspaceId) return;
+    const persisted = loadComposerSelections(workspaceId);
+    if (persisted) {
+      setType(persisted.type);
+      setSelectedModels(persisted.selectedModels);
+      persistedOptionsRef.current = persisted.optionsByModel;
+    } else {
+      persistedOptionsRef.current = {};
+    }
+    hydratedRef.current = true;
+    setHydratedWorkspaceId(workspaceId);
+  }, [workspaceId]);
   useEffect3(() => {
     if (!workspaceId) return;
     let cancelled = false;
@@ -814,13 +884,35 @@ function StudioComposer({
   );
   useEffect3(() => {
     setOptionValues((current) => {
-      const next = reconcileOptionValues(options, current[type], {
+      const seed = { ...persistedOptionsRef.current[modelId], ...current[type] };
+      const next = reconcileOptionValues(options, seed, {
         allowCustomSize: supportsCustomImageSize(modelId)
       });
       const unchanged = Object.keys(next).length === Object.keys(current[type]).length && Object.entries(next).every(([key, value]) => current[type][key] === value);
       return unchanged ? current : { ...current, [type]: next };
     });
   }, [modelId, options, type]);
+  useEffect3(() => {
+    if (!workspaceId || !hydratedRef.current || hydratedWorkspaceId !== workspaceId) return;
+    if (!catalog && modelId && persistedOptionsRef.current[modelId] !== void 0 && !options) return;
+    const seed = { ...persistedOptionsRef.current[modelId], ...optionValues[type] };
+    const reconciled = reconcileOptionValues(options, seed, {
+      allowCustomSize: supportsCustomImageSize(modelId)
+    });
+    const reconciledReady = Object.keys(reconciled).length === Object.keys(optionValues[type]).length && Object.entries(reconciled).every(([key, value]) => optionValues[type][key] === value);
+    if (!reconciledReady) return;
+    const optionsByModel = {
+      ...persistedOptionsRef.current,
+      ...modelId ? { [modelId]: optionValues[type] } : {}
+    };
+    saveComposerSelections(workspaceId, {
+      v: 1,
+      type,
+      selectedModels,
+      optionsByModel
+    });
+    persistedOptionsRef.current = optionsByModel;
+  }, [catalog, hydratedWorkspaceId, modelId, optionValues, options, selectedModels, type, workspaceId]);
   const values = optionValues[type];
   const params = visibleParams(type, options);
   const audioMeta = type === "video" ? options?.audio : void 0;