agentram 0.1.43 → 0.1.47

package/agentram/cli.py

@@ -31,33 +31,12 @@ def looks_like_raw_api_key(value: str) -> bool:
     return not bool(ENV_NAME_PATTERN.fullmatch(stripped))
 
 
-def update_env_file_value(path: Path, key: str, value: str) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    lines = path.read_text(encoding="utf-8").splitlines() if path.exists() else []
-    assignment = f"{key}={value}"
-    updated = False
-    output: list[str] = []
-    for line in lines:
-        if line.strip().startswith(f"{key}="):
-            output.append(assignment)
-            updated = True
-        else:
-            output.append(line)
-    if not updated:
-        if output and output[-1].strip():
-            output.append("")
-        output.append("# Added by AgentRAM TUI setup")
-        output.append(assignment)
-    path.write_text("\n".join(output) + "\n", encoding="utf-8")
-
-
 def resolve_api_key_env(slot: str, value: str) -> tuple[str, str | None]:
     stripped = value.strip()
     if not stripped:
         return "", None
     if looks_like_raw_api_key(stripped):
         env_name = f"AGENTRAM_{slot.upper()}_API_KEY"
-        update_env_file_value(Path(".env"), env_name, stripped)
         os.environ[env_name] = stripped
         return env_name, env_name
     return stripped, None
@@ -614,7 +593,9 @@ def run_textual_tui(context: McpContext) -> bool:
             self.context.profile_store.set_agent(slot, endpoint)
             set_global_agent_if_available(self.context, slot, endpoint)
             if saved_env_name:
-                return f"{slot}={provider}:{model} key=.env:{saved_env_name}"
+                save_global_env_if_available(self.context, saved_env_name)
+            if saved_env_name:
+                return f"{slot}={provider}:{model} key=global-jsonl:{saved_env_name}"
             return f"{slot}={provider}:{model}"
 
         def action_save_setup(self) -> None:
@@ -1249,6 +1230,19 @@ def bind_model_text(context: McpContext, options: dict[str, object]) -> str:
     return f"Bound model: {endpoint.get('id')} provider={endpoint.get('provider')} model={endpoint.get('model')} role={endpoint.get('role')}"
 
 
+def save_global_env_if_available(context: McpContext, env_name: str) -> bool:
+    if not env_name or not global_agent_profile_enabled():
+        return False
+    value = os.getenv(env_name, "")
+    if not value:
+        return False
+    try:
+        context.global_profile_store.set_env_value(env_name, value)
+        return True
+    except OSError:
+        return False
+
+
 def set_global_agent_if_available(context: McpContext, slot: str, endpoint: AgentModelEndpoint) -> bool:
     if not global_agent_profile_enabled():
         return False

package/agentram/orchestration.py

@@ -8,12 +8,69 @@ from pathlib import Path
 import re
 import shlex
 import subprocess
+import sys
 import tempfile
 import urllib.error
 import urllib.request
 from typing import Any, Callable
 from uuid import uuid4
 
+from .config import global_agent_profile_enabled, global_agent_profile_path
+
+
+@dataclass(frozen=True)
+class CliProcessResult:
+    returncode: int
+    stdout: str
+    stderr: str
+
+def cli_stream_output_enabled() -> bool:
+    value = os.getenv("AGENTRAM_STREAM_CLI_OUTPUT", "").strip().lower()
+    return value in {"1", "true", "yes", "on"}
+
+def run_cli_process(args: list[str], timeout: int) -> CliProcessResult:
+    if not cli_stream_output_enabled():
+        process = subprocess.run(
+            args,
+            check=False,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            encoding="utf-8",
+            timeout=timeout,
+        )
+        return CliProcessResult(process.returncode, process.stdout or "", process.stderr or "")
+
+    process = subprocess.Popen(
+        args,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        encoding="utf-8",
+        errors="replace",
+        text=True,
+    )
+    lines: list[str] = []
+    try:
+        assert process.stdout is not None
+        for line in process.stdout:
+            lines.append(line)
+            print(line, end="", flush=True)
+        returncode = process.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        returncode = process.wait()
+        lines.append(f"\ncommand timed out after {timeout}s\n")
+    finally:
+        print("\033[2K\r", end="", flush=True)
+    return CliProcessResult(returncode, "".join(lines), "")
+
+def add_codex_output_last_message(args: list[str], output_path: str) -> list[str]:
+    if "--output-last-message" in args or "-o" in args:
+        return args
+    if len(args) >= 2 and args[1] == "exec":
+        return [args[0], args[1], "--output-last-message", output_path, *args[2:]]
+    return args
+
 
 PROVIDER_ALIASES = {
     "openai compatible": "openai-compatible",
@@ -61,13 +118,33 @@ def split_cli_command(command: str) -> list[str]:
                 return [program, *shlex.split(rest)] if rest else [program]
     return shlex.split(cleaned)
 
+def global_profile_env_value(name: str) -> str:
+    if not global_agent_profile_enabled():
+        return ""
+    path = global_agent_profile_path()
+    if not path.exists():
+        return ""
+    try:
+        lines = [line.strip() for line in path.read_text(encoding="utf-8", errors="ignore").splitlines() if line.strip()]
+        if not lines:
+            return ""
+        data = json.loads(lines[-1])
+    except (OSError, json.JSONDecodeError):
+        return ""
+    env = data.get("env", {})
+    if not isinstance(env, dict):
+        return ""
+    value = env.get(name, "")
+    return str(value) if value else ""
+
+
 def env_value(name: str) -> str:
     value = os.getenv(name, "")
     if value:
         return value
     env_path = Path(".env")
     if not env_path.exists():
-        return ""
+        return global_profile_env_value(name)
     for line in env_path.read_text(encoding="utf-8", errors="ignore").splitlines():
         stripped = line.strip()
         if not stripped or stripped.startswith("#") or "=" not in stripped:
@@ -252,14 +329,7 @@ class MultiModelCodingOrchestrator:
             ]
         )
         try:
-            process = subprocess.run(
-                [*args, "-p", subagent_prompt],
-                check=False,
-                stdin=subprocess.DEVNULL,
-                capture_output=True,
-                encoding="utf-8",
-                timeout=300,
-            )
+            process = run_cli_process([*args, "-p", subagent_prompt], timeout=300)
         except FileNotFoundError as error:
             raise RuntimeError(f"Claude Code command not found: {args[0]}. Install Claude Code CLI or set base_url to the full command path.") from error
         output = (process.stdout or "").strip()
@@ -275,7 +345,7 @@ class MultiModelCodingOrchestrator:
             raise ValueError("codex command is required")
         if len(args) == 1:
             args.append("exec")
-        args = ensure_codex_skip_git_repo_check(args)
+        args = ensure_codex_exec_defaults(args)
         codex_prompt = "\n".join(
             [
                 f"You are AgentRAM {endpoint.role} agent running through Codex CLI.",
@@ -287,6 +357,7 @@ class MultiModelCodingOrchestrator:
             ]
         )
         prompt_path = ""
+        output_path = ""
         try:
             with tempfile.NamedTemporaryFile(
                 "w",
@@ -298,15 +369,18 @@ class MultiModelCodingOrchestrator:
             ) as prompt_file:
                 prompt_file.write(codex_prompt)
                 prompt_path = prompt_file.name
-            short_prompt = f"Read AgentRAM task from file and execute it: {prompt_path}"
-            process = subprocess.run(
-                [*args, short_prompt],
-                check=False,
-                stdin=subprocess.DEVNULL,
-                capture_output=True,
+            with tempfile.NamedTemporaryFile(
+                "w",
                 encoding="utf-8",
-                timeout=int(os.getenv("AGENTRAM_CLI_TIMEOUT", "900")),
-            )
+                delete=False,
+                dir=os.getcwd(),
+                prefix=".agentram_codex_final_",
+                suffix=".txt",
+            ) as output_file:
+                output_path = output_file.name
+            args = add_codex_output_last_message(args, output_path)
+            short_prompt = f"Read AgentRAM task from file and execute it: {prompt_path}"
+            process = run_cli_process([*args, short_prompt], timeout=int(os.getenv("AGENTRAM_CLI_TIMEOUT", "900")))
         except FileNotFoundError as error:
             raise RuntimeError(f"Codex CLI command not found: {args[0]}. Install Codex CLI or set base_url to the full command path.") from error
         finally:
@@ -315,19 +389,39 @@ class MultiModelCodingOrchestrator:
                     os.remove(prompt_path)
                 except OSError:
                     pass
-        output = (process.stdout or "").strip()
+        final_output = ""
+        if output_path:
+            try:
+                final_output = Path(output_path).read_text(encoding="utf-8").strip()
+            except OSError:
+                final_output = ""
+            try:
+                os.remove(output_path)
+            except OSError:
+                pass
+        output = final_output or (process.stdout or "").strip()
         error = (process.stderr or "").strip()
         if process.returncode != 0:
             raise RuntimeError(error or f"codex command failed with exit code {process.returncode}")
         return output or error
 
 
-def ensure_codex_skip_git_repo_check(args: list[str]) -> list[str]:
-    if "--skip-git-repo-check" in args:
+def ensure_codex_exec_defaults(args: list[str]) -> list[str]:
+    if len(args) < 2 or args[1] != "exec":
         return args
-    if len(args) >= 2 and args[1] == "exec":
-        return [args[0], args[1], "--skip-git-repo-check", *args[2:]]
-    return args
+    result = list(args)
+    if "--skip-git-repo-check" not in result:
+        result = [result[0], result[1], "--skip-git-repo-check", *result[2:]]
+    sandbox_index = -1
+    for flag in ("--sandbox", "-s"):
+        if flag in result:
+            sandbox_index = result.index(flag)
+            break
+    if sandbox_index == -1:
+        result = [result[0], result[1], "--sandbox", "workspace-write", *result[2:]]
+    elif sandbox_index + 1 < len(result) and result[sandbox_index + 1] == "read-only":
+        result[sandbox_index + 1] = "workspace-write"
+    return result
 
 
 def parse_openai_sse(raw: str) -> str:

package/agentram/storage.py

@@ -82,7 +82,7 @@ class JsonAgentProfileStore:
         self.path.parent.mkdir(parents=True, exist_ok=True)
 
     def default_payload(self) -> dict[str, object]:
-        return {"updated_at": utc_now(), "endpoints": [], "router": None, "auto_route": True, "agents": {}}
+        return {"updated_at": utc_now(), "endpoints": [], "router": None, "auto_route": True, "agents": {}, "env": {}}
 
     def legacy_json_path(self) -> Path:
         return self.path.with_suffix(".json") if self.path.suffix == ".jsonl" else self.path
@@ -92,10 +92,11 @@ class JsonAgentProfileStore:
         data.setdefault("router", None)
         data.setdefault("auto_route", True)
         data.setdefault("agents", {})
+        data.setdefault("env", {})
         return data
 
     def is_empty_payload(self, data: dict[str, object]) -> bool:
-        return not data.get("endpoints") and not data.get("router") and not data.get("agents")
+        return not data.get("endpoints") and not data.get("router") and not data.get("agents") and not data.get("env")
 
     def load_fallback(self) -> dict[str, object] | None:
         if not self.fallback_path or self.fallback_path == self.path or not self.fallback_path.exists():
@@ -135,6 +136,7 @@ class JsonAgentProfileStore:
             "router": current.get("router"),
             "auto_route": bool(current.get("auto_route", True)),
             "agents": current.get("agents", {}),
+            "env": current.get("env", {}),
         }
         self.write_snapshot(payload)
         return payload
@@ -208,6 +210,24 @@ class JsonAgentProfileStore:
         self.write_snapshot(current)
         return current
 
+    def set_env_value(self, name: str, value: str) -> dict[str, object]:
+        current = self.load()
+        env = current.get("env", {})
+        if not isinstance(env, dict):
+            env = {}
+        env[name] = value
+        current["env"] = env
+        current["updated_at"] = utc_now()
+        self.write_snapshot(current)
+        return current
+
+    def get_env_value(self, name: str) -> str:
+        env = self.load().get("env", {})
+        if not isinstance(env, dict):
+            return ""
+        value = env.get(name, "")
+        return str(value) if value else ""
+
     def get_agent(self, slot: str) -> AgentModelEndpoint | None:
         agents = self.load().get("agents", {})
         if not isinstance(agents, dict):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentram",
-  "version": "0.1.43",
+  "version": "0.1.47",
   "description": "Async, model-agnostic Working RAM for coding agents.",
   "license": "MIT",
   "homepage": "https://github.com/trancongnghia/AGENT_RAM#readme",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentram"
-version = "0.1.43"
+version = "0.1.47"
 description = "Async, model-agnostic RAM layer for agentic coding tools."
 readme = "README.md"
 license = "MIT"