@cmetech/otto 1.1.1 → 1.2.4

package/packages/coworker-persona/src/manifest.ts

@@ -0,0 +1,49 @@
+// Persona manifest parser. See spec §2.5.
+import { parse as parseYaml } from 'yaml';
+
+export interface PersonaStatusLine {
+  label: string;
+  color: string;     // hex
+  icon: string;
+}
+
+export interface PersonaMemorySeed {
+  apply_on_first_activation: boolean;
+  scope?: 'global' | 'per-project' | 'per-project-tagged';
+}
+
+export interface PersonaManifest {
+  name: string;
+  display_name: string;
+  version: string;
+  description: string;
+  author: string;
+  otto_version_required: string;
+  steering: string[];
+  memory_seed?: PersonaMemorySeed;
+  engines?: string;
+  artifact_kinds?: string[];
+  skills_path?: string;
+  status_line: PersonaStatusLine;
+}
+
+// Order matters: tests assert the FIRST missing field reported, and the
+// "missing version" case supplies only `name`, so `version` must be checked
+// before `display_name`.
+const REQUIRED: Array<keyof PersonaManifest> = [
+  'name', 'version', 'display_name', 'description', 'author',
+  'otto_version_required', 'steering', 'status_line',
+];
+
+export function parsePersonaManifest(yamlText: string): PersonaManifest {
+  const raw = parseYaml(yamlText) as Record<string, unknown> | null;
+  if (!raw || typeof raw !== 'object') {
+    throw new Error('persona manifest must be a YAML object');
+  }
+  for (const field of REQUIRED) {
+    if (!(field in raw)) {
+      throw new Error(`persona manifest missing required field: ${field}`);
+    }
+  }
+  return raw as unknown as PersonaManifest;
+}

package/packages/coworker-persona/src/registry.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { PersonaRegistry } from './registry.js';
+
+let tmpHome: string;
+
+describe('PersonaRegistry', () => {
+  beforeEach(async () => {
+    tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), 'persona-test-'));
+    await fs.mkdir(path.join(tmpHome, 'personas'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpHome, { recursive: true, force: true });
+  });
+
+  it('list returns built-in default persona on a fresh registry', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    await r.ensureDefaultInstalled();
+    const installed = await r.list();
+    assert.ok(installed.find(p => p.name === 'default'), 'default persona should be installed');
+  });
+
+  it('install copies a bundle directory into ~/.otto/personas/<name>', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    // Stage a fake persona bundle
+    const bundle = await fs.mkdtemp(path.join(os.tmpdir(), 'fake-bundle-'));
+    await fs.mkdir(path.join(bundle, 'steering'), { recursive: true });
+    await fs.writeFile(path.join(bundle, 'manifest.yaml'),
+      'name: noc-ops\ndisplay_name: NOC\nversion: 1.0.0\ndescription: x\nauthor: x\notto_version_required: ">=2.0.0"\nsteering: [steering/identity.md]\nstatus_line: { label: NOC, color: "#FAD22D", icon: "🛡" }\n');
+    await fs.writeFile(path.join(bundle, 'steering', 'identity.md'), 'noc identity');
+
+    await r.installFromPath(bundle);
+    const installed = await r.list();
+    assert.ok(installed.find(p => p.name === 'noc-ops'));
+    await fs.rm(bundle, { recursive: true, force: true });
+  });
+
+  it('install rejects a bundle missing manifest.yaml', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    const bad = await fs.mkdtemp(path.join(os.tmpdir(), 'bad-bundle-'));
+    await assert.rejects(() => r.installFromPath(bad), /manifest\.yaml/);
+    await fs.rm(bad, { recursive: true, force: true });
+  });
+
+  it('activateInWorkspace writes <workspace>/.otto/persona.json', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    await r.ensureDefaultInstalled();
+    const ws = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-'));
+    await r.activateInWorkspace(ws, 'default');
+    const raw = await fs.readFile(path.join(ws, '.otto', 'persona.json'), 'utf8');
+    const data = JSON.parse(raw);
+    assert.equal(data.active, 'default');
+    assert.equal(typeof data.activated_at, 'string');
+    assert.equal(data.memory_seed_applied, false);
+    await fs.rm(ws, { recursive: true, force: true });
+  });
+
+  it('activeInWorkspace returns "default" when no persona.json exists', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    await r.ensureDefaultInstalled();
+    const ws = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-'));
+    const active = await r.activeInWorkspace(ws);
+    assert.equal(active.name, 'default');
+    await fs.rm(ws, { recursive: true, force: true });
+  });
+
+  it('uninstall refuses if persona is currently active in any tracked workspace', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    await r.ensureDefaultInstalled();
+    // Stage + install a second persona, then activate it
+    const bundle = await fs.mkdtemp(path.join(os.tmpdir(), 'fake-bundle-'));
+    await fs.mkdir(path.join(bundle, 'steering'), { recursive: true });
+    await fs.writeFile(path.join(bundle, 'manifest.yaml'),
+      'name: noc-ops\ndisplay_name: NOC\nversion: 1.0.0\ndescription: x\nauthor: x\notto_version_required: ">=2.0.0"\nsteering: [steering/identity.md]\nstatus_line: { label: NOC, color: "#FAD22D", icon: "🛡" }\n');
+    await fs.writeFile(path.join(bundle, 'steering', 'identity.md'), 'noc');
+    await r.installFromPath(bundle);
+
+    const ws = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-'));
+    await r.activateInWorkspace(ws, 'noc-ops');
+    await assert.rejects(() => r.uninstall('noc-ops', { trackedWorkspaces: [ws] }), /active/);
+
+    await fs.rm(bundle, { recursive: true, force: true });
+    await fs.rm(ws, { recursive: true, force: true });
+  });
+});

package/packages/coworker-persona/src/registry.ts

@@ -0,0 +1,147 @@
+// PersonaRegistry — install / list / activate / switch. Spec §2.5.
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parsePersonaManifest, type PersonaManifest } from './manifest.js';
+
+export interface RegistryOptions {
+  ottoHome: string;            // typically ~/.otto
+}
+
+export interface ActiveRecord {
+  active: string;
+  activated_at: string;
+  memory_seed_applied: boolean;
+}
+
+async function dirExists(p: string): Promise<boolean> {
+  try {
+    const s = await fs.stat(p);
+    return s.isDirectory();
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return false;
+    throw err;
+  }
+}
+
+async function copyDir(src: string, dst: string): Promise<void> {
+  await fs.mkdir(dst, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const e of entries) {
+    const s = path.join(src, e.name);
+    const d = path.join(dst, e.name);
+    if (e.isDirectory()) {
+      await copyDir(s, d);
+    } else {
+      await fs.copyFile(s, d);
+    }
+  }
+}
+
+export class PersonaRegistry {
+  #personasDir: string;
+
+  constructor(opts: RegistryOptions) {
+    this.#personasDir = path.join(opts.ottoHome, 'personas');
+  }
+
+  async ensureDefaultInstalled(): Promise<void> {
+    const target = path.join(this.#personasDir, 'default');
+    if (await dirExists(target)) return;
+    // Source: bundled defaults shipped with this package
+    const here = path.dirname(new URL(import.meta.url).pathname);
+    const source = path.join(here, 'defaults');
+    await copyDir(source, target);
+  }
+
+  async list(): Promise<PersonaManifest[]> {
+    if (!(await dirExists(this.#personasDir))) return [];
+    const entries = await fs.readdir(this.#personasDir, { withFileTypes: true });
+    const out: PersonaManifest[] = [];
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const manifestPath = path.join(this.#personasDir, e.name, 'manifest.yaml');
+      try {
+        const raw = await fs.readFile(manifestPath, 'utf8');
+        out.push(parsePersonaManifest(raw));
+      } catch {
+        // skip malformed bundles
+      }
+    }
+    return out;
+  }
+
+  async installFromPath(bundlePath: string): Promise<PersonaManifest> {
+    const manifestPath = path.join(bundlePath, 'manifest.yaml');
+    let raw: string;
+    try {
+      raw = await fs.readFile(manifestPath, 'utf8');
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        throw new Error(`bundle missing manifest.yaml at ${manifestPath}`);
+      }
+      throw err;
+    }
+    const manifest = parsePersonaManifest(raw);
+    const target = path.join(this.#personasDir, manifest.name);
+    await fs.rm(target, { recursive: true, force: true });
+    await copyDir(bundlePath, target);
+    return manifest;
+  }
+
+  async activateInWorkspace(workspaceRoot: string, name: string): Promise<void> {
+    const persona = await this.get(name);
+    if (!persona) throw new Error(`persona not installed: ${name}`);
+    const wsOtto = path.join(workspaceRoot, '.otto');
+    await fs.mkdir(wsOtto, { recursive: true });
+    const record: ActiveRecord = {
+      active: name,
+      activated_at: new Date().toISOString(),
+      memory_seed_applied: false,
+    };
+    await fs.writeFile(path.join(wsOtto, 'persona.json'), JSON.stringify(record, null, 2));
+  }
+
+  async activeInWorkspace(workspaceRoot: string): Promise<PersonaManifest> {
+    const recordPath = path.join(workspaceRoot, '.otto', 'persona.json');
+    try {
+      const raw = await fs.readFile(recordPath, 'utf8');
+      const record = JSON.parse(raw) as ActiveRecord;
+      const m = await this.get(record.active);
+      if (m) return m;
+    } catch {
+      // fall through to default
+    }
+    const def = await this.get('default');
+    if (!def) throw new Error('default persona not installed');
+    return def;
+  }
+
+  async get(name: string): Promise<PersonaManifest | null> {
+    const manifestPath = path.join(this.#personasDir, name, 'manifest.yaml');
+    try {
+      const raw = await fs.readFile(manifestPath, 'utf8');
+      return parsePersonaManifest(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  async uninstall(name: string, opts: { trackedWorkspaces: string[] }): Promise<void> {
+    if (name === 'default') {
+      throw new Error('cannot uninstall the built-in default persona');
+    }
+    for (const ws of opts.trackedWorkspaces) {
+      try {
+        const raw = await fs.readFile(path.join(ws, '.otto', 'persona.json'), 'utf8');
+        const record = JSON.parse(raw) as ActiveRecord;
+        if (record.active === name) {
+          throw new Error(`persona ${name} is active in workspace ${ws}; switch first`);
+        }
+      } catch (err: unknown) {
+        if ((err as NodeJS.ErrnoException).code === 'ENOENT') continue;
+        if (err instanceof Error && err.message.startsWith('persona ')) throw err;
+      }
+    }
+    await fs.rm(path.join(this.#personasDir, name), { recursive: true, force: true });
+  }
+}

package/packages/coworker-persona/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ES2022",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/packages/coworker-persona/tsconfig.publish.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": { "incremental": false }
+}

package/packages/coworker-scratchpad/dist/cell-archive.d.ts

@@ -0,0 +1,39 @@
+export declare const CELLS_SCHEMA_VERSION = 1;
+export interface CellEntry {
+    id: number;
+    parentId: number | null;
+    code: string;
+    ok: boolean;
+    value?: unknown;
+    error?: {
+        name: string;
+        message: string;
+    };
+    stdout: string;
+    ts: string;
+}
+export interface AppendInput {
+    code: string;
+    ok: boolean;
+    value?: unknown;
+    error?: {
+        name: string;
+        message: string;
+    };
+    stdout: string;
+}
+export declare class CellArchive {
+    #private;
+    private readonly dir;
+    private readonly now;
+    private readonly path;
+    private nextId;
+    constructor(dir: string, now?: () => number);
+    private scan;
+    private ensureHeader;
+    append(input: AppendInput): CellEntry;
+    get lastId(): number | null;
+    get leafId(): number | null;
+    setLeaf(id: number | null): void;
+    reset(): void;
+}

package/packages/coworker-scratchpad/dist/cell-archive.js

@@ -0,0 +1,77 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const CELLS_SCHEMA_VERSION = 1;
+export class CellArchive {
+    dir;
+    now;
+    path;
+    nextId;
+    #lastId;
+    #leafId;
+    constructor(dir, now = Date.now) {
+        this.dir = dir;
+        this.now = now;
+        this.path = join(dir, 'cells.jsonl');
+        const { nextId, lastId } = this.scan();
+        this.nextId = nextId;
+        this.#lastId = lastId;
+        this.#leafId = lastId;
+    }
+    scan() {
+        if (!existsSync(this.path))
+            return { nextId: 1, lastId: null };
+        let lastId = null;
+        for (const line of readFileSync(this.path, 'utf8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (typeof obj.id === 'number')
+                    lastId = obj.id;
+            }
+            catch {
+                // header or corrupt line -> ignore
+            }
+        }
+        return { nextId: (lastId ?? 0) + 1, lastId };
+    }
+    ensureHeader() {
+        if (existsSync(this.path))
+            return;
+        mkdirSync(this.dir, { recursive: true });
+        appendFileSync(this.path, JSON.stringify({ type: 'header', version: CELLS_SCHEMA_VERSION }) + '\n');
+    }
+    append(input) {
+        this.ensureHeader();
+        const id = this.nextId++;
+        const entry = {
+            id,
+            parentId: this.#leafId,
+            code: input.code,
+            ok: input.ok,
+            ...(input.ok ? { value: input.value } : { error: input.error }),
+            stdout: input.stdout,
+            ts: new Date(this.now()).toISOString(),
+        };
+        appendFileSync(this.path, JSON.stringify(entry) + '\n');
+        this.#lastId = id;
+        this.#leafId = id;
+        return entry;
+    }
+    get lastId() {
+        return this.#lastId;
+    }
+    get leafId() {
+        return this.#leafId;
+    }
+    setLeaf(id) {
+        this.#leafId = id;
+    }
+    reset() {
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(this.path, JSON.stringify({ type: 'header', version: CELLS_SCHEMA_VERSION }) + '\n');
+        this.nextId = 1;
+        this.#lastId = null;
+        this.#leafId = null;
+    }
+}

package/packages/coworker-scratchpad/dist/cell-tree.d.ts

@@ -0,0 +1,14 @@
+import type { CellEntry } from './cell-archive.js';
+export interface TreeNode {
+    cell: CellEntry;
+    children: TreeNode[];
+}
+export interface CellTree {
+    root: TreeNode | null;
+    byId: Map<number, TreeNode>;
+    orphans: TreeNode[];
+}
+export declare function projectTree(cells: CellEntry[]): CellTree;
+export declare function findLeaves(tree: CellTree): TreeNode[];
+export declare function validateLeafId(tree: CellTree, id: number): void;
+export declare function formatTreeText(tree: CellTree, currentLeaf?: number | null): string;

package/packages/coworker-scratchpad/dist/cell-tree.js

@@ -0,0 +1,72 @@
+export function projectTree(cells) {
+    const byId = new Map();
+    for (const cell of cells)
+        byId.set(cell.id, { cell, children: [] });
+    const orphans = [];
+    const rootCandidates = [];
+    for (const cell of cells) {
+        const node = byId.get(cell.id);
+        if (cell.parentId === null) {
+            rootCandidates.push(node);
+            continue;
+        }
+        const parent = byId.get(cell.parentId);
+        if (parent)
+            parent.children.push(node);
+        else
+            orphans.push(node);
+    }
+    let root = null;
+    if (rootCandidates.length >= 1) {
+        root = rootCandidates[0];
+        // 1d/1d2 invariant: exactly one root. Defensive: extra roots become orphans.
+        for (let i = 1; i < rootCandidates.length; i++)
+            orphans.push(rootCandidates[i]);
+    }
+    return { root, byId, orphans };
+}
+export function findLeaves(tree) {
+    const out = [];
+    for (const node of tree.byId.values()) {
+        if (node.children.length === 0)
+            out.push(node);
+    }
+    return out;
+}
+export function validateLeafId(tree, id) {
+    if (!tree.byId.has(id)) {
+        throw new Error(`cell id ${id} not found`);
+    }
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + '…';
+}
+function summarizeCell(cell) {
+    const okFlag = cell.ok ? 'ok ' : 'err';
+    const detail = cell.ok
+        ? `value=${truncate(JSON.stringify(cell.value ?? null), 40)}`
+        : `error=${truncate(cell.error?.message ?? '', 40)}`;
+    const codePreview = truncate(cell.code.split('\n')[0], 60);
+    return `#${cell.id} ${okFlag} ${detail.padEnd(45)} ${codePreview}`;
+}
+function renderNode(node, depth, lastSibling, currentLeaf, out) {
+    const indent = '  '.repeat(depth);
+    const connector = lastSibling ? '└─' : '├─';
+    const marker = currentLeaf === node.cell.id ? ' *' : '';
+    out.push(`${indent}${connector} ${summarizeCell(node.cell)}${marker}`);
+    const last = node.children.length - 1;
+    node.children.forEach((child, i) => renderNode(child, depth + 1, i === last, currentLeaf, out));
+}
+export function formatTreeText(tree, currentLeaf) {
+    const lines = [];
+    if (tree.root)
+        renderNode(tree.root, 0, true, currentLeaf ?? null, lines);
+    if (tree.orphans.length > 0) {
+        lines.push('# orphans:');
+        const last = tree.orphans.length - 1;
+        tree.orphans.forEach((o, i) => renderNode(o, 0, i === last, currentLeaf ?? null, lines));
+    }
+    return lines.join('\n');
+}

package/packages/coworker-scratchpad/dist/child-process-runtime.d.ts

@@ -0,0 +1,129 @@
+import type { CredentialInjector } from '@otto/coworker-vault';
+import type { ArtifactCreateDrawer, DataLoadDrawer, RecoveryNote, SnapshotResult } from './kernel-protocol.js';
+export interface CellResult {
+    value: unknown;
+    stdout: string;
+}
+export interface ChildProcessRuntimeOptions {
+    workspace: string;
+    onDataLoad?: (drawer: DataLoadDrawer) => void;
+    cellTimeoutMs?: number;
+    inactivityTimeoutMs?: number;
+    inactivityAfterProgressMs?: number;
+    cancelGraceMs?: number;
+    entryPath?: string;
+    scratchpadDir?: string;
+    /**
+     * Phase 2 Task 13: optional vault credential injector. When provided alongside
+     * a non-empty `bindings`, the runtime adds OTTO_DS_* env vars to the spawned
+     * kernel's environment (after the existing env filter). Absent => no-op; the
+     * runtime behaves exactly as it did pre-Phase-2.
+     */
+    injector?: CredentialInjector;
+    bindings?: string[];
+    /**
+     * Phase 2 Task 13: identifies this runtime's scratchpad for audit records the
+     * injector emits. The runtime itself doesn't otherwise use this field.
+     */
+    scratchpadName?: string;
+    /**
+     * Phase 2 Task 13: session id stamped on audit records the injector emits.
+     * Empty string is a valid no-session value.
+     */
+    sessionId?: string;
+    /**
+     * Phase 4 Task 10: Layer-B fan-out for artifact_create events. The kernel
+     * emits one of these after every successful otto.artifact.create RPC; the
+     * runtime forwards the drawer to this callback so the manager can record it
+     * into memory. Absent => artifact_create events are dropped.
+     */
+    onArtifactCreate?: (drawer: ArtifactCreateDrawer) => void;
+    /**
+     * Phase 4 Task 10: parent-side handler for `artifact_create` RPC requests.
+     * The runtime calls this when it sees an `{type:'request', request:'artifact_create'}`
+     * frame on the child's stdout and writes the resolved response (or an error
+     * frame) back to the child's stdin. If absent, the request is rejected with
+     * "artifacts unavailable" so the cell fails fast instead of hanging.
+     */
+    handleArtifactCreate?: (req: {
+        kind: string;
+        name: string;
+    }) => Promise<{
+        slug: string;
+        uri: string;
+        primary_path: string;
+    }>;
+    /**
+     * Phase 4 Task 10: parent-side handler for `artifact_update` RPC requests.
+     * Mirror of handleArtifactCreate for the update path.
+     */
+    handleArtifactUpdate?: (req: {
+        slug: string;
+        files: Array<{
+            path: string;
+            content: string;
+        }>;
+    }) => Promise<{
+        files_touched: string[];
+    }>;
+}
+export declare class ChildProcessRuntime {
+    private readonly options;
+    private child;
+    private readonly pending;
+    private readonly pendingSnapshots;
+    private activeId;
+    private nextId;
+    private alive;
+    private childReady;
+    private disposed;
+    private restartsSinceSuccess;
+    private recoveryNotes_;
+    private resolveReady;
+    private rejectReady;
+    private ready;
+    /**
+     * Phase 2 Task 13: timestamp of the most recent successful spawn(). Used by
+     * higher-level staleness checks (Task 15) to decide whether a warm kernel's
+     * env-injected credentials need to be refreshed. Pre-start() value is epoch
+     * so callers can distinguish "never spawned" without nullable juggling.
+     */
+    spawnTime: Date;
+    constructor(options: ChildProcessRuntimeOptions);
+    start(): Promise<void>;
+    /**
+     * Phase 2 Task 13: env construction split out so the injector hop has a clean
+     * seam to extend. Existing semantics unchanged: filterEnv applies the kernel's
+     * allowlist/denylist, then (when configured) the injector overlays OTTO_DS_*
+     * vars from vault entries. Only the spawned child sees the result; the parent
+     * process.env is never mutated.
+     */
+    private buildBaseEnv;
+    private spawnChild;
+    private readLoop;
+    private resetInactivity;
+    private onInactivityTimeout;
+    private onTotalTimeout;
+    runCell(code: string): Promise<CellResult>;
+    cancel(): Promise<void>;
+    snapshot(): Promise<SnapshotResult>;
+    /**
+     * Phase 4 Task 10: service an `artifact_create` RPC request from the kernel.
+     * Calls the manager-supplied handler (if any), serializes the result into a
+     * `{type:'response', request:'artifact_create'}` frame, and writes it back
+     * to the child's stdin. Errors are surfaced to the kernel as `ok:false`
+     * frames so the awaiting cell rejects cleanly rather than hanging.
+     */
+    private handleArtifactCreateRpc;
+    /**
+     * Phase 4 Task 10: service an `artifact_update` RPC request. Mirror of
+     * handleArtifactCreateRpc for the update path.
+     */
+    private handleArtifactUpdateRpc;
+    private rejectActive;
+    private failAllPending;
+    private markDead;
+    get hasActiveCell(): boolean;
+    get recoveryNotes(): readonly RecoveryNote[];
+    dispose(): Promise<void>;
+}