fix: read the password without echoing it, and name both agents at the end (#7)

Author: salatmaster

README.md

@@ -201,6 +201,15 @@ KEENETIC_TEST_HOST=… KEENETIC_TEST_PASSWORD=… npm run smoke
 Fixtures are anonymized deterministically and a test scans the whole repository
 for anything that looks like a real MAC address, private IP or key.
 
+The setup wizard reads a password from the terminal, which no unit test can
+reach: piped input takes a different code path entirely. That part is checked
+with a script that drives a real pty, so it needs a terminal and cannot run in
+CI:
+
+```
+KEENETIC_TEST_PASSWORD=… ./scripts/verify-wizard.exp
+```
+
 ## License
 
 MIT

scripts/verify-wizard.exp

@@ -0,0 +1,66 @@
+#!/usr/bin/env expect
+#
+# Checks the two things about `keenetic-mcp init` that no unit test can reach:
+# that the password prompt is actually visible, and that what you type is not.
+#
+# Both need a real terminal. Piped input will not do: under a pty the end of a
+# pipe arrives as Ctrl-D and aborts the first question, and without a pty the
+# wizard takes its buffered path and never touches the terminal code at all.
+# That is why this is expect and not vitest, and why CI cannot run it.
+#
+#   npm run build
+#   KEENETIC_TEST_PASSWORD=... ./scripts/verify-wizard.exp
+#
+# Prints PASS or FAIL for each check and exits non-zero on any failure.
+
+set timeout 30
+log_user 0
+
+if {![info exists env(KEENETIC_TEST_PASSWORD)]} {
+    puts "KEENETIC_TEST_PASSWORD must be set to a password the router accepts."
+    exit 2
+}
+set password $env(KEENETIC_TEST_PASSWORD)
+
+# A throwaway config directory, so a real installation is never touched.
+set config_dir "/tmp/keenetic-wizard-check-[pid]"
+file mkdir $config_dir
+
+spawn env KEENETIC_CONFIG_DIR=$config_dir node dist/index.js init
+
+set failures 0
+
+expect {
+    "Router address" {}
+    timeout { puts "FAIL  the wizard never asked for an address"; exit 1 }
+}
+send "\r"
+
+expect {
+    "Login" {}
+    timeout { puts "FAIL  the wizard never asked for a login"; exit 1 }
+}
+send "\r"
+
+expect {
+    "Password: " { puts "PASS  the password prompt is visible" }
+    timeout      { puts "FAIL  the password prompt never appeared"; incr failures }
+}
+
+# Type it, then look at the screen before pressing enter.
+send $password
+sleep 1
+expect {
+    -re $password { puts "FAIL  the password was echoed to the terminal"; incr failures }
+    timeout       { puts "PASS  the password was not echoed" }
+}
+send "\r"
+
+expect {
+    "Password stored in" { puts "PASS  the wizard completed" }
+    timeout              { puts "FAIL  the wizard did not finish"; incr failures }
+}
+
+expect eof
+file delete -force $config_dir
+exit [expr {$failures > 0}]

src/cli/init.ts

@@ -69,9 +69,15 @@ export async function runInit(deps: InitDeps): Promise<number> {
   deps.out(`Password stored in ${where}`);
   deps.out(`Settings written to ${path}`);
   deps.out('');
-  deps.out('Add the server to your agent:');
-  deps.out('  Codex:  codex mcp add keenetic -- npx -y keenetic-mcp');
-  deps.out('  Others: {"command": "npx", "args": ["-y", "keenetic-mcp"]}');
+  deps.out('Add it to your agent. The plugin brings the skills along with the server:');
+  deps.out('');
+  deps.out('  Claude Code   /plugin marketplace add salatmaster/keenetic-mcp');
+  deps.out('                /plugin install keenetic@keenetic');
+  deps.out('');
+  deps.out('  Codex         codex plugin marketplace add salatmaster/keenetic-mcp');
+  deps.out('                codex plugin add keenetic@keenetic');
+  deps.out('');
+  deps.out('  Anything else {"command": "npx", "args": ["-y", "keenetic-mcp"]}');
   return 0;
 }
 
@@ -93,34 +99,85 @@ async function readGateway(): Promise<string | null> {
   }
 }
 
-// Required-but-nullable rather than optional: exactOptionalPropertyTypes
-// forbids assigning undefined back to an optional property.
-type MutableReadline = { _writeToOutput: ((text: string) => void) | undefined };
-
 interface LineSource {
   ask(question: string, echo: boolean): Promise<string>;
   close(): void;
 }
 
-/** Reads whole lines from a terminal, hiding the echo when asked to. */
+/**
+ * Reads a secret from the terminal without echoing it.
+ *
+ * Raw mode rather than readline: in terminal mode readline redraws the current
+ * line, which erases a prompt written straight to stdout, and muting its
+ * private `_writeToOutput` does not suppress the echo on current Node. Raw mode
+ * turns the echo off at the terminal, so nothing can leak it.
+ */
+function readSecret(question: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const { stdin, stdout } = process;
+    stdout.write(question);
+
+    const wasRaw = stdin.isRaw === true;
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+
+    let secret = '';
+
+    const stop = (): void => {
+      stdin.off('data', onData);
+      if (stdin.isTTY) stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stdout.write('\n');
+    };
+
+    const onData = (chunk: Buffer): void => {
+      for (const char of chunk.toString('utf8')) {
+        switch (char) {
+          case '\r':
+          case '\n':
+          case '\u0004': // Ctrl-D, an empty password
+            stop();
+            resolve(secret);
+            return;
+          case '\u0003': // Ctrl-C
+            stop();
+            reject(new Error('cancelled'));
+            return;
+          case '\u007f': // Delete
+          case '\b':
+            secret = secret.slice(0, -1);
+            break;
+          default:
+            // Skip the rest of the control range, including escape sequences
+            // from arrow keys, which would otherwise land in the password.
+            if (char >= ' ' && char !== '\u007f') secret += char;
+        }
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}
+
+/**
+ * Reads from a terminal.
+ *
+ * A readline interface is opened per visible question and closed again, so it
+ * is never competing with the raw-mode reader for stdin.
+ */
 function terminalSource(): LineSource {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
   return {
     async ask(question, echo) {
-      if (echo) return (await rl.question(question)).trim();
+      if (!echo) return readSecret(question);
 
-      const mutable = rl as unknown as MutableReadline;
-      const original = mutable._writeToOutput;
-      process.stdout.write(question);
-      mutable._writeToOutput = () => {};
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
       try {
-        return await rl.question('');
+        return (await rl.question(question)).trim();
       } finally {
-        mutable._writeToOutput = original;
-        process.stdout.write('\n');
+        rl.close();
       }
     },
-    close: () => rl.close()
+    close: () => {}
   };
 }
 

tests/cli/init.test.ts

@@ -50,10 +50,15 @@ describe('runInit', () => {
     expect(out.join('\n')).not.toContain('hunter2');
   });
 
-  it('prints the config block for the user to paste', async () => {
+  it('names both agents, not just one, plus the generic config', async () => {
     const { deps, out } = await makeDeps();
     await runInit(deps);
-    expect(out.join('\n')).toMatch(/npx -y keenetic-mcp/);
+    const text = out.join('\n');
+    expect(text).toMatch(/Claude Code/);
+    expect(text).toMatch(/Codex/);
+    expect(text).toMatch(/plugin marketplace add salatmaster\/keenetic-mcp/);
+    expect(text).toMatch(/"command": "npx"/);
+    expect(text).toMatch(/"keenetic-mcp"/);
   });
 
   it('fails with a usable message when nothing answers at the gateway', async () => {