sido-askpass 0.5.0 → 0.7.0

package/README.md

@@ -18,10 +18,12 @@ Works with:
 - **Codex Full Access** — sudo authentication from agent-run commands
 - **tmux** — hidden popup prompt without stealing the agent's TTY
 - **Herdr** — temporary password prompt pane that closes automatically
-- **Raw terminals** — `/dev/tty` fallback when no GUI or multiplexer is available
+- **Raw terminals** — `/dev/tty` fallback when an interactive shell owns the TTY
+- **Watch mode** — approve from a second terminal when a TUI/agent owns the TTY (e.g. `ssh` → coding agent → `sudo` with no tmux/Herdr)
 
 Supports Linux and macOS. Requires **Node.js 24+**. Bash is required for the
-tmux, Herdr, and `/dev/tty` backends; tmux and Herdr also require `mkfifo`.
+tmux, Herdr, `/dev/tty`, and watch backends; tmux, Herdr, and watch also require
+`mkfifo`.
 Linux GUI prompting requires either `zenity` or `kdialog`. Windows is not
 supported.
 
@@ -51,21 +53,31 @@ npm install -g sido-askpass && sido-askpass install --system
 System setup runs `sudo tee` to update `/etc/sudo.conf`, so the installation
 command itself must be run somewhere sudo can authenticate.
 
-For a single session without changing a profile or sudo configuration:
+After first setup, rerun the detected managed user and/or system installation
+without remembering its scope:
 
 ```bash
-export SUDO_ASKPASS=$(command -v sido-askpass)
+sido-askpass install
 ```
 
-Alternatively, inject `SUDO_ASKPASS` for one command:
+If no managed installation exists yet, `install` requires an explicit `--user`
+or `--system`.
+
+To use sido for one command without changing your profile or sudo
+configuration:
 
 ```bash
-sido-askpass run sudo -A <command>
+sido-askpass run -- sudo -A <command>
 ```
 
-Everything after `run` is run directly without shell parsing. `run` sets
+Everything after `--` is run directly without shell parsing. `run` sets
 `SUDO_ASKPASS` but does not add `-A` or otherwise rewrite the command, so pass
-`-A` explicitly when sudo must use askpass even if a TTY is available.
+`-A` explicitly when sudo must use askpass even if a TTY is available. Select
+an exact prompt adapter for the command with:
+
+```bash
+sido-askpass run --adapter watch -- sudo -A <command>
+```
 
 ## Using sudo
 
@@ -139,7 +151,7 @@ This gives Codex an actionable reason to retry with escalated permission.
 
 ## Prompt backend compatibility
 
-The first matching context is used:
+By default, `SIDO_ADAPTER=auto` uses the first matching context:
 
 | Context                      | Prompt method                                    | Status                  |
 | ---------------------------- | ------------------------------------------------ | ----------------------- |
@@ -147,7 +159,30 @@ The first matching context is used:
 | `$HERDR_ENV=1`               | Temporary Herdr pane with `read -s`; FIFO return | Tested on Linux         |
 | macOS                        | Hidden `osascript` dialog                        | Implemented, unverified |
 | Linux + `$DISPLAY` / Wayland | `zenity`, then `kdialog`                         | Tested on Linux         |
-| Other environment            | Hidden `read -s` prompt on `/dev/tty`            | Fallback                |
+| Canonical `/dev/tty`         | Hidden `read -s` prompt on `/dev/tty`            | Fallback                |
+| Raw/no TTY                   | Watch mode: park request + FIFO, `approve`       | New                     |
+
+Set `SIDO_ADAPTER` to bypass detection and require one exact adapter:
+
+| Adapter     | Behavior                                              |
+| ----------- | ----------------------------------------------------- |
+| `auto`      | Use the detection chain above; this is the default    |
+| `tmux`      | Open a hidden prompt in a tmux popup                  |
+| `herdr`     | Open a hidden prompt in a temporary Herdr pane        |
+| `osascript` | Open the native macOS password dialog; requires macOS |
+| `zenity`    | Open a Zenity password dialog                         |
+| `kdialog`   | Open a KDE password dialog                            |
+| `tty`       | Read a hidden password from `/dev/tty`                |
+| `watch`     | Wait for `sido-askpass approve` from another terminal |
+
+An explicitly selected adapter either succeeds or exits with an error. It never
+falls back to another adapter. `run` accepts the same selection as
+`--adapter <name>`:
+
+```bash
+SIDO_ADAPTER=osascript sudo -A <command>
+sido-askpass run --adapter tty -- sudo -A <command>
+```
 
 The prompt also shows the requesting command when the parent process command
 line is available. If process inspection is blocked, it silently shows the
@@ -155,8 +190,38 @@ normal password prompt without the command. The displayed command includes its
 arguments, which may reveal sensitive arguments to anyone who can see the
 prompt.
 
+## Watch mode
+
+When no inline prompt is safe — a coding agent's TUI owns the TTY in raw mode,
+or there is no TTY at all — `sido-askpass` parks the request and waits for a
+password from a second terminal:
+
+```bash
+sido-askpass approve   # approve the most recent pending request (one-shot)
+sido-askpass watch     # approve requests as they arrive (Ctrl-C to exit)
+```
+
+The original terminal prints a hint telling you which command to run. Requests
+live under `$XDG_RUNTIME_DIR/sido` (or `~/.cache/sido`); the password travels
+through a kernel FIFO, never a file. `SIDO_ADAPTER=watch` selects watch mode;
+`SIDO_WATCH_TIMEOUT=<sec>` sets how long it waits before giving up (default
+120).
+
 ## Status and removal
 
+Upgrade an npm installation to the latest version and refresh the user
+configuration:
+
+```bash
+sido-askpass upgrade
+```
+
+The upgrade command currently supports npm global installations only and
+rejects commands installed by another package manager. It checks the latest
+published version, upgrades only when that version is newer, then runs
+`sido-askpass install` to refresh the existing managed configuration. If npm
+fails, existing configuration is left unchanged.
+
 Inspect the active environment and installed configuration:
 
 ```bash
@@ -177,9 +242,11 @@ status. Omitting both is supported only by status.
 
 ## Security
 
-Password input is hidden. tmux and Herdr return the password through a kernel
-FIFO; GUI and TTY backends return it through process stdout. Each tmux or Herdr
-prompt uses a private temporary directory. Its FIFO, prompt, and helper script
+Password input is hidden. tmux, Herdr, and watch mode return the password
+through a kernel FIFO; GUI and TTY backends return it through process stdout.
+Each tmux, Herdr, or watch prompt uses a private directory (mode 0700 under
+`$XDG_RUNTIME_DIR/sido` for watch) with a mode-0600 FIFO. Its FIFO and prompt
 are accessible only to the current user and are removed when prompting ends.
-The temporary prompt file contains the displayed command and prompt, but never
-the password.
+Watch's approver feeds the password via stdin (`cat > fifo`), never argv, so it
+never appears in `ps`. The prompt file contains the displayed command and
+prompt, but never the password.

package/dist/sido-askpass.js

@@ -6,18 +6,33 @@
 import { spawnSync } from 'node:child_process'
 import {
   existsSync,
+  mkdirSync,
   mkdtempSync,
   readFileSync,
+  readdirSync,
+  realpathSync,
   rmSync,
+  statSync,
   writeFileSync,
 } from 'node:fs'
 import { tmpdir, userInfo, hostname, homedir } from 'node:os'
-import { join, resolve } from 'node:path'
+import { join, resolve, sep } from 'node:path'
 import { parseArgs } from 'node:util'
 import package_json from '../package.json' with { type: 'json' }
 
 const self_path = resolve(process.argv[1] )
 const command = process.argv[2]
+const adapters = [
+  'auto',
+  'tmux',
+  'herdr',
+  'osascript',
+  'zenity',
+  'kdialog',
+  'tty',
+  'watch',
+]         
+                                        
 
 if (command === '_inner_prompt_receiver') {
   const prompt_file = process.argv[3]
@@ -39,12 +54,30 @@ Repo:    https://github.com/patdx/sido-askpass
 
 Usage:
   sido-askpass                        askpass mode (invoked by sudo)
-  sido-askpass install --user|--system
+  sido-askpass install [--user|--system]
   sido-askpass uninstall --user|--system
+  sido-askpass upgrade                    upgrade an npm install and refresh its config
   sido-askpass status [--user|--system]
-  sido-askpass run <command> [args...]  run <command> with SUDO_ASKPASS set
+  sido-askpass run [--adapter <name>] -- <command> [args...]
+                                       run a command with SUDO_ASKPASS set
+  sido-askpass watch                    wait for and approve pending requests
+  sido-askpass approve                  approve the most recent pending request
   sido-askpass --help
-  sido-askpass --version`)
+  sido-askpass --version
+
+Adapters:
+  auto       detect the best adapter (default)
+  tmux       hidden prompt in a tmux popup
+  herdr      hidden prompt in a temporary Herdr pane
+  osascript  native macOS password dialog
+  zenity     Zenity password dialog
+  kdialog    KDE password dialog
+  tty        hidden prompt on /dev/tty
+  watch      approve from another terminal with "sido-askpass approve"
+
+Env:
+  SIDO_ADAPTER=<name>      select an adapter for askpass mode
+  SIDO_WATCH_TIMEOUT=<sec> approver wait timeout (default 120)`)
   process.exit(0)
 }
 
@@ -63,13 +96,18 @@ if (command === 'install' || command === 'uninstall') {
       system: { type: 'boolean' },
     },
   })
-  if ((values.user && values.system) || (!values.user && !values.system)) {
-    console.error(`[sido] usage: ${self_path} ${command} --user|--system`)
+  if (
+    (values.user && values.system) ||
+    (command === 'uninstall' && !values.user && !values.system)
+  ) {
+    const scope_usage =
+      command === 'install' ? '[--user|--system]' : '--user|--system'
+    console.error(`[sido] usage: ${self_path} ${command} ${scope_usage}`)
     process.exit(1)
   }
-  const scope = values.user ? '--user' : '--system'
+  const scope = values.user ? '--user' : values.system ? '--system' : undefined
   if (command === 'install') do_install(scope)
-  else do_uninstall(scope)
+  else do_uninstall(scope )
   process.exit(0)
 }
 
@@ -90,12 +128,23 @@ if (command === 'status') {
   process.exit(0)
 }
 
+if (command === 'upgrade') {
+  do_upgrade()
+}
+
 if (command === 'run') {
-  if (!process.argv[3]) {
-    console.error(`[sido] usage: ${self_path} run <command> [args...]`)
-    process.exit(1)
-  }
-  do_run(process.argv[3], process.argv.slice(4))
+  const run = parse_run_args(process.argv.slice(3))
+  do_run(run.command, run.args, run.adapter)
+}
+
+if (command === 'watch') {
+  do_watch()
+  process.exit(0)
+}
+
+if (command === 'approve') {
+  do_approve()
+  process.exit(0)
 }
 
 // ── askpass mode ───────────────────────────────────────────────────────────
@@ -114,6 +163,7 @@ const is_mac = process.platform === 'darwin'
 const is_linux = process.platform === 'linux'
 const has_display = !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY)
 const can_gui = is_mac || (is_linux && has_display)
+const selected_adapter = parse_adapter(process.env.SIDO_ADAPTER ?? 'auto')
 
                            
              
@@ -121,8 +171,8 @@ const can_gui = is_mac || (is_linux && has_display)
                      
  
 
-function create_prompt_resources()                  {
-  const dir = mkdtempSync(join(tmpdir(), 'sido-'))
+function create_prompt_resources(base         = tmpdir())                  {
+  const dir = mkdtempSync(join(base, 'sido-'))
   const fifo = join(dir, 'password')
   const result = spawnSync('mkfifo', ['-m', '600', fifo], {
     stdio: ['pipe', 'pipe', 'pipe'],
@@ -161,7 +211,7 @@ function read_stdout(r
   return r.stdout.toString().replace(/\r?\n$/, '')
 }
 
-function read_secret(prompt        )         {
+function read_secret(prompt        )                {
   const r = spawnSync(
     'bash',
     [
@@ -172,12 +222,15 @@ function read_secret(prompt        )         {
     ],
     { stdio: ['ignore', 'pipe', 'inherit'] },
   )
-  return read_stdout(r)
+  if (r.status !== 0 || !r.stdout || r.stdout.length === 0) return null
+  return r.stdout.toString().replace(/\r?\n$/, '')
 }
 
 function inner_prompt_receiver(prompt_file        , fifo        )       {
   const prompt = readFileSync(prompt_file, 'utf8')
-  writeFileSync(fifo, `${read_secret(prompt)}\n`)
+  const pw = read_secret(prompt)
+  if (pw == null) process.exit(1)
+  writeFileSync(fifo, `${pw}\n`)
 }
 
 function get_requesting_command()                     {
@@ -209,10 +262,55 @@ function get_requesting_command()                     {
 }
 
 function main()       {
+  if (selected_adapter !== 'auto') return void adapter_prompt(selected_adapter)
   if (is_tmux) return void tmux_prompt()
-  if (is_herdr) return void herdr_prompt()
+  if (is_herdr) return void herdr_prompt(true)
   if (can_gui) return void gui_prompt()
-  tty_prompt()
+  if (interactive_shell_tty() && tty_prompt()) return
+  watch_prompt()
+}
+
+function adapter_prompt(adapter                          )       {
+  if (adapter === 'tmux') return void tmux_prompt()
+  if (adapter === 'herdr') return void herdr_prompt(false)
+  if (adapter === 'osascript') {
+    if (!is_mac) adapter_unavailable(adapter, 'requires macOS')
+    return void mac_gui()
+  }
+  if (adapter === 'zenity')
+    return void exact_gui_prompt('zenity', [
+      '--password',
+      '--title',
+      display_prompt,
+    ])
+  if (adapter === 'kdialog')
+    return void exact_gui_prompt('kdialog', ['--password', display_prompt])
+  if (adapter === 'tty') {
+    if (!tty_prompt()) adapter_unavailable(adapter, 'could not read /dev/tty')
+    return
+  }
+  watch_prompt()
+}
+
+function adapter_unavailable(adapter         , detail        )        {
+  console.error(`[sido] ${adapter} adapter unavailable: ${detail}`)
+  process.exit(1)
+}
+
+// Returns true when /dev/tty is our controlling terminal and it is in canonical
+// mode (a normal interactive shell owns it) — i.e. safe to read a password
+// inline. A raw-mode tty means a TUI/agent owns the screen, and no tty at all
+// means headless; both fall through to watch mode. `stty -a` is read-only, so
+// it never disturbs the owning application's terminal state.
+function interactive_shell_tty()          {
+  const r = spawnSync('bash', ['-c', 'stty -a < /dev/tty 2>/dev/null'], {
+    stdio: ['ignore', 'pipe', 'inherit'],
+  })
+  if (r.status !== 0) return false
+  const out = r.stdout?.toString() ?? ''
+  // Linux prints `icanon`/`echo`; BSD/macOS prints `canon`/`echo`. Negated
+  // flags are prefixed with `-`, which the lookbehind excludes.
+  return /(?<!-)(?:i?canon)\b/.test(out) && /(?<!-)echo\b/.test(out)
 }
 
 function sudo_conf_path()         {
@@ -223,9 +321,52 @@ function user_profile_path()         {
   return join(homedir(), '.profile')
 }
 
-function do_run(command        , args          )        {
+function parse_adapter(value        )          {
+  if ((adapters                     ).includes(value)) return value           
+  console.error(
+    `[sido] unknown adapter "${value}"; expected one of: ${adapters.join(', ')}`,
+  )
+  process.exit(1)
+}
+
+function parse_run_args(args          )   
+                 
+                
+                   
+  {
+  const separator = args.indexOf('--')
+  if (separator === -1 || !args[separator + 1]) {
+    console.error(
+      `[sido] usage: ${self_path} run [--adapter <name>] -- <command> [args...]`,
+    )
+    process.exit(1)
+  }
+
+  let adapter_value                    
+  try {
+    adapter_value = parseArgs({
+      args: args.slice(0, separator),
+      options: { adapter: { type: 'string' } },
+    }).values.adapter
+  } catch (error) {
+    console.error(`[sido] ${String(error)}`)
+    process.exit(1)
+  }
+
+  return {
+    command: args[separator + 1] ,
+    args: args.slice(separator + 2),
+    ...(adapter_value ? { adapter: parse_adapter(adapter_value) } : {}),
+  }
+}
+
+function do_run(command        , args          , adapter          )        {
   const proc = spawnSync(command, args, {
-    env: { ...process.env, SUDO_ASKPASS: self_path },
+    env: {
+      ...process.env,
+      SUDO_ASKPASS: self_path,
+      ...(adapter ? { SIDO_ADAPTER: adapter } : {}),
+    },
     stdio: 'inherit',
   })
   if (proc.error) {
@@ -238,7 +379,174 @@ function do_run(command        , args          )        {
   process.exit(proc.status ?? 1)
 }
 
-function do_install(scope        )       {
+function compare_semver(left        , right        )                     {
+  const parse = (value        ) => {
+    const match = value.match(
+      /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/,
+    )
+    if (!match) return
+    return {
+      core: [Number(match[1]), Number(match[2]), Number(match[3])],
+      prerelease: match[4]?.split('.'),
+    }
+  }
+  const a = parse(left)
+  const b = parse(right)
+  if (!a || !b) return
+  for (let i = 0; i < a.core.length; i++) {
+    if (a.core[i]  !== b.core[i] ) return a.core[i]  < b.core[i]  ? -1 : 1
+  }
+  if (!a.prerelease && !b.prerelease) return 0
+  if (!a.prerelease) return 1
+  if (!b.prerelease) return -1
+  const length = Math.max(a.prerelease.length, b.prerelease.length)
+  for (let i = 0; i < length; i++) {
+    const x = a.prerelease[i]
+    const y = b.prerelease[i]
+    if (x === undefined) return -1
+    if (y === undefined) return 1
+    if (x === y) continue
+    const x_numeric = /^\d+$/.test(x)
+    const y_numeric = /^\d+$/.test(y)
+    if (x_numeric && y_numeric) return Number(x) < Number(y) ? -1 : 1
+    if (x_numeric !== y_numeric) return x_numeric ? -1 : 1
+    return x < y ? -1 : 1
+  }
+  return 0
+}
+
+function has_managed_user_install()          {
+  const path = user_profile_path()
+  return (
+    existsSync(path) &&
+    /^# sido\nexport SUDO_ASKPASS=.*$/m.test(readFileSync(path, 'utf8'))
+  )
+}
+
+function has_managed_system_install()          {
+  const path = sudo_conf_path()
+  if (!existsSync(path)) return false
+  const result = spawnSync('cat', [path], { stdio: ['pipe', 'pipe', 'pipe'] })
+  return /^# sido\nPath askpass .*$/m.test(result.stdout?.toString() ?? '')
+}
+
+function require_npm_install()       {
+  const root = spawnSync('npm', ['root', '--global'], {
+    stdio: ['inherit', 'pipe', 'inherit'],
+    encoding: 'utf8',
+  })
+  if (root.error || root.status !== 0) {
+    console.error('[sido] upgrade requires npm and an npm global installation')
+    process.exit(1)
+  }
+
+  try {
+    const package_path = realpathSync(join(root.stdout.trim(), 'sido-askpass'))
+    const executable_path = realpathSync(self_path)
+    if (
+      executable_path !== package_path &&
+      !executable_path.startsWith(`${package_path}${sep}`)
+    ) {
+      throw new Error('outside npm package')
+    }
+  } catch {
+    console.error(
+      '[sido] upgrade supports npm global installations only; use the original package manager to upgrade',
+    )
+    process.exit(1)
+  }
+}
+
+function do_upgrade()        {
+  require_npm_install()
+  const latest_result = spawnSync(
+    'npm',
+    ['view', 'sido-askpass@latest', 'version', '--json'],
+    { stdio: ['inherit', 'pipe', 'inherit'], encoding: 'utf8' },
+  )
+  if (latest_result.error) {
+    console.error(
+      `[sido] could not check npm for upgrades: ${latest_result.error.message}`,
+    )
+    process.exit(1)
+  }
+  if (latest_result.status !== 0) {
+    console.error(
+      `[sido] could not check npm for upgrades (status ${latest_result.status})`,
+    )
+    process.exit(latest_result.status ?? 1)
+  }
+
+  let latest        
+  try {
+    const value          = JSON.parse(latest_result.stdout)
+    if (typeof value !== 'string') throw new Error('not a version string')
+    latest = value
+  } catch {
+    console.error('[sido] npm returned an invalid latest version')
+    process.exit(1)
+  }
+
+  const comparison = compare_semver(package_json.version, latest)
+  if (comparison === undefined) {
+    console.error(
+      `[sido] cannot compare versions ${package_json.version} and ${latest}`,
+    )
+    process.exit(1)
+  }
+  if (comparison >= 0) {
+    console.error(
+      `[sido] already up to date (${package_json.version}; npm latest is ${latest})`,
+    )
+    process.exit(0)
+  }
+
+  console.error(
+    `[sido] upgrading ${package_json.version} to ${latest} with npm`,
+  )
+  const upgrade = spawnSync(
+    'npm',
+    ['install', '--global', 'sido-askpass@latest'],
+    { stdio: 'inherit' },
+  )
+  if (upgrade.error) {
+    console.error(`[sido] npm upgrade failed: ${upgrade.error.message}`)
+    process.exit(1)
+  }
+  if (upgrade.status !== 0) {
+    console.error(`[sido] npm upgrade failed with status ${upgrade.status}`)
+    process.exit(upgrade.status ?? 1)
+  }
+
+  console.error('[sido] refreshing managed configuration')
+  const install = spawnSync(self_path, ['install'], {
+    stdio: 'inherit',
+  })
+  if (install.error) {
+    console.error(
+      `[sido] upgraded, but configuration refresh failed: ${install.error.message}`,
+    )
+    process.exit(1)
+  }
+  process.exit(install.status ?? 1)
+}
+
+function do_install(scope         )       {
+  if (!scope) {
+    const scopes = [
+      ...(has_managed_user_install() ? ['--user'] : []),
+      ...(has_managed_system_install() ? ['--system'] : []),
+    ]
+    if (scopes.length === 0) {
+      console.error(
+        `[sido] no existing installation found; use: ${self_path} install --user|--system`,
+      )
+      process.exit(1)
+    }
+    for (const existing_scope of scopes) do_install(existing_scope)
+    return
+  }
+
   if (scope === '--user') {
     const path = user_profile_path()
     const line = `export SUDO_ASKPASS="${self_path}"`
@@ -447,7 +755,7 @@ function tmux_prompt()       {
 // herdr pane run. Shell job control (&, wait) keeps coordination in one sync
 // call and reaps the background cat on cancel.
 
-function herdr_prompt()       {
+function herdr_prompt(allow_fallback         )       {
   let direction = 'right'
   try {
     const layout = spawnSync('herdr', ['pane', 'layout', '--current'], {
@@ -468,10 +776,10 @@ function herdr_prompt()       {
     ['pane', 'split', '--current', '--direction', direction, '--cwd', '/'],
     { stdio: ['inherit', 'pipe', 'pipe'] },
   )
-  if (split.status !== 0) return void fallback_herdr()
+  if (split.status !== 0) return void fallback_herdr(allow_fallback)
   const pane_id = JSON.parse(split.stdout?.toString() ?? '{}').result?.pane
     ?.pane_id
-  if (!pane_id) return void fallback_herdr()
+  if (!pane_id) return void fallback_herdr(allow_fallback)
 
   let resources                 
   try {
@@ -511,10 +819,12 @@ function herdr_prompt()       {
   process.stdout.write(read_stdout(r))
 }
 
-function fallback_herdr()       {
+function fallback_herdr(allow_fallback         )       {
+  if (!allow_fallback) adapter_unavailable('herdr', 'herdr pane split failed')
   console.error('[sido] herdr pane split failed, falling back')
   if (can_gui) return void gui_prompt()
-  tty_prompt()
+  if (tty_prompt()) return
+  watch_prompt()
 }
 
 // ── GUI (macOS / Linux) ────────────────────────────────────────────────────
@@ -525,18 +835,20 @@ function gui_prompt()       {
 }
 
 function mac_gui()       {
+  const dialog_title = 'Administrator Authentication'
   const r = spawnSync(
     'osascript',
     [
       '-e',
       'on run argv',
       '-e',
-      'display dialog (item 1 of argv) with hidden answer default answer ""',
+      'display dialog (item 1 of argv) with title (item 2 of argv) with icon caution with hidden answer default answer "" buttons {"Cancel", "Authenticate"} default button "Authenticate" cancel button "Cancel"',
       '-e',
       'text returned of result',
       '-e',
       'end run',
       display_prompt,
+      dialog_title,
     ],
     { stdio: ['inherit', 'pipe', 'inherit'] },
   )
@@ -550,20 +862,168 @@ function linux_gui()       {
     ['kdialog', '--password', display_prompt],
   ]) {
     const [cmd, ...args] = prog                         
-    const r = spawnSync(cmd, args, { stdio: ['inherit', 'pipe', 'inherit'] })
-    if (r.status === 0) {
-      process.stdout.write(r.stdout?.toString().replace(/\n$/, '') ?? '')
-      return
-    }
+    if (gui_program_prompt(cmd, args)) return
   }
   console.error('[sido] no GUI dialog found')
-  tty_prompt()
+  if (tty_prompt()) return
+  watch_prompt()
+}
+
+function exact_gui_prompt(command        , args          )       {
+  if (!gui_program_prompt(command, args))
+    adapter_unavailable(
+      command           ,
+      `${command} failed or was cancelled`,
+    )
+}
+
+function gui_program_prompt(command        , args          )          {
+  const r = spawnSync(command, args, {
+    stdio: ['inherit', 'pipe', 'inherit'],
+  })
+  if (r.status !== 0) return false
+  process.stdout.write(r.stdout?.toString().replace(/\n$/, '') ?? '')
+  return true
 }
 
 // ── TTY fallback ───────────────────────────────────────────────────────────
 
-function tty_prompt()       {
-  process.stdout.write(read_secret(display_prompt))
+function tty_prompt()          {
+  const pw = read_secret(display_prompt)
+  if (pw == null) return false
+  process.stdout.write(pw)
+  return true
+}
+
+// ── Watch mode (fallback for raw/headless ttys) ────────────────────────────
+//
+// When no inline surface is safe (a TUI/agent owns the tty in raw mode, or
+// there is no tty at all), park the request in a user-private dir and block on
+// a FIFO. A second terminal runs `sido approve` / `sido watch` to supply the
+// password, which is written through the FIFO — never to disk, never to the
+// agent transcript. This is agent-agnostic: it works for opencode, Codex, Pi,
+// plain SSH, and headless scripts alike.
+
+function sido_dir()         {
+  const base = process.env.XDG_RUNTIME_DIR || join(homedir(), '.cache')
+  const dir = join(base, 'sido')
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 })
+  return dir
+}
+
+function watch_timeout_ms()         {
+  const raw = Number(process.env.SIDO_WATCH_TIMEOUT)
+  if (Number.isFinite(raw) && raw > 0) return raw * 1000
+  return 120_000
+}
+
+function watch_prompt()       {
+  let resources                 
+  try {
+    resources = create_prompt_resources(sido_dir())
+  } catch (error) {
+    console.error(`[sido] ${String(error)}`)
+    process.exit(1)
+  }
+
+  const timeout_ms = watch_timeout_ms()
+  console.error(
+    `[sido] password requested${requesting_command ? ` for: ${requesting_command}` : ''}`,
+  )
+  console.error(
+    `[sido] from another terminal run: ${self_path} approve  (waiting up to ${Math.round(timeout_ms / 1000)}s)`,
+  )
+
+  // External `cat` opens the FIFO read-only and blocks until a writer (the
+  // approver) connects. spawnSync's timeout kills it if nobody approves in time
+  // — avoiding libuv's uncancellable threadpool open() on a FIFO.
+  let r
+  try {
+    r = spawnSync('bash', ['-c', 'cat "$1"', 'sido', resources.fifo], {
+      stdio: ['ignore', 'pipe', 'inherit'],
+      timeout: timeout_ms,
+      killSignal: 'SIGTERM',
+    })
+  } finally {
+    remove_prompt_resources(resources)
+  }
+
+  if (r .signal === 'SIGTERM' || r .status === null) {
+    console.error('[sido] timed out waiting for approver')
+    process.exit(1)
+  }
+  process.stdout.write(read_stdout(r ))
+}
+
+function do_watch()       {
+  console.error(
+    `[sido] watching ${sido_dir()} for password requests (Ctrl-C to exit)`,
+  )
+  while (true) {
+    const req = newest_request()
+    if (req) handle_request(req)
+    else spawnSync('sleep', ['1'], { stdio: ['ignore', 'ignore', 'inherit'] })
+  }
+}
+
+function do_approve()       {
+  const req = newest_request()
+  if (!req) {
+    console.error('[sido] no pending password requests')
+    process.exit(0)
+  }
+  handle_request(req)
+}
+
+function newest_request()                     {
+  let entries          
+  try {
+    entries = readdirSync(sido_dir())
+  } catch {
+    return undefined
+  }
+  let newest                    
+  let newest_mtime = -Infinity
+  for (const entry of entries) {
+    if (!entry.startsWith('sido-')) continue
+    const path = join(sido_dir(), entry)
+    const m = statSync(path).mtimeMs
+    if (m > newest_mtime) {
+      newest_mtime = m
+      newest = path
+    }
+  }
+  return newest
+}
+
+function handle_request(req_dir        )       {
+  let prompt = '[sudo] password: '
+  try {
+    prompt = readFileSync(join(req_dir, 'prompt'), 'utf8')
+  } catch {}
+
+  const password = read_secret(prompt)
+  if (password == null) {
+    console.error('[sido] no password entered')
+    process.exit(1)
+  }
+
+  // Feed the password via stdin, not argv, so it never appears in `ps`. The
+  // redirection opens the FIFO write-only and blocks until the waiting shim's
+  // reader connects; the timeout covers a shim that already exited/timed out.
+  const r = spawnSync(
+    'bash',
+    ['-c', 'cat > "$1"', 'sido', join(req_dir, 'password')],
+    {
+      input: `${password}\n`,
+      stdio: ['pipe', 'pipe', 'inherit'],
+      timeout: 5_000,
+    },
+  )
+  console.error(
+    r.status === 0 ? '[sido] password sent' : '[sido] request expired',
+  )
+  rmSync(req_dir, { recursive: true, force: true })
 }
 
 main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sido-askpass",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "SUDO_ASKPASS shim for headless agent environments (tmux, Herdr, GUI, TTY)",
   "license": "MIT",
   "type": "module",