@xano/cli 1.0.6-beta.9 → 1.2.0

package/README.md

@@ -46,16 +46,16 @@ The Metadata API pages unevenly, so `list` commands differ in what they expose.
 | Commands | Flags | Footer |
 |---|---|---|
 | `function list`, `unit_test list`, `workflow_test list` (plus `sandbox` / `tenant` variants) | `--page`, `--per_page` | `Page 2 · 50 shown · next: --page 3` |
-| `static_host list`, `static_host build list` (plus `ephemeral` variants) | `--page` only | `Page 2 · 100 shown · 340 total` |
+| `static_host list`, `static_host build list` | `--page` only | `Page 2 · 100 shown · 340 total` |
 | `branch list`, `workspace list`, `tenant snapshot list`, `sandbox env list`, `tenant env list` | none | `12 branches` |
-| `tenant list`, `release list`, `platform list`, `tenant cluster list`, `ephemeral list` | none | none |
+| `tenant list`, `release list`, `platform list`, `tenant cluster list` | none | none |
 | `tenant backup list` | `--page` only (pre-existing) | none |
 
 Notes:
 
 - **`--per_page` is only offered where the endpoint accepts it.** Static-host endpoints hardcode 100 items per page server-side, so those commands take `--page` alone. `xano static_host list --per_page 10` previously parsed but did nothing; it is now rejected rather than silently ignored.
 - **All paged commands default `--per_page` to 50.** The test-list commands previously requested 10000 internally so nothing was ever cut off; now that the footer and the JSON envelope both report position, a page that stops at 50 is visible rather than silent. Raise it (up to 10000) when you want everything in one call.
-- **The last group has no CLI paging.** Those endpoints page server-side but return a plain array with no page or total metadata, so the CLI cannot tell you where you are. Rather than show a page number with no context — or infer "more available" from a full page, which is wrong exactly when the result count is a multiple of the page size — these commands are left as-is. **They return at most 25–50 items** (50 for tenants and ephemerals, 25 for releases, platforms, and tenant backups). If you have more than that, query the Metadata API directly until those endpoints return paging metadata.
+- **The last group has no CLI paging.** Those endpoints page server-side but return a plain array with no page or total metadata, so the CLI cannot tell you where you are. Rather than show a page number with no context — or infer "more available" from a full page, which is wrong exactly when the result count is a multiple of the page size — these commands are left as-is. **They return at most 25–50 items** (50 for tenants, 25 for releases, platforms, and tenant backups). If you have more than that, query the Metadata API directly until those endpoints return paging metadata.
 - **`--output json` returns an envelope, not a bare array.** Every list command emits `{items, ...}` using the Metadata API's own field names — `curPage`, `nextPage`, `prevPage`, `itemsTotal` — each included only when the endpoint actually reports it. `perPage` is the one field the CLI adds, since the API never echoes it back and it is otherwise invisible at its default. This is a **breaking change** for scripts that parsed the previous bare array — read `.items` instead.
 
   ```jsonc
@@ -487,7 +487,7 @@ Every `run_all` command takes `--concurrency` (default `1`):
 
 ```bash
 xano unit_test run_all --concurrency 4
-xano tenant unit_test run_all my-tenant --concurrency 8
+xano tenant unit_test run_all --tenant my-tenant --concurrency 8
 ```
 
 Output stays in test order regardless of concurrency, so a parallel run is still diffable against a sequential one, and the JSON `results` array keeps a stable order.
@@ -496,6 +496,48 @@ Output stays in test order regardless of concurrency, so a parallel run is still
 
 **The default is 1 on purpose.** These tests execute against a shared workspace database, so tests that touch the same tables or records can interfere with each other when run at the same time — producing failures that look like flakiness rather than a real regression. Raise `--concurrency` once you know your tests are independent.
 
+#### Exit codes
+
+Every `run` and `run_all` command — on all four surfaces (`unit_test`, `workflow_test`, `sandbox`, `tenant`) — uses the same exit codes:
+
+| Code | Meaning |
+|------|---------|
+| `0` | All tests passed, **or** there were no tests to run |
+| `1` | At least one test failed |
+| `2` | The command could not run the tests at all — bad workspace, auth failure, unreadable profile, or the test-list request failed |
+
+**This is identical for `-o json` and summary output.** Adding `-o json` to get machine-readable output does not change the exit code, so a CI job can rely on it in either mode.
+
+```bash
+xano workflow_test run_all -o json || echo "tests failed or the command errored"
+```
+
+**One asymmetry worth knowing about.** In `run`, a non-2xx response from the run endpoint is a CLI error and exits `2`. In `run_all`, a non-2xx response for an *individual* test is recorded as a failed test result with an `API error <status>` message and contributes to exit `1` — because `run_all`'s job is to finish the batch and report a roll-up rather than abort on one test's transport error. Exit `2` in `run_all` is reserved for failures that stop the batch from starting at all.
+
+If you need to tell a backend outage apart from a genuine assertion failure, the exit code alone will not do it — inspect `results[].message` for the `API error` prefix:
+
+```bash
+xano workflow_test run_all -o json | jq '[.results[] | select(.message // "" | startswith("API error"))] | length'
+```
+
+#### JSON output
+
+`run` returns the API's result object unchanged. Treat **any** `status` other than `"ok"` as a failure — several distinct non-`ok` values are returned in practice, so match on "not `ok`" rather than enumerating known failure values:
+
+```json
+{ "status": "exception", "timing": 0.02, "message": "Precondition failed." }
+```
+
+`run_all` returns a roll-up. A branch with no tests is a normal state — freshly created branches routinely have none — and still emits valid JSON rather than plain text, so `JSON.parse` is always safe:
+
+```json
+{ "passed": 0, "failed": 0, "results": [], "total_timing": 0 }
+```
+
+The `total_timing` field is currently emitted by `workflow_test run_all` only; the `unit_test`, `tenant`, and `sandbox` variants omit it. The empty-suite envelope always carries the same keys as that command's populated envelope.
+
+> **Changed in this release:** a failing `run` in summary mode previously exited `2` and printed a spurious `EEXIT: 1` line; it now exits `1` with clean output. A failing `run` with `-o json` previously exited `0`, which silently hid failures from CI. If you match on exit code `2` specifically to detect test failures, switch to a non-zero check.
+
 ### Tenants
 
 Manage tenants, their environment variables, backups, deployments, and clusters.
@@ -652,64 +694,6 @@ xano tenant cluster license set <cluster_id>
 xano tenant cluster license set <cluster_id> --file ./kubeconfig.yaml
 ```
 
-### Ephemeral Tenants
-
-Manage ephemeral tenants — short-lived, auto-expiring tenants scoped to a workspace (default TTL 1h, max 72h). Unlike a sandbox, an ephemeral tenant requires a workspace.
-
-```bash
-# List ephemeral tenants in the current workspace
-xano ephemeral list
-xano ephemeral list -w 5
-
-# List ephemeral tenants across every workspace you can access
-xano ephemeral list --global
-
-# Create an ephemeral tenant (workspace required)
-xano ephemeral create "PR preview"
-xano ephemeral create "Demo" --expires-hours 24 -w 5
-xano ephemeral create "Load test" -d "48h soak" --expires-hours 48
-
-# Get / edit / delete
-xano ephemeral get <tenant_name>
-xano ephemeral edit <tenant_name> --display "New Name" -d "New description"
-xano ephemeral delete <tenant_name> --force
-
-# Pull to / push from local files (multidoc)
-xano ephemeral pull <tenant_name> -d ./my-ephemeral
-xano ephemeral push <tenant_name> -d ./my-ephemeral --dry-run   # preview first
-xano ephemeral push <tenant_name> -d ./my-ephemeral
-
-# Open in the browser (or print the URL)
-xano ephemeral impersonate <tenant_name>
-xano ephemeral impersonate <tenant_name> --url-only
-xano ephemeral impersonate <tenant_name> --guest       # read-only session (browse only)
-```
-
-#### Static hosting for an ephemeral tenant
-
-An ephemeral tenant can host static sites, scoped to that tenant. These commands mirror
-`xano static_host *` but take the tenant name as the first argument (the tenant's static
-hosting is isolated inside the tenant's own database).
-
-```bash
-# List / create / inspect a tenant's static hosts
-xano ephemeral static_host list <tenant_name>
-xano ephemeral static_host create <tenant_name> --name marketing --description "Marketing site"
-xano ephemeral static_host get <tenant_name> -H marketing
-xano ephemeral static_host edit <tenant_name> -H marketing --description "Updated"
-
-# Builds: push a directory, list, inspect, deploy to an env, pull, delete
-xano ephemeral static_host build push <tenant_name> -H default -f ./site
-xano ephemeral static_host build list <tenant_name> -H default
-xano ephemeral static_host build get <tenant_name> -H default --build_id 52
-xano ephemeral static_host deploy <tenant_name> -H default --build_id 52 --env prod
-xano ephemeral static_host build pull <tenant_name> -H default --latest
-xano ephemeral static_host build delete <tenant_name> -H default --build_id 52
-```
-
-> Static hosting is currently available for **local** tenants. Remote (tier2/tier3)
-> tenants are not yet supported and will return an error.
-
 ### Sandbox
 
 Manage your sandbox tenant. Each user has a single sandbox tenant that is auto-provisioned on first use.

package/dist/base-command.d.ts

@@ -117,7 +117,6 @@ export default abstract class BaseCommand extends Command {
     protected logStaticHostUrls(opts: {
         profile: ProfileConfig;
         staticHost: string;
-        tenantName?: string;
         verbose: boolean;
         workspaceId: string;
     }): Promise<void>;
@@ -127,7 +126,6 @@ export default abstract class BaseCommand extends Command {
         profile: ProfileConfig;
         quiet?: boolean;
         staticHost: string;
-        tenantName?: string;
         timeoutMs?: number;
         verbose: boolean;
         workspaceId: string;

package/dist/base-command.js

@@ -370,11 +370,8 @@ export default class BaseCommand extends Command {
      * Returns the final status. Resolves to the last-seen status on timeout.
      */
     async logStaticHostUrls(opts) {
-        const { profile, staticHost, tenantName, verbose, workspaceId } = opts;
-        // When a tenant is scoped, target the tenant's static hosting; otherwise the
-        // workspace-level static host (default, unchanged behavior).
-        const scope = tenantName ? `/tenant/${tenantName}` : '';
-        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}${scope}/static_host/${staticHost}`;
+        const { profile, staticHost, verbose, workspaceId } = opts;
+        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${staticHost}`;
         try {
             const response = await this.verboseFetch(url, {
                 headers: { accept: 'application/json', Authorization: `Bearer ${profile.access_token}` },
@@ -397,14 +394,11 @@ export default class BaseCommand extends Command {
         }
     }
     async waitForBuild(opts) {
-        const { buildId, profile, quiet, staticHost, tenantName, verbose, workspaceId } = opts;
+        const { buildId, profile, quiet, staticHost, verbose, workspaceId } = opts;
         const intervalMs = opts.intervalMs ?? 2000;
         const timeoutMs = opts.timeoutMs ?? 600_000; // 10 min
         const terminal = new Set(['error', 'ok']);
-        // When a tenant is scoped, target the tenant's static hosting; otherwise the
-        // workspace-level static host (default, unchanged behavior).
-        const scope = tenantName ? `/tenant/${tenantName}` : '';
-        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}${scope}/static_host/${staticHost}/build/${buildId}`;
+        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${staticHost}/build/${buildId}`;
         // Spinner only on an interactive TTY and when not emitting JSON. Verbose mode
         // also disables it (the spinner would interleave with request/response logs).
         const animate = Boolean(process.stdout.isTTY) && !quiet && !verbose;

package/dist/commands/release/pull/index.d.ts

@@ -14,4 +14,10 @@ export default class ReleasePull extends BaseCommand {
     };
     run(): Promise<void>;
     private resolveReleaseName;
+    /**
+     * Sanitize a document name for use as a filename.
+     * Strips quotes, replaces spaces with underscores, and removes
+     * characters that are unsafe in filenames.
+     */
+    private sanitizeFilename;
 }

package/dist/commands/release/pull/index.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
-import { buildApiGroupFolderResolver, buildChannelServerResolver, parseDocument, resolveDocumentPath, } from '../../../utils/document-parser.js';
+import { buildApiGroupFolderResolver, parseDocument } from '../../../utils/document-parser.js';
 export default class ReleasePull extends BaseCommand {
     static description = 'Pull a release multidoc from the Xano Metadata API and split into individual files';
     static examples = [
@@ -123,19 +123,96 @@ Pulled 58 documents from release 'v1.0'
         fs.mkdirSync(outputDir, { recursive: true });
         // Resolve api_group names to unique folder names, disambiguating collisions
         const getApiGroupFolder = buildApiGroupFolderResolver(documents, snakeCase);
-        // Resolve a realtime v2 channel path -> owning realtime_server name, so
-        // messages can nest under their channel's server (see resolver docs).
-        const getChannelServer = buildChannelServerResolver(documents);
         // Track filenames per type to handle duplicates
         const filenameCounters = new Map();
         let writtenCount = 0;
         for (const doc of documents) {
-            const { baseName, typeDir } = resolveDocumentPath(doc, outputDir, {
-                getApiGroupFolder,
-                getChannelServer,
-                join: path.join,
-                snakeCase,
-            });
+            let typeDir;
+            let baseName;
+            if (doc.type === 'workspace') {
+                // workspace → workspace/{name}.xs
+                typeDir = path.join(outputDir, 'workspace');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'workspace_trigger') {
+                // workspace_trigger → workspace/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'workspace', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'error_trigger') {
+                // error_trigger → workspace/trigger/{name}.xs (singleton, colocated with workspace triggers)
+                typeDir = path.join(outputDir, 'workspace', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'agent') {
+                // agent → ai/agent/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'agent');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'mcp_server') {
+                // mcp_server → ai/mcp_server/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'mcp_server');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'tool') {
+                // tool → ai/tool/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'tool');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'agent_trigger') {
+                // agent_trigger → ai/agent/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'agent', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'mcp_server_trigger') {
+                // mcp_server_trigger → ai/mcp_server/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'mcp_server', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'table_trigger') {
+                // table_trigger → table/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'table', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'realtime_channel') {
+                // realtime_channel → realtime/channel/{name}.xs
+                typeDir = path.join(outputDir, 'realtime', 'channel');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'realtime_trigger') {
+                // realtime_trigger → realtime/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'realtime', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'api_group') {
+                // api_group "test" → api/{resolved_folder}/{name}.xs
+                const groupFolder = getApiGroupFolder(doc.name);
+                typeDir = path.join(outputDir, 'api', groupFolder);
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'query' && doc.apiGroup) {
+                // query in group "test" → api/{resolved_folder}/{query_name}.xs
+                const groupFolder = getApiGroupFolder(doc.apiGroup);
+                const nameParts = doc.name.split('/');
+                const leafName = nameParts.pop();
+                const folderParts = nameParts.map((part) => snakeCase(part));
+                typeDir = path.join(outputDir, 'api', groupFolder, ...folderParts);
+                baseName = this.sanitizeFilename(leafName);
+                if (doc.verb) {
+                    baseName = `${baseName}_${doc.verb}`;
+                }
+            }
+            else {
+                // Default: split folder path from name
+                const nameParts = doc.name.split('/');
+                const leafName = nameParts.pop();
+                const folderParts = nameParts.map((part) => snakeCase(part));
+                typeDir = path.join(outputDir, doc.type, ...folderParts);
+                baseName = this.sanitizeFilename(leafName);
+                if (doc.verb) {
+                    baseName = `${baseName}_${doc.verb}`;
+                }
+            }
             fs.mkdirSync(typeDir, { recursive: true });
             // Track duplicates per directory
             const dirKey = path.relative(outputDir, typeDir);
@@ -180,4 +257,12 @@ Pulled 58 documents from release 'v1.0'
         }
         return match.id;
     }
+    /**
+     * Sanitize a document name for use as a filename.
+     * Strips quotes, replaces spaces with underscores, and removes
+     * characters that are unsafe in filenames.
+     */
+    sanitizeFilename(name) {
+        return snakeCase(name.replaceAll('"', ''));
+    }
 }

package/dist/commands/sandbox/pull/index.d.ts

@@ -12,4 +12,5 @@ export default class SandboxPull extends BaseCommand {
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private sanitizeFilename;
 }

package/dist/commands/sandbox/pull/index.js

@@ -1,7 +1,7 @@
 import { Flags } from '@oclif/core';
 import snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
-import { buildApiGroupFolderResolver, buildChannelServerResolver, parseDocument, resolveDocumentPath, } from '../../../utils/document-parser.js';
+import { buildApiGroupFolderResolver, parseDocument } from '../../../utils/document-parser.js';
 import { fetchKnowledge, writeKnowledge } from '../../../utils/knowledge-sync.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -92,18 +92,82 @@ Pulled 42 documents from sandbox environment to ./my-sandbox
         const outputDir = path.resolve(flags.directory);
         fs.mkdirSync(outputDir, { recursive: true });
         const getApiGroupFolder = buildApiGroupFolderResolver(documents, snakeCase);
-        // Resolve a realtime v2 channel path -> owning realtime_server name, so
-        // messages can nest under their channel's server (see resolver docs).
-        const getChannelServer = buildChannelServerResolver(documents);
         const filenameCounters = new Map();
         let writtenCount = 0;
         for (const doc of documents) {
-            const { baseName, typeDir } = resolveDocumentPath(doc, outputDir, {
-                getApiGroupFolder,
-                getChannelServer,
-                join: path.join,
-                snakeCase,
-            });
+            let typeDir;
+            let baseName;
+            if (doc.type === 'workspace') {
+                typeDir = path.join(outputDir, 'workspace');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'workspace_trigger') {
+                typeDir = path.join(outputDir, 'workspace', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'error_trigger') {
+                // error_trigger → workspace/trigger/{name}.xs (singleton, colocated with workspace triggers)
+                typeDir = path.join(outputDir, 'workspace', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'agent') {
+                typeDir = path.join(outputDir, 'ai', 'agent');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'mcp_server') {
+                typeDir = path.join(outputDir, 'ai', 'mcp_server');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'tool') {
+                typeDir = path.join(outputDir, 'ai', 'tool');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'agent_trigger') {
+                typeDir = path.join(outputDir, 'ai', 'agent', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'mcp_server_trigger') {
+                typeDir = path.join(outputDir, 'ai', 'mcp_server', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'table_trigger') {
+                typeDir = path.join(outputDir, 'table', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'realtime_channel') {
+                typeDir = path.join(outputDir, 'realtime', 'channel');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'realtime_trigger') {
+                typeDir = path.join(outputDir, 'realtime', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'api_group') {
+                const groupFolder = getApiGroupFolder(doc.name);
+                typeDir = path.join(outputDir, 'api', groupFolder);
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'query' && doc.apiGroup) {
+                const groupFolder = getApiGroupFolder(doc.apiGroup);
+                const nameParts = doc.name.split('/');
+                const leafName = nameParts.pop();
+                const folderParts = nameParts.map((part) => snakeCase(part));
+                typeDir = path.join(outputDir, 'api', groupFolder, ...folderParts);
+                baseName = this.sanitizeFilename(leafName);
+                if (doc.verb) {
+                    baseName = `${baseName}_${doc.verb}`;
+                }
+            }
+            else {
+                const nameParts = doc.name.split('/');
+                const leafName = nameParts.pop();
+                const folderParts = nameParts.map((part) => snakeCase(part));
+                typeDir = path.join(outputDir, doc.type, ...folderParts);
+                baseName = this.sanitizeFilename(leafName);
+                if (doc.verb) {
+                    baseName = `${baseName}_${doc.verb}`;
+                }
+            }
             fs.mkdirSync(typeDir, { recursive: true });
             const dirKey = path.relative(outputDir, typeDir);
             if (!filenameCounters.has(dirKey)) {
@@ -130,4 +194,7 @@ Pulled 42 documents from sandbox environment to ./my-sandbox
             parts.push(`${knowledgeCount} knowledge file${knowledgeCount === 1 ? '' : 's'}`);
         this.log(`Pulled ${parts.join(' + ')} from sandbox environment to ${flags.directory}`);
     }
+    sanitizeFilename(name) {
+        return snakeCase(name.replaceAll('"', ''));
+    }
 }

package/dist/commands/sandbox/unit_test/run/index.js

@@ -46,24 +46,30 @@ Result: PASS
                 this.error(message);
             }
             const result = (await response.json());
+            // Anything other than 'ok' is a failure -- the API has been observed
+            // returning several distinct non-ok statuses, so never enumerate them.
+            const passed = result.status === 'ok';
             if (flags.output === 'json') {
                 this.log(JSON.stringify(result, null, 2));
             }
+            else if (passed) {
+                this.log('Result: PASS');
+            }
             else {
-                if (result.status === 'ok') {
-                    this.log('Result: PASS');
-                }
-                else {
-                    this.log('Result: FAIL');
-                    const failedExpects = result.results?.filter((r) => r.status === 'fail') ?? [];
-                    for (const expect of failedExpects) {
-                        if (expect.message) {
-                            this.log(`  Error: ${expect.message}`);
-                        }
+                this.log('Result: FAIL');
+                const failedExpects = result.results?.filter((r) => r.status === 'fail') ?? [];
+                for (const expect of failedExpects) {
+                    if (expect.message) {
+                        this.log(`  Error: ${expect.message}`);
                     }
-                    this.exit(1);
                 }
             }
+            // Set the code rather than throwing via this.exit(): the exit must apply
+            // in both output modes, and process.exitCode cannot be swallowed by the
+            // surrounding catch. Mirrors what run_all already does.
+            if (!passed) {
+                process.exitCode = 1;
+            }
         }
         catch (error) {
             if (error instanceof Error && 'oclif' in error)

package/dist/commands/sandbox/unit_test/run_all/index.js

@@ -78,7 +78,15 @@ Results: 4 passed, 1 failed
                 },
             });
             if (tests.length === 0) {
-                this.log('No unit tests found');
+                // An empty suite is a normal state (fresh branches have no tests) and
+                // is a success, not a failure. Under -o json it must still be parseable,
+                // with the same keys the populated path emits below.
+                if (flags.output === 'json') {
+                    this.log(JSON.stringify({ failed: 0, passed: 0, results: [] }, null, 2));
+                }
+                else {
+                    this.log('No unit tests found');
+                }
                 return;
             }
             if (flags.output === 'summary') {

package/dist/commands/sandbox/workflow_test/run/index.js

@@ -46,22 +46,25 @@ Result: PASS (0.25s)
                 this.error(message);
             }
             const result = (await response.json());
+            // Anything other than 'ok' is a failure -- the API has been observed
+            // returning several distinct non-ok statuses, so never enumerate them.
+            const passed = result.status === 'ok';
             if (flags.output === 'json') {
                 this.log(JSON.stringify(result, null, 2));
             }
             else {
                 const timing = result.timing ? ` (${result.timing}s)` : '';
-                if (result.status === 'ok') {
-                    this.log(`Result: PASS${timing}`);
-                }
-                else {
-                    this.log(`Result: FAIL${timing}`);
-                    if (result.message) {
-                        this.log(`  Error: ${result.message}`);
-                    }
-                    this.exit(1);
+                this.log(`Result: ${passed ? 'PASS' : 'FAIL'}${timing}`);
+                if (!passed && result.message) {
+                    this.log(`  Error: ${result.message}`);
                 }
             }
+            // Set the code rather than throwing via this.exit(): the exit must apply
+            // in both output modes, and process.exitCode cannot be swallowed by the
+            // surrounding catch. Mirrors what run_all already does.
+            if (!passed) {
+                process.exitCode = 1;
+            }
         }
         catch (error) {
             if (error instanceof Error && 'oclif' in error)

package/dist/commands/sandbox/workflow_test/run_all/index.js

@@ -71,7 +71,15 @@ Results: 2 passed, 1 failed
                 },
             });
             if (tests.length === 0) {
-                this.log('No workflow tests found');
+                // An empty suite is a normal state (fresh branches have no tests) and
+                // is a success, not a failure. Under -o json it must still be parseable,
+                // with the same keys the populated path emits below.
+                if (flags.output === 'json') {
+                    this.log(JSON.stringify({ failed: 0, passed: 0, results: [] }, null, 2));
+                }
+                else {
+                    this.log('No workflow tests found');
+                }
                 return;
             }
             if (flags.output === 'summary') {

package/dist/commands/tenant/pull/index.d.ts

@@ -14,4 +14,10 @@ export default class Pull extends BaseCommand {
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /**
+     * Sanitize a document name for use as a filename.
+     * Strips quotes, replaces spaces with underscores, and removes
+     * characters that are unsafe in filenames.
+     */
+    private sanitizeFilename;
 }