@orchestraworks/cli 0.5.5 → 0.5.8

package/docs/REFERENCE.md

@@ -132,16 +132,28 @@ export ORCHESTRA_ORGANIZATION_ID="org_…"
 ```
 
 **The auth-provider chain** (one ordered chain for every command, presence is selection):
-`ORCHESTRA_API_TOKEN` → the `login` profile → the platform-injected machine edge flag
-(`SFDK_AUTH_EDGE_INJECTED`, which makes the CLI send the request **bare** so the egress edge
-stamps the agent's authorization — no credential ever enters the machine) → a named
-missing-credentials error. There is **no `--token` flag**: a token never appears in argv.
+`ORCHESTRA_API_TOKEN` → the file `ORCHESTRA_API_TOKEN_FILE` names → the `login` profile → the
+platform-injected machine edge flag (`SFDK_AUTH_EDGE_INJECTED`) → a named missing-credentials error.
+There is **no `--token` flag**: a token never appears in argv.
+
+- **The token file.** On an Orchestra machine, the worker writes the agent's own platform token to a
+  file and renews it before it expires. It sets `ORCHESTRA_API_TOKEN_FILE` to that file's path on each
+  agent process. The CLI reads the file again before each request, so a long `orchestra sessions wait`
+  always sends the current token. A missing, empty or unreadable file counts as absent. The worker sets
+  the path before it writes the file, so right after the agent starts, a command may report that the
+  file is not written yet.
+- **The edge flag.** On a machine behind the platform's network edge, the edge adds the agent's
+  authorization to each call to the platform. It replaces any token the request carried with a token for
+  the same agent. With the edge flag and no token, the CLI sends the request **bare**.
+- **A 401 under the token file.** The agent has nothing to renew. The token expired before the worker
+  renewed it, or the agent is no longer placed on the machine, the machine stopped, or the agent is not
+  active.
 
 **Resolved alongside the chain, per field:** the base URL (`--base-url` → `ORCHESTRA_BASE_URL`, then `PLATFORM_BASE_URL` → profile;
 `login` alone adds the built-in default as a fourth tier, because it is the command that has no profile
 to read yet — every other command needs one of the three, and says so if it has none)
-and the organization (`--org` → `ORCHESTRA_ORGANIZATION_ID` → profile; under the edge provider the organization
-rides the stamped identity server-side). Every authenticated request requires HTTPS or loopback — the
+and the organization (`--org` → `ORCHESTRA_ORGANIZATION_ID` → profile; under the token file and the edge flag
+the organization rides the agent's token server-side). Every authenticated request requires HTTPS or loopback — the
 bearer is itself a credential — with the unauthenticated `health` ping the one exemption. `diff`/`apply`
 print the resolved target org as a banner before any read/write, and warn when an exported
 `ORCHESTRA_ORGANIZATION_ID` diverges from the profile's org (so a stale export can't silently redirect writes).
@@ -224,14 +236,15 @@ import {
   Image,
   Secret,
   SecretValue,
-  bearer,
 } from "@orchestraworks/cli";
 
 const factory = new Factory({ name: "acme-support" });
 
-const openaiKey = new Secret(factory, "openai-api-key", {
+new Secret(factory, "openai-api-key", {
   name: "OpenAI API key",
   value: SecretValue.fromEnv("OPENAI_API_KEY_VALUE"), // value read from env at apply — never in the plan
+  hosts: ["api.openai.com"], // where the egress edge presents it
+  injection: { headers: [{ name: "Authorization", value: "Bearer ${secret}" }] }, // how it presents it
 });
 
 const runtime = new Environment(factory, "runtime", {
@@ -241,11 +254,10 @@ const runtime = new Environment(factory, "runtime", {
   resources: { cpu: "2", memory: "4G" }, // an Agent Compute Capacity: cores : 2 G per core
   env: { LOG_LEVEL: "debug" }, // plaintext configuration for the agent process — NOT a secret store:
                                // these values are stored unencrypted and returned by every read, so a
-                               // credential belongs in a Secret bound to an egress allow rule instead.
+                               // credential belongs in a Secret that declares the hosts it is presented on.
   egress: EgressPolicy.denyAll().allow("openai-model-api", {
     hosts: ["api.openai.com"],
-    priority: 300,
-    credential: bearer("Authorization", openaiKey), // binds the Secret to an injected header
+    priority: 300, // a rule opens the network; it carries no credential
   }),
   ingress: [{ name: "web", port: 3000 }],
 });
@@ -346,67 +358,70 @@ factory via a process singleton). Two `fromBuild` calls with the same tag are a
 ### Two starting points: `EgressPolicy.denyAll()` and `EgressPolicy.allowAll()`
 
 `EgressPolicy.denyAll()` refuses every host no rule allows; `EgressPolicy.allowAll()` allows every host no
-rule refuses. Every rule form folds onto either one the same way: a credentialed allow rule still injects its
-credential at the edge, and a `deny` still refuses. A first factory starts open, since a first run fails far
+rule refuses. Every rule form folds onto either one the same way: a rule only opens or closes the network, a
+credential still goes only to the hosts its own `hosts` cover, and a `deny` still refuses. A first factory starts open, since a first run fails far
 more often on a blocked host than on anything else, and tightens once runs succeed: read which hosts the agent
 reached, switch to `denyAll()`, and allow those.
 
 ```ts
 egress: EgressPolicy.allowAll()
-  .applyPreset(github.egressPolicy())                                // the connection's credentialed rules
+  .applyPreset(github.egressPolicy())                                // the connection's API and git hosts
   .deny("no-hosted-data", { hosts: ["*.supabase.co", "db.acme.example"] }), // keep the team's real data out
 ```
 
 Open egress opens hosts, not ports: a service on another port still needs a rule naming `host:port`.
 
-### Egress allow rules: paths and multiple credential bindings
+### Egress allow rules: paths, and where credentials live
 
 `EgressPolicy.denyAll().allow(name, rule)` opens one named outbound rule. Beyond `hosts` and
-`priority` it takes:
-
-- **`paths?: string[]`** — path globs the rule matches; default `["*"]` (all paths). Scope a rule to a
-  subtree with e.g. `paths: ["/backend-api/*"]`.
-- **`credential?: ICredentialBinding`** — a single credential: a bare `Secret` (its own `injection`
-  recipe supplies the headers), or a `bearer`/`basic`/`header`/`inject` binding (see §6).
-- **`credentials?: ICredentialBinding[]`** — several credentials injected on one request, for a
-  destination that needs more than one credential header. Both must ride **one** rule: the platform egress
-  matcher selects exactly one rule per (destination, path, method) and hydrates once per request, so
-  co-required headers cannot be split across two rules.
-
-Every entry is an `ICredentialBinding` — a `Secret`/import or a factory result, never a plain object
-literal. Valid credential shapes are **neither** (a credential-free allow — e.g. `allow(connection)`),
-**one `credential`**, or a **non-empty `credentials` list**. Setting both forms, passing an empty
-`credentials` array, or listing case-insensitively duplicate header names is a **synth error** (a
-duplicate would silently drop a binding at broker hydration). A recipe binding (a bare `Secret` or an
-`inject()` override) names no header of its own — its `injection` recipe does — so it never participates
-in that uniqueness check; uniqueness still holds across the legacy `bearer`/`basic`/`header` bindings
-beside it.
+`priority` it takes **`paths?: string[]`** — path globs the rule matches; default `["*"]` (all paths).
+Scope a rule to a subtree with e.g. `paths: ["/backend-api/*"]`.
 
-```ts
-import { bearer, header } from "@orchestraworks/cli";
+**A rule carries no credential.** A rule is a network rule: it decides whether a request may leave, and
+nothing more. A credential declares where and how it is presented on its own resource:
+
+- a **`Secret`** takes `hosts` (an exact host, `*.suffix`, which also covers the bare suffix, or `*`) and an
+  `injection` recipe naming the headers it sets. A Secret with no `hosts` is presented nowhere; orchestra always
+  sends `hosts`, as `[]` when you declare none.
+- a **`Connection`** takes `hosts`, defaulting to `["*"]`: every host the provider catalog lists for its
+  credential. Narrow it to a subset of those hosts when you want less.
+
+Passing `credential` or `credentials` to a rule, or `credentialHosts` to `allow(connection, …)`, is a
+**synth error** that shows the Secret or Connection form to write instead.
 
-EgressPolicy.denyAll().allow("chatgpt", {
+A destination that needs several credential headers on one request reads them from **one** Secret whose
+value is `SecretValue.fields(...)`, a JSON object of named fields, each read as `${secret.<field>}`:
+
+```ts
+new Secret(factory, "chatgpt", {
+  value: SecretValue.fields({
+    access: SecretValue.fromEnv("ORCHESTRA_FDK_CODEX_OAUTH_ACCESS_VALUE"),
+    account: SecretValue.fromEnv("ORCHESTRA_FDK_CODEX_OAUTH_ACCOUNT_VALUE"),
+  }),
   hosts: ["chatgpt.com"],
-  paths: ["/backend-api/*"],
-  priority: 10,
-  credentials: [
-    bearer("Authorization", codexAccess),
-    header("ChatGPT-Account-Id", codexAccount), // raw value, no scheme prefix
-  ],
+  injection: {
+    headers: [
+      { name: "Authorization", value: "Bearer ${secret.access}" },
+      { name: "ChatGPT-Account-Id", value: "${secret.account}" }, // raw value, no scheme prefix
+    ],
+  },
 });
+
+EgressPolicy.denyAll().allow("chatgpt", { hosts: ["chatgpt.com"], paths: ["/backend-api/*"], priority: 10 });
 ```
 
 ### Ready-made egress: presets and a connection's own rules
 
 Most of an environment's egress is reachability an app used to type out host by host. Two calls replace
-that, and the line between them is the one rule to remember: **anonymous rules ride presets, credentialed
-rules ride the connection.**
+that, and the line between them is the one rule to remember: **anonymous reachability rides presets, a
+provider's own surface rides the connection.**
 
 - **`egressPreset.softwareDevelopment()`** — a static bundle of **credential-free** public-internet allows
   that anyone may apply. A preset is about *reachability*, never credentials.
 - **`connection.egressPolicy(options?)`** — one connection's own outbound surface, compiled from the
-  **provider catalog**: the provider-API rules `allow(connection)` emits, plus the provider's git transport,
-  each bound to that connection's credential.
+  **provider catalog**: the provider-API rules `allow(connection)` emits, plus the provider's git transport.
+  Every rule is a network rule; the broker presents the connection's credential on the hosts the connection
+  covers.
 
 Both return the same bundle value, and `EgressPolicy.applyPreset(bundle)` folds either onto a policy —
 chainable like `allow` and `deny`:
@@ -416,14 +431,14 @@ import { EgressPolicy, egressPreset } from "@orchestraworks/cli";
 
 // …in the Environment's props:
 egress: EgressPolicy.denyAll()
-  .applyPreset(github.egressPolicy())               // credentialed: the provider API + the git transport
+  .applyPreset(github.egressPolicy())               // the provider API + the git transport
   .applyPreset(egressPreset.softwareDevelopment()), // anonymous: registries, public git reads, SaaS reads
 ```
 
 **A bundle is not a new concept.** Every entry lands as an ordinary allow rule, in the order you applied
 them, so `plan.json`, `orchestra fdk diff` and the live environment show only rules — there is nothing about presets to
 learn when reading a plan. Priorities arbitrate without you picking numbers: a preset row rides `100`, every
-connection-bundle rule `300`, and a `deny` defaults to `900` — so a credentialed rule always wins a host a
+connection-bundle rule `300`, and a `deny` defaults to `900` — so a connection's rule always wins a host a
 preset row also opens, and a prohibition wins both. Customization is additive: author more rules beside a
 bundle, and `deny(...)` anything you do not want.
 
@@ -433,7 +448,7 @@ bundle, and `deny(...)` anything you do not want.
 (Atlassian, Zendesk, PagerDuty, Datadog, Sentry, Slack, Notion, Statuspage, Linear). Every row is
 `GET`/`HEAD` except three deliberate, path-scoped POSTs — git's `git-upload-pack` (fetch), Notion's
 query/search, and Linear's `/graphql` — and **no row carries a credential**, so git *push* stays closed and
-a service still needs whatever auth a connection bundle or a Secret-bound rule supplies. It takes no
+a service still needs whatever auth a connection or a Secret presents on its hosts. It takes no
 arguments today, and each call returns fresh arrays, so two environments applying it share nothing.
 
 **The connection bundle** is available identically on a managed `Connection` and on every import
@@ -464,25 +479,26 @@ Two authoring notes:
   correctly (which one wins a request is decided by priority and declaration order, never by the name), so
   the kit refuses instead of shipping the ambiguity.
 
-Why the split is enforced rather than merely conventional — the bundle type has no credential field an app
-could fill in, the priority bands above, and the platform matcher preferring a credentialed rule at an equal
-priority — is in the architecture note `docs/architecture/fdk-agent-as-code.md`, § *Egress bundles*.
+Why the split is enforced rather than merely conventional — no rule has a credential field an app could
+fill in, and the priority bands above — is in the architecture note `docs/architecture/fdk-agent-as-code.md`,
+§ *Egress bundles*.
 
 ### Model traffic through the gateway: `routeModelsViaGateway()`
 
 `EgressPolicy.denyAll().routeModelsViaGateway({ key })` lets the agent reach the platform's model gateway
 with a gateway key it never holds. `key` is the `Secret` whose value is `SecretValue.fromGatewayKey(...)`
-(next section):
+(next section), and that Secret declares how it is presented on the gateway host:
 
 ```ts
 egress: EgressPolicy.denyAll().allow(github).routeModelsViaGateway({ key: gatewayToken }),
 ```
 
-It appends one ordinary allow rule, named `model-gateway` at priority `300`, on the gateway host. The
-rule's binding adds `Authorization: Bearer <your gateway key>` at the egress edge and removes `x-api-key`,
-so the agent calls the gateway with no key and the gateway swaps yours for the provider key.
+It appends one ordinary network allow rule, named `model-gateway` at priority `300`, on the gateway host. The
+key's Secret adds `Authorization: Bearer <your gateway key>` at the egress edge and removes `x-api-key`, so
+the agent calls the gateway with no key and the gateway swaps yours for the provider key. A declared key
+whose `hosts` do not cover the gateway host, or whose `injection` sets no header, is a synth error.
 
-The rule only adds the key. The agent learns the gateway's address from its own model settings, so set
+The rule only opens the host, and the Secret adds the key. The agent learns the gateway's address from its own model settings, so set
 `modelSettings: { enableModelGateway: true }` on each agent that routes through the gateway (§ *The model an
 agent runs* below).
 
@@ -496,14 +512,15 @@ Four authoring notes:
   `model-gateway` is a duplicate-name synth error, and if you *also* hand-author an allow rule over the
   gateway host, give it a different priority. Higher priority is evaluated first; at an equal priority the
   platform matcher silently takes the first match in declaration order.
-- **Your organization needs secrets and managed egress.** Storing the key needs a plan with secrets, and a
-  rule carrying a credential needs managed egress; without them `apply` fails with a named plan error. An
+- **Your organization needs secrets and managed egress.** Storing the key needs a plan with secrets, or
+  `apply` fails with a named plan error. Presenting a credential at egress needs managed egress: without it
+  `apply` succeeds, and the egress edge refuses each model call with `plan_feature_disabled`. An
   organization on a plan without them, the individual plan among them, puts its gateway key into its
   runtime itself, in environment variables or by hand; orchestra has no helper for that.
 - **Calling a provider directly is a different thing, and it has no sugar.** If you want the agent to
-  talk straight to `api.anthropic.com` (or any other provider), write the ordinary rule for it and bind
-  *your* credential — `allow("anthropic", { hosts: ["api.anthropic.com"], priority: 200, credentials:
-  [header("x-api-key", myKey)] })`. That path uses your provider account, and it can coexist with the
+  talk straight to `api.anthropic.com` (or any other provider), write the ordinary rule for it and give
+  *your* key's Secret `hosts: ["api.anthropic.com"]` and an `x-api-key` injection header —
+  `allow("anthropic", { hosts: ["api.anthropic.com"], priority: 200 })`. That path uses your provider account, and it can coexist with the
   gateway rule: the agent's model settings send its own traffic to the gateway, while the direct rule
   covers whatever the agent addresses at the provider host itself (a CLI, a raw HTTP call). A direct
   credential that never seems to fire is usually this, not a bug.
@@ -522,6 +539,8 @@ const modelGateway = new GatewayKey(factory, "model-gateway", {
 
 const gatewayToken = new Secret(factory, "model-gateway-key", {
   value: SecretValue.fromGatewayKey(modelGateway), // apply mints the key and writes its token here
+  hosts: [DEFAULT_MODEL_GATEWAY_HOST],
+  injection: { headers: [{ name: "Authorization", value: "Bearer ${secret}" }], removeHeaders: ["x-api-key"] },
 });
 // … then route through it: EgressPolicy.denyAll().routeModelsViaGateway({ key: gatewayToken })
 ```
@@ -785,17 +804,13 @@ an env value (request body only — never logged, serialized, in `result.json`,
 behind the same TLS transport guard, which refuses a credential write over non-loopback plain HTTP.
 
 Derived credentials: `SecretValue.basicAuth("x-access-token", tokenValue)` renders
-`base64("x-access-token:<token>")` (the base64 derivation happens only at apply). Bind a rendered value to
-an egress header with `bearer(header, secret)`, `basic(header, secret)`, or `header(name, secret)` — the
-raw binder, which injects the secret value **verbatim** (no `Bearer `/`Basic ` scheme prefix), for a
-destination that wants the credential in a bare custom header.
+`base64("x-access-token:<token>")` (the base64 derivation happens only at apply). Present it with an
+`injection` header such as `{ name: "Authorization", value: "Basic ${secret}" }`.
 
-### Injection recipes: several headers from one secret
+### Injection recipes: the headers a secret presents
 
-Those three binders are all one-header-per-secret. A destination that needs a **set** of headers derived
-from one credential — or that needs a client-sent header **stripped** — declares an `injection` recipe on
-the Secret itself and binds it by passing the bare `Secret` as the credential (no binder call — the
-recipe supplies the headers):
+A Secret's `injection` recipe names every header it sets on its `hosts`, and may strip client-sent headers.
+One recipe can set several headers from one credential.
 
 The **Claude sign-in recipe** is the one to copy when the claude harness runs on a person's Claude
 subscription token rather than an API key:
@@ -803,8 +818,9 @@ subscription token rather than an API key:
 ```ts
 import { EgressPolicy, Secret, SecretValue } from "@orchestraworks/cli";
 
-const claudeSignIn = new Secret(factory, "claude-sign-in", {
+new Secret(factory, "claude-sign-in", {
   value: SecretValue.fromEnv("SFDK_CLAUDE_CODE_OAUTH_TOKEN"),
+  hosts: ["api.anthropic.com"],
   injection: {
     headers: [{ name: "authorization", value: "Bearer ${secret}" }],
     removeHeaders: ["x-api-key"], // stripped before injection, so a runtime placeholder cannot leak
@@ -815,8 +831,7 @@ const claudeSignIn = new Secret(factory, "claude-sign-in", {
 env: { CLAUDE_CODE_OAUTH_TOKEN: "placeholder", ANTHROPIC_API_KEY: "" },
 egress: EgressPolicy.allowAll().allow("claude-sign-in", {
   hosts: ["api.anthropic.com"],
-  priority: 300,
-  credential: claudeSignIn, // the bare Secret — its injection recipe supplies the headers
+  priority: 300, // a network rule; the Secret presents itself on its hosts
 }),
 ```
 
@@ -827,22 +842,15 @@ swaps the real token in. The empty `ANTHROPIC_API_KEY` covers the runtime image'
 harness would otherwise send instead.
 
 - **`headers[].value`** templates take `${secret}` (the whole value) or `${secret.<field>}` (a top-level
-  field of a JSON-object secret value); a literal-only value is fine for companion headers.
+  field of a `SecretValue.fields` value); a literal-only value is fine for companion headers.
 - **`removeHeaders`** strips client-sent headers before injection; injecting a header the client also
   sent replaces it.
 - Synth mirrors the platform's write-time rules: header-name charset, the routing/hop-by-hop denylist
   (`host`, `content-length`, `transfer-encoding`, `connection`, `te`, `upgrade`, any `proxy-*`), the two
   placeholder forms, and the caps (≤ 8 header ops, ≤ 8 removals).
 
-The **binding determines application**: a legacy `bearer`/`basic`/`header` binding over a recipe-carrying
-secret is a valid, explicit choice to present that secret as one header (its recipe is not applied on that
-rule). The one remaining synth error is passing a recipe-**less** secret **bare** — there is no recipe to
-apply, so bind it with `bearer`/`basic`/`header` or an `inject()` override instead. `inject(secret,
-recipe)` binds any secret (recipe-carrying or not) under a **binding-owned** recipe that overrides the
-secret's own recipe wholesale — the recipe is validated once at synth and deep-copied into the plan, so a
-later mutation of your input cannot smuggle an unvalidated header. A bare recipe-less check only fires for
-**locally declared** secrets; a `Secret.fromSlug`/`fromId` import carries no visible recipe, so it defers
-to the server.
+A Secret with `hosts` must carry an `injection` recipe with at least one header: the platform refuses a
+Secret that is presented somewhere but sets nothing.
 
 ## 7. Work with existing resources
 
@@ -1190,8 +1198,8 @@ new Trigger(factory, "slack-thread-replies", {
 #### 3. Outbound — what the agent may say
 
 The reply is an ordinary outbound request from the machine, so it needs an egress grant like any other. One
-line on the **receiving agent's environment** synthesizes the provider's `apiHosts` rule plus the
-`Authorization` binding the broker hydrates from that installation:
+line on the **receiving agent's environment** synthesizes a network rule over the provider's `apiHosts`; the
+broker presents that installation's credential on the hosts the connection covers:
 
 ```ts
 const responderEnv = new Environment(factory, "responder-env", {
@@ -1202,19 +1210,18 @@ const responderEnv = new Environment(factory, "responder-env", {
 
 Forget it and nothing looks wrong: synth, apply and routing all succeed, the agent runs — and then its reply
 CLI gets a 403 from the egress fence inside its own machine, where nothing surfaces it but decision logs. So
-synth notices that exact shape (a connection wired inbound to an agent whose environment has no rule bound to
-it) and prints:
+synth notices that exact shape (a connection wired inbound to an agent whose deny-by-default environment has
+no allow rule covering the provider's hosts) and prints:
 
 ```
-warning: connection 'slack' is wired inbound to agent 'codex-agent' but its environment 'codex-env' has no outbound rule for it — add .allow(slack) to its egress, or ignore this if that is deliberate (listener-only, or the hosts are covered by a hand-written rule).
+warning: connection 'slack' is wired inbound to agent 'codex-agent' but its environment 'codex-env' has no allow rule covering its provider's hosts — add .allow(slack) to its egress, or ignore this if that is deliberate (listener-only).
 ```
 
 It never blocks, and **the deliberate listener simply ignores it**: an agent that only reads a provider's
-events and answers somewhere else (or not at all) needs no outbound grant, and so does an agent whose access
-you authored as a hand-written named rule with its own credential — detection is by connection-bound rule
-only, and that false positive is accepted rather than papered over with host matching (a covering rule with
-the wrong credential still 403s). Anything synth cannot prove stays silent instead: an imported agent or
-environment is not in the plan, and a `Connection.fromEnv`/`fromId` binding resolves only at apply.
+events and answers somewhere else (or not at all) needs no outbound grant. Detection is by host coverage: a
+hand-written allow rule whose hosts cover the provider's api hosts counts, because a rule carries no
+credential and the connection presents its own. Anything synth cannot prove stays silent instead: an imported agent or
+environment is not in the plan, and a `Connection.fromEnv`/`fromId` reference resolves only at apply.
 
 #### Asking a person to approve
 

package/node_modules/@orchestraworks/client/dist/apis/AgentsApi.d.ts

@@ -44,7 +44,7 @@ export interface ListAgentsRequest {
     limit?: number;
     status?: ListAgentsStatusEnum;
     name?: string;
-    projectId?: string;
+    teamId?: string;
     xOrganizationId?: string;
 }
 export interface UpdateAgentOperationRequest {

package/node_modules/@orchestraworks/client/dist/apis/AgentsApi.js

@@ -297,8 +297,8 @@ class AgentsApi extends runtime.BaseAPI {
             if (requestParameters['name'] != null) {
                 queryParameters['name'] = requestParameters['name'];
             }
-            if (requestParameters['projectId'] != null) {
-                queryParameters['projectId'] = requestParameters['projectId'];
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
             }
             const headerParameters = {};
             if (requestParameters['xOrganizationId'] != null) {

package/node_modules/@orchestraworks/client/dist/apis/ArtifactsApi.d.ts

@@ -88,7 +88,7 @@ export interface ListArtifactsRequest {
     page?: number;
     limit?: number;
     sessionId?: string;
-    projectId?: string;
+    teamId?: string;
     xOrganizationId?: string;
 }
 export interface ListCommentsRequest {

package/node_modules/@orchestraworks/client/dist/apis/ArtifactsApi.js

@@ -671,8 +671,8 @@ class ArtifactsApi extends runtime.BaseAPI {
             if (requestParameters['sessionId'] != null) {
                 queryParameters['sessionId'] = requestParameters['sessionId'];
             }
-            if (requestParameters['projectId'] != null) {
-                queryParameters['projectId'] = requestParameters['projectId'];
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
             }
             const headerParameters = {};
             if (requestParameters['xOrganizationId'] != null) {

package/node_modules/@orchestraworks/client/dist/apis/ConnectionInstallLinksApi.d.ts

@@ -27,7 +27,7 @@ export interface ListConnectionInstallLinksRequest {
     connectorId?: string;
     slug?: string;
     status?: ListConnectionInstallLinksStatusEnum;
-    projectId?: string;
+    teamId?: string;
     xOrganizationId?: string;
 }
 /**

package/node_modules/@orchestraworks/client/dist/apis/ConnectionInstallLinksApi.js

@@ -139,8 +139,8 @@ class ConnectionInstallLinksApi extends runtime.BaseAPI {
             if (requestParameters['status'] != null) {
                 queryParameters['status'] = requestParameters['status'];
             }
-            if (requestParameters['projectId'] != null) {
-                queryParameters['projectId'] = requestParameters['projectId'];
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
             }
             const headerParameters = {};
             if (requestParameters['xOrganizationId'] != null) {

package/node_modules/@orchestraworks/client/dist/apis/ConnectionsApi.d.ts

@@ -44,7 +44,7 @@ export interface ListConnectionEventTypesRequest {
 export interface ListConnectionsRequest {
     page?: number;
     limit?: number;
-    projectId?: string;
+    teamId?: string;
     xOrganizationId?: string;
 }
 export interface RecordConnectionEventOperationRequest {

package/node_modules/@orchestraworks/client/dist/apis/ConnectionsApi.js

@@ -288,8 +288,8 @@ class ConnectionsApi extends runtime.BaseAPI {
             if (requestParameters['limit'] != null) {
                 queryParameters['limit'] = requestParameters['limit'];
             }
-            if (requestParameters['projectId'] != null) {
-                queryParameters['projectId'] = requestParameters['projectId'];
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
             }
             const headerParameters = {};
             if (requestParameters['xOrganizationId'] != null) {

package/node_modules/@orchestraworks/client/dist/apis/EnvironmentsApi.d.ts

@@ -29,7 +29,7 @@ export interface GetEnvironmentRequest {
 export interface ListEnvironmentsRequest {
     page?: number;
     limit?: number;
-    projectId?: string;
+    teamId?: string;
     computeProviderId?: Array<string>;
     xOrganizationId?: string;
 }

package/node_modules/@orchestraworks/client/dist/apis/EnvironmentsApi.js

@@ -185,8 +185,8 @@ class EnvironmentsApi extends runtime.BaseAPI {
             if (requestParameters['limit'] != null) {
                 queryParameters['limit'] = requestParameters['limit'];
             }
-            if (requestParameters['projectId'] != null) {
-                queryParameters['projectId'] = requestParameters['projectId'];
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
             }
             if (requestParameters['computeProviderId'] != null) {
                 queryParameters['computeProviderId'] = requestParameters['computeProviderId'];

package/node_modules/@orchestraworks/client/dist/apis/FilesApi.d.ts

@@ -38,7 +38,7 @@ export interface GetFileContentRequest {
 export interface ListFilesRequest {
     page?: number;
     limit?: number;
-    projectId?: string;
+    teamId?: string;
     xOrganizationId?: string;
 }
 /**

package/node_modules/@orchestraworks/client/dist/apis/FilesApi.js

@@ -293,8 +293,8 @@ class FilesApi extends runtime.BaseAPI {
             if (requestParameters['limit'] != null) {
                 queryParameters['limit'] = requestParameters['limit'];
             }
-            if (requestParameters['projectId'] != null) {
-                queryParameters['projectId'] = requestParameters['projectId'];
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
             }
             const headerParameters = {};
             if (requestParameters['xOrganizationId'] != null) {

package/node_modules/@orchestraworks/client/dist/apis/ImagesApi.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Orchestra platform API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { type CreateImageRequest } from '../models/CreateImageRequest';
+import { type Image } from '../models/Image';
+import { type PageImage } from '../models/PageImage';
+export interface CreateImageOperationRequest {
+    createImageRequest: CreateImageRequest;
+    xOrganizationId?: string;
+}
+export interface DeleteImageRequest {
+    id: string;
+    xOrganizationId?: string;
+}
+export interface GetImageRequest {
+    id: string;
+    xOrganizationId?: string;
+}
+export interface ListImagesRequest {
+    page?: number;
+    limit?: number;
+    name?: Array<string>;
+    status?: Array<ListImagesStatusEnum>;
+    xOrganizationId?: string;
+}
+/**
+ *
+ */
+export declare class ImagesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for createImage without sending the request
+     */
+    createImageRequestOpts(requestParameters: CreateImageOperationRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    createImageRaw(requestParameters: CreateImageOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Image>>;
+    /**
+     */
+    createImage(requestParameters: CreateImageOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Image>;
+    /**
+     * Creates request options for deleteImage without sending the request
+     */
+    deleteImageRequestOpts(requestParameters: DeleteImageRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    deleteImageRaw(requestParameters: DeleteImageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     */
+    deleteImage(requestParameters: DeleteImageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for getImage without sending the request
+     */
+    getImageRequestOpts(requestParameters: GetImageRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    getImageRaw(requestParameters: GetImageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Image>>;
+    /**
+     */
+    getImage(requestParameters: GetImageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Image>;
+    /**
+     * Creates request options for listImages without sending the request
+     */
+    listImagesRequestOpts(requestParameters: ListImagesRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    listImagesRaw(requestParameters: ListImagesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PageImage>>;
+    /**
+     */
+    listImages(requestParameters?: ListImagesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PageImage>;
+}
+/**
+ * @export
+ */
+export declare const ListImagesStatusEnum: {
+    readonly Copying: "COPYING";
+    readonly Ready: "READY";
+    readonly Failed: "FAILED";
+};
+export type ListImagesStatusEnum = typeof ListImagesStatusEnum[keyof typeof ListImagesStatusEnum];