mindwire 0.1.0 → 0.1.1

package/dist/run.d.ts

@@ -0,0 +1,97 @@
+import type { Http } from "./http.js";
+import type { Event, ResultInfo, RespondInput, Run as RunData } from "./types.js";
+export interface StreamOptions {
+    signal?: AbortSignal;
+    /**
+     * Include the daemon's `{ type: "status", meta: { stream: "open" } }` sentinel that is
+     * flushed the instant the stream opens (used to detect a live vs. buffered transport).
+     * Off by default — most consumers only care about model output.
+     */
+    includeOpenSentinel?: boolean;
+}
+export interface WaitResult {
+    run: RunData;
+    result?: ResultInfo;
+}
+/**
+ * A handle to one turn's run. Wraps the durable `Run` record returned by `POST /turns` and
+ * exposes the unified event stream, cancellation, and status polling.
+ *
+ * Stream it directly:
+ *
+ * ```ts
+ * const run = await mw.turn({ chatId, message: "refactor foo" });
+ * for await (const ev of run) {
+ *   if (ev.type === "text") process.stdout.write(ev.text ?? "");
+ * }
+ * ```
+ */
+export declare class Run {
+    private data;
+    private readonly http;
+    constructor(http: Http, data: RunData);
+    get id(): string;
+    get chatId(): string;
+    get agent(): string | undefined;
+    get status(): RunData["status"];
+    /** `"resolve"` on the parent of a global-resolve run; `undefined` for an ordinary turn. */
+    get kind(): RunData["kind"];
+    /** On a child iteration of a resolve run, the id of its parent resolve run; else `undefined`. */
+    get parentId(): string | undefined;
+    /** Parent of a resolve run only: why the loop ended (`"done"` | `"capped"` | `"error"` | …). */
+    get stopReason(): RunData["stopReason"];
+    /** Parent of a resolve run only: how many child turns the loop ran. */
+    get iterations(): number | undefined;
+    /** The latest known run record. */
+    get value(): RunData;
+    /** Unified SSE event stream: replay buffer, then live events, then close. */
+    stream(opts?: StreamOptions): AsyncGenerator<Event, void, unknown>;
+    /** `for await (const ev of run)` — sugar for `run.stream()`. */
+    [Symbol.asyncIterator](): AsyncGenerator<Event, void, unknown>;
+    /** Cancel the in-flight turn (kills the underlying agent process). */
+    cancel(): Promise<void>;
+    /**
+     * Answer a mid-turn interaction the turn is waiting on — a permission approval, or an
+     * AskUserQuestion / ExitPlanMode reply. Requires the agent's `respond` capability.
+     */
+    respond(input?: RespondInput): Promise<void>;
+    /**
+     * Steer a follow-up message into the running turn without cancelling it. Requires the agent's
+     * `input` capability.
+     */
+    sendInput(text: string): Promise<void>;
+    /**
+     * Soft-stop the running turn (ask the agent to halt current work) without the hard process kill
+     * {@link Run.cancel} does — the turn stays open for a follow-up via {@link Run.sendInput}.
+     * Requires the agent's `interrupt` capability.
+     */
+    interrupt(): Promise<void>;
+    /**
+     * Switch the model of the live turn. An empty/omitted `model` resets the turn to the agent/CLI
+     * default. Only meaningful on a persistent (non-bypass) turn; on a one-shot turn it is a
+     * best-effort no-op. Requires the agent's `setModel` capability.
+     */
+    setModel(model?: string): Promise<void>;
+    /**
+     * Switch the permission mode of the live turn (e.g. `default`, `acceptEdits`, `plan`,
+     * `bypassPermissions`). Only meaningful on a persistent (non-bypass) turn; on a one-shot turn it
+     * is a best-effort no-op. Requires the agent's `setPermissionMode` capability.
+     */
+    setPermissionMode(mode: string): Promise<void>;
+    /**
+     * `GET /runs/{id}/children` — the child iterations of a global-resolve run, oldest→newest, each as
+     * its own {@link Run} handle. An ordinary turn (or a resolve that ran a single iteration) returns an
+     * empty array. Use it to inspect the run tree a {@link Mindwire.resolve} produced.
+     */
+    children(): Promise<Run[]>;
+    /** Re-fetch the run record from the daemon and update this handle. */
+    refresh(): Promise<RunData>;
+    /**
+     * Consume the event stream to completion. Returns the final run record and the `result`
+     * event's summary (if any). Throws {@link RunFailedError} on an `error`/`cancelled` outcome
+     * unless `throwOnError` is set to `false`.
+     */
+    wait(opts?: StreamOptions & {
+        throwOnError?: boolean;
+    }): Promise<WaitResult>;
+}

package/dist/sse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A minimal, dependency-free Server-Sent Events reader.
+ *
+ * The daemon streams `data: <json>\n\n` frames (one JSON object per event) plus `: ping`
+ * comment keepalives and an initial `{ "type": "status", "meta": { "stream": "open" } }`
+ * sentinel. This parser handles multi-line `data:` fields and `\r\n`/`\n` line endings, and
+ * yields the JSON-parsed payload of each event.
+ *
+ * We read via `ReadableStream.getReader()` rather than `for await` so it works on every
+ * runtime with WHATWG streams (Node 18+ undici, Deno, Bun, browsers), not only those that
+ * made the stream async-iterable.
+ */
+export declare function readSSE<T>(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<T, void, unknown>;

package/dist/target/container.d.ts

@@ -0,0 +1,60 @@
+import { type SandboxHost, type ExecResult, type EnsureEvent } from "./host.js";
+/** What {@link provisionContainer} needs to bring up a daemon-in-a-container over a base host. */
+export interface ContainerConfig {
+    /** Create + own a container from this image. */
+    image?: string;
+    /** Attach to an existing container (id or name) instead of creating one. */
+    container?: string;
+    /** Name for a container we create. */
+    name?: string;
+    /** Docker-on-host policy. `"never"` (default) detects and fails; `"ifMissing"` installs + starts it. */
+    install?: "never" | "ifMissing";
+    /** Extra args spliced into `docker run` (before the image), e.g. `["-e", "FOO=bar", "--gpus", "all"]`. */
+    createArgs?: string[];
+    /** Port the in-container daemon binds (published to an ephemeral loopback host port). */
+    daemonPort: number;
+    /** `AGENT_TYPE` for the in-container daemon. */
+    agent: string;
+    /** `AGENT_CWD` — working directory agents run in, inside the container. */
+    agentCwd: string;
+    /** Explicit path to a Linux `mindwired` to deploy (else resolved from the platform package). */
+    daemonBin?: string;
+    /** Redeploy when the running daemon's version differs from the SDK's bundled binary. */
+    autoUpdate?: boolean;
+    /** On `stop()`, `docker rm -f` a container we created (attached containers are left running). */
+    stopOnExit?: boolean;
+    /** Destination label carried on every {@link EnsureEvent}. Defaults to `"container"`. */
+    target?: string;
+}
+/** What {@link provisionContainer} resolves: the container it ensured and how to reach + tear it down. */
+export interface ContainerHandle {
+    /** The full container id (created) or the id/name we attached to. */
+    containerId: string;
+    /** The ephemeral host port the in-container daemon is published to, on the base machine's loopback. */
+    hostPort: number;
+    /** Tear down: `docker rm -f` the container if we created it and `stopOnExit` is set. Idempotent. */
+    stop(): Promise<void>;
+}
+/**
+ * Ensure Docker on the base host, bring up a container, and deploy `mindwired` inside it. Decoupled and
+ * injectable (like `provisionSsh`/`provisionDocker`): tests drive it with a fake {@link SandboxHost}.
+ * The `install`/`provision` phases stream through `onLog`; the daemon cycle then streams its own phases.
+ */
+export declare function provisionContainer(host: SandboxHost, cfg: ContainerConfig, onLog?: (e: EnsureEvent) => void): Promise<ContainerHandle>;
+/**
+ * Wraps a base {@link SandboxHost} so every command runs *inside* a container and every file lands
+ * inside it — nothing more than `docker exec` / `docker cp` layered on the base's own `exec`/`putFile`.
+ * This is the crux of the reuse: the shared {@link ensureDaemon} cycle sees an ordinary `SandboxHost`
+ * and never learns there's a container (or an SSH hop) underneath.
+ */
+export declare class ContainerHost implements SandboxHost {
+    private readonly base;
+    private readonly containerId;
+    constructor(base: SandboxHost, containerId: string);
+    exec(argv: string[], opts?: {
+        timeoutSeconds?: number;
+    }): Promise<ExecResult>;
+    putFile(path: string, data: Uint8Array, opts?: {
+        mode?: string;
+    }): Promise<void>;
+}

package/dist/target/docker.d.ts

@@ -0,0 +1,114 @@
+import { type EnsureEvent } from "./host.js";
+import type { Target, TargetHandle } from "./index.js";
+/**
+ * How to reach the Docker **engine**. Passed straight to `new Docker(engine)` (the `dockerode`
+ * constructor) — a local socket or a TCP/TLS endpoint. Nested (not flattened) so its `port` (the
+ * engine's TCP port) never collides with {@link DockerConfig.port} (the in-container daemon's port).
+ * Omit it entirely for the ambient local engine.
+ *
+ * To reach a **remote host over SSH**, prefer `ssh({ docker })` — mindwire's exec-based container layer
+ * that needs only SSH credentials (no engine socket forwarding, no extra deps) — rather than routing
+ * `dockerode` over SSH here.
+ */
+export interface DockerEngineOptions {
+    /** Remote engine host (TCP). */
+    host?: string;
+    /** Engine TCP port (e.g. 2375 / 2376). */
+    port?: number;
+    /** Local engine socket path (e.g. `/var/run/docker.sock`). */
+    socketPath?: string;
+    /** Transport to the engine. */
+    protocol?: "http" | "https";
+    /** TLS material for a `https` engine. */
+    ca?: string | Buffer;
+    /** TLS material for a `https` engine. */
+    cert?: string | Buffer;
+    /** TLS material for a `https` engine. */
+    key?: string | Buffer;
+}
+/**
+ * Config for the Docker target. Supply `image` to create+own a container, or `container` to attach to
+ * an existing one (which must already publish `port`). Point at a remote engine with `engine` (or pass
+ * your own `docker` instance). `agent` falls back to the client's default agent.
+ */
+export interface DockerConfig {
+    /** A `dockerode` instance to use. Takes precedence over `engine`. Defaults to `new Docker(engine)`. */
+    docker?: DockerodeLike;
+    /** How to reach the Docker engine (remote host / socket / TLS). Ignored when `docker` is passed. */
+    engine?: DockerEngineOptions;
+    /** Create + own a container from this image. */
+    image?: string;
+    /** Attach to an existing container (id or name) instead of creating one. */
+    container?: string;
+    /** Extra options merged into `createContainer` (native dockerode/Docker API fields). */
+    createOptions?: Record<string, unknown>;
+    /** Port the in-container daemon binds (published to an ephemeral host port). */
+    port?: number;
+    /** `AGENT_TYPE` for the in-container daemon. Defaults to the client's agent, then `claude-code`. */
+    agent?: string;
+    /** `AGENT_CWD` — working directory agents run in, inside the container. */
+    agentCwd?: string;
+    /** Explicit path to a Linux `mindwired` to deploy (else resolved from the platform package). */
+    daemonBin?: string;
+    /** Redeploy when the running daemon's version differs from the SDK's bundled binary. */
+    autoUpdate?: boolean;
+    /** On `close()`, stop + remove a container we created (attached containers are left running). */
+    stopOnExit?: boolean;
+}
+/**
+ * The Docker target. Returns a {@link Target} whose `connect()` creates (or attaches to) a container,
+ * ensures `mindwired` runs inside it, and points the SDK at the published port.
+ *
+ * ```ts
+ * new Mindwire({ agent: "claude-code", target: docker({ image: "my/agent-image" }) });
+ * new Mindwire({ agent: "claude-code", target: docker({ container: "my-running-box" }) });
+ * new Mindwire({ agent: "claude-code", target: docker({ image: "x", engine: { host: "10.0.0.5", port: 2375 } }) });
+ * ```
+ */
+export declare function docker(config?: DockerConfig): Target;
+interface DuplexLike {
+    on(event: string, listener: (...args: unknown[]) => void): DuplexLike;
+}
+interface ExecLike {
+    start(opts: Record<string, unknown>): Promise<DuplexLike>;
+    inspect(): Promise<{
+        ExitCode?: number;
+        Running?: boolean;
+    }>;
+}
+interface ContainerInspect {
+    State?: {
+        Running?: boolean;
+    };
+    NetworkSettings?: {
+        Ports?: Record<string, Array<{
+            HostIp?: string;
+            HostPort?: string;
+        }> | null>;
+    };
+}
+interface ContainerLike {
+    readonly id: string;
+    start(): Promise<unknown>;
+    stop(): Promise<unknown>;
+    remove(opts?: Record<string, unknown>): Promise<unknown>;
+    inspect(): Promise<ContainerInspect>;
+    exec(opts: Record<string, unknown>): Promise<ExecLike>;
+    putArchive(file: Uint8Array, opts: {
+        path: string;
+    }): Promise<unknown>;
+    modem: {
+        demuxStream(stream: DuplexLike, stdout: unknown, stderr: unknown): void;
+    };
+}
+export interface DockerodeLike {
+    getContainer(id: string): ContainerLike;
+    createContainer(opts: Record<string, unknown>): Promise<ContainerLike>;
+}
+/**
+ * The provisioning flow, decoupled from the `dockerode` import so it can be driven by an injected fake
+ * in tests. Creates (or attaches to) a container, resolves its published host port, ensures the
+ * daemon, and returns a handle pointed at `http://127.0.0.1:<hostPort>`.
+ */
+export declare function provisionDocker(docker: DockerodeLike, config?: DockerConfig, onLog?: (e: EnsureEvent) => void): Promise<TargetHandle>;
+export {};

package/dist/target/host.d.ts

@@ -0,0 +1,81 @@
+/** Result of running a command in a sandbox — normalized (camelCase) across backends. */
+export interface ExecResult {
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    error?: string;
+}
+/**
+ * The minimal surface an adapter exposes so the shared {@link ensureDaemon} cycle can drive any
+ * backend. Two primitives only — running a command to completion, and landing raw bytes at a path.
+ * How they're implemented (Oblien's runtime exec + base64 files API, Docker's exec + tar putArchive,
+ * …) is the adapter's business; the cycle never sees it.
+ */
+export interface SandboxHost {
+    /** Run a command to completion (foreground) inside the sandbox and return its buffered result. */
+    exec(argv: string[], opts?: {
+        timeoutSeconds?: number;
+    }): Promise<ExecResult>;
+    /** Land raw bytes at an absolute path inside the sandbox (made executable via `opts.mode`). */
+    putFile(path: string, data: Uint8Array, opts?: {
+        mode?: string;
+    }): Promise<void>;
+}
+/** What {@link ensureDaemon} needs: the daemon knobs plus the reconcile inputs. */
+export interface EnsureDaemonConfig {
+    /** Port the in-sandbox daemon binds (on `0.0.0.0`, so a published port can route in). */
+    port: number;
+    /** `AGENT_TYPE` for the in-sandbox daemon. */
+    agent: string;
+    /** `AGENT_CWD` — working directory agents run in, inside the sandbox. */
+    agentCwd: string;
+    /** Explicit path to a Linux `mindwired` to deploy (else resolved from the platform package). */
+    daemonBin?: string;
+    /** Redeploy when the running daemon's version differs from `desiredVersion`. Off by default. */
+    autoUpdate?: boolean;
+    /** Version to reconcile against. Defaults to {@link SDK_VERSION} (the bundled binary's version). */
+    desiredVersion?: string;
+    /** Destination label carried on every {@link EnsureEvent} (e.g. `"ssh"`/`"docker"`/`"oblien"`). */
+    target?: string;
+    /** Receives a step {@link EnsureEvent} at each phase. A throwing callback can't abort provisioning. */
+    onLog?: (e: EnsureEvent) => void;
+}
+/**
+ * A progress event emitted at each phase of the ensure cycle (and, one-shot, by the `local`/`remote`
+ * targets). Surfaced to the caller through the client `logger` callback; the same steps `mw.ensure()`
+ * awaits. Normal order: `connect` (runtime reachable) → `probe` (health checked) → either `skip`
+ * (a healthy current daemon is kept) or `upload` → `launch` → `ready` (a daemon is deployed). `error`
+ * is emitted if any phase throws.
+ *
+ * Two extra phases prefix the cycle when a container is provisioned first (e.g. `ssh({ docker })`):
+ * `install` (Docker on the host detected — and, opt-in, installed/started) and `provision` (the
+ * container created/started and its published port resolved). Those are emitted by the container layer
+ * before it hands the in-container host to the ensure cycle, so the full order is
+ * `connect → install → provision → probe → (skip | upload → launch → ready)`.
+ */
+export interface EnsureEvent {
+    phase: "connect" | "install" | "provision" | "probe" | "download" | "upload" | "launch" | "ready" | "skip" | "error";
+    /** Destination label, e.g. `"ssh"` / `"docker"` / `"oblien"` / `"local"` / `"remote"`. */
+    target: string;
+    /** Human-readable one-line status. */
+    message: string;
+    /** The daemon's reported version, when known (on `probe` / `skip`). */
+    version?: string;
+    /** Target architecture the daemon was resolved for (on `upload`). */
+    arch?: "amd64" | "arm64";
+    /** Size of the uploaded daemon binary in bytes (on `upload`). */
+    bytes?: number;
+    /** Error message (on `error`). */
+    error?: string;
+}
+/**
+ * Make sure a healthy `mindwired` of the desired version is reachable at `127.0.0.1:<port>` inside the
+ * sandbox, deploying it if absent (or redeploying if stale and `autoUpdate` is set). Idempotent: a
+ * healthy, current daemon (e.g. an image that autostarts it, or a reused sandbox) is a no-op.
+ */
+export declare function ensureDaemon(host: SandboxHost, cfg: EnsureDaemonConfig): Promise<void>;
+/**
+ * Resolve a Linux `mindwired` on the host running the SDK: an explicit `daemonBin`, else download the
+ * SDK-matched release binary, verify its checksum, and return its local cache path for upload.
+ */
+export declare function resolveLinuxDaemon(explicit: string | undefined, arch: "amd64" | "arm64"): Promise<string>;

package/dist/target/index.d.ts

@@ -0,0 +1,76 @@
+import type { FetchLike, TokenGetter } from "../http.js";
+import { type EmbeddedOptions } from "../embedded.js";
+import type { EnsureEvent } from "./host.js";
+/**
+ * What `connect()` is told about the turn's context. Provisioning knobs (image, port, credentials, …)
+ * live on each factory's own config — this is only the client-level context every target shares.
+ */
+export interface ConnectSpec {
+    /** The client's default agent, used as the in-daemon `AGENT_TYPE` when the target provisions one. */
+    agent?: string;
+    /** Receives an {@link EnsureEvent} at each provisioning phase (wired from the client `logger`). */
+    onLog?: (e: EnsureEvent) => void;
+}
+/**
+ * A live transport descriptor a target returns from {@link Target.connect} — everything the SDK's
+ * `Http` layer needs to reach the daemon at this destination.
+ */
+export interface TargetHandle {
+    /** Stable id of the destination this handle drives (for logging / reuse). */
+    id: string;
+    /** Base URL for the daemon. With a custom `fetch`, this may be a sentinel the fetch strips. */
+    baseUrl: string;
+    /**
+     * A transport-specific `fetch` for this destination — used for both unary requests and SSE streams.
+     * A target supplies it to route every call through its runtime (e.g. Oblien's `rt.proxy`); a
+     * direct-HTTP destination (loopback, a published Docker port, an SSH tunnel) omits it and the
+     * client's default fetch is used.
+     */
+    fetch?: FetchLike;
+    /** Per-request headers this transport must send (e.g. a proxy-target port). */
+    headers?: Record<string, string>;
+    /** A static bearer token, if the destination uses one. */
+    token?: string;
+    /** Fetch the current bearer for a rotating credential; re-mints on `{force:true}`. */
+    getToken?: TokenGetter;
+    /** Release destination-owned resources (per the factory's `stopOnExit`). Idempotent. */
+    stop(): Promise<void>;
+}
+/**
+ * A destination for the mindwire daemon. Given a {@link ConnectSpec}, provision (or reuse) the
+ * environment, ensure a reachable daemon, and return a {@link TargetHandle}. The built-ins are
+ * {@link local} / {@link remote} (here) and {@link import("./ssh.js").ssh} /
+ * {@link import("./docker.js").docker} / {@link import("./oblien.js").oblien}; a custom backend is
+ * just another object with this shape.
+ */
+export interface Target {
+    /** Destination id, e.g. `"local"` / `"remote"` / `"ssh"` / `"docker"` / `"oblien"`. */
+    readonly name: string;
+    connect(spec: ConnectSpec): Promise<TargetHandle>;
+}
+/**
+ * The default destination: an **embedded** daemon on loopback. On a server runtime (Node/Bun/Deno)
+ * `connect()` auto-spawns the bundled `mindwired` on a free `127.0.0.1` port and points the SDK at it,
+ * so `new Mindwire()` "just works" with nothing to deploy.
+ *
+ * Embedded daemons are memoized by config (see embedded.ts): two zero-config `local()` clients share
+ * one loopback daemon (one environment), while `local({ cwd })` / `local({ statePath })` isolate into
+ * their own. `stop()` is a **no-op** — the shared daemon is reaped on process exit (Risk 5).
+ */
+export declare function local(opts?: EmbeddedOptions): Target;
+/** Options for {@link remote}. */
+export interface RemoteOptions {
+    /** Bearer token for the daemon, if it requires one. */
+    token?: string;
+    /** Extra headers merged into every request. */
+    headers?: Record<string, string>;
+    /** Custom fetch for this destination (else the client default / global fetch). */
+    fetch?: FetchLike;
+}
+/**
+ * A **remote** daemon you already run, reached over plain HTTP at `baseUrl`. `connect()` returns the
+ * transport immediately without a network round-trip — there is no ensure/probe here; `mw.health()`
+ * is the real liveness check (Risk 6). Required in the browser / edge runtimes, where a daemon can't
+ * be spawned. `stop()` is a no-op (mindwire doesn't own a daemon it didn't start).
+ */
+export declare function remote(baseUrl: string, opts?: RemoteOptions): Target;

package/dist/target/oblien.d.ts

@@ -0,0 +1,112 @@
+import { type EnsureEvent } from "./host.js";
+import type { Target, TargetHandle } from "./index.js";
+/**
+ * Config for the Oblien target — auth + endpoint plus the workspace/daemon provisioning knobs. Only
+ * `clientId`/`clientSecret`/`baseUrl` are about reaching Oblien; everything else describes the
+ * workspace to provision and the daemon to run in it. Credentials fall back to the environment (see
+ * {@link connectOblien}); the daemon's `agent` falls back to the client's default agent.
+ */
+export interface OblienConfig {
+    /** Sandbox client id. Falls back to `MINDWIRE_SANDBOX_CLIENT_ID`, then `OBLIEN_CLIENT_ID`. */
+    clientId?: string;
+    /** Sandbox client secret. Falls back to `MINDWIRE_SANDBOX_CLIENT_SECRET`, then `OBLIEN_CLIENT_SECRET`. */
+    clientSecret?: string;
+    /** Management-API base. Defaults to the `oblien` SDK default. */
+    baseUrl?: string;
+    /** `AGENT_TYPE` for the in-workspace daemon. Defaults to the client's agent, then `claude-code`. */
+    agent?: string;
+    /** `AGENT_CWD` — working directory agents run in, inside the workspace. */
+    agentCwd?: string;
+    /** Loopback port the in-workspace daemon listens on. */
+    port?: number;
+    /** Explicit path to a Linux `mindwired` to deploy (else resolved from the platform package). */
+    daemonBin?: string;
+    /** Redeploy the daemon when the running version differs from the SDK's bundled binary. Off by default. */
+    autoUpdate?: boolean;
+    /** On `close()`, tear the workspace down (delete one we created / stop one we reused). */
+    stopOnExit?: boolean;
+    /** Image for a new workspace. Ideally one that already runs `mindwired` and ships the target agent CLI. */
+    image?: string;
+    /** Name for a new workspace. */
+    name?: string;
+    /** Reuse an existing workspace instead of creating one (skips the cold-start provision). */
+    workspaceId?: string;
+    /** vCPUs for a new workspace. */
+    cpus?: number;
+    /** Memory (MB) for a new workspace. */
+    memoryMb?: number;
+    /** Disk (MB) for a new workspace. */
+    diskMb?: number;
+    /** Lifecycle: `temporary` (auto-reaped) or `permanent`. */
+    mode?: "temporary" | "permanent";
+}
+/**
+ * The Oblien target. Returns a {@link Target} whose `connect()` provisions (or reuses) an Oblien
+ * workspace, ensures `mindwired` runs inside it, and points the SDK at the runtime proxy. The
+ * `oblien` npm peer is only touched inside `connect()`.
+ *
+ * ```ts
+ * new Mindwire({ agent: "claude-code", target: oblien({ clientId, clientSecret }) });
+ * ```
+ */
+export declare function oblien(config?: OblienConfig): Target;
+interface OblienExecResult {
+    exit_code?: number;
+    stdout?: string;
+    stderr?: string;
+    error?: string;
+    status?: string;
+}
+interface OblienExecParams {
+    execMode?: "auto" | "shell" | "direct";
+    timeoutSeconds?: number;
+    keepLogs?: boolean;
+}
+interface RuntimeProxyLike {
+    /** Reverse-proxy a request to `127.0.0.1:<port>` inside the workspace. SSE/streaming passes through. */
+    fetch(input: string, init?: RequestInit): Promise<Response>;
+}
+interface RuntimeLike {
+    exec: {
+        run(cmd: string[], params?: OblienExecParams): Promise<OblienExecResult>;
+    };
+    files: {
+        write(params: {
+            fullPath: string;
+            content: string;
+            createDirs?: boolean;
+            append?: boolean;
+            mode?: string;
+        }): Promise<unknown>;
+    };
+    proxy(port: number, host?: string): RuntimeProxyLike;
+}
+interface WorkspaceHandleLike {
+    id: string;
+    start(params?: {
+        force?: boolean;
+    }): Promise<unknown>;
+    stop(): Promise<unknown>;
+    delete(): Promise<unknown>;
+    runtime(options?: {
+        force?: boolean;
+    }): Promise<RuntimeLike>;
+}
+interface OblienClientLike {
+    workspaces: {
+        create(params: Record<string, unknown>): Promise<{
+            id: string;
+        }>;
+    };
+    workspace(id: string): WorkspaceHandleLike;
+}
+/**
+ * The provisioning flow, decoupled from the `oblien` import so it can be driven by an injected client
+ * (used by the unit tests, and available for advanced embedding). Provisions/reuses a workspace,
+ * ensures the daemon, and returns a handle whose `fetch` routes every request through the runtime
+ * proxy (re-acquiring the runtime and retrying once on a `401`).
+ */
+export declare function provisionOblien(client: OblienClientLike, config?: OblienConfig, onLog?: (e: EnsureEvent) => void): Promise<TargetHandle & {
+    workspaceId: string;
+}>;
+export {};