crow-cli 0.1.47__tar.gz → 0.1.50__tar.gz

{crow_cli-0.1.47 → crow_cli-0.1.50}/.github/workflows/build-binaries.yml

@@ -4,6 +4,9 @@ on:
   push:
     tags:
       - "v*" # Trigger on version tags like v0.1.13
+  # Build without cutting a release: the release job below only runs for tags,
+  # so this is how a platform build gets exercised before a version exists.
+  workflow_dispatch:
 
 jobs:
   build:
@@ -13,14 +16,14 @@ jobs:
       matrix:
         os:
           [
-            ubuntu-22.04,
+            ubuntu-24.04,
             macos-15-intel,
             macos-latest,
             windows-latest,
             ubuntu-24.04-arm,
           ]
         include:
-          - os: ubuntu-22.04
+          - os: ubuntu-24.04
             target: linux-x86_64
             archive_name: crow-cli-linux-x86_64.tar.gz
           - os: macos-15-intel
@@ -50,14 +53,20 @@ jobs:
         with:
           python-version-file: "pyproject.toml"
 
-      - name: Install dependencies
-        run: |
-          uv pip install --system pyinstaller
-
+      # pyinstaller is in the dev group, so `uv run` resolves it along with the
+      # project. The old `uv pip install --system pyinstaller` installed into
+      # setup-python's interpreter, which is not the one the build uses.
       - name: Build with PyInstaller
         run: |
           uv run pyinstaller crow-cli.spec --noconfirm
 
+      - name: Smoke-test the binary
+        shell: bash
+        run: |
+          BIN=dist/crow-cli
+          if [ "${{ runner.os }}" == "Windows" ]; then BIN=dist/crow-cli.exe; fi
+          "$BIN" --version
+
       - name: Create archive
         shell: bash
         run: |
@@ -72,7 +81,13 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: crow-cli-${{ matrix.target }}
-          path: ${{ matrix.archive_name }}
+          # `Create archive` cds into dist/, so the archive is dist/<name>. This
+          # was <name> at the workspace root for ten releases: upload-artifact's
+          # default if-no-files-found is `warn`, so every build job passed with an
+          # empty artifact, download-artifact merged nothing, and the release glob
+          # matched nothing — a release with zero assets, all six jobs green.
+          path: dist/${{ matrix.archive_name }}
+          if-no-files-found: error
           retention-days: 30
 
   release:
@@ -96,6 +111,9 @@ jobs:
           files: |
             crow-cli-*.tar.gz
             crow-cli-*.zip
+          # Without this an unmatched glob publishes an assetless release and
+          # exits 0 — which is what happened from v0.1.35 to v0.1.48.
+          fail_on_unmatched_files: true
           draft: false
           prerelease: false
           generate_release_notes: true

crow_cli-0.1.50/.gitignore

@@ -0,0 +1,47 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# keys
+.env
+
+# test database
+*.db
+*.db*
+
+# test caches
+.pytest_cache
+config/logs/*.log
+config-done
+
+# MyST build output
+docs/_build/
+_site/
+
+*.log
+*.log*
+
+sandbox/lancedb-testing/pylate_lancedb/
+
+node_modules/
+
+# playwright-cli scratch state
+.playwright-cli/
+
+# Orphans of the split-clients merge: crates/ and packages/ moved to
+# github.com/crow-cli/crow, and git deleted every TRACKED file under them, but
+# the build output they left on disk is not git's to remove — 58G of cargo
+# target/ and 13G of packages/ (vendored-VSCodium sysroot caches, downloaded
+# .vsix files, the packaged VSCode-* trees, node_modules, bun dists). Ignored
+# so `git status` stays readable and a `git add -A` cannot swallow 71G.
+# Deleting them is safe and reclaims the space; nothing here is a source of
+# truth any more.
+/target/
+/packages/

crow_cli-0.1.50/AGENTS.md

@@ -0,0 +1,3 @@
+# RULES
+
+1. Make no mistakes

{crow_cli-0.1.47 → crow_cli-0.1.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: crow-cli
-Version: 0.1.47
+Version: 0.1.50
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/crow-cli/crow-cli
 Project-URL: Repository, https://github.com/crow-cli/crow-cli
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://github.com/crow-cli/crow-cli#readme
 License-Expression: MIT
 License-File: LICENSE.md
 Requires-Python: >=3.13
-Requires-Dist: agent-client-protocol[http]>=0.12.1
+Requires-Dist: agent-client-protocol[http]>=1.0.0rc3
 Requires-Dist: aiosqlite>=0.22.1
 Requires-Dist: ast-grep-py>=0.45.3
 Requires-Dist: boto3>=1.40.0
@@ -36,6 +36,7 @@ Requires-Dist: polars>=1.44.1
 Requires-Dist: psutil>=7.2.2
 Requires-Dist: psycopg[binary]>=3.1
 Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pywinpty>=3.1.2; sys_platform == 'win32'
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: readabilipy>=0.3.0
 Requires-Dist: redis>=8.1.0
@@ -63,7 +64,9 @@ Description-Content-Type: text/markdown
 
 [Documentation](https://crow-ai.dev)
 
-`crow-cli` is an [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) coding agent: a streaming ReAct loop that reads and edits code, runs shells, searches the web and sees images — plus a set of first-party clients (terminal, TUI, IDE, browser) that all drive the same agent over the same wire.
+`crow-cli` is an [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) coding agent: a streaming ReAct loop that reads and edits code, runs shells, searches the web and sees images.
+
+This repo is the **agent**. The first-party clients (terminal, TUI, IDE, browser) that drive it over the same wire live in their own repo, [`crow-cli/crow`](https://github.com/crow-cli/crow) — `crates/crow-client` for the `crow-agent` TUI, `packages/crow-gui` for the IDE build, `packages/vscode-acp` + `packages/chat` for the chat extension. `crow-cli init` clones it beside this one and `crow-cli install crow` builds from it.
 
 Two ideas hold the whole thing together.
 
@@ -79,10 +82,10 @@ The agent:
 - Docker, for the SearXNG service that backs web search
 - An API key for an OpenAI-compatible LLM provider (OpenRouter, OpenAI, your own endpoint, …)
 
-The clients, if you want to build them:
+The clients, if you want to build them — a clone of [`crow-cli/crow`](https://github.com/crow-cli/crow), which `crow-cli init` leaves at `~/.agents/crow/src/crow`:
 
-- Rust (`rustup` + `cargo`) for the `crow-agent` TUI and `crow-web`
-- node matching `packages/crow-gui/vscodium/.nvmrc` (24.x), `npm`, `bun`, `jq`, `curl`, `unzip`, the libx11/libxkbfile/libsecret headers, and `fakeroot` + `dpkg-dev` for the `.deb` — all of it for the IDE build, which is a from-source VS Code
+- Rust (`rustup` + `cargo`) for the `crow-agent` TUI
+- node matching that repo's `packages/crow-gui/vscodium/.nvmrc` (24.x), `npm`, `bun`, `jq`, `curl`, `unzip`, the libx11/libxkbfile/libsecret headers, and `fakeroot` + `dpkg-dev` for the `.deb` — all of it for the IDE build, which is a from-source VS Code
 
 | Platform | Notes |
 |----------|-------|
@@ -96,7 +99,7 @@ The clients, if you want to build them:
 uv tool install crow-cli --python 3.13     # from PyPI
 ```
 
-…or from a clone, which you want anyway if you mean to build the IDE or the Rust clients — both build from the tree they sit in:
+…or from a clone, which you want anyway if you mean to build the clients — `install crow` builds them from a checkout of their own repo:
 
 ```bash
 git clone https://github.com/crow-cli/crow-cli.git
@@ -118,8 +121,8 @@ cd ~/.agents/crow && docker compose up -d     # starts SearXNG (written by init,
 | `~/.agents/crow/config.yaml` | providers, models, `mcpServers`, `agent_servers`, `db_uri` |
 | `~/.agents/crow/.env` | secrets, referenced from the config as `${VAR}` (chmod 600) |
 | `~/.agents/crow/compose.yaml` + `searxng/settings.yml` | the services init offers: SearXNG, PostgreSQL, RustFS |
-| `~/.agents/crow/prompts/` | `system_prompt.jinja2` and `execute_prompt.jinja2` — edit them, they are yours |
-| `~/.agents/crow/src/` | checkouts init clones and `uv sync`s: `crow-cli` and `crow-cli.github.io` (the website). `--no-source` skips them |
+| `~/.agents/crow/prompts/` | `system_prompt.jinja2` — edit it, it is yours |
+| `~/.agents/crow/src/` | checkouts init clones and `uv sync`s: `crow-cli`, `crow` (the clients) and `crow-cli.github.io` (the website). `--no-source` skips them |
 | `~/.agents/skills/crow-cli` | the crow-cli skill, installed globally on purpose: it is the BIOS, so an agent can repair a broken spawn |
 
 **Nothing runs from that checkout implicitly.** What init does with it is write one `agent_servers` entry into `config.yaml` — ordinary config, which you can read, edit or delete:
@@ -193,18 +196,18 @@ Two shapes, and only two:
 | Client | What it is | The agent | Run it |
 |--------|-----------|-----------|--------|
 | `crow-cli run` | the reference client: one-shot, REPL, JSONL, session forks | spawns its own over stdio | `crow-cli run "…"` |
-| `crow-agent` | Rust ratatui TUI (`crates/crow-client`) | spawns its own over stdio — `--agent`, default `crow-cli acp2` | `crow-agent` |
-| crow IDE | VS Code built from source by `packages/crow-gui`, with the crow chat extension bundled as a built-in — desktop app and browser server | dials `crowAcp.endpoint`, default `ws://127.0.0.1:2771/acp` | `crow` |
-| `crow-web` | browser client: one Rust binary embedding the SPA, owning fs buffers, ptys and an `/acp` proxy | the SPA dials `ws://127.0.0.1:2771/acp`; the proxy upstream is `--acp-url` | `crow-web --port 2770` |
+| `crow-agent` | Rust ratatui TUI (`crates/crow-client` in the `crow` repo) | spawns its own over stdio — `--agent`, default `crow-cli acp2` | `crow-agent` |
+| crow IDE | VS Code built from source by the `crow` repo's `packages/crow-gui`, with the crow chat extension bundled as a built-in — desktop app and browser server | dials `crowAcp.endpoint`, default `ws://127.0.0.1:2771/acp` | `crow` |
 | any ACP client | Zed and friends, over stdio or WebSocket | the client spawns the command you give it | `crow-cli acp` / `acp2` |
 
-**The args, exactly.** `acp --http` serves protocol v1 on **2769**; `acp2 --http` serves v2 on **2771**; `--host` (default `127.0.0.1`) and `--port` move either. One v2 instance is enough for both diallers — the IDE panel's `crowAcp.endpoint` and the browser client's endpoint field both default to `ws://127.0.0.1:2771/acp`. `crow-web`'s own `/acp` proxy is the one default that still points at v1, so give it `--acp-url ws://127.0.0.1:2771/acp` when you want the proxy on the same server. A client that only speaks v1 needs `crow-cli acp --http` instead, on 2769.
+**The args, exactly.** `acp --http` serves protocol v1 on **2769**; `acp2 --http` serves v2 on **2771**; `--host` (default `127.0.0.1`) and `--port` move either. One v2 instance is enough for every dialler — the IDE panel's `crowAcp.endpoint` defaults to `ws://127.0.0.1:2771/acp`. A client that only speaks v1 needs `crow-cli acp --http` instead, on 2769.
 
 ### `crow-agent` — the terminal client
 
-A ratatui ACP client in `crates/crow-client`. It spawns the agent itself (`--agent`, default `crow-cli acp2`) so there is nothing to start first, and it is a real terminal citizen: markdown rendering, syntax-highlighted diffs, drag-to-select copy, tool calls that expand in place, `!` for a shell line and `/` for commands.
+A ratatui ACP client in the `crow` repo's `crates/crow-client`. It spawns the agent itself (`--agent`, default `crow-cli acp2`) so there is nothing to start first, and it is a real terminal citizen: markdown rendering, syntax-highlighted diffs, drag-to-select copy, tool calls that expand in place, `!` for a shell line and `/` for commands.
 
 ```bash
+cd ~/.agents/crow/src/crow                    # the clients repo; `crow-cli init` clones it
 cargo build --release --bin crow-agent
 crow-agent                              # in the current workspace
 crow-agent -w ~/src/project --session-id <id>   # resume a durable session
@@ -212,18 +215,16 @@ crow-agent --model <name>               # ask the agent for a model (default: $C
 crow-agent --demo                       # scripted turns, no agent needed
 ```
 
-`crates/crow-gui` is the ratatui-over-wgpu rendering service; the same crate also compiles to wasm as its own `crow-web` bin (`--features web`, staged by `crates/crow-client/scripts/build-web.sh`). That bin shares its name with the `crow-web` server binary from `crates/crow-web`, so build it with `-p crow-gui`.
-
 ### crow — the IDE
 
-`packages/crow-gui` builds crow's IDE ("crowdium") from Microsoft's open-source VS Code using a **vendored copy of VSCodium's build pipeline**, rebranded, with crow's patches in `packages/crow-gui/vscodium/patches/user/`. Two artifacts come out and both are first-class:
+The `crow` repo's `packages/crow-gui` builds crow's IDE from Microsoft's open-source VS Code using a **vendored copy of VSCodium's build pipeline**, rebranded, with crow's patches in `packages/crow-gui/vscodium/patches/user/`. Two artifacts come out and both are first-class:
 
 | Artifact | What it is | Entry point |
 |----------|-----------|-------------|
 | `vscodium/VSCode-linux-<arch>/` | the Electron desktop app | `bin/crow` |
 | `vscodium/vscode-reh-web-linux-<arch>/` | the browser server (`reh-web`) | `bin/crow-server` |
 
-The chat panel is `packages/vscode-acp` (`crow-acp`), built with bun and copied into every packaged tree as a **built-in** extension alongside the Jupyter + Python stack pinned in `packages/crow-gui/bundled-exts.json` — so notebooks get a kernel picker with no marketplace install.
+The chat panel is that repo's `packages/vscode-acp` (`crow-acp`), built with bun and copied into every packaged tree as a **built-in** extension alongside the Jupyter + Python stack pinned in `packages/crow-gui/bundled-exts.json` — so notebooks get a kernel picker with no marketplace install.
 
 ```bash
 uv run crow-cli install crow   # from the clone: builds the .deb, installs it with dpkg, builds the TUI
@@ -239,8 +240,7 @@ Then open whichever front door you want:
 
 ```bash
 crow                           # the desktop IDE
-crow web                       # the same IDE in a browser on a fixed port
-crow serve-web                 # …or through the IDE's own CLI, which prints a tokenised URL
+crow serve-web                 # the same IDE in a browser, through the IDE's own CLI, which prints a tokenised URL
 crow agent                     # the crow-agent TUI — the one front door that spawns its own agent
 ```
 
@@ -248,29 +248,22 @@ The chat panel is a webview that dials the agent directly and spawns nothing: `c
 
 `serve-web` starts the `reh-web` server that ships **beside** the IDE (`/usr/share/crow/web`, or `$CROW_WEB_DIR`): crow publishes no release tarballs, so there is nothing to download and no update check to fail.
 
-The install **is** the `.deb`, and that is not pedantry: `dpkg -i` is the only route that gets a root-owned `4755 chrome-sandbox`, which Chromium requires — without it the desktop app can die silently on kernels that restrict unprivileged user namespaces (Ubuntu 24.04+). So `install crow` runs the pipeline with `--deb` (it wants `fakeroot` + `dpkg-dev`, and says so *before* a 40-minute build rather than after) and then installs it:
-
-```bash
-cd packages/crow-gui && ./build.sh --deb     # what `install crow` runs; ~40 min the first time
-sudo dpkg -i vscodium/assets/crow_*.deb      # …and what it runs next
-```
-
-A deb that is already built is installed without rebuilding (`--rebuild` forces the pipeline). `--no-deb` is the rootless fallback: it copies the trees to `~/.local/share/crow/{ide,web}` and writes a user-level `.desktop` entry — a build you can run, not an install, with no setuid sandbox. The deb route deletes that user-level entry instead of letting it shadow the package's.
-
-### `crow-web` — the browser client
+The install **is** the `.deb`, and that is not pedantry: `dpkg -i` is the only route that gets a root-owned `4755 chrome-sandbox`, which Chromium requires — without it the desktop app can die silently on kernels that restrict unprivileged user namespaces (Ubuntu 24.04+). So `install crow` runs the pipeline with `--deb` (it wants `fakeroot` + `dpkg-dev`, and says so *before* a 40-minute build rather than after) and then installs it.
 
-`crates/crow-web` is the state server behind the web client: the browser is a view, this process owns what it views — the fs tree, open buffers (content, dirty, mtime), ptys, and a proxy to the agent. Ctrl+S in the editor is a commit to this server, not a browser-side write. The SPA (`packages/chat`, `packages/editor`, vendored `packages/aui`) is embedded in the binary with `rust-embed`, so it is one executable and one origin; `packages/electron` wraps that same binary in a window.
+`install crow` works from anywhere: it builds from the clients checkout it is running in, and a packaged install (pip / uv tool) with no checkout beside it falls back to `~/.agents/crow/src/crow`, cloning it first if that is missing. The whole install, by hand, is:
 
 ```bash
-# terminal 1 — the agent: one instance, left running
-crow-cli acp2 --http                                        # ws://127.0.0.1:2771/acp
-
-# terminal 2 — the client
-cargo run -p crow-web -- --port 2770 --acp-url ws://127.0.0.1:2771/acp
-# open http://127.0.0.1:2770 — the SPA's own endpoint field defaults to :2771 too
+cd ~/.agents/crow/src/crow                              # if it exists; otherwise git clone https://github.com/crow-cli/crow.git there
+cd packages/crow-gui && ./build.sh --arch x64 --deb     # IDE + web server + the .deb; ~40 min the first time
+sudo dpkg -i vscodium/assets/crow_*.deb                 # system-wide: /usr/share/crow, /usr/bin/crow, /usr/bin/crow-web
+cd ../.. && cargo build --release --bin crow-agent      # the agent TUI
+mkdir -p ~/.local/bin && install -m 755 target/release/crow-agent ~/.local/bin/
+crow-cli install crow --no-build                        # writes the ~/.local/bin/crow shim; the deb is already built
 ```
 
-`--root` sets the workspace it owns, `--shell` the pty's shell, and `--acp-url` the upstream of its `/acp` proxy — default `ws://127.0.0.1:2769/acp`, the v1 port, which is why the example above passes it explicitly. It spawns ptys, never agents, and it serves loopback clients only.
+There is no separate `bun install` / `bun run build` step: `build.sh` builds `packages/vscode-acp` (the `crow-acp` chat extension) and drops it into every packaged tree as a built-in, together with the Jupyter + Python stack. The last line is the only one with no shell equivalent — the `crow` shim is forty lines of POSIX sh (`launcher_text()` in `src/crow_cli/cli/install_crow.py`), and `--no-build` writes it without touching the pipeline.
+
+A deb that is already built is installed without rebuilding (`--rebuild` forces the pipeline). `--no-deb` is the rootless fallback: it copies the trees to `~/.local/share/crow/{ide,web}` and writes a user-level `.desktop` entry — a build you can run, not an install, with no setuid sandbox, and it says so up front. The deb route deletes that user-level entry instead of letting it shadow the package's.
 
 ### Any other ACP client
 
@@ -363,7 +356,7 @@ models:
     provider: openrouter
     model: anthropic/claude-sonnet-4
 agent_servers:
-  crow-execute:
+  my-agent:
     protocol: acp2
     command: uv
     args: ["--project", "~/.agents/crow/src/crow-cli", "run", "crow-cli", "acp2"]
@@ -398,7 +391,7 @@ uv run pytest tests/integration   # real sqlite, agent spawn
 uv run pytest tests/e2e           # live LLM calls (costs $)
 ```
 
-The Rust clients build with cargo (`cargo build --release --bin crow-agent`; the workspace's default member is `crates/crow-client`, so `crow-web` and `crow-gui` want `-p <crate>`), the web client's frontend with bun/npm in `packages/chat`, and the IDE with `packages/crow-gui/build.sh` (`--help` lists its flags; `--prepare-only` stops after fetch + patch + `npm ci`).
+The clients build in their own repo — `cd ~/.agents/crow/src/crow`. There: the Rust client with cargo (`cargo build --release --bin crow-agent`; `crates/crow-client` is the workspace's only member), the chat webview and the extension with bun (`bun install` at the root, then `bun run ext:build`), and the IDE with `packages/crow-gui/build.sh` (`--help` lists its flags; `--prepare-only` stops after fetch + patch + `npm ci`). Its CI is `.github/workflows/build-ide.yml` and `build-tui.yml` in that repo.
 
 ## Project layout
 
@@ -414,18 +407,19 @@ src/crow_cli/tools/       the in-kernel subtools the prelude binds
 src/crow_cli/config/      config loading, defaults, overrides (shared by every layer)
 src/crow_cli/memory/      shared SQL persistence (sqlite default, PostgreSQL supported)
 
-crates/crow-client/       crow-agent — the ratatui ACP client TUI
-crates/crow-gui/          ratatui-over-wgpu UI service (native window or wasm)
-crates/crow-web/          the browser client's Rust state server (fs, ptys, /acp proxy)
+tests/                    unit, integration, e2e
+```
 
-packages/chat/            the chat SPA (@crow/chat)
-packages/editor/          the CodeMirror 6 editor pane (@crow/editor)
+The clients are a separate repo — [`crow-cli/crow`](https://github.com/crow-cli/crow), cloned by `init` to `~/.agents/crow/src/crow`:
+
+```
+crates/crow-client/       crow-agent — the ratatui ACP client TUI
+packages/chat/            the chat webview source (@crow/chat) — the extension's UI
 packages/aui/             vendored assistant-ui, as built dist
-packages/electron/        Electron shell around the crow-web binary
 packages/vscode-acp/      crow-acp — the chat extension bundled into the IDE
 packages/crow-gui/        the IDE build pipeline (vendored VSCodium + crow's patches)
 ```
 
 ## License
 
-MIT — see [LICENSE.md](./LICENSE.md).
+MIT — see [LICENSE.md](./LICENSE.md).

{crow_cli-0.1.47 → crow_cli-0.1.50}/PYINSTALLER_BUILD.md

@@ -5,16 +5,21 @@
 ### 1. GitHub Workflow: `.github/workflows/build-binaries.yml`
 
 Builds crow-cli binaries for:
-- **Linux x86_64** (ubuntu-22.04)
-- **macOS x86_64** (macos-13)
+- **Linux x86_64** (ubuntu-24.04)
+- **Linux ARM64** (ubuntu-24.04-arm)
+- **macOS x86_64** (macos-15-intel)
 - **macOS ARM64** (macos-latest - Apple Silicon)
+- **Windows x86_64** (windows-latest)
 
-**Trigger:** Push version tags (e.g., `v0.1.13`)
+**Trigger:** Push version tags (e.g., `v0.1.49`), or run the workflow by hand
+(`workflow_dispatch`) to exercise a platform build without cutting a release.
 
 **Output:** Creates GitHub release with attached archives:
 - `crow-cli-linux-x86_64.tar.gz`
+- `crow-cli-linux-aarch64.tar.gz`
 - `crow-cli-darwin-x86_64.tar.gz`
 - `crow-cli-darwin-aarch64.tar.gz`
+- `crow-cli-windows-x86_64.zip`
 
 ### 2. PyInstaller Spec File: `crow-cli.spec`
 
@@ -32,11 +37,13 @@ Added `pyinstaller>=6.0.0` to dev dependency group
 
 ```bash
 cd crow-cli
-uv --project . pip install pyinstaller
-uv --project . run pyinstaller crow-cli.spec --noconfirm
-dist/crow-cli --help
+uv run pyinstaller crow-cli.spec --noconfirm
+dist/crow-cli --version
 ```
 
+`pyinstaller` is in the dev dependency group, so `uv run` resolves it with the
+project — the same command the workflow runs.
+
 ## 🚀 Usage
 
 ### To trigger a build:

{crow_cli-0.1.47 → crow_cli-0.1.50}/README.md

@@ -12,7 +12,9 @@
 
 [Documentation](https://crow-ai.dev)
 
-`crow-cli` is an [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) coding agent: a streaming ReAct loop that reads and edits code, runs shells, searches the web and sees images — plus a set of first-party clients (terminal, TUI, IDE, browser) that all drive the same agent over the same wire.
+`crow-cli` is an [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) coding agent: a streaming ReAct loop that reads and edits code, runs shells, searches the web and sees images.
+
+This repo is the **agent**. The first-party clients (terminal, TUI, IDE, browser) that drive it over the same wire live in their own repo, [`crow-cli/crow`](https://github.com/crow-cli/crow) — `crates/crow-client` for the `crow-agent` TUI, `packages/crow-gui` for the IDE build, `packages/vscode-acp` + `packages/chat` for the chat extension. `crow-cli init` clones it beside this one and `crow-cli install crow` builds from it.
 
 Two ideas hold the whole thing together.
 
@@ -28,10 +30,10 @@ The agent:
 - Docker, for the SearXNG service that backs web search
 - An API key for an OpenAI-compatible LLM provider (OpenRouter, OpenAI, your own endpoint, …)
 
-The clients, if you want to build them:
+The clients, if you want to build them — a clone of [`crow-cli/crow`](https://github.com/crow-cli/crow), which `crow-cli init` leaves at `~/.agents/crow/src/crow`:
 
-- Rust (`rustup` + `cargo`) for the `crow-agent` TUI and `crow-web`
-- node matching `packages/crow-gui/vscodium/.nvmrc` (24.x), `npm`, `bun`, `jq`, `curl`, `unzip`, the libx11/libxkbfile/libsecret headers, and `fakeroot` + `dpkg-dev` for the `.deb` — all of it for the IDE build, which is a from-source VS Code
+- Rust (`rustup` + `cargo`) for the `crow-agent` TUI
+- node matching that repo's `packages/crow-gui/vscodium/.nvmrc` (24.x), `npm`, `bun`, `jq`, `curl`, `unzip`, the libx11/libxkbfile/libsecret headers, and `fakeroot` + `dpkg-dev` for the `.deb` — all of it for the IDE build, which is a from-source VS Code
 
 | Platform | Notes |
 |----------|-------|
@@ -45,7 +47,7 @@ The clients, if you want to build them:
 uv tool install crow-cli --python 3.13     # from PyPI
 ```
 
-…or from a clone, which you want anyway if you mean to build the IDE or the Rust clients — both build from the tree they sit in:
+…or from a clone, which you want anyway if you mean to build the clients — `install crow` builds them from a checkout of their own repo:
 
 ```bash
 git clone https://github.com/crow-cli/crow-cli.git
@@ -67,8 +69,8 @@ cd ~/.agents/crow && docker compose up -d     # starts SearXNG (written by init,
 | `~/.agents/crow/config.yaml` | providers, models, `mcpServers`, `agent_servers`, `db_uri` |
 | `~/.agents/crow/.env` | secrets, referenced from the config as `${VAR}` (chmod 600) |
 | `~/.agents/crow/compose.yaml` + `searxng/settings.yml` | the services init offers: SearXNG, PostgreSQL, RustFS |
-| `~/.agents/crow/prompts/` | `system_prompt.jinja2` and `execute_prompt.jinja2` — edit them, they are yours |
-| `~/.agents/crow/src/` | checkouts init clones and `uv sync`s: `crow-cli` and `crow-cli.github.io` (the website). `--no-source` skips them |
+| `~/.agents/crow/prompts/` | `system_prompt.jinja2` — edit it, it is yours |
+| `~/.agents/crow/src/` | checkouts init clones and `uv sync`s: `crow-cli`, `crow` (the clients) and `crow-cli.github.io` (the website). `--no-source` skips them |
 | `~/.agents/skills/crow-cli` | the crow-cli skill, installed globally on purpose: it is the BIOS, so an agent can repair a broken spawn |
 
 **Nothing runs from that checkout implicitly.** What init does with it is write one `agent_servers` entry into `config.yaml` — ordinary config, which you can read, edit or delete:
@@ -142,18 +144,18 @@ Two shapes, and only two:
 | Client | What it is | The agent | Run it |
 |--------|-----------|-----------|--------|
 | `crow-cli run` | the reference client: one-shot, REPL, JSONL, session forks | spawns its own over stdio | `crow-cli run "…"` |
-| `crow-agent` | Rust ratatui TUI (`crates/crow-client`) | spawns its own over stdio — `--agent`, default `crow-cli acp2` | `crow-agent` |
-| crow IDE | VS Code built from source by `packages/crow-gui`, with the crow chat extension bundled as a built-in — desktop app and browser server | dials `crowAcp.endpoint`, default `ws://127.0.0.1:2771/acp` | `crow` |
-| `crow-web` | browser client: one Rust binary embedding the SPA, owning fs buffers, ptys and an `/acp` proxy | the SPA dials `ws://127.0.0.1:2771/acp`; the proxy upstream is `--acp-url` | `crow-web --port 2770` |
+| `crow-agent` | Rust ratatui TUI (`crates/crow-client` in the `crow` repo) | spawns its own over stdio — `--agent`, default `crow-cli acp2` | `crow-agent` |
+| crow IDE | VS Code built from source by the `crow` repo's `packages/crow-gui`, with the crow chat extension bundled as a built-in — desktop app and browser server | dials `crowAcp.endpoint`, default `ws://127.0.0.1:2771/acp` | `crow` |
 | any ACP client | Zed and friends, over stdio or WebSocket | the client spawns the command you give it | `crow-cli acp` / `acp2` |
 
-**The args, exactly.** `acp --http` serves protocol v1 on **2769**; `acp2 --http` serves v2 on **2771**; `--host` (default `127.0.0.1`) and `--port` move either. One v2 instance is enough for both diallers — the IDE panel's `crowAcp.endpoint` and the browser client's endpoint field both default to `ws://127.0.0.1:2771/acp`. `crow-web`'s own `/acp` proxy is the one default that still points at v1, so give it `--acp-url ws://127.0.0.1:2771/acp` when you want the proxy on the same server. A client that only speaks v1 needs `crow-cli acp --http` instead, on 2769.
+**The args, exactly.** `acp --http` serves protocol v1 on **2769**; `acp2 --http` serves v2 on **2771**; `--host` (default `127.0.0.1`) and `--port` move either. One v2 instance is enough for every dialler — the IDE panel's `crowAcp.endpoint` defaults to `ws://127.0.0.1:2771/acp`. A client that only speaks v1 needs `crow-cli acp --http` instead, on 2769.
 
 ### `crow-agent` — the terminal client
 
-A ratatui ACP client in `crates/crow-client`. It spawns the agent itself (`--agent`, default `crow-cli acp2`) so there is nothing to start first, and it is a real terminal citizen: markdown rendering, syntax-highlighted diffs, drag-to-select copy, tool calls that expand in place, `!` for a shell line and `/` for commands.
+A ratatui ACP client in the `crow` repo's `crates/crow-client`. It spawns the agent itself (`--agent`, default `crow-cli acp2`) so there is nothing to start first, and it is a real terminal citizen: markdown rendering, syntax-highlighted diffs, drag-to-select copy, tool calls that expand in place, `!` for a shell line and `/` for commands.
 
 ```bash
+cd ~/.agents/crow/src/crow                    # the clients repo; `crow-cli init` clones it
 cargo build --release --bin crow-agent
 crow-agent                              # in the current workspace
 crow-agent -w ~/src/project --session-id <id>   # resume a durable session
@@ -161,18 +163,16 @@ crow-agent --model <name>               # ask the agent for a model (default: $C
 crow-agent --demo                       # scripted turns, no agent needed
 ```
 
-`crates/crow-gui` is the ratatui-over-wgpu rendering service; the same crate also compiles to wasm as its own `crow-web` bin (`--features web`, staged by `crates/crow-client/scripts/build-web.sh`). That bin shares its name with the `crow-web` server binary from `crates/crow-web`, so build it with `-p crow-gui`.
-
 ### crow — the IDE
 
-`packages/crow-gui` builds crow's IDE ("crowdium") from Microsoft's open-source VS Code using a **vendored copy of VSCodium's build pipeline**, rebranded, with crow's patches in `packages/crow-gui/vscodium/patches/user/`. Two artifacts come out and both are first-class:
+The `crow` repo's `packages/crow-gui` builds crow's IDE from Microsoft's open-source VS Code using a **vendored copy of VSCodium's build pipeline**, rebranded, with crow's patches in `packages/crow-gui/vscodium/patches/user/`. Two artifacts come out and both are first-class:
 
 | Artifact | What it is | Entry point |
 |----------|-----------|-------------|
 | `vscodium/VSCode-linux-<arch>/` | the Electron desktop app | `bin/crow` |
 | `vscodium/vscode-reh-web-linux-<arch>/` | the browser server (`reh-web`) | `bin/crow-server` |
 
-The chat panel is `packages/vscode-acp` (`crow-acp`), built with bun and copied into every packaged tree as a **built-in** extension alongside the Jupyter + Python stack pinned in `packages/crow-gui/bundled-exts.json` — so notebooks get a kernel picker with no marketplace install.
+The chat panel is that repo's `packages/vscode-acp` (`crow-acp`), built with bun and copied into every packaged tree as a **built-in** extension alongside the Jupyter + Python stack pinned in `packages/crow-gui/bundled-exts.json` — so notebooks get a kernel picker with no marketplace install.
 
 ```bash
 uv run crow-cli install crow   # from the clone: builds the .deb, installs it with dpkg, builds the TUI
@@ -188,8 +188,7 @@ Then open whichever front door you want:
 
 ```bash
 crow                           # the desktop IDE
-crow web                       # the same IDE in a browser on a fixed port
-crow serve-web                 # …or through the IDE's own CLI, which prints a tokenised URL
+crow serve-web                 # the same IDE in a browser, through the IDE's own CLI, which prints a tokenised URL
 crow agent                     # the crow-agent TUI — the one front door that spawns its own agent
 ```
 
@@ -197,29 +196,22 @@ The chat panel is a webview that dials the agent directly and spawns nothing: `c
 
 `serve-web` starts the `reh-web` server that ships **beside** the IDE (`/usr/share/crow/web`, or `$CROW_WEB_DIR`): crow publishes no release tarballs, so there is nothing to download and no update check to fail.
 
-The install **is** the `.deb`, and that is not pedantry: `dpkg -i` is the only route that gets a root-owned `4755 chrome-sandbox`, which Chromium requires — without it the desktop app can die silently on kernels that restrict unprivileged user namespaces (Ubuntu 24.04+). So `install crow` runs the pipeline with `--deb` (it wants `fakeroot` + `dpkg-dev`, and says so *before* a 40-minute build rather than after) and then installs it:
-
-```bash
-cd packages/crow-gui && ./build.sh --deb     # what `install crow` runs; ~40 min the first time
-sudo dpkg -i vscodium/assets/crow_*.deb      # …and what it runs next
-```
-
-A deb that is already built is installed without rebuilding (`--rebuild` forces the pipeline). `--no-deb` is the rootless fallback: it copies the trees to `~/.local/share/crow/{ide,web}` and writes a user-level `.desktop` entry — a build you can run, not an install, with no setuid sandbox. The deb route deletes that user-level entry instead of letting it shadow the package's.
-
-### `crow-web` — the browser client
+The install **is** the `.deb`, and that is not pedantry: `dpkg -i` is the only route that gets a root-owned `4755 chrome-sandbox`, which Chromium requires — without it the desktop app can die silently on kernels that restrict unprivileged user namespaces (Ubuntu 24.04+). So `install crow` runs the pipeline with `--deb` (it wants `fakeroot` + `dpkg-dev`, and says so *before* a 40-minute build rather than after) and then installs it.
 
-`crates/crow-web` is the state server behind the web client: the browser is a view, this process owns what it views — the fs tree, open buffers (content, dirty, mtime), ptys, and a proxy to the agent. Ctrl+S in the editor is a commit to this server, not a browser-side write. The SPA (`packages/chat`, `packages/editor`, vendored `packages/aui`) is embedded in the binary with `rust-embed`, so it is one executable and one origin; `packages/electron` wraps that same binary in a window.
+`install crow` works from anywhere: it builds from the clients checkout it is running in, and a packaged install (pip / uv tool) with no checkout beside it falls back to `~/.agents/crow/src/crow`, cloning it first if that is missing. The whole install, by hand, is:
 
 ```bash
-# terminal 1 — the agent: one instance, left running
-crow-cli acp2 --http                                        # ws://127.0.0.1:2771/acp
-
-# terminal 2 — the client
-cargo run -p crow-web -- --port 2770 --acp-url ws://127.0.0.1:2771/acp
-# open http://127.0.0.1:2770 — the SPA's own endpoint field defaults to :2771 too
+cd ~/.agents/crow/src/crow                              # if it exists; otherwise git clone https://github.com/crow-cli/crow.git there
+cd packages/crow-gui && ./build.sh --arch x64 --deb     # IDE + web server + the .deb; ~40 min the first time
+sudo dpkg -i vscodium/assets/crow_*.deb                 # system-wide: /usr/share/crow, /usr/bin/crow, /usr/bin/crow-web
+cd ../.. && cargo build --release --bin crow-agent      # the agent TUI
+mkdir -p ~/.local/bin && install -m 755 target/release/crow-agent ~/.local/bin/
+crow-cli install crow --no-build                        # writes the ~/.local/bin/crow shim; the deb is already built
 ```
 
-`--root` sets the workspace it owns, `--shell` the pty's shell, and `--acp-url` the upstream of its `/acp` proxy — default `ws://127.0.0.1:2769/acp`, the v1 port, which is why the example above passes it explicitly. It spawns ptys, never agents, and it serves loopback clients only.
+There is no separate `bun install` / `bun run build` step: `build.sh` builds `packages/vscode-acp` (the `crow-acp` chat extension) and drops it into every packaged tree as a built-in, together with the Jupyter + Python stack. The last line is the only one with no shell equivalent — the `crow` shim is forty lines of POSIX sh (`launcher_text()` in `src/crow_cli/cli/install_crow.py`), and `--no-build` writes it without touching the pipeline.
+
+A deb that is already built is installed without rebuilding (`--rebuild` forces the pipeline). `--no-deb` is the rootless fallback: it copies the trees to `~/.local/share/crow/{ide,web}` and writes a user-level `.desktop` entry — a build you can run, not an install, with no setuid sandbox, and it says so up front. The deb route deletes that user-level entry instead of letting it shadow the package's.
 
 ### Any other ACP client
 
@@ -312,7 +304,7 @@ models:
     provider: openrouter
     model: anthropic/claude-sonnet-4
 agent_servers:
-  crow-execute:
+  my-agent:
     protocol: acp2
     command: uv
     args: ["--project", "~/.agents/crow/src/crow-cli", "run", "crow-cli", "acp2"]
@@ -347,7 +339,7 @@ uv run pytest tests/integration   # real sqlite, agent spawn
 uv run pytest tests/e2e           # live LLM calls (costs $)
 ```
 
-The Rust clients build with cargo (`cargo build --release --bin crow-agent`; the workspace's default member is `crates/crow-client`, so `crow-web` and `crow-gui` want `-p <crate>`), the web client's frontend with bun/npm in `packages/chat`, and the IDE with `packages/crow-gui/build.sh` (`--help` lists its flags; `--prepare-only` stops after fetch + patch + `npm ci`).
+The clients build in their own repo — `cd ~/.agents/crow/src/crow`. There: the Rust client with cargo (`cargo build --release --bin crow-agent`; `crates/crow-client` is the workspace's only member), the chat webview and the extension with bun (`bun install` at the root, then `bun run ext:build`), and the IDE with `packages/crow-gui/build.sh` (`--help` lists its flags; `--prepare-only` stops after fetch + patch + `npm ci`). Its CI is `.github/workflows/build-ide.yml` and `build-tui.yml` in that repo.
 
 ## Project layout
 
@@ -363,18 +355,19 @@ src/crow_cli/tools/       the in-kernel subtools the prelude binds
 src/crow_cli/config/      config loading, defaults, overrides (shared by every layer)
 src/crow_cli/memory/      shared SQL persistence (sqlite default, PostgreSQL supported)
 
-crates/crow-client/       crow-agent — the ratatui ACP client TUI
-crates/crow-gui/          ratatui-over-wgpu UI service (native window or wasm)
-crates/crow-web/          the browser client's Rust state server (fs, ptys, /acp proxy)
+tests/                    unit, integration, e2e
+```
 
-packages/chat/            the chat SPA (@crow/chat)
-packages/editor/          the CodeMirror 6 editor pane (@crow/editor)
+The clients are a separate repo — [`crow-cli/crow`](https://github.com/crow-cli/crow), cloned by `init` to `~/.agents/crow/src/crow`:
+
+```
+crates/crow-client/       crow-agent — the ratatui ACP client TUI
+packages/chat/            the chat webview source (@crow/chat) — the extension's UI
 packages/aui/             vendored assistant-ui, as built dist
-packages/electron/        Electron shell around the crow-web binary
 packages/vscode-acp/      crow-acp — the chat extension bundled into the IDE
 packages/crow-gui/        the IDE build pipeline (vendored VSCodium + crow's patches)
 ```
 
 ## License
 
-MIT — see [LICENSE.md](./LICENSE.md).
+MIT — see [LICENSE.md](./LICENSE.md).

{crow_cli-0.1.47 → crow_cli-0.1.50}/crow-cli.spec

@@ -1,5 +1,7 @@
 # -*- mode: python ; coding: utf-8 -*-
 
+import sys
+
 from PyInstaller.utils.hooks import copy_metadata
 
 block_cipher = None
@@ -37,6 +39,10 @@ a = Analysis(
         'crow_cli.config',
         'crow_cli.client',
         'crow_cli.client.main',
+        'crow_cli.client.pty_spawn',
+        # ConPTY, reached only from pty_spawn's Windows branch — and only on
+        # Windows, where pywinpty is installed (a platform-marked dependency).
+        *(['winpty'] if sys.platform == 'win32' else []),
         'crow_cli.agent_runner',
         # Lazy (PEP 562) facades resolve through importlib at runtime —
         # invisible to static analysis, so pin them here.