ai-remote 0.4.4 → 0.4.5

package/README.md

@@ -7,53 +7,92 @@
 
 ## 🚀 Quick Start (CLI)
 
-Run immediately with `npx` (zero install):
+Run immediately with `npx` (zero install). `open` names the machine once and
+leaves a session running; every command after it drives that session, so none of
+them repeats the host, the account or the password:
 
 ```bash
 # Connect and open a live supervision window:
 AI_REMOTE_PASSWORD=secret npx ai-remote open 192.168.1.50 -u Administrator
 
 # Take a screenshot:
-AI_REMOTE_PASSWORD=secret npx ai-remote shot 192.168.1.50 -u Administrator -o screen.png
+npx ai-remote shot -o screen.png
 
 # Click or type on the remote desktop:
-npx ai-remote click 192.168.1.50 500,300
-npx ai-remote type 192.168.1.50 "notepad"
-npx ai-remote key 192.168.1.50 Enter
+npx ai-remote click 500,300
+npx ai-remote type "notepad"
+npx ai-remote key Enter
 
 # Run commands in the remote terminal over SSH:
-npx ai-remote exec 192.168.1.50 "dir"
+npx ai-remote exec "dir"
+
+# Let it go when you are done -- nothing closes on its own:
+npx ai-remote close
 ```
 
 ### CLI Commands
 
 ```
-  ai-remote open   <host[:port]>          connect, show a window, and stay open
-  ai-remote shot   <host[:port]>          screenshot the desktop
-  ai-remote click  <host[:port]> X,Y      click, --button right|middle, --double
-  ai-remote type   <host[:port]> "text"   type into whatever has focus
-  ai-remote key    <host[:port]> <Code>   press keys, e.g. MetaLeft, ControlLeft+KeyA
-  ai-remote exec   <host[:port]> "cmd"    run a command in the terminal (SSH)
-  ai-remote shell  <host[:port]>          an interactive terminal
-  ai-remote do     <host[:port]> "steps"  several actions in one go
-  ai-remote view   <host[:port]>          open the window on a running session
-  ai-remote view   <host[:port]> --close  close the window, session keeps running
-  ai-remote status | list | close [<host>]
-  ai-remote probe  <host[:port]>          is anything listening?
+  ai-remote open <host[:port]>       connect, show a window, and stay open
+
+  ai-remote shot                     screenshot the desktop
+  ai-remote click X,Y                click, --button right|middle, --double
+  ai-remote type  "text"             type into whatever has focus
+  ai-remote key   <Code>             press keys, e.g. MetaLeft, ControlLeft+KeyA
+  ai-remote exec  "cmd"              run a command in the terminal (SSH)
+  ai-remote shell                    an interactive terminal
+  ai-remote do    "steps"            several actions in one go
+  ai-remote view                     open the window on the session
+  ai-remote view --close             close the window, session keeps running
+  ai-remote status                   what the session is doing
+  ai-remote list                     every session that is open
+  ai-remote close                    close it; --all closes every session
+  ai-remote probe [<host[:port]>]    is anything listening?
+```
+
+### Sessions
+
+The session opened last is the one the commands drive, and it lives until it is
+closed -- including across terminals, so an agent and the person watching it
+reach the same desktop. With more than one open, `--session NAME` picks between
+them; a session answers to its name, its host, or `host:port`.
+
+```bash
+npx ai-remote open 192.168.1.50 -u Administrator --session desk
+npx ai-remote open 192.168.1.60 -u Administrator --session build
+
+npx ai-remote list                  # * marks the one commands will use
+npx ai-remote shot --session desk
+npx ai-remote close --all
 ```
 
-### Common Options
+`probe` is the one command besides `open` that still takes an address, because
+it answers whether a session could be opened at all; with no address it probes
+the current session's host.
+
+### Options for `open`
 
 - `-u, --user NAME`: Account name on the host.
 - `-d, --domain NAME`: Windows domain or computer name.
+- `--session NAME`: Name this session (default: `host_port`).
 - `--ssh-user NAME`: Account for the SSH terminal (defaults to `--user`).
 - `--ssh-port N`: SSH port (default: 22).
 - `-s, --security MODE`: `auto` | `nla` | `tls` | `rdp` (default: `auto`).
 - `-W, --width N` / `-H, --height N`: Desktop resolution (default: 1280x800).
-- `-o, --out FILE`: Screenshot output file path (default: `screen.png`).
+- `--idle MINUTES`: Close an unused session (default: 0, never).
 - `--headless` / `--no-view`: Run headless without opening the viewer window.
+- `--no-reuse`: A second session beside one that is already open.
+
+### Options for the rest
+
+- `--session NAME`: Which session to drive (default: the one opened last).
+- `-o, --out FILE`: Screenshot output file path (default: `screen.png`).
+- `--max-edge N`: Shrink a screenshot to fit N.
 - `--json`: Output machine-readable JSON results on stdout.
 
+The password comes from `AI_REMOTE_PASSWORD` (or `REMOTECTL_PASSWORD`). There is
+no `--password` flag: a command line is visible to every process on the machine.
+
 ---
 
 ## 📦 Library Installation

package/dist/cli.mjs

@@ -3,7 +3,7 @@
 // src/cli/cli.ts
 import { basename, resolve as resolvePath } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
-import { readFileSync, readdirSync, existsSync as existsSync2, openSync, unlinkSync as unlinkSync2 } from "node:fs";
+import { readFileSync as readFileSync2, openSync } from "node:fs";
 
 // src/protocols/ssh/messages.ts
 var MSG = {
@@ -2827,8 +2827,8 @@ var Tls12Client = class {
       case HANDSHAKE.FINISHED: {
         const expected = await this.#verifyData("server finished");
         const actual = body.subarray(0, 12);
-        const matches = expected.length === actual.length && expected.every((byte, i) => byte === actual[i]);
-        if (!matches) throw new Error("TLS: the host Finished message did not verify");
+        const matches2 = expected.length === actual.length && expected.every((byte, i) => byte === actual[i]);
+        if (!matches2) throw new Error("TLS: the host Finished message did not verify");
         this.transcript.push(message);
         this.established = true;
         this.resolveHandshake({
@@ -7569,6 +7569,7 @@ function sessionName(host, port, explicit) {
 var socketPath = (name) => join(RUN_DIR, `${name}.sock`);
 var metaPath = (name) => join(RUN_DIR, `${name}.json`);
 var logPath = (name) => join(RUN_DIR, `${name}.log`);
+var currentPath = () => join(ROOT, "current");
 
 // src/cli/daemon.ts
 async function runDaemon(options) {
@@ -7606,7 +7607,11 @@ async function runDaemon(options) {
       viewer: viewer?.url ?? null,
       width: session.framebuffer.width || size.width,
       height: session.framebuffer.height || size.height,
-      startedAt
+      startedAt,
+      // So `shell` and `exec` need no flags either: the account the terminal
+      // signs in as was settled when the session was opened.
+      sshUser: options.sshUsername || bareUsername(options.username),
+      sshPort: options.sshPort
     }, null, 2));
   }
   let viewer = null;
@@ -7674,6 +7679,8 @@ async function runDaemon(options) {
           window: viewer?.window?.kind ?? null,
           viewers: viewer?.viewers ?? 0,
           shell: shell ? "open" : shellStarting ? "opening" : "closed",
+          sshUser: options.sshUsername || bareUsername(options.username),
+          sshPort: options.sshPort,
           pid: process.pid
         };
       case "shot": {
@@ -7797,10 +7804,89 @@ async function runScript(session, script) {
   return done;
 }
 
+// src/cli/sessions.ts
+import { existsSync as existsSync2, readFileSync, readdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+function liveSessions() {
+  ensureRunDir();
+  return readdirSync(RUN_DIR).filter((file) => file.endsWith(".json")).flatMap((file) => {
+    try {
+      const meta = JSON.parse(readFileSync(`${RUN_DIR}/${file}`, "utf8"));
+      try {
+        process.kill(meta.pid, 0);
+      } catch {
+        cleanup(meta.name);
+        return [];
+      }
+      return [meta];
+    } catch {
+      return [];
+    }
+  }).toSorted((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+function cleanup(name) {
+  for (const file of [socketPath(name), metaPath(name), logPath(name)]) {
+    try {
+      if (existsSync2(file)) unlinkSync2(file);
+    } catch {
+    }
+  }
+  forgetCurrent(name);
+}
+function setCurrent(name) {
+  ensureRunDir();
+  writeFileSync2(currentPath(), `${name}
+`, { mode: 384 });
+}
+function readCurrent() {
+  try {
+    return readFileSync(currentPath(), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function forgetCurrent(name) {
+  if (name && readCurrent() !== name) return;
+  try {
+    if (existsSync2(currentPath())) unlinkSync2(currentPath());
+  } catch {
+  }
+}
+var matches = (meta, asked) => meta.name === asked || meta.host === asked || `${meta.host}:${meta.port}` === asked;
+function pickSession(open, asked, current, program = "ai-remote") {
+  if (asked) {
+    const named = open.find((meta) => matches(meta, asked));
+    return named ? { session: named } : {
+      problem: `No open session matches "${asked}".${listing(open, program)}`
+    };
+  }
+  if (!open.length) {
+    return { problem: `No session is open. Start one with \`${program} open <host[:port]>\`.` };
+  }
+  const marked = current ? open.find((meta) => meta.name === current) : void 0;
+  if (marked) return { session: marked };
+  if (open.length === 1) return { session: open[0] };
+  return {
+    problem: `${open.length} sessions are open and none of them is the current one. Pass \`--session NAME\`.${listing(open, program)}`
+  };
+}
+function listing(open, program) {
+  if (!open.length) return ` Nothing is open -- \`${program} open <host[:port]>\` starts a session.`;
+  return `
+Open: ${open.map((meta) => `${meta.name} (${meta.host}:${meta.port})`).join(", ")}`;
+}
+function freeName(base, taken) {
+  const used = new Set(taken);
+  if (!used.has(base)) return base;
+  for (let suffix = 2; ; suffix++) {
+    const candidate = `${base}_${suffix}`;
+    if (!used.has(candidate)) return candidate;
+  }
+}
+
 // src/cli/cli.ts
 function readLog(name) {
   try {
-    return readFileSync(logPath(name), "utf8").split("\n").filter((line) => line.trim() && !/^\s/.test(line) && !line.startsWith("[RDP] ")).slice(-4).join("\n");
+    return readFileSync2(logPath(name), "utf8").split("\n").filter((line) => line.trim() && !/^\s/.test(line) && !line.startsWith("[RDP] ")).slice(-4).join("\n");
   } catch {
     return "";
   }
@@ -7811,40 +7897,56 @@ var NAME = (() => {
 })();
 var USAGE = `${NAME} -- drive a remote desktop, with a window you can watch
 
-  ${NAME} open   <host[:port]>          connect, show a window, and stay open
-  ${NAME} shot   <host[:port]>          screenshot the desktop
-  ${NAME} click  <host[:port]> X,Y      click, --button right|middle, --double
-  ${NAME} type   <host[:port]> "text"   type into whatever has focus
-  ${NAME} key    <host[:port]> <Code>   press keys, e.g. MetaLeft, ControlLeft+KeyA
-  ${NAME} exec   <host[:port]> "cmd"    run a command in the terminal (SSH)
-  ${NAME} shell  <host[:port]>          an interactive terminal
-  ${NAME} do     <host[:port]> "steps"  several actions in one go
-  ${NAME} view   <host[:port]>          open the window on a running session
-  ${NAME} view   <host[:port]> --close   close the window, session keeps running
-  ${NAME} status | list | close [<host>]
-  ${NAME} probe  <host[:port]>          is anything listening?
+One command names the machine:
+
+  ${NAME} open <host[:port]>       connect, show a window, and stay open
+
+The rest drive that session, and take no host:
+
+  ${NAME} shot                     screenshot the desktop
+  ${NAME} click X,Y                click, --button right|middle, --double
+  ${NAME} type  "text"             type into whatever has focus
+  ${NAME} key   <Code>             press keys, e.g. MetaLeft, ControlLeft+KeyA
+  ${NAME} exec  "cmd"              run a command in the terminal (SSH)
+  ${NAME} shell                    an interactive terminal
+  ${NAME} do    "steps"            several actions in one go
+  ${NAME} view                     open the window on the session
+  ${NAME} view --close             close the window, session keeps running
+  ${NAME} status                   what the session is doing
+  ${NAME} list                     every session that is open
+  ${NAME} close                    close it; --all closes every session
+  ${NAME} probe [<host[:port]>]    is anything listening?
 
 Steps for "do", separated by semicolons:
   move X,Y \xB7 click X,Y[,right|middle] \xB7 dblclick X,Y \xB7 scroll X,Y,DX,DY
   type TEXT \xB7 key Code[+Code...] \xB7 cad \xB7 wait MS \xB7 shot FILE
 
-Options
+Sessions
+  The session opened last is the one commands use. --session NAME picks
+  another, and a session answers to its name, its host, or host:port.
+  A session stays open until it is closed; \`${NAME} list\` shows them.
+
+Options for open
   -u, --user NAME        account on the host
   -d, --domain NAME      Windows domain or computer name
+      --session NAME     name this session             (default: host_port)
       --ssh-user NAME    only if the terminal signs in as someone else;
                          by default it reuses --user and the same password
       --ssh-port N       SSH port                      (default: 22)
   -s, --security MODE    auto | nla | tls | rdp        (default: auto)
   -W, --width  N         desktop width                 (default: 1280)
   -H, --height N         desktop height                (default: 800)
-  -o, --out FILE         where a screenshot goes       (default: screen.png)
-      --max-edge N       shrink a screenshot to fit N
       --view-port N      port for the window           (default: 7373)
       --idle MINUTES     close an unused session       (default: 0, never)
       --headless         no window (same as --no-view)
       --no-view          no window
       --no-open          window, but do not launch a browser
-      --no-reuse         a fresh session, ignoring any that is already open
+      --no-reuse         a second session beside one that is already open
+
+Options for the rest
+      --session NAME     which session to drive        (default: the last opened)
+  -o, --out FILE         where a screenshot goes       (default: screen.png)
+      --max-edge N       shrink a screenshot to fit N
       --json             machine-readable result on stdout
 
 The password comes from AI_REMOTE_PASSWORD (or REMOTECTL_PASSWORD). There is no
@@ -7871,6 +7973,7 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "view-port",
   "idle",
   "name",
+  "session",
   "ssh-user",
   "ssh-port",
   "settle"
@@ -7888,7 +7991,7 @@ function parse(argv) {
     if (VALUE_FLAGS.has(name)) flags[name] = argv[++i] ?? "";
     else flags[name] = true;
   }
-  return { command: positional[0] ?? "", target: positional[1] ?? "", rest: positional.slice(2), flags };
+  return { command: positional[0] ?? "", rest: positional.slice(1), flags };
 }
 var flag = (args, ...names) => {
   for (const name of names) if (typeof args.flags[name] === "string") return args.flags[name];
@@ -7908,29 +8011,38 @@ var CliError = class extends Error {
   code;
 };
 var password = () => process.env.AI_REMOTE_PASSWORD ?? process.env.REMOTECTL_PASSWORD ?? "";
-function liveSessions() {
-  ensureRunDir();
-  return readdirSync(RUN_DIR).filter((file) => file.endsWith(".json")).flatMap((file) => {
-    try {
-      const meta = JSON.parse(readFileSync(`${RUN_DIR}/${file}`, "utf8"));
-      try {
-        process.kill(meta.pid, 0);
-      } catch {
-        cleanup(meta.name);
-        return [];
-      }
-      return [meta];
-    } catch {
-      return [];
-    }
-  });
+function currentSession(args) {
+  const chosen = pickSession(liveSessions(), flag(args, "session", "name"), readCurrent(), NAME);
+  if ("problem" in chosen) throw new CliError(chosen.problem, 12);
+  return chosen.session;
 }
-function cleanup(name) {
-  for (const file of [socketPath(name), metaPath(name), logPath(name)]) {
-    try {
-      if (existsSync2(file)) unlinkSync2(file);
-    } catch {
-    }
+function refuseTarget(command, token) {
+  const address = /^(\d{1,3}\.){3}\d{1,3}(:\d+)?$/.test(token) || /^[\w-]+(\.[\w-]+)+(:\d+)?$/.test(token) || /^localhost(:\d+)?$/i.test(token);
+  throw new CliError(
+    address ? `\`${command}\` does not take a host: it drives the session \`${NAME} open\` left running.
+  ${NAME} open ${token}    then    ${NAME} ${command} ...
+--session NAME picks between several; \`${NAME} list\` shows what is open.` : `\`${command}\` takes no argument: it acts on the session \`${NAME} open\` left running.
+  ${NAME} ${command} --session ${token}    acts on another one
+\`${NAME} list\` shows what is open.`,
+    12
+  );
+}
+var TAKES_NOTHING = /* @__PURE__ */ new Set(["shot", "view", "status", "shell", "close"]);
+var COORDINATE = /^-?\d+\s*,\s*-?\d+$/;
+function refuseLegacyTarget(args) {
+  const { command, rest } = args;
+  if (TAKES_NOTHING.has(command) && rest.length) refuseTarget(command, rest[0]);
+  const spec = flag(args, "at") ?? rest[0];
+  if (command === "click" && spec && !COORDINATE.test(spec) && rest[1] && COORDINATE.test(rest[1])) {
+    refuseTarget("click", spec);
+  }
+  if (command === "key" && rest[0] && /[.:]/.test(rest[0])) refuseTarget("key", rest[0]);
+}
+function refuseSessionHost(args, command, session) {
+  if (args.rest.length < 2) return;
+  const token = args.rest[0].replace(/^\w+:\/\//, "");
+  if (token === session.host || token === `${session.host}:${session.port}` || token === session.name) {
+    refuseTarget(command, args.rest[0]);
   }
 }
 async function ask(name, op, args = {}) {
@@ -7942,6 +8054,14 @@ async function ask(name, op, args = {}) {
   if (!response.ok) throw new CliError(response.error ?? `The session refused "${op}".`, response.code ?? 1);
   return response.result;
 }
+async function tell(session, op, args = {}) {
+  const result = await ask(session.name, op, args);
+  if (result === null) {
+    cleanup(session.name);
+    throw new CliError(`The session ${session.name} is no longer answering. It has been cleaned up.`, 12);
+  }
+  return result;
+}
 async function startSession(args, name, host, port) {
   const daemonArgs = [
     process.argv[1],
@@ -7965,8 +8085,10 @@ async function startSession(args, name, host, port) {
     flag(args, "ssh-port") ?? "22",
     "--view-port",
     flag(args, "view-port") ?? "7373",
+    // Zero unless asked for: a session stays open until it is closed. An agent
+    // that pauses to think is not an agent that has finished.
     "--idle",
-    flag(args, "idle") ?? "30"
+    flag(args, "idle") ?? "0"
   ];
   if (has(args, "no-view", "headless")) daemonArgs.push("--no-view");
   if (has(args, "no-open")) daemonArgs.push("--no-open");
@@ -8000,38 +8122,84 @@ async function main() {
     return;
   }
   const json = has(args, "json");
-  if (args.command === "list" || args.command === "status" && !args.target) {
+  if (args.command === "__session") {
+    const { host, port } = splitTarget(args.rest[0] ?? "", 3389);
+    await runDaemon({
+      name: sessionName(host, port, flag(args, "name", "session")),
+      host,
+      port,
+      username: flag(args, "u", "user") ?? "",
+      password: password(),
+      domain: flag(args, "d", "domain") ?? "",
+      width: Number(flag(args, "W", "width") ?? 1280),
+      height: Number(flag(args, "H", "height") ?? 800),
+      security: flag(args, "s", "security") ?? "auto",
+      clientName: "ai-remote",
+      view: !has(args, "no-view", "headless"),
+      launchBrowser: !has(args, "no-open"),
+      viewPort: Number(flag(args, "view-port") ?? 7373),
+      sshUsername: flag(args, "ssh-user") ?? flag(args, "u", "user") ?? "",
+      sshPort: Number(flag(args, "ssh-port") ?? 22),
+      tab: has(args, "tab"),
+      fullscreen: has(args, "fullscreen"),
+      idleMs: Math.max(0, Number(flag(args, "idle") ?? 0)) * 6e4
+    });
+    return;
+  }
+  if (args.command === "__window") {
+    await runWindow(process.argv.slice(3));
+    return;
+  }
+  if (args.command === "list") {
     const sessions = liveSessions();
+    const current = readCurrent();
     if (json) {
-      process.stdout.write(`${JSON.stringify({ sessions })}
+      process.stdout.write(`${JSON.stringify({ current, sessions })}
 `);
       return;
     }
     if (!sessions.length) {
-      process.stdout.write("No sessions are open.\n");
+      process.stdout.write(`No sessions are open. \`${NAME} open <host>\` starts one.
+`);
       return;
     }
     for (const meta of sessions) {
-      process.stdout.write(`${meta.name}  ${meta.host}:${meta.port}  ${meta.width}x${meta.height}  pid ${meta.pid}${meta.viewer ? `  ${meta.viewer}` : ""}
+      process.stdout.write(`${meta.name === current ? "*" : " "} ${meta.name}  ${meta.host}:${meta.port}  ${meta.width}x${meta.height}  pid ${meta.pid}${meta.viewer ? `  ${meta.viewer}` : ""}
 `);
     }
     return;
   }
-  if (!args.target && args.command !== "close") throw new CliError("Name the machine to connect to.", 12);
-  const { host, port } = splitTarget(args.target || "", 3389);
-  const name = sessionName(host, port, flag(args, "name"));
-  if (args.command === "close") {
-    const targets = args.target ? [name] : liveSessions().map((meta) => meta.name);
-    for (const target of targets) {
-      await ask(target, "close").catch(() => null);
-      cleanup(target);
-      process.stdout.write(`Closed ${target}.
-`);
-    }
-    if (!targets.length) process.stdout.write("No sessions are open.\n");
+  if (args.command === "open") {
+    const target = args.rest[0];
+    if (!target) throw new CliError(`Name the machine to connect to: \`${NAME} open <host[:port]>\``, 12);
+    const { host, port } = splitTarget(target, 3389);
+    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;
+    let status = has(args, "no-reuse") ? null : await ask(name2, "status");
+    const reused = Boolean(status);
+    if (!status) status = await startSession(args, name2, host, port);
+    if (!has(args, "no-view", "headless") && !status.viewer) {
+      Object.assign(status, await ask(name2, "view-open", { launch: !has(args, "no-open") }));
+    }
+    setCurrent(name2);
+    report(json, "open", {
+      host,
+      port,
+      name: name2,
+      reused,
+      width: status.width,
+      height: status.height,
+      viewer: status.viewer,
+      window: status.window,
+      viewers: status.viewers
+    });
     return;
   }
   if (args.command === "probe") {
+    const target = args.rest[0];
+    const where = target ? splitTarget(target, 3389) : currentSession(args);
+    const { host, port } = where;
     const { reachable, ms, detail } = await probe(host, port);
     if (json) process.stdout.write(`${JSON.stringify({ host, port, reachable, ms, detail })}
 `);
@@ -8040,106 +8208,103 @@ async function main() {
     if (!reachable) throw new CliError(detail, 10);
     return;
   }
-  if (args.command === "__session") {
-    await runDaemon({
-      name,
-      host,
-      port,
-      username: flag(args, "u", "user") ?? "",
-      password: password(),
-      domain: flag(args, "d", "domain") ?? "",
-      width: Number(flag(args, "W", "width") ?? 1280),
-      height: Number(flag(args, "H", "height") ?? 800),
-      security: flag(args, "s", "security") ?? "auto",
-      clientName: "ai-remote",
-      view: !has(args, "no-view", "headless"),
-      launchBrowser: !has(args, "no-open"),
-      viewPort: Number(flag(args, "view-port") ?? 7373),
-      sshUsername: flag(args, "ssh-user") ?? flag(args, "u", "user") ?? "",
-      sshPort: Number(flag(args, "ssh-port") ?? 22),
-      tab: has(args, "tab"),
-      fullscreen: has(args, "fullscreen"),
-      // Zero by default: a session stays open until it is closed. An agent
-      // that pauses to think is not an agent that has finished.
-      idleMs: Math.max(0, Number(flag(args, "idle") ?? 0)) * 6e4
-    });
+  refuseLegacyTarget(args);
+  if (args.command === "close") {
+    const targets = has(args, "all") ? liveSessions().map((meta) => meta.name) : [currentSession(args).name];
+    for (const target of targets) {
+      await ask(target, "close").catch(() => null);
+      cleanup(target);
+      process.stdout.write(`Closed ${target}.
+`);
+    }
+    if (!targets.length) process.stdout.write("No sessions are open.\n");
+    const left = liveSessions();
+    if (!readCurrent() && left.length) setCurrent(left[left.length - 1].name);
     return;
   }
-  if (args.command === "__window") {
-    await runWindow(process.argv.slice(3));
+  if (args.command === "status" && !liveSessions().length) {
+    if (json) process.stdout.write(`${JSON.stringify({ ok: true, sessions: [] })}
+`);
+    else process.stdout.write("No sessions are open.\n");
     return;
   }
+  const session = currentSession(args);
+  const { name } = session;
   if (args.command === "shell") {
-    await interactiveShell(args, host);
+    await interactiveShell(args, session);
     return;
   }
-  let status = has(args, "no-reuse") ? null : await ask(name, "status");
-  const reused = Boolean(status);
-  if (!status) status = await startSession(args, name, host, port);
-  const report = { host, port, name, reused, width: status.width, height: status.height };
+  const summary = {
+    host: session.host,
+    port: session.port,
+    name,
+    width: session.width,
+    height: session.height
+  };
   switch (args.command) {
-    case "open":
-      if (!has(args, "no-view", "headless") && !status.viewer) {
-        Object.assign(status, await ask(name, "view-open", { launch: !has(args, "no-open") }));
-      }
-      Object.assign(report, { viewer: status.viewer, window: status.window, viewers: status.viewers });
+    case "status": {
+      Object.assign(summary, await tell(session, "status"));
       break;
+    }
     case "view": {
       if (has(args, "close")) {
-        const { closed } = await ask(name, "view-close");
-        Object.assign(report, { viewer: null, closed });
+        const { closed } = await tell(session, "view-close");
+        Object.assign(summary, { viewer: null, closed });
         break;
       }
-      Object.assign(report, await ask(name, "view-open", { launch: !has(args, "no-open") }));
+      Object.assign(summary, await tell(session, "view-open", { launch: !has(args, "no-open") }));
       break;
     }
     case "shot": {
       const file = resolvePath(flag(args, "o", "out") ?? "screen.png");
       const maxEdge = Number(flag(args, "max-edge") ?? 0);
-      Object.assign(report, await ask(name, "shot", { file, maxEdge }));
+      Object.assign(summary, await tell(session, "shot", { file, maxEdge }));
       break;
     }
     case "click": {
       const spec = flag(args, "at") ?? args.rest[0];
-      if (!spec) throw new CliError("click needs a position, e.g. `click 192.168.1.5 640,400`", 12);
+      if (!spec) throw new CliError(`click needs a position, e.g. \`${NAME} click 640,400\``, 12);
       const [x, y] = spec.split(",").map(Number);
       const button2 = flag(args, "button") ?? "left";
       const step = `click ${x},${y}${button2 === "left" ? "" : `,${button2}`}`;
-      await ask(name, "script", { script: has(args, "double") ? `${step}; ${step}` : step });
-      Object.assign(report, { clicked: { x, y, button: button2 } });
+      await tell(session, "script", { script: has(args, "double") ? `${step}; ${step}` : step });
+      Object.assign(summary, { clicked: { x, y, button: button2 } });
       break;
     }
     case "type": {
+      refuseSessionHost(args, "type", session);
       const text = args.rest.join(" ");
       if (!text) throw new CliError("type needs some text", 12);
-      await ask(name, "script", { script: `type ${text}` });
-      Object.assign(report, { typed: text.length });
+      await tell(session, "script", { script: `type ${text}` });
+      Object.assign(summary, { typed: text.length });
       break;
     }
     case "key": {
       if (!args.rest.length) throw new CliError("key needs at least one code, e.g. MetaLeft", 12);
-      await ask(name, "script", { script: args.rest.map((code) => `key ${code}`).join("; ") });
-      Object.assign(report, { keys: args.rest });
+      await tell(session, "script", { script: args.rest.map((code) => `key ${code}`).join("; ") });
+      Object.assign(summary, { keys: args.rest });
       break;
     }
     case "do": {
+      refuseSessionHost(args, "do", session);
       const script = args.rest.join(" ");
       if (!script) throw new CliError('do needs a script, e.g. "key MetaLeft; wait 800; shot s.png"', 12);
-      Object.assign(report, await ask(name, "script", { script }));
+      Object.assign(summary, await tell(session, "script", { script }));
       break;
     }
     case "exec": {
+      refuseSessionHost(args, "exec", session);
       const command = args.rest.join(" ");
       if (!command) throw new CliError("exec needs a command to run", 12);
-      const result = await ask(name, "exec", { command });
-      Object.assign(report, result);
+      const result = await tell(session, "exec", { command });
+      Object.assign(summary, result);
       if (!json) {
         process.stdout.write(result.output.endsWith("\n") ? result.output : `${result.output}
 `);
         if (result.exitStatus) process.stderr.write(`exit ${result.exitStatus}
 `);
       }
-      if (json) process.stdout.write(`${JSON.stringify({ ok: result.exitStatus === 0, ...report })}
+      if (json) process.stdout.write(`${JSON.stringify({ ok: result.exitStatus === 0, ...summary })}
 `);
       process.exit(result.exitStatus === 0 ? 0 : 1);
       return;
@@ -8147,16 +8312,29 @@ async function main() {
     default:
       throw new CliError(`Unknown command "${args.command}".`, 12);
   }
-  if (json) process.stdout.write(`${JSON.stringify({ ok: true, ...report })}
+  report(json, args.command, summary);
+}
+function report(json, command, summary) {
+  if (json) process.stdout.write(`${JSON.stringify({ ok: true, ...summary })}
 `);
-  else process.stdout.write(`${describe(args.command, report)}
+  else process.stdout.write(`${describe(command, summary)}
 `);
 }
-async function interactiveShell(args, host) {
+async function interactiveShell(args, session) {
+  const username = bareUsername(flag(args, "ssh-user") ?? session.sshUser ?? "");
+  if (!username) {
+    throw new CliError(
+      `The session ${session.name} has no account for a terminal. Open it with -u, or pass --ssh-user here.`,
+      12
+    );
+  }
+  if (!password()) {
+    throw new CliError("The terminal signs in for itself, so it needs AI_REMOTE_PASSWORD in this shell.", 11);
+  }
   const shell = new Shell({
-    host,
-    port: Number(flag(args, "ssh-port") ?? 22),
-    username: flag(args, "ssh-user") ?? bareUsername(flag(args, "u", "user") ?? ""),
+    host: session.host,
+    port: Number(flag(args, "ssh-port") ?? session.sshPort ?? 22),
+    username,
     password: password(),
     columns: process.stdout.columns ?? 120,
     rows: process.stdout.rows ?? 30
@@ -8194,26 +8372,29 @@ async function probe(host, port) {
     socket.on("error", (error) => done(false, error.message));
   });
 }
-function describe(command, report) {
-  const size = `${report.width}x${report.height}`;
-  const where = report.reused ? "the open session" : "a new session";
+function describe(command, summary) {
+  const size = `${summary.width}x${summary.height}`;
   if (command === "open") {
-    const window = report.window === "window" ? "A window is open on it." : report.window === "tab" ? "It opened in your browser." : report.viewer ? `Open it at ${report.viewer}` : "No window (headless).";
-    return `${report.reused ? "Already connected" : "Connected"} to ${report.host}:${report.port} at ${size}. ${window}
-Run more commands against it, then \`${NAME} close ${report.host}\` when you are done.`;
+    const window = summary.window === "window" ? "A window is open on it." : summary.window === "tab" ? "It opened in your browser." : summary.viewer ? `Open it at ${summary.viewer}` : "No window (headless).";
+    return `${summary.reused ? "Already connected" : "Connected"} to ${summary.host}:${summary.port} at ${size}. ${window}
+Session ${summary.name}. Run more commands with no host, then \`${NAME} close\` when you are done.`;
+  }
+  if (command === "status") {
+    return `${summary.name}  ${summary.host}:${summary.port}  ${size}  ${summary.connected ? "connected" : "disconnected"}  terminal ${summary.shell}
+${summary.viewer ? `Window: ${summary.viewer} (${summary.viewers} watching)` : "No window."}`;
   }
   if (command === "view") {
-    if (report.viewer) return `Window: ${report.viewer}`;
-    return report.closed ? "Closed the window. The session is still open." : "There was no window open.";
+    if (summary.viewer) return `Window: ${summary.viewer}`;
+    return summary.closed ? "Closed the window. The session is still open." : "There was no window open.";
   }
-  if (command === "shot") return `Wrote ${report.file} (${report.width}x${report.height}) from ${where}.`;
+  if (command === "shot") return `Wrote ${summary.file} (${summary.width}x${summary.height}) from ${summary.name}.`;
   if (command === "click") {
-    const { x, y } = report.clicked;
+    const { x, y } = summary.clicked;
     return `Clicked (${x}, ${y}) on a ${size} desktop.`;
   }
-  if (command === "type") return `Typed ${report.typed} characters.`;
-  if (command === "key") return `Pressed ${report.keys.join(", ")}.`;
-  if (command === "do") return `Ran ${report.steps.length} steps: ${report.steps.join(" \u2192 ")}`;
+  if (command === "type") return `Typed ${summary.typed} characters.`;
+  if (command === "key") return `Pressed ${summary.keys.join(", ")}.`;
+  if (command === "do") return `Ran ${summary.steps.length} steps: ${summary.steps.join(" \u2192 ")}`;
   return "Done.";
 }
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-remote",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "RDP, VNC and SSH protocol engines that run in Node, a Worker or a browser -- plus `npx ai-remote`, a CLI that drives a machine and shows you what it is doing",
   "type": "module",
   "bin": {