opensandbox-cli 1.1.1__tar.gz → 1.1.2.dev20261020__tar.gz

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: opensandbox-cli
-Version: 1.1.1
+Version: 1.1.2.dev20261020
 Summary: OpenSandbox CLI - Command-line interface for managing sandboxes
 Project-URL: Homepage, https://open-sandbox.ai
 Project-URL: Repository, https://github.com/opensandbox-group/OpenSandbox
@@ -395,11 +395,7 @@ Create from a template (golden image):
 osb sandbox create --template <template-id> --timeout 30m -o json
 ```
 
-Template mode fixes the workload shape on the server: `--image`, `--env`,
-`--resource`, `--entrypoint`, `--volumes-file`, and `--credential-proxy` cannot
-be combined with `--template`. Only `--timeout` (required), `--metadata`,
-`--extension`, and `--network-policy-file` may accompany it. Only templates in
-the `Succeeded` phase can be used. See [Manage templates](#manage-templates).
+Template mode fixes the workload shape on the server: `--image`, `--env`, `--resource`, `--entrypoint`, `--volumes-file`, and `--credential-proxy` cannot be combined with `--template`. Only `--timeout` (required), `--metadata`, `--extension`, and `--network-policy-file` may accompany it. Only templates in the `Succeeded` phase can be used. See [Manage templates](#manage-templates).
 
 Create from a snapshot:
 
@@ -415,8 +411,7 @@ Create from a request file (`-f`, like `kubectl apply -f`):
 osb sandbox create -f sandbox-request.json -o json
 ```
 
-`sandbox-request.json` uses the public `CreateSandboxRequest` JSON format
-(camelCase keys):
+`sandbox-request.json` uses the public `CreateSandboxRequest` JSON format (camelCase keys):
 
 ```json
 {
@@ -431,23 +426,13 @@ osb sandbox create -f sandbox-request.json -o json
 }
 ```
 
-- Exactly one of `image` (string or `{ "uri": ..., "auth": { "username": ..., "password": ... } }`),
-  `templateId`, or `snapshotId` is required; `timeout` is integer seconds, or
-  `null` for manual cleanup.
-- Supported fields: `image`, `templateId`, `snapshotId`, `platform`, `timeout`,
-  `resourceLimits`, `resourceRequests`, `env`, `metadata`, `extensions`,
-  `entrypoint`, `networkPolicy`, `credentialProxy`, `secureAccess`, `volumes`,
-  `lifecycle`.
-- `-f` cannot be combined with request-building flags; `--skip-health-check`,
-  `--ready-timeout`, and `-o` still apply. In template mode the file may only
-  set `timeout`, `metadata`, `extensions`, and `networkPolicy` alongside
-  `templateId` (a finite `timeout` is required).
+- Exactly one of `image` (string or `{ "uri": ..., "auth": { "username": ..., "password": ... } }`), `templateId`, or `snapshotId` is required; `timeout` is integer seconds, or `null` for manual cleanup.
+- Supported fields: `image`, `templateId`, `snapshotId`, `platform`, `timeout`, `resourceLimits`, `resourceRequests`, `env`, `metadata`, `extensions`, `entrypoint`, `networkPolicy`, `credentialProxy`, `secureAccess`, `volumes`, `lifecycle`.
+- `-f` cannot be combined with request-building flags; `--skip-health-check`, `--ready-timeout`, and `-o` still apply. In template mode the file may only set `timeout`, `metadata`, `extensions`, and `networkPolicy` alongside `templateId` (a finite `timeout` is required).
 
 ### Manage templates
 
-Templates are golden-image builds; the build runs asynchronously, so poll
-`template get` until the status phase is `Succeeded`. Template management
-requires a Kubernetes-backed runtime.
+Templates are golden-image builds; the build runs asynchronously, so poll `template get` until the status phase is `Succeeded`. Template management requires a Kubernetes-backed runtime.
 
 ```bash
 osb template create --image python:3.12 --publish s3://bucket/publish -o json
@@ -456,11 +441,7 @@ osb template list -o json
 osb template delete <template-id> -o json
 ```
 
-`template create` also accepts `--resource cpu=1 memory=512Mi disk=2Gi`,
-`--entrypoint` (repeat per argv item), `--env KEY=VALUE`, `--metadata
-KEY=VALUE`, `--format native|overlaybd`, `--readiness-probe`, and
-`--warmup-seconds`. Or pass a request file in the public `CreateTemplateRequest`
-JSON format:
+`template create` also accepts `--resource cpu=1 memory=512Mi disk=2Gi`, `--entrypoint` (repeat per argv item), `--env KEY=VALUE`, `--metadata KEY=VALUE`, `--format native|overlaybd`, `--readiness-probe`, and `--warmup-seconds`. Or pass a request file in the public `CreateTemplateRequest` JSON format:
 
 ```bash
 osb template create -f template-request.json -o json
@@ -499,9 +480,7 @@ osb sandbox metrics <sandbox-id> --watch -o raw
 
 ### Pause a sandbox
 
-Pause is asynchronous. `Pause request accepted` confirms that the server accepted
-the request, not that the sandbox has reached the `Paused` state. Poll the sandbox
-until the transition finishes:
+Pause is asynchronous. `Pause request accepted` confirms that the server accepted the request, not that the sandbox has reached the `Paused` state. Poll the sandbox until the transition finishes:
 
 ```bash
 osb sandbox pause <sandbox-id>
@@ -530,16 +509,9 @@ osb command status <sandbox-id> <execution-id> -o json
 osb command logs <sandbox-id> <execution-id> -o json
 ```
 
-Background start errors or a stream ending before startup confirmation make the
-CLI exit non-zero without success metadata. After a successful start, use
-`command status` and `command logs` to check the process's eventual result.
+Background start errors or a stream ending before startup confirmation make the CLI exit non-zero without success metadata. After a successful start, use `command status` and `command logs` to check the process's eventual result.
 
-By default the payload after `--` is joined into one shell command string, so
-pipelines, redirection, and `$VAR` expansion work as in a terminal. Add `--argv`
-to pass the arguments to the executable as a literal argv list (no shell) when
-values such as `$HOME`, quotes, embedded spaces, or empty strings must reach the
-process unchanged. `--argv` needs a sandbox image whose execd accepts argv
-requests:
+By default the payload after `--` is joined into one shell command string, so pipelines, redirection, and `$VAR` expansion work as in a terminal. Add `--argv` to pass the arguments to the executable as a literal argv list (no shell) when values such as `$HOME`, quotes, embedded spaces, or empty strings must reach the process unchanged. `--argv` needs a sandbox image whose execd accepts argv requests:
 
 ```bash
 osb command run <sandbox-id> -o raw --argv -- python3 -c "import sys; print(sys.argv[1:])" "a b" '$HOME' "x'y" ""
@@ -566,10 +538,7 @@ osb file replace <sandbox-id> /workspace/app.py --old old --new new -o json
 osb file chmod <sandbox-id> /workspace/script.sh --mode 755 -o json
 ```
 
-Downloads replace regular files only on success; a failed or interrupted
-download preserves any existing regular file. Existing devices and named pipes
-receive data directly. Stdout aliases (such as `/dev/stdout`) stream only the file
-bytes, without a success message. See the [CLI guide](../docs/cli/index.md#work-with-files).
+Downloads replace regular files only on success; a failed or interrupted download preserves any existing regular file. Existing devices and named pipes receive data directly. Stdout aliases (such as `/dev/stdout`) stream only the file bytes, without a success message. See the [CLI guide](../docs/cli/index.md#work-with-files).
 
 ### Manage runtime egress policy
 
@@ -593,9 +562,7 @@ osb command run <sandbox-id> -o raw -- curl -I https://pypi.org
 
 ### Manage Credential Vault
 
-Credential Vault operations call the sandbox egress sidecar through the Python SDK.
-Create the sandbox with `--credential-proxy` and an explicit network policy before
-writing vault state.
+Credential Vault operations call the sandbox egress sidecar through the Python SDK. Create the sandbox with `--credential-proxy` and an explicit network policy before writing vault state.
 
 ```bash
 osb credential-vault create <sandbox-id> --file vault.yaml -o json
@@ -606,14 +573,14 @@ osb credential-vault binding list <sandbox-id> -o json
 osb credential-vault delete <sandbox-id> -o json
 ```
 
-Use `--file -` to read a JSON/YAML payload from stdin. Do not pass plaintext
-credential values as command-line flags; keep them in the payload stream or file.
+Use `--file -` to read a JSON/YAML payload from stdin. Do not pass plaintext credential values as command-line flags; keep them in the payload stream or file.
 
 ### Collect diagnostics
 
-Use the stable diagnostics commands for API-backed log and event descriptors.
+Use context to identify the runtime backend, then collect log and event descriptors.
 
 ```bash
+osb diagnostics context <sandbox-id> -o json
 osb diagnostics events <sandbox-id> --scope runtime -o raw
 osb diagnostics events <sandbox-id> --scope all -o raw
 osb diagnostics logs <sandbox-id> --scope container -o raw
@@ -622,7 +589,9 @@ osb diagnostics events <sandbox-id> --scope runtime -o json
 osb diagnostics logs <sandbox-id> --scope container -o yaml
 ```
 
-`--scope` is required for stable diagnostics. The built-in server supports
+`context` returns backend routing information without connecting to execd and
+supports table, JSON, and YAML output. `--scope` is required for logs/events.
+The built-in server supports
 `container` and `all` for logs, and `runtime` and `all` for events. It returns
 `DIAGNOSTICS_SCOPE_UNSUPPORTED` for unavailable scopes, including lifecycle events.
 Best-effort scopes may include a `warnings` field when the backend can only
@@ -632,8 +601,7 @@ temporary URL. Structured CLI output follows the SDK/Python field style, for
 example `content_url`, `content_length`, and `expires_at`. Older server builds
 may still return `DIAGNOSTICS_NOT_IMPLEMENTED` for scoped diagnostics.
 
-Legacy DevOps diagnostics remain experimental. Prefer `osb diagnostics logs/events`
-for stable API-backed log and event collection.
+Legacy DevOps diagnostics remain experimental. Prefer `osb diagnostics logs/events` for stable API-backed log and event collection.
 
 ```bash
 osb devops inspect <sandbox-id> -o raw
@@ -701,12 +669,12 @@ Supported targets:
 
 | Target | Install location |
 | --- | --- |
-| `claude` | `./.claude/skills/` or `~/.claude/skills/` |
+| `claude` | `./.claude/skills/<name>/SKILL.md` or `~/.claude/skills/<name>/SKILL.md` |
 | `cursor` | `./.cursor/rules/` or `~/.cursor/rules/` |
 | `codex` | `./.codex/skills/<name>/SKILL.md` or `~/.codex/skills/<name>/SKILL.md` |
-| `copilot` | `./.github/copilot-instructions.md` or `~/.github/copilot-instructions.md` |
+| `copilot` | `./.github/copilot-instructions.md` or `~/.copilot/copilot-instructions.md` |
 | `windsurf` | `./.windsurfrules` or `~/.windsurfrules` |
-| `cline` | `./.clinerules` or `~/.clinerules` |
+| `cline` | `./.clinerules` or `~/.cline/rules/opensandbox-<name>.md` |
 | `opencode` | `./.agents/skills/<name>/SKILL.md` or `~/.agents/skills/<name>/SKILL.md` |
 
 Common flows:

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/README.md

@@ -162,11 +162,7 @@ Create from a template (golden image):
 osb sandbox create --template <template-id> --timeout 30m -o json
 ```
 
-Template mode fixes the workload shape on the server: `--image`, `--env`,
-`--resource`, `--entrypoint`, `--volumes-file`, and `--credential-proxy` cannot
-be combined with `--template`. Only `--timeout` (required), `--metadata`,
-`--extension`, and `--network-policy-file` may accompany it. Only templates in
-the `Succeeded` phase can be used. See [Manage templates](#manage-templates).
+Template mode fixes the workload shape on the server: `--image`, `--env`, `--resource`, `--entrypoint`, `--volumes-file`, and `--credential-proxy` cannot be combined with `--template`. Only `--timeout` (required), `--metadata`, `--extension`, and `--network-policy-file` may accompany it. Only templates in the `Succeeded` phase can be used. See [Manage templates](#manage-templates).
 
 Create from a snapshot:
 
@@ -182,8 +178,7 @@ Create from a request file (`-f`, like `kubectl apply -f`):
 osb sandbox create -f sandbox-request.json -o json
 ```
 
-`sandbox-request.json` uses the public `CreateSandboxRequest` JSON format
-(camelCase keys):
+`sandbox-request.json` uses the public `CreateSandboxRequest` JSON format (camelCase keys):
 
 ```json
 {
@@ -198,23 +193,13 @@ osb sandbox create -f sandbox-request.json -o json
 }
 ```
 
-- Exactly one of `image` (string or `{ "uri": ..., "auth": { "username": ..., "password": ... } }`),
-  `templateId`, or `snapshotId` is required; `timeout` is integer seconds, or
-  `null` for manual cleanup.
-- Supported fields: `image`, `templateId`, `snapshotId`, `platform`, `timeout`,
-  `resourceLimits`, `resourceRequests`, `env`, `metadata`, `extensions`,
-  `entrypoint`, `networkPolicy`, `credentialProxy`, `secureAccess`, `volumes`,
-  `lifecycle`.
-- `-f` cannot be combined with request-building flags; `--skip-health-check`,
-  `--ready-timeout`, and `-o` still apply. In template mode the file may only
-  set `timeout`, `metadata`, `extensions`, and `networkPolicy` alongside
-  `templateId` (a finite `timeout` is required).
+- Exactly one of `image` (string or `{ "uri": ..., "auth": { "username": ..., "password": ... } }`), `templateId`, or `snapshotId` is required; `timeout` is integer seconds, or `null` for manual cleanup.
+- Supported fields: `image`, `templateId`, `snapshotId`, `platform`, `timeout`, `resourceLimits`, `resourceRequests`, `env`, `metadata`, `extensions`, `entrypoint`, `networkPolicy`, `credentialProxy`, `secureAccess`, `volumes`, `lifecycle`.
+- `-f` cannot be combined with request-building flags; `--skip-health-check`, `--ready-timeout`, and `-o` still apply. In template mode the file may only set `timeout`, `metadata`, `extensions`, and `networkPolicy` alongside `templateId` (a finite `timeout` is required).
 
 ### Manage templates
 
-Templates are golden-image builds; the build runs asynchronously, so poll
-`template get` until the status phase is `Succeeded`. Template management
-requires a Kubernetes-backed runtime.
+Templates are golden-image builds; the build runs asynchronously, so poll `template get` until the status phase is `Succeeded`. Template management requires a Kubernetes-backed runtime.
 
 ```bash
 osb template create --image python:3.12 --publish s3://bucket/publish -o json
@@ -223,11 +208,7 @@ osb template list -o json
 osb template delete <template-id> -o json
 ```
 
-`template create` also accepts `--resource cpu=1 memory=512Mi disk=2Gi`,
-`--entrypoint` (repeat per argv item), `--env KEY=VALUE`, `--metadata
-KEY=VALUE`, `--format native|overlaybd`, `--readiness-probe`, and
-`--warmup-seconds`. Or pass a request file in the public `CreateTemplateRequest`
-JSON format:
+`template create` also accepts `--resource cpu=1 memory=512Mi disk=2Gi`, `--entrypoint` (repeat per argv item), `--env KEY=VALUE`, `--metadata KEY=VALUE`, `--format native|overlaybd`, `--readiness-probe`, and `--warmup-seconds`. Or pass a request file in the public `CreateTemplateRequest` JSON format:
 
 ```bash
 osb template create -f template-request.json -o json
@@ -266,9 +247,7 @@ osb sandbox metrics <sandbox-id> --watch -o raw
 
 ### Pause a sandbox
 
-Pause is asynchronous. `Pause request accepted` confirms that the server accepted
-the request, not that the sandbox has reached the `Paused` state. Poll the sandbox
-until the transition finishes:
+Pause is asynchronous. `Pause request accepted` confirms that the server accepted the request, not that the sandbox has reached the `Paused` state. Poll the sandbox until the transition finishes:
 
 ```bash
 osb sandbox pause <sandbox-id>
@@ -297,16 +276,9 @@ osb command status <sandbox-id> <execution-id> -o json
 osb command logs <sandbox-id> <execution-id> -o json
 ```
 
-Background start errors or a stream ending before startup confirmation make the
-CLI exit non-zero without success metadata. After a successful start, use
-`command status` and `command logs` to check the process's eventual result.
+Background start errors or a stream ending before startup confirmation make the CLI exit non-zero without success metadata. After a successful start, use `command status` and `command logs` to check the process's eventual result.
 
-By default the payload after `--` is joined into one shell command string, so
-pipelines, redirection, and `$VAR` expansion work as in a terminal. Add `--argv`
-to pass the arguments to the executable as a literal argv list (no shell) when
-values such as `$HOME`, quotes, embedded spaces, or empty strings must reach the
-process unchanged. `--argv` needs a sandbox image whose execd accepts argv
-requests:
+By default the payload after `--` is joined into one shell command string, so pipelines, redirection, and `$VAR` expansion work as in a terminal. Add `--argv` to pass the arguments to the executable as a literal argv list (no shell) when values such as `$HOME`, quotes, embedded spaces, or empty strings must reach the process unchanged. `--argv` needs a sandbox image whose execd accepts argv requests:
 
 ```bash
 osb command run <sandbox-id> -o raw --argv -- python3 -c "import sys; print(sys.argv[1:])" "a b" '$HOME' "x'y" ""
@@ -333,10 +305,7 @@ osb file replace <sandbox-id> /workspace/app.py --old old --new new -o json
 osb file chmod <sandbox-id> /workspace/script.sh --mode 755 -o json
 ```
 
-Downloads replace regular files only on success; a failed or interrupted
-download preserves any existing regular file. Existing devices and named pipes
-receive data directly. Stdout aliases (such as `/dev/stdout`) stream only the file
-bytes, without a success message. See the [CLI guide](../docs/cli/index.md#work-with-files).
+Downloads replace regular files only on success; a failed or interrupted download preserves any existing regular file. Existing devices and named pipes receive data directly. Stdout aliases (such as `/dev/stdout`) stream only the file bytes, without a success message. See the [CLI guide](../docs/cli/index.md#work-with-files).
 
 ### Manage runtime egress policy
 
@@ -360,9 +329,7 @@ osb command run <sandbox-id> -o raw -- curl -I https://pypi.org
 
 ### Manage Credential Vault
 
-Credential Vault operations call the sandbox egress sidecar through the Python SDK.
-Create the sandbox with `--credential-proxy` and an explicit network policy before
-writing vault state.
+Credential Vault operations call the sandbox egress sidecar through the Python SDK. Create the sandbox with `--credential-proxy` and an explicit network policy before writing vault state.
 
 ```bash
 osb credential-vault create <sandbox-id> --file vault.yaml -o json
@@ -373,14 +340,14 @@ osb credential-vault binding list <sandbox-id> -o json
 osb credential-vault delete <sandbox-id> -o json
 ```
 
-Use `--file -` to read a JSON/YAML payload from stdin. Do not pass plaintext
-credential values as command-line flags; keep them in the payload stream or file.
+Use `--file -` to read a JSON/YAML payload from stdin. Do not pass plaintext credential values as command-line flags; keep them in the payload stream or file.
 
 ### Collect diagnostics
 
-Use the stable diagnostics commands for API-backed log and event descriptors.
+Use context to identify the runtime backend, then collect log and event descriptors.
 
 ```bash
+osb diagnostics context <sandbox-id> -o json
 osb diagnostics events <sandbox-id> --scope runtime -o raw
 osb diagnostics events <sandbox-id> --scope all -o raw
 osb diagnostics logs <sandbox-id> --scope container -o raw
@@ -389,7 +356,9 @@ osb diagnostics events <sandbox-id> --scope runtime -o json
 osb diagnostics logs <sandbox-id> --scope container -o yaml
 ```
 
-`--scope` is required for stable diagnostics. The built-in server supports
+`context` returns backend routing information without connecting to execd and
+supports table, JSON, and YAML output. `--scope` is required for logs/events.
+The built-in server supports
 `container` and `all` for logs, and `runtime` and `all` for events. It returns
 `DIAGNOSTICS_SCOPE_UNSUPPORTED` for unavailable scopes, including lifecycle events.
 Best-effort scopes may include a `warnings` field when the backend can only
@@ -399,8 +368,7 @@ temporary URL. Structured CLI output follows the SDK/Python field style, for
 example `content_url`, `content_length`, and `expires_at`. Older server builds
 may still return `DIAGNOSTICS_NOT_IMPLEMENTED` for scoped diagnostics.
 
-Legacy DevOps diagnostics remain experimental. Prefer `osb diagnostics logs/events`
-for stable API-backed log and event collection.
+Legacy DevOps diagnostics remain experimental. Prefer `osb diagnostics logs/events` for stable API-backed log and event collection.
 
 ```bash
 osb devops inspect <sandbox-id> -o raw
@@ -468,12 +436,12 @@ Supported targets:
 
 | Target | Install location |
 | --- | --- |
-| `claude` | `./.claude/skills/` or `~/.claude/skills/` |
+| `claude` | `./.claude/skills/<name>/SKILL.md` or `~/.claude/skills/<name>/SKILL.md` |
 | `cursor` | `./.cursor/rules/` or `~/.cursor/rules/` |
 | `codex` | `./.codex/skills/<name>/SKILL.md` or `~/.codex/skills/<name>/SKILL.md` |
-| `copilot` | `./.github/copilot-instructions.md` or `~/.github/copilot-instructions.md` |
+| `copilot` | `./.github/copilot-instructions.md` or `~/.copilot/copilot-instructions.md` |
 | `windsurf` | `./.windsurfrules` or `~/.windsurfrules` |
-| `cline` | `./.clinerules` or `~/.clinerules` |
+| `cline` | `./.clinerules` or `~/.cline/rules/opensandbox-<name>.md` |
 | `opencode` | `./.agents/skills/<name>/SKILL.md` or `~/.agents/skills/<name>/SKILL.md` |
 
 Common flows:

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/commands/diagnostics.py

@@ -64,6 +64,24 @@ def diagnostics_group(ctx: click.Context) -> None:
         click.echo(ctx.get_help())
 
 
+@diagnostics_group.command("context")
+@click.argument("sandbox_id")
+@output_option("table", "json", "yaml")
+@click.pass_obj
+@handle_errors
+def diagnostics_context(
+    obj: ClientContext,
+    sandbox_id: str,
+    output_format: str | None,
+) -> None:
+    """Identify the sandbox backend and its diagnostic identifiers."""
+    context = obj.get_manager().get_diagnostic_context(sandbox_id)
+    output = prepare_output(
+        obj, output_format, allowed=("table", "json", "yaml"), fallback="table"
+    )
+    output.print_dict(context.model_dump(mode="json"), title="Diagnostic Context")
+
+
 @diagnostics_group.command("logs")
 @click.argument("sandbox_id")
 @click.option(

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/commands/sandbox.py

@@ -823,14 +823,14 @@ def sandbox_get(obj: ClientContext, sandbox_id: str, output_format: str | None)
 def sandbox_kill(
     obj: ClientContext, sandbox_ids: tuple[str, ...], output_format: str | None
 ) -> None:
-    """Terminate one or more sandboxes."""
+    """Request deletion of one or more sandboxes; cleanup may continue."""
     prepare_output(obj, output_format, allowed=("table", "json", "yaml"), fallback="table")
     mgr = obj.get_manager()
     rows: list[dict[str, str]] = []
     for sid in sandbox_ids:
         with obj.output.spinner(f"Killing sandbox {sid}..."):
             mgr.kill_sandbox(sid)
-        rows.append({"sandbox_id": sid, "status": "terminated"})
+        rows.append({"sandbox_id": sid, "status": "deletion_requested"})
     obj.output.print_rows(rows, columns=["sandbox_id", "status"], title="Sandboxes")
 
 

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/commands/skills.py

@@ -69,11 +69,13 @@ _TARGETS = cast(dict[str, TargetConfig], {
             "project": {
                 "strategy": "copy",
                 "dest_dir": Path(".claude") / "skills",
+                "dest_file_template": "{slug}/SKILL.md",
                 "preserve_frontmatter": True,
             },
             "global": {
                 "strategy": "copy",
                 "dest_dir": Path.home() / ".claude" / "skills",
+                "dest_file_template": "{slug}/SKILL.md",
                 "preserve_frontmatter": True,
             }
         },
@@ -122,7 +124,7 @@ _TARGETS = cast(dict[str, TargetConfig], {
             },
             "global": {
                 "strategy": "append",
-                "dest_file": Path.home() / ".github" / "copilot-instructions.md",
+                "dest_file": Path.home() / ".copilot" / "copilot-instructions.md",
                 "preserve_frontmatter": False,
             }
         },
@@ -151,8 +153,9 @@ _TARGETS = cast(dict[str, TargetConfig], {
                 "preserve_frontmatter": False,
             },
             "global": {
-                "strategy": "append",
-                "dest_file": Path.home() / ".clinerules",
+                "strategy": "copy",
+                "dest_dir": Path.home() / ".cline" / "rules",
+                "dest_file_template": "opensandbox-{slug}.md",
                 "preserve_frontmatter": False,
             }
         },

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/config.py

@@ -85,6 +85,12 @@ def resolve_config(
 ) -> dict[str, Any]:
     """Merge config from all sources and return a flat dict.
 
+    Values that come from the config file are coerced to the type declared for
+    each key. A file may legitimately encode a value with a different TOML type
+    than the CLI expects (for example an all-digit ``connection.api_key`` or a
+    ``defaults.timeout`` given in seconds), and callers downstream rely on the
+    declared type.
+
     Keys returned:
       - api_key, domain, protocol, request_timeout (int seconds), use_server_proxy (bool)
       - default_image, default_timeout (str like "10m")
@@ -97,27 +103,27 @@ def resolve_config(
     return {
         "api_key": cli_api_key
         or os.getenv("OPEN_SANDBOX_API_KEY")
-        or conn.get("api_key"),
+        or _str_or_none(conn.get("api_key")),
         "domain": cli_domain
         or os.getenv("OPEN_SANDBOX_DOMAIN")
-        or conn.get("domain"),
+        or _str_or_none(conn.get("domain")),
         "protocol": cli_protocol
         or os.getenv("OPEN_SANDBOX_PROTOCOL")
-        or conn.get("protocol")
+        or _str_or_none(conn.get("protocol"))
         or "http",
         "request_timeout": cli_timeout
         or _int_or_none(os.getenv("OPEN_SANDBOX_REQUEST_TIMEOUT"))
-        or conn.get("request_timeout")
+        or _int_or_none(conn.get("request_timeout"))
         or 30,
         "use_server_proxy": _coalesce(
             cli_use_server_proxy,
             _bool_or_none(os.getenv("OPEN_SANDBOX_USE_SERVER_PROXY")),
-            conn.get("use_server_proxy"),
+            _bool_or_none(conn.get("use_server_proxy")),
             False,
         ),
-        "color": output_cfg.get("color", True),
-        "default_image": defaults.get("image"),
-        "default_timeout": defaults.get("timeout"),
+        "color": _coalesce(_bool_or_none(output_cfg.get("color")), True),
+        "default_image": _str_or_none(defaults.get("image")),
+        "default_timeout": _str_or_none(defaults.get("timeout")),
     }
 
 
@@ -133,18 +139,34 @@ def init_config_file(config_path: Path | None = None, *, force: bool = False) ->
     return path
 
 
-def _int_or_none(value: str | None) -> int | None:
-    if value is None:
-        return None
-    try:
-        return int(value)
-    except ValueError:
+def _int_or_none(value: Any) -> int | None:
+    """Coerce a configured value to ``int``, or ``None`` when it is not numeric."""
+    if value is None or isinstance(value, bool):
         return None
+    if isinstance(value, int):
+        return value
+    if isinstance(value, (str, float)):
+        try:
+            return int(value)
+        except (TypeError, ValueError, OverflowError):
+            return None
+    return None
+
 
+def _bool_or_none(value: Any) -> bool | None:
+    """Coerce a configured value to ``bool``, or ``None`` when it is not boolean.
 
-def _bool_or_none(value: str | None) -> bool | None:
+    ``0``/``1`` are accepted so hand-edited files that write a TOML integer for a
+    boolean key keep resolving instead of silently falling back to the default.
+    """
     if value is None:
         return None
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return bool(value) if value in (0, 1) else None
+    if not isinstance(value, str):
+        return None
     normalized = value.strip().lower()
     if normalized in ("1", "true", "yes", "on"):
         return True
@@ -153,6 +175,17 @@ def _bool_or_none(value: str | None) -> bool | None:
     return None
 
 
+def _str_or_none(value: Any) -> str | None:
+    """Coerce a configured value to ``str``, or ``None`` when it has no text form."""
+    if value is None or isinstance(value, bool):
+        return None
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (int, float)):
+        return str(value)
+    return None
+
+
 def _coalesce(*values: Any) -> Any:
     for value in values:
         if value is not None:

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/main.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 
 import click
@@ -48,9 +49,46 @@ BANNER = r"""[bold cyan]
 """
 
 
+# A representative icon: any encoding that cannot render it would raise on output.
+_OUTPUT_PROBE = "\u2705"
+
+
+def _configure_output_streams() -> None:
+    """Keep CLI output writable when the active encoding cannot represent it.
+
+    Click and Rich print emoji and box-drawing characters. On a legacy Windows
+    code page (cp936, cp1252, ...) or a POSIX ``C`` locale writing them raises
+    ``UnicodeEncodeError``, which aborts the command - even after the work is
+    done - so streams whose encoding cannot represent that output escape the
+    characters instead of raising.
+
+    Escaping (``backslashreplace``) keeps payload writes - raw command and
+    file data, machine-readable output - recoverable; ``errors="replace"``
+    would silently corrupt them into ``?``. CPython uses the same handler for
+    Windows stderr.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        encoding = getattr(stream, "encoding", None)
+        if reconfigure is None or encoding is None:
+            continue
+        try:
+            _OUTPUT_PROBE.encode(encoding)
+        except (LookupError, UnicodeEncodeError):
+            try:
+                reconfigure(errors="backslashreplace")
+            except (OSError, ValueError):  # pragma: no cover - detached stream
+                pass
+
+
 class BannerGroup(click.Group):
     """Custom Click group that shows a banner before help text."""
 
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        """Configure output streams before Click renders help or runs a command."""
+        _configure_output_streams()
+        return super().parse_args(ctx, args)
+
     def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
         console = Console(stderr=False)
         console.print(BANNER.format(version=__version__))

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/output.py

@@ -59,6 +59,18 @@ _DIM_COLUMNS = {"created_at", "expires_at", "modified_at", "updated_at"}
 _ID_COLUMNS = {"id", "sandbox_id", "execution_id", "context_id"}
 
 
+def _stdout_can_encode(text: str) -> bool:
+    """Return whether stdout can represent ``text`` without substitution."""
+    encoding = getattr(sys.stdout, "encoding", None)
+    if encoding is None:
+        return True
+    try:
+        text.encode(encoding)
+    except (LookupError, UnicodeEncodeError):
+        return False
+    return True
+
+
 def _style_value(col: str, value: str) -> Text:
     """Apply contextual styling to a cell value."""
     lower = value.lower()
@@ -248,7 +260,15 @@ class OutputFormatter:
                 "PyYAML is not installed. Use --output json instead.", fg="red", err=True
             )
             sys.exit(1)
-        click.echo(yaml.dump(data, default_flow_style=False, allow_unicode=True).rstrip())
+        text = yaml.dump(data, default_flow_style=False, allow_unicode=True).rstrip()
+        if not _stdout_can_encode(text):
+            # Keep machine-readable output valid on limited code pages: escape
+            # non-ASCII into round-trippable sequences instead of letting the
+            # stream replace characters with "?".
+            text = yaml.dump(
+                data, default_flow_style=False, allow_unicode=False
+            ).rstrip()
+        click.echo(text)
 
     def _print_kv_table(self, data: dict[str, Any], *, title: str | None = None) -> None:
         table = Table(

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/skills/opensandbox-command-execution.md

@@ -50,12 +50,9 @@ osb command session run <sandbox-id> <session-id> -o raw -- sh -lc 'pwd'
 
 Treat these as three distinct execution paths:
 
-- `osb command run` without `--background`
-  Use for foreground one-shot commands when the result should stream directly to the terminal
-- `osb command run --background`
-  Use when the user needs an execution ID, later status checks, or log retrieval
-- `osb command session ...`
-  Use when shell state must persist across commands, such as exported variables or a working directory
+- `osb command run` without `--background` Use for foreground one-shot commands when the result should stream directly to the terminal
+- `osb command run --background` Use when the user needs an execution ID, later status checks, or log retrieval
+- `osb command session ...` Use when shell state must persist across commands, such as exported variables or a working directory
 
 ## Golden Paths
 

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/skills/opensandbox-credential-vault.md

@@ -5,36 +5,28 @@ description: Use OpenSandbox Credential Vault commands to manage sandbox-local o
 
 # OpenSandbox Credential Vault
 
-Manage outbound credential injection with `osb credential-vault`. Treat vault
-changes as a controlled runtime workflow: confirm the sandbox was created with
-Credential Proxy, write secrets only through payload files or stdin, inspect
-sanitized state, then verify actual outbound behavior from inside the sandbox.
+Manage outbound credential injection with `osb credential-vault`. Treat vault changes as a controlled runtime workflow: confirm the sandbox was created with Credential Proxy, write secrets only through payload files or stdin, inspect sanitized state, then verify actual outbound behavior from inside the sandbox.
 
 ## When To Use
 
 - the user needs real credentials injected into outbound HTTP or HTTPS requests
 - the user wants to create, inspect, patch, or delete Credential Vault state
 - the user needs to add, replace, or remove runtime credentials or bindings
-- the user wants to keep plaintext credentials out of sandbox env vars, files,
-  shell history, and command arguments
+- the user wants to keep plaintext credentials out of sandbox env vars, files, shell history, and command arguments
 
 ## Prerequisites
 
-Credential Vault requires an egress sidecar with transparent MITM enabled. Create
-the sandbox with both a network policy and Credential Proxy:
+Credential Vault requires an egress sidecar with transparent MITM enabled. Create the sandbox with both a network policy and Credential Proxy:
 
 ```bash
 osb sandbox create --image python:3.12 --network-policy-file network-policy.json --credential-proxy -o json
 ```
 
-If `credential-vault create`, `patch`, or `delete` returns a precondition error,
-the sandbox was likely not created with Credential Proxy, the egress API auth
-token is missing, mitmproxy is not ready, or insecure upstream TLS mode is set.
+If `credential-vault create`, `patch`, or `delete` returns a precondition error, the sandbox was likely not created with Credential Proxy, the egress API auth token is missing, mitmproxy is not ready, or insecure upstream TLS mode is set.
 
 ## Payload Rules
 
-Use JSON or YAML payload files, or `--file -` for stdin. Do not put real secret
-values in command-line flags.
+Use JSON or YAML payload files, or `--file -` for stdin. Do not put real secret values in command-line flags.
 
 Create payload shape:
 
@@ -107,8 +99,7 @@ credentials:
 
 ## Inspect Metadata
 
-Vault read APIs return sanitized metadata only. Plaintext credential values are
-write-only and should not appear in command output.
+Vault read APIs return sanitized metadata only. Plaintext credential values are write-only and should not appear in command output.
 
 ```bash
 osb credential-vault credential get <sandbox-id> api-token -o json
@@ -117,8 +108,7 @@ osb credential-vault binding get <sandbox-id> api -o json
 
 ## Cleanup
 
-Delete all sandbox-local vault state when credential injection is no longer
-needed:
+Delete all sandbox-local vault state when credential injection is no longer needed:
 
 ```bash
 osb credential-vault delete <sandbox-id> -o json
@@ -132,5 +122,4 @@ When helping a user:
 2. Confirm the sandbox was created with `--credential-proxy` and network policy.
 3. Keep secret material in payload files or stdin, never in CLI flags.
 4. Use `get` or `list` to inspect sanitized state.
-5. Verify behavior with `osb command run ... -o raw -- curl ...` when injection
-   behavior matters.
+5. Verify behavior with `osb command run ... -o raw -- curl ...` when injection behavior matters.

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/skills/opensandbox-file-operations.md

@@ -40,14 +40,10 @@ osb config show -o json
 
 Treat these as distinct categories:
 
-- sandbox-only content operations
-  `cat`, `write`, `replace`, `mv`, `mkdir`, `rm`, `rmdir`, `info`, `chmod`
-- host-to-sandbox transfer
-  `upload`
-- sandbox-to-host transfer
-  `download`
-- discovery before modification
-  `search`, then `info`
+- sandbox-only content operations `cat`, `write`, `replace`, `mv`, `mkdir`, `rm`, `rmdir`, `info`, `chmod`
+- host-to-sandbox transfer `upload`
+- sandbox-to-host transfer `download`
+- discovery before modification `search`, then `info`
 
 If the path is uncertain, search first. If the file boundary crosses between host and sandbox, use `upload` or `download` instead of `write` or `cat`.
 

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/skills/opensandbox-network-egress.md

@@ -56,10 +56,8 @@ osb config show -o json
 
 Runtime egress policy consists of:
 
-- `defaultAction`
-  The fallback action when no rule matches
-- `egress`
-  An ordered list of allow or deny rules
+- `defaultAction` The fallback action when no rule matches
+- `egress` An ordered list of allow or deny rules
 
 Important semantics:
 

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/skills/opensandbox-sandbox-lifecycle.md

@@ -267,7 +267,7 @@ Rules:
 - use `renew` before long-running work instead of waiting for expiry
 - use `pause` only when the workload can tolerate suspension
 - treat the pause result as request acceptance and poll `sandbox get` until the state is `Paused` or `Failed`
-- use `kill` when cleanup is the real goal; do not leave orphaned sandboxes behind
+- `kill` returns `deletion_requested` when accepted; poll `sandbox get` until `404` to confirm resource removal. Pool `Noop` preserves processes even after removal.
 
 ## Runtime Notes
 

{opensandbox_cli-1.1.1 → opensandbox_cli-1.1.2.dev20261020}/src/opensandbox_cli/skills/opensandbox-sandbox-troubleshooting.md

@@ -66,11 +66,17 @@ Use this order by default:
 
 ```bash
 osb sandbox get <sandbox-id> -o json
+osb diagnostics context <sandbox-id> -o json
 osb sandbox health <sandbox-id> -o json
 osb diagnostics events <sandbox-id> --scope runtime -o raw
 osb diagnostics logs <sandbox-id> --scope container -o raw
 ```
 
+Use context's `backend_type` and `backend_identifiers` to select backend-specific
+investigation. Context works before execd is ready. Fast Sandbox supports runtime
+events but not container logs; skip log collection for that backend. If context
+is unavailable on an older server, continue with sandbox state and supported diagnostics.
+
 Then drill down only where the stable diagnostics point:
 
 ```bash