@xingular/harness 0.1.6 → 1.0.0

package/dist/sdk/terminal/socket.js

@@ -0,0 +1,256 @@
+// The session socket: how a process the harness did not start in-process (the `pi` command in
+// a terminal, with its extension and the `xagent-wiki` / `xagent-mcp` commands) reaches the
+// session it belongs to. Owner-only Unix socket (a named pipe on Windows), newline-delimited JSON.
+// A connection carries one request unless the request asks to `keep` it open, in which case the
+// reply leaves it open for the next request. Each terminal session holds a random token bound to
+// its caller, its connected-apps grant, and its controller; the token stops working when the
+// terminal ends.
+import { createHash, randomBytes } from 'node:crypto';
+import { chmodSync, mkdirSync, rmSync, statSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { log } from "../core/bus.js";
+import { HarnessError, toErrorShape } from "../core/errors.js";
+import { newId } from "../core/fs.js";
+const MAX_REQUEST_BYTES = 1024 * 1024;
+/** macOS refuses a socket path longer than 103 bytes. */
+const MAX_SOCKET_PATH = 100;
+/**
+ * Windows has no socket files for Node's `net`: it listens on a named pipe, which lives in a
+ * machine-wide namespace. A random name keeps another local process from guessing it and standing
+ * in front of the session; the token still decides what a caller may do.
+ */
+export function socketPath(stateDir) {
+    if (process.platform === 'win32')
+        return `\\\\.\\pipe\\xingular-harness-${randomBytes(12).toString('hex')}`;
+    const path = join(stateDir, 'run', 'harness.sock');
+    if (Buffer.byteLength(path) <= MAX_SOCKET_PATH)
+        return path;
+    return join(tmpdir(), `xh-${createHash('sha256').update(path).digest('hex').slice(0, 16)}.sock`);
+}
+function alternateSocketPath(path) {
+    const candidate = join(dirname(path), `harness-${process.pid}-${randomBytes(8).toString('hex')}.sock`);
+    return Buffer.byteLength(candidate) <= MAX_SOCKET_PATH ? candidate : join(tmpdir(), `xh-${randomBytes(16).toString('hex')}.sock`);
+}
+/** A named pipe has no folder, file mode, or owner to check or clean up. */
+const isPipePath = (path) => path.startsWith('\\\\.\\pipe\\');
+/** Names the folder and the user when the operating system refuses the socket, so the cause shows. */
+function refusedBind(path, error) {
+    const code = error?.code;
+    if (code !== 'EACCES' && code !== 'EPERM')
+        return error;
+    if (isPipePath(path)) {
+        return new HarnessError('session_socket_denied', `The session pipe ${path} could not be created (${code}).`, 'Start the harness again from your own user session. If it keeps failing, report this code and the Windows version.');
+    }
+    let folder;
+    try {
+        const stat = statSync(dirname(path));
+        folder = `${dirname(path)} is owned by uid ${stat.uid} with mode ${(stat.mode & 0o777).toString(8)}`;
+    }
+    catch {
+        folder = `${dirname(path)} could not be read`;
+    }
+    const uid = process.getuid?.() ?? 'unknown';
+    return new HarnessError('session_socket_denied', `The session socket ${path} could not be created (${code}). ${folder}; this process runs as uid ${uid}.`, 'Run the harness from your own terminal, as the user that owns its state folder, or choose a state folder you own with --state.');
+}
+export class SessionSocket {
+    handlers;
+    server = null;
+    listening = null;
+    socketPathValue;
+    grants = new Map();
+    /**
+     * A second key per token, handed out once. The token is in the session's environment, where a
+     * command the model runs can read it; this key is claimed by the session's extension as it
+     * loads, before any model turn, and kept in its memory only.
+     */
+    controls = new Map();
+    clients = new Set();
+    constructor(path, handlers) {
+        this.handlers = handlers;
+        this.socketPathValue = path;
+    }
+    get path() { return this.socketPathValue; }
+    issue(grant) {
+        const token = `${newId()}${newId()}`.replaceAll('-', '');
+        this.grants.set(token, grant);
+        return token;
+    }
+    revoke(token) {
+        this.grants.delete(token);
+        this.controls.delete(token);
+    }
+    revokeSession(sessionId) {
+        for (const [token, grant] of this.grants)
+            if (grant.sessionId === sessionId)
+                this.revoke(token);
+    }
+    /** Runs one request line and returns the reply line's object. */
+    async handle(line, connection) {
+        try {
+            let request;
+            try {
+                request = JSON.parse(line);
+            }
+            catch {
+                throw new HarnessError('invalid_request', 'The request is not JSON.');
+            }
+            connection?.keep?.(request.keep === true);
+            const token = typeof request.token === 'string' ? request.token : '';
+            const grant = this.grants.get(token);
+            if (!grant)
+                throw new HarnessError('unauthorized', 'This session token is not valid. It ends when its terminal session ends.');
+            if (typeof request.event === 'string') {
+                if (!grant.terminal)
+                    throw new HarnessError('unknown_method', 'This session has no terminal controller.');
+                connection?.waiting(grant);
+                try {
+                    return { result: (await grant.terminal.accept(request.event, (request.data ?? {}))) ?? {} };
+                }
+                finally {
+                    connection?.waiting(null);
+                }
+            }
+            const call = typeof request.call === 'string' ? request.call : '';
+            const params = (request.params && typeof request.params === 'object' ? request.params : {});
+            if (['wiki.', 'skill.', 'recall.', 'trajectory.'].some((prefix) => call.startsWith(prefix)))
+                return { result: this.handlers.memory(grant.caller(), call, params) };
+            if (call === 'tools.list' && !grant.broker)
+                return { result: { tools: [] } };
+            if (['mcp.', 'tools.'].some((prefix) => call.startsWith(prefix))) {
+                if (!grant.broker)
+                    throw new HarnessError('mcp_unauthorized', 'Connected apps are not available to this session.');
+                return { result: await this.handlers.apps(grant.broker, call, params) };
+            }
+            if (call === 'control.claim') {
+                if (this.controls.has(token))
+                    throw new HarnessError('unauthorized', "This session's control key was already claimed.");
+                const key = `${newId()}${newId()}`.replaceAll('-', '');
+                this.controls.set(token, key);
+                return { result: { key } };
+            }
+            if (call.startsWith('terminal.') && grant.terminal?.control) {
+                const key = this.controls.get(token);
+                if (!key || request.control !== key)
+                    throw new HarnessError('unauthorized', 'Only a person at this terminal can answer decisions or change its draft state.');
+                return { result: await grant.terminal.control(call, params) };
+            }
+            if ((call.startsWith('plugins.') || call.startsWith('hub.')) && this.handlers.plugins) {
+                const key = this.controls.get(token);
+                return { result: await this.handlers.plugins(grant, call, params, key !== undefined && request.control === key) };
+            }
+            if (call.startsWith('accounts.') && this.handlers.accounts) {
+                const key = this.controls.get(token);
+                return { result: await this.handlers.accounts(grant, call, params, key !== undefined && request.control === key) };
+            }
+            throw new HarnessError('unknown_method', `Unknown call ${call}.`);
+        }
+        catch (error) {
+            return { error: toErrorShape(error) };
+        }
+    }
+    serve(client) {
+        let buffer = '';
+        let busy = false;
+        let ended = false;
+        let waiting = null;
+        this.clients.add(client);
+        client.on('error', () => { });
+        client.once('close', () => {
+            this.clients.delete(client);
+            // A decision the native process was waiting on can no longer reach it.
+            waiting?.terminal?.disconnected();
+        });
+        // Requests on one connection run one at a time, in order.
+        const next = () => {
+            if (busy || ended)
+                return;
+            const newline = buffer.indexOf('\n');
+            if (newline < 0)
+                return;
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            busy = true;
+            client.pause();
+            let keep = false;
+            void this.handle(line, { waiting: (grant) => void (waiting = grant), keep: (value) => void (keep = value) }).then((reply) => {
+                busy = false;
+                const text = `${JSON.stringify(reply)}\n`;
+                if (!keep || client.destroyed) {
+                    ended = true;
+                    client.end(text);
+                    return;
+                }
+                client.write(text);
+                client.resume();
+                next();
+            });
+        };
+        client.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            if (Buffer.byteLength(buffer) > MAX_REQUEST_BYTES) {
+                client.destroy();
+                return;
+            }
+            next();
+        });
+    }
+    bind(path) {
+        return new Promise((resolve, reject) => {
+            const server = createServer((client) => this.serve(client));
+            server.once('error', reject);
+            server.listen(path, () => {
+                if (!isPipePath(path)) {
+                    try {
+                        chmodSync(path, 0o600);
+                    }
+                    catch (error) {
+                        log('session socket permissions', error instanceof Error ? error.message : String(error));
+                    }
+                }
+                this.server = server;
+                resolve();
+            });
+        });
+    }
+    /** Binds the usual path, or an instance-specific path if another Harness owns it. */
+    async bindAvailablePath() {
+        if (!isPipePath(this.path))
+            mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+        try {
+            await this.bind(this.path);
+        }
+        catch (error) {
+            if (isPipePath(this.path) || error.code !== 'EADDRINUSE')
+                throw refusedBind(this.path, error);
+            this.socketPathValue = alternateSocketPath(this.path);
+            try {
+                await this.bind(this.path);
+            }
+            catch (alternateError) {
+                throw refusedBind(this.path, alternateError);
+            }
+        }
+    }
+    /** Binds the socket once; later calls wait for the same bind. */
+    listen() {
+        this.listening ??= this.bindAvailablePath().catch(error => {
+            this.listening = null;
+            throw error;
+        });
+        return this.listening;
+    }
+    async close() {
+        this.grants.clear();
+        const server = this.server;
+        this.server = null;
+        this.listening = null;
+        for (const client of this.clients)
+            client.destroy();
+        if (server)
+            await new Promise((resolve) => server.close(() => resolve()));
+        if (!isPipePath(this.path))
+            rmSync(this.path, { force: true });
+    }
+}

package/dist/sdk/terminal/standalone.d.ts

@@ -0,0 +1,18 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { type Harness, type HarnessOptions } from "../harness.js";
+export interface StandalonePaths {
+    dataRoot: string;
+    stateDir: string;
+}
+export interface StandaloneDependencies {
+    home?: string;
+    cwd?: string;
+    stdinIsTTY?: boolean;
+    stdoutIsTTY?: boolean;
+    createSessionId?: () => string;
+    createHarness?: (options: HarnessOptions) => Harness;
+    spawn?: typeof nodeSpawn;
+}
+export declare function standaloneArguments(argv: string[]): string[] | null;
+export declare function parseStandaloneOptions(argv: string[], home?: string, cwd?: string): StandalonePaths;
+export declare function runStandaloneTerminal(argv: string[], dependencies?: StandaloneDependencies): Promise<number>;

package/dist/sdk/terminal/standalone.js

@@ -0,0 +1,146 @@
+// The standalone host prepares an isolated Harness terminal and supervises its frontend.
+import { spawn as nodeSpawn } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { appendFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+import { setLogSink } from "../core/bus.js";
+import { createHarness } from "../harness.js";
+export function standaloneArguments(argv) {
+    const command = argv[0];
+    if (!command || command.startsWith('--') || command === '-h')
+        return argv;
+    return command === 'terminal' ? argv.slice(1) : null;
+}
+export function parseStandaloneOptions(argv, home = homedir(), cwd = process.cwd()) {
+    const root = join(home, '.xingular-harness');
+    const paths = {
+        dataRoot: join(root, 'data'),
+        stateDir: join(root, 'state')
+    };
+    const given = new Set();
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument !== '--data' && argument !== '--state')
+            throw new Error(`Unknown standalone option: ${argument}`);
+        const value = argv[index + 1];
+        if (!value || value.startsWith('--'))
+            throw new Error(`${argument} needs a directory path.`);
+        paths[argument === '--data' ? 'dataRoot' : 'stateDir'] = resolve(cwd, value);
+        given.add(argument);
+        index += 1;
+    }
+    // A home that is not a folder path (for example HOME set to the word "HOME") would put the
+    // defaults, and the session socket, in whatever folder the command was started from.
+    if (!isAbsolute(home) && !(given.has('--data') && given.has('--state'))) {
+        throw new Error(`The home folder "${home}" is not an absolute path, so the default data and state folders cannot be placed. Set HOME to your home folder, or pass --data and --state with absolute folders.`);
+    }
+    return paths;
+}
+function processEnvironment(overrides) {
+    const environment = { ...process.env };
+    for (const [name, value] of Object.entries(overrides)) {
+        if (value === null)
+            delete environment[name];
+        else
+            environment[name] = value;
+    }
+    return environment;
+}
+function exitCode(code, signal) {
+    if (code !== null)
+        return code;
+    if (signal === 'SIGINT')
+        return 130;
+    if (signal === 'SIGTERM')
+        return 143;
+    if (signal === 'SIGHUP')
+        return 129;
+    return 1;
+}
+function spawnError(error, launch) {
+    const code = error.code;
+    if (code !== 'ENOENT' && code !== 'EACCES' && code !== 'EPERM')
+        return error;
+    const problem = code === 'ENOENT' ? 'was not found' : `could not start (${code})`;
+    return new Error(`Could not start the Harness terminal. The Bun executable "${launch.program}" ${problem}; install Bun or set XINGULAR_HARNESS_BUN, then run npm run build:tui.`, { cause: error });
+}
+function spawnFrontend(launch, cwd, spawn = nodeSpawn) {
+    return new Promise((resolveExit, reject) => {
+        const child = spawn(launch.program, launch.args, {
+            cwd,
+            env: processEnvironment(launch.env),
+            stdio: 'inherit'
+        });
+        let settled = false;
+        const cleanup = () => {
+            process.off('SIGINT', onInterrupt);
+            process.off('SIGTERM', onTerminate);
+            process.off('SIGHUP', onHangup);
+        };
+        const finish = (action) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            action();
+        };
+        // Ctrl+C is delivered to both processes in the foreground process group. Keep this host
+        // alive while the frontend handles it so the account credentials and harness socket are cleaned up.
+        const onInterrupt = () => undefined;
+        const onTerminate = () => {
+            child.kill('SIGTERM');
+        };
+        const onHangup = () => undefined;
+        process.on('SIGINT', onInterrupt);
+        process.on('SIGTERM', onTerminate);
+        process.on('SIGHUP', onHangup);
+        child.once('error', (error) => finish(() => reject(spawnError(error, launch))));
+        child.once('exit', (code, signal) => finish(() => resolveExit(exitCode(code, signal))));
+    });
+}
+export async function runStandaloneTerminal(argv, dependencies = {}) {
+    if (!(dependencies.stdinIsTTY ?? process.stdin.isTTY) || !(dependencies.stdoutIsTTY ?? process.stdout.isTTY)) {
+        throw new Error('The interactive Harness terminal needs a TTY. Run it from a terminal, or use `xharness serve` for a host process.');
+    }
+    const cwd = resolve(dependencies.cwd ?? process.cwd());
+    const paths = parseStandaloneOptions(argv, dependencies.home, cwd);
+    const makeHarness = dependencies.createHarness ?? createHarness;
+    const harness = makeHarness({ dataRoot: paths.dataRoot, stateDir: paths.stateDir, productName: 'Xingular Harness' });
+    const newSessionId = dependencies.createSessionId ?? randomUUID;
+    let current = { sessionId: newSessionId(), accountId: null, nativeSessionId: null };
+    // The frontend draws on this terminal, so the host's diagnostics go to a file the person can read instead.
+    const logFile = join(paths.stateDir, 'harness.log');
+    setLogSink((text) => {
+        try {
+            appendFileSync(logFile, `${new Date().toISOString()} ${text}\n`);
+        }
+        catch {
+            // Diagnostics are best effort; a full disk must not stop the terminal.
+        }
+    });
+    try {
+        await harness.ready;
+        if (harness.accounts.overview().accounts.length === 0)
+            harness.accounts.create('Default', 'subscription');
+        const cwdHash = createHash('sha256').update(cwd).digest('hex');
+        const sessionFolder = join(paths.dataRoot, 'sessions', 'terminal', cwdHash);
+        for (;;) {
+            const launch = await harness.terminals.prepare({ ...current, cwd, sessionFolder });
+            const code = await spawnFrontend(launch, cwd, dependencies.spawn);
+            // `/accounts` asks for a switch and ends the frontend. The conversation resumes on the chosen account.
+            const next = harness.terminals.takeRelaunch(current.sessionId);
+            if (!next)
+                return code;
+            const label = harness.accounts.find(next.accountId).label;
+            process.stdout.write(`Switching this session to account ${label}.\n`);
+            await harness.terminals.dispose(current.sessionId);
+            current = { sessionId: newSessionId(), accountId: next.accountId, nativeSessionId: next.nativeSessionId };
+        }
+    }
+    finally {
+        await harness.terminals.dispose(current.sessionId);
+        await harness.close();
+        setLogSink(null);
+    }
+}

package/dist/sdk/terminal/terminals.d.ts

@@ -0,0 +1,176 @@
+import type { CapabilitySet } from "../capabilities/types.js";
+import type { Subagents } from "../sessions/subagentService.js";
+import { type SubagentOptions } from "../sessions/subagents.js";
+import type { Accounts } from "../accounts/accounts.js";
+import type { Approvals } from "../sessions/approvals.js";
+import type { Bus } from "../core/bus.js";
+import type { HarnessEnv } from "../core/env.js";
+import type { ConnectedApps } from "../mcp/service.js";
+import type { CallerContext } from "../core/caller.js";
+import { type VariantChoice } from "../variant/materialise.js";
+import type { VariantTrust } from "../variant/trust.js";
+import type { AttachParams, PluginScope } from "../plugins/api.js";
+import type { Plugins } from "../plugins/plugins.js";
+import type { Plugin } from "../plugins/types.js";
+import type { Hub } from "../hub/hub.js";
+import { type Launch } from "../prompt/compile.js";
+import type { RunRecord } from "../sessions/contracts.js";
+import type { ToolPolicy } from "../sessions/policy.js";
+import type { RunRegistry } from "../sessions/registry.js";
+import type { World } from "../world/world.js";
+/** The files a terminal session needs on disk, outside this process. */
+export interface TerminalAssets {
+    /** The Node binary that runs the commands. */
+    node: string;
+    /** The built `xharness` command (`dist/cli.js`). */
+    cli: string;
+    /** The built Pi extension (`dist/terminal-pi.js`). */
+    piExtension: string;
+    /** The built OpenTUI frontend (`dist/terminal-opentui.js`). */
+    openTui: string;
+}
+/** Where the package's own build puts them. An application that bundles the harness passes its own. */
+export declare function defaultAssets(): TerminalAssets;
+export interface TerminalPrepareInput {
+    subagents?: SubagentOptions | null;
+    sessionId: string;
+    /** The account the session is pinned to. Omitted only for a session that has none yet; it then takes the default and keeps it. */
+    accountId?: string | null;
+    projectId?: string | null;
+    cwd: string;
+    /** The session's own folder. Its compiled instructions and native history are kept under it. */
+    sessionFolder: string;
+    nativeSessionId?: string | null;
+    model?: string | null;
+    readOnly?: boolean;
+    /** What the application adds to the instructions, and which of its tools it describes. */
+    launch?: Launch;
+    /** The variant the session runs; its version is pinned for the session. */
+    variant?: VariantChoice | null;
+    /** Give the session the connected-apps broker. Defaults to yes. */
+    connections?: boolean;
+    /** Fields copied onto each run this session records. */
+    run?: Partial<Pick<RunRecord, 'mode' | 'worktreeId'>>;
+}
+export interface TerminalLaunch {
+    program: string;
+    args: string[];
+    /** Variables to set; `null` removes an inherited one. */
+    env: Record<string, string | null>;
+    accountId: string;
+    nativeSessionId: string | null;
+}
+export interface TerminalsOptions {
+    doctor?: import("../doctor/service.js").Doctor;
+    /** Which plugin code in variants a person trusted. */
+    trust?: VariantTrust | null;
+    subagents?: Subagents;
+    resolveCapabilities?: (caller: CallerContext, tools: readonly string[], cwd: string) => Promise<CapabilitySet>;
+    env: HarnessEnv;
+    stateDir: string;
+    accounts: Accounts;
+    runs: RunRegistry;
+    approvals: Approvals;
+    apps: ConnectedApps;
+    policy: ToolPolicy;
+    bus: Bus;
+    /** Chooses what a terminal loads. Without it Pi discovers extensions and skills on its own. */
+    plugins?: Plugins;
+    /** Lists plugins and applies a person's choices, for the session's `/plugins` command. */
+    pluginControl?: PluginControl;
+    hub?: Hub;
+    assets?: TerminalAssets;
+    /** Web, browser and computer tools, offered when their plugins are on. */
+    world?: World;
+}
+/** What `/plugins` in a terminal can do. Each takes the session's folder, account and project. */
+export interface PluginControl {
+    list(scope: PluginScope): Promise<Plugin[]>;
+    attach(params: AttachParams, on: boolean): Promise<Plugin[]>;
+    trust(scope: PluginScope & {
+        hash: string;
+    }): Promise<Plugin[]>;
+    untrust(scope: PluginScope & {
+        hash: string;
+    }): Promise<Plugin[]>;
+    /** Saves numbers a person set on a plugin; each is checked against the plugin's settings. */
+    configure(params: PluginScope & {
+        pluginId: string;
+        settings: Record<string, unknown>;
+    }): Promise<Plugin[]>;
+}
+export declare class Terminals {
+    private readonly options;
+    private readonly sessions;
+    private readonly diagnosticOwners;
+    /** The variant each live session runs, for loading its skills. */
+    private readonly variantDirs;
+    /** The world tools each session was given, so a call can only reach one of them. */
+    private readonly worldNames;
+    private readonly worldReadOnly;
+    private readonly socket;
+    private readonly assets;
+    /** A session's `/accounts` switch, taken once its Pi process has ended. */
+    private readonly relaunches;
+    constructor(options: TerminalsOptions);
+    /** The commands a terminal session finds on PATH. Rewritten only when they change. */
+    private ensureCommands;
+    /** The broker's tools, then the world tools whose plugins are on for this session. */
+    private tools;
+    /** The world tools a new session will have, named in its instructions. */
+    private worldToolNames;
+    /** Whether a world tool's plugin is switched on for a session's folder, account and project. */
+    private worldOn;
+    private appsCall;
+    /**
+     * `/plugins` in a terminal. Listing is open to the session. A change is taken only from the
+     * session's own extension, which asks the person in the terminal first: the model can reach
+     * this socket from a shell command, and must not be able to trust code or switch it on.
+     */
+    private pluginsCall;
+    /**
+     * `/accounts` in a terminal. Every call needs the session's control key: adding, signing in,
+     * or removing an account is a person's choice, never the model's shell command.
+     */
+    private accountsCall;
+    /** The account a session asked to switch to. Taken once, after its Pi process has ended and before `dispose`. */
+    takeRelaunch(sessionId: string): {
+        accountId: string;
+        nativeSessionId: string | null;
+    } | null;
+    private live;
+    private historyDir;
+    private runRecord;
+    /** The run a native turn reports into: the one reserved by `send`, or a new one for what the person typed. */
+    private begin;
+    private decide;
+    private subagentsCall;
+    private componentsCall;
+    private trajectoryCall;
+    /** The only terminal frontend: the Bun-run OpenTUI application. */
+    private frontendCommand;
+    /**
+     * Prepares an OpenTUI terminal session and returns what to spawn. The caller must report the
+     * process's end with `dispose`, also when it never starts.
+     */
+    prepare(input: TerminalPrepareInput): Promise<TerminalLaunch>;
+    /** Hands the terminal an instruction as a new run. Resolves once the native session has taken it. */
+    send(input: {
+        sessionId: string;
+        runId?: string | null;
+        text: string;
+    }): Promise<{
+        runId: string;
+    }>;
+    /** What the person typed into the terminal. */
+    input(sessionId: string, data: string): void;
+    state(sessionId: string): {
+        ready: boolean;
+        dirty: boolean;
+        active: boolean;
+    };
+    has(sessionId: string): boolean;
+    /** The terminal process ended (or never started): its turn, tokens, and written credentials go with it. */
+    dispose(sessionId: string): Promise<void>;
+    close(): Promise<void>;
+}