@watasu/sdk 0.1.6 → 0.1.25

package/dist/template.js

@@ -0,0 +1,624 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ConnectionConfig } from './connectionConfig.js';
+import { InvalidArgumentError, NotFoundError, SandboxError, unsupported } from './errors.js';
+import { ControlClient, withQuery } from './transport.js';
+/** Ready-check command wrapper accepted by template builders. */
+export class ReadyCmd {
+    cmd;
+    constructor(cmd) {
+        this.cmd = cmd;
+    }
+    /** Return the shell command used as the ready check. */
+    getCmd() {
+        return this.cmd;
+    }
+}
+/** Return a ready check that waits for a TCP port to listen. */
+export function waitForPort(port) {
+    return new ReadyCmd(`ss -tuln | grep :${port}`);
+}
+/** Return a ready check that waits for a URL to return an HTTP status code. */
+export function waitForURL(url, statusCode = 200) {
+    return new ReadyCmd(`curl -s -o /dev/null -w "%{http_code}" ${url} | grep -q "${statusCode}"`);
+}
+/** Alias for `waitForURL`. */
+export const waitForUrl = waitForURL;
+/** Return a ready check that waits for a process name. */
+export function waitForProcess(processName) {
+    return new ReadyCmd(`pgrep ${processName} > /dev/null`);
+}
+/** Return a ready check that waits for a file to exist. */
+export function waitForFile(filename) {
+    return new ReadyCmd(`[ -f ${filename} ]`);
+}
+/** Return a ready check that waits for a fixed duration in milliseconds. */
+export function waitForTimeout(timeout) {
+    const seconds = Math.max(1, Math.floor(timeout / 1000));
+    return new ReadyCmd(`sleep ${seconds}`);
+}
+/** Chainable template builder for Watasu package-spec template builds. */
+export class TemplateBase {
+    base;
+    packages = {};
+    files = [];
+    setup = [];
+    env = {};
+    currentWorkdir;
+    currentUser;
+    startCmd;
+    readyCmd;
+    force = false;
+    fileContextPath;
+    fileIgnorePatterns;
+    constructor(options = {}) {
+        this.fileContextPath = path.resolve(options.fileContextPath ?? process.cwd());
+        this.fileIgnorePatterns = options.fileIgnorePatterns ?? [];
+    }
+    static async build(template, nameOrOptions, options = {}) {
+        const { name, buildOptions } = normalizeBuildArguments(nameOrOptions, options);
+        buildOptions.onBuildLogs?.({ timestamp: new Date(), level: 'info', message: 'Build started' });
+        const data = await TemplateBase.buildInBackground(template, name, buildOptions);
+        await waitForBuildFinish(data, buildOptions);
+        buildOptions.onBuildLogs?.({ timestamp: new Date(), level: 'info', message: 'Build finished' });
+        return data;
+    }
+    static async buildInBackground(template, nameOrOptions, options = {}) {
+        const { name, buildOptions } = normalizeBuildArguments(nameOrOptions, options);
+        const config = new ConnectionConfig(buildOptions);
+        const control = new ControlClient(config);
+        const payload = {
+            name,
+            tags: buildOptions.tags,
+            cpu_count: buildOptions.cpuCount ?? 2,
+            memory_mb: buildOptions.memoryMB ?? 1024,
+            skip_cache: buildOptions.skipCache ?? template.force,
+            build_spec: template.toBuildSpec(),
+        };
+        if (buildOptions.team !== undefined)
+            payload.team = buildOptions.team;
+        const response = await control.post('/templates', { json: payload });
+        return buildInfo(record(response.template_build ?? response));
+    }
+    static async getBuildStatus(data, options = {}) {
+        const config = new ConnectionConfig(options);
+        const control = new ControlClient(config);
+        const payload = await control.get(withQuery(`/templates/${encodeURIComponent(data.templateId)}/builds/${encodeURIComponent(data.buildId)}/status`, {
+            logs_offset: options.logsOffset,
+        }));
+        return templateBuildStatus(record(payload));
+    }
+    static async exists(name, options) {
+        return TemplateBase.aliasExists(name, options);
+    }
+    static async aliasExists(alias, options = {}) {
+        const config = new ConnectionConfig(options);
+        const control = new ControlClient(config);
+        try {
+            await control.get(`/templates/aliases/${encodeURIComponent(alias)}`);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof NotFoundError)
+                return false;
+            throw error;
+        }
+    }
+    static async assignTags(targetName, tags, options = {}) {
+        const config = new ConnectionConfig(options);
+        const control = new ControlClient(config);
+        const response = await control.post('/templates/tags', {
+            json: { target: targetName, tags: Array.isArray(tags) ? tags : [tags] },
+        });
+        return {
+            buildId: stringValue(response.build_id) ?? '',
+            tags: arrayOfStrings(response.tags),
+        };
+    }
+    static async removeTags(name, tags, options = {}) {
+        const config = new ConnectionConfig(options);
+        const control = new ControlClient(config);
+        await control.delete('/templates/tags', {
+            json: { name, tags: Array.isArray(tags) ? tags : [tags] },
+        });
+    }
+    static async getTags(templateId, options = {}) {
+        const config = new ConnectionConfig(options);
+        const control = new ControlClient(config);
+        const response = await control.get(`/templates/${encodeURIComponent(templateId)}/tags`);
+        const tags = Array.isArray(response) ? response : [];
+        return tags.map((item) => templateTag(record(item)));
+    }
+    static async toJSON(template) {
+        return JSON.stringify(template.toBuildSpec());
+    }
+    static toDockerfile(template) {
+        return template.toDockerfile();
+    }
+    fromDebianImage(_variant = 'stable') {
+        this.base = 'base';
+        return this;
+    }
+    fromUbuntuImage(_variant = 'latest') {
+        this.base = 'base';
+        return this;
+    }
+    fromPythonImage(_version = '3') {
+        this.base = this.base ?? 'base';
+        return this;
+    }
+    fromNodeImage(_variant = 'lts') {
+        this.base = this.base ?? 'base';
+        return this;
+    }
+    fromBunImage(_variant = 'latest') {
+        this.base = this.base ?? 'base';
+        return this;
+    }
+    fromBaseImage() {
+        this.base = 'base';
+        return this;
+    }
+    fromImage(_baseImage, _credentials) {
+        this.base = this.base ?? 'base';
+        return this;
+    }
+    fromAWSRegistry(_image, _credentials) {
+        unsupported('Template.fromAWSRegistry');
+    }
+    fromGCPRegistry(_image, _credentials) {
+        unsupported('Template.fromGCPRegistry');
+    }
+    fromTemplate(template) {
+        this.base = template;
+        return this;
+    }
+    fromDockerfile(dockerfileContentOrPath) {
+        const candidate = path.isAbsolute(dockerfileContentOrPath)
+            ? dockerfileContentOrPath
+            : path.resolve(this.fileContextPath, dockerfileContentOrPath);
+        const content = fs.existsSync(candidate) && fs.statSync(candidate).isFile()
+            ? fs.readFileSync(candidate, 'utf8')
+            : dockerfileContentOrPath;
+        parseDockerfileIntoTemplate(content, this);
+        return this;
+    }
+    copy(src, dest, options = {}) {
+        const sources = Array.isArray(src) ? src : [src];
+        for (const source of sources)
+            this.addCopySource(source, dest, options, sources.length > 1);
+        return this;
+    }
+    copyItems(items) {
+        for (const item of items) {
+            this.copy(item.src, item.dest, {
+                forceUpload: item.forceUpload,
+                user: item.user,
+                mode: item.mode,
+                resolveSymlinks: item.resolveSymlinks,
+            });
+        }
+        return this;
+    }
+    remove(path, options = {}) {
+        const paths = Array.isArray(path) ? path : [path];
+        return this.runCmd(`rm ${options.recursive ? '-r ' : ''}${options.force ? '-f ' : ''}${paths.join(' ')}`, {
+            user: options.user,
+        });
+    }
+    rename(src, dest, options = {}) {
+        return this.runCmd(`mv ${src} ${dest}${options.force ? ' -f' : ''}`, { user: options.user });
+    }
+    makeDir(path, options = {}) {
+        const paths = Array.isArray(path) ? path : [path];
+        const mode = options.mode === undefined ? '' : `-m ${options.mode.toString(8)} `;
+        return this.runCmd(`mkdir -p ${mode}${paths.join(' ')}`, { user: options.user });
+    }
+    makeSymlink(src, dest, options = {}) {
+        return this.runCmd(`ln -s ${options.force ? '-f ' : ''}${src} ${dest}`, { user: options.user });
+    }
+    runCmd(command, options = {}) {
+        const commandText = Array.isArray(command) ? command.join(' && ') : command;
+        this.setup.push(this.commandWithContext(commandText, options.user));
+        return this;
+    }
+    setWorkdir(workdir) {
+        this.currentWorkdir = workdir;
+        return this;
+    }
+    setUser(user) {
+        this.currentUser = user;
+        return this;
+    }
+    pipInstall(packages, options = {}) {
+        const packageList = packages === undefined ? [] : arrayOfStrings(packages);
+        if (packageList.length > 0 && options.g !== false) {
+            this.addPackages('pip', packageList);
+        }
+        else {
+            const suffix = packageList.length > 0 ? packageList.join(' ') : '.';
+            this.runCmd(`python3 -m pip install ${options.g === false ? '--user ' : ''}${suffix}`);
+        }
+        return this;
+    }
+    npmInstall(packages, options = {}) {
+        const packageList = packages === undefined ? [] : arrayOfStrings(packages);
+        if (packageList.length > 0 && options.g) {
+            this.addPackages('npm', packageList);
+        }
+        else {
+            this.runCmd(`npm install ${options.g ? '-g ' : ''}${options.dev ? '--save-dev ' : ''}${packageList.join(' ')}`.trim());
+        }
+        return this;
+    }
+    bunInstall(packages, options = {}) {
+        const packageList = packages === undefined ? [] : arrayOfStrings(packages);
+        this.runCmd(`bun install ${options.g ? '-g ' : ''}${options.dev ? '--dev ' : ''}${packageList.join(' ')}`.trim());
+        return this;
+    }
+    aptInstall(packages, _options = {}) {
+        this.addPackages('apt', arrayOfStrings(packages));
+        return this;
+    }
+    addMcpServer(servers) {
+        if (this.base !== 'mcp-gateway') {
+            throw new SandboxError('MCP servers can only be added to mcp-gateway template');
+        }
+        return this.runCmd(`mcp-gateway pull ${arrayOfStrings(servers).join(' ')}`, { user: 'root' });
+    }
+    gitClone(url, path, options = {}) {
+        const args = ['git clone'];
+        if (options.branch)
+            args.push(`--branch ${options.branch}`, '--single-branch');
+        if (options.depth)
+            args.push(`--depth ${options.depth}`);
+        args.push(url);
+        if (path)
+            args.push(path);
+        return this.runCmd(args.join(' '), { user: options.user });
+    }
+    setStartCmd(startCommand, readyCommand) {
+        this.startCmd = startCommand;
+        this.readyCmd = readyCommandText(readyCommand);
+        return this;
+    }
+    setReadyCmd(readyCommand) {
+        this.readyCmd = readyCommandText(readyCommand);
+        return this;
+    }
+    setEnvs(envs) {
+        Object.assign(this.env, envs);
+        return this;
+    }
+    skipCache() {
+        this.force = true;
+        return this;
+    }
+    toBuildSpec() {
+        const spec = {};
+        if (this.base)
+            spec.base = this.base;
+        if (Object.keys(this.packages).length > 0)
+            spec.packages = this.packages;
+        if (this.files.length > 0)
+            spec.files = this.files;
+        if (this.setup.length > 0)
+            spec.setup = this.setup;
+        if (Object.keys(this.env).length > 0)
+            spec.env = this.env;
+        if (this.startCmd)
+            spec.start_cmd = this.startCmd;
+        if (this.readyCmd)
+            spec.ready_cmd = this.readyCmd;
+        return spec;
+    }
+    addPackages(manager, packages) {
+        this.packages[manager] = [...(this.packages[manager] ?? []), ...packages];
+    }
+    addCopySource(source, dest, options, multipleSources) {
+        const sourcePath = this.resolveContextPath(source);
+        const stat = fs.statSync(sourcePath);
+        if (stat.isDirectory()) {
+            for (const filePath of walkFiles(sourcePath, options.resolveSymlinks ?? true)) {
+                const relativePath = toPosixPath(path.relative(sourcePath, filePath));
+                if (this.ignored(relativePath) || this.ignored(toPosixPath(path.relative(this.fileContextPath, filePath))))
+                    continue;
+                this.addFileSpec(filePath, posixJoin(dest, relativePath), toPosixPath(path.relative(this.fileContextPath, filePath)), options);
+            }
+            return;
+        }
+        if (!stat.isFile()) {
+            throw new InvalidArgumentError(`copy source is not a file or directory: ${source}`);
+        }
+        const destPath = multipleSources || dest.endsWith('/') ? posixJoin(dest, path.basename(source)) : dest;
+        this.addFileSpec(sourcePath, destPath, toPosixPath(path.relative(this.fileContextPath, sourcePath)), options);
+    }
+    addFileSpec(filePath, destPath, sourcePath, options) {
+        const file = {
+            path: normalizeSandboxPath(destPath),
+            source_path: sourcePath,
+            content_b64: fs.readFileSync(filePath).toString('base64'),
+        };
+        if (options.mode !== undefined)
+            file.mode = options.mode;
+        if (options.user !== undefined)
+            file.user = options.user;
+        this.files.push(file);
+    }
+    resolveContextPath(source) {
+        if (path.isAbsolute(source)) {
+            throw new InvalidArgumentError('copy source must be relative to the template file context');
+        }
+        const resolved = path.resolve(this.fileContextPath, source);
+        const relative = path.relative(this.fileContextPath, resolved);
+        if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            throw new InvalidArgumentError('copy source must stay inside the template file context');
+        }
+        return resolved;
+    }
+    ignored(relativePath) {
+        return this.fileIgnorePatterns.some((pattern) => matchesIgnorePattern(relativePath, pattern));
+    }
+    commandWithContext(command, user) {
+        const workdir = this.currentWorkdir ? `cd ${shellQuote(this.currentWorkdir)} && ` : '';
+        const commandText = `${workdir}${command}`;
+        const commandUser = user ?? this.currentUser;
+        return commandUser && commandUser !== 'root'
+            ? `su -s /bin/bash -c ${shellQuote(commandText)} ${shellQuote(commandUser)}`
+            : commandText;
+    }
+    toDockerfile() {
+        const lines = ['FROM base'];
+        for (const packageName of this.packages.apt ?? [])
+            lines.push(`RUN apt-get update && apt-get install -y ${packageName}`);
+        for (const packageName of this.packages.pip ?? [])
+            lines.push(`RUN python3 -m pip install ${packageName}`);
+        for (const packageName of this.packages.npm ?? [])
+            lines.push(`RUN npm install -g ${packageName}`);
+        for (const file of this.files)
+            lines.push(`COPY ${file.source_path ?? file.path} ${file.path}`);
+        for (const command of this.setup)
+            lines.push(`RUN ${command}`);
+        return `${lines.join('\n')}\n`;
+    }
+}
+function readyCommandText(command) {
+    return command instanceof ReadyCmd ? command.getCmd() : command;
+}
+function walkFiles(root, resolveSymlinks) {
+    const entries = fs.readdirSync(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const entryPath = path.join(root, entry.name);
+        const stat = resolveSymlinks ? fs.statSync(entryPath) : fs.lstatSync(entryPath);
+        if (stat.isDirectory())
+            files.push(...walkFiles(entryPath, resolveSymlinks));
+        if (stat.isFile())
+            files.push(entryPath);
+    }
+    return files.sort();
+}
+function normalizeSandboxPath(value) {
+    return toPosixPath(value).replace(/\/+/g, '/');
+}
+function posixJoin(base, relativePath) {
+    const normalizedBase = normalizeSandboxPath(base);
+    return normalizeSandboxPath(path.posix.join(normalizedBase, relativePath));
+}
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function matchesIgnorePattern(relativePath, pattern) {
+    if (!pattern)
+        return false;
+    const normalizedPattern = toPosixPath(pattern);
+    if (normalizedPattern.endsWith('/'))
+        return relativePath.startsWith(normalizedPattern);
+    if (!normalizedPattern.includes('*'))
+        return relativePath === normalizedPattern || relativePath.startsWith(`${normalizedPattern}/`);
+    const escaped = normalizedPattern.split('*').map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*');
+    return new RegExp(`^${escaped}$`).test(relativePath);
+}
+function parseDockerfileIntoTemplate(dockerfileContentOrPath, template) {
+    for (const instruction of dockerfileInstructions(dockerfileContentOrPath)) {
+        const keyword = instruction.keyword.toUpperCase();
+        const value = instruction.value;
+        if (keyword === 'FROM') {
+            template.fromImage(value.split(/\s+/)[0] || 'base');
+        }
+        else if (keyword === 'RUN') {
+            template.runCmd(value);
+        }
+        else if (keyword === 'WORKDIR') {
+            template.setWorkdir(value);
+        }
+        else if (keyword === 'USER') {
+            template.setUser(value);
+        }
+        else if (keyword === 'ENV') {
+            template.setEnvs(parseEnvInstruction(value));
+        }
+        else if (keyword === 'COPY' || keyword === 'ADD') {
+            const args = shellWords(value).filter((word) => !word.startsWith('--'));
+            if (args.length < 2)
+                throw new InvalidArgumentError(`${keyword} requires source and destination`);
+            const dest = args[args.length - 1];
+            template.copy(args.slice(0, -1), dest);
+        }
+        else if (keyword === 'CMD' || keyword === 'ENTRYPOINT') {
+            template.setStartCmd(value, waitForTimeout(20_000));
+        }
+    }
+}
+function dockerfileInstructions(content) {
+    const logicalLines = [];
+    let current = '';
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        if (line.endsWith('\\')) {
+            current += `${line.slice(0, -1)} `;
+            continue;
+        }
+        logicalLines.push(`${current}${line}`);
+        current = '';
+    }
+    if (current.trim())
+        logicalLines.push(current.trim());
+    return logicalLines.flatMap((line) => {
+        const match = line.match(/^([A-Za-z]+)\s+(.*)$/);
+        return match ? [{ keyword: match[1], value: match[2].trim() }] : [];
+    });
+}
+function parseEnvInstruction(value) {
+    const words = shellWords(value);
+    if (words.length === 2 && !words[0].includes('='))
+        return { [words[0]]: words[1] };
+    const env = {};
+    for (const word of words) {
+        const index = word.indexOf('=');
+        if (index > 0)
+            env[word.slice(0, index)] = word.slice(index + 1);
+    }
+    return env;
+}
+function shellWords(value) {
+    const words = [];
+    let word = '';
+    let quote;
+    let escaping = false;
+    for (const char of value) {
+        if (escaping) {
+            word += char;
+            escaping = false;
+        }
+        else if (char === '\\') {
+            escaping = true;
+        }
+        else if (quote) {
+            if (char === quote)
+                quote = undefined;
+            else
+                word += char;
+        }
+        else if (char === '"' || char === "'") {
+            quote = char;
+        }
+        else if (/\s/.test(char)) {
+            if (word) {
+                words.push(word);
+                word = '';
+            }
+        }
+        else {
+            word += char;
+        }
+    }
+    if (word)
+        words.push(word);
+    return words;
+}
+export const Template = Object.assign((options) => new TemplateBase(options), {
+    build: TemplateBase.build,
+    buildInBackground: TemplateBase.buildInBackground,
+    getBuildStatus: TemplateBase.getBuildStatus,
+    exists: TemplateBase.exists,
+    aliasExists: TemplateBase.aliasExists,
+    assignTags: TemplateBase.assignTags,
+    removeTags: TemplateBase.removeTags,
+    getTags: TemplateBase.getTags,
+    toJSON: TemplateBase.toJSON,
+    toDockerfile: TemplateBase.toDockerfile,
+});
+async function waitForBuildFinish(data, options) {
+    let logsOffset = 0;
+    let status = 'building';
+    while (status === 'building' || status === 'waiting') {
+        const buildStatus = await TemplateBase.getBuildStatus(data, { ...options, logsOffset });
+        logsOffset += buildStatus.logEntries.length;
+        buildStatus.logEntries.forEach((entry) => options.onBuildLogs?.(entry));
+        status = buildStatus.status;
+        if (status === 'ready')
+            return;
+        if (status === 'error')
+            throw new SandboxError(buildStatus.reason?.message ?? 'Template build failed');
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+}
+function normalizeBuildArguments(nameOrOptions, options) {
+    if (typeof nameOrOptions === 'string')
+        return { name: nameOrOptions, buildOptions: options };
+    if (!nameOrOptions.alias)
+        throw new InvalidArgumentError('name is required');
+    return { name: nameOrOptions.alias, buildOptions: nameOrOptions };
+}
+function buildInfo(payload) {
+    const templateId = stringValue(payload.template_id ?? payload.templateId);
+    const buildId = stringValue(payload.build_id ?? payload.buildId);
+    if (!templateId || !buildId)
+        throw new SandboxError('template build response did not include identifiers');
+    return {
+        alias: stringValue(payload.alias) ?? stringValue(payload.name) ?? '',
+        name: stringValue(payload.name) ?? stringValue(payload.alias) ?? '',
+        tags: arrayOfStrings(payload.tags),
+        templateId,
+        buildId,
+    };
+}
+function templateBuildStatus(payload) {
+    return {
+        buildID: stringValue(payload.build_id ?? payload.buildID) ?? '',
+        templateID: stringValue(payload.template_id ?? payload.templateID) ?? '',
+        status: (stringValue(payload.status) ?? 'building'),
+        logEntries: Array.isArray(payload.log_entries)
+            ? payload.log_entries.map((item) => logEntry(record(item)))
+            : [],
+        logs: arrayOfStrings(payload.logs),
+        reason: payload.reason ? buildStatusReason(record(payload.reason)) : undefined,
+    };
+}
+function buildStatusReason(payload) {
+    return {
+        message: stringValue(payload.message) ?? 'Template build failed',
+        step: stringValue(payload.step),
+        logEntries: Array.isArray(payload.log_entries)
+            ? payload.log_entries.map((item) => logEntry(record(item)))
+            : [],
+    };
+}
+function logEntry(payload) {
+    const timestamp = stringValue(payload.timestamp);
+    return {
+        timestamp: timestamp ? new Date(timestamp) : undefined,
+        level: stringValue(payload.level) ?? 'info',
+        message: stringValue(payload.message) ?? '',
+    };
+}
+function templateTag(payload) {
+    return {
+        tag: stringValue(payload.tag) ?? '',
+        buildId: stringValue(payload.build_id ?? payload.buildId) ?? '',
+        createdAt: new Date(stringValue(payload.created_at ?? payload.createdAt) ?? 0),
+    };
+}
+function record(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+function stringValue(value) {
+    if (typeof value === 'string' && value.length > 0)
+        return value;
+    if (typeof value === 'number')
+        return String(value);
+    return undefined;
+}
+function arrayOfStrings(value) {
+    if (Array.isArray(value))
+        return value.map(String);
+    if (typeof value === 'string')
+        return [value];
+    return [];
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/terminal.d.ts

@@ -0,0 +1,41 @@
+import { CommandHandle } from './commands.js';
+import { Pty, PtySize } from './pty.js';
+/** Captured terminal output. */
+export declare class TerminalOutput {
+    private _data;
+    get data(): string;
+    addData(data: string): void;
+}
+export type TerminalOpts = {
+    onData?: (data: string) => Promise<void> | void;
+    onExit?: () => Promise<void> | void;
+    size?: PtySize;
+    terminalID?: string;
+    cmd?: string;
+    cwd?: string;
+    rootDir?: string;
+    envVars?: Record<string, string>;
+    timeout?: number;
+};
+/** A running terminal session in a sandbox. */
+export declare class Terminal {
+    readonly terminalID: string;
+    private readonly handle;
+    readonly output: TerminalOutput;
+    private readonly onExit?;
+    readonly finished: Promise<TerminalOutput>;
+    private waitPromise?;
+    constructor(terminalID: string, handle: CommandHandle, output: TerminalOutput, onExit?: (() => Promise<void> | void) | undefined);
+    get data(): string;
+    kill(): Promise<void>;
+    wait(): Promise<TerminalOutput>;
+    private waitOnce;
+    sendData(data: string): Promise<void>;
+    resize({ cols, rows }: PtySize): Promise<void>;
+}
+/** Manager for starting terminal sessions. */
+export declare class TerminalManager {
+    private readonly pty;
+    constructor(pty: Pty);
+    start(opts?: TerminalOpts): Promise<Terminal>;
+}