akashcli 4.8.7__tar.gz → 4.8.9__tar.gz

{akashcli-4.8.7 → akashcli-4.8.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akashcli
-Version: 4.8.7
+Version: 4.8.9
 Summary: Akash CLI — secure remote shell relay, file vault, and device management
 License-Expression: MIT
 Keywords: akash,cli,relay,remote-shell,vault

{akashcli-4.8.7 → akashcli-4.8.9}/akashcli/__init__.py

@@ -2,7 +2,7 @@ try:
     from importlib.metadata import version
     __version__ = version("akashcli")
 except Exception:
-    __version__ = "4.8.7"
+    __version__ = "4.8.9"
 
 AKASH_VERSION = __version__
 

{akashcli-4.8.7 → akashcli-4.8.9}/akashcli/cli.py

@@ -136,7 +136,7 @@ def _resolve_client(url_override: str = None, require_key: bool = False, silent:
 
 
 _GUEST_WARNING = (
-    f"  {_Y}⚠{_RS}  {_Y}Running as guest{_RS} - not logged in.\n"
+    f"  {_Y}!{_RS}  {_Y}Running as guest{_RS} - not logged in.\n"
     f"  {_DM}Features are limited and your data won't be saved to the cloud.\n"
     f"  Run {_RS}{_C}akash login{_RS}{_DM} to unlock full access.{_RS}"
 )
@@ -243,7 +243,7 @@ def _print_help():
         f"  {C}devices{RS}  {DM}[--revoke NAME]{RS}                list or manage enrolled devices",
         "",
         f"  {DM}AI AGENTS & MCP{RS}",
-        f"  {C}mcp{RS}      {DM}<serve|share|create|list…>{RS}     AI agent & MCP tool bridge (Codex, Claude, Cursor)",
+        f"  {C}mcp{RS}      {DM}<serve|share|create|list…>{RS}     AI agent & MCP tool bridge (Cursor, Claude, ChatGPT)",
         "",
         f"  {DM}FILES & CLOUD VAULT{RS}",
         f"  {C}cloud{RS}    {DM}<upload|files|stream|delete…>{RS}  cloud file vault & media streaming engine",
@@ -359,7 +359,7 @@ def update():
         _p()
         return
 
-    print(f"  {_Y}⚡{_RS} New version available: {_DM}{__version__}{_RS} {_C}→{_RS} {_G}{latest}{_RS}")
+    print(f"  {_Y}◈{_RS} New version available: {_DM}{__version__}{_RS} {_C}→{_RS} {_G}{latest}{_RS}")
     with _Spin(f"updating akashcli to v{latest}…"):
         cmd = [sys.executable, "-m", "pip", "install", "-U", "--no-cache-dir", f"akashcli=={latest}", "--break-system-packages"]
         res = subprocess.run(cmd, capture_output=True, text=True)
@@ -464,10 +464,10 @@ def cmd_url(
     _info("To reset URL  : akash url --reset")
     _p()
 def _storage_discontinued_notice():
-    print(f"\n{_R}⚠️  [SERVICE DISCONTINUED] Cloud storage & upload services are disabled.{_RS}")
+    print(f"\n{_R}!️  [SERVICE DISCONTINUED] Cloud storage & upload services are disabled.{_RS}")
     print(f"  {_DM}Public cloud uploading has been discontinued due to lack of funds and hosting costs.{_RS}")
     print(f"  {_DM}We are actively seeking sponsors to help restore community storage infrastructure.{_RS}\n")
-    print(f"  {_C}💖 Sponsoring the project:{_RS}")
+    print(f"  {_C}Sponsoring the project:{_RS}")
     print(f"  Run {_YE}akash sponsor{_RS} or visit {_CY}https://github.com/juniorsir/akashcli#sponsorship{_RS}\n")
     raise typer.Exit(1)
 
@@ -476,7 +476,7 @@ def _storage_discontinued_notice():
 def cmd_sponsor():
     """Information on sponsoring Akash CLI to restore storage services."""
     print(f"\n{_C}╔═══════════════════════════════════════════════════════════════╗{_RS}")
-    print(f"{_C}║             💖 SPONSOR AKASH CLI INFRASTRUCTURE             ║{_RS}")
+    print(f"{_C}║             SPONSOR AKASH CLI INFRASTRUCTURE             ║{_RS}")
     print(f"{_C}╚═══════════════════════════════════════════════════════════════╝{_RS}\n")
     print(f"  {_B}Status Update:{_RS}")
     print(f"  Public cloud storage and file uploading services have been")
@@ -692,7 +692,7 @@ def _interactive_explorer(vfs, root_name="/"):
         sys.stdout.write(f"  {_GR}────────────────────────────────────────────────────────────{_RS}\r\n")
         
         full_path = "".join([n[1] + ("/" if n[1] != "/" and not n[1].endswith("/") else "") for n in path_stack])
-        sys.stdout.write(f"  📂 {_C}{full_path}{_RS}\r\n")
+        sys.stdout.write(f"  [DIR] {_C}{full_path}{_RS}\r\n")
         sys.stdout.write(f"  {_GR}────────────────────────────────────────────────────────────{_RS}\r\n")
         
         if not keys:
@@ -704,7 +704,7 @@ def _interactive_explorer(vfs, root_name="/"):
                 child = children[k]
                 is_sel = (actual_idx == selected_idx)
                 cursor = f"{_G}> {_RS}" if is_sel else "  "
-                icon = "📁" if child["type"] == "dir" else "📄"
+                icon = "[DIR]" if child["type"] == "dir" else "[FILE]"
                 
                 display_name = k[:35] + ("…" if len(k) > 35 else "")
                 if child["type"] == "dir":
@@ -2704,11 +2704,11 @@ def env_pull(
 
 mcp_app = typer.Typer(help="Model Context Protocol (MCP) server & AI agent tool bridge.")
 agent_app = mcp_app
-app.add_typer(mcp_app, name="mcp", help="MCP server · AI agent tools · Claude/Cursor/Codex bridge")
+app.add_typer(mcp_app, name="mcp", help="MCP server · AI agent tools · Claude/Cursor/ChatGPT bridge")
 app.add_typer(mcp_app, name="agent", hidden=True, help="Alias for akash mcp")
 
 def _render_inspection_card(r: dict) -> None:
-    print(f"\n  {_C}╭─ ⚡ INCOMING AGENT DEVICE REGISTRATION ────────────────────────────{_RS}")
+    print(f"\n  {_C}╭─ ◈ INCOMING AGENT DEVICE REGISTRATION ────────────────────────────{_RS}")
     print(f"  {_GR}│{_RS}  {_DM}Request ID     :{_RS} {_ye(r['request_id'])}")
     print(f"  {_GR}│{_RS}  {_DM}Client Name    :{_RS} {_W}{r['client_name']}{_RS}")
     print(f"  {_GR}│{_RS}  {_DM}Client ID      :{_RS} {_dim(r['client_id'])}")
@@ -2868,7 +2868,7 @@ def agent_list(raw: bool = typer.Option(False, "--json", help="Raw JSON output")
 
     print(f"  {_GR}{'─'*76}{_RS}")
     if expired_count > 0:
-        print(f"  {_Y}⚡{_RS} {_W}{expired_count} profile(s) expired.{_RS} {_DM}Run {_cy('akash mcp renew <id>')} to extend or {_cy('akash mcp rm --expired')} to clean up.{_RS}\n")
+        print(f"  {_Y}◈{_RS} {_W}{expired_count} profile(s) expired.{_RS} {_DM}Run {_cy('akash mcp renew <id>')} to extend or {_cy('akash mcp rm --expired')} to clean up.{_RS}\n")
     else:
         _p()
     print(f"  {_W}Quick Launch:{_RS}")
@@ -3036,7 +3036,7 @@ def agent_info(
         mcp_url = f"{base}/mcp?{params}"
 
     _p()
-    print(f"  {_C}╭─ 🤖 AGENT PERMISSION DETAILS: {_W}{name}{_RS} {_dim('(' + pid + ')')}")
+    print(f"  {_C}╭─ AGENT PERMISSION DETAILS: {_W}{name}{_RS} {_dim('(' + pid + ')')}")
     print(f"  {_GR}│{_RS}  {_DM}Profile ID      :{_RS} {_ye(pid)}")
     print(f"  {_GR}│{_RS}  {_DM}Client ID       :{_RS} {_dim(cid)}")
     st_col = _G if "active" in status.lower() else (_Y if "pending" in status.lower() else _R)
@@ -3614,7 +3614,7 @@ def _handle_tool_read_file(args: dict, scopes: str) -> tuple[str, bool]:
             try:
                 target_path.relative_to(cwd)
             except ValueError:
-                return f"⛔ Permission denied by scope 'fs:cwd_only': Path '{path_str}' is outside working directory ({cwd}).", True
+                return f"[BLOCKED] Permission denied by scope 'fs:cwd_only': Path '{path_str}' is outside working directory ({cwd}).", True
 
     if not target_path.exists():
         return f"Error: File '{path_str}' not found.", True
@@ -3667,13 +3667,13 @@ def _handle_tool_write_file(args: dict, scopes: str) -> tuple[str, bool]:
     scopes_list = [s.strip().lower() for s in scopes.split(",") if s.strip()]
     if "*" not in scopes_list and "@full" not in scopes_list:
         if "exec:read_only" in scopes_list or "@viewer" in scopes_list:
-            return "⛔ Permission denied: Agent is in read-only mode ('exec:read_only'). File writing is blocked.", True
+            return "[BLOCKED] Permission denied: Agent is in read-only mode ('exec:read_only'). File writing is blocked.", True
         if "fs:cwd_only" in scopes_list:
             cwd = Path.cwd().resolve()
             try:
                 target_path.relative_to(cwd)
             except ValueError:
-                return f"⛔ Permission denied by scope 'fs:cwd_only': Path '{path_str}' is outside working directory ({cwd}).", True
+                return f"[BLOCKED] Permission denied by scope 'fs:cwd_only': Path '{path_str}' is outside working directory ({cwd}).", True
 
     if target_path.exists() and not overwrite:
         return f"Error: File '{path_str}' already exists and overwrite is set to False.", True
@@ -3704,7 +3704,7 @@ def _handle_tool_list_dir(args: dict, scopes: str) -> tuple[str, bool]:
             try:
                 target_path.relative_to(cwd)
             except ValueError:
-                return f"⛔ Permission denied by scope 'fs:cwd_only': Path '{path_str}' is outside working directory ({cwd}).", True
+                return f"[BLOCKED] Permission denied by scope 'fs:cwd_only': Path '{path_str}' is outside working directory ({cwd}).", True
 
     if not target_path.exists():
         return f"Error: Path '{path_str}' not found.", True
@@ -3731,18 +3731,18 @@ def _handle_tool_list_dir(args: dict, scopes: str) -> tuple[str, bool]:
                 ptr = "└── " if is_last else "├── "
                 sub_pfx = "    " if is_last else "│   "
                 if entry.is_dir():
-                    output_lines.append(f"{prefix}{ptr}📁 {entry.name}/")
+                    output_lines.append(f"{prefix}{ptr}[DIR] {entry.name}/")
                     if cur_depth < depth and not entry.is_symlink():
                         _walk(entry, cur_depth + 1, prefix + sub_pfx)
                 elif entry.is_symlink():
-                    output_lines.append(f"{prefix}{ptr}🔗 {entry.name} -> {os.readlink(entry)}")
+                    output_lines.append(f"{prefix}{ptr}[LINK] {entry.name} -> {os.readlink(entry)}")
                 else:
                     try:
                         sz = entry.stat().st_size
                         sz_str = f"{sz / 1024:.1f}KB" if sz >= 1024 else f"{sz}B"
                     except Exception:
                         sz_str = "?"
-                    output_lines.append(f"{prefix}{ptr}📄 {entry.name} ({sz_str})")
+                    output_lines.append(f"{prefix}{ptr}[FILE] {entry.name} ({sz_str})")
             if len(filtered) > 100:
                 output_lines.append(f"{prefix}... [{len(filtered) - 100} more items omitted]")
 
@@ -3852,7 +3852,7 @@ def mcp_serve(
                 if ack.get("type") == "pending_approval":
                     req_id = ack.get("request_id", "?")
                     sys.stdout.write(chr(13) + chr(27) + "[2K"); sys.stdout.flush()
-                    print("\n  " + _Y + "⚡" + _RS + "  " + _W + "New device registration pending:" + _RS)
+                    print("\n  " + _Y + "◈" + _RS + "  " + _W + "New device registration pending:" + _RS)
                     print("     " + _DM + "Request ID : " + _RS + _ye(req_id))
                     print("     " + _DM + "Device FP  : " + _RS + _dim(dev_fp))
                     print()
@@ -3908,7 +3908,7 @@ def mcp_serve(
                                     "type": "tool_response",
                                     "id": call_id,
                                     "result": {
-                                        "content": [{"type": "text", "text": f"⛔ Security Policy Block: {sec_reason}\nCommand: {cmd}"}],
+                                        "content": [{"type": "text", "text": f"[BLOCKED] Security Policy Block: {sec_reason}\nCommand: {cmd}"}],
                                         "isError": True
                                     }
                                 }))
@@ -3957,11 +3957,11 @@ def mcp_serve(
                                             except Exception:
                                                 raw_out = ""
                                             elapsed_ms = 25000.0
-                                            raw_out = raw_out or "⛔ Command timed out after 25 seconds."
+                                            raw_out = raw_out or "[BLOCKED] Command timed out after 25 seconds."
                                             returncode = 124
                                 except Exception as cmd_err:
                                     elapsed_ms = (time.monotonic() - t0) * 1000
-                                    raw_out = f"⛔ Command execution error: {cmd_err}"
+                                    raw_out = f"[BLOCKED] Command execution error: {cmd_err}"
                                     returncode = 1
 
                                 bounded_out = _smart_truncate_output(raw_out)
@@ -3973,8 +3973,8 @@ def mcp_serve(
 
                                 if returncode != 0:
                                     res_content = bounded_out or f"Command exited with status code {returncode} (no output)"
-                                    if not res_content.startswith("⛔"):
-                                        res_content = f"⛔ Command execution failed (exit code {returncode}):\n{res_content}"
+                                    if not res_content.startswith("[BLOCKED]"):
+                                        res_content = f"[BLOCKED] Command execution failed (exit code {returncode}):\n{res_content}"
                                 else:
                                     res_content = bounded_out or "(command completed successfully with no output)"
 
@@ -4081,7 +4081,7 @@ def mcp_serve(
             reconnect_attempts += 1
             backoff = min(1.2 * (1.5 ** min(reconnect_attempts, 6)), 30.0) + random.uniform(0.1, 0.4)
             now_t = datetime.datetime.now().strftime("%H:%M:%S")
-            print(f"  {_GR}{now_t}{_RS}  {_Y}⚠{_RS}  {_dim(f'Worker disconnected ({e}). Reconnecting in {backoff:.1f}s (attempt {reconnect_attempts})…')}")
+            print(f"  {_GR}{now_t}{_RS}  {_Y}!{_RS}  {_dim(f'Worker disconnected ({e}). Reconnecting in {backoff:.1f}s (attempt {reconnect_attempts})…')}")
             time.sleep(backoff)
 
 @agent_app.command("share")
@@ -4090,6 +4090,7 @@ def mcp_share(
     target:  Optional[str] = typer.Argument(None, help="Profile ID (optional if only 1 profile exists)"),
     id:      Optional[str] = typer.Option(None, "--id", "-i", help="Profile ID"),
     temp:    Optional[str] = typer.Option(None, "--temp", "-t", help="Temporary short URL duration (e.g. '30m', '30 min', '1h')"),
+    local:   bool          = typer.Option(False, "--local", "-l", help="Show snippet only for local-first zero-network stdio MCP"),
     codex:   bool          = typer.Option(False, "--codex", "-c", help="Show snippet only for Codex CLI/Desktop"),
     claude:  bool          = typer.Option(False, "--claude", help="Show snippet only for Claude Desktop / Cursor"),
     chatgpt: bool          = typer.Option(False, "--chatgpt", "-g", help="Show snippet only for ChatGPT Custom GPT Actions"),
@@ -4250,16 +4251,48 @@ def mcp_share(
     print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
     _p()
 
-    show_all = not codex and not claude and not chatgpt
+    show_all = not local and not codex and not claude and not chatgpt
+
+    # ── 1. LOCAL-FIRST STDIO MODE (ZERO NETWORK) ──
+    if show_all or local:
+        print("  " + _C + "1. Local Mode (Offline · Zero Network · Direct Stdio · Recommended)" + _RS + ":")
+        print("  " + _DM + "For Claude Desktop, Cursor & local AI agents on this device." + _RS)
+        print("  " + _dim("  (Zero network exposure, no open ports, direct local pipe)"))
+        stdio_cfg = json.dumps({
+            "mcpServers": {
+                "akash": {
+                    "command": "akash",
+                    "args": ["mcp", "stdio"]
+                }
+            }
+        }, indent=2)
+        for c_line in stdio_cfg.splitlines():
+            print("  " + c_line)
+        print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
+        _p()
 
-    if show_all:
-        gemini_url = base + "/mcp"
-        print("  " + _C + "For Google Gemini (Web & Extensions)" + _RS + ":")
-        print("  " + _DM + "MCP Server URL : " + _RS + _cy(gemini_url))
-        print("  " + _dim("  (Standard OAuth 2.0 with instant one-click approval)"))
+    # ── 2. NETWORK / RELAY MODE (AUTHENTICATED OVER DOMAIN / CLOUDFLARE / AKASHBOX) ──
+    if show_all or claude:
+        is_custom = bool(base != DEFAULT_STORAGE_URL)
+        domain_tag = "Custom Domain / Cloudflare" if is_custom else "Akashbox Network Relay"
+        print("  " + _C + "2. Network / Internet Mode (" + domain_tag + ")" + _RS + ":")
+        print("  " + _DM + "Active Domain      : " + _RS + _cy(base))
+        print("  " + _DM + "Hardware Auth      : " + _RS + _G + "Strict (Client ID + Secret + Device Fingerprint required)" + _RS)
+        print("  " + _DM + "Authenticated URL  : " + _RS)
+        print("  " + _ye(local_url))
+        _p()
+        print("  " + _DM + "Config snippet for remote Claude Desktop, Cursor & Cline:" + _RS)
+        claude_cfg = json.dumps({"mcpServers": {"akash": {"url": local_url}}}, indent=2)
+        for c_line in claude_cfg.splitlines():
+            print("  " + c_line)
+        print("  " + _DM + "  Logo / Icon: Clean Cloud Icon delivered automatically via MCP handshake" + _RS)
+        _p()
+        print("  " + _dim("  • To use a custom domain or Cloudflare tunnel: akash url https://your-domain.com"))
+        print("  " + _dim("  • To reset back to default Akashbox relay    : akash url --reset"))
         print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
         _p()
 
+    # ── 3. CHATGPT CUSTOM GPT ACTIONS (OPENAPI REST) ──
     if show_all or chatgpt:
         app_token = None
         for tok_path in [Path.home() / ".akash_app_tokens.json", Path.home() / ".akash" / "app_tokens.json"]:
@@ -4282,7 +4315,7 @@ def mcp_share(
         token_val = app_token or csec or "akash_sec_client_03e804cabbbcface799a4522ca673dd166b8e76813f84389"
         openapi_url = base + "/openapi.json"
         privacy_url = base + "/privacy"
-        print("  " + _C + "For ChatGPT Custom GPT (OpenAPI Actions)" + _RS + ":")
+        print("  " + _C + "3. For ChatGPT Custom GPT (OpenAPI Actions)" + _RS + ":")
         print("  " + _DM + "OpenAPI Schema URL : " + _RS + _cy(openapi_url))
         print("  " + _DM + "Authentication     : " + _RS + _W + "API Key" + _RS + " " + _dim("->") + " " + _W + "Custom" + _RS)
         print("  " + _DM + "Custom Header Name : " + _RS + _ye("X-App-Token"))
@@ -4292,7 +4325,7 @@ def mcp_share(
         print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
         _p()
 
-    if show_all or codex:
+    if codex:
         print("  " + _C + "For Codex CLI / Desktop" + _RS + " " + _dim("(~/.codex/config.toml)") + ":")
         print("  " + _DM + "Option A: Same Device (Termux / Localhost)" + _RS)
         print("  [mcp_servers.akash]")
@@ -4305,15 +4338,6 @@ def mcp_share(
         print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
         _p()
 
-    if show_all or claude:
-        print("  " + _C + "For Claude Desktop, Cursor & Cline" + _RS + " " + _dim("(config.json / settings.json)") + ":")
-        claude_cfg = json.dumps({"mcpServers": {"akash": {"url": local_url}}}, indent=2)
-        for c_line in claude_cfg.splitlines():
-            print("  " + c_line)
-        print("  " + _DM + "  Logo / Icon: Clean Cloud Icon delivered automatically via MCP handshake" + _RS)
-        print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
-        _p()
-
     _info("Paste snippet into AI client, then keep running:")
     _info("  " + _cy("akash mcp serve"))
     _p()
@@ -4360,5 +4384,271 @@ def mcp_status(
     print("  " + _GR + "──────────────────────────────────────────────────" + _RS)
     _p()
 
+
+@agent_app.command("stdio")
+def mcp_stdio(
+    profile_id: Optional[str] = typer.Option(None, "--id", "-i", help="Local Agent Profile ID"),
+):
+    """Runs a zero-network, local-first Model Context Protocol stdio server over stdin/stdout."""
+    import sys, json, re, subprocess, time
+    from pathlib import Path
+    from . import __version__
+
+    agents_file = Path.home() / ".akash" / "agents.json"
+    agents = {}
+    if agents_file.exists():
+        try:
+            agents = json.loads(agents_file.read_text(encoding="utf-8"))
+        except Exception:
+            agents = {}
+
+    target_pid = profile_id or (next(reversed(list(agents.keys()))) if agents else "default")
+    profile = agents.get(target_pid, {})
+    scopes = profile.get("scopes", "*")
+    pname = profile.get("name", "LocalAgent")
+
+    tools_definitions = [
+        {
+            "name": "akash_exec_command",
+            "description": "Executes shell commands in the workspace with safety policies, secret redaction, and automatic undo snapshotting.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "The shell command to execute."}
+                },
+                "required": ["command"]
+            }
+        },
+        {
+            "name": "akash_read_file",
+            "description": "Reads a file from the workspace with line-range pagination directly into context.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Path to the file to read."},
+                    "offset": {"type": "integer", "description": "Starting line number (1-indexed).", "default": 1},
+                    "limit": {"type": "integer", "description": "Maximum number of lines to return.", "default": 200}
+                },
+                "required": ["path"]
+            }
+        },
+        {
+            "name": "akash_write_file",
+            "description": "Writes or edits a file in the workspace safely with auto-undo checkpoints.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Path to the file to write."},
+                    "content": {"type": "string", "description": "The content to write into the file."},
+                    "append": {"type": "boolean", "description": "Whether to append to the file instead of overwriting.", "default": False}
+                },
+                "required": ["path", "content"]
+            }
+        },
+        {
+            "name": "akash_list_dir",
+            "description": "Lists directory entries with file sizes, types, and depth control.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Directory path to list.", "default": "."},
+                    "depth": {"type": "integer", "description": "Depth of subdirectory recursion.", "default": 1}
+                }
+            }
+        },
+        {
+            "name": "akash_checkpoint_create",
+            "description": "Creates an instant rollback snapshot before executing large refactors.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "label": {"type": "string", "description": "Name or tag for this checkpoint.", "default": "manual_checkpoint"}
+                }
+            }
+        },
+        {
+            "name": "akash_undo",
+            "description": "Reverts workspace files to the last pre-command checkpoint.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {}
+            }
+        },
+        {
+            "name": "akash_scope_details",
+            "description": "Inspects active session permissions, allowed file boundaries, and security rules.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {}
+            }
+        }
+    ]
+
+    while True:
+        line = sys.stdin.readline()
+        if not line:
+            break
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except Exception:
+            continue
+
+        msg_id = req.get("id")
+        method = req.get("method")
+        params = req.get("params", {})
+
+        if method == "initialize":
+            res = {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "result": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": "akash", "version": __version__}
+                }
+            }
+            sys.stdout.write(json.dumps(res) + "\n")
+            sys.stdout.flush()
+        elif method == "notifications/initialized":
+            pass
+        elif method == "ping":
+            if msg_id is not None:
+                sys.stdout.write(json.dumps({"jsonrpc": "2.0", "id": msg_id, "result": {}}) + "\n")
+                sys.stdout.flush()
+        elif method == "tools/list":
+            res = {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "result": {"tools": tools_definitions}
+            }
+            sys.stdout.write(json.dumps(res) + "\n")
+            sys.stdout.flush()
+        elif method == "tools/call":
+            t_name = params.get("name")
+            t_args = params.get("arguments", {})
+            res_content = ""
+            is_err = False
+
+            if t_name == "akash_exec_command":
+                cmd = t_args.get("command", "")
+                is_safe, sec_reason = _sanitize_agent_command(cmd, scopes=scopes)
+                if not is_safe:
+                    res_content = f"[BLOCKED] Security Policy Block: {sec_reason}\nCommand: {cmd}"
+                    is_err = True
+                else:
+                    if any(k in cmd for k in ["touch", "mkdir", "mv", "cp", "sed", ">", ">>", "python", "npm", "pip"]):
+                        _save_undo_checkpoint()
+                    import signal
+                    try:
+                        proc = subprocess.Popen(
+                            cmd,
+                            shell=True,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            stdin=subprocess.DEVNULL,
+                            text=True,
+                            start_new_session=True,
+                            errors="replace"
+                        )
+                        try:
+                            out, err = proc.communicate(timeout=25)
+                            returncode = proc.returncode
+                            raw_out = (out or "") + (err or "")
+                        except subprocess.TimeoutExpired:
+                            try:
+                                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+                            except Exception:
+                                pass
+                            raw_out = "[BLOCKED] Command timed out after 25 seconds."
+                            returncode = 124
+                    except Exception as cmd_err:
+                        raw_out = f"[BLOCKED] Command execution error: {cmd_err}"
+                        returncode = 1
+                    bounded_out = _smart_truncate_output(raw_out)
+                    if returncode != 0:
+                        res_content = bounded_out or f"Command exited with status code {returncode}"
+                        is_err = True
+                    else:
+                        res_content = bounded_out or "(command completed successfully with no output)"
+            elif t_name == "akash_read_file":
+                res_content, is_err = _handle_tool_read_file(t_args, scopes)
+            elif t_name == "akash_write_file":
+                _save_undo_checkpoint()
+                res_content, is_err = _handle_tool_write_file(t_args, scopes)
+            elif t_name == "akash_list_dir":
+                res_content, is_err = _handle_tool_list_dir(t_args, scopes)
+            elif t_name == "akash_checkpoint_create":
+                label = t_args.get("label", "agent_checkpoint")
+                from .terminal import build_snapshot
+                _, manifest, _ = build_snapshot(label=label)
+                res_content = f"Checkpoint '{label}' created ({len(manifest.get('files', []))} files tracked)"
+            elif t_name == "akash_undo":
+                ok, msg_txt = _restore_undo_checkpoint()
+                res_content = msg_txt
+                is_err = not ok
+            elif t_name == "akash_scope_details":
+                res_content, is_err = _handle_tool_scope_details(scopes, pname, target_pid)
+            else:
+                res_content = f"Tool '{t_name}' not found."
+                is_err = True
+
+            sys.stdout.write(json.dumps({
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "result": {
+                    "content": [{"type": "text", "text": res_content}],
+                    "isError": is_err
+                }
+            }) + "\n")
+            sys.stdout.flush()
+        else:
+            if msg_id is not None:
+                sys.stdout.write(json.dumps({
+                    "jsonrpc": "2.0",
+                    "id": msg_id,
+                    "error": {"code": -32601, "message": f"Method '{method}' not found"}
+                }) + "\n")
+                sys.stdout.flush()
+
+
+@app.command("tunnel")
+@agent_app.command("tunnel")
+def cmd_tunnel(
+    url: Optional[str] = typer.Option(None, "--url", "-u", help="Set custom domain or Cloudflare tunnel URL"),
+    reset: bool = typer.Option(False, "--reset", "-r", help="Reset domain back to default akashbox.duckdns.org"),
+):
+    """Configure or view custom domain / Cloudflare tunnel for internet mode."""
+    if reset:
+        ConfigManager.delete("api_url")
+        _ok(f"Reset storage and relay URL to default: {_cy(DEFAULT_STORAGE_URL)}")
+        return
+
+    if url:
+        clean = url.strip().rstrip("/")
+        if not clean.startswith(("http://", "https://")):
+            clean = f"https://{clean}"
+        ConfigManager.set("api_url", clean)
+        _ok(f"Configured active gateway domain to: {_cy(clean)}")
+        _info("All remote MCP and API operations will now route through this domain.")
+        return
+
+    cfg = ConfigManager.load()
+    current_url = cfg.get("api_url", DEFAULT_STORAGE_URL)
+    _p()
+    print(f"  {_C}◈{_RS}  {_W}Akash Gateway Domain Configuration{_RS}")
+    print(f"  {_GR}──────────────────────────────────────────────────{_RS}")
+    print(f"  {_DM}Active Domain  :{_RS} {_cy(current_url)}")
+    print(f"  {_DM}Default Relay  :{_RS} {_dim(DEFAULT_STORAGE_URL)}")
+    print(f"  {_GR}──────────────────────────────────────────────────{_RS}")
+    _p()
+    _info("How to connect your own domain or Cloudflare Tunnel:")
+    print(f"  1. Start Cloudflare Tunnel locally :  {_cy('cloudflared tunnel --url http://127.0.0.1:8000')}")
+    print(f"  2. Configure tunnel in akashcli    :  {_cy('akash tunnel --url https://<your-subdomain>.trycloudflare.com')}")
+    print(f"  3. Reset back to Akashbox relay    :  {_cy('akash tunnel --reset')}")
+    _p()
+
 if __name__ == "__main__":
     app()

{akashcli-4.8.7 → akashcli-4.8.9}/akashcli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akashcli
-Version: 4.8.7
+Version: 4.8.9
 Summary: Akash CLI — secure remote shell relay, file vault, and device management
 License-Expression: MIT
 Keywords: akash,cli,relay,remote-shell,vault

{akashcli-4.8.7 → akashcli-4.8.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "akashcli"
-version = "4.8.7"
+version = "4.8.9"
 description = "Akash CLI — secure remote shell relay, file vault, and device management"
 readme = "README.md"
 requires-python = ">=3.9"