@indianic/dialout 1.10.0 → 1.12.0

package/dist/cli-terminal.js

@@ -0,0 +1,1121 @@
+"use strict";
+// User CLI session: login, the machine list, a remote shell, and one-file
+// copy. config.json's apiKey and WS_INTERNAL_TOKEN are never read. The
+// session file is the user JWT only. Leaving this process detaches the
+// view; it must not end the remote tmux session.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+exports.logout = logout;
+exports.printMachines = printMachines;
+exports.machineMatchError = machineMatchError;
+exports.connectMachine = connectMachine;
+exports.fatalTerminalFrame = fatalTerminalFrame;
+exports.bridgeTerminal = bridgeTerminal;
+exports.sharedControlMessage = sharedControlMessage;
+exports.controlWaitMsFor = controlWaitMsFor;
+exports.runTerminalControl = runTerminalControl;
+exports.transferCopy = transferCopy;
+exports.copyCommand = copyCommand;
+exports.copyFile = copyFile;
+exports.serveMcp = serveMcp;
+const crypto_1 = require("crypto");
+const http_1 = require("http");
+const https_1 = require("https");
+const fs_1 = require("fs");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const ws_1 = __importDefault(require("ws"));
+const config_1 = require("./config");
+const cli_client_1 = require("./cli-client");
+const mcp_stdio_1 = require("./mcp-stdio");
+const LOGIN_EXPIRED = 'dialout: login expired, run dialout login\n';
+const ORIGIN_TEXT = 'dialout: server URL could not be turned into an API origin';
+const ORIGIN_FAILED = `${ORIGIN_TEXT}\n`;
+const ENROLL_MSG = 'dialout: finish two-factor enrollment in the browser, then run dialout login\n';
+const EXISTS_CONFLICT = 'exists (use overwrite)';
+const FILE_TOO_BIG = 'file exceeds 10 MB';
+// Stat stays on the JSON budget. File bytes wait long enough that a relay
+// which answers at 70s can still return 504 instead of a client timeout.
+const JSON_TIMEOUT_MS = 20_000;
+const FILE_BYTE_TIMEOUT_MS = 90_000;
+// The server fires "Agent did not answer" at this pad past the caller's
+// deadline. The client pad is on top of that, so the sentence wins the race.
+const SERVER_SILENCE_PAD_MS = 5_000;
+const CLIENT_WAIT_PAD_MS = 5_000;
+const DEFAULT_CONTROL_MS = 120_000;
+function sessionFile() {
+    return path.join((0, config_1.getConfigDir)(), 'cli-session.json');
+}
+function unlisten(emitter, event, listener) {
+    if (typeof emitter.off === 'function')
+        emitter.off(event, listener);
+    else
+        emitter.removeListener?.(event, listener);
+}
+function chunkText(chunk) {
+    return typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+}
+// Bytes left after a newline when one read delivered two prompts. A pipe
+// can do that; a tty usually does not.
+let carry = '';
+// PIN is the only hidden prompt. A tty in raw mode does not echo. Cooked
+// mode already echoes, and a pipe has no echo to suppress.
+function readLine(io, label, hidden) {
+    io.stdout.write(label);
+    const stdin = io.stdin;
+    const raw = hidden && stdin.isTTY === true && typeof stdin.setRawMode === 'function';
+    if (raw)
+        stdin.setRawMode(true);
+    return new Promise((resolve) => {
+        let buf = '';
+        const seeded = carry;
+        carry = '';
+        const cleanup = () => {
+            unlisten(stdin, 'data', onData);
+            if (raw) {
+                try {
+                    stdin.setRawMode(false);
+                }
+                catch { /* tty already gone */ }
+            }
+            stdin.pause?.();
+        };
+        const finish = (line) => {
+            cleanup();
+            if (raw)
+                io.stdout.write('\n');
+            resolve(line);
+        };
+        const push = (text) => {
+            for (let i = 0; i < text.length; i++) {
+                const ch = text[i] ?? '';
+                if (ch === '\u0003') {
+                    cleanup();
+                    process.exit(130);
+                }
+                if (ch === '\n' || ch === '\r') {
+                    if (ch === '\r' && text[i + 1] === '\n')
+                        i += 1;
+                    carry = text.slice(i + 1);
+                    finish(buf);
+                    return true;
+                }
+                if (raw && (ch === '\u007f' || ch === '\b')) {
+                    buf = buf.slice(0, -1);
+                    continue;
+                }
+                buf += ch;
+            }
+            return false;
+        };
+        const onData = (chunk) => {
+            push(chunkText(chunk));
+        };
+        if (seeded && push(seeded))
+            return;
+        stdin.on('data', onData);
+        stdin.resume?.();
+    });
+}
+function requestBytes(method, target, headers, body, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        };
+        const ok = (status, buf) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ status, body: buf });
+        };
+        const url = new URL(target);
+        const lib = url.protocol === 'https:' ? https_1.request : http_1.request;
+        const reqHeaders = { ...headers };
+        if (body !== undefined)
+            reqHeaders['Content-Length'] = String(body.length);
+        const req = lib(url, { method, headers: reqHeaders }, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => {
+                chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+            });
+            res.on('end', () => {
+                ok(res.statusCode ?? 0, Buffer.concat(chunks));
+            });
+        });
+        // A stuck API call should not hold the prompt open forever.
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error('timed out'));
+        });
+        req.on('error', (err) => fail(err));
+        if (body !== undefined)
+            req.write(body);
+        req.end();
+    });
+}
+function parseJsonBody(body) {
+    const text = body.toString('utf8');
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function requestJson(method, target, headers, body) {
+    return requestBytes(method, target, headers, body !== undefined ? Buffer.from(body, 'utf8') : undefined, JSON_TIMEOUT_MS).then(({ status, body: buf }) => ({ status, json: parseJsonBody(buf) }));
+}
+async function postAuth(origin, body) {
+    const { json } = await requestJson('POST', `${origin}/api/auth`, {
+        'Content-Type': 'application/json',
+        'X-DevDash-Client': 'native',
+    }, JSON.stringify(body));
+    return json;
+}
+function fail(io, message) {
+    io.stderr.write(message.endsWith('\n') ? message : `${message}\n`);
+    process.exitCode = 1;
+}
+async function login(io) {
+    const { serverUrl } = (0, config_1.loadConfig)();
+    const origin = (0, cli_client_1.apiOriginFromServerUrl)(serverUrl);
+    if (!origin) {
+        fail(io, ORIGIN_FAILED);
+        return;
+    }
+    const email = (await readLine(io, 'Email: ', false)).trim();
+    const otpCode = (await readLine(io, 'PIN: ', true)).trim();
+    let first;
+    try {
+        const loginBody = {
+            action: 'login',
+            email,
+            otpCode,
+        };
+        first = await postAuth(origin, loginBody);
+    }
+    catch (err) {
+        fail(io, `dialout: ${err instanceof Error ? err.message : 'request failed'}`);
+        return;
+    }
+    let step = (0, cli_client_1.interpretAuthBody)(first);
+    if (step.step === 'totp') {
+        const code = (await readLine(io, 'Authenticator code: ', false)).trim();
+        const pendingToken = step.pendingToken;
+        try {
+            // No trustDevice: this client has no browser trust cookie to set.
+            const verifyBody = {
+                action: 'verify-2fa',
+                code,
+                pendingToken,
+            };
+            step = (0, cli_client_1.interpretAuthBody)(await postAuth(origin, verifyBody));
+        }
+        catch (err) {
+            fail(io, `dialout: ${err instanceof Error ? err.message : 'request failed'}`);
+            return;
+        }
+    }
+    if (step.step === 'enroll') {
+        fail(io, ENROLL_MSG);
+        return;
+    }
+    if (step.step === 'error') {
+        fail(io, step.message);
+        return;
+    }
+    if (step.step !== 'store') {
+        fail(io, 'unexpected login response');
+        return;
+    }
+    (0, cli_client_1.writeCliSession)(sessionFile(), { token: step.token, serverUrl });
+}
+function logout() {
+    const file = sessionFile();
+    if (!(0, fs_1.existsSync)(file))
+        return;
+    try {
+        (0, fs_1.unlinkSync)(file);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT')
+            throw err;
+    }
+}
+function readMachineRows(json) {
+    if (!Array.isArray(json))
+        return null;
+    const rows = [];
+    for (const item of json) {
+        if (typeof item !== 'object' || item === null)
+            return null;
+        const rec = item;
+        if (typeof rec.id !== 'number' || !Number.isInteger(rec.id))
+            return null;
+        if (typeof rec.name !== 'string' || rec.name.length === 0)
+            return null;
+        rows.push({ id: rec.id, name: rec.name, isOnline: rec.isOnline === true });
+    }
+    return rows;
+}
+async function fetchMachines(session, http) {
+    const origin = (0, cli_client_1.apiOriginFromServerUrl)(session.serverUrl);
+    if (!origin)
+        return { ok: false, kind: 'origin' };
+    try {
+        const headers = { Authorization: `Bearer ${session.token}` };
+        const target = `${origin}/api/machines`;
+        let status;
+        let json;
+        if (http) {
+            const res = await http({ method: 'GET', url: target, headers, timeoutMs: JSON_TIMEOUT_MS });
+            status = res.status;
+            json = parseJsonBody(res.body);
+        }
+        else {
+            const got = await requestJson('GET', target, headers);
+            status = got.status;
+            json = got.json;
+        }
+        if (status === 401)
+            return { ok: false, kind: 'expired' };
+        if (status < 200 || status >= 300)
+            return { ok: false, kind: 'http', detail: String(status) };
+        const rows = readMachineRows(json);
+        if (!rows)
+            return { ok: false, kind: 'http' };
+        return { ok: true, rows };
+    }
+    catch (err) {
+        return { ok: false, kind: 'network', detail: err instanceof Error ? err.message : 'request failed' };
+    }
+}
+function reportFetchFailure(result) {
+    if (result.kind === 'expired') {
+        process.stderr.write(LOGIN_EXPIRED);
+        return;
+    }
+    if (result.kind === 'origin') {
+        process.stderr.write(ORIGIN_FAILED);
+        return;
+    }
+    if (result.kind === 'network') {
+        process.stderr.write(`dialout: ${result.detail ?? 'request failed'}\n`);
+        return;
+    }
+    const suffix = result.detail ? ` (${result.detail})` : '';
+    process.stderr.write(`dialout: could not list machines${suffix}\n`);
+}
+async function printMachines() {
+    const session = (0, cli_client_1.readCliSession)(sessionFile());
+    if (!session) {
+        process.stderr.write(LOGIN_EXPIRED);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await fetchMachines(session);
+    if (!result.ok) {
+        reportFetchFailure(result);
+        process.exitCode = 1;
+        return;
+    }
+    for (const row of result.rows) {
+        process.stdout.write(`${row.id}  ${row.name}  ${row.isOnline ? 'online' : 'offline'}\n`);
+    }
+}
+function machineMatchError(input, matched) {
+    if (matched.reason === 'none')
+        return `dialout: no machine named "${input}"`;
+    if (matched.reason === 'offline') {
+        const label = matched.matches[0]?.name ?? input;
+        return `dialout: ${label} is offline`;
+    }
+    return matched.matches
+        .map((row) => `  ${row.id}  ${row.name}  ${row.isOnline ? 'online' : 'offline'}`)
+        .join('\n');
+}
+function reportMatch(name, matched) {
+    if (matched.ok)
+        return true;
+    process.stderr.write(`${machineMatchError(name, matched)}\n`);
+    return false;
+}
+async function connectMachine(name) {
+    const session = (0, cli_client_1.readCliSession)(sessionFile());
+    if (!session) {
+        process.stderr.write(LOGIN_EXPIRED);
+        return 1;
+    }
+    // The token was issued for the server URL stored beside it. A later
+    // profile switch must not reuse it against a different server.
+    const { serverUrl } = (0, config_1.loadConfig)();
+    if (session.serverUrl !== serverUrl) {
+        process.stderr.write(LOGIN_EXPIRED);
+        return 1;
+    }
+    const result = await fetchMachines(session);
+    if (!result.ok) {
+        reportFetchFailure(result);
+        return 1;
+    }
+    const matched = (0, cli_client_1.matchMachine)(result.rows, name);
+    if (!reportMatch(name, matched))
+        return 1;
+    if (!matched.ok)
+        return 1;
+    const url = (0, cli_client_1.terminalSocketUrl)(session.serverUrl, matched.machine.id, session.token);
+    if (!url) {
+        process.stderr.write(ORIGIN_FAILED);
+        return 1;
+    }
+    return bridgeTerminal({
+        url,
+        machineName: matched.machine.name,
+        machineId: matched.machine.id,
+        pid: process.pid,
+        stdin: process.stdin,
+        stdout: process.stdout,
+        signals: process,
+    });
+}
+function termSize(stdout) {
+    const cols = typeof stdout.columns === 'number' && stdout.columns > 0 ? stdout.columns : 80;
+    const rows = typeof stdout.rows === 'number' && stdout.rows > 0 ? stdout.rows : 24;
+    return { cols, rows };
+}
+function messageText(raw) {
+    if (typeof raw === 'string')
+        return raw;
+    if (Buffer.isBuffer(raw))
+        return raw.toString('utf8');
+    if (raw instanceof ArrayBuffer)
+        return Buffer.from(raw).toString('utf8');
+    if (Array.isArray(raw) && raw.every((part) => Buffer.isBuffer(part))) {
+        return Buffer.concat(raw).toString('utf8');
+    }
+    return '';
+}
+function fatalSentence(error) {
+    return error.endsWith('\n') ? error : `${error}\n`;
+}
+// Frames that must settle the local tty. `unauthorized` is not one of them:
+// that sentence is the login-expired path, not the server's text.
+function fatalTerminalFrame(msg, sessionId) {
+    if (typeof msg !== 'object' || msg === null || Array.isArray(msg))
+        return null;
+    const rec = msg;
+    if (rec.type === 'pty_error') {
+        if (rec.id !== sessionId || typeof rec.error !== 'string')
+            return null;
+        return { sentence: fatalSentence(rec.error) };
+    }
+    if (rec.type === 'error' && typeof rec.error === 'string' && rec.error !== 'unauthorized') {
+        return { sentence: fatalSentence(rec.error) };
+    }
+    return null;
+}
+function bridgeTerminal(opts) {
+    // A new id per process, so this attach does not steal another viewer's
+    // socket. The tmux name stays one shell per machine.
+    const id = `cli-m${opts.machineId}-${opts.pid}`;
+    const tmuxName = `dd-m${opts.machineId}`;
+    const socket = opts.socket ?? new ws_1.default(opts.url);
+    let rawOn = false;
+    let settled = false;
+    const restoreTty = () => {
+        if (!rawOn)
+            return;
+        rawOn = false;
+        try {
+            opts.stdin.setRawMode?.(false);
+        }
+        catch { /* tty already restored */ }
+    };
+    // The hint is a normal line. Raw mode is what hands the screen to the remote shell.
+    process.stderr.write(`dialout: ${opts.machineName} \u2014 exit the shell to return here\n`);
+    if (opts.stdin.isTTY === true && typeof opts.stdin.setRawMode === 'function') {
+        opts.stdin.setRawMode(true);
+        rawOn = true;
+    }
+    return new Promise((resolve) => {
+        let atLineStart = true;
+        let pendingTilde = false;
+        let opened = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            unlisten(opts.stdin, 'data', onStdin);
+            unlisten(opts.signals, 'SIGTERM', onTerm);
+            unlisten(opts.signals, 'SIGHUP', onHang);
+            unlisten(opts.signals, 'SIGWINCH', onResize);
+            unlisten(socket, 'message', onMessage);
+            unlisten(socket, 'close', onClose);
+            unlisten(socket, 'error', onError);
+            unlisten(socket, 'open', onOpen);
+            unlisten(socket, 'unexpected-response', onUpgradeRejected);
+            restoreTty();
+            try {
+                socket.close?.();
+            }
+            catch { /* already closed */ }
+            resolve(code);
+        };
+        const backOn = () => {
+            process.stderr.write(`dialout: back on ${os.hostname()}\n`);
+        };
+        const send = (msg) => {
+            try {
+                socket.send(JSON.stringify(msg));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
+        const lost = () => {
+            if (settled)
+                return;
+            // Only while the socket can still take a frame. A close that already
+            // landed does not get a second detach, and never a remote-shell end.
+            if (socket.readyState === ws_1.default.OPEN) {
+                send({ type: 'pty_detach', id });
+            }
+            process.stderr.write('dialout: connection lost\n');
+            finish(1);
+        };
+        const expired = () => {
+            if (settled)
+                return;
+            process.stderr.write(LOGIN_EXPIRED);
+            finish(1);
+        };
+        const onStdin = (chunk) => {
+            if (settled)
+                return;
+            const result = (0, cli_client_1.consumeEscape)(atLineStart, chunkText(chunk), pendingTilde);
+            atLineStart = result.atLineStart;
+            pendingTilde = result.pendingTilde;
+            if (result.forward.length > 0) {
+                send({ type: 'pty_data', id, data: result.forward });
+            }
+            if (!result.detach)
+                return;
+            send({ type: 'pty_detach', id });
+            backOn();
+            finish(0);
+        };
+        const onResize = () => {
+            if (settled)
+                return;
+            const { cols, rows } = termSize(opts.stdout);
+            send({ type: 'pty_resize', id, cols, rows });
+        };
+        const onTerm = () => lost();
+        const onHang = () => lost();
+        const onMessage = (raw) => {
+            if (settled)
+                return;
+            let msg;
+            try {
+                const parsed = JSON.parse(messageText(raw));
+                if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+                    return;
+                msg = parsed;
+            }
+            catch {
+                return;
+            }
+            if (msg.type === 'pty_data' && msg.id === id && typeof msg.data === 'string') {
+                opts.stdout.write(msg.data);
+                return;
+            }
+            if (msg.type === 'pty_exit' && (msg.id === undefined || msg.id === id)) {
+                const code = typeof msg.code === 'number' ? msg.code : 0;
+                backOn();
+                finish(code);
+                return;
+            }
+            // pty_error and "Machine is offline" never used to settle, so finish
+            // never restored the tty and Ctrl-C was not SIGINT. Do not pty_detach
+            // or pty_close: this frame means the shell was not opened.
+            const fatal = fatalTerminalFrame(msg, id);
+            if (fatal) {
+                process.stderr.write(fatal.sentence);
+                finish(1);
+                return;
+            }
+            if (msg.type === 'error' && msg.error === 'unauthorized') {
+                expired();
+            }
+        };
+        const onClose = (code) => {
+            if (settled)
+                return;
+            if (code === 1008) {
+                expired();
+                return;
+            }
+            lost();
+        };
+        const onError = () => {
+            if (settled)
+                return;
+            lost();
+        };
+        // The server rejects a bad or expired JWT with an HTTP upgrade failure,
+        // before any pty frame. That is a login problem, not a dropped shell.
+        const onUpgradeRejected = (_req, res) => {
+            try {
+                res?.resume?.();
+                res?.destroy?.();
+            }
+            catch { /* response already gone */ }
+            expired();
+        };
+        const onOpen = () => {
+            if (opened || settled)
+                return;
+            opened = true;
+            const { cols, rows } = termSize(opts.stdout);
+            send({
+                type: 'pty_open',
+                id,
+                ensureSession: tmuxName,
+                tmuxSession: tmuxName,
+                cols,
+                rows,
+            });
+        };
+        opts.stdin.on('data', onStdin);
+        opts.signals.on('SIGTERM', onTerm);
+        opts.signals.on('SIGHUP', onHang);
+        opts.signals.on('SIGWINCH', onResize);
+        socket.on('message', onMessage);
+        socket.on('close', onClose);
+        socket.on('error', onError);
+        socket.on('unexpected-response', onUpgradeRejected);
+        opts.stdin.resume?.();
+        if (socket.readyState === ws_1.default.OPEN)
+            onOpen();
+        else
+            socket.on('open', onOpen);
+    }).finally(() => {
+        restoreTty();
+    });
+}
+const CONTROL_FIELDS = ['command', 'cwd', 'timeoutMs', 'lines', 'text', 'keys'];
+function sharedControlMessage(type, requestId, args) {
+    const msg = { type, requestId };
+    const rec = args;
+    for (const key of CONTROL_FIELDS) {
+        if (rec[key] !== undefined)
+            msg[key] = rec[key];
+    }
+    return msg;
+}
+function controlWaitMsFor(type, args) {
+    // Read and keys have no caller timeout, so they use the 120s default.
+    // A non-finite exec timeout does too: the server's timer treats it the same way.
+    const requested = type === 'tmux_exec' ? args.timeoutMs : undefined;
+    const base = typeof requested === 'number' && Number.isFinite(requested) ? requested : DEFAULT_CONTROL_MS;
+    return base + SERVER_SILENCE_PAD_MS + CLIENT_WAIT_PAD_MS;
+}
+function controlResultValue(msg) {
+    const rest = {};
+    for (const [key, value] of Object.entries(msg)) {
+        if (key === 'type' || key === 'requestId' || key === 'ok')
+            continue;
+        rest[key] = value;
+    }
+    if (Object.keys(rest).length === 0)
+        return 'ok';
+    return rest;
+}
+function runTerminalControl(opts) {
+    const requestId = (0, crypto_1.randomBytes)(16).toString('hex');
+    const payload = sharedControlMessage(opts.type, requestId, opts.args);
+    const waitMs = controlWaitMsFor(opts.type, opts.args);
+    const resultType = `${opts.type}_result`;
+    const connect = opts.connect ?? ((url) => new ws_1.default(url));
+    return new Promise((resolve, reject) => {
+        let socket;
+        try {
+            socket = connect(opts.url);
+        }
+        catch (err) {
+            reject(err instanceof Error ? err : new Error('Machine offline'));
+            return;
+        }
+        let settled = false;
+        let timer;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            unlisten(socket, 'message', onMessage);
+            unlisten(socket, 'close', onClose);
+            unlisten(socket, 'error', onError);
+            unlisten(socket, 'open', onOpen);
+            unlisten(socket, 'unexpected-response', onUpgradeRejected);
+            try {
+                socket.close();
+            }
+            catch { /* already closed */ }
+            fn();
+        };
+        const fail = (err) => finish(() => reject(err));
+        const succeed = (value) => finish(() => resolve(value));
+        const onMessage = (raw) => {
+            if (settled)
+                return;
+            let msg;
+            try {
+                const parsed = JSON.parse(messageText(raw));
+                if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+                    return;
+                msg = parsed;
+            }
+            catch {
+                return;
+            }
+            if (msg.type !== resultType || msg.requestId !== requestId)
+                return;
+            // A late "Agent did not answer" is the server's sentence. Do not
+            // replace it with Machine offline — that sentence means the socket died.
+            if (msg.ok === false || typeof msg.error === 'string') {
+                const error = typeof msg.error === 'string' ? msg.error : 'request failed';
+                fail(new Error(error));
+                return;
+            }
+            succeed(controlResultValue(msg));
+        };
+        const onClose = () => fail(new Error('Machine offline'));
+        const onError = () => {
+            // Upgrade failure and a dropped socket both emit error. close and
+            // unexpected-response pick the sentence.
+        };
+        const onUpgradeRejected = (_req, res) => {
+            fail(noSession());
+            try {
+                res?.resume?.();
+                res?.destroy?.();
+            }
+            catch { /* response already gone */ }
+        };
+        const onOpen = () => {
+            if (settled)
+                return;
+            try {
+                socket.send(JSON.stringify(payload));
+            }
+            catch (err) {
+                fail(err instanceof Error ? err : new Error('Machine offline'));
+            }
+        };
+        timer = setTimeout(() => fail(new Error('Machine offline')), waitMs);
+        socket.on('message', onMessage);
+        socket.on('close', onClose);
+        socket.on('error', onError);
+        socket.on('unexpected-response', onUpgradeRejected);
+        if (socket.readyState === ws_1.default.OPEN)
+            onOpen();
+        else
+            socket.on('open', onOpen);
+    });
+}
+function noSession() {
+    const err = new Error('dialout: login expired, run dialout login');
+    err.code = 'NO_SESSION';
+    return err;
+}
+function notDeployed() {
+    const err = new Error('file transfer is not on this server yet');
+    err.code = 'NOT_DEPLOYED';
+    // MCP maps this code to one sentence. A missing file is 400 ENOENT, not this.
+    err.limit = cli_client_1.MAX_COPY_BYTES;
+    return err;
+}
+function requireSession() {
+    const session = (0, cli_client_1.readCliSession)(sessionFile());
+    if (!session)
+        throw noSession();
+    // Same rule as connect: a token belongs to the server URL stored with it.
+    if (session.serverUrl !== (0, config_1.loadConfig)().serverUrl)
+        throw noSession();
+    return session;
+}
+function throwFetchFailure(result) {
+    if (result.kind === 'expired')
+        throw noSession();
+    if (result.kind === 'origin')
+        throw new Error(ORIGIN_TEXT);
+    if (result.kind === 'network')
+        throw new Error(`dialout: ${result.detail ?? 'request failed'}`);
+    const suffix = result.detail ? ` (${result.detail})` : '';
+    throw new Error(`dialout: could not list machines${suffix}`);
+}
+async function listMachines() {
+    const session = requireSession();
+    const listed = await fetchMachines(session);
+    if (!listed.ok)
+        throwFetchFailure(listed);
+    return listed.rows.map((row) => ({ name: row.name, id: row.id, online: row.isOnline }));
+}
+async function runMachineControl(type, args) {
+    const session = requireSession();
+    const listed = await fetchMachines(session);
+    if (!listed.ok)
+        throwFetchFailure(listed);
+    const machine = typeof args.machine === 'string'
+        ? args.machine
+        : '';
+    const matched = (0, cli_client_1.matchMachine)(listed.rows, machine);
+    // Match failures are the tool text. The socket stays closed.
+    if (!matched.ok)
+        throw new Error(machineMatchError(machine, matched));
+    const url = (0, cli_client_1.terminalSocketUrl)(session.serverUrl, matched.machine.id, session.token);
+    if (!url)
+        throw new Error(ORIGIN_TEXT);
+    return runTerminalControl({ url, type, args });
+}
+function defaultCopyHttp(req) {
+    return requestBytes(req.method, req.url, req.headers, req.body, req.timeoutMs);
+}
+// URLSearchParams encodes a space as '+'. The path has to keep a real space
+// as %20, and a leading '~' has to stay so the agent can expand it.
+function fileApiUrl(origin, kind, machineId, filePath, overwrite) {
+    const pathname = kind === 'stat' ? '/api/files/stat' : '/api/files';
+    let url = `${origin}${pathname}?machineId=${encodeURIComponent(String(machineId))}&path=${encodeURIComponent(filePath)}`;
+    if (overwrite !== undefined)
+        url += `&overwrite=${overwrite}`;
+    return url;
+}
+function lastSegment(filePath) {
+    const trimmed = filePath.endsWith('/') ? filePath.slice(0, -1) : filePath;
+    const slash = trimmed.lastIndexOf('/');
+    return slash === -1 ? trimmed : trimmed.slice(slash + 1);
+}
+function isLatin1(value) {
+    for (let i = 0; i < value.length; i++) {
+        if (value.charCodeAt(i) > 255)
+            return false;
+    }
+    return true;
+}
+function errorString(body, status) {
+    const json = parseJsonBody(body);
+    if (typeof json === 'object' && json !== null && !Array.isArray(json)) {
+        const error = json.error;
+        if (typeof error === 'string')
+            return error;
+    }
+    return `dialout: request failed (${status})`;
+}
+function offlineLine(name) {
+    return machineMatchError(name, {
+        ok: false,
+        reason: 'offline',
+        matches: [{ id: 0, name, isOnline: false }],
+    });
+}
+// 404 is an old server with no file route. Every other failure keeps the
+// server's sentence, except the two the CLI names itself.
+function statusError(status, body, machineName) {
+    if (status >= 200 && status < 300)
+        return null;
+    if (status === 404)
+        return notDeployed();
+    if (status === 503)
+        return new Error(offlineLine(machineName));
+    if (status === 413)
+        return new Error(FILE_TOO_BIG);
+    return new Error(errorString(body, status));
+}
+function readUpload(filePath) {
+    let st;
+    try {
+        st = (0, fs_1.statSync)(filePath);
+    }
+    catch (err) {
+        throw new Error(err instanceof Error ? err.message : 'request failed');
+    }
+    if (!st.isFile())
+        throw new Error('not a file');
+    if (st.size > cli_client_1.MAX_COPY_BYTES)
+        throw new Error(FILE_TOO_BIG);
+    const bytes = (0, fs_1.readFileSync)(filePath);
+    if (bytes.length > cli_client_1.MAX_COPY_BYTES)
+        throw new Error(FILE_TOO_BIG);
+    return bytes;
+}
+function readStat(body) {
+    const json = parseJsonBody(body);
+    if (typeof json !== 'object' || json === null || Array.isArray(json))
+        return null;
+    const type = json.type;
+    if (typeof type !== 'string')
+        return null;
+    return { type };
+}
+async function statRemote(http, origin, machineId, machineName, filePath, headers) {
+    const res = await http({
+        method: 'GET',
+        url: fileApiUrl(origin, 'stat', machineId, filePath),
+        headers,
+        timeoutMs: JSON_TIMEOUT_MS,
+    });
+    if (res.status === 400) {
+        const error = errorString(res.body, 400);
+        if (error.startsWith('ENOENT'))
+            return { kind: 'missing', error };
+        return { kind: 'fail', error: new Error(error) };
+    }
+    const failed = statusError(res.status, res.body, machineName);
+    if (failed)
+        return { kind: 'fail', error: failed };
+    const stat = readStat(res.body);
+    if (!stat)
+        return { kind: 'fail', error: new Error('dialout: unexpected stat response') };
+    return { kind: 'stat', stat };
+}
+function promptLine(stdin, stdout, label) {
+    stdout.write(label);
+    return new Promise((resolve) => {
+        let buf = '';
+        let done = false;
+        const finish = (line) => {
+            if (done)
+                return;
+            done = true;
+            unlisten(stdin, 'data', onData);
+            stdin.pause?.();
+            resolve(line);
+        };
+        const onData = (chunk) => {
+            const text = chunkText(chunk);
+            for (let i = 0; i < text.length; i++) {
+                const ch = text[i] ?? '';
+                if (ch === '\n' || ch === '\r') {
+                    if (ch === '\r' && text[i + 1] === '\n')
+                        i += 1;
+                    finish(buf);
+                    return;
+                }
+                buf += ch;
+            }
+        };
+        stdin.on('data', onData);
+        stdin.resume?.();
+    });
+}
+// MCP passes prompt false. Its stdin is the JSON-RPC session, so a y/N
+// question there would consume the next client frame.
+async function confirmOverwrite(prompt, io, destPath) {
+    if (!prompt)
+        throw new Error(EXISTS_CONFLICT);
+    if (io.stdin.isTTY !== true)
+        throw new Error(EXISTS_CONFLICT);
+    const answer = (await promptLine(io.stdin, io.stdout, `overwrite ${destPath}? [y/N] `)).trim();
+    if (answer !== 'y' && answer !== 'Y')
+        throw new Error(EXISTS_CONFLICT);
+}
+function isExactExists(status, body) {
+    return status === 400 && errorString(body, 400) === EXISTS_CONFLICT;
+}
+async function transferCopy(opts) {
+    const parsed = (0, cli_client_1.parseCopyPair)(opts.source, opts.dest);
+    if (!parsed.ok)
+        throw new Error(parsed.error);
+    const homedir = opts.hooks?.homedir ?? os.homedir();
+    const localExpanded = (0, cli_client_1.expandLocalHome)(parsed.local, homedir);
+    // Size and "not a file" are local. Do not ask the network about them.
+    const uploadBytes = parsed.upload ? readUpload(localExpanded) : undefined;
+    const session = opts.hooks?.session ?? requireSession();
+    const http = opts.hooks?.http ?? defaultCopyHttp;
+    const listed = await fetchMachines(session, opts.hooks?.http);
+    if (!listed.ok)
+        throwFetchFailure(listed);
+    const matched = (0, cli_client_1.matchMachine)(listed.rows, parsed.machine);
+    if (!matched.ok)
+        throw new Error(machineMatchError(parsed.machine, matched));
+    const origin = (0, cli_client_1.apiOriginFromServerUrl)(session.serverUrl);
+    if (!origin)
+        throw new Error(ORIGIN_TEXT);
+    const headers = { Authorization: `Bearer ${session.token}` };
+    const machineName = matched.machine.name;
+    const machineId = matched.machine.id;
+    const io = opts.hooks?.io ?? {
+        stdin: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr,
+    };
+    const looked = await statRemote(http, origin, machineId, machineName, parsed.remote, headers);
+    if (parsed.upload) {
+        if (looked.kind === 'fail')
+            throw looked.error;
+        if (looked.kind === 'missing' && parsed.remote.endsWith('/'))
+            throw new Error(looked.error);
+        const remoteIsDir = looked.kind === 'stat' && looked.stat.type === 'directory';
+        const remoteDest = remoteIsDir || parsed.remote.endsWith('/')
+            ? (0, cli_client_1.resolveRemoteDest)(parsed.remote, true, lastSegment(localExpanded))
+            : parsed.remote;
+        const base = lastSegment(localExpanded);
+        const putHeaders = {
+            ...headers,
+            'Content-Type': 'application/octet-stream',
+        };
+        if (base.length > 0 && isLatin1(base))
+            putHeaders['X-File-Name'] = base;
+        const send = (overwrite) => http({
+            method: 'PUT',
+            url: fileApiUrl(origin, 'bytes', machineId, remoteDest, overwrite ? '1' : '0'),
+            headers: putHeaders,
+            body: uploadBytes,
+            timeoutMs: FILE_BYTE_TIMEOUT_MS,
+        });
+        let res = await send(opts.force);
+        if (isExactExists(res.status, res.body) && !opts.force) {
+            await confirmOverwrite(opts.prompt, io, remoteDest);
+            res = await send(true);
+        }
+        const failed = statusError(res.status, res.body, machineName);
+        if (failed)
+            throw failed;
+        return `${uploadBytes.length} bytes → ${parsed.machine}:${remoteDest}`;
+    }
+    if (looked.kind === 'fail')
+        throw looked.error;
+    if (looked.kind === 'missing')
+        throw new Error(looked.error);
+    if (looked.stat.type === 'directory' || parsed.remote.endsWith('/'))
+        throw new Error('not a file');
+    const res = await http({
+        method: 'GET',
+        url: fileApiUrl(origin, 'bytes', machineId, parsed.remote),
+        headers,
+        timeoutMs: FILE_BYTE_TIMEOUT_MS,
+    });
+    const failed = statusError(res.status, res.body, machineName);
+    if (failed)
+        throw failed;
+    const localIsDir = parsed.local.endsWith('/') || localPathIsDir(localExpanded);
+    const localDest = (0, cli_client_1.resolveLocalDest)(localExpanded, localIsDir, lastSegment(parsed.remote));
+    // Stat before opening. A refused overwrite must not truncate the file.
+    if (localFileExists(localDest)) {
+        if (!opts.force)
+            await confirmOverwrite(opts.prompt, io, localDest);
+    }
+    try {
+        (0, fs_1.writeFileSync)(localDest, res.body);
+    }
+    catch (err) {
+        throw new Error(err instanceof Error ? err.message : 'request failed');
+    }
+    return `${res.body.length} bytes → ${localDest}`;
+}
+function localPathIsDir(filePath) {
+    try {
+        return (0, fs_1.statSync)(filePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function localFileExists(filePath) {
+    try {
+        const st = (0, fs_1.statSync)(filePath);
+        if (st.isDirectory())
+            throw new Error('not a file');
+        return st.isFile();
+    }
+    catch (err) {
+        if (err instanceof Error && err.message === 'not a file')
+            throw err;
+        const code = err.code;
+        if (code === 'ENOENT')
+            return false;
+        throw new Error(err instanceof Error ? err.message : 'request failed');
+    }
+}
+async function copyCommand(source, dest, force) {
+    try {
+        const line = await transferCopy({ source, dest, force, prompt: true });
+        process.stdout.write(`${line}\n`);
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'request failed';
+        process.stderr.write(message.endsWith('\n') ? message : `${message}\n`);
+        return 1;
+    }
+}
+async function copyFile(args, hooks) {
+    const source = typeof args.source === 'string' ? args.source : '';
+    const dest = typeof args.dest === 'string' ? args.dest : '';
+    return transferCopy({ source, dest, force: false, prompt: false, hooks });
+}
+async function serveMcp() {
+    const session = (0, cli_client_1.readCliSession)(sessionFile());
+    if (!session) {
+        process.stderr.write(LOGIN_EXPIRED);
+        process.exit(1);
+    }
+    if (session.serverUrl !== (0, config_1.loadConfig)().serverUrl) {
+        process.stderr.write(LOGIN_EXPIRED);
+        process.exit(1);
+    }
+    const deps = {
+        listMachines,
+        exec: (args) => runMachineControl('tmux_exec', args),
+        readScreen: (args) => runMachineControl('tmux_read', args),
+        writeKeys: (args) => runMachineControl('tmux_keys', args),
+        copyFile: (args) => copyFile(args),
+    };
+    await (0, mcp_stdio_1.runMcpStdio)(deps);
+}
+//# sourceMappingURL=cli-terminal.js.map