@usestatemachines/cli 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 State
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# State Machines CLI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The State Machines CLI signs you in, links a repository to a workspace, and manages environments through the State Machines API.
+Programs receive workspace API keys through `run` or `env pull`. The account token stays inside the CLI.
+
+```sh
+statemachines login
+statemachines init --agent claude
+statemachines run -- npm test
+```
+
+Plain `init` links the repository and installs the selected agent skill. Add `--sdk` to install the SDK, `--quickstart` to write the example, or `--env` to pull a workspace key into `.env.local`.
+Run `statemachines help --json` for command schemas, flags, errors, and exit codes.
+
+Without an interactive terminal, commands return JSON and never prompt. Use `--workspace` to select a workspace and `--yes` to confirm a destructive command.
+For agent sign-in, run `login --no-wait --json`, show the user its URL and code, then run `login --resume --json` after approval.
+
+Approve only a login you started. A matching code does not identify the requesting computer.
+`logout` revokes the account token and its workspace keys. Offline revocations stay pending until the API is reachable.
+
+The package manifest defines the Node requirement and exact SDK dependency.
+The installed package includes its API contracts and agent instructions. It does not require the management API source or monorepo templates.
+
+## Credential storage
+
+`statemachines login` saves the CLI token in the system keychain. If the keychain write fails, the CLI saves the token in `credentials.json` in its configuration directory and prints a warning. Cancellation never falls back to the file. Other Node programs you run may read a macOS keychain item created by Node.
+
+To choose the store yourself, set `STATEMACHINES_CREDENTIAL_STORE`:
+
+- `file` saves credentials in `credentials.json` and never uses the keychain. Use it over SSH and on machines without a keychain service.
+- `keychain` saves credentials only in the keychain, and a keychain failure stops the command.
+
+## Update notices
+
+In an interactive terminal, the CLI checks npm for a newer version and prints a notice on stderr when one exists. To turn the notice off, set `STATEMACHINES_NO_UPDATE_NOTIFIER=1` or set `NO_UPDATE_NOTIFIER` to any value. The CLI never checks in CI, from `npx`, or when an agent runs it.

package/dist/agents/bundled.d.ts

@@ -0,0 +1,5 @@
+export declare const prompt: string;
+export declare const llmsTxt: string;
+export declare const skill: string;
+export declare const quickstart: string;
+export declare const cliCommand: string;

package/dist/agents/bundled.js

@@ -0,0 +1,6 @@
+// Generated by scripts/build-agents.mjs from the SDK agent templates.
+export const prompt = "Install the State Machines skill in this existing repository so I can use disposable app environments with my coding agent.\n\n1. Read the repository instructions. Run `npx @usestatemachines/cli@0.1.0 init --agent <this-agent> --yes`, using this agent's supported name from `npx @usestatemachines/cli@0.1.0 init --help`. If sign-in is required, ask for my agreement, then run `npx @usestatemachines/cli@0.1.0 login --no-wait --json`. Show the URL and code, wait for my approval, then run `npx @usestatemachines/cli@0.1.0 login --resume --json` and retry the same init command. If more than one workspace is available, ask which to use and pass `--workspace <workspace-id>`. If this agent cannot run commands or has no supported destination, download https://docs.usestatemachines.com/skill.md and install `state-machines/SKILL.md` in its supported project skills directory. Preserve a different installed copy. If persistent skills are unsupported, read the skill for this session and explain the limitation. Report a failed download or installation.\n2. Read the skill. Do not create a new project, install the SDK, write example code, change an integration or create remote resources during skill installation. Keep the repository's existing conventions.\n3. Reuse the project's existing `STATEMACHINES_API_KEY` loader when present. Otherwise, use the skill's CLI sign-in steps after I agree to sign in. Never ask me to paste a credential into chat, print it, or commit it.\n4. Report where the skill was installed and whether the agent needs to reload it. Skill installation alone does not verify an API connection. Ask: \"What would you like to run or test?\" Wait for my answer before making further changes.\n";
+export const llmsTxt = "# State Machines\n\n> State Machines runs disposable environments of replica SaaS apps, such as Salesforce, for tests and coding agents. Create, connect to, and delete them with the TypeScript SDK `@usestatemachines/sdk`.\n\nUse the project's package manager to install or reuse `@usestatemachines/sdk`. It is ESM only and runs on Node.js and Cloudflare Workers, not browsers. `engines` in its `package.json` gives the Node.js versions. TypeScript needs `lib: [\"DOM\"]` or `@types/node`. `new StateMachines()` reads the API key from `STATEMACHINES_API_KEY` and doesn't read `.env` files; in Cloudflare Workers, pass `apiKey` explicitly. Never print the key. The installed `node_modules/@usestatemachines/sdk/README.md` matches your version: read it before relying on memory. Read the bundled `agents/SKILL.md` for the task workflow. Reuse the project's secret loader and check the key in the process that runs the test, not just the current shell. Installing the skill does not require SDK installation, example files or remote resources. Ask what the user wants to run and wait. Install the SDK and verify access when their chosen task needs it. Run the connection check below only if the user asks to verify the connection. Do not choose a business workflow from the repository.\n\n## Get a credential\n\nIf the project's existing command loads `STATEMACHINES_API_KEY`, reuse that command and secret loader. Otherwise, run `npx @usestatemachines/cli@0.1.0 whoami --json`. If it succeeds, use the workspace commands below. If it exits with code 3, ask the user to sign in. Only after the user agrees, start `npx @usestatemachines/cli@0.1.0 login --no-wait --json`, show its `verificationUrl` and `userCode`, and wait for approval. A matching code does not identify the requesting computer. After that approval, run `npx @usestatemachines/cli@0.1.0 login --resume --json` with the same profile to finish that attempt.\n\nFor `cli.not_linked`, run `npx @usestatemachines/cli@0.1.0 workspaces list --json`. Ask which workspace to use when there is more than one, then run `npx @usestatemachines/cli@0.1.0 link --workspace <workspace-id> --json`. Run the user's existing code with `npx @usestatemachines/cli@0.1.0 run -- <command>`. Never print or commit a credential.\n\n## CLI commands\n\nPrefix these commands with `npx @usestatemachines/cli@0.1.0`. Use `help --json` for flags and result schemas:\n\n- `login`, `logout`, `whoami`, `profiles list`, and `profiles use`\n- `workspaces list`, `workspaces use`, `link`, `unlink`, and `init`\n- `apps list`, `environments create`, `environments list`, `environments get`, `environments wait`, and `environments delete`\n- `connect`, `snapshots create`, `snapshots list`, `snapshots get`, `snapshots delete`, `requests list`, and `requests get`\n- `run -- <command>`, `env pull`, `api`, `doctor`, `version`, `help`, and `completion`\n\n## Concepts\n\n- Environment: one disposable run of one or more apps. `const env = await sm.environments.create({ apps: ['salesforce'] })` creates it and waits until it is `running`. Use `{ wait: false }` to retain the ID before startup. Wait for `running` inside `try`, then delete the owned environment in `finally`, including after a wait failure.\n- Apps: a string names the app by its ID, and the app's name in the environment is the same string. Use `{ appId: 'salesforce', name: 'crm', setup }` for your own name, for two copies of one app, or for the app's setup. Later calls take the name.\n- Credentials: `const crm = await env.connect('salesforce')` returns `token`, `services` and `fetch`. Each service has an `id`, a `url` and the `headers` its requests need. The credentials always list each `public` service of the app's version. Pass `{ services: [id] }` to `connect()` to also list a service by its ID. A `preview` service is listed only when named. `crm.service('api')` returns the `api` service, which is the app URL. `crm.fetch(path)` joins `path` to the `api` service URL and adds its headers, which carry `Authorization: Bearer` with `token`. For Salesforce SOAP, also put `crm.token` in the envelope's `SessionHeader/sessionId`. `fetch` never sends your API key, never follows redirects and never retries. `token` and each service's `headers` are secrets.\n- Actor: one of the app's users; requests run with that user's permissions. `connect()` acts as the app's default actor (for Salesforce, the administrator) unless you pass `actorId`. Salesforce actor IDs are its user IDs, such as `005…`. Find the app by name in `env.apps`, then page through `sm.apps.versions(appId)` to find its exact `versionId`. Read actor IDs from that version's `actors`.\n- Snapshot: the saved data of every app of a running environment, taken at one moment. `await env.snapshots.create({ name: 'seeded' })` waits until it is `ready`. `sm.environments.create({ snapshotId })` creates a new environment from it, in place of `apps`; each app keeps its name and version. A delete during the snapshot fails it with `interrupted`.\n- Recorded requests: `sm.requests.list({ environmentId })` pages the calls made to the environment's apps. `sm.requests.get(id)` adds headers and a preview of each body. `sm.requests.body(id, 'request')` or `'response'` returns the full body as bytes. Recording is best effort.\n- YAML: `parseEnvironmentYaml(text)` turns a YAML document with the fields of `create` into its input.\n- Pagination: every `list` returns one page, `{ data, nextCursor }`. Pass `nextCursor` back as `cursor` until it is `null`.\n\n## Statuses\n\nEnums are open: handle values you don't recognise.\n\n- Environment `status`: `starting`, `running`, `failed`, `deleted`. A `deleted` environment has a `reason` when State Machines deleted it: `expired`, `failed` (it never reached `running`) or `cancelled` (staff ended it). The `reason` is `null` when a caller deleted it. When the environment failed, `failure` is `{ appName, code, message }`, and `code` is `start_failed`, `pause_removed`, `version_unavailable`, `invalid_setup` or `invalid_services`. For `invalid_setup` and `invalid_services`, the app refused a value in `setup` or in `services`, and `message` starts with its path.\n- Snapshot `status`: `saving`, `ready`, `failed`, `deleted`. A failed snapshot has `failure.code` `interrupted` or `internal_error`.\n- `create` throws `EnvironmentFailedError` when the environment fails, `UnexpectedStatusError` when it becomes `deleted` for another reason, and `WaitTimeoutError` when `timeoutMs` passes.\n- `snapshots.create` throws `SnapshotFailedError` when the snapshot fails and `UnexpectedStatusError` when it was deleted.\n- `sm.environments.wait(id, { status })` and `sm.snapshots.wait(id, { status })` wait for any status, and throw once it cannot be reached without another call.\n\n## Limits\n\nWhen `sm.me().limits` is non-null:\n\n- Running environments are capped per organization: `(await sm.me()).limits.concurrentEnvironments` counts `starting` and `running`.\n- `timeLimitMinutes` has a default and a maximum: `(await sm.me()).limits.timeLimitMinutes`. It counts `starting` and `running` only; at the end the environment is deleted with `reason: 'expired'`.\n\n## Errors and retries\n\nA failed API call throws `StateMachinesError` with `status`, `code`, `message`, `requestId`, `fields` and `retryAfterMs`. The SDK retries `502`, `503`, `504` and connection errors itself, until a deadline; `create` retries reuse one idempotency key. It retries nothing else.\n\n| Code | Status | What to do |\n| --- | --- | --- |\n| `invalid_request` | 400 | Read `fields`, keyed by the dotted path of each wrong field. |\n| `forbidden` | 403 | The key lacks the permission. |\n| `not_found` | 404 | Check the ID and the workspace. |\n| `invalid_status` | 409 | The status does not allow the call. Snapshots need a running environment. |\n| `snapshot_in_progress` | 409 | Wait for the running snapshot, then create another. |\n| `idempotency_key_reused` | 409 | The key was used with a different input. Replay with the exact same input. |\n| `workspace_archived` | 409 | The workspace is archived. |\n| `body_too_large` | 413 | The request body is over the API's size limit. Send less. |\n| `version_unavailable` | 422 | The app has no default version. |\n| `environment_limit_reached` | 429 | Delete only this task’s known leftovers, or ask the user to free capacity. |\n| `unavailable` | 503 | Retried automatically. If `create` still has an unknown outcome, replay the same input with the key retained before the original call. Do not generate a new key. |\n\n## Errors from the app URL\n\n`crm.fetch` returns these as responses with the same JSON envelope, and never retries them. Assert the expected status and result. For writes, read back the stored result. Never blindly retry a write whose outcome is unknown.\n\n| Code | Status | What to do |\n| --- | --- | --- |\n| `environment_not_running` | 409 | The environment is failed or deleted; `error.status` names it. Create another environment. |\n| `environment_starting` | 503 | For reads, wait `Retry-After` and retry. Check stored state before retrying an uncertain write. |\n| `environment_unavailable` | 503 | The app is restarting. For reads, wait `Retry-After`. Check stored state before retrying an uncertain write. |\n| `response_too_large` | 502 | The response is over the size limit. Ask for less, for example with a smaller page. |\n| `invalid_setup` | 503 | The app refused its `setup` after the environment started, such as in a newer version. `error.message` starts with the path of the value. Create another environment with a `setup` that the app accepts. |\n| `invalid_services` | 503 | The app refused a value in `services` after the environment started. `error.message` starts with the path of the value. Create another environment with `services` that the app accepts. |\n| `unsupported_protocol` | 501 | The app does not serve this path, method or content type, or the request body is compressed. |\n\n## Quickstart\n\nUse the project's TypeScript runner with its secret loader, or pass that runner through `npx @usestatemachines/cli@0.1.0 run -- <command>`. For an empty Node.js project, save as `state-quickstart.mts` and run `npx @usestatemachines/cli@0.1.0 run -- npx tsx state-quickstart.mts`. The check prints the response status and deletes the environment. Only after it prints `200`, report verified setup and the rerun command. Continue only with an explicitly supplied task. Otherwise, ask what to run next and wait with no setup environment left running.\n\n```ts\nimport { StateMachines } from '@usestatemachines/sdk';\n\nconst sm = new StateMachines(); // reads STATEMACHINES_API_KEY\nconst env = await sm.environments.create(\n  { apps: ['salesforce'] },\n  { wait: false },\n);\n\ntry {\n  await sm.environments.wait(env.id, { status: 'running' });\n  const salesforce = await env.connect('salesforce');\n  const res = await salesforce.fetch('/services/data/v67.0/limits');\n  console.log(res.status, await res.json());\n} finally {\n  await env.delete();\n}\n```\n\n## Docs\n\n- [Documentation](https://docs.usestatemachines.com): guides, concepts and reference ([llms.txt](https://docs.usestatemachines.com/llms.txt))\n- [npm package](https://www.npmjs.com/package/@usestatemachines/sdk): install, README and versions\n- [Agent skill](https://docs.usestatemachines.com/skill.md): workflow, rules and troubleshooting for coding agents\n- [OpenAPI document](https://cdn.jsdelivr.net/npm/@usestatemachines/sdk/openapi.json): the HTTP API the SDK calls\n- [State Machines](https://usestatemachines.com): website\n";
+export const skill = "---\nname: state-machines\ndescription: Use when setting up State Machines or running code, integration tests, or API experiments against disposable SaaS replicas such as Salesforce. Applies to @usestatemachines/sdk and STATEMACHINES_API_KEY, including environment creation, actors, snapshots, cleanup and recovery.\n---\n\n## Start with the user's task\n\nDuring skill installation, read the repository instructions and preserve its existing structure. Do not create a new project, install dependencies, write examples or create remote resources. Report the installed skill location and any reload requirement, then ask \"What would you like to run or test?\" and wait. Skill installation does not verify a connection.\n\nOnce the user chooses a task, inspect the project's package manager, runtime, runner and secret loader. Install or reuse a compatible `@usestatemachines/sdk` only when the task needs it. Read the installed README for API signatures and `package.json` for runtime requirements. The SDK is ESM and runs on Node.js and Cloudflare Workers, not in a browser. Follow the user's task and existing project conventions without requiring a separate onboarding example.\n\n## Get a credential\n\nThe SDK reads `STATEMACHINES_API_KEY` from the process environment. It does not load `.env` files. Use the project's existing test command or secret loader. An empty variable in your current shell does not prove that the test process lacks it. Verify presence without displaying the value. In Workers, pass the binding explicitly with `new StateMachines({ apiKey: env.STATEMACHINES_API_KEY })`.\n\nIf the project's existing command loads `STATEMACHINES_API_KEY`, keep using that command and secret loader. Call `sm.me()` in that process to verify access and workspace scope. `me.limits` can be null.\n\nOtherwise, run `npx @usestatemachines/cli@0.1.0 whoami --json`. A successful result means you can use the workspace commands below. If it exits with code 3, ask the user to sign in. After the user agrees, complete this login:\n\n1. Run `npx @usestatemachines/cli@0.1.0 login --no-wait --json`.\n2. Show the returned `verificationUrl` and `userCode`. Ask the user to approve only the login you just started. A matching code does not identify the computer requesting access. Wait for the user to approve the login.\n3. After that approval, run `npx @usestatemachines/cli@0.1.0 login --resume --json` with the same profile used to start the login. Resume that attempt instead of starting another login.\n\nIf a command returns `cli.not_linked`, run `npx @usestatemachines/cli@0.1.0 workspaces list --json`. Ask the user which workspace to use when there is more than one. Run `npx @usestatemachines/cli@0.1.0 link --workspace <workspace-id> --json` with the selected ID.\n\nRun the user's existing command with `npx @usestatemachines/cli@0.1.0 run -- <command>`. The child receives a workspace key. The CLI keeps the credential out of its output.\n\nIf access is denied or the workspace differs from the task, report the blocker. Do not invite or remove members, or change permissions.\n\nNever print, log or commit API keys, `credentials.token`, the `headers` of `credentials.services`, environment dumps, or secret-file contents. Use synthetic test data.\n\n## Run the user’s chosen task\n\nApply this section after setup, once the user has chosen a task.\n\n- `sm.apps.list()` returns app IDs. Every list returns `{ data, nextCursor }`. Follow cursors until the required entry is found or `nextCursor` is null.\n- Create only the apps the task needs. A string such as `'salesforce'` is both its app ID and its name in the environment. For named apps, later `connect()` calls use the name.\n- `connect(appName)` uses the app's default actor, the Salesforce administrator. For another actor, find the matching app by name in `environment.apps`, read its `versionId`, then find that exact version through `sm.apps.versions(appId)`. Use an actor ID from its `actors`, never a role label, workspace member ID, or the first version in a list.\n- Check the app's services and [known differences](https://docs.usestatemachines.com/apps/known-differences.md) for the behavior under test. A replica does not import a customer's org or run arbitrary customer automation.\n- Configure the existing integration's test transport with the returned app URL and credentials. Verify its requests reach that URL. A successful standalone SDK request does not prove the integration uses the replica. If transport configuration needs a broader change, explain it before expanding the task.\n- Check the expected HTTP status and assert the result. For writes, read the stored data back and assert the relevant fields. For negative tests, assert the expected error. Do not weaken an assertion to make unsupported behavior pass.\n\n## Own the full lifecycle\n\nCreate with `{ wait: false }` to retain the accepted environment ID before waiting. Enter `try` immediately, then wait for `running`, connect and run the check inside it. Delete in `finally`, including after a startup failure, timeout or failed assertion. An aborted wait does not cancel the work that the API accepted. Cleanup must use a fresh, un-aborted signal. Preserve both verification and cleanup errors, and report the environment ID if deletion fails.\n\nDelete only environments created for this task. If the organization is at its limit, clean up a known leftover from this task or ask the user to free capacity. Do not delete unrelated environments or a user-supplied reusable snapshot.\n\nThe SDK retries management connection errors and `502`, `503`, `504` with one idempotency key per create call. To recover across separate attempts or a restart, retain the input and an explicit `idempotencyKey` before creation. Replay using the same input, key, workspace and caller. Do not create a replacement with a new key while the first outcome is unknown. See [operation recovery](https://docs.usestatemachines.com/sdk-api/recovery.md).\n\n## Optional connection check\n\nRun this only when the user asks to verify the connection. It proves the connection and cleanup, not an existing integration's behavior. Save it in the project's examples or test location. Use the existing TypeScript runner and secret loader, or pass that runner through `npx @usestatemachines/cli@0.1.0 run -- <command>`. For an empty Node.js project, save `state-quickstart.mts` and run `npx @usestatemachines/cli@0.1.0 run -- npx tsx state-quickstart.mts`.\n\n```ts\nimport { StateMachines } from '@usestatemachines/sdk';\n\nconst sm = new StateMachines(); // reads STATEMACHINES_API_KEY\nconst env = await sm.environments.create(\n  { apps: ['salesforce'] },\n  { wait: false },\n);\n\ntry {\n  await sm.environments.wait(env.id, { status: 'running' });\n  const salesforce = await env.connect('salesforce');\n  const res = await salesforce.fetch('/services/data/v67.0/limits');\n  console.log(res.status, await res.json());\n} finally {\n  await env.delete();\n}\n```\n\n## Load details when needed\n\n- **Repeated fixtures or parallel tests:** Read [isolated tests](https://docs.usestatemachines.com/sdk-api/testing.md). Save seeded data with `env.snapshots.create({ name })`, then create each test's environment with `{ snapshotId }`. A snapshot in `saving` cannot be deleted yet. Retain its ID and wait for `ready` or `failed` before cleanup. Delete a reusable snapshot only when the task calls for it.\n- **Another actor, vendor client or SOAP:** Read [credentials](https://docs.usestatemachines.com/environments/credentials.md). `credentials.fetch()` confines requests to the app URL, adds its authentication headers, and never follows redirects. External clients must send a service's `headers` only to its `url` and disable redirects. For Salesforce SOAP, put the actor token in `SessionHeader/sessionId` in the envelope.\n- **Cloudflare Workers:** Pass the key explicitly. Use `{ wait: false }` and keep the environment ID across requests or in the job's state. A request ending does not cancel startup. Follow the worker's background-job lifecycle for polling and cleanup.\n- **Long runs:** Read `sm.me().limits` when non-null. The environment time limit covers starting and running. Use a supported `timeLimitMinutes` when the task needs it.\n\n## Recover without changing the test's meaning\n\nManagement failures throw SDK errors. App HTTP failures are returned as `Response` objects. Use `instanceof` with the SDK error classes. Native `credentials.fetch()` never retries. Read the State Machines error code in `error.code` and distinguish it from an app's own error.\n\n| Failure | Next action |\n| --- | --- |\n| `invalid_request` | Read `err.fields` and the installed method signature. |\n| `version_unavailable` | Discover the app ID and available versions. Stop if the required version is unavailable. |\n| `environment_limit_reached` | Clean up only this task's known leftovers, or report the capacity blocker. |\n| `EnvironmentFailedError` | Read `err.environment.failure` and clean up the owned environment. |\n| `WaitTimeoutError` or abort | Use the retained environment ID. If older code waited inside `create`, a non-null `WaitTimeoutError.resource` carries its ID. If neither an ID nor a replay key is recoverable, report unresolved cleanup. Do not guess from a list. Wait again only if the task should continue. Otherwise delete the owned environment. |\n| Unknown create outcome | Replay the retained input and idempotency key. Do not start another operation with a new key. |\n| `invalid_status` | Read the current resource status before choosing the next call. |\n| `snapshot_in_progress` | Find the saving snapshot for this environment and wait for it before creating another. |\n| `SnapshotFailedError` | Report the failure. Retry only if the task still needs a snapshot and the source environment is running. |\n| App `environment_not_running` | Inspect the environment. Do not silently switch the integration to another target. |\n| App `invalid_setup` or `invalid_services` | The app refused a value of `setup` or `services` after the start. `error.message` starts with its path. Create another environment with a value that the app accepts, and delete the owned one. |\n| App or gateway `503` | For a retryable read, honor `Retry-After`. For a write with an uncertain outcome, inspect stored state or report uncertainty before retrying. |\n| Cleanup failure | Preserve the task result, report the owned resource ID and retry deletion with valid access and a fresh signal. Do not report cleanup as successful. |\n\n## Finish with evidence\n\nLeave the smallest rerunnable test or example. Report the behavior checked, command, assertion result, SDK and app versions, selected actor, resource IDs without secrets, and cleanup outcome. Say when execution was blocked or only typechecking ran. A passing replica check establishes the asserted behavior for that version and actor, not full production compatibility.\n\nFind other guides through https://docs.usestatemachines.com/llms.txt. Read focused pages before the full documentation bundle. This dashboard also serves an agent index at https://app.usestatemachines.com/llms.txt.\n";
+export const quickstart = "import { StateMachines } from '@usestatemachines/sdk';\n\nconst sm = new StateMachines(); // reads STATEMACHINES_API_KEY\nconst env = await sm.environments.create(\n  { apps: ['salesforce'] },\n  { wait: false },\n);\n\ntry {\n  await sm.environments.wait(env.id, { status: 'running' });\n  const salesforce = await env.connect('salesforce');\n  const res = await salesforce.fetch('/services/data/v67.0/limits');\n  console.log(res.status, await res.json());\n} finally {\n  await env.delete();\n}\n";
+export const cliCommand = 'npx @usestatemachines/cli@0.1.0';

package/dist/agents/destinations.d.ts

@@ -0,0 +1,13 @@
+export declare const agentDestinations: readonly [{
+    readonly id: 'claude';
+    readonly label: 'Claude Code';
+    readonly directory: '.claude';
+    readonly path: '.claude/skills/state-machines/SKILL.md';
+    readonly documentation: 'https://code.claude.com/docs/en/skills#choose-where-skills-load';
+}, {
+    readonly id: 'codex';
+    readonly label: 'Codex';
+    readonly directory: '.agents';
+    readonly path: '.agents/skills/state-machines/SKILL.md';
+    readonly documentation: 'https://learn.chatgpt.com/docs/build-skills#where-codex-loads-local-skills';
+}];

package/dist/agents/destinations.js

@@ -0,0 +1,16 @@
+export const agentDestinations = [
+    {
+        id: 'claude',
+        label: 'Claude Code',
+        directory: '.claude',
+        path: '.claude/skills/state-machines/SKILL.md',
+        documentation: 'https://code.claude.com/docs/en/skills#choose-where-skills-load',
+    },
+    {
+        id: 'codex',
+        label: 'Codex',
+        directory: '.agents',
+        path: '.agents/skills/state-machines/SKILL.md',
+        documentation: 'https://learn.chatgpt.com/docs/build-skills#where-codex-loads-local-skills',
+    },
+];

package/dist/api-internal.d.ts

@@ -0,0 +1,62 @@
+import type { RawHttpResponse } from './command.js';
+import type { ApiOrigin } from './context-types.js';
+import { type CliErrorCode } from './errors.js';
+import { parseCreateKey, parseKey, parseKeyList, parseKeyListQuery, parseLoginToken, parseStartedLogin, parseStartLogin, parseTokenList } from './generated/internal.js';
+import type { EffectOptions, Io } from './io-types.js';
+export declare const retryBudgetMs = 30000;
+export type StartLoginInput = ReturnType<typeof parseStartLogin>;
+export type StartedLogin = ReturnType<typeof parseStartedLogin>;
+export type PollResult = ({
+    readonly kind: 'approved';
+} & ReturnType<typeof parseLoginToken>) | {
+    readonly kind: 'pending' | 'slow-down';
+    readonly interval: number;
+} | {
+    readonly kind: 'denied' | 'expired';
+};
+export type CreatedKey = {
+    readonly kind: 'created';
+    readonly apiKey: ReturnType<typeof parseKey>;
+    readonly secret: string;
+} | {
+    readonly kind: 'replayed-without-secret';
+    readonly apiKey: ReturnType<typeof parseKey>;
+};
+export interface AnonymousApi {
+    start(input: StartLoginInput, options?: EffectOptions): Promise<StartedLogin>;
+    poll(deviceCode: string, options?: EffectOptions): Promise<PollResult>;
+    readiness(options?: EffectOptions): Promise<{
+        ready: boolean;
+    }>;
+}
+export interface AuthenticatedInternalApi {
+    collected(loginId: string, options?: EffectOptions): Promise<void>;
+    revokeCurrent(options?: EffectOptions): Promise<'revoked' | 'already-invalid'>;
+    listTokens(query?: {
+        cursor?: string;
+        limit?: number;
+    }, options?: EffectOptions): Promise<ReturnType<typeof parseTokenList>>;
+    listKeys(query: ReturnType<typeof parseKeyListQuery>, options?: EffectOptions): Promise<ReturnType<typeof parseKeyList>>;
+    createKey(input: ReturnType<typeof parseCreateKey>, idempotencyKey: string, options?: EffectOptions): Promise<CreatedKey>;
+    revokeKey(id: string, options?: EffectOptions): Promise<ReturnType<typeof parseKey>>;
+    raw(input: {
+        method: string;
+        path: string;
+        data: string | null;
+    }, options?: EffectOptions): Promise<RawHttpResponse>;
+}
+export interface ApiTransport {
+    readonly io: Io;
+    readonly fetch: typeof fetch;
+    readonly origin: ApiOrigin;
+    readonly options?: EffectOptions;
+}
+export declare function validateRawPath(path: string): string;
+export declare function checkEffect(io: Io, options: EffectOptions, expired?: CliErrorCode): void;
+export declare function withinDeadline<Value>(io: Io, options: EffectOptions, action: (signal: AbortSignal) => Promise<Value>, expired?: CliErrorCode): Promise<Value>;
+export declare function bufferResponse(response: Response): Promise<Response>;
+export declare function createSdkFetch(transport: ApiTransport & {
+    options: EffectOptions;
+}): typeof fetch;
+export declare function createAnonymousApi(transport: ApiTransport): AnonymousApi;
+export declare function createAuthenticatedApi(transport: ApiTransport, token: string): AuthenticatedInternalApi;

package/dist/api-internal.js

@@ -0,0 +1,348 @@
+import { StateMachinesError } from '@usestatemachines/sdk';
+import { z } from 'zod';
+import { CliError } from './errors.js';
+import { parseApiError, parseCollected, parseCreatedKey, parseCreateKey, parseKey, parseKeyList, parseKeyListQuery, parseLoginToken, parsePollError, parseStartedLogin, parseStartLogin, parseTokenList, } from './generated/internal.js';
+import { retryPolicy } from './generated/retry.js';
+export const retryBudgetMs = 30_000;
+export function validateRawPath(path) {
+    if (!path.startsWith('/v1/') || /[\\\s#]/.test(path)) {
+        throw new CliError('cli.path_refused');
+    }
+    let decoded = path.split('?')[0] ?? '';
+    for (let count = 0; count < 8; count++) {
+        if (/[\\\s?#]/.test(decoded) ||
+            decoded.includes('//') ||
+            decoded.split('/').some((part) => part === '.' || part === '..')) {
+            throw new CliError('cli.path_refused');
+        }
+        if (/^\/v1\/(?:cli(?:\/|$)|api-keys(?:\/|$))/i.test(decoded)) {
+            throw new CliError('cli.path_refused');
+        }
+        let next;
+        try {
+            next = decodeURIComponent(decoded);
+        }
+        catch {
+            throw new CliError('cli.path_refused');
+        }
+        if (next === decoded) {
+            return path;
+        }
+        decoded = next;
+    }
+    throw new CliError('cli.path_refused');
+}
+export function checkEffect(io, options, expired = 'cli.wait_timeout') {
+    if (options.signal.aborted) {
+        throw new CliError('cli.cancelled');
+    }
+    if (options.deadline !== null && io.now() >= options.deadline) {
+        throw new CliError(expired);
+    }
+}
+export async function withinDeadline(io, options, action, expired = 'cli.wait_timeout') {
+    checkEffect(io, options, expired);
+    const controller = new AbortController();
+    const signal = AbortSignal.any([controller.signal, options.signal]);
+    const timer = new AbortController();
+    let deadline = null;
+    if (options.deadline !== null) {
+        deadline = io
+            .sleep(Math.max(0, options.deadline - io.now()), {
+            signal: timer.signal,
+            deadline: null,
+        })
+            .then(() => {
+            controller.abort();
+            throw new CliError(expired);
+        });
+    }
+    try {
+        const operation = action(signal);
+        return await (deadline === null
+            ? operation
+            : Promise.race([operation, deadline]));
+    }
+    finally {
+        timer.abort();
+    }
+}
+export async function bufferResponse(response) {
+    const bytes = await response.arrayBuffer();
+    return new Response(bytes.byteLength === 0 ? null : bytes, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+async function decode(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        throw new CliError('cli.invalid_response');
+    }
+}
+function parsed(parse, input) {
+    try {
+        return parse(input);
+    }
+    catch {
+        throw new CliError('cli.invalid_response');
+    }
+}
+function argument(parse, input) {
+    try {
+        return parse(input);
+    }
+    catch {
+        throw new CliError('cli.invalid_arguments');
+    }
+}
+async function apiFailure(response, body) {
+    let detail;
+    try {
+        detail = parseApiError(body === undefined ? await response.json() : body);
+    }
+    catch {
+        throw new StateMachinesError({
+            message: 'The API returned an unexpected response.',
+            status: response.status,
+            code: null,
+            requestId: response.headers.get('x-request-id'),
+            fields: null,
+            retryAfterMs: null,
+        });
+    }
+    const retry = response.headers.get('retry-after');
+    throw new StateMachinesError({
+        ...detail,
+        status: response.status,
+        retryAfterMs: retry !== null && /^\d+$/.test(retry) ? Number(retry) * 1000 : null,
+    });
+}
+function queryString(query) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined) {
+            params.set(key, String(value));
+        }
+    }
+    return params.size === 0 ? '' : `?${params}`;
+}
+function requester(transport, token) {
+    const { io, origin } = transport;
+    const defaults = transport.options ?? { signal: io.signal, deadline: null };
+    return async (path, input, options = defaults) => {
+        const started = io.now();
+        const budgeted = started + retryBudgetMs < (options.deadline ?? Infinity);
+        const effects = budgeted
+            ? { ...options, deadline: started + retryBudgetMs }
+            : options;
+        const expired = budgeted ? 'cli.network' : 'cli.wait_timeout';
+        let delay = retryPolicy.initialInterval;
+        while (true) {
+            checkEffect(io, effects, expired);
+            let response;
+            try {
+                response = await withinDeadline(io, effects, async (signal) => {
+                    const headers = new Headers(input.headers);
+                    if (!headers.has('accept')) {
+                        headers.set('accept', 'application/json');
+                    }
+                    if (token !== null) {
+                        headers.set('authorization', `Bearer ${token}`);
+                    }
+                    if (input.data !== undefined) {
+                        headers.set('content-type', 'application/json');
+                    }
+                    const response = await transport.fetch(`${origin}${path}`, {
+                        method: input.method,
+                        headers,
+                        redirect: 'manual',
+                        signal,
+                        ...(input.data === undefined
+                            ? {}
+                            : {
+                                body: typeof input.data === 'string'
+                                    ? input.data
+                                    : JSON.stringify(input.data),
+                            }),
+                    });
+                    return bufferResponse(response);
+                }, expired);
+            }
+            catch (error) {
+                checkEffect(io, effects, expired);
+                if (error instanceof CliError) {
+                    throw error;
+                }
+                if (!input.retry ||
+                    !retryPolicy.retryConnectionErrors ||
+                    io.now() - started + delay >= retryBudgetMs) {
+                    throw new CliError('cli.network');
+                }
+                await io.sleep(delay, effects);
+                delay = Math.min(retryPolicy.maxInterval, delay * retryPolicy.exponent);
+                continue;
+            }
+            if (!input.retry ||
+                !retryPolicy.statusCodes.includes(response.status) ||
+                io.now() - started + delay >= retryBudgetMs) {
+                return response;
+            }
+            await response.body?.cancel();
+            await io.sleep(delay, effects);
+            delay = Math.min(retryPolicy.maxInterval, delay * retryPolicy.exponent);
+        }
+    };
+}
+export function createSdkFetch(transport) {
+    const request = requester(transport, null);
+    return async (resource, init) => {
+        const original = new Request(resource, init);
+        const url = new URL(original.url);
+        if (url.origin !== transport.origin) {
+            return transport.fetch(new Request(original, { redirect: 'manual' }));
+        }
+        const response = await request(`${url.pathname}${url.search}`, {
+            method: original.method,
+            headers: original.headers,
+            ...(original.body === null ? {} : { data: await original.text() }),
+            retry: true,
+        }, {
+            ...transport.options,
+            signal: AbortSignal.any([transport.options.signal, original.signal]),
+        });
+        if (retryPolicy.statusCodes.includes(response.status)) {
+            return apiFailure(response);
+        }
+        return response;
+    };
+}
+export function createAnonymousApi(transport) {
+    const request = requester(transport, null);
+    return {
+        async start(input, options) {
+            const body = parseStartLogin(input);
+            const response = await request('/v1/cli/logins', { method: 'POST', data: body, retry: false }, options);
+            if (!response.ok) {
+                return apiFailure(response);
+            }
+            const started = parsed(parseStartedLogin, await decode(response));
+            const verification = new URL(started.verificationUrl);
+            if (!/^[A-Za-z0-9_-]{43}$/.test(started.deviceCode) ||
+                started.expiresIn <= 0 ||
+                started.interval <= 0 ||
+                verification.username !== '' ||
+                verification.password !== '' ||
+                !(verification.protocol === 'https:' ||
+                    (verification.protocol === 'http:' &&
+                        ['localhost', '127.0.0.1'].includes(verification.hostname)))) {
+                throw new CliError('cli.invalid_response');
+            }
+            return started;
+        },
+        async poll(deviceCode, options) {
+            const response = await request('/v1/cli/logins/token', { method: 'POST', data: { deviceCode }, retry: true }, options);
+            if (response.status === 400) {
+                const body = await decode(response);
+                let outcome;
+                try {
+                    outcome = parsePollError(body);
+                }
+                catch {
+                    return apiFailure(response, body);
+                }
+                if ((outcome.error === 'authorization_pending' ||
+                    outcome.error === 'slow_down') &&
+                    outcome.interval <= 0) {
+                    throw new CliError('cli.invalid_response');
+                }
+                switch (outcome.error) {
+                    case 'authorization_pending':
+                        return { kind: 'pending', interval: outcome.interval };
+                    case 'slow_down':
+                        return { kind: 'slow-down', interval: outcome.interval };
+                    case 'access_denied':
+                        return { kind: 'denied' };
+                    case 'expired_token':
+                        return { kind: 'expired' };
+                }
+            }
+            if (!response.ok) {
+                return apiFailure(response);
+            }
+            return {
+                kind: 'approved',
+                ...parsed(parseLoginToken, await decode(response)),
+            };
+        },
+        async readiness(options) {
+            const response = await request('/_state/ready', { method: 'GET', retry: false }, options);
+            if (!response.ok) {
+                return { ready: false };
+            }
+            return parsed((value) => z.object({ ready: z.boolean() }).parse(value), await decode(response));
+        },
+    };
+}
+export function createAuthenticatedApi(transport, token) {
+    const request = requester(transport, token);
+    async function json(path, input, parse, options) {
+        const response = await request(path, { retry: true, ...input }, options);
+        if (!response.ok) {
+            return apiFailure(response);
+        }
+        return parsed(parse, await decode(response));
+    }
+    return {
+        async collected(loginId, options) {
+            const result = await json(`/v1/cli/logins/${encodeURIComponent(loginId)}/collected`, { method: 'POST', retry: false }, parseCollected, options);
+            if (result.loginId !== loginId) {
+                throw new CliError('cli.invalid_response');
+            }
+        },
+        async revokeCurrent(options) {
+            const response = await request('/v1/cli/tokens/current', { method: 'DELETE', retry: false }, options);
+            if (response.status === 401) {
+                return 'already-invalid';
+            }
+            if (!response.ok) {
+                return apiFailure(response);
+            }
+            return 'revoked';
+        },
+        listTokens: (query = {}, options) => json(`/v1/cli/tokens${queryString(query)}`, { method: 'GET' }, parseTokenList, options),
+        listKeys: async (query, options) => json(`/v1/api-keys${queryString(argument(parseKeyListQuery, query))}`, { method: 'GET' }, parseKeyList, options),
+        async createKey(input, idempotencyKey, options) {
+            const result = await json('/v1/api-keys', {
+                method: 'POST',
+                data: parseCreateKey(input),
+                headers: { 'idempotency-key': idempotencyKey },
+            }, parseCreatedKey, options);
+            return result.secret === undefined
+                ? { kind: 'replayed-without-secret', apiKey: result.apiKey }
+                : { kind: 'created', apiKey: result.apiKey, secret: result.secret };
+        },
+        revokeKey: (id, options) => json(`/v1/api-keys/${encodeURIComponent(id)}`, { method: 'DELETE', retry: false }, parseKey, options),
+        async raw(input, options) {
+            const path = validateRawPath(input.path);
+            const response = await request(path, {
+                method: input.method,
+                ...(input.data === null ? {} : { data: input.data }),
+                retry: false,
+            }, options);
+            return {
+                status: response.status,
+                body: (async function* () {
+                    if (response.body) {
+                        for await (const chunk of response.body) {
+                            yield chunk;
+                        }
+                    }
+                })(),
+            };
+        },
+    };
+}

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runProcess } from './io.js';
+import { main } from './main.js';
+await runProcess(main);