whale-code 6.4.0 → 6.5.0

package/dist/node/portal/shell.js

@@ -0,0 +1,142 @@
+/**
+ * ShellChannel — PTY spawn on target, stdin/stdout bridge on initiator.
+ *
+ * Initiator side: pipes process.stdin → stream, stream → process.stdout
+ * Target side: spawns node-pty, pipes PTY ↔ stream
+ */
+// ============================================================================
+// INITIATOR SIDE
+// ============================================================================
+/**
+ * Open a remote shell from the initiator. Pipes local terminal to remote PTY.
+ */
+export async function openShell(session, opts = {}) {
+    const cols = opts.cols || process.stdout.columns || 80;
+    const rows = opts.rows || process.stdout.rows || 24;
+    const stream = session.openStream({
+        channel: "shell",
+        term: process.env.TERM || "xterm-256color",
+        cols,
+        rows,
+        cwd: opts.cwd,
+        command: opts.command,
+    });
+    // Wait for ACK
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Shell open timed out")), 10_000);
+        session.once("stream:ack", (s) => {
+            if (s.streamId === stream.streamId) {
+                clearTimeout(timeout);
+                resolve();
+            }
+        });
+    });
+    // Pipe stdin → stream → stdout
+    const wasRaw = process.stdin.isRaw;
+    if (process.stdin.isTTY && !opts.command) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    const onStdinData = (data) => {
+        if (!stream.destroyed) {
+            stream.write(data);
+        }
+    };
+    process.stdin.on("data", onStdinData);
+    stream.on("data", (data) => {
+        process.stdout.write(data);
+    });
+    // Handle terminal resize
+    const onResize = () => {
+        const newCols = process.stdout.columns || 80;
+        const newRows = process.stdout.rows || 24;
+        // Send resize as a control message on stream 0 (JSON)
+        const msg = { type: "resize", cols: newCols, rows: newRows };
+        // Encode as a DATA frame on the shell stream with a special prefix
+        const resizeFrame = Buffer.from(`\x00RESIZE${JSON.stringify(msg)}`);
+        if (!stream.destroyed) {
+            stream.write(resizeFrame);
+        }
+    };
+    process.stdout.on("resize", onResize);
+    const cleanup = () => {
+        process.stdin.removeListener("data", onStdinData);
+        process.stdout.removeListener("resize", onResize);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(wasRaw ?? false);
+        }
+        process.stdin.pause();
+        if (!stream.destroyed) {
+            stream.end();
+        }
+    };
+    // Auto-cleanup when stream closes
+    stream.on("end", cleanup);
+    stream.on("error", cleanup);
+    // For single command mode, collect output and close
+    if (opts.command) {
+        return new Promise((resolve) => {
+            stream.on("end", () => {
+                resolve({ stream, cleanup });
+            });
+        });
+    }
+    return { stream, cleanup };
+}
+// ============================================================================
+// TARGET SIDE (handler)
+// ============================================================================
+const RESIZE_PREFIX = Buffer.from("\x00RESIZE");
+/**
+ * Handle an incoming shell stream on the target node.
+ * Spawns a PTY and bridges it to the stream.
+ */
+export async function handleShell(stream, meta) {
+    // Dynamic import of node-pty (only needed on target)
+    const pty = await import("node-pty");
+    const os = await import("node:os");
+    const shell = process.env.SHELL || (process.platform === "win32" ? "powershell.exe" : "/bin/bash");
+    const cwd = meta.cwd || os.homedir();
+    const ptyProcess = pty.spawn(shell, meta.command ? ["-c", meta.command] : [], {
+        name: meta.term || "xterm-256color",
+        cols: meta.cols || 80,
+        rows: meta.rows || 24,
+        cwd,
+        env: { ...process.env, TERM: meta.term || "xterm-256color" },
+    });
+    // PTY → stream
+    ptyProcess.onData((data) => {
+        if (!stream.destroyed) {
+            stream.write(Buffer.from(data));
+        }
+    });
+    // Stream → PTY (with resize detection)
+    stream.on("data", (data) => {
+        // Check for resize control message
+        if (data.length > RESIZE_PREFIX.length && data.subarray(0, RESIZE_PREFIX.length).equals(RESIZE_PREFIX)) {
+            try {
+                const msg = JSON.parse(data.subarray(RESIZE_PREFIX.length).toString());
+                ptyProcess.resize(msg.cols, msg.rows);
+            }
+            catch {
+                // Not a resize message, forward as data
+                ptyProcess.write(data.toString());
+            }
+            return;
+        }
+        ptyProcess.write(data.toString());
+    });
+    // PTY exit → close stream
+    ptyProcess.onExit(() => {
+        if (!stream.destroyed) {
+            stream.end();
+        }
+    });
+    // Stream close → kill PTY
+    stream.on("end", () => {
+        ptyProcess.kill();
+    });
+    stream.on("error", () => {
+        ptyProcess.kill();
+    });
+}

package/dist/node/portal/stream.d.ts

@@ -0,0 +1,43 @@
+/**
+ * PortalStream — Node.js Duplex stream wrapping a multiplexed stream ID.
+ *
+ * Each channel (shell, file, forward, etc.) gets a PortalStream that behaves
+ * like a normal Node.js Duplex. Writing to it sends DATA frames; reading
+ * receives DATA frames routed by the multiplexer.
+ */
+import { Duplex, type DuplexOptions } from "node:stream";
+import type { SynPayload } from "./protocol.js";
+export interface PortalStreamOptions extends DuplexOptions {
+    streamId: number;
+    channelMeta?: SynPayload;
+    sendFrame: (streamId: number, data: Buffer) => void;
+    sendFin: (streamId: number) => void;
+    sendRst: (streamId: number, reason?: string) => void;
+}
+export declare class PortalStream extends Duplex {
+    readonly streamId: number;
+    readonly channelMeta: SynPayload | undefined;
+    private _sendFrame;
+    private _sendFin;
+    private _sendRst;
+    private _remoteFinished;
+    private _localFinished;
+    constructor(opts: PortalStreamOptions);
+    /**
+     * Called by multiplexer when a DATA frame arrives for this stream.
+     */
+    pushData(data: Buffer): void;
+    /**
+     * Called by multiplexer when a FIN frame arrives for this stream.
+     */
+    pushFin(): void;
+    /**
+     * Called by multiplexer when a RST frame arrives for this stream.
+     */
+    pushRst(reason?: string): void;
+    get isFullyClosed(): boolean;
+    _read(_size: number): void;
+    _write(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+}

package/dist/node/portal/stream.js

@@ -0,0 +1,90 @@
+/**
+ * PortalStream — Node.js Duplex stream wrapping a multiplexed stream ID.
+ *
+ * Each channel (shell, file, forward, etc.) gets a PortalStream that behaves
+ * like a normal Node.js Duplex. Writing to it sends DATA frames; reading
+ * receives DATA frames routed by the multiplexer.
+ */
+import { Duplex } from "node:stream";
+export class PortalStream extends Duplex {
+    streamId;
+    channelMeta;
+    _sendFrame;
+    _sendFin;
+    _sendRst;
+    _remoteFinished = false;
+    _localFinished = false;
+    constructor(opts) {
+        super({ ...opts, allowHalfOpen: true });
+        this.streamId = opts.streamId;
+        this.channelMeta = opts.channelMeta;
+        this._sendFrame = opts.sendFrame;
+        this._sendFin = opts.sendFin;
+        this._sendRst = opts.sendRst;
+    }
+    /**
+     * Called by multiplexer when a DATA frame arrives for this stream.
+     */
+    pushData(data) {
+        if (!this._remoteFinished) {
+            this.push(data);
+        }
+    }
+    /**
+     * Called by multiplexer when a FIN frame arrives for this stream.
+     */
+    pushFin() {
+        this._remoteFinished = true;
+        this.push(null); // signal end of readable side
+    }
+    /**
+     * Called by multiplexer when a RST frame arrives for this stream.
+     */
+    pushRst(reason) {
+        this._remoteFinished = true;
+        this._localFinished = true;
+        this.destroy(new Error(reason || "Stream reset by remote"));
+    }
+    get isFullyClosed() {
+        return this._remoteFinished && this._localFinished;
+    }
+    // ---- Duplex implementation ----
+    _read(_size) {
+        // Data is pushed via pushData() — no pull-based reading needed
+    }
+    _write(chunk, _encoding, callback) {
+        if (this._localFinished) {
+            callback(new Error("Stream already closed"));
+            return;
+        }
+        try {
+            this._sendFrame(this.streamId, chunk);
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    _final(callback) {
+        this._localFinished = true;
+        try {
+            this._sendFin(this.streamId);
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    _destroy(error, callback) {
+        if (!this._localFinished) {
+            this._localFinished = true;
+            try {
+                this._sendRst(this.streamId, error?.message);
+            }
+            catch {
+                // best effort
+            }
+        }
+        callback(error);
+    }
+}

package/dist/node/portal/transfer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * FileChannel — chunked file push/pull with progress tracking.
+ *
+ * Push: fs.createReadStream → chunk into 64KB DATA frames → stream
+ * Pull: request via SYN → receive DATA frames → fs.createWriteStream
+ * Directory: tar pipe (using system tar CLI)
+ */
+import type { PortalStream } from "./stream.js";
+import type { SynFilePush, SynFilePull } from "./protocol.js";
+import type { PortalSession } from "./session.js";
+export interface TransferProgress {
+    name: string;
+    bytesTransferred: number;
+    totalBytes: number;
+    percent: number;
+}
+export type ProgressCallback = (progress: TransferProgress) => void;
+/**
+ * Push a local file or directory to a remote node.
+ */
+export declare function pushFile(session: PortalSession, localPath: string, remotePath?: string, onProgress?: ProgressCallback): Promise<void>;
+/**
+ * Pull a file from a remote node.
+ */
+export declare function pullFile(session: PortalSession, remotePath: string, localDir?: string, onProgress?: ProgressCallback): Promise<string>;
+/**
+ * Handle an incoming file push on the target node.
+ */
+export declare function handleFilePush(stream: PortalStream, meta: SynFilePush, receiveDir?: string): Promise<string>;
+/**
+ * Handle an incoming file pull request on the target node.
+ */
+export declare function handleFilePull(stream: PortalStream, meta: SynFilePull): Promise<void>;

package/dist/node/portal/transfer.js

@@ -0,0 +1,231 @@
+/**
+ * FileChannel — chunked file push/pull with progress tracking.
+ *
+ * Push: fs.createReadStream → chunk into 64KB DATA frames → stream
+ * Pull: request via SYN → receive DATA frames → fs.createWriteStream
+ * Directory: tar pipe (using system tar CLI)
+ */
+import { createReadStream, createWriteStream, statSync, mkdirSync, existsSync } from "node:fs";
+import { basename, join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import { pipeline } from "node:stream/promises";
+const DEFAULT_RECEIVE_DIR = join(homedir(), "Portal");
+const CHUNK_SIZE = 64 * 1024;
+// ============================================================================
+// PUSH (initiator sends file to target)
+// ============================================================================
+/**
+ * Push a local file or directory to a remote node.
+ */
+export async function pushFile(session, localPath, remotePath, onProgress) {
+    const stat = statSync(localPath);
+    const name = basename(localPath);
+    if (stat.isDirectory()) {
+        return pushDirectory(session, localPath, onProgress);
+    }
+    const stream = session.openStream({
+        channel: "file",
+        direction: "push",
+        name: remotePath ? basename(remotePath) : name,
+        size: stat.size,
+        mode: stat.mode,
+        mtime: Math.floor(stat.mtimeMs / 1000),
+    });
+    // Wait for ACK
+    await waitForAck(session, stream);
+    // Stream file data
+    const fileStream = createReadStream(localPath, { highWaterMark: CHUNK_SIZE });
+    let transferred = 0;
+    fileStream.on("data", (chunk) => {
+        const len = typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
+        transferred += len;
+        onProgress?.({
+            name,
+            bytesTransferred: transferred,
+            totalBytes: stat.size,
+            percent: stat.size > 0 ? Math.round((transferred / stat.size) * 100) : 100,
+        });
+    });
+    await pipeline(fileStream, stream);
+}
+/**
+ * Push a directory by streaming tar.
+ */
+async function pushDirectory(session, localPath, onProgress) {
+    const name = basename(localPath) + "/";
+    const stream = session.openStream({
+        channel: "file",
+        direction: "push",
+        name,
+        size: 0,
+        mode: 0o755,
+        mtime: Math.floor(Date.now() / 1000),
+        isDirectory: true,
+    });
+    await waitForAck(session, stream);
+    // Use system tar to stream directory
+    const tar = spawn("tar", ["-cf", "-", "-C", dirname(localPath), basename(localPath)], {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let transferred = 0;
+    tar.stdout.on("data", (chunk) => {
+        transferred += chunk.length;
+        onProgress?.({
+            name,
+            bytesTransferred: transferred,
+            totalBytes: 0,
+            percent: 0,
+        });
+    });
+    await pipeline(tar.stdout, stream);
+    await new Promise((resolve, reject) => {
+        tar.on("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`tar exited with code ${code}`));
+        });
+    });
+}
+// ============================================================================
+// PULL (initiator requests file from target)
+// ============================================================================
+/**
+ * Pull a file from a remote node.
+ */
+export async function pullFile(session, remotePath, localDir, onProgress) {
+    const stream = session.openStream({
+        channel: "file",
+        direction: "pull",
+        path: remotePath,
+    });
+    await waitForAck(session, stream);
+    // First data frame contains file metadata as JSON
+    const metaBuf = await readFirstChunk(stream);
+    const meta = JSON.parse(metaBuf.toString());
+    const destDir = localDir || process.cwd();
+    const destPath = join(destDir, meta.name);
+    if (meta.isDirectory) {
+        // Receive tar stream
+        mkdirSync(destDir, { recursive: true });
+        const tar = spawn("tar", ["-xf", "-", "-C", destDir], {
+            stdio: ["pipe", "ignore", "pipe"],
+        });
+        await pipeline(stream, tar.stdin);
+        await new Promise((resolve, reject) => {
+            tar.on("exit", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`tar extract failed with code ${code}`));
+            });
+        });
+        return destPath;
+    }
+    // Receive file data
+    mkdirSync(dirname(destPath), { recursive: true });
+    const ws = createWriteStream(destPath, { mode: meta.size > 0 ? undefined : 0o644 });
+    let transferred = 0;
+    stream.on("data", (chunk) => {
+        transferred += chunk.length;
+        onProgress?.({
+            name: meta.name,
+            bytesTransferred: transferred,
+            totalBytes: meta.size,
+            percent: meta.size > 0 ? Math.round((transferred / meta.size) * 100) : 0,
+        });
+    });
+    await pipeline(stream, ws);
+    return destPath;
+}
+// ============================================================================
+// TARGET SIDE (handlers)
+// ============================================================================
+/**
+ * Handle an incoming file push on the target node.
+ */
+export async function handleFilePush(stream, meta, receiveDir) {
+    const destDir = receiveDir || DEFAULT_RECEIVE_DIR;
+    mkdirSync(destDir, { recursive: true });
+    if (meta.isDirectory) {
+        const tar = spawn("tar", ["-xf", "-", "-C", destDir], {
+            stdio: ["pipe", "ignore", "pipe"],
+        });
+        await pipeline(stream, tar.stdin);
+        await new Promise((resolve, reject) => {
+            tar.on("exit", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`tar extract failed with code ${code}`));
+            });
+        });
+        return join(destDir, meta.name.replace(/\/$/, ""));
+    }
+    const destPath = join(destDir, meta.name);
+    mkdirSync(dirname(destPath), { recursive: true });
+    const ws = createWriteStream(destPath, { mode: meta.mode });
+    await pipeline(stream, ws);
+    return destPath;
+}
+/**
+ * Handle an incoming file pull request on the target node.
+ */
+export async function handleFilePull(stream, meta) {
+    const path = meta.path;
+    if (!existsSync(path)) {
+        stream.destroy(new Error(`File not found: ${path}`));
+        return;
+    }
+    const stat = statSync(path);
+    const name = basename(path);
+    // Send metadata as first chunk
+    const metaJson = JSON.stringify({
+        name,
+        size: stat.size,
+        isDirectory: stat.isDirectory(),
+        mode: stat.mode,
+        mtime: Math.floor(stat.mtimeMs / 1000),
+    });
+    stream.write(Buffer.from(metaJson));
+    if (stat.isDirectory()) {
+        // Stream tar
+        const tar = spawn("tar", ["-cf", "-", "-C", dirname(path), name], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        await pipeline(tar.stdout, stream);
+    }
+    else {
+        // Stream file
+        const rs = createReadStream(path, { highWaterMark: CHUNK_SIZE });
+        await pipeline(rs, stream);
+    }
+}
+// ============================================================================
+// HELPERS
+// ============================================================================
+function waitForAck(session, stream) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Stream ACK timed out")), 10_000);
+        session.once("stream:ack", (s) => {
+            if (s.streamId === stream.streamId) {
+                clearTimeout(timeout);
+                resolve();
+            }
+        });
+    });
+}
+function readFirstChunk(stream) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Timeout waiting for metadata")), 10_000);
+        stream.once("data", (chunk) => {
+            clearTimeout(timeout);
+            resolve(chunk);
+        });
+        stream.once("error", (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}

package/dist/node/portal/ui.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Portal UI — terminal progress bars, status display, and interactive menu.
+ */
+import type { DiscoveredNode } from "./discovery.js";
+import type { TransferProgress } from "./transfer.js";
+import type { ForwardInfo } from "./forward.js";
+import type { PortalSession } from "./session.js";
+export declare function printNodeList(nodes: DiscoveredNode[], showOffline?: boolean): void;
+export declare function printProgress(progress: TransferProgress): void;
+export declare function printSessionStatus(sessions: Array<ReturnType<PortalSession["getInfo"]>>): void;
+export declare function printForwardStatus(forwards: ForwardInfo[]): void;
+export declare function showPortalMenu(nodeName: string): Promise<string>;
+export declare function printConnecting(nodeName: string): void;
+export declare function printConnected(hostname: string): void;
+export declare function printDisconnected(reason?: string): void;
+export declare function printError(msg: string): void;