npm - @1claw/cli - Versions diffs - 0.57.0 → 0.58.1 - Mend

@1claw/cli 0.57.0 → 0.58.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (64) hide show

package/README.md CHANGED Viewed

@@ -1,4 +1,4 @@
-# @1claw/cli (v0.56.3)
+# @1claw/cli (v0.57.0)
 Command-line interface for [1Claw](https://1claw.xyz).
@@ -847,6 +847,15 @@ Create, manage, and trigger automation workflows for agents.
 1claw automation delete <id>                   # Delete automation
 ```
+**Agent-scoped create** (agent JWT only; simple manual/webhook workflows):
+```bash
+1claw agent automation create <agent-id> my-reminder \
+  --workflow '{"steps":[{"type":"log","message":"done"}]}' \
+  --api-key ocv_...
+# Or: ONECLAW_AGENT_TOKEN=... 1claw agent automation create <agent-id> ...
+```
 `workflow_spec` is required on create (`--workflow` JSON or `@file`). For cron
 triggers, `--cron` is required. Dashboard `schedule` is accepted by the API as
 an alias for `cron`.
@@ -1113,7 +1122,7 @@ conflicts: []                    # e.g. [other-tool] to forbid combining
 ## Agent Templates (`spawn`)
-`1claw spawn` creates a framework-specific AI agent from a pre-built template. Each template ships a Dockerfile, starter code, and entrypoint pre-wired with 1Claw MCP and Shroud. The container follows the same daemon-socket security model as `init --docker` — **the container never sees raw API keys.**
+`1claw spawn` creates a framework-specific AI agent from a pre-built template. Each template ships a Dockerfile, starter code, and entrypoint pre-wired with 1Claw MCP and Shroud. After spawn, an **interactive browser chat UI** opens at `http://localhost:<port>` (default 3000) so you can send test messages immediately. The container follows the same daemon-socket security model as `init --docker` — **the container never sees raw API keys.**
 ```bash
 1claw spawn langchain                        # LangChain agent with Shroud LLM routing
@@ -1123,6 +1132,8 @@ conflicts: []                    # e.g. [other-tool] to forbid combining
 1claw spawn --refresh                        # Force-refresh templates from GitHub
 ```
+When the health check passes, spawn prints the local URL and opens your browser to the shared chat UI. Framework logic runs on an internal port; the UI forwards `POST /chat` to your agent or falls back to Shroud through the host daemon `/proxy`.
 ### Available templates
 **Python:**

package/dist/bundled-templates/shared/index.html ADDED Viewed

@@ -0,0 +1,109 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>1Claw __FRAMEWORK__</title>
+<style>
+    :root { color-scheme: dark; }
+    * { box-sizing: border-box; }
+    body {
+        margin: 0; font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
+        background: #0b0d12; color: #e6e9ef; height: 100vh; display: flex; flex-direction: column;
+    }
+    header {
+        padding: 12px 18px; border-bottom: 1px solid #1c2230;
+        display: flex; align-items: center; gap: 12px; background: #0e1219;
+    }
+    header .dot { width: 9px; height: 9px; border-radius: 50%; background: #38d39f; box-shadow: 0 0 8px #38d39f; }
+    header h1 { font-size: 15px; margin: 0; font-weight: 600; }
+    header .meta { margin-left: auto; font-size: 12px; color: #7c869b; }
+    header .badge { background: #1c2230; padding: 2px 8px; border-radius: 999px; margin-left: 6px; }
+    #log { flex: 1; overflow-y: auto; padding: 18px; display: flex; flex-direction: column; gap: 12px; }
+    .msg { max-width: 80%; padding: 10px 14px; border-radius: 12px; white-space: pre-wrap; line-height: 1.45; font-size: 14px; }
+    .user { align-self: flex-end; background: #2563eb; color: #fff; border-bottom-right-radius: 3px; }
+    .bot { align-self: flex-start; background: #161b25; border: 1px solid #1c2230; border-bottom-left-radius: 3px; }
+    .tool { align-self: flex-start; font-size: 11px; color: #8aa0c2; margin-top: -6px; }
+    form { display: flex; gap: 8px; padding: 14px 18px; border-top: 1px solid #1c2230; background: #0e1219; }
+    input { flex: 1; background: #0b0d12; border: 1px solid #28303f; color: #e6e9ef; padding: 11px 14px; border-radius: 10px; font-size: 14px; outline: none; }
+    input:focus { border-color: #2563eb; }
+    button { background: #2563eb; color: #fff; border: none; padding: 0 18px; border-radius: 10px; font-size: 14px; cursor: pointer; font-weight: 600; }
+    button:disabled { opacity: .5; cursor: default; }
+</style>
+</head>
+<body>
+<header>
+    <span class="dot"></span>
+    <h1>1Claw __FRAMEWORK__</h1>
+    <span class="meta" id="meta">connecting…</span>
+</header>
+<div id="log"></div>
+<form id="form">
+    <input id="input" placeholder="Type a message or /help" autocomplete="off" autofocus />
+    <button id="send" type="submit">Send</button>
+</form>
+<script>
+    const log = document.getElementById("log");
+    const form = document.getElementById("form");
+    const input = document.getElementById("input");
+    const send = document.getElementById("send");
+    const meta = document.getElementById("meta");
+    function add(role, text, tool) {
+        if (tool) {
+            const t = document.createElement("div");
+            t.className = "tool";
+            t.textContent = "⚙ " + tool;
+            log.appendChild(t);
+        }
+        const el = document.createElement("div");
+        el.className = "msg " + (role === "user" ? "user" : "bot");
+        el.textContent = text;
+        log.appendChild(el);
+        log.scrollTop = log.scrollHeight;
+    }
+    async function loadInfo() {
+        try {
+            const r = await fetch("/api/info");
+            const info = await r.json();
+            const parts = [];
+            if (info.framework) parts.push(info.framework);
+            parts.push("vault=" + info.mode);
+            if (info.agentId) parts.push("agent=" + info.agentId.slice(0, 8) + "…");
+            parts.push(info.daemonReachable ? "daemon ✓" : "daemon —");
+            meta.innerHTML = parts.map((p) => '<span class="badge">' + p + "</span>").join("");
+        } catch {
+            meta.textContent = "offline";
+        }
+    }
+    form.addEventListener("submit", async (e) => {
+        e.preventDefault();
+        const message = input.value.trim();
+        if (!message) return;
+        add("user", message);
+        input.value = "";
+        send.disabled = true;
+        try {
+            const r = await fetch("/api/chat", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ message }),
+            });
+            const data = await r.json();
+            add("bot", data.reply || "(no reply)", data.tool);
+        } catch (err) {
+            add("bot", "Error: " + err.message);
+        } finally {
+            send.disabled = false;
+            input.focus();
+        }
+    });
+    add("bot", "1Claw agent ready. Credentials stay in the host daemon — this container never sees secret values. Type /help to begin.");
+    loadInfo();
+    setInterval(loadInfo, 15000);
+</script>
+</body>
+</html>

package/dist/bundled-templates/shared/spawn_chat_ui.py ADDED Viewed

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""
+Minimal browser chat UI for `1claw spawn` templates.
+Listens on CHAT_UI_PORT (default 3000). Forwards chat to the framework agent on
+AGENT_INTERNAL_PORT (default 3001) when available, otherwise falls back to Shroud
+via the host daemon /proxy (credentials never enter the container).
+"""
+from __future__ import annotations
+import json
+import os
+import socket
+import sys
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+PORT = int(os.environ.get("CHAT_UI_PORT", "3000"))
+AGENT_PORT = int(os.environ.get("AGENT_INTERNAL_PORT", "3001"))
+SOCKET_PATH = os.environ.get("ONECLAW_DAEMON_SOCKET", "/run/1claw/daemon.sock")
+SECRET_PREFIX = os.environ.get("ONECLAW_SECRET_PREFIX", "")
+AGENT_ID = os.environ.get("ONECLAW_AGENT_ID", "")
+FRAMEWORK = os.environ.get("ONECLAW_FRAMEWORK", "agent")
+MODE = os.environ.get(
+    "ONECLAW_MODE",
+    "local" if os.environ.get("ONECLAW_LOCAL_VAULT") == "true" else "cloud",
+)
+LLM_VIA_SHROUD = os.environ.get("ONECLAW_LLM_VIA_SHROUD", "").lower() == "true"
+SHROUD_URL = (os.environ.get("ONECLAW_SHROUD_URL") or "https://shroud.1claw.xyz").rstrip("/")
+SHROUD_SECRET = os.environ.get("ONECLAW_SHROUD_SECRET", "")
+SHROUD_API_KEY_SECRET = os.environ.get("ONECLAW_SHROUD_API_KEY_SECRET", "")
+SHROUD_PROVIDER = os.environ.get("ONECLAW_SHROUD_PROVIDER", "openai")
+SHROUD_MODEL = os.environ.get("ONECLAW_SHROUD_MODEL", "gpt-4o-mini")
+SYSTEM_PROMPT = os.environ.get(
+    "ONECLAW_SHROUD_SYSTEM_PROMPT",
+    "You are a helpful AI agent running inside a 1Claw secure container. "
+    "Your credentials are held by the host daemon and never exposed to you.",
+)
+HISTORY_MAX = 20
+_conversation: list[dict[str, str]] = []
+_lock = threading.Lock()
+_INDEX_HTML = Path(__file__).with_name("index.html")
+if _INDEX_HTML.is_file():
+    INDEX_HTML = _INDEX_HTML.read_text(encoding="utf-8")
+else:
+    INDEX_HTML = "<h1>1Claw Agent</h1>"
+def _daemon_request(method: str, path: str, body: dict[str, Any] | None = None) -> tuple[int, dict[str, Any] | None]:
+    payload = json.dumps(body).encode("utf-8") if body is not None else None
+    headers = [
+        f"{method} {path} HTTP/1.1",
+        "Host: localhost",
+        "Content-Type: application/json",
+        "Connection: close",
+    ]
+    if SECRET_PREFIX:
+        headers.append(f"X-Secret-Prefix: {SECRET_PREFIX}")
+    if payload is not None:
+        headers.append(f"Content-Length: {len(payload)}")
+    headers.append("")
+    headers.append("")
+    raw = "\r\n".join(headers).encode("utf-8") + (payload or b"")
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.settimeout(120)
+    try:
+        sock.connect(SOCKET_PATH)
+        sock.sendall(raw)
+        chunks: list[bytes] = []
+        while True:
+            part = sock.recv(65536)
+            if not part:
+                break
+            chunks.append(part)
+    finally:
+        sock.close()
+    text = b"".join(chunks).decode("utf-8", errors="replace")
+    if "\r\n\r\n" not in text:
+        return 0, None
+    _, body_text = text.split("\r\n\r\n", 1)
+    status_line = text.split("\r\n", 1)[0]
+    try:
+        status = int(status_line.split()[1])
+    except (IndexError, ValueError):
+        status = 0
+    try:
+        parsed = json.loads(body_text) if body_text.strip() else None
+    except json.JSONDecodeError:
+        parsed = {"raw": body_text}
+    return status, parsed
+def _daemon_reachable() -> bool:
+    try:
+        status, _ = _daemon_request("GET", "/health")
+        return status == 200
+    except OSError:
+        return False
+def _shroud_chat(user_text: str) -> tuple[bool, str]:
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}, *_conversation, {"role": "user", "content": user_text}]
+    proxy_body: dict[str, Any] = {
+        "secretName": SHROUD_SECRET,
+        "url": f"{SHROUD_URL}/v1/chat/completions",
+        "method": "POST",
+        "headers": {
+            "Content-Type": "application/json",
+            "X-Shroud-Provider": SHROUD_PROVIDER,
+        },
+        "body": json.dumps({"model": SHROUD_MODEL, "messages": messages}),
+    }
+    if SHROUD_API_KEY_SECRET:
+        proxy_body["injectSecrets"] = [SHROUD_API_KEY_SECRET]
+    status, body = _daemon_request("POST", "/proxy", proxy_body)
+    if status != 200 or not body:
+        detail = (body or {}).get("error") if body else "unknown daemon error"
+        return False, f"Daemon refused the LLM call ({status}): {detail}"
+    upstream_status = body.get("status", 502)
+    raw_upstream = body.get("body", "")
+    try:
+        upstream = json.loads(raw_upstream) if isinstance(raw_upstream, str) else raw_upstream
+    except json.JSONDecodeError:
+        upstream = {"raw": raw_upstream}
+    if upstream_status != 200:
+        err = upstream.get("error") if isinstance(upstream, dict) else upstream
+        if isinstance(err, dict):
+            msg = err.get("message") or str(err)
+        else:
+            msg = str(err or upstream)
+        return False, f"Shroud/upstream returned {upstream_status}: {msg}"
+    content = (
+        upstream.get("choices", [{}])[0]
+        .get("message", {})
+        .get("content")
+        if isinstance(upstream, dict)
+        else None
+    )
+    if not content:
+        return False, f"No content in model response: {str(upstream)[:400]}"
+    return True, str(content)
+def _agent_chat(user_text: str) -> dict[str, Any] | None:
+    req = Request(
+        f"http://127.0.0.1:{AGENT_PORT}/chat",
+        data=json.dumps({"message": user_text}).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urlopen(req, timeout=120) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+    except (HTTPError, URLError, TimeoutError, json.JSONDecodeError, OSError):
+        return None
+    if isinstance(data, dict) and data.get("response"):
+        return {
+            "reply": str(data["response"]),
+            "tool": data.get("framework") or FRAMEWORK,
+        }
+    if isinstance(data, dict) and data.get("error"):
+        return {"reply": str(data["error"]), "tool": "agent_error"}
+    return None
+def handle_chat(message: str) -> dict[str, Any]:
+    text = (message or "").strip()
+    if text in ("", "/help"):
+        llm_line = (
+            f"LLM is wired via Shroud ({SHROUD_PROVIDER}/{SHROUD_MODEL}) — type a message to chat.\n"
+            if LLM_VIA_SHROUD and SHROUD_SECRET
+            else "Framework agent on port "
+            f"{AGENT_PORT} handles chat when running; Shroud fallback uses the daemon.\n"
+        )
+        return {
+            "reply": (
+                f"1Claw {FRAMEWORK} agent ready.\n"
+                f"{llm_line}"
+                "Commands:\n"
+                "  /secrets — list secret names available via the daemon\n"
+                "  /info    — show runtime info\n"
+                "Secret values never enter this container."
+            ),
+            "tool": None,
+        }
+    if text == "/info":
+        llm = f" · llm=shroud:{SHROUD_PROVIDER}/{SHROUD_MODEL}" if LLM_VIA_SHROUD else " · llm=agent"
+        return {
+            "reply": (
+                f"Agent {AGENT_ID or '(local)'} · framework={FRAMEWORK} · "
+                f"vault={MODE} · chat_ui=:{PORT} · agent=:{AGENT_PORT}{llm}"
+            ),
+            "tool": "info",
+        }
+    if text == "/secrets":
+        path = f"/secrets?prefix={SECRET_PREFIX}" if SECRET_PREFIX else "/secrets"
+        try:
+            status, body = _daemon_request("GET", path)
+            if status != 200:
+                return {"reply": f"Daemon returned {status}", "tool": "list_secrets"}
+            names = [s.get("name", "") for s in (body or {}).get("secrets", [])]
+            names = [n for n in names if n]
+            reply = (
+                "Available secrets:\n" + "\n".join(f"  • {n}" for n in names)
+                if names
+                else "No secrets available to this agent."
+            )
+            return {"reply": reply, "tool": "list_secrets"}
+        except OSError as exc:
+            return {"reply": f"Could not reach daemon: {exc}", "tool": "list_secrets"}
+    agent_out = _agent_chat(text)
+    if agent_out is not None:
+        return agent_out
+    if LLM_VIA_SHROUD and SHROUD_SECRET:
+        try:
+            ok, reply = _shroud_chat(text)
+            if ok:
+                with _lock:
+                    _conversation.append({"role": "user", "content": text})
+                    _conversation.append({"role": "assistant", "content": reply})
+                    while len(_conversation) > HISTORY_MAX:
+                        _conversation.pop(0)
+            return {"reply": reply, "tool": "shroud_llm"}
+        except OSError as exc:
+            return {"reply": f"Could not reach the daemon for LLM call: {exc}", "tool": "shroud_llm"}
+    return {
+        "reply": (
+            "No LLM configured. Re-run spawn with --agent-key ocv_... "
+            "and optional --llm-api-key. The host daemon injects Shroud credentials."
+        ),
+        "tool": None,
+    }
+class Handler(BaseHTTPRequestHandler):
+    def log_message(self, fmt: str, *args: Any) -> None:
+        sys.stderr.write(f"[spawn-chat-ui] {self.address_string()} - {fmt % args}\n")
+    def _json(self, status: int, obj: dict[str, Any]) -> None:
+        body = json.dumps(obj).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+    def do_GET(self) -> None:
+        path = self.path.split("?", 1)[0]
+        if path == "/health":
+            self._json(
+                200,
+                {
+                    "status": "ok",
+                    "framework": FRAMEWORK,
+                    "agent_port": AGENT_PORT,
+                    "llm_wired": LLM_VIA_SHROUD and bool(SHROUD_SECRET),
+                },
+            )
+            return
+        if path == "/api/info":
+            self._json(
+                200,
+                {
+                    "agentId": AGENT_ID or None,
+                    "framework": FRAMEWORK,
+                    "runtime": "docker",
+                    "mode": MODE,
+                    "agentPort": AGENT_PORT,
+                    "llm": (
+                        {
+                            "via": "shroud",
+                            "provider": SHROUD_PROVIDER,
+                            "model": SHROUD_MODEL,
+                        }
+                        if LLM_VIA_SHROUD
+                        else None
+                    ),
+                    "daemonReachable": _daemon_reachable(),
+                },
+            )
+            return
+        if path in ("/", "/index.html"):
+            html = INDEX_HTML.replace("__FRAMEWORK__", FRAMEWORK)
+            body = html.encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            return
+        self._json(404, {"error": "not found"})
+    def do_POST(self) -> None:
+        path = self.path.split("?", 1)[0]
+        if path != "/api/chat":
+            self._json(404, {"error": "not found"})
+            return
+        length = int(self.headers.get("Content-Length", "0"))
+        if length > 1024 * 1024:
+            self._json(413, {"error": "body too large"})
+            return
+        try:
+            payload = json.loads(self.rfile.read(length).decode("utf-8") or "{}")
+        except json.JSONDecodeError:
+            self._json(400, {"error": "invalid JSON"})
+            return
+        result = handle_chat(str(payload.get("message", "")))
+        self._json(200, result)
+def main() -> None:
+    server = ThreadingHTTPServer(("0.0.0.0", PORT), Handler)
+    print(
+        f"[spawn-chat-ui] listening on :{PORT} "
+        f"(framework={FRAMEWORK}, agent=:{AGENT_PORT}, mode={MODE})",
+        flush=True,
+    )
+    server.serve_forever()
+if __name__ == "__main__":
+    main()

package/dist/bundled-templates/shared/start-with-chat-ui.sh ADDED Viewed

@@ -0,0 +1,33 @@
+#!/bin/sh
+# Start the framework agent on AGENT_INTERNAL_PORT, then run the shared chat UI
+# on CHAT_UI_PORT (spawn publishes this port to localhost).
+set -e
+AGENT_INTERNAL_PORT="${AGENT_INTERNAL_PORT:-3001}"
+CHAT_UI_PORT="${CHAT_UI_PORT:-3000}"
+export AGENT_INTERNAL_PORT CHAT_UI_PORT
+if [ $# -lt 1 ]; then
+    echo "Usage: start-with-chat-ui.sh <agent command...>" >&2
+    exit 1
+fi
+"$@" &
+AGENT_PID=$!
+cleanup() {
+    kill "$AGENT_PID" 2>/dev/null || true
+}
+trap cleanup EXIT INT TERM
+i=0
+while [ "$i" -lt 30 ]; do
+    if curl -sf "http://127.0.0.1:${AGENT_INTERNAL_PORT}/health" >/dev/null 2>&1; then
+        break
+    fi
+    i=$((i + 1))
+    sleep 0.5
+done
+echo "Ready: http://0.0.0.0:${CHAT_UI_PORT} (chat UI → agent on :${AGENT_INTERNAL_PORT})"
+exec python3 /app/shared/spawn_chat_ui.py

package/dist/bundled-templates/templates/agentkit/Dockerfile CHANGED Viewed

@@ -6,6 +6,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 WORKDIR /app
+COPY shared /app/shared
+RUN chmod +x /app/shared/start-with-chat-ui.sh
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt

package/dist/bundled-templates/templates/agentkit/agent.py CHANGED Viewed

@@ -78,6 +78,6 @@ Credentials stay in the host daemon — this container never sees secret values.
 if __name__ == "__main__":
-    port = int(os.environ.get("CHAT_UI_PORT", "3000"))
+    port = int(os.environ.get("AGENT_INTERNAL_PORT", "3001"))
     print(f"AgentKit agent listening on http://0.0.0.0:{port}")
     app.run(host="0.0.0.0", port=port)

package/dist/bundled-templates/templates/agentkit/entrypoint.sh CHANGED Viewed

@@ -30,5 +30,5 @@ if [ -S "$DAEMON_SOCKET" ]; then
     fi
 fi
-echo "Ready: http://0.0.0.0:${CHAT_UI_PORT}"
-exec python agent.py
+# Chat UI starts in start-with-chat-ui.sh
+exec /app/shared/start-with-chat-ui.sh python agent.py

package/dist/bundled-templates/templates/agno/Dockerfile CHANGED Viewed

@@ -6,6 +6,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 WORKDIR /app
+COPY shared /app/shared
+RUN chmod +x /app/shared/start-with-chat-ui.sh
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt

package/dist/bundled-templates/templates/agno/agent.py CHANGED Viewed

@@ -81,6 +81,6 @@ Credentials stay in the host daemon — this container never sees secret values.
 if __name__ == "__main__":
-    port = int(os.environ.get("CHAT_UI_PORT", "3000"))
+    port = int(os.environ.get("AGENT_INTERNAL_PORT", "3001"))
     print(f"Agno agent listening on http://0.0.0.0:{port}")
     app.run(host="0.0.0.0", port=port)

package/dist/bundled-templates/templates/agno/entrypoint.sh CHANGED Viewed

@@ -30,5 +30,5 @@ if [ -S "$DAEMON_SOCKET" ]; then
     fi
 fi
-echo "Ready: http://0.0.0.0:${CHAT_UI_PORT}"
-exec python agent.py
+# Chat UI starts in start-with-chat-ui.sh
+exec /app/shared/start-with-chat-ui.sh python agent.py

package/dist/bundled-templates/templates/agno/requirements.txt CHANGED Viewed

@@ -1,3 +1,3 @@
-agno>=1.0.0
+agno>=1.7.0,<2
 flask>=3.0.0
 oneclaw>=0.42.0

package/dist/bundled-templates/templates/coder/Dockerfile CHANGED Viewed

@@ -6,6 +6,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 WORKDIR /app
+COPY shared /app/shared
+RUN chmod +x /app/shared/start-with-chat-ui.sh
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt

package/dist/bundled-templates/templates/coder/agent.py CHANGED Viewed

@@ -114,6 +114,6 @@ Credentials stay in the host daemon — this container never sees secret values.
 if __name__ == "__main__":
-    port = int(os.environ.get("CHAT_UI_PORT", "3000"))
+    port = int(os.environ.get("AGENT_INTERNAL_PORT", "3001"))
     print(f"Coder agent listening on http://0.0.0.0:{port}")
     app.run(host="0.0.0.0", port=port)

package/dist/bundled-templates/templates/coder/entrypoint.sh CHANGED Viewed

@@ -30,5 +30,5 @@ if [ -S "$DAEMON_SOCKET" ]; then
     fi
 fi
-echo "Ready: http://0.0.0.0:${CHAT_UI_PORT}"
-exec python agent.py
+# Chat UI starts in start-with-chat-ui.sh
+exec /app/shared/start-with-chat-ui.sh python agent.py

package/dist/bundled-templates/templates/crewai/Dockerfile CHANGED Viewed

@@ -6,6 +6,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 WORKDIR /app
+COPY shared /app/shared
+RUN chmod +x /app/shared/start-with-chat-ui.sh
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt

package/dist/bundled-templates/templates/crewai/agent.py CHANGED Viewed

@@ -104,6 +104,6 @@ Credentials stay in the host daemon — this container never sees secret values.
 if __name__ == "__main__":
-    port = int(os.environ.get("CHAT_UI_PORT", "3000"))
+    port = int(os.environ.get("AGENT_INTERNAL_PORT", "3001"))
     print(f"CrewAI agent listening on http://0.0.0.0:{port}")
     app.run(host="0.0.0.0", port=port)

package/dist/bundled-templates/templates/crewai/entrypoint.sh CHANGED Viewed

@@ -30,5 +30,5 @@ if [ -S "$DAEMON_SOCKET" ]; then
     fi
 fi
-echo "Ready: http://0.0.0.0:${CHAT_UI_PORT}"
-exec python agent.py
+# Chat UI starts in start-with-chat-ui.sh
+exec /app/shared/start-with-chat-ui.sh python agent.py

package/dist/bundled-templates/templates/elizaos/Dockerfile CHANGED Viewed

@@ -6,6 +6,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 WORKDIR /app
+COPY shared /app/shared
+RUN chmod +x /app/shared/start-with-chat-ui.sh
 COPY package.json tsconfig.json ./
 RUN npm install --omit=dev 2>/dev/null || npm install

package/dist/bundled-templates/templates/elizaos/agent.ts CHANGED Viewed

@@ -11,7 +11,7 @@ const SHROUD_URL = process.env.ONECLAW_SHROUD_URL ?? "https://shroud.1claw.xyz";
 const LLM_VIA_SHROUD = process.env.ONECLAW_LLM_VIA_SHROUD === "true";
 const PROVIDER = process.env.ONECLAW_SHROUD_PROVIDER ?? "openai";
 const MODEL = process.env.ONECLAW_SHROUD_MODEL ?? "gpt-4o-mini";
-const PORT = parseInt(process.env.CHAT_UI_PORT ?? "3000", 10);
+const PORT = parseInt(process.env.AGENT_INTERNAL_PORT ?? "3001", 10);
 const conversationHistory: { role: "user" | "assistant"; content: string }[] = [];