Files
worklane/tests/cmd_install_tool.rs
T
Ansho ReiandClaude Opus 5 11145b228e (c092ea7) Ship the opencode tool definitions with the binary, behind install-tool
`.opencode/tools/worklane.ts` was the second agent asset and the only one
that existed nowhere but a checkout. `cargo install` places binaries and
nothing else, so anyone who installed worklane got the skills and never the
tools, and the copy that did exist was reachable only from this repo. It is
now `assets/TOOL.ts`, embedded with `include_str!` like every other asset,
and `install-tool` writes it where opencode looks.

Its own command rather than a flag on `install-skill`, because the two
artifacts are not alike. A skill is inert markdown and one path serves both
agents. The tool is executable TypeScript and serves one: Claude Code has no
directory it scans for a tool definition, `claude mcp add` is the only way a
tool enters its list, and its plugin system adopts agents, hooks, monitors,
workflows, output-styles and themes and nothing named tools. Reaching it
would mean an MCP server, which is a different artifact and not this file.
So somebody on Claude Code takes the documents and never the wrapper, which
is the choice this command exists to give them.

The path was measured rather than guessed, as the ticket asked. 1.15.10
loads `~/.config/opencode/tool/` and `~/.config/opencode/tools/` both: each
was served in turn from a directory outside any project and
`/experimental/tool/ids` came back with all eleven worklane tools. Singular
is the target, the spelling opencode's own documentation puts first the way
it writes `agent(s)` and `skill(s)`. `tools_root()` follows
`XDG_CONFIG_HOME` where `skills_root()` does not, because opencode's config
root is an XDG path and `~/.claude` is not; `opencode debug paths` reports
`$XDG_CONFIG_HOME/opencode` with it set. An empty value counts as unset, the
convention `colors_wanted` already follows.

`opencode_tool_dir` takes both variables as arguments for the reason
`colors_wanted` does: a threaded test binary cannot mutate the process
environment to reach one branch at a time.

The file name is load bearing and now pinned by a test. opencode builds each
tool id as the file name then the export, so `worklane.ts` plus eleven
`export const` lines is what makes them `worklane_add` through
`worklane_uncheck`. Renaming the file renames every tool and every
permission rule naming one.

The closing line is not the skills' "on their next session". opencode reads
its config once at startup and never reloads it, so a running one keeps the
tools it began with and the honest instruction is to restart it.

Nothing else has to be installed, which is worth saying because the file is
executable and reads as though it wants a toolchain. Criterion 6 asked the
command to name the plugin package and Bun as runtime requirements and both
are wrong: a copy in a project with no `node_modules` above it registered
all eleven tools on a machine with no `bun` on `PATH`. opencode is a Bun
binary and the import resolves inside it. The message says the opposite, and
the reasoning is on the ticket.

`install_each` is the outcome loop both commands now share, with the
compare-and-refuse invocation passed in: that line is the only part of an
outcome that has to name the command it came from. What each command says
after the loop stays with the command.

`every_tool_the_wrapper_exports_is_a_real_subcommand` guards the direction
that breaks at call time, a tool wrapping a command that has been renamed or
dropped. Deliberately not the reverse: the wrapper has no tool for `relate`,
`campaign`, `assign` or `tags`, so an agent holding the tools cannot reach
campaigns or relations at all, and a test asserting that gap would fail on a
decision nobody has taken rather than on a mistake. Its own ticket.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-23 14:14:14 +02:00

150 lines
5.6 KiB
Rust

use assert_cmd::Command;
use assert_fs::TempDir;
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
/// The tool as this test's binary carries it, so the print path is pinned to the file in
/// the repo rather than to a description of it.
const TOOL: &str = include_str!("../assets/TOOL.ts");
/// `XDG_CONFIG_HOME` is redirected, and `HOME` with it, so the suite never writes into
/// the config of whoever runs it. Both, because the fallback reads `HOME` and a machine
/// that has neither set is not the case under test here.
fn run(config: &TempDir, args: &[&str]) -> std::process::Output {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.env("XDG_CONFIG_HOME", config.path())
.env("HOME", config.path())
.args(args);
cmd.assert().get_output().clone()
}
fn installed(config: &TempDir) -> std::path::PathBuf {
config.path().join("opencode/tool/worklane.ts")
}
fn stdout(output: &std::process::Output) -> String {
String::from_utf8(output.stdout.clone()).unwrap()
}
/// Nothing about the tool needs a board, and it is wanted before there is one.
///
/// The file name is asserted, not just the directory: opencode names each tool as the
/// file then the export, so `worklane.ts` is what makes them `worklane_add` and
/// `worklane_mv`.
#[test]
fn the_tool_installs_outside_a_worklane_directory() {
let config = TempDir::new().unwrap();
let output = run(&config, &["install-tool"]);
assert!(output.status.success());
assert_eq!(std::fs::read_to_string(installed(&config)).unwrap(), TOOL);
assert!(
stdout(&output).contains("Installed the worklane tool"),
"{}",
stdout(&output)
);
}
/// What the message has to carry, and it is not the skills' "next session": opencode
/// reads its config once at startup and never reloads it, so a running one keeps the
/// tools it began with. The second half is there because the file is executable and
/// looks like it needs a toolchain, which it does not.
#[test]
fn the_tool_says_to_restart_opencode_and_that_nothing_else_is_needed() {
let config = TempDir::new().unwrap();
let out = stdout(&run(&config, &["install-tool"]));
assert!(out.contains("Restart it"), "{out}");
assert!(out.contains("never reloaded"), "{out}");
assert!(out.contains("Nothing else to install"), "{out}");
assert!(out.contains("Bun"), "{out}");
}
/// Installing twice is a no-op rather than a rewrite, exactly as `install-skill` is.
#[test]
fn a_second_install_reports_the_copy_unchanged() {
let config = TempDir::new().unwrap();
run(&config, &["install-tool"]);
let out = stdout(&run(&config, &["install-tool"]));
assert!(out.contains("Already up to date"), "{out}");
assert!(!out.contains("Installed the"), "{out}");
}
/// An edited copy is somebody's work, and the refusal names the invocation that shows
/// what it would be replaced with. `--print` there and not a skill name: there is one
/// tool file, so nothing has to say which.
#[test]
fn a_modified_copy_is_refused_until_force() {
let config = TempDir::new().unwrap();
run(&config, &["install-tool"]);
std::fs::write(installed(&config), "// hand written\n").unwrap();
let refused = stdout(&run(&config, &["install-tool"]));
assert!(refused.contains("Differs from the version in this binary"), "{refused}");
assert!(refused.contains("worklane install-tool --print"), "{refused}");
assert_eq!(std::fs::read_to_string(installed(&config)).unwrap(), "// hand written\n");
let forced = stdout(&run(&config, &["install-tool", "--force"]));
assert!(forced.contains("Installed the worklane tool"), "{forced}");
assert_eq!(std::fs::read_to_string(installed(&config)).unwrap(), TOOL);
}
/// `--print` is for diffing against an installed copy, so it writes nothing.
#[test]
fn print_writes_the_tool_to_stdout_and_installs_nothing() {
let config = TempDir::new().unwrap();
let output = run(&config, &["install-tool", "--print"]);
assert_eq!(stdout(&output), TOOL);
assert!(!installed(&config).exists());
}
/// With no `XDG_CONFIG_HOME` the tool lands under `HOME`, which is the same answer
/// opencode gives: its config root is `$XDG_CONFIG_HOME/opencode` when that is set and
/// `~/.config/opencode` when it is not.
#[test]
fn the_tool_falls_back_to_the_home_directory_without_xdg_config_home() {
let home = TempDir::new().unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
let output = cmd
.env_remove("XDG_CONFIG_HOME")
.env("HOME", home.path())
.arg("install-tool")
.assert()
.success()
.get_output()
.clone();
let path = home.path().join(".config/opencode/tool/worklane.ts");
assert_eq!(std::fs::read_to_string(&path).unwrap(), TOOL);
assert!(
stdout(&output).contains(&path.display().to_string()),
"{}",
stdout(&output)
);
}
/// The two commands are independent, which is the whole point of them being two: a
/// person on Claude Code takes the skills and never the tool, and one who wants the
/// tools is not made to take a second copy of the documents to get them.
#[test]
fn each_install_command_leaves_the_other_target_alone() {
let config = TempDir::new().unwrap();
run(&config, &["install-tool"]);
assert!(installed(&config).exists());
assert!(!config.path().join(".claude/skills").exists());
let skills_only = TempDir::new().unwrap();
run(&skills_only, &["install-skill"]);
assert!(
skills_only
.path()
.join(".claude/skills/worklane/SKILL.md")
.exists()
);
assert!(!installed(&skills_only).exists());
}