ai-remote 0.5.0 → 0.5.1

package/dist/{cli-identities-ZILT4XCR.mjs → cli-identities-GBQWYF2O.mjs}

@@ -53,7 +53,7 @@ async function parsePrivateKey(text, comment = "") {
 async function parseOpenSshKey(body, comment) {
   const magic = new TextDecoder().decode(body.subarray(0, OPENSSH_MAGIC.length));
   if (magic !== OPENSSH_MAGIC) throw new Error("this is not an OpenSSH private key");
-  const reader = new SshReader(body, OPENSSH_MAGIC.length);
+  const reader = new SshReader(body.slice(), OPENSSH_MAGIC.length);
   const cipher = reader.string();
   reader.string();
   reader.stringBytes();
@@ -171,7 +171,7 @@ async function ecdsaIdentity(keyBlob, curve, point, d, comment) {
   const x = point.subarray(1, 1 + spec.size);
   const y = point.subarray(1 + spec.size, 1 + spec.size * 2);
   const key = await importJwk(
-    { kty: "EC", crv: spec.jwk, x: b64u(x), y: b64u(y), d: b64u(padStart(d, spec.size)) },
+    { kty: "EC", crv: spec.jwk, x: b64u(x), y: b64u(y), d: b64u(padStart(d.slice(), spec.size)) },
     { name: "ECDSA", namedCurve: spec.jwk }
   );
   const algorithm = `ecdsa-sha2-${curve}`;
@@ -231,8 +231,8 @@ async function fromPkcs8(der, comment) {
       const [name, spec] = curve;
       const point = concatBytes(
         new Uint8Array([4]),
-        padStart(from(jwk.x), spec.size),
-        padStart(from(jwk.y), spec.size)
+        padStart(from(jwk.x).slice(), spec.size),
+        padStart(from(jwk.y).slice(), spec.size)
       );
       return ecdsaIdentity(new Uint8Array(0), name, point, from(jwk.d), comment);
     }

package/dist/{cli-shell-45XRTE7O.mjs → cli-shell-22PZYNSJ.mjs}

@@ -1,8 +1,8 @@
 import {
   Shell,
   bareUsername
-} from "./cli-chunk-Q33YGIDO.mjs";
-import "./cli-chunk-S2TWL5LF.mjs";
+} from "./cli-chunk-M5GGPPAC.mjs";
+import "./cli-chunk-X2JMVOWL.mjs";
 import "./cli-chunk-XT2FISR5.mjs";
 export {
   Shell,

package/dist/{cli-window-ZKAXEHQV.mjs → cli-window-WLRFUKSW.mjs}

@@ -4,8 +4,8 @@ import {
   openWindow,
   readCurrentDisplaySize,
   runWindow
-} from "./cli-chunk-F2TSY3YW.mjs";
-import "./cli-chunk-OZG2CODR.mjs";
+} from "./cli-chunk-DGYNADUR.mjs";
+import "./cli-chunk-WBOYG4KJ.mjs";
 export {
   detectCurrentDisplaySize,
   nativeWindowAvailable,

package/dist/cli.mjs

@@ -13,12 +13,21 @@ import {
   metaPath,
   sessionName,
   socketPath
-} from "./cli-chunk-OZG2CODR.mjs";
+} from "./cli-chunk-WBOYG4KJ.mjs";
 
 // src/cli/cli.ts
 import { resolve as resolvePath } from "node:path";
 import { readFileSync as readFileSync2, openSync } from "node:fs";
 
+// src/cli/target.ts
+function splitTarget(target, fallbackPort) {
+  const stripped = target.replace(/^\w+:\/\//, "");
+  const at = stripped.lastIndexOf("@");
+  const account = at === -1 ? "" : stripped.slice(0, at);
+  const [host, port] = (at === -1 ? stripped : stripped.slice(at + 1)).split(":");
+  return { account, host, port: port ? Number(port) : fallbackPort };
+}
+
 // src/cli/prompt.ts
 function canPrompt() {
   return Boolean(process.stdin.isTTY) && !process.env.AI_REMOTE_NO_PROMPT;
@@ -312,11 +321,6 @@ var flag = (args, ...names) => {
   return void 0;
 };
 var has = (args, ...names) => names.some((name) => args.flags[name] === true);
-function splitTarget(target, fallbackPort) {
-  const stripped = target.replace(/^\w+:\/\//, "");
-  const [host, port] = stripped.split(":");
-  return { host, port: port ? Number(port) : fallbackPort };
-}
 var PORTS = { rdp: 3389, vnc: 5900, ssh: 22 };
 function modeFor(args, target) {
   if (has(args, "ssh", "ssh-only", "terminal")) return "ssh";
@@ -361,7 +365,7 @@ async function promptFor(host, port, username, note = "") {
 }
 function identityLoader(paths) {
   return async () => {
-    const { loadIdentities } = await import("./cli-identities-ZILT4XCR.mjs");
+    const { loadIdentities } = await import("./cli-identities-GBQWYF2O.mjs");
     const { identities, skipped } = await loadIdentities(paths);
     for (const note of skipped) console.log(`[ssh] skipped ${note}`);
     console.log(identities.length ? `[ssh] keys: ${identities.map((identity) => identity.comment).join(", ")}` : "[ssh] no keys to offer");
@@ -430,13 +434,13 @@ async function tell(session, op, args = {}, timeoutMs) {
   }
   return result;
 }
-async function startSession(args, name, host, port, secret) {
+async function startSession(args, name, host, port, secret, account = "") {
   const mode = modeFor(args, `${host}:${port}`);
   const explicitWidth = flag(args, "W", "width");
   const explicitHeight = flag(args, "H", "height");
   let fullscreenSize = null;
   if (mode === "rdp" && has(args, "fullscreen") && (!explicitWidth || !explicitHeight)) {
-    const { detectCurrentDisplaySize } = await import("./cli-window-ZKAXEHQV.mjs");
+    const { detectCurrentDisplaySize } = await import("./cli-window-WLRFUKSW.mjs");
     const display = await detectCurrentDisplaySize();
     if (display) fullscreenSize = fullscreenRdpSize(display, has(args, "side-panel"));
   }
@@ -453,7 +457,7 @@ async function startSession(args, name, host, port, secret) {
     "--name",
     name,
     "-u",
-    flag(args, "u", "user") ?? "",
+    flag(args, "u", "user") ?? account,
     "-d",
     flag(args, "d", "domain") ?? "",
     "-s",
@@ -463,7 +467,7 @@ async function startSession(args, name, host, port, secret) {
     "-H",
     height,
     "--ssh-user",
-    flag(args, "ssh-user") ?? flag(args, "u", "user") ?? "",
+    flag(args, "ssh-user") ?? flag(args, "u", "user") ?? account,
     // In a terminal session the target port is the SSH port; there is no other.
     "--ssh-port",
     flag(args, "ssh-port") ?? (mode === "ssh" ? String(port) : "22"),
@@ -559,7 +563,7 @@ async function main() {
   }
   const json = has(args, "json");
   if (args.command === "__display-size") {
-    const { readCurrentDisplaySize } = await import("./cli-window-ZKAXEHQV.mjs");
+    const { readCurrentDisplaySize } = await import("./cli-window-WLRFUKSW.mjs");
     const size = await readCurrentDisplaySize();
     if (size) process.stdout.write(`${JSON.stringify(size)}
 `);
@@ -568,7 +572,7 @@ async function main() {
   if (args.command === "__session") {
     const mode = modeFor(args, args.rest[0]);
     const { host, port } = splitTarget(args.rest[0] ?? "", defaultPort(mode));
-    const { runDaemon } = await import("./cli-daemon-3BBFQCML.mjs");
+    const { runDaemon } = await import("./cli-daemon-M3KM2YHW.mjs");
     await runDaemon({
       name: sessionName(host, port, flag(args, "name", "session")),
       host,
@@ -601,7 +605,7 @@ async function main() {
     return;
   }
   if (args.command === "__window") {
-    const { runWindow } = await import("./cli-window-ZKAXEHQV.mjs");
+    const { runWindow } = await import("./cli-window-WLRFUKSW.mjs");
     await runWindow(process.argv.slice(3));
     return;
   }
@@ -653,11 +657,11 @@ Saved, nothing open (\`${NAME} open <host>\` needs no password):
       throw new CliError(`--keys takes "adapt" or "literal", not "${keys}".`, 12);
     }
     const mode = modeFor(args, target);
-    const { host, port } = splitTarget(target, defaultPort(mode));
+    const { account: targetAccount, host, port } = splitTarget(target, defaultPort(mode));
     const asked = flag(args, "session", "name");
     const base = sessionName(host, port, asked);
     const name2 = has(args, "no-reuse") && !asked ? freeName(base, liveSessions().map((meta) => meta.name)) : base;
-    const account = flag(args, "u", "user") ?? "";
+    const account = flag(args, "u", "user") ?? targetAccount;
     const prompts = prompting(args);
     let secret = await passwordFor(host, port, account);
     let prompted = false;
@@ -669,7 +673,7 @@ Saved, nothing open (\`${NAME} open <host>\` needs no password):
     const reused = Boolean(status);
     if (!status) {
       try {
-        status = await startSession(args, name2, host, port, secret);
+        status = await startSession(args, name2, host, port, secret, account);
       } catch (error) {
         const refused = error instanceof CliError && error.code === 11;
         if (!refused || prompted || !prompts) throw error;
@@ -683,7 +687,7 @@ Saved, nothing open (\`${NAME} open <host>\` needs no password):
         cleanup(name2);
         secret = typed;
         prompted = true;
-        status = await startSession(args, name2, host, port, secret);
+        status = await startSession(args, name2, host, port, secret, account);
       }
     }
     const saved = has(args, "save") && secret ? await keepSecret(host, port, account, secret) : null;
@@ -983,7 +987,7 @@ function report(json, command, summary) {
 `);
 }
 async function sshLogin(args, session, what) {
-  const { bareUsername } = await import("./cli-shell-45XRTE7O.mjs");
+  const { bareUsername } = await import("./cli-shell-22PZYNSJ.mjs");
   const username = bareUsername(flag(args, "ssh-user") ?? session.sshUser ?? "");
   if (!username) {
     throw new CliError(
@@ -991,7 +995,7 @@ async function sshLogin(args, session, what) {
       12
     );
   }
-  const { loadIdentities } = await import("./cli-identities-ZILT4XCR.mjs");
+  const { loadIdentities } = await import("./cli-identities-GBQWYF2O.mjs");
   const { identities, skipped } = await loadIdentities(args.identities);
   const port = Number(flag(args, "ssh-port") ?? session.sshPort ?? 22);
   let password2 = await passwordFor(session.host, port, username);
@@ -1065,7 +1069,7 @@ async function copyFiles(args, json) {
     upload,
     walkLocal,
     walkRemote
-  } = await import("./cli-copy-BOF44DWQ.mjs");
+  } = await import("./cli-copy-ZBTICP7N.mjs");
   const from = resolveEndpoint(args, parseEndpoint(args.rest[0]));
   const to = resolveEndpoint(args, parseEndpoint(args.rest[1]));
   if (!from.endpoint.remote && !to.endpoint.remote) {
@@ -1143,7 +1147,7 @@ async function copyFiles(args, json) {
   }
 }
 async function interactiveShell(args, session) {
-  const { Shell } = await import("./cli-shell-45XRTE7O.mjs");
+  const { Shell } = await import("./cli-shell-22PZYNSJ.mjs");
   const login = await sshLogin(args, session, "a terminal");
   const { username, port, identities } = login;
   const prompts = prompting(args);

package/dist/protocols.d.ts

@@ -139,6 +139,14 @@ interface ScrollDelta {
     x: number;
     y: number;
 }
+/**
+ * What the metrics rail instruments. A real WebSocket in the browser; in the
+ * CLI, a shim with the same surface over a TCP socket straight at the host.
+ */
+interface InstrumentableSocket {
+    readonly readyState: number;
+    addEventListener(type: string, listener: (event: any) => void): void;
+}
 /**
  * A live session. Both drivers expose this, so the AI pane's screen tool and
  * the toolbar never have to ask which protocol they are driving.
@@ -157,7 +165,7 @@ export interface RemoteSession extends EventTarget {
     /** RFB compression level. RDP ignores it. */
     compressionLevel?: number;
     /** The transport the metrics rail instruments. Can appear a tick after construction. */
-    readonly socket?: WebSocket | null;
+    readonly socket?: InstrumentableSocket | null;
     readonly screenGeometry: ScreenGeometry;
     movePointer(x: number, y: number): boolean;
     clickPointer(x: number, y: number, button?: PointerButton): boolean;
@@ -245,6 +253,45 @@ export interface ProtocolDriver {
     /** Protocol-specific wording for a close, or null to fall back to the shared text. */
     describeDisconnect(context: DisconnectContext): string | null;
 }
+/**
+ * Signing in with a key instead of a password.
+ *
+ * An identity is a public key blob, the algorithm name that goes with it, and
+ * something that can sign. What does the signing is deliberately behind a
+ * function: a key read off disk signs with Web Crypto, and a key held by
+ * ssh-agent signs by asking the agent -- the session cannot tell the two apart
+ * and does not need to.
+ *
+ * The parser here reads the format `ssh-keygen` writes by default, which no
+ * runtime can parse on its own: OpenSSH's own container rather than PKCS#8.
+ * Only unencrypted keys are read. A key with a passphrase would need bcrypt
+ * and a prompt, and the answer to a passphrase is ssh-agent, which is already
+ * holding the decrypted key.
+ */
+/** One key that can sign for a user, however it happens to be held. */
+interface SshIdentity {
+    /** The public key type, e.g. `ssh-ed25519`. */
+    readonly keyType: string;
+    /** The public key, in the wire format the host expects. */
+    readonly keyBlob: Uint8Array;
+    /** Where it came from, for logs and error messages. */
+    readonly comment: string;
+    /**
+     * Signature algorithms to offer, best first. RSA keys sign under several,
+     * and a host will say which of them it is willing to take.
+     */
+    readonly algorithms: readonly string[];
+    /** The full signature blob (algorithm name and signature) over `data`. */
+    sign(data: Uint8Array, algorithm: string): Promise<Uint8Array>;
+}
+/**
+ * Read a private key file.
+ *
+ * Returns one identity, or throws with the reason a human can act on -- which
+ * for the common failure is "this key has a passphrase, so let ssh-agent hold
+ * it" rather than a decoder error.
+ */
+declare function parsePrivateKey(text: string, comment?: string): Promise<SshIdentity>;
 export declare const DEFAULT_PORT = 22;
 export declare const COMMAND_MAX_MS: number;
 /**
@@ -253,9 +300,88 @@ export declare const COMMAND_MAX_MS: number;
  * Each shell gets its own, because none of the three agree on how to print a
  * string, run a command and read back its exit status.
  */
-export declare function frameCommand(family: any, command: string, id: any): string;
+export declare function frameCommand(family: string, command: string, id: string): string;
+/** What runCommand resolves with. */
+export interface CommandResult {
+    output: string;
+    exitStatus: number | null;
+    exitSignal?: string;
+    timedOut?: boolean;
+    started?: boolean;
+    reason?: string;
+    durationMs: number;
+}
+/** A tool command's output framing, hidden from the screen while it runs. */
+interface DisplayFilter {
+    begin: string;
+    end: string;
+    stage: 'before' | 'inside' | 'closing';
+    pending: string;
+}
+/** What a caller can ask of an SSH session. */
+export interface SshSessionOptions {
+    username?: string;
+    password?: string;
+    identities?: SshIdentity[] | (() => Promise<SshIdentity[]>);
+    preferredShell?: 'powershell';
+    /** Run a subsystem (e.g. 'sftp') rather than a shell. */
+    subsystem?: string;
+    columns?: number;
+    rows?: number;
+    hostLabel?: string;
+    log?: (step: string, detail?: unknown) => void;
+    verifyHost?: (info: any) => Promise<boolean> | boolean;
+    openTransport?: ((url: string) => any) | null;
+    requestInput?: (prompt: any) => Promise<string>;
+}
 export declare class SshSession extends EventTarget {
     #private;
+    private readonly options;
+    private readonly username;
+    private password;
+    /**
+     * Keys to sign in with, if any. A function rather than a list is allowed
+     * because reading keys off a disk -- or asking an agent for them -- is work
+     * a session that never needs them should not do.
+     */
+    /** Replaced with the resolved list the first time it is read. */
+    private identities;
+    private readonly requestInput;
+    /** Whether there is anybody to ask; see the constructor. */
+    private readonly canAsk;
+    private columns;
+    private rows;
+    /** A subsystem to run instead of a shell, e.g. 'sftp'. */
+    private readonly subsystem;
+    private channelId;
+    private remoteChannelId;
+    private remoteWindow;
+    private remoteMaxPacket;
+    private localWindow;
+    private pendingWrites;
+    private shellOpen;
+    private commandInFlight;
+    /** Set while a tool command runs, to keep its framing off the screen. */
+    displayFilter: DisplayFilter | null;
+    /** True only after the requested interactive shell is ready for commands. */
+    private readySignaled;
+    private powerShellAttempted;
+    private powerShellTimer;
+    /** '', 'posix', 'cmd' or 'powershell'; learned from the prompt. */
+    private shellFamily;
+    private promptTail;
+    private exitStatus;
+    private exitSignal?;
+    private authMethods;
+    /** Which keys were offered and refused, for the message if nothing works. */
+    private triedKeys;
+    /** Set once the host has said no to the stored password. */
+    private passwordRejected;
+    private closed;
+    private waiters;
+    private readonly transport;
+    private fingerprint?;
+    private lastMessage?;
     /**
      * @param {string} url          gateway WebSocket URL
      * @param {object} options
@@ -268,11 +394,11 @@ export declare class SshSession extends EventTarget {
      * @param {(info: object) => Promise<boolean>} [options.verifyHost]
      * @param {(prompt: object) => Promise<string>} [options.requestInput]
      */
-    constructor(url: string, options?: {});
+    constructor(url: string, options?: SshSessionOptions);
     connect(): void;
     disconnect(): void;
     /** Send keystrokes, or anything else the terminal produces, to the shell. */
-    write(data: Uint8Array): void;
+    write(data: Uint8Array | string): void;
     /**
      * Run one command in this shell and return what it printed.
      *
@@ -299,12 +425,20 @@ export declare class SshSession extends EventTarget {
     /** Tell the shell its window changed, so full-screen programs redraw. */
     resize(columns: number, rows: number): void;
 }
+import { Terminal } from '@xterm/xterm';
 export declare class SshTerminal {
-    constructor(container: any);
-    get columns(): any;
-    get rows(): any;
-    onData(handler: any): void;
-    onResize(handler: any): void;
+    private readonly container;
+    readonly terminal: Terminal;
+    private readonly fitAddon;
+    private readonly observer;
+    /** Where keystrokes go; readLine swaps it out while it owns the line. */
+    private dataHandler;
+    private fitting;
+    constructor(container: HTMLElement);
+    get columns(): number;
+    get rows(): number;
+    onData(handler: ((data: string) => void) | null): void;
+    onResize(handler: (cols: number, rows: number) => void): void;
     write(data: Uint8Array): void;
     /** Gateway-side notices, kept visually apart from what the host prints. */
     notice(text: string, tone?: string): void;
@@ -329,20 +463,20 @@ export declare class SshTerminal {
     fit(): void;
     /** The grid the host is being told about, for a status line or a log. */
     get geometry(): {
-        columns: any;
-        rows: any;
-        fontSize: any;
+        columns: number;
+        rows: number;
+        fontSize: number;
     };
-    get selection(): any;
+    get selection(): string;
     /**
      * Read one line from the user, for a password or a one-time code the host
      * asked for during authentication. The shell is not open yet, so the
      * terminal is free to be a prompt.
      */
     readLine({ prompt, echo }?: {
-        echo?: boolean;
         prompt?: string;
-    }): Promise<unknown>;
+        echo?: boolean;
+    }): Promise<string>;
     destroy(): void;
 }
 export declare const DRIVERS: Record<RemoteProtocol, ProtocolDriver>;