grains-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{grains_cli-0.1.0 → grains_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grains-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: Command-line tools for Grains: build, run, deploy, and pay AI agents.
 Author: Grains
 License-Expression: Apache-2.0
@@ -23,6 +23,8 @@ Requires-Dist: httpx
 Requires-Dist: eth-account>=0.11
 Dynamic: license-file
 
+<p align="center"><img src="https://grains.run/brand-icon.png" width="96" alt="Grains"></p>
+
 # grains-cli
 
 Command-line tools for [Grains](https://grains.run) — build, run, deploy, and

{grains_cli-0.1.0 → grains_cli-0.2.0}/README.md

@@ -1,3 +1,5 @@
+<p align="center"><img src="https://grains.run/brand-icon.png" width="96" alt="Grains"></p>
+
 # grains-cli
 
 Command-line tools for [Grains](https://grains.run) — build, run, deploy, and

grains_cli-0.2.0/grains_cli/apiclient.py

@@ -0,0 +1,81 @@
+"""Minimal Grains control-plane client for the CLI (deploy/logs/agents).
+
+Authenticated by a deploy token (--token or GRAINS_DEPLOY_TOKEN). Kept
+self-contained so grains-cli doesn't depend on grains-mcp.
+"""
+from __future__ import annotations
+
+import io
+import os
+import zipfile
+from pathlib import Path
+
+import httpx
+
+DEFAULT_API = "https://api.grains.run"
+
+
+class GrainsAPIError(Exception):
+    def __init__(self, status: int, body):
+        super().__init__(f"HTTP {status}: {body}")
+        self.status = status
+        self.body = body
+
+
+def resolve_api(explicit: str | None) -> str:
+    return (explicit or os.environ.get("GRAINS_API_URL") or DEFAULT_API).rstrip("/")
+
+
+def resolve_token(explicit: str | None) -> str | None:
+    if explicit or os.environ.get("GRAINS_DEPLOY_TOKEN"):
+        return explicit or os.environ.get("GRAINS_DEPLOY_TOKEN")
+    from .login import stored_token  # lazy: avoid import cycle
+    return stored_token(resolve_api(None))
+
+
+def zip_project(path: Path) -> bytes:
+    """Zip an agent project: grains.toml + grains_app.* + any other files,
+    skipping caches/VCS/virtualenvs."""
+    skip_dirs = {".git", "__pycache__", "node_modules", ".venv", "dist", "build",
+                 ".pytest_cache", ".ruff_cache", ".egg-info"}
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for f in sorted(path.rglob("*")):
+            if f.is_dir():
+                continue
+            if any(part in skip_dirs or part.endswith(".egg-info") for part in f.relative_to(path).parts):
+                continue
+            zf.write(f, f.relative_to(path).as_posix())
+    return buf.getvalue()
+
+
+class GrainsClient:
+    def __init__(self, api: str, token: str, http: httpx.Client | None = None):
+        self.api = api.rstrip("/")
+        self.token = token
+        self.http = http if http is not None else httpx.Client(timeout=120.0)
+
+    def _req(self, method: str, path: str, **kw):
+        headers = {"Authorization": f"Bearer {self.token}"}
+        headers.update(kw.pop("headers", None) or {})
+        r = self.http.request(method, self.api + path, headers=headers, **kw)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+            except ValueError:
+                body = r.text
+            raise GrainsAPIError(r.status_code, body)
+        return {} if r.status_code == 204 or not r.content else r.json()
+
+    def create_agent(self, name: str) -> dict:
+        return self._req("POST", "/v1/agents", json={"name": name})
+
+    def deploy(self, name: str, zip_bytes: bytes) -> dict:
+        return self._req("POST", f"/v1/agents/{name}/deployments",
+                         content=zip_bytes, headers={"Content-Type": "application/zip"})
+
+    def list_agents(self) -> dict:
+        return self._req("GET", "/v1/agents")
+
+    def logs(self, name: str, limit: int = 50) -> dict:
+        return self._req("GET", f"/v1/agents/{name}/logs?limit={limit}")

grains_cli-0.2.0/grains_cli/deploy.py

@@ -0,0 +1,80 @@
+"""`grains deploy` / `grains logs` / `grains agents` — CLI control-plane commands."""
+from __future__ import annotations
+
+import argparse
+import sys
+import tomllib
+from pathlib import Path
+
+from .apiclient import GrainsAPIError, GrainsClient, resolve_api, resolve_token, zip_project
+
+
+def _client_or_exit(args) -> GrainsClient:
+    token = resolve_token(getattr(args, "token", None))
+    if not token:
+        print("error: provide --token or set GRAINS_DEPLOY_TOKEN "
+              "(get one at https://api.grains.run/welcome)", file=sys.stderr)
+        raise SystemExit(2)
+    return GrainsClient(resolve_api(getattr(args, "api", None)), token)
+
+
+def _agent_name(path: Path) -> str:
+    toml_path = path / "grains.toml"
+    if not toml_path.exists():
+        print(f"error: no grains.toml in {path} (run `grains init` first)", file=sys.stderr)
+        raise SystemExit(2)
+    return tomllib.loads(toml_path.read_text())["agent"]["name"]
+
+
+def cmd_deploy(args: argparse.Namespace) -> int:
+    path = Path(args.path).resolve()
+    name = _agent_name(path)
+    client = _client_or_exit(args)
+    try:
+        try:
+            client.create_agent(name)
+            print(f"created agent {name}")
+        except GrainsAPIError as e:
+            if e.status != 409:  # already exists is fine
+                raise
+        result = client.deploy(name, zip_project(path))
+    except GrainsAPIError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    dep = result.get("deployment", result)
+    status = dep.get("status")
+    print(f"deployed {name}: {status}")
+    if dep.get("error"):
+        print(f"  error: {dep['error']}", file=sys.stderr)
+        return 1
+    return 0 if status == "live" else 1
+
+
+def cmd_logs(args: argparse.Namespace) -> int:
+    client = _client_or_exit(args)
+    try:
+        events = client.logs(args.name, args.limit).get("events", [])
+    except GrainsAPIError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    if not events:
+        print("(no logs)")
+    for e in events:
+        print(e.get("message", ""))
+    return 0
+
+
+def cmd_agents(args: argparse.Namespace) -> int:
+    client = _client_or_exit(args)
+    try:
+        agents = client.list_agents().get("agents", [])
+    except GrainsAPIError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    if not agents:
+        print("(no agents)")
+    for a in agents:
+        price = f" {a['price_value']} {a.get('price_currency', 'USDC')}" if a.get("price_value") else ""
+        vis = "public" if a.get("public") else "private"
+        print(f"{a['name']:<24} {a.get('status', ''):<8} {vis}{price}")
+    return 0

{grains_cli-0.1.0 → grains_cli-0.2.0}/grains_cli/dev.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 import asyncio
 import importlib.util
 import json
+import shutil
+import subprocess
 import sys
 import threading
 import tomllib
@@ -50,6 +52,36 @@ def _load_entrypoint(target: Path, entrypoint: str):
     return getattr(module, func_name)
 
 
+_NODE_RUNNER = str(Path(__file__).resolve().parent / "_node_runner.mjs")
+
+
+def _run_task_node(task_id, store, text, payload, app_dir, entrypoint) -> None:
+    store.set(task_id, status="working")
+    task_json = json.dumps({"task_id": task_id, "text": text, "payload": payload}).encode()
+    try:
+        proc = subprocess.run(
+            ["node", _NODE_RUNNER, str(app_dir), entrypoint],
+            input=task_json, capture_output=True, timeout=300,
+        )
+    except FileNotFoundError:
+        store.set(task_id, status="failed", error="node not found on PATH")
+        return
+    except subprocess.TimeoutExpired:
+        store.set(task_id, status="failed", error="task timed out")
+        return
+    last = (proc.stdout.decode(errors="replace").strip().splitlines() or [""])[-1]
+    try:
+        result = json.loads(last)
+    except json.JSONDecodeError:
+        err = proc.stderr.decode(errors="replace")[-2000:] or "no output from node runner"
+        store.set(task_id, status="failed", error=err)
+        return
+    if result.get("status") == "failed":
+        store.set(task_id, status="failed", error=result.get("error"))
+        return
+    store.set(task_id, status="done", reply=result.get("reply"), charges=result.get("charges", []))
+
+
 def _run_task(task_id: str, store: _TaskStore, text: str, payload: dict) -> None:
     store.set(task_id, status="working")
     task = Task(id=task_id, text=text, payload=payload)
@@ -68,6 +100,7 @@ def _run_task(task_id: str, store: _TaskStore, text: str, payload: dict) -> None
 
 class _Handler(BaseHTTPRequestHandler):
     store: _TaskStore
+    runner: dict
 
     def log_message(self, *args) -> None:  # silence default request logging
         pass
@@ -113,11 +146,15 @@ class _Handler(BaseHTTPRequestHandler):
             self._json(400, {"error": "body must be a JSON object"})
             return
         task_id = self.store.create()
-        threading.Thread(
-            target=_run_task,
-            args=(task_id, self.store, body.get("text", ""), body.get("payload", {})),
-            daemon=True,
-        ).start()
+        r = self.runner
+        if r["is_node"]:
+            target_fn = _run_task_node
+            args = (task_id, self.store, body.get("text", ""), body.get("payload", {}),
+                    r["target"], r["entrypoint"])
+        else:
+            target_fn = _run_task
+            args = (task_id, self.store, body.get("text", ""), body.get("payload", {}))
+        threading.Thread(target=target_fn, args=args, daemon=True).start()
         self._json(202, {"task_id": task_id})
 
 
@@ -125,11 +162,17 @@ def serve(path: str, port: int = 0) -> ThreadingHTTPServer:
     """Load grains.toml + the entrypoint and start the task API in a background thread."""
     target = Path(path).resolve()
     config = tomllib.loads((target / "grains.toml").read_text())
-    handler_func = _load_entrypoint(target, config["agent"]["entrypoint"])
-    agent.handler(handler_func)
+    entrypoint = config["agent"]["entrypoint"]
+    runtime = str(config["agent"].get("runtime", "python3.12"))
+    is_node = runtime.startswith(("node", "nodejs"))
+    if is_node and not shutil.which("node"):
+        raise RuntimeError("this is a Node agent but `node` is not on PATH")
+    if not is_node:
+        agent.handler(_load_entrypoint(target, entrypoint))
 
     store = _TaskStore()
-    bound_handler = type("_BoundHandler", (_Handler,), {"store": store})
+    runner = {"is_node": is_node, "target": target, "entrypoint": entrypoint}
+    bound_handler = type("_BoundHandler", (_Handler,), {"store": store, "runner": runner})
     server = ThreadingHTTPServer(("127.0.0.1", port), bound_handler)
     threading.Thread(target=server.serve_forever, daemon=True).start()
     return server

{grains_cli-0.1.0 → grains_cli-0.2.0}/grains_cli/init.py

@@ -48,6 +48,8 @@ def detect_framework(target: Path) -> str:
     for framework in _FRAMEWORK_PRIORITY:
         if framework in names:
             return framework
+    if not names and (target / "package.json").exists():
+        return "node"
     return "none"
 
 
@@ -60,7 +62,10 @@ def _sanitize_name(name: str) -> str:
 def cmd_init(args) -> int:
     target = Path(args.path).resolve()
     target.mkdir(parents=True, exist_ok=True)
-    app_path = target / "grains_app.py"
+
+    framework = args.template or detect_framework(target)
+    app_filename = "grains_app.mjs" if framework == "node" else "grains_app.py"
+    app_path = target / app_filename
     toml_path = target / "grains.toml"
 
     if not args.force:
@@ -69,9 +74,8 @@ def cmd_init(args) -> int:
             print(f"refusing to overwrite existing file(s): {', '.join(existing)} (use --force)")
             return 1
 
-    framework = args.template or detect_framework(target)
     app_path.write_text(templates.render_app(framework))
-    toml_path.write_text(templates.render_toml(_sanitize_name(target.name)))
+    toml_path.write_text(templates.render_toml(_sanitize_name(target.name), framework))
 
     print(f"detected framework: {framework}")
     print(f"wrote {app_path}")

grains_cli-0.2.0/grains_cli/login.py

@@ -0,0 +1,173 @@
+"""`grains login` -- browser sign-in via the Grains OAuth 2.1 server.
+
+Same PKCE + dynamic-client-registration flow Claude Code uses against
+mcp.grains.run, with a loopback redirect: register a public client, open the
+browser to the consent page, catch the code on 127.0.0.1, exchange it for a
+deploy token, and store it in ~/.grains/credentials.json (0600). After this,
+every CLI command works with no token pasting; GRAINS_DEPLOY_TOKEN still
+wins when set (CI, scripts).
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import hashlib
+import json
+import os
+import secrets
+import stat
+import sys
+import threading
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from urllib.parse import parse_qs, urlencode, urlparse
+
+import httpx
+
+from .apiclient import resolve_api
+
+CRED_PATH = Path.home() / ".grains" / "credentials.json"
+LOGIN_TIMEOUT_S = 300
+
+
+def stored_token(api: str) -> str | None:
+    try:
+        data = json.loads(CRED_PATH.read_text())
+    except (OSError, ValueError):
+        return None
+    return (data.get(api) or {}).get("token")
+
+
+def store_token(api: str, token: str) -> None:
+    CRED_PATH.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        data = json.loads(CRED_PATH.read_text())
+    except (OSError, ValueError):
+        data = {}
+    data[api] = {"token": token}
+    CRED_PATH.write_text(json.dumps(data, indent=2))
+    CRED_PATH.chmod(stat.S_IRUSR | stat.S_IWUSR)
+
+
+def pkce_pair() -> tuple[str, str]:
+    verifier = secrets.token_urlsafe(48)
+    challenge = (
+        base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest())
+        .rstrip(b"=")
+        .decode()
+    )
+    return verifier, challenge
+
+
+class _Callback(BaseHTTPRequestHandler):
+    result: dict = {}
+    expected_state = ""
+
+    def log_message(self, *a):  # silence
+        pass
+
+    def do_GET(self):
+        q = parse_qs(urlparse(self.path).query)
+        ok = q.get("state", [""])[0] == self.expected_state and "code" in q
+        if ok:
+            _Callback.result = {"code": q["code"][0]}
+        else:
+            _Callback.result = {"error": q.get("error", ["invalid callback"])[0]}
+        body = (
+            b"<body style='font-family:system-ui;text-align:center;padding-top:4rem'>"
+            + (b"<h2>Signed in to Grains.</h2>You can close this tab." if ok
+               else b"<h2>Sign-in failed.</h2>Return to the terminal.")
+            + b"</body>"
+        )
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.end_headers()
+        self.wfile.write(body)
+
+
+def login_flow(api: str, http: httpx.Client | None = None, open_browser=webbrowser.open,
+               timeout_s: float = LOGIN_TIMEOUT_S) -> str:
+    """Run the full browser PKCE flow; returns the deploy token."""
+    client = http or httpx.Client(timeout=30.0)
+    meta = client.get(f"{api}/.well-known/oauth-authorization-server").json()
+
+    server = HTTPServer(("127.0.0.1", 0), _Callback)
+    port = server.server_address[1]
+    redirect_uri = f"http://127.0.0.1:{port}/callback"
+
+    reg = client.post(meta["registration_endpoint"], json={
+        "client_name": "grains CLI",
+        "redirect_uris": [redirect_uri],
+    })
+    reg.raise_for_status()
+    client_id = reg.json()["client_id"]
+
+    verifier, challenge = pkce_pair()
+    state = secrets.token_urlsafe(16)
+    _Callback.expected_state = state
+    _Callback.result = {}
+    auth_url = meta["authorization_endpoint"] + "?" + urlencode({
+        "response_type": "code",
+        "client_id": client_id,
+        "redirect_uri": redirect_uri,
+        "state": state,
+        "code_challenge": challenge,
+        "code_challenge_method": "S256",
+    })
+
+    thread = threading.Thread(target=server.handle_request, daemon=True)
+    thread.start()
+    print("Opening your browser to sign in with GitHub…")
+    print(f"  {auth_url}")
+    open_browser(auth_url)
+    thread.join(timeout=timeout_s)
+    server.server_close()
+    if "code" not in _Callback.result:
+        raise RuntimeError(_Callback.result.get("error") or "sign-in timed out")
+
+    resp = client.post(meta["token_endpoint"], data={
+        "grant_type": "authorization_code",
+        "code": _Callback.result["code"],
+        "code_verifier": verifier,
+        "client_id": client_id,
+        "redirect_uri": redirect_uri,
+    })
+    resp.raise_for_status()
+    return resp.json()["access_token"]
+
+
+def ensure_token(api: str, *, allow_login: bool = True) -> str:
+    token = os.environ.get("GRAINS_DEPLOY_TOKEN") or stored_token(api)
+    if token:
+        return token
+    if not allow_login:
+        raise RuntimeError("not signed in (run `grains login`)")
+    token = login_flow(api)
+    store_token(api, token)
+    print("Signed in. Token stored in ~/.grains/credentials.json")
+    return token
+
+
+def cmd_login(args: argparse.Namespace) -> int:
+    api = resolve_api(getattr(args, "api", None))
+    try:
+        token = login_flow(api)
+    except Exception as e:  # noqa: BLE001
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    store_token(api, token)
+    print("Signed in. Token stored in ~/.grains/credentials.json")
+    return 0
+
+
+def cmd_logout(args: argparse.Namespace) -> int:
+    api = resolve_api(getattr(args, "api", None))
+    try:
+        data = json.loads(CRED_PATH.read_text())
+        data.pop(api, None)
+        CRED_PATH.write_text(json.dumps(data, indent=2))
+    except (OSError, ValueError):
+        pass
+    print("Signed out.")
+    return 0

{grains_cli-0.1.0 → grains_cli-0.2.0}/grains_cli/main.py

@@ -3,9 +3,12 @@ from __future__ import annotations
 
 import argparse
 
+from . import deploy as deploy_cmd
 from . import dev as dev_cmd
 from . import init as init_cmd
+from . import login as login_cmd
 from . import pay as pay_cmd
+from . import ship as ship_cmd
 from . import verify as verify_cmd
 
 
@@ -18,7 +21,7 @@ def build_parser() -> argparse.ArgumentParser:
     p_init.add_argument("--force", action="store_true", help="overwrite existing files")
     p_init.add_argument(
         "--template",
-        choices=["crewai", "langgraph", "langchain", "none"],
+        choices=["crewai", "langgraph", "langchain", "none", "node"],
         default=None,
         help="force a template instead of auto-detecting the framework",
     )
@@ -41,6 +44,37 @@ def build_parser() -> argparse.ArgumentParser:
     p_pay.add_argument("--caller-token", default=None, help="grains_ct_... caller token, if required")
     p_pay.set_defaults(func=pay_cmd.cmd_pay)
 
+    p_ship = sub.add_parser("ship", help="sign in, scaffold if needed, deploy, and wait for live")
+    p_ship.add_argument("path", nargs="?", default=".")
+    p_ship.add_argument("--api", help="control-plane URL (or GRAINS_API_URL)")
+    p_ship.set_defaults(func=ship_cmd.cmd_ship)
+
+    p_login = sub.add_parser("login", help="sign in with GitHub in your browser")
+    p_login.add_argument("--api")
+    p_login.set_defaults(func=login_cmd.cmd_login)
+
+    p_logout = sub.add_parser("logout", help="forget the stored deploy token")
+    p_logout.add_argument("--api")
+    p_logout.set_defaults(func=login_cmd.cmd_logout)
+
+    p_deploy = sub.add_parser("deploy", help="deploy the agent in this directory to Grains")
+    p_deploy.add_argument("path", nargs="?", default=".")
+    p_deploy.add_argument("--token", help="deploy token (or set GRAINS_DEPLOY_TOKEN)")
+    p_deploy.add_argument("--api", help="control-plane URL (or GRAINS_API_URL)")
+    p_deploy.set_defaults(func=deploy_cmd.cmd_deploy)
+
+    p_logs = sub.add_parser("logs", help="recent logs for a deployed agent")
+    p_logs.add_argument("name")
+    p_logs.add_argument("--limit", type=int, default=50)
+    p_logs.add_argument("--token")
+    p_logs.add_argument("--api")
+    p_logs.set_defaults(func=deploy_cmd.cmd_logs)
+
+    p_agents = sub.add_parser("agents", help="list your agents")
+    p_agents.add_argument("--token")
+    p_agents.add_argument("--api")
+    p_agents.set_defaults(func=deploy_cmd.cmd_agents)
+
     return parser
 
 

grains_cli-0.2.0/grains_cli/ship.py

@@ -0,0 +1,79 @@
+"""`grains ship` -- the one command: sign in, scaffold, deploy, live.
+
+Collapses the whole funnel: browser sign-in if needed (PKCE, no token
+pasting), `grains init` if the directory has no agent yet, deploy, poll
+until live, print the endpoint. `uvx grains-cli ship` is the marketing
+one-liner; this module has to keep it honest.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+import time
+import tomllib
+from argparse import Namespace
+from pathlib import Path
+
+from . import init as init_cmd
+from .apiclient import GrainsAPIError, GrainsClient, resolve_api, zip_project
+from .login import ensure_token
+
+POLL_INTERVAL_S = 3
+BUILD_TIMEOUT_S = 600  # container-tier first builds take minutes
+
+
+def _status(client: GrainsClient, name: str, dep: dict) -> str:
+    if dep.get("status") != "building":
+        return dep.get("status", "unknown")
+    # lazy-reconciled container build: poll the deployment until it settles
+    dep_id = dep.get("id")
+    deadline = time.monotonic() + BUILD_TIMEOUT_S
+    while time.monotonic() < deadline:
+        time.sleep(POLL_INTERVAL_S)
+        cur = client._req("GET", f"/v1/agents/{name}/deployments/{dep_id}")
+        status = cur.get("deployment", cur).get("status")
+        if status not in ("building", "pending"):
+            return status
+        print("  building…", flush=True)
+    return "timeout"
+
+
+def cmd_ship(args: argparse.Namespace) -> int:
+    path = Path(args.path).resolve()
+    api = resolve_api(getattr(args, "api", None))
+
+    try:
+        token = ensure_token(api)
+    except Exception as e:  # noqa: BLE001
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+
+    if not (path / "grains.toml").exists():
+        print(f"no grains.toml in {path.name}/ -- scaffolding")
+        rc = init_cmd.cmd_init(Namespace(path=str(path), force=False, template=None))
+        if rc != 0:
+            return rc
+
+    name = tomllib.loads((path / "grains.toml").read_text())["agent"]["name"]
+    client = GrainsClient(api, token)
+    try:
+        try:
+            client.create_agent(name)
+        except GrainsAPIError as e:
+            if e.status != 409:
+                raise
+        result = client.deploy(name, zip_project(path))
+    except GrainsAPIError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+
+    dep = result.get("deployment", result)
+    status = _status(client, name, dep)
+    agents_base = api.replace("api.", "agents.")
+    print()
+    print(f"  endpoint   {agents_base.removeprefix('https://')}/{name}")
+    if result.get("agent", {}).get("did") or dep.get("did"):
+        print(f"  identity   {result.get('agent', {}).get('did') or dep.get('did')}")
+    print(f"  status     {status}")
+    print(f"  dashboard  grains.run/dashboard.html")
+    return 0 if status == "live" else 1

{grains_cli-0.1.0 → grains_cli-0.2.0}/grains_cli/templates.py

@@ -33,24 +33,37 @@ def handle(task: Task):
     return task.reply(str(result))
 '''
 
+_NODE_APP = '''// Grains wrapper -- generated by `grains init`.
+export function handle(task) {
+  return task.reply("echo: " + task.text);
+}
+'''
+
 _APP_TEMPLATES = {
     "crewai": _CREWAI_APP,
     "langchain": _INVOKE_APP,
     "langgraph": _INVOKE_APP,
     "none": _ECHO_APP,
+    "node": _NODE_APP,
+}
+
+_RUNTIME_BY_FRAMEWORK = {
+    "node": "nodejs20.x",
 }
+_DEFAULT_RUNTIME = "python3.12"
 
 
 def render_app(framework: str) -> str:
     return _APP_TEMPLATES.get(framework, _ECHO_APP)
 
 
-def render_toml(name: str) -> str:
+def render_toml(name: str, framework: str = "none") -> str:
+    runtime = _RUNTIME_BY_FRAMEWORK.get(framework, _DEFAULT_RUNTIME)
     return (
         "[agent]\n"
         f'name = "{name}"\n'
         'entrypoint = "grains_app:handle"\n'
-        'runtime = "python3.12"\n'
+        f'runtime = "{runtime}"\n'
         "public = false\n"
         "\n"
         "[secrets]\n"

{grains_cli-0.1.0 → grains_cli-0.2.0}/grains_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grains-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: Command-line tools for Grains: build, run, deploy, and pay AI agents.
 Author: Grains
 License-Expression: Apache-2.0
@@ -23,6 +23,8 @@ Requires-Dist: httpx
 Requires-Dist: eth-account>=0.11
 Dynamic: license-file
 
+<p align="center"><img src="https://grains.run/brand-icon.png" width="96" alt="Grains"></p>
+
 # grains-cli
 
 Command-line tools for [Grains](https://grains.run) — build, run, deploy, and

{grains_cli-0.1.0 → grains_cli-0.2.0}/grains_cli.egg-info/SOURCES.txt

@@ -2,10 +2,14 @@ LICENSE
 README.md
 pyproject.toml
 grains_cli/__init__.py
+grains_cli/apiclient.py
+grains_cli/deploy.py
 grains_cli/dev.py
 grains_cli/init.py
+grains_cli/login.py
 grains_cli/main.py
 grains_cli/pay.py
+grains_cli/ship.py
 grains_cli/templates.py
 grains_cli/verify.py
 grains_cli.egg-info/PKG-INFO
@@ -14,7 +18,9 @@ grains_cli.egg-info/dependency_links.txt
 grains_cli.egg-info/entry_points.txt
 grains_cli.egg-info/requires.txt
 grains_cli.egg-info/top_level.txt
+tests/test_deploy.py
 tests/test_dev.py
 tests/test_init.py
+tests/test_init_node.py
 tests/test_pay.py
 tests/test_verify.py

{grains_cli-0.1.0 → grains_cli-0.2.0}/grains_cli.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 grains = grains_cli.main:main
+grains-cli = grains_cli.main:main

{grains_cli-0.1.0 → grains_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "grains-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "Command-line tools for Grains: build, run, deploy, and pay AI agents."
 readme = "README.md"
 license = "Apache-2.0"
@@ -24,6 +24,7 @@ dependencies = ["grains-sdk[crypto]>=0.1.0", "httpx", "eth-account>=0.11"]
 
 [project.scripts]
 grains = "grains_cli.main:main"
+grains-cli = "grains_cli.main:main"
 
 [project.urls]
 Homepage = "https://grains.run"

grains_cli-0.2.0/tests/test_deploy.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import argparse
+import io
+import zipfile
+from pathlib import Path
+
+import httpx
+from grains_cli import deploy as deploy_cmd
+from grains_cli.apiclient import GrainsClient, zip_project
+
+
+def _project(tmp_path: Path, mjs=False):
+    (tmp_path / "grains.toml").write_text('[agent]\nname = "cliagent"\nentrypoint = "grains_app:handle"\nruntime = "python3.12"\npublic = false\n')
+    (tmp_path / ("grains_app.mjs" if mjs else "grains_app.py")).write_text("x = 1\n")
+    (tmp_path / "__pycache__").mkdir()
+    (tmp_path / "__pycache__" / "junk.pyc").write_text("junk")
+    return tmp_path
+
+
+def test_zip_project_skips_caches(tmp_path):
+    _project(tmp_path)
+    names = zipfile.ZipFile(io.BytesIO(zip_project(tmp_path))).namelist()
+    assert "grains.toml" in names and "grains_app.py" in names
+    assert not any("__pycache__" in n for n in names)
+
+
+def test_deploy_creates_then_deploys(tmp_path, monkeypatch):
+    _project(tmp_path)
+    calls = []
+
+    def handler(req: httpx.Request) -> httpx.Response:
+        calls.append((req.method, req.url.path))
+        if req.url.path == "/v1/agents":
+            return httpx.Response(201, json={"agent": {"name": "cliagent"}})
+        if req.url.path.endswith("/deployments"):
+            assert req.headers["content-type"] == "application/zip"
+            return httpx.Response(202, json={"deployment": {"status": "live"}})
+        return httpx.Response(404)
+
+    client = GrainsClient("https://api.test", "grains_dt_x", http=httpx.Client(transport=httpx.MockTransport(handler)))
+    monkeypatch.setattr(deploy_cmd, "_client_or_exit", lambda a: client)
+    rc = deploy_cmd.cmd_deploy(argparse.Namespace(path=str(tmp_path), token="grains_dt_x", api=None))
+    assert rc == 0
+    assert ("POST", "/v1/agents") in calls
+    assert any(p.endswith("/deployments") for _, p in calls)
+
+
+def test_deploy_tolerates_existing_agent(tmp_path):
+    _project(tmp_path)
+
+    def handler(req):
+        if req.url.path == "/v1/agents":
+            return httpx.Response(409, json={"detail": "taken"})
+        if req.url.path.endswith("/deployments"):
+            return httpx.Response(202, json={"deployment": {"status": "live"}})
+        return httpx.Response(404)
+
+    client = GrainsClient("https://api.test", "t", http=httpx.Client(transport=httpx.MockTransport(handler)))
+    import grains_cli.deploy as d
+    orig = d._client_or_exit
+    d._client_or_exit = lambda a: client
+    try:
+        rc = d.cmd_deploy(argparse.Namespace(path=str(tmp_path), token="t", api=None))
+    finally:
+        d._client_or_exit = orig
+    assert rc == 0
+
+
+def test_deploy_requires_token(tmp_path, monkeypatch, capsys):
+    _project(tmp_path)
+    monkeypatch.delenv("GRAINS_DEPLOY_TOKEN", raising=False)
+    rc = None
+    try:
+        deploy_cmd.cmd_deploy(argparse.Namespace(path=str(tmp_path), token=None, api=None))
+    except SystemExit as e:
+        rc = e.code
+    assert rc == 2
+    assert "welcome" in capsys.readouterr().err

{grains_cli-0.1.0 → grains_cli-0.2.0}/tests/test_dev.py

@@ -179,3 +179,23 @@ def test_charges_surfaced_in_task_record(running_server, tmp_path):
     record = _wait_for_done(base, body["task_id"])
     assert record["status"] == "done"
     assert record["charges"] == [{"value": "5.00", "currency": "USDC"}]
+
+
+def test_dev_runs_node_agent(running_server, tmp_path):
+    import shutil
+    if not shutil.which("node"):
+        import pytest
+        pytest.skip("node not available")
+    project = tmp_path / "nodeagent"
+    project.mkdir()
+    (project / "grains_app.mjs").write_text(
+        "export function handle(task) {\n  return task.reply('node echo: ' + task.text);\n}\n"
+    )
+    (project / "grains.toml").write_text(
+        '[agent]\nname = "n"\nentrypoint = "grains_app:handle"\nruntime = "nodejs20.x"\npublic = false\n'
+    )
+    base = running_server(project)
+    _, body = _post_json(base, "/tasks", {"text": "hi"})
+    record = _wait_for_done(base, body["task_id"])
+    assert record["status"] == "done"
+    assert record["reply"]["text"] == "node echo: hi"

grains_cli-0.2.0/tests/test_init_node.py

@@ -0,0 +1,88 @@
+"""`grains init --template node` scaffolds a valid grains_app.mjs + grains.toml
+for JS/Node agents -- mirrors test_init.py's coverage of the Python templates.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tomllib
+
+import pytest
+from grains_cli.init import cmd_init, detect_framework
+from grains_cli.main import build_parser
+from grains_cli.templates import render_app
+
+
+def _parse_init(argv):
+    return build_parser().parse_args(["init", *argv])
+
+
+def _run_init(tmp_path, **extra_argv):
+    argv = [str(tmp_path)]
+    for flag, value in extra_argv.items():
+        if value is True:
+            argv.append(f"--{flag}")
+        elif value is not None:
+            argv.extend([f"--{flag}", str(value)])
+    return cmd_init(_parse_init(argv))
+
+
+def test_node_is_a_valid_template_choice():
+    args = _parse_init([".", "--template", "node"])
+    assert args.template == "node"
+
+
+def test_init_generates_node_app_and_toml(tmp_path):
+    rc = _run_init(tmp_path, template="node")
+    assert rc == 0
+
+    app_path = tmp_path / "grains_app.mjs"
+    toml_path = tmp_path / "grains.toml"
+    assert app_path.exists()
+    assert toml_path.exists()
+    assert not (tmp_path / "grains_app.py").exists()
+
+    config = tomllib.loads(toml_path.read_text())
+    assert config["agent"]["entrypoint"] == "grains_app:handle"
+    assert config["agent"]["runtime"] == "nodejs20.x"
+    assert config["agent"]["public"] is False
+    assert config["secrets"]["names"] == []
+    assert config["egress"]["allow"] == []
+
+
+def test_node_wrapper_is_at_most_25_lines():
+    assert len(render_app("node").splitlines()) <= 25
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node not installed")
+def test_generated_node_app_parses_with_node_check(tmp_path):
+    _run_init(tmp_path, template="node")
+    app_path = tmp_path / "grains_app.mjs"
+    result = subprocess.run(
+        ["node", "--check", str(app_path)], capture_output=True, text=True, check=False
+    )
+    assert result.returncode == 0, result.stderr
+
+
+def test_detect_framework_node_from_package_json_with_no_python_deps(tmp_path):
+    (tmp_path / "package.json").write_text('{"name": "x"}\n')
+    assert detect_framework(tmp_path) == "node"
+
+
+def test_detect_framework_prefers_python_deps_over_node(tmp_path):
+    (tmp_path / "package.json").write_text('{"name": "x"}\n')
+    (tmp_path / "requirements.txt").write_text("crewai==0.80.0\n")
+    assert detect_framework(tmp_path) == "crewai"
+
+
+def test_detect_framework_none_when_no_package_json_and_no_python_deps(tmp_path):
+    assert detect_framework(tmp_path) == "none"
+
+
+def test_init_force_overwrite_from_python_to_node(tmp_path):
+    _run_init(tmp_path, template="none")
+    assert (tmp_path / "grains_app.py").exists()
+    _run_init(tmp_path, template="node", force=True)
+    assert (tmp_path / "grains_app.mjs").exists()
+    config = tomllib.loads((tmp_path / "grains.toml").read_text())
+    assert config["agent"]["runtime"] == "nodejs20.x"