@volter/supercode-teams 0.2.20

package/browser-attach.mjs

@@ -0,0 +1,90 @@
+// A remote browser profile as a local CDP endpoint (company RFC 0008 §5). The
+// caller's own CDP client connects to 127.0.0.1; each WebSocket it opens rides
+// its own `product` stream to `browser-profile:<name>` on the machine, where the
+// daemon admits it and Volter Browsers' door reviews every command. The
+// machine's loopback cdpUrl and Volter Browsers' publication token never leave it.
+//
+// This is Volter Browsers' client, carried here until the Teams packages split.
+import { createServer } from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { WebSocketServer } from 'ws';
+import { fromWebPage } from './client.mjs';
+
+/**
+ * Serve `browser-profile:<profile>` locally. `/json/version` answers with a
+ * browser WebSocket URL on this listener, so `chromium.connectOverCDP(address)`
+ * and other CDP clients work unchanged. `channel` is a machine channel, or a
+ * function that opens one: with a function, a channel the server closed (a grant
+ * revoked or changed) is reopened for the next connection, which is admitted
+ * afresh. Returns { address, close }.
+ */
+export async function attachBrowserProfile(channel, { profile, listen = { host: '127.0.0.1', port: 0 } }) {
+  if (typeof profile !== 'string' || !profile) throw new Error('a browser profile name is required');
+  const target = `browser-profile:${profile}`;
+  const source = typeof channel === 'function' ? channel : null;
+  let current = source ? null : channel;
+  let opening = null;
+  const machine = async () => {
+    if (current && !current.closed) return current;
+    if (!source) throw new Error('the machine channel closed');
+    opening ??= source().then((opened) => { current = opened; return opened; }).finally(() => { opening = null; });
+    return opening;
+  };
+  // An unguessable path: another local user's page cannot open the socket by guessing it.
+  const path = `/devtools/browser/${randomBytes(12).toString('hex')}`;
+  const wss = new WebSocketServer({ noServer: true, maxPayload: 8 * 1024 * 1024 });
+  let base = '';
+  const http = createServer((req, res) => {
+    const route = new URL(req.url ?? '/', 'http://x').pathname.replace(/\/$/, '');
+    // Local programs only: a web page on this host (one a teammate drives included) never
+    // reads the socket path, and DNS rebinding never reaches it.
+    const host = String(req.headers.host ?? '');
+    if (fromWebPage(req) || !/^(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/.test(host)) { res.writeHead(403); res.end(); return; }
+    if (route === '/json/version') {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ Browser: `Volter Browsers (${profile})`, 'Protocol-Version': '1.3', webSocketDebuggerUrl: `ws://${base}${path}` }));
+      return;
+    }
+    if (route === '/json' || route === '/json/list') {
+      // Pages are discovered over the browser socket (Target.getTargets); none are routed separately.
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end('[]');
+      return;
+    }
+    res.writeHead(404); res.end();
+  });
+  http.on('upgrade', async (req, socket, head) => {
+    if (fromWebPage(req) || new URL(req.url ?? '/', 'http://x').pathname !== path) { socket.end('HTTP/1.1 404 Not Found\r\n\r\n'); return; }
+    let stream;
+    try { stream = await (await machine()).open('product', { target }); }
+    catch (error) { socket.end(`HTTP/1.1 403 Forbidden\r\nContent-Type: text/plain\r\n\r\n${String(error.message).slice(0, 200)}`); return; }
+    wss.handleUpgrade(req, socket, head, (client) => {
+      stream.on('data', (text) => { if (client.readyState === client.OPEN) client.send(String(text)); });
+      stream.on('close', (reason) => client.close(1000, String(reason ?? '').slice(0, 120)));
+      client.on('message', (data, binary) => { if (!binary && !stream.closed) stream.write(String(data)); });
+      client.on('close', () => stream.close());
+      client.on('error', () => stream.close());
+    });
+  });
+  await new Promise((resolve, reject) => { http.once('error', reject); http.listen(listen.port ?? 0, listen.host ?? '127.0.0.1', resolve); });
+  const a = http.address();
+  base = `${a.family === 'IPv6' ? `[${a.address}]` : a.address}:${a.port}`;
+  return {
+    address: `http://${base}`,
+    close: () => new Promise((resolve) => { for (const client of wss.clients) client.terminate(); if (source) current?.close?.(); http.close(() => resolve()); }),
+  };
+}
+
+/**
+ * The browser profiles a machine's Volter Browsers serves, as `view` on `browser-profile:*`
+ * sees them: each one's name, whether its browser is running, whether it may be shared with
+ * teammates, and the sites a running one is signed in to (domains only).
+ */
+export async function listBrowserProfiles(channel) {
+  const stream = await channel.open('product', { target: 'browser-profile:*', op: 'list' });
+  return new Promise((resolve, reject) => {
+    let answered = false;
+    stream.on('data', (text) => { answered = true; try { resolve(JSON.parse(String(text)).profiles); } catch (error) { reject(error); } });
+    stream.on('close', (reason) => { if (!answered) reject(new Error(`the machine answered no list${reason ? `: ${reason}` : ''}`)); });
+  });
+}

package/client.mjs

@@ -0,0 +1,212 @@
+// The harness's side of a machine channel (opened with @volter/teams/client): operators
+// get a `HarnessTransport` so the harness SDK runs unchanged over the channel; everyone
+// gets terminal attachments, files, ports and describe as their grants allow. The
+// frontend package loads when a runtime attachment is first opened.
+import { connect as netConnect } from 'node:net';
+import { randomBytes } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { Channel } from '@volter/teams/channel';
+import { openLocalMachine, openRemoteMachine, StreamRpc, fromWebPage } from '@volter/teams/client';
+
+export { openLocalMachine, openRemoteMachine, StreamRpc, fromWebPage };
+
+export async function execServerBridge(channel, harness, { host = '127.0.0.1' } = {}) {
+  // a channel, or a function opening one per connection (closed with it), so a daemon's restart strands nothing
+  const own = typeof channel === 'function';
+  const source = own ? channel : async () => channel;
+  const { WebSocketServer } = await import('ws');
+  // An unguessable path, and no request a web page makes: a page on this host (one a teammate
+  // drives through Volter Browsers included) must not reach the machine's exec server.
+  const route = `/${randomBytes(12).toString('hex')}`;
+  const server = new WebSocketServer({ host, port: 0, path: route, maxPayload: 64 * 1024 * 1024, verifyClient: ({ req }) => !fromWebPage(req) });
+  await new Promise((resolve, reject) => { server.once('listening', resolve); server.once('error', reject); });
+  server.on('connection', async (socket) => {
+    // the client speaks first (its `initialize`), before the stream below is open: hold its frames till then
+    let stream = null;
+    const early = [];
+    const send = (data) => stream.write(Buffer.from(`${data.toString('utf8').replace(/\n$/, '')}\n`, 'utf8').toString('base64'));
+    socket.on('message', (data) => { if (!stream) early.push(data); else if (!stream.closed) send(data); });
+    socket.on('close', () => { if (stream && !stream.closed) stream.close('client closed'); });
+    let ch = null;
+    try { ch = await source(); stream = await ch.open('exec-server', { harness }); }
+    catch (error) { if (own) ch?.close?.(); socket.close(1011, String(error.message ?? error).slice(0, 120)); return; }
+    if (own) stream.on('close', () => ch.close?.());
+    if (socket.readyState !== socket.OPEN) { stream.close('client closed'); return; }
+    let buffer = '';
+    stream.on('data', (chunk) => {
+      buffer += Buffer.from(chunk, 'base64').toString('utf8');
+      let nl;
+      while ((nl = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        if (line) socket.send(line);
+      }
+    });
+    stream.on('close', (reason) => socket.close(1000, String(reason ?? '').slice(0, 120)));
+    for (const data of early.splice(0)) send(data);
+  });
+  const { port } = server.address();
+  return {
+    url: `ws://${host}:${port}${route}`,
+    close: () => new Promise((resolve) => { for (const client of server.clients) client.terminate(); server.close(() => resolve()); }),
+  };
+}
+
+/**
+ * A `HarnessTransport` (harness SDK `ClientOptions.transport`) over the
+ * channel's `harness` stream. Only an operator's channel is admitted to it.
+ */
+export function harnessTransport(channel) {
+  let stream = null;
+  return {
+    get running() { return stream !== null && !stream.closed; },
+    async start(handlers) {
+      stream = await channel.open('harness');
+      let buffer = '';
+      stream.on('data', (chunk) => {
+        buffer += chunk;
+        let index;
+        while ((index = buffer.indexOf('\n')) >= 0) {
+          const line = buffer.slice(0, index);
+          buffer = buffer.slice(index + 1);
+          if (line) handlers.onLine(line);
+        }
+      });
+      stream.on('close', (reason) => handlers.onExit(null, reason ?? null));
+    },
+    write(line) {
+      if (!stream || stream.closed) throw new Error('harness stream is not open');
+      stream.write(line.endsWith('\n') ? line : line + '\n');
+    },
+    async close() {
+      stream?.close();
+      stream = null;
+    },
+  };
+}
+
+/** The node's own doors (describe, grants, launch, files, ports, attention, titles) over the `node` stream. */
+export async function nodeRpc(channel) {
+  const stream = await channel.open('node');
+  return new StreamRpc(stream);
+}
+
+/**
+ * Attach to a pane. Returns an EventEmitter: 'data' (string of terminal
+ * bytes), 'close'; `write(text)` sends input when mode is control;
+ * `resize(cols, rows)`; `close()`.
+ */
+export async function attachPane(channel, { pane, mode = 'observe', cols = 120, rows = 40 }) {
+  const stream = await channel.open('terminal', { pane, mode, cols, rows });
+  const emitter = new EventEmitter();
+  stream.on('data', (chunk) => {
+    // The terminal substrate speaks JSON frames: {type:'hello',cols,rows} | {type:'data',data} | {type:'error',message};
+    // the node adds {type:'notice',message} for input it refused (a suspended pane).
+    const text = Buffer.from(chunk, 'base64').toString('utf8');
+    let frame = null;
+    try { frame = JSON.parse(text); } catch { /* raw bytes */ }
+    if (frame && typeof frame.data === 'string') emitter.emit('data', frame.data);
+    else if (frame && frame.type === 'hello') emitter.emit('hello', frame);
+    else if (frame && frame.type === 'error') emitter.emit('error-message', frame.message);
+    else if (frame && frame.type === 'notice') emitter.emit('notice', frame.message);
+    else emitter.emit('data', text);
+  });
+  stream.on('close', (reason) => emitter.emit('close', reason));
+  emitter.write = (text) => stream.write(JSON.stringify({ input: text }));
+  emitter.resize = (c, r) => stream.write(JSON.stringify({ resize: { cols: c, rows: r } }));
+  emitter.close = () => stream.close();
+  return emitter;
+}
+
+/**
+ * Attach to a MANAGED runtime on the Machine (frontend.v2 over the
+ * channel). Returns a `FrontendClient` from `@volter/supercode-frontend`
+ * whose fetch rides the channel's `frontend` stream; the node resolves the
+ * runtime's receipt and mints this principal its own credential, so `lease()`,
+ * `takeControl()`, `sendInput()`, `startEvents()` behave exactly as on loopback
+ * and the lease coordinator sees this caller as its own RuntimeClientId.
+ */
+export async function attachRuntime(channel, { runtime, permissions = ['observe', 'interact', 'approve'] }) {
+  const { FrontendClient } = await import('@volter/supercode-frontend');
+  const stream = await channel.open('frontend', { runtime });
+  let next = 1;
+  const pending = new Map(); // id → { onHead, onChunk, onEnd }
+  stream.on('data', (chunk) => {
+    let message;
+    try { message = JSON.parse(chunk); } catch { return; }
+    const waiter = pending.get(message.id);
+    if (!waiter) return;
+    if (message.status !== undefined && !waiter.headed) { waiter.headed = true; waiter.onHead(message); }
+    if (message.chunk) waiter.onChunk(Buffer.from(message.chunk, 'base64'));
+    if (message.end) { pending.delete(message.id); waiter.onEnd(message.error ?? null); }
+  });
+  stream.on('close', (reason) => {
+    for (const waiter of pending.values()) waiter.onEnd(reason ?? 'stream closed');
+    pending.clear();
+  });
+  const fetchOverStream = (url, init = {}) => new Promise((resolve, reject) => {
+    const id = next++;
+    const path = url.startsWith('http') ? new URL(url).pathname + new URL(url).search : url;
+    let controller;
+    const body = new ReadableStream({ start(c) { controller = c; } });
+    const waiter = {
+      headed: false,
+      onHead: (head) => resolve(new Response(body, { status: head.status, headers: head.headers ?? {} })),
+      onChunk: (bytes) => { try { controller.enqueue(new Uint8Array(bytes)); } catch { /* consumer gone */ } },
+      onEnd: (error) => { try { if (error && !waiter.headed) reject(new Error(error)); controller.close(); } catch { /* already closed */ } },
+    };
+    pending.set(id, waiter);
+    init.signal?.addEventListener('abort', () => { pending.delete(id); stream.write(JSON.stringify({ id, abort: true })); try { controller.error(new Error('aborted')); } catch { /* closed */ } });
+    const bodyText = init.body == null ? null : typeof init.body === 'string' ? Buffer.from(init.body) : Buffer.from(init.body);
+    stream.write(JSON.stringify({ id, method: init.method ?? 'GET', path, headers: init.headers ?? {}, body: bodyText ? bodyText.toString('base64') : null }));
+  });
+  const client = new FrontendClient({ baseUrl: 'http://node', token: 'via-node', permissions, fetch: fetchOverStream });
+  client.detachChannel = () => stream.close();
+  return client;
+}
+
+/**
+ * Forward a Machine port to this box (`port:<pane>/<n>`): a local listener whose
+ * every accepted connection rides its own `port` stream to 127.0.0.1:<port> on the Machine.
+ * Returns { address, close }.
+ */
+export async function forwardPort(channel, { pane = null, port, listen = { host: '127.0.0.1', port: 0 } }) {
+  const { createServer } = await import('node:net');
+  const server = createServer(async (local) => {
+    let remote;
+    try {
+      remote = await channel.open('port', { pane, port });
+    } catch (error) {
+      local.destroy(error);
+      return;
+    }
+    remote.on('data', (chunk) => { if (!local.destroyed) local.write(Buffer.from(chunk, 'base64')); });
+    remote.on('close', () => local.end());
+    local.on('data', (bytes) => { if (!remote.closed) remote.write(bytes.toString('base64')); });
+    local.on('close', () => remote.close());
+    local.on('error', () => remote.close());
+  });
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(listen.port ?? 0, listen.host ?? '127.0.0.1', resolve); });
+  const a = server.address();
+  return { address: `${a.address}:${a.port}`, close: () => new Promise((r) => server.close(() => r())) };
+}
+
+/**
+ * Watch a Machine's live state: 'snapshot' once, then 'delta' events with pane
+ * added/changed/gone and port changes; 'error' for a tick that failed; 'close'. The node
+ * shows a participant only the panes its grants cover.
+ */
+export async function watchMachine(channel, { intervalMs = 1000 } = {}) {
+  const stream = await channel.open('watch', { intervalMs });
+  const emitter = new EventEmitter();
+  stream.on('data', (chunk) => {
+    let message;
+    try { message = JSON.parse(chunk); } catch { return; }
+    if (message.type === 'snapshot') emitter.emit('snapshot', message);
+    else if (message.type === 'delta') emitter.emit('delta', message);
+    else if (message.type === 'error') emitter.emit('error-message', message.message);
+  });
+  stream.on('close', (reason) => emitter.emit('close', reason));
+  emitter.close = () => stream.close();
+  return emitter;
+}

package/connector/effects.mjs

@@ -0,0 +1,95 @@
+import { ERROR_CODES } from '../contracts/index.mjs';
+// A native action crosses a process boundary. Persist intent before crossing it;
+// an unanswered claim or action is reconciled as unknown, never executed again.
+export class EffectConsumer {
+  constructor(connector, adapter) { this.connector = connector; this.adapter = adapter; this.work = Promise.resolve(); }
+  poll() {
+    const work = this.work.then(() => this.pollSerial());
+    this.work = work.catch(() => {});
+    return work;
+  }
+  async pollSerial() {
+    const c = this.connector;
+    await this.adapter.recheck?.();
+    for (const [id, local] of Object.entries(c.state.effects)) {
+      if (local.result && !local.reported && local.incarnation_id === c.state.incarnation_id) {
+        try {
+          const path = `/machines/${c.machineId}/effects/${encodeURIComponent(id)}`;
+          const delivery = await c.effectRequest('GET', path);
+          await this.report(delivery.effect, path, local.result);
+        } catch (error) { c.lastError = error; }
+      }
+    }
+    let after = null;
+    do {
+      const page = await c.effectRequest('GET', `/machines/${c.machineId}/effects?limit=100${after ? `&after=${encodeURIComponent(after)}` : ''}`);
+      for (const delivery of page.items ?? []) {
+        try { await this.consume(delivery); }
+        catch (error) { c.lastError = error; }
+      }
+      if (page.next_cursor === after && after !== null) throw new Error('effect pagination did not advance');
+      after = page.next_cursor ?? null;
+    } while (after && !c.abort.signal.aborted);
+  }
+  async consume(delivery) {
+    const c = this.connector, effect = delivery.effect, id = effect.id;
+    if (effect.incarnation_id !== c.state.incarnation_id || effect.machine_id !== c.machineId || effect.team_id !== c.teamId) return;
+    const path = `/machines/${c.machineId}/effects/${encodeURIComponent(id)}`;
+    let local = c.state.effects[id];
+    if (local?.result) return this.report(effect, path, local.result);
+    if (local || delivery.state === 'running') {
+      // A claim response may have been lost. Even when the server still says pending,
+      // the persisted attempt is not replayed: claim under a fresh key then report unknown.
+      if (delivery.state === 'pending') {
+        const claim = await c.effectRequest('POST', `${path}/claim`, { incarnation_id: c.state.incarnation_id }, { freshKey: true });
+        if (!claim.execute && claim.delivery.state !== 'running') return;
+      }
+      return this.finish(effect, path, { state: 'unknown', error: null });
+    }
+    if (effect.expires_at <= c.clock.nowMs() || c.abort.signal.aborted) return;
+    let prepared, preparationError;
+    try { prepared = await this.adapter.prepare(effect); } catch (error) { preparationError = error; }
+    c.state.effects[id] = { state: 'claiming', incarnation_id: c.state.incarnation_id }; c.save();
+    let claim;
+    try { claim = await c.effectRequest('POST', `${path}/claim`, { incarnation_id: c.state.incarnation_id }, { freshKey: true }); }
+    catch (error) { await prepared?.dispose?.(); throw error; }
+    if (!claim.execute) {
+      await prepared?.dispose?.();
+      if (claim.delivery.state === 'running') return this.finish(effect, path, { state: 'unknown', error: null });
+      return;
+    }
+    if (preparationError) return this.finish(effect, path, failed(preparationError));
+    c.state.effects[id] = { state: 'started', incarnation_id: c.state.incarnation_id }; c.save();
+    let result;
+    try {
+      if (c.abort.signal.aborted || effect.expires_at <= c.clock.nowMs()) {
+        result = failed(Object.assign(new Error('effect expired before native execution'), { code: 'forbidden' }));
+      } else {
+        const receipt = await prepared.execute();
+        result = { state: 'succeeded', receipt: { native_session_id: receipt?.native_session_id ?? null, runtime_id: receipt?.runtime_id ?? null } };
+      }
+    } catch (error) {
+      // Only a locally proven refusal is a failure. Timeout, transport loss and an
+      // arbitrary native exception cannot prove the harness did not perform the action.
+      result = error.nativeOutcome === 'failed' ? failed(error) : { state: 'unknown', error: null };
+    } finally { await prepared?.dispose?.(); }
+    return this.finish(effect, path, result);
+  }
+  async finish(effect, path, result) {
+    const c = this.connector;
+    c.state.effects[effect.id] = { state: 'finished', incarnation_id: c.state.incarnation_id, result }; c.save();
+    return this.report(effect, path, result);
+  }
+  async report(effect, path, result) {
+    try { await this.connector.effectRequest('POST', `${path}/result`, result); }
+    catch (error) { if ([401,403,404,409].includes(error.status)) await this.adapter.discard?.(effect); throw error; }
+    if (result.state === 'succeeded') await this.adapter.activate?.(effect);
+    else await this.adapter.discard?.(effect);
+    this.connector.state.effects[effect.id].reported = true; this.connector.save();
+  }
+}
+function failed(error) {
+  const nativeCode = ({busy:'controller_busy',controller_required:'controller_busy',lease_expired:'conflict',unauthenticated:'authentication_required',unauthorized:'forbidden',unsupported_action:'unsupported',invalid_argument:'invalid_request'})[error.sdkCode];
+  const code = [nativeCode, error.sdkCode, error.data?.code, error.code].find(value => ERROR_CODES.includes(value)) ?? 'unsupported';
+  return { state: 'failed', error: { code, message: error.teamsSafeMessage ? error.message : 'native adapter could not safely complete the requested action', request_id: 'local', retryable: false, details: null } };
+}

package/connector/index.d.ts

@@ -0,0 +1,69 @@
+import type { CaptureReceipt, Coverage, HarnessId, NormalizedMessage, SyncRule, NativeEffect } from '../contracts/index.js';
+
+import type { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
+
+export interface ConnectorClock {
+  nowMs(): number;
+}
+
+export interface LoadedConnectorSession {
+  messages?: Array<NormalizedMessage | ({ value: NormalizedMessage } & Record<string, unknown>)>;
+  turns?: Array<NormalizedMessage | ({ value: NormalizedMessage } & Record<string, unknown>)>;
+  title?: string | null;
+  repository?: unknown;
+  recorded_activity_at?: number | null;
+}
+
+export interface ConnectorCore {
+  translateSession?: SupercodeHarnessClient['translateSession'];
+  runtimeCapabilities?: SupercodeHarnessClient['runtimeCapabilities'];
+  attachManagedRuntime?: SupercodeHarnessClient['attachManagedRuntime'];
+  resumeManagedRuntime?: SupercodeHarnessClient['resumeManagedRuntime'];
+  materializeSession?: SupercodeHarnessClient['materializeSession'];
+  session(locator: unknown): { load(): Promise<LoadedConnectorSession>; follow?(options?: { signal?: AbortSignal }): AsyncIterable<unknown> };
+  discover?(query: { workspace?: string; harnesses?: HarnessId[]; homes?: unknown; limit?: number; cursor?: string }): Promise<{ sessions?: Array<{ locator: { harness?: HarnessId; session_id?: string } & Record<string, unknown> }>; entries?: Array<{ locator: { harness?: HarnessId; session_id?: string } & Record<string, unknown> }>; next_cursor?: string | null; nextCursor?: string | null }>;
+}
+
+export interface TeamsConnectorOptions {
+  server: string;
+  teamId: string;
+  machineId: string;
+  sourceId: string;
+  credential: string;
+  stateDir: string;
+  core: ConnectorCore;
+  /** Optional embedding adapter; ambiguous exceptions are never retried. */
+  effectExecutor?: (effect: NativeEffect, context: {core: ConnectorCore; signal: AbortSignal}) => Promise<{native_session_id?: string | null; runtime_id?: string | null} | void>;
+  clock?: ConnectorClock;
+  fetch?: typeof globalThis.fetch;
+}
+
+export interface CaptureOptions {
+  locator: unknown;
+  descriptor?: { title?: string | null; updated_at_ms?: number | null; parent_session_id?: string | null } | null;
+  harness: HarnessId;
+  nativeSessionId: string;
+  visibility?: 'team' | 'restricted';
+  ruleId: string;
+  ruleRevision: number;
+  coverage?: Coverage;
+  backfill?: 'none' | 'all' | { mode: 'none' | 'all' } | { mode: 'since'; since: number };
+}
+
+export interface ConnectorConfigurationValue {
+  machine: unknown;
+  source: unknown;
+  rules: SyncRule[];
+  authorization_revision: number;
+}
+
+export declare class TeamsConnector {
+  constructor(options: TeamsConnectorOptions);
+  readonly lastError?: unknown;
+  configuration(): Promise<ConnectorConfigurationValue>;
+  start(options?: { bindings?: () => unknown | Promise<unknown>; roots?: () => Array<{ id: string; machine_id: string; name: string; harnesses: HarnessId[]; path?: string; workspace?: string; homes?: unknown }> | Promise<Array<{ id: string; machine_id: string; name: string; harnesses: HarnessId[]; path?: string; workspace?: string; homes?: unknown }>> }): Promise<ConnectorConfigurationValue>;
+  capture(options: CaptureOptions): Promise<CaptureReceipt | null>;
+  flush(): Promise<CaptureReceipt | null>;
+  pollEffects(): Promise<void>;
+  stop(): Promise<void>;
+}