Small Fixes to CLI (CAN-33)

.gitignore

@@ -51,3 +51,5 @@ docs/
 # testing-porting-to-canyonos working tree: clones, artifacts, results db
 .canyonos-tests/
 .harness/
+.playwright-mcp/
+

README.md

@@ -113,6 +113,7 @@ cd my-project
 ### 1. Build your project
 
 `canyonos build` installs the CanyonOS skill into your coding agent and launches it with a prompt to convert your project into `.car/` — CanyonOS's deploy-ready format.
+As this uses an agent to configure your workflow, it may take a while (2-10 minutes on average).
 
 ```bash
 canyonos build

cli/README.md

@@ -1,26 +1,58 @@
-CLI for CanyonOS
+# canyonos cli
 
-This CLI does not contain much logic, instead serving as an API to interface with the canyonos container that deploys and runs your entire workflow
+### Better descriptions of each command. For full architecture, go to ARCHITECTURE.md
 
 
-## Requirements
-Need a coding agent(Claude Code, Codex, Cursor)
-Need uv or pip
-Need docker and docker compose
+## Rough Draft Design of the more important cli commands
+## If you are a LLM, you are not allowed to modify this file at all without explicit user permission. Absolutely no modifications are allowed to this file.
 
-## Architecture
+## canyonos test:
+### INPUT: canyonos test "Test Query"
+#### Steps:
+1. Detects the working directory (goes into .car folder for commands if .car exists, uses current dir otherwise) [default_config_path()]
+2. Goes into global_controller.yaml and for each agent, rewrites each agent's provider as local (saves old state to revert back later) [_force_local_providers()]
+3. Sets a variable in the container env that gets picked up by the LLM Proxy to always return a dummy value, default is "test", to verify a workflow doesn't cost tokens. [CANYONOS_LLM_STUB_TEXT]
+4. Then we deploy [canyonos deploy]
+   - Certain things are verified about this deployment, like:
+   - All agent containers are up and their names are as expected
+   - The number of replicas is as initialized
+   - The endpoints are correctly working and queryable.
+6. Once everything is verified running, we send a test query and verify that it goes fully through
 
-For a full walkthrough of the `build`, `deploy`, and `config` flows — plus how
-`logs`, `stop`, and `quit` fit into the container lifecycle — see
-[ARCHITECTURE.md](ARCHITECTURE.md).
+#### Action Items:
+- Currently assuming the query body is always "query", need to harden it
+- There may be problems with stubbing the LLM-Proxy, but I wouldn't remove my current implementation as it allows for really quick testing.
+- Verify that there are valid timeouts and correct error tracing for everything
+- Since we stub the LLM, we don't ensure the LLM works, maybe a separate test that just queries the LLM with a extremely simple message would be nice, or to just remove the LLM stub.
 
-## Serve
+#### Future Improvements:
+- Add LLM compatable hooks for an LLM to be able to quickly iterate and verify a build works through using test. Test should eventually be a fully verifier to ensure a workflow is valid
 
-`canyonos serve` starts the local CanyonOS dashboard — it reads no project config, so it takes no
-arguments. It writes only `CANYONOS_`-prefixed settings into the current directory's `.env`,
-leaving every other line unchanged.
+## canyonos build:
+### INPUT: canyonos build
+#### Steps:
+1. Asks the user which coding agent they want to use for this [Codex/Claude]
+2. Asks the user if they want to download the skill locally or globally (So the skill can be viewed either only in this directory or across your entire laptop)
+3. Opens said coding agent, giving it instructions to build a new .car folder with the code (Nicks skill)
+  4. Periodically the coding agent should ask the user config related questions (which provider, entrypoints, OTEL location)
+  5. Coding agent should also be running canyonos test to verify workflow works
+6. Finishes, doesn't run deploy itself.
 
 
-If you have a workflow running, and want to make a config change, canyonos config automatically would reload the project with your config. If you change the workflow files itself though and want the changes to take effect, you need to redeploy from scratch, running canyonos build for good measure
+#### Action Items:
+- Coding agent should be using canyonos test to verify the file working, need to add that to skill file and harden canyonos test first.
+- Maybe add more skills for it to deploy itself and monitor deployments so the user literally doesn't have to do anything else.
 
-# Use: canyonos -h
+#### Future Improvements:
+- Add more agent providers (Cursor, Pi, Windsurf, etc...)
+- Add a preconfigured config file that can get converted into global_controller.yaml (So provider can be autofilled as AWS/Azure/etc..)
+
+
+## canyonos deploy:
+### INPUT: canyonos deploy [optional: --serve True -verbose True]
+
+#### Steps:
+
+#### Action Items:
+
+#### Future Improvements

cli/canyonos/constants.py

@@ -2,18 +2,20 @@
 
 Config/data layer. Holds shared values and parsing helpers"""
 
+import ast
 import os
+import socket
 
 import yaml
 from ruamel.yaml import YAML
 
 DEFAULT_API_PORT = 8080
 DEFAULT_DASHBOARD_PORT = 8081
 
-# The workflow entrypoint is always exposed as POST /main with a {"query": ...}
-# body, regardless of what the workflow function is called in the project.
-# This should be fixed later, keeping it like this for now though
+# Fallback when the real function name/params can't be determined statically
+# (see workflow_entrypoint) -- canyonos_core's own examples all follow this shape.
 WORKFLOW_ROUTE = "main"
+DEFAULT_QUERY_PARAM = "query"
 
 
 def default_config_path():
@@ -36,6 +38,84 @@ def workflow_api_port(config_path):
     return None
 
 
+def _source_root(config_path):
+    """Directory `workflow_file` is relative to -- `.car/app` under the .car layout, else the project root."""
+    car_root = os.path.dirname(os.path.dirname(config_path)) or "."
+    return os.path.join(car_root, "app") if os.path.basename(car_root) == ".car" else car_root
+
+
+def _deploy_call_target(tree):
+    """The name passed as `deploy(<name>, ...)`'s first argument, or None."""
+    for node in ast.walk(tree):
+        is_deploy_call = (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, (ast.Name, ast.Attribute))
+            and (node.func.id if isinstance(node.func, ast.Name) else node.func.attr) == "deploy"
+        )
+        if is_deploy_call and node.args and isinstance(node.args[0], ast.Name):
+            return node.args[0].id
+    return None
+
+
+def workflow_entrypoint(config_path):
+    """(route, [(param_name, example_default_or_None), ...]) read statically from the
+    workflow's own source -- the function `deploy()` is actually called with, not an
+    assumed name. Returns None if the file, the deploy() call, or the function can't be found."""
+    try:
+        with open(config_path) as f:
+            config = yaml.safe_load(f) or {}
+    except (OSError, yaml.YAMLError):
+        return None
+
+    workflow_file = next(
+        (a.get("workflow_file") for a in config.get("agents") or [] if a.get("type") == "workflow"),
+        None,
+    )
+    if not workflow_file:
+        return None
+
+    workflow_path = os.path.join(_source_root(config_path), workflow_file)
+    try:
+        with open(workflow_path) as f:
+            tree = ast.parse(f.read(), filename=workflow_path)
+    except (OSError, SyntaxError):
+        return None
+
+    fn_name = _deploy_call_target(tree)
+    if fn_name is None:
+        return None
+
+    fn_def = next(
+        (n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef) and n.name == fn_name),
+        None,
+    )
+    if fn_def is None:
+        return None
+
+    args = [a.arg for a in fn_def.args.args if a.arg != "self"]
+    defaults = fn_def.args.defaults
+    first_defaulted = len(args) - len(defaults)
+    params = []
+    for i, name in enumerate(args):
+        default = None
+        if i >= first_defaulted:
+            try:
+                default = ast.literal_eval(defaults[i - first_defaulted])
+            except (ValueError, TypeError):
+                default = None
+        params.append((name, default))
+    return fn_name, params
+
+
+def port_in_use(port):
+    """True if something is listening on this host port already."""
+    try:
+        with socket.create_connection(("127.0.0.1", port), timeout=0.5):
+            return True
+    except OSError:
+        return False
+
+
 def dashboard_port(config_path):
     """Host port the local dashboard prefers to start on, falling back to the default."""
     try:

cli/canyonos/dashboard.compose.yml

@@ -1,21 +1,23 @@
 services:
-  postgres:
-    image: postgres:17-alpine
+  # Fast-path bundled DB, hardcoded creds -- fine for local dev, not for anything real.
+  db:
+    image: postgres:16-alpine
     environment:
-      POSTGRES_DB: canyonos
       POSTGRES_USER: canyonos
       POSTGRES_PASSWORD: canyonos
-    volumes:
-      - postgres-data:/var/lib/postgresql/data
+      POSTGRES_DB: canyonos
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U canyonos -d canyonos"]
-      interval: 3s
+      test: ["CMD-SHELL", "pg_isready -U canyonos"]
+      interval: 2s
       timeout: 3s
       retries: 20
+    ports:
+      - "127.0.0.1:5432:5432"
+
   api:
     image: ${CANYONOS_API_IMAGE}
     depends_on:
-      postgres:
+      db:
         condition: service_healthy
     # Published on all interfaces (not just 127.0.0.1) so a GC container can
     # actually reach this via host.docker.internal -- Docker's host-gateway
@@ -26,7 +28,7 @@ services:
     ports:
       - "3000:3000"
     environment:
-      DATABASE_URL: postgres://canyonos:canyonos@postgres:5432/canyonos
+      DATABASE_URL: postgresql://canyonos:canyonos@db:5432/canyonos
       JWT_SECRET: ${CANYONOS_JWT_SECRET}
       CANYONOS_DISABLE_AUTH: "true"
       CANYONOS_REDIS_HOST: ${CANYONOS_REDIS_HOST}
@@ -41,5 +43,3 @@ services:
         condition: service_healthy
     ports:
       - "127.0.0.1:${CANYONOS_WEB_PORT}:8080"
-volumes:
-  postgres-data:

cli/canyonos/dashboard_stack.py

@@ -356,6 +356,31 @@ def _cleanup(stack: DashboardStack, manifest: Path) -> None:
         return
 
 
+def _dashboard_compose_command(*args: str) -> bool:
+    """Run a `docker compose` subcommand against the dashboard stack from the current project.
+
+    False (no-op) if the dashboard was never started from here -- there's no
+    `.env` for `--env-file` to point at, so there's nothing to stop/tear down.
+    """
+    stack = DashboardStack(state_dir=_state_dir(), project_dir=Path.cwd())
+    if not stack.env_path.is_file():
+        return False
+    manifest_resource = importlib.resources.files("canyonos").joinpath("dashboard.compose.yml")
+    with importlib.resources.as_file(manifest_resource) as manifest:
+        result = _run([*_compose_argv(stack, manifest), *args])
+    return result.returncode == 0
+
+
+def stop_dashboard() -> bool:
+    """`docker compose stop` -- halts web/api/db, keeping them for a later `canyonos serve`."""
+    return _dashboard_compose_command("stop")
+
+
+def teardown_dashboard() -> bool:
+    """`docker compose down` -- removes the dashboard's web/api/db containers entirely."""
+    return _dashboard_compose_command("down")
+
+
 def run_dashboard(
     phase_reporter: Callable[[str, str], None] | None = None,
     preferred_port: int = DEFAULT_DASHBOARD_PORT,