Introducing a new way to review your PRs.

Read the announcement

paperclipai / paperclip

The open-source app everyone uses to manage agents at work

View on GitHub

30 documents · Updated Nov 20, 2026

docs / extensibility-platform

Extensibility platform

The Paperclip extensibility platform lets trusted external packages add product behavior without changing the core application. Plugins connect outside services, manage Paperclip resources, add agent tools and UI, provide workspaces and execution environments, and expose machine interfaces through the CLI and MCP server. Plugin platform, external app connections, and CLI and MCP interfaces describe these child surfaces in more detail. The platform also supports agent work through agent work management, organization-wide control through organization work management, and operational safeguards through automation and control, security and governance, and application platform operations.

Extension model

The extension model uses a validated plugin manifest as the contract between a plugin and the host. The manifest names the package, worker entry point, capabilities, and product surfaces. The host validates these declarations before it installs or activates the plugin.

The worker receives a scoped PluginContext. This context gives the plugin controlled access to Paperclip data, events, jobs, configuration, secrets, external HTTP services, storage, tools, and UI bridges. The host keeps ownership of identity, company scope, and capability checks. Ordinary plugin workers do not receive ambient host secrets.

Configuration changes carry the company that changed. A worker that serves more than one company must opt into multi-company configuration. Without that opt-in, the host rejects a second company's distinct configuration instead of replacing the first one. This prevents one worker's connections or secrets from silently moving to another company.

References: packages/…/define-plugin.ts• L223-292 packages/…/protocol.ts• L254-377 packages/…/worker-rpc-host.ts• L1961-2009

Plugin package and deployment

The SDK is the single author-facing package for plugin worker code, host context types, protocol helpers, manifest types, and environment and workspace contracts. It also provides UI helpers, test hosts, build presets, and a local development server. The host discovers local and npm packages, validates their manifests, and starts ready workers with their declared surfaces.

The create-paperclip-plugin tool provides starter projects for general plugins, connectors, workspaces, and environment drivers. A scaffold includes worker, manifest, UI, build, test, and local development entry points. Local development can use workspace or packed SDK dependencies. Published npm packages are the supported deployment path.

Plugin workers and same-origin plugin UI are trusted code in the current runtime. Capabilities protect host services and tenant scope, but they are not a full sandbox for untrusted marketplace code. Local installs run code from the selected folder, while deployed installs require the package to be trusted by the instance.

References: packages/…/README.md• L1-53 packages/…/index.ts• L117-177 packages/…/index.ts• L303-344 packages/…/entrypoints.test.ts• L20-87

Host and worker boundary

The host runs each installed plugin in its own worker process. The host and worker exchange typed JSON-RPC 2.0 messages over standard input and output. Initialization sends the manifest and configuration. The worker then reports the optional handlers it supports, so the host can route only the product surfaces that the worker can serve.

Worker calls back to the host through the same channel. These calls carry host-issued invocation scope and are checked against the plugin's capabilities. The protocol reports distinct failures for an unavailable worker, denied capability, timeout, missing optional method, invalid company scope, unsafe cross-company configuration, and provider diagnostic evidence.

The boundary also carries tracing receipts and byte-safe duplex channel messages. JSON-RPC uses a checked base64 form for channel bytes, while the host-owned route remains bound to the worker session. Tracing and channel telemetry must not change plugin control flow.

The host controls worker idle sleep. It closes admission for new work, waits for accepted calls and plugin-owned activity to settle, and keeps the worker active when the plugin cannot prove that it is idle. This lets environment providers drain leases, sessions, and live channels before teardown.

This diagram shows the main path from a package to Paperclip behavior.

flowchart LR
    A[Plugin package] --> B[Validated manifest]
    B --> C[Installed plugin]
    C --> D[Worker process]
    D --> E[Scoped host context]
    E --> F[Paperclip data and events]
    E --> G[Tools, UI, resources, and environments]

References: packages/…/protocol.ts• L7-20 packages/…/protocol.ts• L247-325 packages/…/protocol.ts• L1241-1362 packages/…/worker-rpc-host.ts• L284-343 packages/…/worker-rpc-host.ts• L343-483 packages/…/worker-rpc-host.test.ts• L193-333

Product extensions

Plugins extend Paperclip through related product surfaces. The manifest declares the surface. The worker supplies the behavior. The host attaches that behavior to a company, agent, UI slot, workspace, execution run, or outside service.

SurfaceProduct role
Events and jobsReact to Paperclip changes or run recurring work.
Connector appsAdd a catalog entry whose tools become available only through an installed connection.
ToolsGive agents named actions for outside systems or plugin workflows.
Managed resourcesReconcile company-scoped agents, projects, routines, and skills.
External objectsDetect and refresh references to objects outside Paperclip.
AI connection routingSelect an authorized AI connection from a plugin-managed pool.
Issue interactions and API routesCollect structured input and expose bounded plugin-owned HTTP actions.
Environment driversGive runs a place to work through leases, commands, workspace sync, setup, templates, Runner tasks, and live channels.
Workspace providersPrepare and remove project workspaces and branches outside the core workspace store.
Agent lifecycle and runtime stateApply committed agent changes and provide runtime inputs to the owning lifecycle plugin.
UI and launchersAdd pages, tabs, widgets, settings, actions, and entry points in Paperclip.

One plugin can combine these surfaces. For example, an integration can listen for Paperclip events, keep an external object record, expose a connector tool, reconcile a managed project, and show sync state in the UI.

Manifest-declared jobs have durable host records. The host syncs job declarations when a plugin becomes ready. When a plugin is disabled or unloaded, the host stops new runs and applies the selected history policy.

References: packages/…/define-plugin.ts• L223-377 packages/…/define-plugin.ts• L379-467 packages/…/types.ts• L267-327 packages/…/index.ts• L350-427 packages/…/worker-rpc-host.ts• L1874-1921

Managed resources

Managed resources are Paperclip records that a plugin declares and resolves by a stable key inside each company. Reconciliation creates or relinks the record when needed. Reset restores the plugin's declared defaults while leaving the record in normal Paperclip workflows.

The supported kinds are:

  • Agents, with suggested identity, runtime, permissions, budget, and instructions.
  • Projects, which give plugin work a stable project.
  • Routines, which can link a managed agent and project and define triggers.
  • Skills, which install company skills with markdown and supporting files.

Managed references stay tied to the declaring plugin. This lets a routine refer to its plugin's agent or project without relying on a changing database ID. Managed skills use a plugin-scoped key and report drift when a company changes declared files.

References: packages/…/index.ts• L349-372 packages/…/types.ts• L978-1041 packages/…/worker-rpc-host.ts• L791-853 server/…/plugin-host-services.ts• L2017-2117

Execution environments

An environment driver gives an agent a place to run work. Paperclip treats the external allocation as a lease linked to a company, environment, and run. The provider validates configuration, acquires or resumes the lease, realizes a workspace, executes work, transfers files, and proves release or destruction.

Provider features are optional and negotiated at worker startup. A provider advertises only the handlers it implements. The host can therefore select reusable leases, native file sync, interactive setup, templates, Runner ingress, login terminals, and duplex channels from an explicit contract.

Environment tasks extend a lease into a provider-owned Runner task. The task contract carries durable run identity, checked launch requirements, project authorization, file and saved-state access, credentials, status, connection, and completion operations. Only approved credential material crosses this boundary. A task result must match the requested operation and provider task ID. An accepted submission or stop is not treated as proof that execution has ended.

Release and resume also carry closed, typed outcomes. A provider may report that a retained task is unavailable, but a transport or provider error does not prove that a sandbox is gone. The host uses bounded retry rules for safe diagnostic classes and keeps replacement and cleanup decisions separate from those diagnostics.

Providers can use different execution backends behind the same driver contract. Kubernetes can use a long-lived sandbox resource or a one-shot job. Only the long-lived backend has the exec channel needed for native file sync, so the job backend keeps the generic transfer path. The host-visible contract stays the same while provider-specific deployment choices remain behind the plugin.

This flow shows how an execution run uses an external environment.

flowchart LR
    A[Environment configuration] --> B[Provider validation]
    B --> C[Lease acquisition or resume]
    C --> D[Workspace realization]
    D --> E[Commands and file transfer]
    E --> F[Runner task or live channel]
    F --> G[Release, stop, or destroy]
    B -. uncertain create .-> H[Ownership record and cleanup retry]

References: packages/…/define-plugin.ts• L403-571 packages/…/protocol.ts• L597-799 packages/…/environment-tasks.ts• L59-166 packages/…/environment-tasks.ts• L170-237 packages/…/environment-resume-error.ts• L7-85 packages/…/worker-rpc-host.ts• L1752-1843

Workspace providers

A workspace provider manages project source state beside the execution environment. It can prepare a shared workspace, an isolated workspace, or an operator branch. The host supplies an operation identity and checks that the provider returns the expected project, workspace, source revision, and branch binding.

Preparation can be asynchronous. The host accepts a pending preparation during submission and polls it later. Fresh workspace work can carry recovery data without exposing a VM, lease, or host path to the provider. Finalization proves that retained work is durable; removal is a separate operation that requires its own confirmation.

References: packages/…/workspace-provider.ts• L29-103 packages/…/workspace-provider.ts• L110-200 packages/…/workspace-provider.test.ts• L55-119

Runner tasks

Runner tasks separate durable run identity from provider task identity. Each operation has a matching result kind and task ID. This lets the host retry an ambiguous submission and resume saved state without treating an accepted stop as proof that execution has ended.

The contract makes per-turn and warm task lifetime explicit. Runner owns bounded launch requirements, credentials, configured environment, and execution-context versions. A provider cannot infer a feature from an incomplete request. Release and resume require the full durable identity and a valid bootstrap ticket when resuming work.

References: packages/…/environment-tasks.ts• L90-166 packages/…/environment-tasks.ts• L170-286 packages/…/environment-task-release-resume.test.ts• L55-173

Provider examples

The published Daytona provider illustrates a feature-rich environment contract. It supports reusable sandboxes, bounded lifetime, warm or per-turn Runner behavior, incremental output, authenticated Runner ingress, duplex channels, interactive setup, and workspace transfer. It records the provider identity and ownership evidence needed to adopt a slow creation or clean up an uncertain one.

Daytona can qualify a named snapshot by its immutable provider identity before allocation. It also applies safe stop, archive, and delete defaults. Those defaults remain outside host-owned warm-runner and reconnect windows, so provider cleanup does not interrupt work that Paperclip can still resume.

Live channels stay tied to the exact host route, worker session, and provider lease. Release revokes those routes before provider termination. A sandbox that is still changing state is not started until the provider confirms the transition or the operation reaches its deadline.

The Cloudflare provider illustrates a remote bridge variant of the same contract. Ordinary bridge calls use a transport deadline. Command execution can extend that deadline to cover the requested command time. Streaming execution reports output events and a final result. A bridge timeout crosses the worker boundary as a safe transport diagnostic rather than as provider detail.

References: packages/…/plugin.ts• L1234-1418 packages/…/plugin.ts• L1472-1526 packages/…/plugin.ts• L2764-2866 packages/…/plugin.ts• L2881-3119 packages/…/plugin.test.ts• L595-713 packages/…/plugin.test.ts• L1010-1264 packages/…/plugin.test.ts• L1272-1600 packages/…/plugin.test.ts• L765-920 packages/…/bridge-client.ts• L38-110 packages/…/bridge-client.ts• L228-275 packages/…/bridge-client.test.ts• L21-104 packages/…/package.json• L1-23

Data and service integration

The host gives plugins controlled ways to keep integration data and reach outside Paperclip. Plugin state and entities are isolated by plugin and explicit company scope. The registry stores installed identity, lifecycle status, company configuration and settings, external mappings, scheduled jobs, webhook deliveries, and the manifest that defines the active surfaces.

Plugin identity survives a soft uninstall so a later reinstall can restore the same plugin-scoped records. Company configuration is stored separately from the plugin record and is replayed to the single worker in a stable order. Changes to plugin manifests or workspace-provider declarations notify the work that depends on those contracts.

External service calls use a host HTTP client when the plugin declares outbound access. The host permits only HTTP and HTTPS, checks DNS results for private targets, pins a safe address, applies time and response limits, and records plugin activity through host-owned surfaces. Plugin issue reads follow host privacy rules, so a plugin is not automatically a company member.

AI connection pools add a plugin-owned selection layer above authorized connections. The host sends authorized member data and usage context. The plugin returns a member or a retry or unavailable result. It does not receive credentials or raw provider responses.

References: server/…/plugin-registry.ts• L61-72 server/…/plugin-registry.ts• L152-218 server/…/plugin-registry.ts• L220-340 server/…/plugin-registry.ts• L343-486 server/…/plugin-registry.ts• L692-897 packages/…/host-client-factory.ts• L376-439 packages/…/worker-rpc-host.ts• L629-677 server/…/plugin-host-services.ts• L105-242 server/…/plugin-host-services.ts• L834-960 server/…/plugin-host-services.ts• L1904-1912

Agent tools and UI surfaces

Plugin tools turn outside integration actions into agent-callable operations. A plugin declares each tool's name and input schema, then registers its handler in the worker. Paperclip namespaces the tool with the plugin identity and sends the active agent, run, company, and project context with each call.

Plugin UI uses the browser SDK entry point. It can read worker data, invoke actions, receive host actor context, navigate through the host router, and receive company-scoped live events. The host mounts declared pages, tabs, widgets, settings, and actions only for ready plugins.

Task panel activation connects authenticated runtime activity to a plugin agent-detail tab. The activity identifies a namespace and activity key. It is a display signal, not an authorization grant; core supplies the company, task, agent, and run context from the authenticated run.

References: packages/…/types.ts• L995-1055 packages/…/protocol.ts• L437-488 packages/…/worker-rpc-host.ts• L1403-1436 packages/…/worker-rpc-host.ts• L1522-1530

App connections

The app connection surface gives a company a guided way to discover a known service, add credentials or an endpoint, select agent actions, and control which agents may use them. Catalog visibility and saved connection recognition are separate, so an existing connection can remain valid when the visible catalog changes. External app connections explains this setup and access flow in more detail.

Connector plugins add a catalog app without granting tools by themselves. An operator or company administrator installs a connection and chooses its agent scope. The host validates connection settings, resolves a credential for one call when needed, and passes the selected connection and run context to the plugin.

Connector policy adds review before agent-facing external actions. The host matches a known connection or provider catalog, classifies discovered tools by risk, and quarantines new entries until they are reviewed. A connection search can also return an external provider choice. The agent must use the saved human answer before it can request that provider, and a broad catalog can be narrowed to the exact tools needed for one task.

References: packages/…/README.md• L118-151 packages/…/types.ts• L267-327 packages/…/types.ts• L1105-1137 packages/…/index.ts• L531-644 packages/…/worker-rpc-host.test.ts• L1248-1290

Machine interfaces

Paperclip provides operator and machine surfaces with different roles. The CLI starts and manages an instance for a human operator. MCP publishes typed Paperclip actions for agents and other machine clients. CLI and MCP interfaces covers both interfaces in detail.

The CLI startup path prepares an instance, loads or creates configuration, runs health checks, starts the server, and records the running instance for later control. Its test-drive path creates an isolated local instance for manual evaluation.

The MCP server adapts typed tools to the Paperclip HTTP API. A run-scoped MCP surface supports service discovery and connection requests when a human must complete setup. Tokens are bound to the run and checked before initialization, tool listing, and each call.

References: packages/…/index.ts• L52-92 packages/…/protocol.ts• L107-144 packages/…/protocol.ts• L162-179

Access boundaries

Capabilities are the permission contract for plugin features. The host checks them during manifest validation and again for worker-to-host operations. A missing capability or unknown operation produces a rejection rather than an implicit grant.

Company and actor context come from the host. Nested worker calls echo a host-issued invocation identifier. UI actions receive immutable actor context. Tool calls receive active run context. State, entities, managed resources, workspaces, and credentials remain scoped to their owning plugin, company, project, run, or lease.

Installed workers and same-origin UI are trusted code in the current deployment model. Capability checks protect the host API contract and tenant boundaries, but they do not replace process or browser isolation for untrusted code. Plugin HTTP access blocks private network targets, and plugin issue reads fail closed for private issues.

References: packages/…/host-client-factory.ts• L608-715 packages/…/protocol.ts• L107-144 packages/…/protocol.ts• L286-339 server/…/plugin-host-services.ts• L834-960 packages/…/worker-rpc-host.test.ts• L473-588

Change checklist

When these files or sections are changed, remember to consider these:

  • Keep manifest declarations, capability mapping, worker method names, optional handler advertisement, and host dispatch aligned for each plugin surface.
  • Keep package entrypoints, scaffold templates, local build recovery, activation status, timeout recovery, trusted install origins, and worker environment grants aligned.
  • Keep company scope aligned across host-to-worker calls, nested worker calls, configuration, secrets, project credentials, and workspace metadata.
  • Keep single-company and multi-company configuration behavior aligned across the SDK context, RPC payload, startup replay, and worker guard.
  • Keep plugin identity, idempotent bundled registration, soft uninstall, reactivation, company settings, external mappings, jobs, and webhook records aligned.
  • Keep connector app declarations aligned with connection settings, credential resolution, tool handlers, dynamic tool lists, review state, and agent grants.
  • Keep workspace provider requirements aligned with project lifecycle declarations, operation identity, source revision checks, asynchronous preparation, and binding validation.
  • Keep environment task operation kinds, launch requirements, credentials, durable identities, task IDs, lifecycle policy, and result validation aligned across the SDK and providers.
  • Keep release and resume results distinct from accepted or stopped results. A result must still prove the requested task operation.
  • Keep retry diagnostics separate from ownership, replacement, and cleanup evidence. A transport error does not prove that an environment is absent.
  • Keep provider creation-operation identity, ownership labels, observed provider IDs, timeout diagnostics, and cleanup records aligned so a late allocation is never adopted or deleted under the wrong lease.
  • Keep snapshot qualification tied to a verified immutable provider identity. A failed or timed-out qualification must not continue into sandbox allocation.
  • Keep lease identity, workspace identity, provider expiry, session identity, Runner ingress, live channels, and teardown evidence aligned across acquisition, resume, execution, and release.
  • Keep provider auto-stop windows beyond host warm-runner and Runner reconnect grace periods. Do not persist those host-owned floors as provider configuration.
  • Keep native sync negotiation aligned with both sync hooks and the fallback path. A backend must not claim a feature that it cannot serve.
  • Keep provider archive and file transfer behavior aligned with workspace confinement, archive size limits, free-space guards, partial-result handling, and scratch cleanup.
  • Keep bridge request deadlines aligned with command deadlines, streamed output handling, and typed transport error envelopes.
  • Keep connector source matching, reviewed adapters, risk classification, catalog freshness, provider-choice consent, scoped tool requests, and connection identity checks aligned.
  • Keep task panel activity identifiers aligned with authenticated Runner activity and the matching agent detail-tab declaration.
  • Keep provider tracing aligned with closed names, bounded attributes, invocation trace context, and the rule that telemetry cannot change work.
  • Treat SDK entry-point changes, task schemas, workspace bindings, MCP tool schemas, CLI options, and plugin manifests as external client contracts.

Important failure modes

TriggerConsequenceGuard
A plugin requests a host method without its declared capability.The operation is rejected before the host service runs.Manifest validation and host dispatch map operations to required capabilities.
A nested worker call names a different company from the active invocation.The host rejects the call instead of serving another company's data.Host-issued invocation scope is checked before dispatch.
A single-company worker receives a second company's distinct configuration during startup replay.The host rejects the update instead of replacing the first company's settings.Multi-company behavior requires explicit opt-in and configs replay in stable company order.
A bundled local plugin has missing entrypoints or runtime dependencies.Activation fails before the plugin can provide its surfaces.The loader builds trusted bundled packages and verifies the required output before retrying activation.
A plugin package requests sandbox-provider environment credentials without the required driver or trusted origin.The worker starts without those credentials.Environment-driver declaration, package identity, and trusted install origin gate the allowlist.
Two installed plugins declare the same page route.The new plugin cannot activate with an ambiguous UI route.The loader rejects duplicate routes within a manifest and conflicts with installed plugins.
A plugin is disabled while a scheduled run is pending.The run could execute after the plugin is no longer active.Lifecycle coordination stops new runs and cancels unstarted work.
A connector tool is declared without a worker handler.The connector worker fails to start or cannot serve the declared tool.Startup checks require every static connector tool to have a registered handler.
A workspace provider returns another project's or source revision's binding.Paperclip rejects the result and does not attach the workspace.Returned bindings are checked against operation input.
A workspace provider returns unsupported while polling an accepted preparation.The host cannot complete the preparation from that provider.Unsupported is allowed only during submission; later polls must return pending or prepared.
A task response has the wrong task ID or result kind.The host rejects the provider response.The SDK validates and matches every result.
A release or stop reply is accepted before the provider proves termination.The host could resume or reuse work that is still running.Release and resume contracts require exact operation results; termination uses a provider receipt.
A resume error contains only a provider message or an invalid diagnostic.The host cannot safely classify the failure for retry or cleanup.The SDK forwards only a closed status or transport-code envelope and validates it again at the host boundary.
Environment creation times out after the provider may have allocated a resource.The late resource could be orphaned or attached to the wrong lease.An attempt-specific identity and ownership labels support read-only observation, safe adoption only after exact matching, and durable cleanup retry.
Snapshot qualification returns an incomplete, mutable, or unverified identity.Paperclip could allocate from the wrong snapshot or use a name whose meaning changed.Qualification requires the expected immutable provider fields and stops before allocation when the lookup fails.
A cached provider handle is reused across leases or provider accounts.A command or file transfer could reach another sandbox.The cache uses company, environment, lease, and non-secret account scope. Every handle must match the requested provider lease.
A provider auto-stop interval ends during a warm Runner or reconnect grace window.A still-resumable run loses its sandbox before the host can reconnect.Daytona raises the provider floor beyond host-owned windows and keeps explicit disable values intact.
A provider advertises native sync without the matching worker hooks or backend channel.The host selects a transfer path the provider cannot serve.Startup negotiation and per-lease capability checks fail closed.
A provider session or live channel remains active during release.Work can continue after the lease ends.Admission closes, channels drain, and termination requires a provider receipt.
A file transfer archive contains an escaping entry or link.Extraction could write outside the intended workspace.The provider validates archive members and link targets before extraction.
Large file transfer compression is unavailable or fails.Transfer still takes the generic path without changing file contents.Compression is optional and falls back to the raw transfer path.
A plugin HTTP request resolves only to private or reserved addresses.The request cannot reach an internal host.The host validates DNS results and pins a public address.
A plugin tries to read a private issue or relation.The private record or relationship metadata is not returned.Plugin reads use the non-member issue privacy gate.
An agent requests a broad or unreviewed external tool catalog.Access is not granted to the connection or requested tools.Connection identity, active grants, review state, and exact tool names are checked.
An agent asks for an aggregator without a saved human provider choice.Connection setup pauses before external access is requested.The host requires a matching saved selection interaction.
A worker sends an unknown tracing name or unbounded attribute.The telemetry is dropped or reduced to a safe value.The host clamps names, attributes, values, and time ranges at the trust boundary.
An MCP request uses an invalid or ended-run token.Service discovery or connection setup stops before it affects the run.The runtime endpoint checks the token at each MCP lifecycle step.

Key files

FileWhy to read it
packages/…/README.mdGives plugin authors the supported package surfaces, connector model, deployment limits, and lifecycle rules.
packages/…/index.tsDefines the public worker SDK, protocol, context, manifest, environment, and connection exports.
packages/…/define-plugin.tsDefines plugin lifecycle hooks and product contribution handlers.
packages/…/types.tsDescribes worker context, tool and connector calls, managed resources, and scoped product data.
packages/…/protocol.tsDefines host-worker messages, invocation scope, environment operations, tasks, login sessions, and channels.
packages/…/environment-tasks.tsDefines the durable Runner task operations, credentials, and matching results.
packages/…/environment-resume-error.tsDefines safe diagnostics for classifying environment resume failures.
packages/…/workspace-provider.tsDefines workspace preparation, recovery, finalization, and removal contracts.
packages/…/worker-rpc-host.tsRuns the worker boundary, dispatches optional methods, carries host context, and controls idle sleep.
packages/…/host-client-factory.tsMaps worker calls to host services and enforces capability and invocation scope.
packages/…/testing.tsProvides in-memory host and environment harnesses for checking plugin contracts.
packages/…/index.tsShows the supported starter templates and the package shape generated for plugin authors.
server/…/plugin-loader.tsDiscovers, installs, builds, activates, and shuts down plugin packages.
server/…/plugin-registry.tsPersists plugin identity, company configuration, settings, external mappings, jobs, and webhook records.
server/…/plugin-host-services.tsShows the host boundary for Paperclip data, HTTP, issue privacy, secrets, and provider telemetry.
packages/…/plugin.tsIllustrates leases, snapshot qualification, creation cleanup, lifetime policy, Runner ingress, and live channels.
packages/…/bridge-client.tsIllustrates a remote environment bridge with bounded requests and streamed command output.