@kisev/agentomatic 11.0.0-dev.46.gfbe1e4c6992e

package/dist/runtime/state.js

@@ -0,0 +1,193 @@
+import { createHash } from "node:crypto";
+import { lstat, mkdir, open, readFile, readdir, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { appendPrivate, withLifecycleLock, writeAtomic } from "../lifecycle.js";
+function home(value = process.env.HOME ?? homedir()) {
+    if (!isAbsolute(value) || value.split(sep).includes(".."))
+        throw new Error("HOME must be an absolute safe path");
+    return resolve(value);
+}
+function inside(root, target) {
+    const value = relative(root, target);
+    return value === "" || (!value.startsWith(`..${sep}`) && value !== "..");
+}
+export function stateRoot(name, homePath) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name))
+        throw new Error("unsafe state name");
+    const configured = process.env.XDG_STATE_HOME;
+    if (configured && (!isAbsolute(configured) || configured.split(sep).includes("..")))
+        throw new Error("XDG_STATE_HOME must be an absolute safe path");
+    const base = configured ? resolve(configured) : join(home(homePath), ".local", "state");
+    return join(base, "opencode", "skills", name);
+}
+export function configRoot(name, homePath) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name))
+        throw new Error("unsafe config name");
+    const base = process.env.XDG_CONFIG_HOME
+        ? resolve(process.env.XDG_CONFIG_HOME)
+        : join(home(homePath), ".config");
+    return join(base, "opencode", "skill-config", name);
+}
+async function safeDirectory(path, boundary, create = false) {
+    const target = resolve(path);
+    if (!inside(boundary, target))
+        throw new Error("state path escapes its boundary");
+    try {
+        const info = await lstat(boundary);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error("state directory is unsafe");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (create) {
+        let current = resolve(target).startsWith(sep) ? sep : "";
+        for (const piece of resolve(target).split(sep).filter(Boolean)) {
+            current = join(current, piece);
+            try {
+                const info = await lstat(current);
+                if (!info.isDirectory() || info.isSymbolicLink())
+                    throw new Error("state directory is unsafe");
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+                await mkdir(current, { mode: 0o700 });
+            }
+        }
+    }
+    const rootInfo = await lstat(boundary);
+    if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink())
+        throw new Error("state directory is unsafe");
+    let current = resolve(boundary);
+    for (const piece of relative(current, target).split(sep).filter(Boolean)) {
+        current = join(current, piece);
+        const info = await lstat(current);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error("state directory is unsafe");
+    }
+}
+export async function readState(path, boundary) {
+    if (!inside(boundary, path))
+        throw new Error("state path escapes its boundary");
+    try {
+        await safeDirectory(dirname(path), boundary);
+        const info = await lstat(path);
+        if (!info.isFile() || info.isSymbolicLink())
+            throw new Error("state file is unsafe");
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+export async function listState(boundary, suffix = ".json") {
+    try {
+        await safeDirectory(boundary, boundary);
+        return (await readdir(boundary)).filter((name) => name.endsWith(suffix)).sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function writeState(path, boundary, value) {
+    if (!inside(boundary, path))
+        throw new Error("state path escapes its boundary");
+    await withLifecycleLock(boundary, async () => {
+        await safeDirectory(dirname(path), boundary, true);
+        await writeAtomic(path, Buffer.from(`${JSON.stringify(value)}\n`), 0o600);
+    });
+}
+function stableValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableValue);
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => [key, stableValue(item)]));
+    return value;
+}
+async function immutableState(path, boundary, content) {
+    await safeDirectory(dirname(path), boundary, true);
+    let created = false;
+    try {
+        const file = await open(path, "wx", 0o600);
+        created = true;
+        try {
+            await file.writeFile(content);
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        }
+        const directory = await open(dirname(path), "r");
+        try {
+            await directory.sync();
+        }
+        finally {
+            await directory.close();
+        }
+    }
+    catch (error) {
+        if (created) {
+            try {
+                await rm(path, { force: true });
+                const directory = await open(dirname(path), "r");
+                try {
+                    await directory.sync();
+                }
+                finally {
+                    await directory.close();
+                }
+            }
+            catch {
+                // Preserve the write failure; a later immutable-content check remains fail-closed.
+            }
+            throw error;
+        }
+        if (error.code !== "EEXIST")
+            throw error;
+        const info = await lstat(path);
+        if (!info.isFile() || info.isSymbolicLink() || !(await readFile(path)).equals(content))
+            throw new Error("immutable state history was changed");
+    }
+}
+export async function writeVersionedState(path, boundary, logicalName, value) {
+    if (!inside(boundary, path))
+        throw new Error("state path escapes its boundary");
+    const body = Buffer.from(`${JSON.stringify(stableValue(value))}\n`);
+    const history = join(boundary, "history", digest({ logicalName }));
+    try {
+        const info = await lstat(path);
+        if (!info.isFile() || info.isSymbolicLink())
+            throw new Error("state file is unsafe");
+        const previous = await readFile(path);
+        await immutableState(join(history, `${createHash("sha256").update(previous).digest("hex")}.json`), boundary, previous);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    await safeDirectory(dirname(path), boundary, true);
+    await writeAtomic(path, body, 0o600);
+}
+export async function appendState(path, boundary, value) {
+    if (!inside(boundary, path))
+        throw new Error("state path escapes its boundary");
+    await withLifecycleLock(boundary, async () => {
+        await safeDirectory(dirname(path), boundary, true);
+        await appendPrivate(path, value);
+    });
+}
+export async function withStateLock(boundary, callback) {
+    return withLifecycleLock(boundary, callback);
+}
+export function digest(value) {
+    return createHash("sha256").update(JSON.stringify(value), "utf8").digest("hex");
+}

package/dist/runtime/worktree.d.ts

@@ -0,0 +1,33 @@
+export type WorktreeStatus = "managed" | "missing" | "blocked" | "unknown";
+export type WorktreeRecord = {
+    schema_version: 1;
+    workspace_id: string;
+    project: string;
+    path: string;
+    branch: string;
+    start_ref: string;
+    repository_fingerprint: string;
+    marker: string;
+    status: WorktreeStatus;
+    created_at: string;
+    updated_at: string;
+};
+export declare function worktreePlan(project: string, workspaceID?: `${string}-${string}-${string}-${string}-${string}`): Promise<Record<string, unknown>>;
+export declare function worktreeCreate(input: {
+    project: string;
+    workspace_id: string;
+    path?: string;
+    branch?: string;
+    start_ref?: string;
+}): Promise<WorktreeRecord>;
+export declare function worktreeStatus(project: string, workspaceID: string): Promise<WorktreeRecord | undefined>;
+export declare function worktreeList(project: string): Promise<WorktreeRecord[]>;
+export declare function worktreeRelease(project: string, workspaceID: string): Promise<{
+    status: "released" | "blocked";
+    workspace_id: string;
+    reason?: string;
+}>;
+export declare function worktreeRecover(project: string): Promise<{
+    recovered: number;
+    blocked: number;
+}>;

package/dist/runtime/worktree.js

@@ -0,0 +1,220 @@
+import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { chmod, lstat, mkdir, readFile, readdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { digest, listState, readState, stateRoot, withStateLock, writeVersionedState, } from "./state.js";
+import { appendPrivate, writeAtomic } from "../lifecycle.js";
+const run = promisify(execFile);
+const SCHEMA_VERSION = 1;
+function markerPath(path) {
+    return join(path, ".opencode-worktree.json");
+}
+function root(project) {
+    return join(stateRoot("worktree"), digest(resolve(project)));
+}
+function recordPath(project, id) {
+    return join(root(project), "workspaces", `${id}.json`);
+}
+async function git(project, args) {
+    const result = await run("git", args, { cwd: project, maxBuffer: 1024 * 1024 });
+    return result.stdout.trim();
+}
+async function fingerprint(project) {
+    const common = await git(project, ["rev-parse", "--git-common-dir"]);
+    return digest({ common: resolve(project, common) });
+}
+async function privateDirectory(path) {
+    const info = await lstat(path);
+    if (!info.isDirectory() || info.isSymbolicLink() || (info.mode & 0o077) !== 0)
+        throw new Error("workspace directory is unsafe");
+}
+async function marker(path) {
+    try {
+        const info = await lstat(markerPath(path));
+        if (!info.isFile() || info.isSymbolicLink() || info.nlink !== 1 || (info.mode & 0o077) !== 0)
+            throw new Error("workspace marker is unsafe");
+        return JSON.parse(await readFile(markerPath(path), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function saveRecord(item, event) {
+    const state = root(item.project);
+    item.updated_at = new Date().toISOString();
+    await writeVersionedState(recordPath(item.project, item.workspace_id), state, `workspace:${item.workspace_id}`, item);
+    await appendPrivate(join(state, "receipts.jsonl"), {
+        schema_version: 1,
+        event,
+        workspace_id: item.workspace_id,
+        status: item.status,
+        at: item.updated_at,
+    });
+    await appendPrivate(join(state, event.startsWith("release") ? "release.journal.jsonl" : "create.journal.jsonl"), {
+        schema_version: 1,
+        event,
+        workspace_id: item.workspace_id,
+        path: item.path,
+        at: item.updated_at,
+    });
+}
+async function records(project) {
+    const state = root(project);
+    const directory = join(state, "workspaces");
+    const values = await Promise.all((await listState(directory)).map((name) => readState(recordPath(project, name.slice(0, -5)), state)));
+    for (const value of values)
+        if (value && value.schema_version !== SCHEMA_VERSION)
+            throw new Error("unsupported_schema");
+    return values.filter((v) => Boolean(v));
+}
+async function inspect(item) {
+    try {
+        await privateDirectory(item.path);
+        const actual = await marker(item.path);
+        if (!actual ||
+            actual.workspace_id !== item.workspace_id ||
+            actual.repository_fingerprint !== item.repository_fingerprint ||
+            actual.project !== item.project ||
+            actual.marker !== item.marker)
+            return "unknown";
+        const registered = await git(item.project, ["worktree", "list", "--porcelain"]);
+        if (!registered.split("\n").some((line) => line === `worktree ${item.path}`))
+            return "unknown";
+        if ((await fingerprint(item.path)) !== item.repository_fingerprint)
+            return "blocked";
+        const status = await git(item.path, ["status", "--porcelain"]);
+        const foreignChanges = status
+            .split("\n")
+            .filter((line) => line && line !== "?? .opencode-worktree.json");
+        return foreignChanges.length ? "blocked" : "managed";
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "missing";
+        return "blocked";
+    }
+}
+export async function worktreePlan(project, workspaceID = randomUUID()) {
+    const rootProject = resolve(project);
+    const repo = await fingerprint(rootProject);
+    return {
+        schema_version: SCHEMA_VERSION,
+        workspace_id: workspaceID,
+        project: rootProject,
+        path: join(stateRoot("worktree"), "managed", digest(rootProject), workspaceID),
+        start_ref: await git(rootProject, ["rev-parse", "HEAD"]),
+        repository_fingerprint: repo,
+    };
+}
+export async function worktreeCreate(input) {
+    const project = resolve(input.project);
+    const state = root(project);
+    return withStateLock(state, async () => {
+        const existing = await readState(recordPath(project, input.workspace_id), state);
+        if (existing) {
+            const status = await inspect(existing);
+            existing.status = status;
+            await saveRecord(existing, "create.idempotent");
+            if (status !== "managed")
+                throw new Error(`workspace ${status}`);
+            return existing;
+        }
+        const repo = await fingerprint(project);
+        const path = resolve(input.path ?? join(stateRoot("worktree"), "managed", digest(project), input.workspace_id));
+        const branch = input.branch ?? `opencode/${input.workspace_id}`;
+        const start = input.start_ref ?? (await git(project, ["rev-parse", "HEAD"]));
+        try {
+            const existingPath = await lstat(path);
+            if (!existingPath.isDirectory() || existingPath.isSymbolicLink())
+                throw new Error("workspace path is unsafe");
+            throw new Error((await readdir(path)).length
+                ? "workspace path is unknown and not empty"
+                : "workspace path is unknown");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+        await git(project, ["worktree", "add", "-b", branch, path, start]);
+        await chmod(path, 0o700);
+        const markerValue = {
+            schema_version: 1,
+            workspace_id: input.workspace_id,
+            project,
+            repository_fingerprint: repo,
+            marker: randomUUID(),
+        };
+        await writeAtomic(markerPath(path), Buffer.from(`${JSON.stringify(markerValue)}\n`), 0o600);
+        const item = {
+            schema_version: 1,
+            workspace_id: input.workspace_id,
+            project,
+            path,
+            branch,
+            start_ref: start,
+            repository_fingerprint: repo,
+            marker: String(markerValue.marker),
+            status: "managed",
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+        };
+        await saveRecord(item, "create.completed");
+        return item;
+    });
+}
+export async function worktreeStatus(project, workspaceID) {
+    const item = await readState(recordPath(resolve(project), workspaceID), root(resolve(project)));
+    if (!item)
+        return undefined;
+    if (item.schema_version !== SCHEMA_VERSION)
+        throw new Error("unsupported_schema");
+    item.status = await inspect(item);
+    return item;
+}
+export async function worktreeList(project) {
+    const result = await records(resolve(project));
+    for (const item of result)
+        item.status = await inspect(item);
+    return result;
+}
+export async function worktreeRelease(project, workspaceID) {
+    const projectRoot = resolve(project);
+    return withStateLock(root(projectRoot), async () => {
+        const item = await worktreeStatus(projectRoot, workspaceID);
+        if (!item)
+            throw new Error("workspace not found");
+        if (item.status !== "managed")
+            return { status: "blocked", workspace_id: workspaceID, reason: item.status };
+        try {
+            await git(item.project, ["worktree", "remove", "--force", item.path]);
+            item.status = "missing";
+            await saveRecord(item, "release.completed");
+            return { status: "released", workspace_id: workspaceID };
+        }
+        catch (error) {
+            return { status: "blocked", workspace_id: workspaceID, reason: String(error) };
+        }
+    });
+}
+export async function worktreeRecover(project) {
+    const projectRoot = resolve(project);
+    const items = await worktreeList(projectRoot);
+    const result = { recovered: 0, blocked: 0 };
+    await withStateLock(root(projectRoot), async () => {
+        for (const item of items) {
+            if (item.status === "managed") {
+                result.recovered += 1;
+                await saveRecord(item, "recover.completed");
+            }
+            else if (item.status !== "missing") {
+                result.blocked += 1;
+                await saveRecord(item, "recover.blocked");
+            }
+        }
+    });
+    return result;
+}

package/dist/terminal-wizard.d.ts

@@ -0,0 +1,3 @@
+export declare function selectOption(label: string, options: readonly string[], stdin?: NodeJS.ReadStream, stderr?: NodeJS.WriteStream, initial?: number): Promise<number | null>;
+export declare function selectOptions(label: string, options: readonly string[], initialSelected?: readonly string[], stdin?: NodeJS.ReadStream, stderr?: NodeJS.WriteStream): Promise<string[] | null>;
+export declare function promptText(label: string, stdin?: NodeJS.ReadStream, stderr?: NodeJS.WriteStream): Promise<string | null>;

package/dist/terminal-wizard.js

@@ -0,0 +1,237 @@
+import { InstallerError } from "./installer.js";
+function parseKey(buffer) {
+    const seq = buffer.toString();
+    if (seq === "\r" || seq === "\n")
+        return { name: "return", sequence: seq };
+    if (seq === " ")
+        return { name: "space", sequence: seq };
+    if (seq === "a" || seq === "A")
+        return { name: "all", sequence: seq };
+    if (seq === "n" || seq === "N")
+        return { name: "none", sequence: seq };
+    if (seq === "\x03")
+        return { name: "ctrl+c", sequence: seq };
+    if (seq === "\x04")
+        return { name: "ctrl+d", sequence: seq };
+    if (seq === "\x1b" || seq === "\x1b\x1b" || seq === "\x1b\x1b\x1b")
+        return { name: "escape", sequence: seq };
+    if (seq === "\x1b[A" || seq === "\x1bOA" || seq === "\x1b[OA")
+        return { name: "up", sequence: seq };
+    if (seq === "\x1b[B" || seq === "\x1bOB" || seq === "\x1b[OB")
+        return { name: "down", sequence: seq };
+    if (seq === "\x1b[C" || seq === "\x1bOC" || seq === "\x1b[OC")
+        return { name: "right", sequence: seq };
+    if (seq === "\x1b[D" || seq === "\x1bOD" || seq === "\x1b[OD")
+        return { name: "left", sequence: seq };
+    return { name: "unknown", sequence: seq };
+}
+function nextSequence(remaining) {
+    if (remaining.startsWith("\x1b[O"))
+        return remaining.slice(0, 4);
+    if (remaining.startsWith("\x1b[") || remaining.startsWith("\x1bO"))
+        return remaining.slice(0, 3);
+    return remaining[0];
+}
+function validateOptions(options) {
+    if (options.length === 0)
+        throw new InstallerError("invalid_input", "Interactive selector requires at least one option");
+    if (new Set(options).size !== options.length)
+        throw new InstallerError("invalid_input", "Interactive selector options must be unique");
+}
+function clearLines(stderr, count) {
+    for (let i = 0; i < count; i++) {
+        stderr.write("\x1b[A\x1b[K");
+    }
+}
+export async function selectOption(label, options, stdin = process.stdin, stderr = process.stderr, initial = 0) {
+    if (!stdin.isTTY || !stderr.isTTY) {
+        throw new InstallerError("terminal_required", "This operation requires an interactive terminal");
+    }
+    validateOptions(options);
+    let selected = Math.max(0, Math.min(initial, options.length - 1));
+    const lineCount = options.length + 2;
+    function render() {
+        stderr.write(`? ${label}\n`);
+        stderr.write("  Up/Down move | Enter select | Esc cancel\n");
+        for (let i = 0; i < options.length; i++) {
+            const cursor = i === selected ? "> " : "  ";
+            stderr.write(`${cursor}${options[i]}\n`);
+        }
+    }
+    render();
+    return new Promise((resolve) => {
+        stdin.setRawMode(true);
+        stdin.resume();
+        function cleanup() {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+        }
+        function onData(data) {
+            let remaining = data.toString();
+            while (remaining) {
+                const sequence = nextSequence(remaining);
+                remaining = remaining.slice(sequence.length);
+                const key = parseKey(Buffer.from(sequence));
+                if (key.name === "ctrl+c" || key.name === "ctrl+d" || key.name === "escape") {
+                    cleanup();
+                    clearLines(stderr, lineCount);
+                    resolve(null);
+                    return;
+                }
+                if (key.name === "return") {
+                    cleanup();
+                    clearLines(stderr, lineCount);
+                    resolve(selected);
+                    return;
+                }
+                if (key.name === "up") {
+                    clearLines(stderr, lineCount);
+                    selected = (selected - 1 + options.length) % options.length;
+                    render();
+                }
+                else if (key.name === "down") {
+                    clearLines(stderr, lineCount);
+                    selected = (selected + 1) % options.length;
+                    render();
+                }
+            }
+        }
+        stdin.on("data", onData);
+    });
+}
+export async function selectOptions(label, options, initialSelected = [], stdin = process.stdin, stderr = process.stderr) {
+    if (!stdin.isTTY || !stderr.isTTY) {
+        throw new InstallerError("terminal_required", "This operation requires an interactive terminal");
+    }
+    validateOptions(options);
+    const allowed = new Set(options);
+    for (const value of initialSelected) {
+        if (!allowed.has(value))
+            throw new InstallerError("invalid_input", `Unknown initial selector option: ${value}`);
+    }
+    const selected = new Set(initialSelected);
+    let active = 0;
+    const lineCount = options.length + 3;
+    function render() {
+        stderr.write(`? ${label}\n`);
+        stderr.write("  Up/Down move | Space toggle | A all | N none | Enter confirm | Esc cancel\n");
+        for (let index = 0; index < options.length; index += 1) {
+            const cursor = index === active ? "> " : "  ";
+            const marker = selected.has(options[index]) ? "[x]" : "[ ]";
+            stderr.write(`${cursor}${marker} ${options[index]}\n`);
+        }
+        stderr.write(`  Selected ${selected.size}/${options.length}\n`);
+    }
+    render();
+    return new Promise((resolve) => {
+        stdin.setRawMode(true);
+        stdin.resume();
+        function cleanup() {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+        }
+        function finish(value) {
+            cleanup();
+            clearLines(stderr, lineCount);
+            resolve(value);
+        }
+        function redraw(update) {
+            clearLines(stderr, lineCount);
+            update();
+            render();
+        }
+        function onData(data) {
+            let remaining = data.toString();
+            while (remaining) {
+                const sequence = nextSequence(remaining);
+                remaining = remaining.slice(sequence.length);
+                const key = parseKey(Buffer.from(sequence));
+                if (key.name === "ctrl+c" || key.name === "ctrl+d" || key.name === "escape") {
+                    finish(null);
+                    return;
+                }
+                if (key.name === "return") {
+                    finish(options.filter((option) => selected.has(option)));
+                    return;
+                }
+                if (key.name === "up") {
+                    redraw(() => {
+                        active = (active - 1 + options.length) % options.length;
+                    });
+                }
+                else if (key.name === "down") {
+                    redraw(() => {
+                        active = (active + 1) % options.length;
+                    });
+                }
+                else if (key.name === "space") {
+                    redraw(() => {
+                        const option = options[active];
+                        if (selected.has(option))
+                            selected.delete(option);
+                        else
+                            selected.add(option);
+                    });
+                }
+                else if (key.name === "all") {
+                    redraw(() => {
+                        for (const option of options)
+                            selected.add(option);
+                    });
+                }
+                else if (key.name === "none") {
+                    redraw(() => selected.clear());
+                }
+            }
+        }
+        stdin.on("data", onData);
+    });
+}
+export async function promptText(label, stdin = process.stdin, stderr = process.stderr) {
+    if (!stdin.isTTY || !stderr.isTTY) {
+        throw new InstallerError("terminal_required", "This operation requires an interactive terminal");
+    }
+    stderr.write(`? ${label}\n`);
+    stderr.write("  Type a value | Enter confirm | Esc cancel\n");
+    stderr.write("> ");
+    return new Promise((resolve) => {
+        let buffer = "";
+        stdin.setRawMode(true);
+        stdin.resume();
+        function cleanup() {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+        }
+        function onData(data) {
+            for (const seq of data.toString()) {
+                if (seq === "\r" || seq === "\n") {
+                    cleanup();
+                    stderr.write("\n");
+                    resolve(buffer.trim() || null);
+                    return;
+                }
+                if (seq === "\x03" || seq === "\x04" || seq === "\x1b") {
+                    cleanup();
+                    stderr.write("\n");
+                    resolve(null);
+                    return;
+                }
+                if (seq === "\x7f" || seq === "\b") {
+                    if (buffer.length > 0) {
+                        buffer = buffer.slice(0, -1);
+                        stderr.write("\x1b[D \x1b[D");
+                    }
+                    continue;
+                }
+                if (seq >= " ") {
+                    buffer += seq;
+                    stderr.write(seq);
+                }
+            }
+        }
+        stdin.on("data", onData);
+    });
+}