d0zingcat/claude-code
1
0
Fork 0
mirror of https://github.com/instructkr/claude-code.git synced 2026-06-04 11:36:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: make dump-manifests self-contained

Browse Source
This commit is contained in:
bellman
2026-06-04 02:46:44 +09:00
parent cd58c054ca
commit 4522490bd5
6 changed files with 328 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
ROADMAP.md
View File

@@ -1244,8 +1244,7 @@ Model name prefix now wins unconditionally over env-var presence. Regression tes
45. **`claw dump-manifests` fails with opaque "No such file or directory"** — dogfooded 2026-04-09. `claw dump-manifests` emits `error: failed to extract manifests: No such file or directory (os error 2)` with no indication of which file or directory is missing. **Partial fix at `47aa1a5`+1**: error message now includes `looked in: <path>` so the build-tree path is visible, what manifests are, or how to fix it. Fix shape: (a) surface the missing path in the error message; (b) add a pre-check that explains what manifests are and where they should be (e.g. `.claw/manifests/` or the plugins directory); (c) if the command is only valid after `claw init` or after installing plugins, say so explicitly. Source: Jobdori dogfood 2026-04-09.
45. **`claw dump-manifests` fails with opaque `No such file or directory`** — **done (verified 2026-04-12):** current `main` now accepts `claw dump-manifests --manifests-dir PATH`, pre-checks for the required upstream manifest files (`src/commands.ts`, `src/tools.ts`, `src/entrypoints/cli.tsx`), and replaces the opaque os error with guidance that points users to `CLAUDE_CODE_UPSTREAM` or `--manifests-dir`. Fresh proof: parser coverage for both flag forms, unit coverage for missing-manifest and explicit-path flows, and `output_format_contract` JSON coverage via the new flag all pass. **Original filing below.**
45. **`claw dump-manifests` fails with opaque `No such file or directory`** — **done (verified 2026-04-12):** current `main` now accepts `claw dump-manifests --manifests-dir PATH`, pre-checks for the required upstream manifest files (`src/commands.ts`, `src/tools.ts`, `src/entrypoints/cli.tsx`), and replaces the opaque os error with guidance that points users to `CLAUDE_CODE_UPSTREAM` or `--manifests-dir`. Fresh proof: parser coverage for both flag forms, unit coverage for missing-manifest and explicit-path flows, and `output_format_contract` JSON coverage via the new flag all pass. **Original filing below.**
45. **`claw dump-manifests` fails with opaque `No such file or directory`** — **done (verified 2026-06-03):** current `main` now emits a self-contained Rust resolver inventory for `claw dump-manifests` without requiring upstream TypeScript files, build-machine paths, or `CLAUDE_CODE_UPSTREAM`. Explicit `--manifests-dir PATH` scopes resolver discovery to another directory and missing/not-directory values emit typed `missing_manifests` guidance. Fresh proof: parser coverage for both flag forms, unit coverage for self-contained default, explicit-directory, and missing-directory flows, plus `output_format_contract` JSON coverage all pass. **Original filing below.**
46. **`/tokens`, `/cache`, `/stats` were dead spec — parse arms missing** — dogfooded 2026-04-09. All three had spec entries with `resume_supported: true` but no parse arms, producing the circular error "Unknown slash command: /tokens — Did you mean /tokens". Also `SlashCommand::Stats` existed but was unimplemented in both REPL and resume dispatch. **Done at `60ec2ae` 2026-04-09**: `"tokens" | "cache"` now alias to `SlashCommand::Stats`; `Stats` is wired in both REPL and resume path with full JSON output. Source: Jobdori dogfood.
47. **`/diff` fails with cryptic "unknown option 'cached'" outside a git repo; resume /diff used wrong CWD** — dogfooded 2026-04-09. `claw --resume <session> /diff` in a non-git directory produced `git diff --cached failed: error: unknown option 'cached'` because git falls back to `--no-index` mode outside a git tree. Also resume `/diff` used `session_path.parent()` (the `.claw/sessions/<id>/` dir) as CWD for the diff — never a git repo. **Done at `aef85f8` 2026-04-09**: `render_diff_report_for()` now checks `git rev-parse --is-inside-work-tree` first and returns a clear "no git repository" message; resume `/diff` uses `std::env::current_dir()`. Source: Jobdori dogfood.
@@ -1547,7 +1546,7 @@ Original filing (2026-04-13): user requested a `-acp` parameter to support ACP p
**Source.** Jobdori dogfood 2026-04-17 against `/tmp/cd3` on main HEAD `e58c194` in response to Clawhip pinpoint nudge at `1494653681222811751`. Distinct from #80/#81/#82 (status/error surfaces lie about *static* runtime state): this is a surface that lies about *time itself*, and the lie is smeared into every live-agent system prompt, not just a single error string or status field.
84. **`claw dump-manifests` default search path is the build machine's absolute filesystem path baked in at compile time — broken and information-leaking for any user running a distributed binary** — dogfooded 2026-04-17 on main HEAD `70a0f0c` from `/tmp/cd4` (fresh workspace). Running `claw dump-manifests` with no arguments emits:
84. **DONE — `claw dump-manifests` no longer bakes or leaks the build machine's absolute filesystem path** — fixed 2026-06-03 in `fix: make dump-manifests self-contained`. The runtime default now uses the current workspace and emits the Rust resolver inventory directly, so distributed binaries no longer depend on upstream TypeScript source files or compile-time `CARGO_MANIFEST_DIR` paths. Explicit `--manifests-dir` remains as a discovery-root override and invalid roots return typed `missing_manifests` diagnostics. Original filing below: running `claw dump-manifests` with no arguments emitted:
```
error: Manifest source files are missing.
repo root: /Users/yeongyu/clawd/claw-code
@@ -6366,7 +6365,7 @@ Original filing (2026-04-18): the session emitted `SessionStart hook (completed)
429. **DONE — global workspace directory override is accepted and validated before dispatch** — fixed 2026-06-03 in `fix: add global cwd override`. `claw --cwd PATH ...`, `claw -C PATH ...`, and `claw --directory PATH ...` now run as if launched from the selected workspace before config, status, doctor, MCP, skills, and other command dispatch. The override takes precedence over process `$PWD`; invalid values emit typed `invalid_cwd` JSON errors with `path` and `reason` (`not_found`, `not_a_directory`, or `empty`) instead of the old misleading `Did you mean --acp?` CLI parse path. Help/usage docs list the global flags and the precedence/validation contract. Regression coverage: `global_cwd_flag_routes_status_workspace_and_short_alias_429`, `global_cwd_flag_reports_typed_invalid_paths_429`, and classifier coverage for `invalid_cwd`.
430. **`dump-manifests` is documented as "emit every skill/agent/tool manifest the resolver would load for the current cwd" but actually requires the upstream Claude Code TypeScript source files (`src/commands.ts`, `src/tools.ts`, `src/entrypoints/cli.tsx`) — the command is unusable for any user who installed claw without cloning the original Claude Code repo** — dogfooded 2026-05-11 by Jobdori on `075c2144` in response to Clawhip pinpoint nudge at `1503275502046023690`. Reproduction: `claw dump-manifests --output-format json` returns `{"error":"Manifest source files are missing.","hint":"repo root: /private/tmp/claw-dog-0530\n missing: src/commands.ts, src/tools.ts, src/entrypoints/cli.tsx\n Hint: set CLAUDE_CODE_UPSTREAM=/path/to/upstream or pass \`claw dump-manifests --manifests-dir /path/to/upstream\`.","kind":"missing_manifests"}`. The fresh-main worktree at `/private/tmp/claw-dog-0530` does not contain these TypeScript files because the Rust port doesn't include the upstream TS source. The `--help` text says the command works against "the current cwd" but in practice it requires `CLAUDE_CODE_UPSTREAM=` pointing at an unshipped TS source tree. **Three sibling problems compounded:** (a) **derivative-work disclosure leak**: the error message exposes that `claw-code` is a port of Claude Code (`CLAUDE_CODE_UPSTREAM` env var name) — even if true, surfacing this in a casual diagnostic message couples user-facing behavior to upstream provenance details. (b) **kind drift**: `claw dump-manifests --manifests-dir /tmp/nonexistent --output-format json` returns `kind:"unknown"`, while `claw dump-manifests` (no override) returns `kind:"missing_manifests"`. Same root cause (no usable upstream), two different `kind` discriminators — automation cannot switch on a single error type. (c) **export-positional-arg silently dropped**: probed in the same run — `claw export <bogus-positional>` ignores the path and returns `kind:"no_managed_sessions"` regardless of what positional arg was passed. The `--help` advertises `[PATH]` as the output-file destination but the path is discarded before validation, indistinguishable from invocation with no args. **Required fix shape:** (a) make `dump-manifests` emit the manifests claw-code itself ships with (Rust-resolver-discovered skills/agents/tools), independent of any upstream TS source — that matches the `--help` description; (b) if upstream-comparison is genuinely needed for parity work, move it to a separate command like `parity dump-upstream-manifests` and remove the upstream dependency from `dump-manifests`; (c) standardize on one error `kind` for the manifest-missing failure mode (`missing_manifests` is more descriptive than `unknown`); (d) `claw export <PATH>` must validate the path positional arg before the session-discovery check, so users see `kind:"invalid_output_path"` (or similar) when the path is malformed instead of always seeing `kind:"no_managed_sessions"`. **Why this matters:** `dump-manifests` is the inventory surface a downstream automation lane would call to learn what claw can do in the current workspace. If it's broken without upstream TS source, downstream lanes can't introspect — they have to fall back to `agents list`/`skills list`/`mcp list` separately and re-aggregate. Cross-references #422 (kind:unknown for unknown_subcommand), #423 (kind:unknown for missing_argument), #428 (kind:unknown for invalid_permission_mode) — `kind:"unknown"` keeps appearing as the catch-all for surfaces that should have typed kinds. Source: Jobdori live dogfood, `075c2144`, 2026-05-11.
430. **DONE — `dump-manifests` emits the self-contained Rust resolver inventory instead of requiring upstream Claude Code TypeScript source files** — fixed 2026-06-03 in `fix: make dump-manifests self-contained`. `claw dump-manifests --output-format json` now succeeds from an installed workspace with `source:"rust-resolver"`, command/tool/agent/skill/bootstrap manifests, no `CLAUDE_CODE_UPSTREAM` hint, and no `src/commands.ts` dependency. Explicit `--manifests-dir` scopes resolver discovery to another directory and missing/not-directory roots emit typed `missing_manifests` JSON. Sibling export diagnostics now validate explicit positional/`--output` paths before session discovery and return typed `invalid_output_path` JSON with `path` and `reason`. Regression coverage: `dump_manifests_defaults_to_rust_resolver_inventory`, `dump_manifests_scopes_explicit_manifest_dir_without_upstream_ts`, `dump_manifests_missing_explicit_dir_has_typed_kind`, `dump_manifests_and_init_emit_json_when_requested`, `local_json_surfaces_have_non_empty_action_contract_714`, and `export_invalid_output_path_reports_typed_json_430`.
431. **`skills uninstall <name>` requires Anthropic credentials despite being a local filesystem operation — `claw skills uninstall nonexistent-skill-xyz --output-format json` returns `kind:"missing_credentials"` instead of resolving locally that the skill doesn't exist** — dogfooded 2026-05-11 by Jobdori on `328fd114` in response to Clawhip pinpoint nudge at `1503275502046023690` (sibling probe to #430). Reproduction (no creds, isolated `CLAW_CONFIG_HOME`): `claw skills uninstall nonexistent-skill-xyz --output-format json` returns `{"error":"missing Anthropic credentials; export ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY...","kind":"missing_credentials"}`. Uninstalling a skill is a pure local filesystem operation: read the skills directory, find the named skill, remove its files. There is no semantic reason to require API credentials. Same class of bug as #357 (`session list` requires creds), #369 (`session help/fork` require creds), and #427 (`resume <bogus-id>` requires creds). **Three sibling findings in same probe:** (a) `claw skills install <bogus-name>` returns `{"error":"No such file or directory (os error 2)","kind":"unknown"}` — leaks raw OS error string with no hint about expected install source format (path vs name vs URL?), and the catch-all `kind:"unknown"` again instead of typed `kind:"skill_install_source_not_found"`. (b) `claw skills install` (no args) returns `action:"help"` with `unexpected:"install"` — but `install` IS a documented subcommand. The handler treats it as "unknown action" instead of "missing required argument". Should emit `kind:"missing_argument"` with `argument:"install_source"`. (c) `claw agents create my-agent` returns `action:"help"` with `unexpected:"create my-agent"` — there is no agent-creation surface at all. Users must hand-craft `.claw/agents/<name>.md` files with no scaffolding command, while `claw init` only creates the top-level `.claw/` skeleton. **Required fix shape:** (a) `skills uninstall <name>` must be local-first: enumerate the local skills dir, return `kind:"skill_not_found"` (with `skills_dir:` and `available_names:[]` fields) for missing, or remove the files and return `kind:"skills"` with `action:"uninstall", removed:<name>` for present skills; (b) `skills install <source>` must distinguish source forms (`path:`, `name:`, `url:`) and emit `kind:"invalid_install_source"` with the parsed-and-failed reason; (c) `skills install` (no args) emits `kind:"missing_argument"` with `argument:"install_source"`; (d) add `claw agents create <name>` (or `claw init agent <name>`) that scaffolds `.claw/agents/<name>.md` with a stub frontmatter; or document explicitly that agents are user-authored only. **Why this matters:** lifecycle commands (`uninstall`, `install`, `create`) are the primary surface for managing claw's extension surface area. If `uninstall` requires API creds, an offline user who fat-fingered an install can't undo it. If `install` returns a raw OS error, automation can't programmatically recover. If `agents create` doesn't exist, agent authoring is undocumented file-touching only. Cross-references #357, #369, #427 (auth-gate-on-local-ops cluster), and #422/#423/#428/#430 (`kind:"unknown"` catch-all cluster). Source: Jobdori live dogfood, `328fd114`, 2026-05-11.

1
rust/Cargo.lock generated
View File

@@ -2244,7 +2244,6 @@ version = "0.1.3"
dependencies = [
"api",
"commands",
"compat-harness",
"crossterm",
"log",
"mock-anthropic-service",

5
rust/README.md
View File

@@ -147,6 +147,7 @@ Top-level commands:
```
`claw acp` is a local discoverability surface for editor-first users: it reports the current ACP/Zed status without starting the runtime. As of April 16, 2026, claw-code does **not** ship an ACP/Zed daemon or JSON-RPC entrypoint yet, and `claw acp serve` is only a status alias until the real protocol surface lands. Status queries exit 0 and expose the same machine-readable contract via `--output-format json`; malformed ACP invocations exit 1 with `kind: unsupported_acp_invocation`.
`claw dump-manifests` is self-contained: it emits the Rust resolver inventory for the selected workspace (commands, tools, agents, skills, and bootstrap phases) without requiring an upstream Claude Code TypeScript checkout. Use `--manifests-dir PATH` only to scope resolver discovery to another directory.
The command surface is moving quickly. For the canonical live help text, run:
@@ -185,7 +186,7 @@ rust/
└── crates/
├── api/ # Provider clients + streaming + request preflight
├── commands/ # Shared slash-command registry + help rendering
├── compat-harness/ # TS manifest extraction harness
├── compat-harness/ # Compatibility/parity harness utilities
├── mock-anthropic-service/ # Deterministic local Anthropic-compatible mock
├── plugins/ # Plugin metadata, manager, install/enable/disable surfaces
├── runtime/ # Session, config, permissions, MCP, prompts, auth/runtime loop
@@ -198,7 +199,7 @@ rust/
- **api** — provider clients, SSE streaming, request/response types, auth (`ANTHROPIC_API_KEY` + bearer-token support), request-size/context-window preflight
- **commands** — slash command definitions, parsing, help text generation, JSON/text command rendering
- **compat-harness** — extracts tool/prompt manifests from upstream TS source
- **compat-harness** — compatibility and parity helpers for comparing behavior with upstream fixtures
- **mock-anthropic-service** — deterministic `/v1/messages` mock for CLI parity tests and local harness runs
- **plugins** — plugin metadata, install/enable/disable/update flows, plugin tool definitions, hook integration surfaces
- **runtime** — `ConversationRuntime`, config loading, session persistence, permission policy, MCP client lifecycle, system prompt assembly, usage tracking

1
rust/crates/rusty-claude-cli/Cargo.toml
View File

@@ -12,7 +12,6 @@ path = "src/main.rs"
[dependencies]
api = { path = "../api" }
commands = { path = "../commands" }
compat-harness = { path = "../compat-harness" }
crossterm = "0.28"
pulldown-cmark = "0.13"
rustyline = "15"

369
rust/crates/rusty-claude-cli/src/main.rs
View File

@@ -48,7 +48,6 @@ use commands::{
slash_command_specs, validate_slash_command_input, PluginsCommandResult, SkillSlashDispatch,
SlashCommand,
};
use compat_harness::{extract_manifest, UpstreamPaths};
use init::initialize_repo;
use plugins::{PluginHooks, PluginManager, PluginManagerConfig, PluginRegistry};
use render::{MarkdownStreamState, Spinner, TerminalRenderer};
@@ -347,6 +346,16 @@ fn main() {
);
}
}
} else if kind == "invalid_output_path" {
if let Some(error) = error.downcast_ref::<InvalidOutputPathError>() {
if let Some(object) = error_json.as_object_mut() {
object.insert("path".to_string(), serde_json::json!(&error.path));
object.insert(
"reason".to_string(),
serde_json::json!(error.reason.as_str()),
);
}
}
}
// #819/#820/#823: JSON mode error envelopes must go to stdout so machine
// consumers can parse failures from stdout byte 0 (parity with all
@@ -387,7 +396,9 @@ fn classify_error_kind(message: &str) -> &'static str {
"command_not_found"
} else if message.contains("missing Anthropic credentials") {
"missing_credentials"
} else if message.contains("Manifest source files are missing") {
} else if message.contains("Manifest source files are missing")
|| message.starts_with("missing_manifests:")
{
"missing_manifests"
} else if message.contains("no worker state file found") {
"missing_worker_state"
@@ -413,6 +424,8 @@ fn classify_error_kind(message: &str) -> &'static str {
"unsupported_skills_action"
} else if message.starts_with("invalid_cwd:") {
"invalid_cwd"
} else if message.starts_with("invalid_output_path:") {
"invalid_output_path"
} else if message.contains("unrecognized argument") || message.contains("unknown option") {
"cli_parse"
} else if message.starts_with("missing_flag_value:") {
@@ -607,6 +620,53 @@ impl std::fmt::Display for InvalidCwdError {
impl std::error::Error for InvalidCwdError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum InvalidOutputPathReason {
Empty,
ParentNotFound,
ParentNotADirectory,
PathIsDirectory,
}
impl InvalidOutputPathReason {
fn as_str(self) -> &'static str {
match self {
Self::Empty => "empty",
Self::ParentNotFound => "parent_not_found",
Self::ParentNotADirectory => "parent_not_a_directory",
Self::PathIsDirectory => "path_is_directory",
}
}
}
#[derive(Debug)]
struct InvalidOutputPathError {
path: String,
reason: InvalidOutputPathReason,
}
impl InvalidOutputPathError {
fn new(path: impl Into<String>, reason: InvalidOutputPathReason) -> Self {
Self {
path: path.into(),
reason,
}
}
}
impl std::fmt::Display for InvalidOutputPathError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"invalid_output_path: {}: `{}`\nUsage: claw export [PATH] [--session SESSION] [--output PATH]",
self.reason.as_str(),
self.path
)
}
}
impl std::error::Error for InvalidOutputPathError {}
fn split_global_cwd_args(
args: &[String],
) -> Result<(Vec<String>, Option<PathBuf>), Box<dyn std::error::Error>> {
@@ -3844,12 +3904,12 @@ fn dump_manifests(
manifests_dir: Option<&Path>,
output_format: CliOutputFormat,
) -> Result<(), Box<dyn std::error::Error>> {
let workspace_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
let workspace_dir = env::current_dir()?;
dump_manifests_at_path(&workspace_dir, manifests_dir, output_format)
}
const DUMP_MANIFESTS_OVERRIDE_HINT: &str =
"Hint: set CLAUDE_CODE_UPSTREAM=/path/to/upstream or pass `claw dump-manifests --manifests-dir /path/to/upstream`.";
const DUMP_MANIFESTS_USAGE_HINT: &str =
"Usage: claw dump-manifests [--manifests-dir <path>] [--output-format json]";
// Internal function for testing that accepts a workspace directory path.
fn dump_manifests_at_path(
@@ -3857,72 +3917,105 @@ fn dump_manifests_at_path(
manifests_dir: Option<&Path>,
output_format: CliOutputFormat,
) -> Result<(), Box<dyn std::error::Error>> {
let paths = if let Some(dir) = manifests_dir {
let resolved = dir.canonicalize().unwrap_or_else(|_| dir.to_path_buf());
UpstreamPaths::from_repo_root(resolved)
} else {
// Surface the resolved path in the error so users can diagnose missing
// manifest files without guessing what path the binary expected.
let resolved = workspace_dir
.canonicalize()
.unwrap_or_else(|_| workspace_dir.to_path_buf());
UpstreamPaths::from_workspace_dir(&resolved)
};
let discovery_root = manifests_dir.unwrap_or(workspace_dir);
let resolved_root = discovery_root
.canonicalize()
.unwrap_or_else(|_| discovery_root.to_path_buf());
let source_root = paths.repo_root();
if !source_root.exists() {
if !resolved_root.exists() {
return Err(format!(
"Manifest source directory does not exist.\n looked in: {}\n {DUMP_MANIFESTS_OVERRIDE_HINT}",
source_root.display(),
"missing_manifests: manifest discovery directory does not exist.\n looked in: {}\n {DUMP_MANIFESTS_USAGE_HINT}",
resolved_root.display(),
)
.into());
}
if !resolved_root.is_dir() {
return Err(format!(
"missing_manifests: manifest discovery path is not a directory.\n looked in: {}\n {DUMP_MANIFESTS_USAGE_HINT}",
resolved_root.display(),
)
.into());
}
let required_paths = [
("src/commands.ts", paths.commands_path()),
("src/tools.ts", paths.tools_path()),
("src/entrypoints/cli.tsx", paths.cli_path()),
];
let missing = required_paths
.iter()
.filter_map(|(label, path)| (!path.is_file()).then_some(*label))
.collect::<Vec<_>>();
if !missing.is_empty() {
return Err(format!(
"Manifest source files are missing.\n repo root: {}\n missing: {}\n {DUMP_MANIFESTS_OVERRIDE_HINT}",
source_root.display(),
missing.join(", "),
)
.into());
}
match extract_manifest(&paths) {
Ok(manifest) => {
match output_format {
CliOutputFormat::Text => {
println!("commands: {}", manifest.commands.entries().len());
println!("tools: {}", manifest.tools.entries().len());
println!("bootstrap phases: {}", manifest.bootstrap.phases().len());
}
CliOutputFormat::Json => println!(
"{}",
serde_json::to_string_pretty(&json!({
"kind": "dump-manifests",
"action": "dump",
"commands": manifest.commands.entries().len(),
"tools": manifest.tools.entries().len(),
"bootstrap_phases": manifest.bootstrap.phases().len(),
}))?
),
}
Ok(())
let manifest = build_rust_resolver_manifest(&resolved_root)?;
match output_format {
CliOutputFormat::Text => {
println!("Manifest Dump");
println!(" Source rust-resolver");
println!(" Workspace {}", resolved_root.display());
println!(" Commands {}", manifest["commands"]);
println!(" Tools {}", manifest["tools"]);
println!(" Agents {}", manifest["agents"]);
println!(" Skills {}", manifest["skills"]);
println!(" Bootstrap phases {}", manifest["bootstrap_phases"]);
}
Err(error) => Err(format!(
"failed to extract manifests: {error}\n looked in: {path}\n {DUMP_MANIFESTS_OVERRIDE_HINT}",
path = paths.repo_root().display()
)
.into()),
CliOutputFormat::Json => println!("{}", serde_json::to_string_pretty(&manifest)?),
}
Ok(())
}
fn build_rust_resolver_manifest(workspace_dir: &Path) -> Result<Value, Box<dyn std::error::Error>> {
let command_entries = slash_command_specs()
.iter()
.map(|spec| {
json!({
"name": spec.name,
"aliases": spec.aliases,
"summary": spec.summary,
"argument_hint": spec.argument_hint,
"resume_supported": spec.resume_supported,
"implemented": !STUB_COMMANDS.contains(&spec.name),
})
})
.collect::<Vec<_>>();
let tool_entries = mvp_tool_specs()
.into_iter()
.map(|spec| {
json!({
"name": spec.name,
"description": spec.description,
"required_permission": spec.required_permission.as_str(),
"input_schema": spec.input_schema,
})
})
.collect::<Vec<_>>();
let agent_report = handle_agents_slash_command_json(None, workspace_dir)?;
let skill_report = handle_skills_slash_command_json(None, workspace_dir)?;
let agents = agent_report
.get("agents")
.and_then(Value::as_array)
.cloned()
.unwrap_or_default();
let skills = skill_report
.get("skills")
.and_then(Value::as_array)
.cloned()
.unwrap_or_default();
let bootstrap = runtime::BootstrapPlan::claude_code_default()
.phases()
.iter()
.map(|phase| format!("{phase:?}"))
.collect::<Vec<_>>();
Ok(json!({
"kind": "dump-manifests",
"action": "dump",
"status": "ok",
"source": "rust-resolver",
"workspace": workspace_dir.display().to_string(),
"commands": command_entries.len(),
"tools": tool_entries.len(),
"agents": agents.len(),
"skills": skills.len(),
"bootstrap_phases": bootstrap.len(),
"command_manifests": command_entries,
"tool_manifests": tool_entries,
"agent_manifests": agents,
"skill_manifests": skills,
"bootstrap_manifest": bootstrap,
}))
}
fn print_bootstrap_plan(output_format: CliOutputFormat) -> Result<(), Box<dyn std::error::Error>> {
@@ -9912,6 +10005,52 @@ fn resolve_export_path(
Ok(cwd.join(final_name))
}
fn validate_export_output_path(path: Option<&Path>) -> Result<(), InvalidOutputPathError> {
let Some(path) = path else {
return Ok(());
};
let raw = path.to_string_lossy();
if raw.trim().is_empty() {
return Err(InvalidOutputPathError::new(
raw.to_string(),
InvalidOutputPathReason::Empty,
));
}
if matches!(fs::metadata(path), Ok(metadata) if metadata.is_dir()) {
return Err(InvalidOutputPathError::new(
raw.to_string(),
InvalidOutputPathReason::PathIsDirectory,
));
}
if let Some(parent) = path
.parent()
.filter(|parent| !parent.as_os_str().is_empty())
{
match fs::metadata(parent) {
Ok(metadata) if metadata.is_dir() => {}
Ok(_) => {
return Err(InvalidOutputPathError::new(
raw.to_string(),
InvalidOutputPathReason::ParentNotADirectory,
));
}
Err(error) if error.kind() == io::ErrorKind::NotFound => {
return Err(InvalidOutputPathError::new(
raw.to_string(),
InvalidOutputPathReason::ParentNotFound,
));
}
Err(_) => {
return Err(InvalidOutputPathError::new(
raw.to_string(),
InvalidOutputPathReason::ParentNotFound,
));
}
}
}
Ok(())
}
const SESSION_MARKDOWN_TOOL_SUMMARY_LIMIT: usize = 280;
fn summarize_tool_payload_for_markdown(payload: &str) -> String {
@@ -9930,6 +10069,7 @@ fn run_export(
output_path: Option<&Path>,
output_format: CliOutputFormat,
) -> Result<(), Box<dyn std::error::Error>> {
validate_export_output_path(output_path)?;
let (handle, session) = load_session_reference(session_reference)?;
let markdown = render_session_markdown(&session, &handle.id, &handle.path);
@@ -17472,81 +17612,76 @@ mod sandbox_report_tests {
#[cfg(test)]
mod dump_manifests_tests {
use super::{dump_manifests_at_path, CliOutputFormat};
use super::{build_rust_resolver_manifest, dump_manifests_at_path, CliOutputFormat};
use std::fs;
#[test]
fn dump_manifests_shows_helpful_error_when_manifests_missing() {
let root = std::env::temp_dir().join(format!(
"claw_test_missing_manifests_{}",
std::process::id()
));
fn dump_manifests_defaults_to_rust_resolver_inventory() {
let root =
std::env::temp_dir().join(format!("claw_test_rust_manifests_{}", std::process::id()));
let workspace = root.join("workspace");
std::fs::create_dir_all(&workspace).expect("failed to create temp workspace");
fs::create_dir_all(&workspace).expect("workspace should exist");
let result = dump_manifests_at_path(&workspace, None, CliOutputFormat::Text);
assert!(
result.is_err(),
"expected an error when manifests are missing"
);
let manifest = build_rust_resolver_manifest(&workspace).expect("manifest should build");
assert_eq!(manifest["kind"], "dump-manifests");
assert_eq!(manifest["source"], "rust-resolver");
assert!(manifest["commands"].as_u64().expect("commands count") > 0);
assert!(manifest["tools"].as_u64().expect("tools count") > 0);
assert!(manifest["command_manifests"]
.as_array()
.expect("command manifests")
.iter()
.any(|entry| entry["name"] == "status"));
assert!(manifest["tool_manifests"]
.as_array()
.expect("tool manifests")
.iter()
.any(|entry| entry["name"] == "read_file"));
assert!(dump_manifests_at_path(&workspace, None, CliOutputFormat::Text).is_ok());
let error_msg = result.unwrap_err().to_string();
assert!(
error_msg.contains("Manifest source files are missing"),
"error message should mention missing manifest sources: {error_msg}"
);
assert!(
error_msg.contains(&root.display().to_string()),
"error message should contain the resolved repo root path: {error_msg}"
);
assert!(
error_msg.contains("src/commands.ts"),
"error message should mention missing commands.ts: {error_msg}"
);
assert!(
error_msg.contains("CLAUDE_CODE_UPSTREAM"),
"error message should explain how to supply the upstream path: {error_msg}"
);
let _ = std::fs::remove_dir_all(&root);
let _ = fs::remove_dir_all(&root);
}
#[test]
fn dump_manifests_uses_explicit_manifest_dir() {
fn dump_manifests_scopes_explicit_manifest_dir_without_upstream_ts() {
let root = std::env::temp_dir().join(format!(
"claw_test_explicit_manifest_dir_{}",
std::process::id()
));
let workspace = root.join("workspace");
let upstream = root.join("upstream");
fs::create_dir_all(workspace.join("nested")).expect("workspace should exist");
fs::create_dir_all(upstream.join("src/entrypoints"))
.expect("upstream fixture should exist");
fs::write(
upstream.join("src/commands.ts"),
"import FooCommand from './commands/foo'\n",
)
.expect("commands fixture should write");
fs::write(
upstream.join("src/tools.ts"),
"import ReadTool from './tools/read'\n",
)
.expect("tools fixture should write");
fs::write(
upstream.join("src/entrypoints/cli.tsx"),
"startupProfiler()\n",
)
.expect("cli fixture should write");
let manifest_dir = root.join("manifest-source");
fs::create_dir_all(&workspace).expect("workspace should exist");
fs::create_dir_all(&manifest_dir).expect("manifest dir should exist");
let result = dump_manifests_at_path(&workspace, Some(&upstream), CliOutputFormat::Text);
let result = dump_manifests_at_path(&workspace, Some(&manifest_dir), CliOutputFormat::Text);
assert!(
result.is_ok(),
"explicit manifest dir should succeed: {result:?}"
"explicit manifest dir should not require upstream TS files: {result:?}"
);
let _ = fs::remove_dir_all(&root);
}
#[test]
fn dump_manifests_missing_explicit_dir_has_typed_kind() {
let root = std::env::temp_dir().join(format!(
"claw_test_missing_manifest_dir_{}",
std::process::id()
));
let workspace = root.join("workspace");
let missing = root.join("missing");
fs::create_dir_all(&workspace).expect("workspace should exist");
let result = dump_manifests_at_path(&workspace, Some(&missing), CliOutputFormat::Text);
let error = result.expect_err("missing explicit manifest dir should fail");
let error_msg = error.to_string();
assert!(error_msg.starts_with("missing_manifests:"));
assert!(error_msg.contains(&missing.display().to_string()));
assert!(!error_msg.contains("CLAUDE_CODE_UPSTREAM"));
assert!(!error_msg.contains("src/commands.ts"));
let _ = fs::remove_dir_all(&root);
}
}
#[cfg(test)]

114
rust/crates/rusty-claude-cli/tests/output_format_contract.rs
View File

@@ -634,6 +634,60 @@ fn global_cwd_flag_reports_typed_invalid_paths_429() {
assert_eq!(empty_json["reason"], "empty");
}
#[test]
fn export_invalid_output_path_reports_typed_json_430() {
let root = unique_temp_dir("export-invalid-output-430");
fs::create_dir_all(&root).expect("temp dir should exist");
let missing_relative = "missing/transcript.md";
let missing_output = run_claw(
&root,
&["--output-format", "json", "export", missing_relative],
&[],
);
assert_eq!(missing_output.status.code(), Some(1));
assert!(
missing_output.stderr.is_empty(),
"invalid export path JSON should keep stderr empty, got:\n{}",
String::from_utf8_lossy(&missing_output.stderr)
);
let missing_stdout = String::from_utf8_lossy(&missing_output.stdout);
let missing_json: Value = serde_json::from_str(missing_stdout.trim()).unwrap_or_else(|_| {
panic!("invalid export path should emit JSON, got: {missing_stdout:?}")
});
assert_eq!(missing_json["kind"], "invalid_output_path");
assert_eq!(missing_json["error_kind"], "invalid_output_path");
assert_eq!(missing_json["reason"], "parent_not_found");
assert_eq!(missing_json["path"], missing_relative);
let directory = root.join("existing-directory");
fs::create_dir_all(&directory).expect("directory fixture should exist");
let directory_output = run_claw(
&root,
&[
"--output-format=json",
"export",
"--output",
directory.to_str().expect("utf8 directory path"),
],
&[],
);
assert_eq!(directory_output.status.code(), Some(1));
assert!(directory_output.stderr.is_empty());
let directory_stdout = String::from_utf8_lossy(&directory_output.stdout);
let directory_json: Value =
serde_json::from_str(directory_stdout.trim()).unwrap_or_else(|_| {
panic!("directory export path should emit JSON, got: {directory_stdout:?}")
});
assert_eq!(directory_json["kind"], "invalid_output_path");
assert_eq!(directory_json["error_kind"], "invalid_output_path");
assert_eq!(directory_json["reason"], "path_is_directory");
assert_eq!(
directory_json["path"],
directory.to_str().expect("utf8 directory path")
);
}
#[test]
fn status_json_accepts_namespaced_model_env_and_surfaces_alias_426() {
let root = unique_temp_dir("status-model-env-426");
@@ -1154,20 +1208,22 @@ fn dump_manifests_and_init_emit_json_when_requested() {
let root = unique_temp_dir("manifest-init-json");
fs::create_dir_all(&root).expect("temp dir should exist");
let upstream = write_upstream_fixture(&root);
let manifests = assert_json_command(
&root,
&[
"--output-format",
"json",
"dump-manifests",
"--manifests-dir",
upstream.to_str().expect("utf8 upstream"),
],
);
let manifests = assert_json_command(&root, &["--output-format", "json", "dump-manifests"]);
assert_eq!(manifests["kind"], "dump-manifests");
assert_eq!(manifests["commands"], 1);
assert_eq!(manifests["tools"], 1);
assert_eq!(manifests["status"], "ok");
assert_eq!(manifests["source"], "rust-resolver");
assert!(manifests["commands"].as_u64().expect("commands count") > 0);
assert!(manifests["tools"].as_u64().expect("tools count") > 0);
assert!(manifests["command_manifests"]
.as_array()
.expect("command manifests")
.iter()
.any(|entry| entry["name"] == "status"));
assert!(manifests["tool_manifests"]
.as_array()
.expect("tool manifests")
.iter()
.any(|entry| entry["name"] == "read_file"));
let workspace = root.join("workspace");
fs::create_dir_all(&workspace).expect("workspace should exist");
@@ -1663,7 +1719,6 @@ fn local_json_surfaces_have_non_empty_action_contract_714() {
let session_path = write_session_fixture(&workspace, "action-sweep-export", Some("export me"));
let export_output = root.join("export.md");
let upstream = write_upstream_fixture(&root);
let git_init = Command::new("git")
.arg("init")
.current_dir(&git_workspace)
@@ -1701,13 +1756,7 @@ fn local_json_surfaces_have_non_empty_action_contract_714() {
),
(
&workspace,
vec![
"--output-format".into(),
"json".into(),
"dump-manifests".into(),
"--manifests-dir".into(),
upstream.to_str().expect("upstream utf8").into(),
],
strings(&["--output-format", "json", "dump-manifests"]),
),
(
&workspace,
@@ -2301,29 +2350,6 @@ fn strings(items: &[&str]) -> Vec<String> {
items.iter().map(|item| (*item).to_string()).collect()
}
fn write_upstream_fixture(root: &Path) -> PathBuf {
let upstream = root.join("claw-code");
let src = upstream.join("src");
let entrypoints = src.join("entrypoints");
fs::create_dir_all(&entrypoints).expect("upstream entrypoints dir should exist");
fs::write(
src.join("commands.ts"),
"import FooCommand from './commands/foo'\n",
)
.expect("commands fixture should write");
fs::write(
src.join("tools.ts"),
"import ReadTool from './tools/read'\n",
)
.expect("tools fixture should write");
fs::write(
entrypoints.join("cli.tsx"),
"if (args[0] === '--version') {}\nstartupProfiler()\n",
)
.expect("cli fixture should write");
upstream
}
fn write_session_fixture(root: &Path, session_id: &str, user_text: Option<&str>) -> PathBuf {
let session_path = root.join("session.jsonl");
let mut session = Session::new()