One harness setup path: pipelines harness setup <claude|codex|opencode|pi>
Checks the CLI on the server's PATH (install command when missing), signs in with the harness's own login only when needed (--login forces it), keeps the OpenCode/Pi model pickers, and verifies with the server's check. Works on native and Docker installs (Docker delegates to the container setup); --host is a hidden compatibility alias. harness list shows all four harnesses' installed/signed-in/configured/default status. ./install --opencode|--pi now point to the command; ./install ends with the next-step hint.
This commit is contained in:
@@ -37,6 +37,21 @@ installs these for you. See [Installation](docs/install.md).
|
||||
Then open the URL the installer prints (default `http://localhost:8082/`) and
|
||||
sign in with the password you chose.
|
||||
|
||||
### Set up harnesses
|
||||
|
||||
One command per harness (native or Docker install). Each checks the CLI is
|
||||
installed (printing the install command if not), signs in with the harness's
|
||||
own login when needed, picks default models for OpenCode/Pi, and verifies it
|
||||
the way the server does. No restart needed.
|
||||
|
||||
```sh
|
||||
pipelines harness setup opencode # stages + chat (required; ./install configured it)
|
||||
pipelines harness setup pi # pipeline stages
|
||||
pipelines harness setup claude # chat
|
||||
pipelines harness setup codex # chat
|
||||
pipelines harness list # status of all four
|
||||
```
|
||||
|
||||
## What you can do
|
||||
|
||||
**Runs**
|
||||
|
||||
@@ -76,6 +76,7 @@ func main() {
|
||||
args = []string{"tui"}
|
||||
}
|
||||
if err == nil {
|
||||
app.Install = config
|
||||
err = app.Run(ctx, args)
|
||||
}
|
||||
if err != nil {
|
||||
|
||||
@@ -42,8 +42,8 @@ Configure two independent model defaults:
|
||||
|
||||
```sh
|
||||
./install --docker --harness pi # Docker setup without OpenCode login
|
||||
./install --opencode --default
|
||||
./install --pi
|
||||
pipelines harness setup opencode --default
|
||||
pipelines harness setup pi
|
||||
pipelines harness
|
||||
pipelines harness default pi
|
||||
pipelines new --harness pi
|
||||
@@ -82,8 +82,9 @@ reused on reinstall/reconfigure.
|
||||
Profiles live in XDG config home's `pipelines/harnesses.json` and record their
|
||||
launch mode: a host profile launches the executable directly, while a
|
||||
Docker-linked profile records the checkout directory and launches through
|
||||
`docker compose exec`. `harness setup <opencode|pi> --host` configures (or
|
||||
converts) a host profile and clears any Docker link; without `--host`,
|
||||
`docker compose exec`. `harness setup <opencode|pi>` on a native installation
|
||||
configures (or converts) a host profile and clears any Docker link; on a Docker
|
||||
installation it configures the container. Without a native installation,
|
||||
reconfiguring a Docker-linked profile re-verifies that the recorded directory
|
||||
still has `compose.yaml` and fails naming it instead of saving a link that cannot
|
||||
launch. Setup's summary and `harness list` report the resulting mode (and, for
|
||||
|
||||
+76
-28
@@ -1,8 +1,8 @@
|
||||
# Harnesses
|
||||
|
||||
A harness is the agent program Pipelines drives. Pipelines never installs,
|
||||
upgrades or signs in a harness for you; it uses the copy and login you already
|
||||
have on the server machine.
|
||||
A harness is the agent program Pipelines drives. Pipelines never installs or
|
||||
upgrades a harness; it uses the copy you install on the server machine and the
|
||||
harness's own login, which `pipelines harness setup <name>` opens for you.
|
||||
|
||||
| Harness | Pipeline stages | Chat | Mid-turn messages | Authoring/debug sessions |
|
||||
| --- | --- | --- | --- | --- |
|
||||
@@ -13,6 +13,52 @@ have on the server machine.
|
||||
|
||||
Stage configs accept only `harness=opencode` or `harness=pi`.
|
||||
|
||||
## Set up harnesses
|
||||
|
||||
After `./install` (native or `--docker`), set up each harness with one
|
||||
command. It works the same on native and Docker installations (the mode is
|
||||
detected from the installation):
|
||||
|
||||
```sh
|
||||
pipelines harness setup opencode # stages + chat: sign in, pick the two default models
|
||||
pipelines harness setup pi # stages: sign in via /login, pick the two default models
|
||||
pipelines harness setup claude # chat: claude auth login if needed, verify
|
||||
pipelines harness setup codex # chat: codex login if needed, verify the App Server socket
|
||||
pipelines harness list # installed / signed in / configured / default, all four
|
||||
```
|
||||
|
||||
Each run:
|
||||
|
||||
1. **Checks the CLI** is installed where the server finds it (the `PATH`
|
||||
recorded by `./install`, plus the locations listed per harness below). If
|
||||
it is missing, it prints the install command and stops:
|
||||
|
||||
| Harness | Install command |
|
||||
| --- | --- |
|
||||
| OpenCode | `curl -fsSL https://opencode.ai/install \| bash` |
|
||||
| Pi | `npm install --global @earendil-works/pi-coding-agent` |
|
||||
| Claude Code | `curl -fsSL https://claude.ai/install.sh \| bash` |
|
||||
| Codex | `npm install --global @openai/codex` |
|
||||
|
||||
2. **Signs in** with the harness's own login only when it is not signed in
|
||||
(`opencode auth login`, Pi's `/login`, `claude auth login`, `codex login`).
|
||||
`--login` forces it.
|
||||
3. **Models.** OpenCode and Pi: fuzzy-pick the interactive model and the
|
||||
new-pipeline model (or pass `--model P/M --pipeline-model P/M`; `--default`
|
||||
makes the harness the default). Claude Code and Codex: nothing to pick;
|
||||
models are chosen per chat in the app.
|
||||
4. **Verifies** with the server's own check and prints one success line:
|
||||
OpenCode/Pi list both models from a signed-in provider (no inference);
|
||||
Claude Code `claude auth status`; Codex the App Server socket. No restart is
|
||||
needed: new runs read OpenCode/Pi profiles when they start, and the server
|
||||
looks for Claude Code and Codex every 10 seconds. (After a first OpenCode
|
||||
sign-in to a new provider, run `pipelines restart` if the app's chat does not
|
||||
offer it yet.)
|
||||
|
||||
OpenCode is required: `./install` stops without it, because it is the default
|
||||
stage and chat harness, and configures its profile itself. Claude Code and
|
||||
Codex are chat-only and need a native installation.
|
||||
|
||||
## Choosing models
|
||||
|
||||
**Pipeline stages.** Each model stage pins its own model in its `configs`
|
||||
@@ -48,18 +94,16 @@ profiles in `~/.config/pipelines/harnesses.json` (override with
|
||||
drafts and starters). Published versions are never rewritten.
|
||||
|
||||
```sh
|
||||
pipelines harness list # profiles, default, launch mode
|
||||
pipelines harness setup opencode --host # fuzzy-pick both models
|
||||
pipelines harness setup pi --host --login # sign in to Pi, then pick models
|
||||
pipelines harness setup opencode --host --model P/M --pipeline-model P/M
|
||||
pipelines harness default pi # default harness for new/edit/debug
|
||||
pipelines harness setup opencode # fuzzy-pick both models
|
||||
pipelines harness setup pi --login # sign in to Pi again, then pick models
|
||||
pipelines harness setup opencode --model P/M --pipeline-model P/M
|
||||
pipelines harness default pi # default harness for new/edit/debug
|
||||
pipelines harness list --json # profiles, launch mode and status
|
||||
```
|
||||
|
||||
`--host` writes a native profile and clears any Docker link. `./install`
|
||||
writes the OpenCode host profile itself (from `--model`, the saved profile, or
|
||||
OpenCode's own default) and keeps an existing valid Pi profile; it never adds
|
||||
a Pi profile on its own. `./install --opencode` and `./install --pi` (which run
|
||||
`scripts/setup-harness.py`) apply only to a Docker installation.
|
||||
`./install` writes the OpenCode profile itself (from `--model`, the saved
|
||||
profile, or OpenCode's own default) and keeps an existing valid Pi profile; it
|
||||
never adds a Pi profile on its own.
|
||||
|
||||
**Chat** models are chosen in the chat's model picker; each harness supplies
|
||||
its own catalog.
|
||||
@@ -93,9 +137,9 @@ A server started with `-opencode-endpoint URL` (or
|
||||
`PIPELINES_OPENCODE_ENDPOINT`) attaches chat to that service instead; the
|
||||
native installer does not set this.
|
||||
|
||||
**Install and sign in:** install OpenCode yourself, then sign in to your
|
||||
providers with OpenCode (`opencode auth login`). Pipelines reads the default
|
||||
model with `opencode api get /api/model/default`.
|
||||
**Install and sign in:** `pipelines harness setup opencode` (runs
|
||||
`opencode auth login` when no provider is connected). Pipelines reads the
|
||||
default model with `opencode api get /api/model/default`.
|
||||
|
||||
**Mid-turn messages:** not supported by the harness. A message sent while a
|
||||
turn runs is stored in the server's durable queue (up to 8 per chat) and sent
|
||||
@@ -118,12 +162,12 @@ thinking level and is verified before the task is sent.
|
||||
**Install and sign in:**
|
||||
|
||||
```sh
|
||||
# install Pi yourself so `pi` is on PATH, then:
|
||||
pipelines harness setup pi --host --login
|
||||
pipelines harness setup pi
|
||||
```
|
||||
|
||||
`--login` opens a bare Pi session; run `/login` there, finish the provider
|
||||
sign-in, and exit with Ctrl+C or Ctrl+D to return to model selection.
|
||||
When Pi lists no models (or with `--login`) setup opens a bare Pi session; run
|
||||
`/login` there, finish the provider sign-in, and exit with Ctrl+C or Ctrl+D to
|
||||
return to model selection.
|
||||
|
||||
## Claude Code
|
||||
|
||||
@@ -138,7 +182,9 @@ and output and `--permission-prompt-tool=stdio` (at most 8 live at once). Idle
|
||||
chats are resumed with `--resume <id>`. Approvals and `AskUserQuestion` appear
|
||||
as cards in the app.
|
||||
|
||||
**Sign in:** use your existing Claude Code login. A background service can see
|
||||
**Sign in:** `pipelines harness setup claude` runs `claude auth login` when
|
||||
`claude auth status` (with the server's `PATH` and the fallbacks below) is not
|
||||
signed in. A background service can see
|
||||
a stale keychain entry; when the default login check fails, the server retries
|
||||
with the login file in `~/.claude`. For a login that does not depend on either,
|
||||
create a long-lived token and store it privately:
|
||||
@@ -171,7 +217,8 @@ and read at its next step. Model changes apply from the next turn.
|
||||
it every 10 seconds and attaches when it appears. Pipelines never starts a
|
||||
Codex daemon or changes Codex settings.
|
||||
|
||||
**Sign in:** your existing Codex login. Threads created from Pipelines are
|
||||
**Sign in:** `pipelines harness setup codex` runs `codex login` when `codex
|
||||
login status` fails, then checks for the socket. Threads created from Pipelines are
|
||||
ordinary Codex threads and also show in the Codex app.
|
||||
|
||||
**Behavior:** new threads use the `workspace-write` sandbox and Codex's own
|
||||
@@ -207,14 +254,15 @@ elsewhere once you continue it in Pipelines.
|
||||
- **Harness works in a terminal but not from the service.** The login service
|
||||
does not read your shell profile. It uses the `PATH` recorded when you ran
|
||||
`./install` (prefixed with `<prefix>/bin`). Rerun `./install` from a shell
|
||||
where the harness is on `PATH`, or set an absolute `executable` with
|
||||
`pipelines harness setup <name> --host --executable /path/to/bin`.
|
||||
- **Claude Code not listed under Chat.** Check `claude` resolves in one of the
|
||||
locations above and `claude auth status` reports logged in.
|
||||
- **Codex not listed under Chat.** Open the Codex app and confirm the socket
|
||||
where the harness is on `PATH` (setup tells you when this is the case). For
|
||||
OpenCode/Pi you can instead set an absolute executable with
|
||||
`pipelines harness setup <name> --executable /path/to/bin`.
|
||||
- **Claude Code not listed under Chat.** Run `pipelines harness setup claude`.
|
||||
- **Codex not listed under Chat.** Run `pipelines harness setup codex`; open
|
||||
the Codex app and confirm the socket
|
||||
exists under `~/.codex/app-server-control/`. The installer does not record
|
||||
a custom `CODEX_HOME` for the service, so the default `~/.codex` is used.
|
||||
- **"Pi is not configured on this execution server".** Run
|
||||
`pipelines harness setup pi --host` on the server machine.
|
||||
`pipelines harness setup pi` on the server machine.
|
||||
- **"invalid provider/model identifier".** Use the exact IDs from the harness's
|
||||
model list; placeholders such as `default/default` are refused.
|
||||
|
||||
+26
-9
@@ -23,8 +23,8 @@ them, and it stops naming whatever is missing.
|
||||
| git, curl | source checkout, updates, release lookup |
|
||||
| C compiler (`cc`, `clang` or `gcc`) | ntfy's SQLite driver is cgo (Xcode Command Line Tools on macOS) |
|
||||
| **Docker, running** | builds the Flutter web app and the APK |
|
||||
| OpenCode on `PATH` | required; default stage and chat harness |
|
||||
| Pi, Claude Code, Codex | optional; see [Harnesses](harnesses.md) |
|
||||
| OpenCode on `PATH` | required; default stage and chat harness (`curl -fsSL https://opencode.ai/install \| bash`) |
|
||||
| Pi, Claude Code, Codex | optional; set up after install with `pipelines harness setup <name>` |
|
||||
| tailscale | optional; tailnet HTTPS access |
|
||||
|
||||
The install is **all or nothing**: the web app and the server are built before
|
||||
@@ -60,7 +60,24 @@ Linux needs `systemctl --user`. Other platforms are refused.
|
||||
(stopped, plist renamed to `.disabled`), so only one web app is served.
|
||||
11. If `PIPELINES_WEB_PUBLIC_URL` is an `https://…ts.net` address, runs
|
||||
`tailscale serve --bg --https=<port> http://127.0.0.1:<web-port>`.
|
||||
12. Prints the browser URLs.
|
||||
12. Prints the browser URLs and the next step, setting up harnesses.
|
||||
|
||||
## Set up harnesses
|
||||
|
||||
One command per harness, the same on native and Docker installations:
|
||||
|
||||
```sh
|
||||
pipelines harness setup opencode # stages + chat (required; ./install already configured it)
|
||||
pipelines harness setup pi # stages
|
||||
pipelines harness setup claude # chat
|
||||
pipelines harness setup codex # chat
|
||||
pipelines harness list # status of all four
|
||||
```
|
||||
|
||||
Each run checks the CLI is installed where the server finds it (printing the
|
||||
install command if not), signs in with the harness's own login when needed,
|
||||
picks OpenCode/Pi default models, and verifies with the server's check. No
|
||||
restart is needed. See [Harnesses](harnesses.md#set-up-harnesses).
|
||||
|
||||
It also warns when a different `pipelines` earlier on `PATH` shadows the new
|
||||
one; it does not touch that binary.
|
||||
@@ -129,10 +146,10 @@ Options: `--server-url ws(s)://host:port/connect`, `--notes TEXT`, `--prefix`.
|
||||
|
||||
`./install --docker` is the optional Compose installation with its own
|
||||
container harness credentials; see [Docker](docker.md). Do not run it
|
||||
alongside a native install on the same ports. `./install --opencode` and
|
||||
`./install --pi` reconfigure a **Docker** installation's harness and refuse on
|
||||
a native install; native installs use `pipelines harness setup` (see
|
||||
[Harnesses](harnesses.md)).
|
||||
alongside a native install on the same ports. Its harnesses are set up with
|
||||
the same `pipelines harness setup opencode|pi` (run from the checkout), which
|
||||
configures them inside the container. The old `./install --opencode` and
|
||||
`./install --pi` only print that command and exit.
|
||||
|
||||
## Lifecycle commands
|
||||
|
||||
@@ -251,5 +268,5 @@ per-user data directory (`XDG_DATA_HOME`, or Application Support on macOS).
|
||||
- **Web app missing**: the server refuses to start without it. Run
|
||||
`./install --web`.
|
||||
- **A harness works in the terminal but not in the service**: the service uses
|
||||
the `PATH` recorded at install time. Rerun `./install` from a shell where the
|
||||
harness is on `PATH`. See [Harnesses](harnesses.md#troubleshooting).
|
||||
the `PATH` recorded at install time; `pipelines harness setup <name>` says
|
||||
so. Rerun `./install` from a shell where the harness is on `PATH`. See [Harnesses](harnesses.md#troubleshooting).
|
||||
|
||||
+2
-3
@@ -9,9 +9,8 @@ python3 -c 'import sys; sys.exit(0 if sys.version_info >= (3, 9) else "Python 3.
|
||||
mode=${1:-}
|
||||
case "$mode" in
|
||||
--opencode|--pi)
|
||||
harness=${mode#--}
|
||||
shift
|
||||
exec python3 scripts/setup-harness.py "$harness" "$@"
|
||||
echo "./install $mode was removed; run: pipelines harness setup ${mode#--}" >&2
|
||||
exit 2
|
||||
;;
|
||||
--docker|docker)
|
||||
if [ "$#" -gt 0 ]; then shift; fi
|
||||
|
||||
@@ -28,7 +28,11 @@ propagation; container profiles have no `DockerDirectory` and cannot recurse, an
|
||||
explicit native profiles keep the host path. The picker uses a true `x/term` TTY
|
||||
check, so `/dev/null` and pipes fail fast instead of hanging.
|
||||
|
||||
`pipelines harness setup opencode|pi --login --default` runs a styled onboarding
|
||||
`pipelines harness setup <claude|codex|opencode|pi>` is the single setup path on
|
||||
native and Docker installations: it checks the CLI is reachable from the server
|
||||
(printing the install command when missing), signs in only when needed (`--login`
|
||||
forces it) and verifies with the server's own check. Claude Code and Codex have
|
||||
no models to pick. For OpenCode/Pi it runs a styled onboarding
|
||||
wizard (bold title, verified Docker harness versions) and selects separate
|
||||
harness and new-pipeline models using type-to-filter fuzzy pickers, not numbered
|
||||
prompts. Each picker itself shows its numbered step with the title and purpose
|
||||
@@ -39,14 +43,14 @@ and Esc cancels. The saved value is preselected and marked `(current)`; the wind
|
||||
follows the active row on narrow terminals and the heading, selected row and
|
||||
no-match state stay within the real terminal height.
|
||||
Automation: `--model PROVIDER/MODEL --pipeline-model PROVIDER/MODEL`.
|
||||
`harness default [opencode|pi]` switches defaults; `harness list` prints settings.
|
||||
`harness default [opencode|pi]` switches defaults; `harness list` shows installed /
|
||||
signed-in / configured / default status for all four (`--json` adds profiles).
|
||||
Setup reads catalogs/login state without inference. Changing defaults never
|
||||
rewrites published definitions or retained drafts. Canceling or failing either
|
||||
picker leaves saved preferences byte-identical. Non-terminal automation with a
|
||||
missing model fails clearly instead of starting a picker.
|
||||
|
||||
`./install --opencode` / `./install --pi` reopen login and selection. With an
|
||||
existing Docker setup, they configure inside its container and link the host
|
||||
On an existing Docker setup, `pipelines harness setup opencode|pi` configures inside its container and link the host
|
||||
launcher without restarting/deploying services. They resolve and verify the current
|
||||
OpenCode V2 release from the single documented complete
|
||||
`GET .../git/matching-refs/tags/v2` response (a bounded complete array with no
|
||||
@@ -63,8 +67,7 @@ stay authoritative and a dirty source still rebuilds. If discovery, digest
|
||||
resolution or completeness cannot be established they stop with an error (keeping
|
||||
the last verified Dockerfile fallback pins); they never guess, fall back to a host
|
||||
runtime or install a stale pin.
|
||||
Without a Docker installation, `./install --opencode`/`--pi` stop and require an
|
||||
existing Docker setup; the native installation reuses the host OpenCode
|
||||
(`./install --opencode`/`--pi` were removed and only point to that command.) The native installation reuses the host OpenCode
|
||||
configuration, writes **host** (non-Docker) profiles for the harnesses it detects
|
||||
into XDG config home's `pipelines/harnesses.json`, and clears a stale Docker link
|
||||
so a Docker-era profile is not left Docker-linked. It never installs, upgrades or
|
||||
|
||||
@@ -51,7 +51,7 @@ parallel/distributed task engine or a guarantee that model reports are correct.
|
||||
source identity labels already match; a dirty source always invokes the Docker
|
||||
build and relies on layer caching. A model/login-only reconfiguration compares only
|
||||
the verified release image identity, so a changed source alone does not rebuild.
|
||||
`./install --opencode|--pi` reconfigures inside the existing container and
|
||||
`pipelines harness setup opencode|pi` reconfigures inside the existing container and
|
||||
refuses an image that does not match; it does not rebuild or restart services (an
|
||||
explicit ordinary `./install` does when the user asks).
|
||||
|
||||
|
||||
@@ -67,6 +67,30 @@ func (a *authEnv) resolve(ctx context.Context, binary string, base []string) []s
|
||||
return append(append([]string{}, base...), a.extra...)
|
||||
}
|
||||
|
||||
// SignedIn reports whether Claude Code started with env is signed in, trying
|
||||
// the same sources the server uses for the processes it starts: the default
|
||||
// login, then the login file in ConfigDir, then the private service token. The
|
||||
// second result names the source that worked.
|
||||
func SignedIn(ctx context.Context, binary string, env []string) (bool, string) {
|
||||
if cliLoggedIn(ctx, binary, env) {
|
||||
return true, "Claude Code login"
|
||||
}
|
||||
if dir := ConfigDir(); dir != "" && !hasEnv(env, secureStorageEnvKey) && !hasEnv(env, "CLAUDE_CONFIG_DIR") {
|
||||
if cliLoggedIn(ctx, binary, append(append([]string{}, env...), secureStorageEnvKey+"="+dir)) {
|
||||
return true, "login file in " + dir
|
||||
}
|
||||
}
|
||||
if HasServiceToken() && !hasEnv(env, "CLAUDE_CODE_OAUTH_TOKEN") {
|
||||
if cliLoggedIn(ctx, binary, withServiceToken(append([]string{}, env...))) {
|
||||
return true, "service token " + serviceTokenPath()
|
||||
}
|
||||
}
|
||||
return false, ""
|
||||
}
|
||||
|
||||
// ServiceTokenPath is the token file the server reads.
|
||||
func ServiceTokenPath() string { return serviceTokenPath() }
|
||||
|
||||
func hasEnv(env []string, key string) bool {
|
||||
for _, item := range env {
|
||||
if strings.HasPrefix(item, key+"=") {
|
||||
|
||||
@@ -20,6 +20,7 @@ import (
|
||||
"git.a-wan.net/alan/pipelines/internal/client"
|
||||
"git.a-wan.net/alan/pipelines/internal/draft"
|
||||
"git.a-wan.net/alan/pipelines/internal/harness"
|
||||
"git.a-wan.net/alan/pipelines/internal/installation"
|
||||
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
"git.a-wan.net/alan/pipelines/internal/runinspect"
|
||||
@@ -32,6 +33,9 @@ import (
|
||||
type App struct {
|
||||
Out, Err io.Writer
|
||||
In io.Reader
|
||||
// Install is the native installation manifest this CLI belongs to, or nil
|
||||
// (Docker installation, or a development/Go-installed CLI).
|
||||
Install *installation.Config
|
||||
}
|
||||
type options struct {
|
||||
outputFormat string
|
||||
|
||||
@@ -64,7 +64,7 @@ var notes = map[string]string{
|
||||
}
|
||||
|
||||
var serviceHelp = map[string]string{
|
||||
"harness": "pipelines harness launches the configured default. harness setup opencode|pi offers fuzzy model selection; --host configures a native host harness and clears any Docker link, --login reopens login, --default chooses the default harness, --model and --pipeline-model set separate defaults explicitly. harness list prints non-secret settings, including each profile's launch mode. Only configured harnesses are offered.",
|
||||
"harness": "pipelines harness launches the configured default (opencode or pi). harness setup <claude|codex|opencode|pi> is the one way to set up a harness on a native or Docker installation: it checks the CLI is installed where the server finds it (printing the install command when missing), signs in with the harness's own login when needed (--login forces it), picks OpenCode/Pi models with fuzzy selection (--model, --pipeline-model, --default), and verifies with the server's own check. harness list shows installed, signed-in, configured and default status for all four (--json adds the profiles).",
|
||||
"skill": "pipelines skill install installs/updates the bundled workflow skill in OpenCode and detected Claude Code skill roots without changing login/config or user-modified skills. ./install includes this step.",
|
||||
"service": "Configure per-user OS autostart: pipelines service enable. Runs use the directory you invoke pipelines run from. Use --print to preview, service status to inspect, and service disable before uninstalling. Linux uses systemd; macOS uses launchd. No sudo.",
|
||||
"serve": "Run the native server in the foreground. Its flags are documented by pipelines serve --help. Installation never starts it automatically.",
|
||||
|
||||
+2
-158
@@ -17,11 +17,7 @@ import (
|
||||
|
||||
func (a App) harness(ctx context.Context, args []string) error {
|
||||
if len(args) > 0 && args[0] == "list" {
|
||||
list, err := harness.List()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return a.output(list)
|
||||
return a.harnessList(ctx, args[1:])
|
||||
}
|
||||
if len(args) > 0 && args[0] == "default" {
|
||||
c, err := harness.Load()
|
||||
@@ -81,159 +77,7 @@ func (a App) harness(ctx context.Context, args []string) error {
|
||||
return harness.Save(c)
|
||||
}
|
||||
if len(args) > 0 && args[0] == "setup" {
|
||||
f := flag.NewFlagSet("harness setup", flag.ContinueOnError)
|
||||
f.SetOutput(a.Err)
|
||||
model := f.String("model", "", "Interactive harness default provider/model")
|
||||
pipelineModel := f.String("pipeline-model", "", "New pipeline stage default provider/model")
|
||||
executable := f.String("executable", "", "Harness executable (defaults to its name)")
|
||||
login := f.Bool("login", false, "Open the harness login without deleting credentials")
|
||||
makeDefault := f.Bool("default", false, "Use this harness by default")
|
||||
host := f.Bool("host", false, "Configure a native host harness and clear any Docker link")
|
||||
versions := f.String("versions", "", "Verified Docker harness versions to display (from the in-image probe)")
|
||||
if err := parse(f, args[1:]); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(f.Args()) > 1 {
|
||||
return fmt.Errorf("usage: pipelines harness setup [opencode|pi] [--login] [--host] [--model P/M] [--pipeline-model P/M] [--default]")
|
||||
}
|
||||
name := ""
|
||||
if len(f.Args()) == 1 {
|
||||
name = f.Args()[0]
|
||||
} else {
|
||||
var available []string
|
||||
for _, name := range []string{"opencode", "pi"} {
|
||||
if _, err := exec.LookPath(name); err == nil {
|
||||
available = append(available, name)
|
||||
}
|
||||
}
|
||||
var err error
|
||||
name, err = harness.Select(ctx, "Harness to configure", available, a.In, a.Err)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if name != "opencode" && name != "pi" {
|
||||
return fmt.Errorf("supported harnesses: opencode, pi")
|
||||
}
|
||||
if *executable == "" {
|
||||
*executable = name
|
||||
}
|
||||
if strings.ContainsRune(*executable, os.PathSeparator) {
|
||||
absolute, pathErr := filepath.Abs(*executable)
|
||||
if pathErr != nil {
|
||||
return pathErr
|
||||
}
|
||||
*executable = absolute
|
||||
}
|
||||
if _, err := exec.LookPath(*executable); err != nil {
|
||||
return fmt.Errorf("install %s before configuring it: %w", name, err)
|
||||
}
|
||||
c, err := harness.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
existing, exists := c.Profiles[name]
|
||||
// A profile can move between Docker and host. Without an explicit
|
||||
// --host selection a Docker-linked profile is only reconfigured when its
|
||||
// recorded installation is still verifiable; otherwise setup fails
|
||||
// naming the directory instead of saving a link that cannot launch.
|
||||
if !*host && exists && existing.DockerDirectory != "" {
|
||||
if err := harness.VerifyDockerLink(existing.DockerDirectory); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
onboarding := harness.NewOnboarding(a.Out)
|
||||
action := "Configure"
|
||||
if exists {
|
||||
action = "Reconfigure"
|
||||
}
|
||||
onboarding.Header(name, action)
|
||||
onboarding.Versions(*versions)
|
||||
if *login {
|
||||
switch name {
|
||||
case "opencode":
|
||||
warm, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
_, warmErr := exec.CommandContext(warm, *executable, "api", "get", "/api/integration").Output()
|
||||
cancel()
|
||||
if warmErr != nil {
|
||||
return fmt.Errorf("OpenCode provider discovery failed before login: %w", warmErr)
|
||||
}
|
||||
case "pi":
|
||||
onboarding.AuthHandoff()
|
||||
}
|
||||
// Pi has no standalone `auth login`: open a fresh, no-context,
|
||||
// extension-free, no-prompt, no-tools session and let the user run
|
||||
// /login there. `--tui-mode regular` is a documented Pi 1.1.0 flag
|
||||
// that keeps Pipelines' header/handoff visible above Pi's interface
|
||||
// instead of the default fullscreen clear. Never inject a coding/task
|
||||
// prompt or scripted keystrokes.
|
||||
loginArgs := []string{"auth", "login"}
|
||||
if name == "pi" {
|
||||
loginArgs = []string{"--tui-mode", "regular", "--no-extensions", "--no-skills", "--no-context-files", "--no-prompt-templates", "--no-tools"}
|
||||
}
|
||||
cmd := exec.CommandContext(ctx, *executable, loginArgs...)
|
||||
cmd.Stdin = a.In
|
||||
cmd.Stdout = a.Out
|
||||
cmd.Stderr = a.Err
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("%s login did not complete: %w", name, err)
|
||||
}
|
||||
}
|
||||
readCtx, cancel := context.WithTimeout(ctx, 60*time.Second)
|
||||
defer cancel()
|
||||
models, err := harnessModels(readCtx, name, *executable)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if *model == "" {
|
||||
*model, err = harness.Pick(ctx, harness.Selection{
|
||||
Step: "Step 1 of 2",
|
||||
Title: "Choose the interactive " + harness.DisplayName(name) + " model",
|
||||
Purpose: "Used when you open " + harness.DisplayName(name) + " for authoring and debugging sessions. It is stored separately from the new-pipeline-stage model.",
|
||||
Options: models,
|
||||
Current: c.Profiles[name].Model,
|
||||
}, a.In, a.Err)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if *pipelineModel == "" {
|
||||
*pipelineModel, err = harness.Pick(ctx, harness.Selection{
|
||||
Step: "Step 2 of 2",
|
||||
Title: "Choose the default model for new " + harness.DisplayName(name) + " pipelines",
|
||||
Purpose: "Used by model stages in new pipelines and starters. It never rewrites published workflows or existing drafts.",
|
||||
Options: models,
|
||||
Current: c.Profiles[name].PipelineModel,
|
||||
}, a.In, a.Err)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
available := func(value string) bool {
|
||||
for _, m := range models {
|
||||
if m == value {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
if !harness.ValidModel(*model) || !harness.ValidModel(*pipelineModel) || !available(*model) || !available(*pipelineModel) {
|
||||
return fmt.Errorf("choose exact model IDs from %s's available catalog; defaults unchanged", name)
|
||||
}
|
||||
profile := c.Profiles[name]
|
||||
profile.Executable, profile.Model, profile.PipelineModel = *executable, *model, *pipelineModel
|
||||
if *host {
|
||||
profile.DockerDirectory = ""
|
||||
}
|
||||
c.Profiles[name] = profile
|
||||
if *makeDefault || c.Default == "" {
|
||||
c.Default = name
|
||||
}
|
||||
if err = harness.Save(c); err != nil {
|
||||
return err
|
||||
}
|
||||
onboarding.Summary(name, *model, *pipelineModel, c.Default, c.Profiles[name].Mode())
|
||||
return nil
|
||||
return a.harnessSetup(ctx, args[1:])
|
||||
}
|
||||
name := ""
|
||||
if len(args) > 0 && (args[0] == "opencode" || args[0] == "pi") {
|
||||
|
||||
@@ -0,0 +1,618 @@
|
||||
package cli
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"text/tabwriter"
|
||||
"time"
|
||||
|
||||
"git.a-wan.net/alan/pipelines/internal/claude"
|
||||
"git.a-wan.net/alan/pipelines/internal/codex"
|
||||
"git.a-wan.net/alan/pipelines/internal/harness"
|
||||
)
|
||||
|
||||
// harnessNames is every harness `pipelines harness setup` and `list` handle.
|
||||
var harnessNames = []string{"claude", "codex", "opencode", "pi"}
|
||||
|
||||
const harnessSetupUsage = `Usage: pipelines harness setup <claude|codex|opencode|pi> [options]
|
||||
|
||||
Set up one agent harness for this Pipelines installation (native or Docker,
|
||||
detected from the installation). Steps:
|
||||
1. check the harness CLI is installed where the server finds it
|
||||
(prints the install command and stops when it is missing)
|
||||
2. sign in with the harness's own login when not signed in
|
||||
3. OpenCode/Pi: pick the interactive and new-pipeline default models
|
||||
(Claude Code and Codex models are chosen per chat in the app)
|
||||
4. verify with the server's own check and report whether a restart is needed
|
||||
|
||||
Options:
|
||||
--login sign in again even when already signed in
|
||||
--model P/M OpenCode/Pi interactive (authoring/debug) model
|
||||
--pipeline-model P/M OpenCode/Pi default model for new pipeline stages
|
||||
--default make this OpenCode/Pi harness the default for new/edit/debug
|
||||
--executable PATH OpenCode/Pi executable (default: found on the server's PATH)
|
||||
|
||||
See also: pipelines harness list
|
||||
`
|
||||
|
||||
// harnessFallbackDirs are per-user install locations a login service PATH may
|
||||
// lack; the server looks there too (see claude.BinaryPath and OpenCode
|
||||
// discovery). A variable so tests never find a real harness on this machine.
|
||||
var harnessFallbackDirs = func() []string {
|
||||
dirs := []string{"/opt/homebrew/bin", "/usr/local/bin", "/usr/bin"}
|
||||
if home, err := os.UserHomeDir(); err == nil {
|
||||
dirs = append([]string{filepath.Join(home, ".local", "bin")}, dirs...)
|
||||
}
|
||||
return dirs
|
||||
}
|
||||
|
||||
// harnessInstallCommand is the documented install command for each harness.
|
||||
func harnessInstallCommand(name string) string {
|
||||
switch name {
|
||||
case "opencode":
|
||||
return "curl -fsSL https://opencode.ai/install | bash"
|
||||
case "pi":
|
||||
return "npm install --global @earendil-works/pi-coding-agent"
|
||||
case "claude":
|
||||
return "curl -fsSL https://claude.ai/install.sh | bash"
|
||||
case "codex":
|
||||
return "npm install --global @openai/codex"
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// setupEnvironment is where the harness has to work: the server's PATH on a
|
||||
// native installation, or the Docker checkout that owns the container.
|
||||
type setupEnvironment struct {
|
||||
docker string // Docker installation checkout, "" for native
|
||||
path string // PATH the server runs with
|
||||
native bool // a native installation manifest was found
|
||||
}
|
||||
|
||||
func (a App) detectSetupEnvironment(host bool, c harness.Config) setupEnvironment {
|
||||
if a.Install != nil {
|
||||
path := a.Install.Path
|
||||
if path == "" {
|
||||
path = os.Getenv("PATH")
|
||||
}
|
||||
return setupEnvironment{path: path, native: true}
|
||||
}
|
||||
if !host && !inContainer() {
|
||||
for _, name := range []string{c.Default, "opencode", "pi"} {
|
||||
if p, ok := c.Profiles[name]; ok && dockerInstallation(p.DockerDirectory) {
|
||||
return setupEnvironment{docker: p.DockerDirectory}
|
||||
}
|
||||
}
|
||||
if wd, err := os.Getwd(); err == nil && dockerInstallation(wd) {
|
||||
return setupEnvironment{docker: wd}
|
||||
}
|
||||
}
|
||||
return setupEnvironment{path: os.Getenv("PATH")}
|
||||
}
|
||||
|
||||
// dockerInstallation reports a configured `./install --docker` checkout, the
|
||||
// same test scripts/setup-harness.py applies.
|
||||
func dockerInstallation(dir string) bool {
|
||||
if dir == "" {
|
||||
return false
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(dir, "compose.yaml")); err != nil {
|
||||
return false
|
||||
}
|
||||
data, err := os.ReadFile(filepath.Join(dir, ".env"))
|
||||
return err == nil && strings.Contains(string(data), "PIPELINES_HOST_REPOSITORY=")
|
||||
}
|
||||
|
||||
func inContainer() bool {
|
||||
_, err := os.Stat("/.dockerenv")
|
||||
return err == nil
|
||||
}
|
||||
|
||||
func executableFile(path string) bool {
|
||||
info, err := os.Stat(path)
|
||||
return err == nil && info.Mode().IsRegular() && info.Mode().Perm()&0111 != 0
|
||||
}
|
||||
|
||||
func lookPathIn(name, pathList string) string {
|
||||
if strings.ContainsRune(name, os.PathSeparator) {
|
||||
if absolute, err := filepath.Abs(name); err == nil && executableFile(absolute) {
|
||||
return absolute
|
||||
}
|
||||
return ""
|
||||
}
|
||||
for _, dir := range filepath.SplitList(pathList) {
|
||||
if dir == "" {
|
||||
continue
|
||||
}
|
||||
if candidate := filepath.Join(dir, name); executableFile(candidate) {
|
||||
return candidate
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// findHarness resolves a harness executable the way the server would: its
|
||||
// override variable, the configured profile, the server's PATH, then the
|
||||
// per-user install locations.
|
||||
func findHarness(name string, env setupEnvironment, profile harness.Profile) string {
|
||||
var candidates []string
|
||||
switch name {
|
||||
case "claude":
|
||||
candidates = append(candidates, strings.TrimSpace(os.Getenv("PIPELINES_CLAUDE")))
|
||||
case "opencode":
|
||||
candidates = append(candidates, strings.TrimSpace(os.Getenv("PIPELINES_OPENCODE")))
|
||||
}
|
||||
if profile.DockerDirectory == "" {
|
||||
candidates = append(candidates, profile.Executable)
|
||||
}
|
||||
for _, candidate := range candidates {
|
||||
if candidate == "" {
|
||||
continue
|
||||
}
|
||||
if path := lookPathIn(candidate, env.path); path != "" {
|
||||
return path
|
||||
}
|
||||
}
|
||||
if path := lookPathIn(name, env.path); path != "" {
|
||||
return path
|
||||
}
|
||||
return lookPathIn(name, strings.Join(harnessFallbackDirs(), string(os.PathListSeparator)))
|
||||
}
|
||||
|
||||
// missingHarness is the clear stop when a harness CLI cannot be found.
|
||||
func missingHarness(name string, env setupEnvironment) error {
|
||||
display := harness.DisplayName(name)
|
||||
if shell, err := exec.LookPath(name); err == nil && env.path != os.Getenv("PATH") {
|
||||
return fmt.Errorf("%s is on this shell's PATH (%s) but not on the PATH the Pipelines server runs with.\nRerun ./install from this shell so the server records it, then rerun: pipelines harness setup %s", display, shell, name)
|
||||
}
|
||||
return fmt.Errorf("%s is not installed where the Pipelines server can find it.\nInstall it: %s\nThen rerun: pipelines harness setup %s", display, harnessInstallCommand(name), name)
|
||||
}
|
||||
|
||||
// serviceEnviron is this process's environment with the server's PATH.
|
||||
func serviceEnviron(path string) []string {
|
||||
var env []string
|
||||
for _, item := range os.Environ() {
|
||||
if !strings.HasPrefix(item, "PATH=") {
|
||||
env = append(env, item)
|
||||
}
|
||||
}
|
||||
return append(env, "PATH="+path)
|
||||
}
|
||||
|
||||
func (a App) interactive(ctx context.Context, env []string, executable string, args ...string) error {
|
||||
cmd := exec.CommandContext(ctx, executable, args...)
|
||||
cmd.Env = env
|
||||
cmd.Stdin, cmd.Stdout, cmd.Stderr = a.In, a.Out, a.Err
|
||||
return cmd.Run()
|
||||
}
|
||||
|
||||
func codexSignedIn(ctx context.Context, executable string, env []string) bool {
|
||||
ctx, cancel := context.WithTimeout(ctx, 20*time.Second)
|
||||
defer cancel()
|
||||
cmd := exec.CommandContext(ctx, executable, "login", "status")
|
||||
cmd.Env = env
|
||||
return cmd.Run() == nil
|
||||
}
|
||||
|
||||
func (a App) harnessSetup(ctx context.Context, args []string) error {
|
||||
f := flag.NewFlagSet("harness setup", flag.ContinueOnError)
|
||||
f.SetOutput(a.Err)
|
||||
f.Usage = func() { fmt.Fprint(a.Out, harnessSetupUsage) }
|
||||
model := f.String("model", "", "")
|
||||
pipelineModel := f.String("pipeline-model", "", "")
|
||||
executable := f.String("executable", "", "")
|
||||
login := f.Bool("login", false, "")
|
||||
makeDefault := f.Bool("default", false, "")
|
||||
// --host is a hidden compatibility alias: it forces the native host mode a
|
||||
// native installation selects anyway. --versions is passed by the Docker
|
||||
// installer from its in-image probe.
|
||||
host := f.Bool("host", false, "")
|
||||
versions := f.String("versions", "", "")
|
||||
if err := parse(f, args); err != nil {
|
||||
if errors.Is(err, flag.ErrHelp) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
if len(f.Args()) > 1 {
|
||||
return fmt.Errorf("usage: pipelines harness setup <claude|codex|opencode|pi> [--login] [--model P/M] [--pipeline-model P/M] [--default]")
|
||||
}
|
||||
name := ""
|
||||
if len(f.Args()) == 1 {
|
||||
name = f.Args()[0]
|
||||
} else {
|
||||
var err error
|
||||
if name, err = harness.Select(ctx, "Harness to set up", harnessNames, a.In, a.Err); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
known := false
|
||||
for _, n := range harnessNames {
|
||||
known = known || n == name
|
||||
}
|
||||
if !known {
|
||||
return fmt.Errorf("unknown harness %q; supported harnesses: claude, codex, opencode, pi", name)
|
||||
}
|
||||
chat := name == "claude" || name == "codex"
|
||||
if chat && (*model != "" || *pipelineModel != "" || *makeDefault || *executable != "") {
|
||||
return fmt.Errorf("--model, --pipeline-model, --default and --executable apply to opencode and pi; %s models are chosen per chat in the app", harness.DisplayName(name))
|
||||
}
|
||||
c, err := harness.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
env := a.detectSetupEnvironment(*host, c)
|
||||
if env.docker != "" {
|
||||
if chat {
|
||||
return fmt.Errorf("%s chat needs a native installation; this is a Docker installation (%s), which runs OpenCode and Pi only", harness.DisplayName(name), env.docker)
|
||||
}
|
||||
forward := []string{name}
|
||||
if *login {
|
||||
forward = append(forward, "--login")
|
||||
}
|
||||
if *model != "" {
|
||||
forward = append(forward, "--model", *model)
|
||||
}
|
||||
if *pipelineModel != "" {
|
||||
forward = append(forward, "--pipeline-model", *pipelineModel)
|
||||
}
|
||||
if *makeDefault {
|
||||
forward = append(forward, "--default")
|
||||
}
|
||||
python, err := exec.LookPath("python3")
|
||||
if err != nil {
|
||||
return fmt.Errorf("Python 3 is required to set up a harness in the Docker installation: %w", err)
|
||||
}
|
||||
fmt.Fprintf(a.Out, "Docker installation (%s): setting up %s inside the container.\n", env.docker, harness.DisplayName(name))
|
||||
cmd := exec.CommandContext(ctx, python, append([]string{filepath.Join(env.docker, "scripts", "setup-harness.py")}, forward...)...)
|
||||
cmd.Dir = env.docker
|
||||
cmd.Stdin, cmd.Stdout, cmd.Stderr = a.In, a.Out, a.Err
|
||||
return cmd.Run()
|
||||
}
|
||||
switch name {
|
||||
case "claude":
|
||||
return a.setupClaude(ctx, env, *login)
|
||||
case "codex":
|
||||
return a.setupCodex(ctx, env, *login)
|
||||
}
|
||||
return a.setupProfileHarness(ctx, name, env, c, profileSetup{
|
||||
model: *model, pipelineModel: *pipelineModel, executable: *executable,
|
||||
login: *login, makeDefault: *makeDefault, host: *host, versions: *versions,
|
||||
})
|
||||
}
|
||||
|
||||
func (a App) setupClaude(ctx context.Context, env setupEnvironment, login bool) error {
|
||||
binary := findHarness("claude", env, harness.Profile{})
|
||||
if binary == "" {
|
||||
return missingHarness("claude", env)
|
||||
}
|
||||
fmt.Fprintf(a.Out, "Claude Code: %s\n", binary)
|
||||
environ := serviceEnviron(env.path)
|
||||
signed, how := claude.SignedIn(ctx, binary, environ)
|
||||
if signed && !login {
|
||||
fmt.Fprintf(a.Out, "Signed in (%s); skipping login. Use --login to sign in again.\n", how)
|
||||
} else {
|
||||
fmt.Fprintln(a.Out, "Opening the Claude Code sign-in (claude auth login).")
|
||||
if err := a.interactive(ctx, environ, binary, "auth", "login"); err != nil {
|
||||
return fmt.Errorf("Claude Code login did not complete: %w", err)
|
||||
}
|
||||
signed, how = claude.SignedIn(ctx, binary, environ)
|
||||
}
|
||||
if !signed {
|
||||
return fmt.Errorf("Claude Code is still not signed in for the server. For a login that does not depend on the keychain, run `claude setup-token` and save the token as an owner-only file at %s (install -m 600 /dev/null %s), then rerun: pipelines harness setup claude", claude.ServiceTokenPath(), claude.ServiceTokenPath())
|
||||
}
|
||||
fmt.Fprintln(a.Out, "Models: chosen per chat in the app's model picker; nothing to set here.")
|
||||
fmt.Fprintf(a.Out, "Verified: Claude Code is signed in (%s), using the server's own `claude auth status` check.\n", how)
|
||||
fmt.Fprintln(a.Out, "Server: the running server looks for Claude Code every 10 s; no restart needed.")
|
||||
return nil
|
||||
}
|
||||
|
||||
func (a App) setupCodex(ctx context.Context, env setupEnvironment, login bool) error {
|
||||
socket := codex.DefaultSocketPath()
|
||||
binary := findHarness("codex", env, harness.Profile{})
|
||||
if binary == "" {
|
||||
if codex.Available() {
|
||||
fmt.Fprintf(a.Out, "Codex CLI not found, but the Codex App Server is running (%s); its sign-in is managed by the Codex app.\n", socket)
|
||||
fmt.Fprintln(a.Out, "Server: the running server attaches to that socket within 10 s; no restart needed.")
|
||||
return nil
|
||||
}
|
||||
return missingHarness("codex", env)
|
||||
}
|
||||
fmt.Fprintf(a.Out, "Codex: %s\n", binary)
|
||||
environ := serviceEnviron(env.path)
|
||||
signed := codexSignedIn(ctx, binary, environ)
|
||||
if signed && !login {
|
||||
fmt.Fprintln(a.Out, "Signed in (codex login status); skipping login. Use --login to sign in again.")
|
||||
} else {
|
||||
fmt.Fprintln(a.Out, "Opening the Codex sign-in (codex login).")
|
||||
if err := a.interactive(ctx, environ, binary, "login"); err != nil {
|
||||
return fmt.Errorf("Codex login did not complete: %w", err)
|
||||
}
|
||||
signed = codexSignedIn(ctx, binary, environ)
|
||||
}
|
||||
if !signed {
|
||||
return fmt.Errorf("Codex is still not signed in (codex login status); run `codex login` and rerun: pipelines harness setup codex")
|
||||
}
|
||||
fmt.Fprintln(a.Out, "Models: chosen per chat in the app's model picker; nothing to set here.")
|
||||
if !codex.Available() {
|
||||
return fmt.Errorf("Codex is signed in, but its App Server control socket %s does not exist. Open the Codex app (it provides the socket); the running server checks every 10 s and attaches without a restart", socket)
|
||||
}
|
||||
fmt.Fprintf(a.Out, "Verified: Codex App Server socket %s is present (the server's own check).\n", socket)
|
||||
fmt.Fprintln(a.Out, "Server: the running server re-checks Codex every 10 s; no restart needed.")
|
||||
return nil
|
||||
}
|
||||
|
||||
type profileSetup struct {
|
||||
model, pipelineModel, executable, versions string
|
||||
login, makeDefault, host bool
|
||||
}
|
||||
|
||||
// profileLogin runs the harness's own sign-in. Pi has no standalone `auth
|
||||
// login`: open a fresh, no-context, extension-free, no-prompt, no-tools session
|
||||
// and let the user run /login there. `--tui-mode regular` keeps Pipelines'
|
||||
// header/handoff visible above Pi's interface. Never inject a coding/task
|
||||
// prompt or scripted keystrokes.
|
||||
func (a App) profileLogin(ctx context.Context, name, executable string, onboarding harness.Onboarding) error {
|
||||
loginArgs := []string{"auth", "login"}
|
||||
switch name {
|
||||
case "opencode":
|
||||
warm, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
_, warmErr := exec.CommandContext(warm, executable, "api", "get", "/api/integration").Output()
|
||||
cancel()
|
||||
if warmErr != nil {
|
||||
return fmt.Errorf("OpenCode provider discovery failed before login: %w", warmErr)
|
||||
}
|
||||
case "pi":
|
||||
onboarding.AuthHandoff()
|
||||
loginArgs = []string{"--tui-mode", "regular", "--no-extensions", "--no-skills", "--no-context-files", "--no-prompt-templates", "--no-tools"}
|
||||
}
|
||||
cmd := exec.CommandContext(ctx, executable, loginArgs...)
|
||||
cmd.Stdin, cmd.Stdout, cmd.Stderr = a.In, a.Out, a.Err
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("%s login did not complete: %w", name, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (a App) setupProfileHarness(ctx context.Context, name string, env setupEnvironment, c harness.Config, o profileSetup) error {
|
||||
existing, exists := c.Profiles[name]
|
||||
executable := ""
|
||||
if o.executable != "" {
|
||||
if executable = lookPathIn(o.executable, env.path); executable == "" {
|
||||
if path, err := exec.LookPath(o.executable); err == nil {
|
||||
executable, _ = filepath.Abs(path)
|
||||
}
|
||||
}
|
||||
if executable == "" {
|
||||
return fmt.Errorf("%s executable %s was not found", harness.DisplayName(name), o.executable)
|
||||
}
|
||||
} else if executable = findHarness(name, env, existing); executable == "" {
|
||||
return missingHarness(name, env)
|
||||
}
|
||||
// A Docker-linked profile is only reconfigured on the host when its
|
||||
// recorded installation is still verifiable; a native installation or
|
||||
// --host replaces the link with the host profile instead.
|
||||
native := o.host || env.native
|
||||
if !native && exists && existing.DockerDirectory != "" {
|
||||
if err := harness.VerifyDockerLink(existing.DockerDirectory); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
onboarding := harness.NewOnboarding(a.Out)
|
||||
action := "Configure"
|
||||
if exists {
|
||||
action = "Reconfigure"
|
||||
}
|
||||
onboarding.Header(name, action)
|
||||
onboarding.Versions(o.versions)
|
||||
fmt.Fprintf(a.Out, "%s: %s\n", harness.DisplayName(name), executable)
|
||||
readCtx, cancel := context.WithTimeout(ctx, 60*time.Second)
|
||||
defer cancel()
|
||||
models, err := harnessModels(readCtx, name, executable)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
loggedIn := false
|
||||
if o.login || len(models) == 0 {
|
||||
if !o.login {
|
||||
fmt.Fprintf(a.Out, "No signed-in %s provider lists any models; opening the %s sign-in.\n", harness.DisplayName(name), harness.DisplayName(name))
|
||||
}
|
||||
if err := a.profileLogin(ctx, name, executable, onboarding); err != nil {
|
||||
return err
|
||||
}
|
||||
loggedIn = true
|
||||
if models, err = harnessModels(readCtx, name, executable); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(models) == 0 {
|
||||
return fmt.Errorf("%s still lists no models from a signed-in provider; sign in with `pipelines harness setup %s --login`", harness.DisplayName(name), name)
|
||||
}
|
||||
} else {
|
||||
fmt.Fprintf(a.Out, "Signed in (%d models available); skipping login. Use --login to sign in again.\n", len(models))
|
||||
}
|
||||
model, pipelineModel := o.model, o.pipelineModel
|
||||
if model == "" {
|
||||
model, err = harness.Pick(ctx, harness.Selection{
|
||||
Step: "Step 1 of 2",
|
||||
Title: "Choose the interactive " + harness.DisplayName(name) + " model",
|
||||
Purpose: "Used when you open " + harness.DisplayName(name) + " for authoring and debugging sessions. It is stored separately from the new-pipeline-stage model.",
|
||||
Options: models,
|
||||
Current: existing.Model,
|
||||
}, a.In, a.Err)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if pipelineModel == "" {
|
||||
pipelineModel, err = harness.Pick(ctx, harness.Selection{
|
||||
Step: "Step 2 of 2",
|
||||
Title: "Choose the default model for new " + harness.DisplayName(name) + " pipelines",
|
||||
Purpose: "Used by model stages in new pipelines and starters. It never rewrites published workflows or existing drafts.",
|
||||
Options: models,
|
||||
Current: existing.PipelineModel,
|
||||
}, a.In, a.Err)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
available := func(value string) bool {
|
||||
for _, m := range models {
|
||||
if m == value {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
if !harness.ValidModel(model) || !harness.ValidModel(pipelineModel) || !available(model) || !available(pipelineModel) {
|
||||
return fmt.Errorf("choose exact model IDs from %s's available catalog; defaults unchanged", name)
|
||||
}
|
||||
profile := existing
|
||||
profile.Executable, profile.Model, profile.PipelineModel = executable, model, pipelineModel
|
||||
if native {
|
||||
profile.DockerDirectory = ""
|
||||
}
|
||||
c.Profiles[name] = profile
|
||||
if o.makeDefault || c.Default == "" {
|
||||
c.Default = name
|
||||
}
|
||||
if err = harness.Save(c); err != nil {
|
||||
return err
|
||||
}
|
||||
onboarding.Summary(name, model, pipelineModel, c.Default, c.Profiles[name].Mode())
|
||||
check := "pipelines provider-check --model " + pipelineModel
|
||||
if name == "pi" {
|
||||
check = "pipelines provider-check --harness pi --model " + pipelineModel
|
||||
}
|
||||
fmt.Fprintf(a.Out, "Verified: %s lists both models from a signed-in provider (live check, may cost: %s).\n", harness.DisplayName(name), check)
|
||||
fmt.Fprintln(a.Out, "Server: new runs and sessions read these profiles when they start; no restart needed.")
|
||||
if loggedIn && name == "opencode" && env.native {
|
||||
fmt.Fprintln(a.Out, "If the app's OpenCode chat does not offer the newly signed-in provider, run `pipelines restart` when no runs are active.")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// harnessStatus is one row of `pipelines harness list`.
|
||||
type harnessStatus struct {
|
||||
Name string `json:"name"`
|
||||
Installed bool `json:"installed"`
|
||||
Executable string `json:"executable,omitempty"`
|
||||
SignedIn bool `json:"signed_in"`
|
||||
Configured bool `json:"configured"`
|
||||
Default bool `json:"default"`
|
||||
Detail string `json:"detail"`
|
||||
Docker bool `json:"docker,omitempty"`
|
||||
}
|
||||
|
||||
func harnessStatuses(ctx context.Context, env setupEnvironment, c harness.Config) []harnessStatus {
|
||||
var rows []harnessStatus
|
||||
for _, name := range harnessNames {
|
||||
profile, configured := c.Profiles[name]
|
||||
row := harnessStatus{Name: name, Default: c.Default == name}
|
||||
if configured && profile.DockerDirectory != "" {
|
||||
row.Installed, row.SignedIn, row.Configured, row.Docker = true, true, true, true
|
||||
row.Detail = "model " + profile.Model + " · new pipelines " + profile.PipelineModel + " · " + profile.Mode()
|
||||
rows = append(rows, row)
|
||||
continue
|
||||
}
|
||||
row.Executable = findHarness(name, env, profile)
|
||||
row.Installed = row.Executable != ""
|
||||
check, cancel := context.WithTimeout(ctx, 20*time.Second)
|
||||
environ := serviceEnviron(env.path)
|
||||
switch name {
|
||||
case "claude":
|
||||
if row.Installed {
|
||||
row.SignedIn, _ = claude.SignedIn(check, row.Executable, environ)
|
||||
}
|
||||
row.Configured = row.SignedIn
|
||||
row.Detail = "chat; models chosen per chat"
|
||||
case "codex":
|
||||
if row.Installed {
|
||||
row.SignedIn = codexSignedIn(check, row.Executable, environ)
|
||||
}
|
||||
row.Configured = codex.Available()
|
||||
if row.Configured {
|
||||
row.SignedIn = true
|
||||
row.Detail = "chat; Codex App Server attached"
|
||||
} else {
|
||||
row.Detail = "chat; open the Codex app (no App Server socket)"
|
||||
}
|
||||
default:
|
||||
if row.Installed {
|
||||
models, err := harnessModels(check, name, row.Executable)
|
||||
row.SignedIn = err == nil && len(models) > 0
|
||||
}
|
||||
row.Configured = configured
|
||||
if configured {
|
||||
row.Detail = "model " + profile.Model + " · new pipelines " + profile.PipelineModel
|
||||
} else {
|
||||
row.Detail = "stages; no models chosen"
|
||||
}
|
||||
}
|
||||
cancel()
|
||||
if env.docker != "" && (name == "claude" || name == "codex") {
|
||||
row.Configured = false
|
||||
row.Detail = "not used by a Docker installation"
|
||||
}
|
||||
rows = append(rows, row)
|
||||
}
|
||||
return rows
|
||||
}
|
||||
|
||||
func (a App) harnessList(ctx context.Context, args []string) error {
|
||||
f := flag.NewFlagSet("harness list", flag.ContinueOnError)
|
||||
f.SetOutput(a.Err)
|
||||
asJSON := f.Bool("json", false, "Print profiles and status as JSON")
|
||||
if err := parse(f, args); err != nil {
|
||||
if errors.Is(err, flag.ErrHelp) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
view, err := harness.List()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
c, err := harness.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rows := harnessStatuses(ctx, a.detectSetupEnvironment(false, c), c)
|
||||
if *asJSON {
|
||||
return a.output(struct {
|
||||
harness.ListView
|
||||
Harnesses []harnessStatus `json:"harnesses"`
|
||||
}{view, rows})
|
||||
}
|
||||
yes := func(v bool) string {
|
||||
if v {
|
||||
return "yes"
|
||||
}
|
||||
return "no"
|
||||
}
|
||||
w := tabwriter.NewWriter(a.Out, 0, 4, 2, ' ', 0)
|
||||
fmt.Fprintln(w, "HARNESS\tINSTALLED\tSIGNED IN\tCONFIGURED\tDEFAULT\tDETAIL")
|
||||
for _, row := range rows {
|
||||
installed, signed := yes(row.Installed), yes(row.SignedIn)
|
||||
if row.Docker {
|
||||
installed, signed = "in Docker", "in Docker"
|
||||
} else if !row.Installed {
|
||||
signed = "-"
|
||||
}
|
||||
def := "-"
|
||||
if row.Default {
|
||||
def = "yes"
|
||||
}
|
||||
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n", row.Name, installed, signed, yes(row.Configured), def, row.Detail)
|
||||
}
|
||||
if err := w.Flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Fprintln(a.Out, "\nSet one up: pipelines harness setup <claude|codex|opencode|pi>")
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
package cli
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.a-wan.net/alan/pipelines/internal/installation"
|
||||
)
|
||||
|
||||
// isolateHarnesses gives a test an empty PATH directory of fake harnesses and
|
||||
// a private HOME, so no real harness, login, config or socket is reachable.
|
||||
func isolateHarnesses(t *testing.T) (root, bin string) {
|
||||
t.Helper()
|
||||
root = t.TempDir()
|
||||
bin = filepath.Join(root, "bin")
|
||||
if err := os.Mkdir(bin, 0700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Setenv("HOME", root)
|
||||
t.Setenv("PATH", bin)
|
||||
t.Setenv("FIXTURE", root)
|
||||
t.Setenv("PIPELINES_HARNESS_CONFIG", filepath.Join(root, "harnesses.json"))
|
||||
t.Setenv("PIPELINES_CLAUDE", "")
|
||||
t.Setenv("PIPELINES_OPENCODE", "")
|
||||
t.Setenv("PIPELINES_CLAUDE_TOKEN_FILE", filepath.Join(root, "no-token"))
|
||||
t.Setenv("CLAUDE_CONFIG_DIR", filepath.Join(root, ".claude"))
|
||||
t.Setenv("CODEX_HOME", filepath.Join(root, "codex"))
|
||||
previous := harnessFallbackDirs
|
||||
harnessFallbackDirs = func() []string { return nil }
|
||||
t.Cleanup(func() { harnessFallbackDirs = previous })
|
||||
return root, bin
|
||||
}
|
||||
|
||||
func fakeHarness(t *testing.T, bin, name, body string) string {
|
||||
t.Helper()
|
||||
path := filepath.Join(bin, name)
|
||||
if err := os.WriteFile(path, []byte("#!/bin/sh\n"+body), 0700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return path
|
||||
}
|
||||
|
||||
func runHarness(t *testing.T, app App, args ...string) (string, error) {
|
||||
t.Helper()
|
||||
var out bytes.Buffer
|
||||
app.In, app.Out, app.Err = bytes.NewBuffer(nil), &out, &out
|
||||
err := app.Run(context.Background(), append([]string{"harness"}, args...))
|
||||
return out.String(), err
|
||||
}
|
||||
|
||||
func TestHarnessSetupMissingCLIPrintsInstallCommand(t *testing.T) {
|
||||
isolateHarnesses(t)
|
||||
for _, name := range harnessNames {
|
||||
_, err := runHarness(t, App{}, "setup", name)
|
||||
if err == nil || !strings.Contains(err.Error(), harnessInstallCommand(name)) || !strings.Contains(err.Error(), "pipelines harness setup "+name) {
|
||||
t.Fatalf("%s: missing CLI error = %v", name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestHarnessSetupUsesTheServerPath(t *testing.T) {
|
||||
root, bin := isolateHarnesses(t)
|
||||
fakeHarness(t, bin, "claude", "echo '{\"loggedIn\":true}'\n")
|
||||
servicePath := filepath.Join(root, "service-bin")
|
||||
_, err := runHarness(t, App{Install: &installation.Config{Path: servicePath}}, "setup", "claude")
|
||||
if err == nil || !strings.Contains(err.Error(), "not on the PATH the Pipelines server runs with") {
|
||||
t.Fatalf("shell-only claude error = %v", err)
|
||||
}
|
||||
if _, err := runHarness(t, App{Install: &installation.Config{Path: bin}}, "setup", "claude"); err != nil {
|
||||
t.Fatalf("claude on the server PATH: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHarnessSetupClaudeSignedInSkipsLogin(t *testing.T) {
|
||||
root, bin := isolateHarnesses(t)
|
||||
fakeHarness(t, bin, "claude", "case \"$*\" in\n'auth status') echo '{\"loggedIn\":true}' ;;\n*) echo \"$*\" >> \"$FIXTURE/claude-calls\"; exit 1 ;;\nesac\n")
|
||||
out, err := runHarness(t, App{}, "setup", "claude")
|
||||
if err != nil {
|
||||
t.Fatal(err, out)
|
||||
}
|
||||
for _, want := range []string{"skipping login", "Verified: Claude Code is signed in", "every 10 s; no restart needed"} {
|
||||
if !strings.Contains(out, want) {
|
||||
t.Fatalf("missing %q:\n%s", want, out)
|
||||
}
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(root, "claude-calls")); !os.IsNotExist(err) {
|
||||
t.Fatal("a signed-in Claude Code was asked to log in")
|
||||
}
|
||||
if _, err := runHarness(t, App{}, "setup", "claude", "--model", "a/b"); err == nil {
|
||||
t.Fatal("--model accepted for Claude Code")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHarnessSetupClaudeRunsLoginWhenSignedOut(t *testing.T) {
|
||||
root, bin := isolateHarnesses(t)
|
||||
fakeHarness(t, bin, "claude", "case \"$*\" in\n'auth status') if [ -f \"$FIXTURE/logged\" ]; then echo '{\"loggedIn\":true}'; else echo '{\"loggedIn\":false}'; exit 1; fi ;;\n'auth login') : > \"$FIXTURE/logged\" ;;\n*) exit 91 ;;\nesac\n")
|
||||
out, err := runHarness(t, App{}, "setup", "claude")
|
||||
if err != nil {
|
||||
t.Fatal(err, out)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(root, "logged")); err != nil || !strings.Contains(out, "claude auth login") || !strings.Contains(out, "Verified") {
|
||||
t.Fatalf("login not invoked:\n%s", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHarnessSetupCodexLoginAndSocket(t *testing.T) {
|
||||
root, bin := isolateHarnesses(t)
|
||||
fakeHarness(t, bin, "codex", "case \"$*\" in\n'login status') [ -f \"$FIXTURE/logged\" ] ;;\nlogin) : > \"$FIXTURE/logged\" ;;\n*) exit 91 ;;\nesac\n")
|
||||
out, err := runHarness(t, App{}, "setup", "codex")
|
||||
if _, statErr := os.Stat(filepath.Join(root, "logged")); statErr != nil || !strings.Contains(out, "codex login") {
|
||||
t.Fatalf("codex login not invoked:\n%s", out)
|
||||
}
|
||||
if err == nil || !strings.Contains(err.Error(), "app-server-control.sock") || !strings.Contains(err.Error(), "Open the Codex app") {
|
||||
t.Fatalf("missing socket error = %v", err)
|
||||
}
|
||||
// Unix socket paths are length-limited; keep CODEX_HOME short.
|
||||
home, err := os.MkdirTemp("/tmp", "cx")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { os.RemoveAll(home) })
|
||||
t.Setenv("CODEX_HOME", home)
|
||||
if err := os.Mkdir(filepath.Join(home, "app-server-control"), 0700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
listener, err := net.Listen("unix", filepath.Join(home, "app-server-control", "app-server-control.sock"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer listener.Close()
|
||||
out, err = runHarness(t, App{}, "setup", "codex")
|
||||
if err != nil || !strings.Contains(out, "skipping login") || !strings.Contains(out, "socket") || !strings.Contains(out, "no restart needed") {
|
||||
t.Fatalf("codex with socket: %v\n%s", err, out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHarnessSetupOpenCodeLogsInWhenNoProviderIsConnected(t *testing.T) {
|
||||
root, bin := isolateHarnesses(t)
|
||||
fakeHarness(t, bin, "opencode", "case \"$*\" in\n'api get /api/integration') echo '{}' ;;\nmodels) printf '%s\\n' fixture/harness fixture/stages ;;\n'auth list --format json') if [ -f \"$FIXTURE/logged\" ]; then echo '[{\"id\":\"fixture\",\"connections\":[{}]}]'; else echo '[]'; fi ;;\n'auth login') : > \"$FIXTURE/logged\" ;;\n*) exit 91 ;;\nesac\n")
|
||||
out, err := runHarness(t, App{}, "setup", "opencode", "--model", "fixture/harness", "--pipeline-model", "fixture/stages")
|
||||
if err != nil {
|
||||
t.Fatal(err, out)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(root, "logged")); err != nil {
|
||||
t.Fatalf("OpenCode login not invoked:\n%s", out)
|
||||
}
|
||||
for _, want := range []string{"opening the OpenCode sign-in", "Configuration complete", "Verified: OpenCode lists both models", "no restart needed"} {
|
||||
if !strings.Contains(out, want) {
|
||||
t.Fatalf("missing %q:\n%s", want, out)
|
||||
}
|
||||
}
|
||||
// Signed in now: a second setup skips the login.
|
||||
out, err = runHarness(t, App{}, "setup", "opencode", "--model", "fixture/harness", "--pipeline-model", "fixture/stages")
|
||||
if err != nil || !strings.Contains(out, "skipping login") {
|
||||
t.Fatalf("signed-in OpenCode: %v\n%s", err, out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHarnessListShowsAllFour(t *testing.T) {
|
||||
root, bin := isolateHarnesses(t)
|
||||
fakeHarness(t, bin, "claude", "echo '{\"loggedIn\":true}'\n")
|
||||
opencode := fakeHarness(t, bin, "opencode", "case \"$*\" in\n'api get /api/integration') echo '{}' ;;\nmodels) printf '%s\\n' fixture/harness fixture/stages ;;\n'auth list --format json') echo '[{\"id\":\"fixture\",\"connections\":[{}]}]' ;;\n*) exit 91 ;;\nesac\n")
|
||||
writeHarnessConfig(t, filepath.Join(root, "harnesses.json"), `{"default":"opencode","profiles":{"opencode":{"executable":"`+opencode+`","model":"fixture/harness","pipeline_model":"fixture/stages"}}}`)
|
||||
out, err := runHarness(t, App{}, "list")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
lines := map[string]string{}
|
||||
for _, line := range strings.Split(out, "\n") {
|
||||
if fields := strings.Fields(line); len(fields) > 0 {
|
||||
lines[fields[0]] = strings.Join(fields, " ")
|
||||
}
|
||||
}
|
||||
for name, want := range map[string]string{
|
||||
"claude": "claude yes yes yes -",
|
||||
"codex": "codex no - no -",
|
||||
"opencode": "opencode yes yes yes yes model fixture/harness",
|
||||
"pi": "pi no - no -",
|
||||
} {
|
||||
if !strings.HasPrefix(lines[name], want) {
|
||||
t.Fatalf("%s row = %q, want prefix %q\n%s", name, lines[name], want, out)
|
||||
}
|
||||
}
|
||||
out, err = runHarness(t, App{}, "list", "--json")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var view struct {
|
||||
Default string `json:"default"`
|
||||
Harnesses []harnessStatus `json:"harnesses"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(out), &view); err != nil || view.Default != "opencode" || len(view.Harnesses) != 4 {
|
||||
t.Fatalf("list --json = %v\n%s", err, out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHarnessSetupHelpHidesCompatibilityFlags(t *testing.T) {
|
||||
isolateHarnesses(t)
|
||||
out, err := runHarness(t, App{}, "setup", "--help")
|
||||
if err != nil || !strings.Contains(out, "pipelines harness setup <claude|codex|opencode|pi>") || strings.Contains(out, "--host") || strings.Contains(out, "--versions") {
|
||||
t.Fatalf("help: %v\n%s", err, out)
|
||||
}
|
||||
}
|
||||
@@ -47,7 +47,9 @@ MAINTAIN
|
||||
|
||||
SERVER / INTERFACE
|
||||
harness [opencode|pi] Launch the configured default harness in this directory
|
||||
harness setup opencode|pi Login/select separate harness and new-pipeline defaults
|
||||
harness setup <claude|codex|opencode|pi>
|
||||
Install check, sign-in, models and verify for one harness
|
||||
harness list Installed / signed-in / configured / default for all four
|
||||
tui Open the dashboard (default with no command)
|
||||
serve Start native server in the foreground (Ctrl+C stops it)
|
||||
service enable Configure user autostart
|
||||
|
||||
@@ -54,10 +54,10 @@ func (p Profile) Mode() string {
|
||||
// is reconfigured or reported as usable, so a stale link is never silently kept.
|
||||
func VerifyDockerLink(directory string) error {
|
||||
if directory == "" {
|
||||
return fmt.Errorf("no Docker installation directory is recorded; run pipelines harness setup <opencode|pi> --host for a native harness")
|
||||
return fmt.Errorf("no Docker installation directory is recorded; run pipelines harness setup <opencode|pi> on the native installation")
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(directory, "compose.yaml")); err != nil {
|
||||
return fmt.Errorf("recorded Docker installation %s is no longer usable: %w; relink with pipelines harness link <opencode|pi> --docker-directory <checkout>, or switch to a host harness with pipelines harness setup <opencode|pi> --host", directory, err)
|
||||
return fmt.Errorf("recorded Docker installation %s is no longer usable: %w; relink with pipelines harness link <opencode|pi> --docker-directory <checkout>, or rerun pipelines harness setup <opencode|pi> from the native installation", directory, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -80,6 +80,10 @@ func DisplayName(name string) string {
|
||||
return "OpenCode"
|
||||
case "pi":
|
||||
return "Pi"
|
||||
case "claude":
|
||||
return "Claude Code"
|
||||
case "codex":
|
||||
return "Codex"
|
||||
default:
|
||||
return name
|
||||
}
|
||||
|
||||
@@ -308,6 +308,8 @@ exec pipelines provider-check --model "$1" --yes --json --timeout 90s
|
||||
"Rerun when the registry/npm is reachable; refusing to silently install stale copies.") from None
|
||||
|
||||
def reconfigure_harness(self, name, options):
|
||||
# `pipelines harness setup <name>` on a Docker installation lands here.
|
||||
# The in-container setup signs in only when needed (or with --login).
|
||||
# Reuse the setup resolution/verification path without rebuilding or
|
||||
# restarting services: a stale image needs an explicit ./install upgrade.
|
||||
releases = self.resolve_releases()
|
||||
@@ -323,10 +325,10 @@ exec pipelines provider-check --model "$1" --yes --json --timeout 90s
|
||||
"pi": found.get("pi", releases["pi"]["version"]),
|
||||
"node": found.get("node", ""),
|
||||
})
|
||||
self.compose("exec", "pipelines", "pipelines", "harness", "setup", name, "--login", "--versions", label, *options)
|
||||
self.compose("exec", "pipelines", "pipelines", "harness", "setup", name, "--versions", label, *options)
|
||||
|
||||
def link_host(self, name=None, config=None):
|
||||
# Shared by fresh setup and --opencode/--pi reconfiguration. The host
|
||||
# Shared by fresh setup and `pipelines harness setup` reconfiguration. The host
|
||||
# launcher is linked from the container profile; it is never executed
|
||||
# from a host harness runtime.
|
||||
if config is None:
|
||||
@@ -601,6 +603,7 @@ printf 'header = "Authorization: Bearer %s"\\n' "$(cat "$PIPELINES_NTFY_TOKEN_FI
|
||||
if shutil.which("go") or shutil.which("pipelines"):
|
||||
self.link_host()
|
||||
print("Docker setup complete. Use docker compose ps / logs to manage it; no OS user service was registered.")
|
||||
print("Next: set up your agent harnesses: pipelines harness setup opencode|pi")
|
||||
|
||||
|
||||
def arguments(argv=None):
|
||||
|
||||
@@ -1,5 +1,10 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Reconfigure one harness without reinstalling/restarting services or deleting login."""
|
||||
"""Docker backend of `pipelines harness setup opencode|pi`.
|
||||
|
||||
Reconfigures one harness in the Docker installation without reinstalling or
|
||||
restarting services or deleting login. Run `pipelines harness setup <name>`
|
||||
instead of calling this directly.
|
||||
"""
|
||||
import importlib.util
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
@@ -19,7 +24,7 @@ setup_docker = module("setup_docker", "setup-docker.py")
|
||||
def main():
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
if len(sys.argv) < 2 or sys.argv[1] not in ("opencode", "pi"):
|
||||
sys.exit("Usage: setup-harness.py opencode|pi [harness setup options]")
|
||||
sys.exit("Usage: pipelines harness setup opencode|pi [--login] [--model P/M] [--pipeline-model P/M] [--default]")
|
||||
name = sys.argv[1]
|
||||
settings = root / ".env"
|
||||
docker = settings.is_file() and "PIPELINES_HOST_REPOSITORY=" in settings.read_text()
|
||||
|
||||
@@ -103,8 +103,9 @@ class Setup:
|
||||
opencode = shutil.which("opencode")
|
||||
if not opencode:
|
||||
raise ValueError(
|
||||
"OpenCode was not found on PATH. Install OpenCode yourself (this installer never installs, "
|
||||
"upgrades or downloads it) and rerun; model selection happens in your existing OpenCode configuration.")
|
||||
"OpenCode was not found on PATH. It is required: it runs pipeline stages and chat by default. "
|
||||
"Install it yourself (this installer never installs, upgrades or downloads it): "
|
||||
"curl -fsSL https://opencode.ai/install | bash -- then rerun ./install.")
|
||||
pi = shutil.which("pi")
|
||||
return {"opencode": str(Path(opencode).resolve()), "pi": str(Path(pi).resolve()) if pi else ""}
|
||||
|
||||
@@ -928,6 +929,8 @@ class Setup:
|
||||
else:
|
||||
print(f"Unauthenticated API bound to {args.bind_address}:{args.port}; use the authenticated web URL.")
|
||||
app_build.print_web_urls(manifest, lan_host=lan_ip)
|
||||
print("OpenCode is required (default stage and chat harness) and is set up by ./install.")
|
||||
print("Next: set up your agent harnesses: pipelines harness setup claude|codex|opencode|pi")
|
||||
|
||||
|
||||
def arguments(argv=None):
|
||||
|
||||
@@ -627,7 +627,8 @@ fi
|
||||
installer.verify_harness_versions = lambda resolved: {"opencode": "2.0.26", "pi": "1.1.0", "node": "22.19.0"}
|
||||
installer.reconfigure_harness("pi", ["--model", "fixture/model"])
|
||||
setup_call = next(c for c in calls if "setup" in c)
|
||||
self.assertIn("--login", setup_call)
|
||||
# The in-container setup signs in only when needed; --login is opt-in.
|
||||
self.assertNotIn("--login", setup_call)
|
||||
self.assertIn("--versions", setup_call)
|
||||
label = setup_call[setup_call.index("--versions") + 1]
|
||||
for want in ("OpenCode 2.0.26", "Pi 1.1.0", "Node 22.19.0"):
|
||||
|
||||
@@ -69,6 +69,14 @@ class HarnessSetupTests(unittest.TestCase):
|
||||
with self.assertRaisesRegex(ValueError, "run ./install"):
|
||||
setup.main()
|
||||
|
||||
def test_install_harness_flags_point_to_the_single_setup_command(self):
|
||||
install = Path(__file__).resolve().parents[1] / "install.sh"
|
||||
for flag, name in (("--opencode", "opencode"), ("--pi", "pi")):
|
||||
result = subprocess.run(["sh", str(install), flag], capture_output=True, text=True)
|
||||
self.assertEqual(result.returncode, 2)
|
||||
self.assertEqual(result.stdout, "")
|
||||
self.assertEqual(result.stderr.strip(), f"./install {flag} was removed; run: pipelines harness setup {name}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
@@ -473,8 +473,10 @@ class SetupNativeTests(unittest.TestCase):
|
||||
installer.run(setup_native.arguments([]))
|
||||
self.assertEqual((prefix / "secrets/publisher-token").read_text(), before)
|
||||
self.assertEqual(manage.load(prefix)["web"]["port"], 8096)
|
||||
self.assertEqual(output.getvalue().splitlines()[-2:], [
|
||||
" http://localhost:8096/", " http://192.168.1.20:8096/"])
|
||||
self.assertEqual(output.getvalue().splitlines()[-4:], [
|
||||
" http://localhost:8096/", " http://192.168.1.20:8096/",
|
||||
"OpenCode is required (default stage and chat harness) and is set up by ./install.",
|
||||
"Next: set up your agent harnesses: pipelines harness setup claude|codex|opencode|pi"])
|
||||
self.assertFalse(any("token" in call for call in recorder.calls), "reinstall re-created the token")
|
||||
|
||||
def test_ntfy_is_built_from_the_pinned_module(self):
|
||||
|
||||
Reference in New Issue
Block a user