@luckypiggy/zhihu-ai-cli 0.1.0-test.1 → 0.2.1-test.4

package/dist/credentials.js

@@ -17,26 +17,102 @@ function safeProfile(profile) {
     }
     return profile;
 }
-/** Spawn a fixed executable without a shell and without putting secret input in argv/env. */
+const MAC_SECURITY_EXECUTABLE = "/usr/bin/security";
+const MAC_EXPECT_EXECUTABLE = "/usr/bin/expect";
+const MAC_EXPECT_FAILURE = 70;
+const MAC_EXPECT_TIMEOUT = 124;
+const MAC_EXPECT_SCRIPT_BODY = `
+set timeout 5
+log_user 0
+if {[gets stdin secret] < 0} { exit ${MAC_EXPECT_FAILURE} }
+set prompt_count 0
+spawn -noecho $zhihu_command {*}$zhihu_args
+expect {
+  "password data for new item:" {
+    if {$prompt_count != 0} { exit ${MAC_EXPECT_FAILURE} }
+    set prompt_count 1
+    send -- "$secret\\r"
+    exp_continue
+  }
+  "retype password for new item:" {
+    if {$prompt_count != 1} { exit ${MAC_EXPECT_FAILURE} }
+    set prompt_count 2
+    send -- "$secret\\r"
+    exp_continue
+  }
+  timeout { exit ${MAC_EXPECT_TIMEOUT} }
+  eof {}
+}
+if {[catch {wait} wait_result] != 0} { exit ${MAC_EXPECT_FAILURE} }
+if {[llength $wait_result] == 4
+    && [string is integer -strict [lindex $wait_result 2]]
+    && [string is integer -strict [lindex $wait_result 3]]} {
+  if {[lindex $wait_result 2] != 0} { exit ${MAC_EXPECT_FAILURE} }
+  set exit_status [lindex $wait_result 3]
+  if {$exit_status == 0 && $prompt_count != 2} { exit ${MAC_EXPECT_FAILURE} }
+  exit $exit_status
+}
+exit ${MAC_EXPECT_FAILURE}
+`;
+function commandEnvironment() {
+    const allowedEnvironmentKeys = new Set([
+        "HOME",
+        "PATH",
+        "LANG",
+        "LC_ALL",
+        "LC_CTYPE",
+        "DBUS_SESSION_BUS_ADDRESS",
+        "XDG_RUNTIME_DIR",
+        "XDG_CONFIG_HOME",
+        "DISPLAY",
+    ]);
+    return Object.fromEntries(Object.entries(process.env).filter(([key]) => allowedEnvironmentKeys.has(key) || key.startsWith("LC_")));
+}
+function isMacSecurityWrite(command, args) {
+    return process.platform === "darwin"
+        && command === MAC_SECURITY_EXECUTABLE
+        && args[0] === "add-generic-password"
+        && args.at(-1) === "-w";
+}
+function tclQuote(value) {
+    return `"${value
+        .replaceAll("\\", "\\\\")
+        .replaceAll("\"", "\\\"")
+        .replaceAll("$", "\\$")
+        .replaceAll("[", "\\[")
+        .replaceAll("]", "\\]")
+        .replaceAll("\r", "\\r")
+        .replaceAll("\n", "\\n")}"`;
+}
+function macSecurityExpectArgs(command, args) {
+    const commandLiteral = tclQuote(command);
+    const argsLiteral = args.map(tclQuote).join(" ");
+    const script = `set zhihu_command ${commandLiteral}\nset zhihu_args [list ${argsLiteral}]${MAC_EXPECT_SCRIPT_BODY}`;
+    return ["-c", script];
+}
+/**
+ * Remove an input value from command output before it can reach diagnostics.
+ */
+function removeInputFromOutput(output, input) {
+    if (!input)
+        return output;
+    const candidates = [input, input.endsWith("\n") ? input.slice(0, -1) : input];
+    return candidates.reduce((value, candidate) => candidate ? value.split(candidate).join("") : value, output);
+}
+/**
+ * Spawn a fixed executable without putting secret input in argv/env.
+ */
 export const processCommandRunner = (command, args, options = {}) => new Promise((resolve, reject) => {
+    const useMacSecurityExpect = isMacSecurityWrite(command, args);
+    const executable = useMacSecurityExpect ? MAC_EXPECT_EXECUTABLE : command;
+    const executableArgs = useMacSecurityExpect ? macSecurityExpectArgs(command, args) : [...args];
     let child;
     try {
-        const allowedEnvironmentKeys = new Set([
-            "HOME",
-            "PATH",
-            "LANG",
-            "LC_ALL",
-            "LC_CTYPE",
-            "DBUS_SESSION_BUS_ADDRESS",
-            "XDG_RUNTIME_DIR",
-            "XDG_CONFIG_HOME",
-            "DISPLAY",
-        ]);
-        const environment = Object.fromEntries(Object.entries(process.env).filter(([key]) => allowedEnvironmentKeys.has(key) || key.startsWith("LC_")));
-        child = spawn(command, [...args], {
+        child = spawn(executable, executableArgs, {
             shell: false,
             stdio: ["pipe", "pipe", "pipe"],
-            env: environment,
+            env: commandEnvironment(),
+            detached: false,
         });
     }
     catch {
@@ -46,36 +122,80 @@ export const processCommandRunner = (command, args, options = {}) => new Promise
     let stdout = "";
     let stderr = "";
     let timer;
-    const finish = (result) => {
+    let settled = false;
+    let inputSent = false;
+    let terminated = false;
+    const clearMainTimer = () => {
         if (timer)
             clearTimeout(timer);
-        resolve(result);
+    };
+    const terminateChild = () => {
+        if (terminated)
+            return;
+        terminated = true;
+        try {
+            child.kill();
+        }
+        catch {
+            // Cleanup is best effort; do not turn a child race into an uncaught
+            // stream error.
+        }
+    };
+    const finish = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        clearMainTimer();
+        const cleanStdout = removeInputFromOutput(stdout, options.input);
+        const cleanStderr = removeInputFromOutput(stderr, options.input);
+        resolve({ ...result, stdout: cleanStdout, stderr: cleanStderr });
+    };
+    const failUnavailable = (message) => {
+        if (settled)
+            return;
+        terminateChild();
+        settled = true;
+        clearMainTimer();
+        reject(new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", message));
+    };
+    const sendInput = () => {
+        if (inputSent || settled)
+            return;
+        inputSent = true;
+        try {
+            if (options.input !== undefined) {
+                // For macOS `security ... -w`, the expect helper reads the single
+                // logical credential input and answers each prompt on its PTY.
+                // The input is still only written to the child stream, never argv/env.
+                child.stdin.write(options.input);
+            }
+            child.stdin.end();
+        }
+        catch {
+            failUnavailable("System credential store is unavailable");
+        }
     };
     child.stdout.on("data", (chunk) => {
         stdout += chunk.toString();
         if (stdout.length > 16384)
-            child.kill();
+            terminateChild();
     });
     child.stderr.on("data", (chunk) => {
         stderr += chunk.toString();
         if (stderr.length > 16384)
-            child.kill();
-    });
-    child.once("error", () => {
-        if (timer)
-            clearTimeout(timer);
-        reject(new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", "System credential store is unavailable"));
+            terminateChild();
     });
+    // Keep listeners attached after settlement so a late EPIPE from a child
+    // that exited during the handshake cannot become an uncaught error.
+    child.stdin.on("error", () => failUnavailable("System credential store is unavailable"));
+    child.on("error", () => failUnavailable("System credential store is unavailable"));
     child.once("close", (code) => finish({ code: code ?? 1, stdout, stderr }));
     if (options.timeoutMs) {
         timer = setTimeout(() => {
-            child.kill();
-            reject(new CredentialStoreError("CREDENTIAL_STORE_UNAVAILABLE", "System credential store timed out"));
+            failUnavailable("System credential store timed out");
         }, options.timeoutMs);
     }
-    if (options.input !== undefined)
-        child.stdin.write(options.input);
-    child.stdin.end();
+    sendInput();
 });
 function missingResult(result) {
     return result.code !== 0 && !result.stdout.trim() && !result.stderr.trim();
@@ -158,6 +278,9 @@ export class SecureCredentialStore {
         try {
             const command = this.command();
             const result = await this.runner(command.executable, command.writeArgs, {
+                // The process runner passes this single logical credential to the
+                // fixed macOS Expect helper, which answers both security prompts in
+                // the child PTY without placing the secret in argv or the environment.
                 input: `${credential}\n`,
                 timeoutMs: 5000,
             });