@realtimex/rtxexec 0.1.0 → 0.3.0

package/README.md

@@ -41,3 +41,115 @@ when the installed launcher is a .cmd/.bat file. Shell pipelines must be compose
 explicitly; the wrapper does not interpret shell syntax.
 
 `npm test` runs isolated fixtures. `npm pack --dry-run` validates package contents.
+
+
+## Browser Login credentials (0.2.0)
+
+Create a **Login** in RealTimeX Settings > Secrets (encrypted username/password,
+login URL and exact allowed origins). Management belongs to the moderator CLI;
+rtxexec only uses credentials. Browser operations require Node.js 22 or newer.
+
+Prepare the page using agent-browser on your existing RealTimeX browser. Then:
+
+```sh
+rtxexec browser-tabs --cdp 9235
+rtxexec browser-login secret://company-login --cdp 9235 --tab <target-id> \
+  --username-selector '#username' --password-selector '#password' \
+  --submit-selector 'button[type=submit]'
+```
+
+Use the full target ID from `browser-tabs`, not agent-browser's `t1`/`t2` alias.
+The command never navigates or chooses a tab automatically. Each CSS selector must
+match exactly one visible top-level form control. Iframe forms are not supported.
+For two-step logins, specify only the username selector first, then prepare the
+password step and run again with only its selector. Omit submit to fill only.
+A `filled` or `submitted` result does not prove authentication: verify a non-secret
+success state separately. MFA and CAPTCHA stay in the normal browser workflow.
+
+This works with agent-browser 0.27.0 because it uses the local CDP connection
+instead of unsupported credential-provider flags. Values are passed as CDP
+arguments in an isolated execution context, never inserted into JavaScript source,
+saved in another vault, or printed in normal output. Scope, enabled state and exact
+origin are checked before resolution; the form's origin/action is rechecked during
+filling. History records resolution with browser origin/target and terminal context,
+not an assertion that login succeeded.
+
+The destination/browser necessarily receives the values. Do not take snapshots,
+screenshots, recordings, DOM-value reads, or network traces while credentials are
+present. A page may display a username after login. This reduces accidental exposure;
+it does not prevent intentional local extraction or malicious website behavior.
+
+
+## Structured credential items
+
+RealTimeX stores Login, Card, Identity, SSH key and Secure note items. Management
+stays in Settings or the moderator CLI; rtxexec only uses saved values.
+List metadata to discover `reference` and `fieldNames`. To select a field:
+
+```sh
+rtxexec --env API_TOKEN=secret://service#apiToken -- program
+rtxexec --stdin secret://note#notes -- program
+```
+
+A Login can contain just a password, the built-in API key / Token (`apiToken`),
+or custom fields; a username and website are optional for terminal use. New Login
+defaults to password when present, otherwise `apiToken`; Secure note defaults to
+notes. Existing scalar references keep their value. An explicit move into Password
+or API key / Token preserves both default and `#value` references, including after
+rotation.
+Use explicit field references for Card, Identity and SSH items.
+
+### Fill Card or Identity forms
+
+Prepare a page with agent-browser, identify its visible top-level selectors,
+and use the exact CDP target ID from `browser-tabs`:
+
+```sh
+rtxexec browser-fill secret://card --cdp 9235 --tab TARGET_ID \
+  --field 'number=#card-number' --field 'securityCode=#cvv'
+```
+
+Only mapped fields are requested. The item's permitted origins and workspace
+scope are enforced. Inputs, textareas and selects are supported; iframe forms
+are not. This command never submits. Check non-secret status and perform any
+submission separately within the authorized task. Avoid snapshots, recordings
+and field-value reads while saved data is in the page. `browser-login` remains
+available and now requests only the username/password fields selected.
+
+### SSH and Git
+
+```sh
+rtxexec ssh secret://deploy-key -- ssh user@host
+rtxexec ssh secret://deploy-key -- git fetch origin
+```
+
+Requires OpenSSH (and Git for Git commands). The app unlocks the saved key for
+this execution. rtxexec writes it to a restricted temporary directory, supplies
+the path to SSH or Git, and removes the directory when the child finishes or
+fails. Unix uses directory mode 0700 and file mode 0600; Windows requires icacls
+to restrict the directory before writing. Existing host-key verification stays
+in effect. SIGKILL or a machine crash may prevent cleanup. The CLI keeps no
+persistent vault or secret cache. Output masking is best effort; this is an
+accidental-disclosure safeguard, not a boundary against deliberate local access.
+
+## Linked SSO logins
+
+A Login can keep its normal username/password and link multiple saved Login items
+for SSO. Management uses `ssoCredentialIds` (moderator flag
+`--sso-credential-ids id1,id2`; an empty flag clears links). Names and descriptions
+identify the provider and account; no separate provider instructions are needed.
+
+Use agent-browser to choose the matching sign-in button and reach the provider.
+Then explicitly select the linked Login:
+
+```sh
+rtxexec browser-login secret://rtgit --sso secret://google \
+  --cdp 9235 --tab TARGET_ID \
+  --username-selector '#username' --password-selector '#password'
+```
+
+The server checks both items' enabled state and workspace scope, and the provider's
+allowed website origin. It records usage for both without copying values into the
+site item. Omitting `--sso` uses normal credentials; selection never automatically
+follows further links. Ask when the provider/account is ambiguous, and handle
+already signed-in sessions or MFA through the normal browser workflow.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@realtimex/rtxexec",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Run commands with secrets from the RealTimeX app vault",
   "type": "module",
   "bin": { "rtxexec": "bin/rtxexec.js" },

package/src/browser.js

@@ -0,0 +1,179 @@
+import { UsageError } from './error.js';
+import { resolveSecrets } from './client.js';
+
+export function parseBrowserArguments(argv) {
+  const command = argv[0];
+  const options = {};
+  let reference;
+  let i = 1;
+  if (command !== 'browser-tabs') reference = argv[i++];
+  const allowed = command === 'browser-tabs' ? ['cdp'] : command === 'browser-fill' ? ['cdp', 'tab', 'field', 'sso'] : ['cdp', 'tab', 'username-selector', 'password-selector', 'submit-selector', 'sso'];
+  for (; i < argv.length; i += 2) {
+    const key = argv[i]?.replace(/^--/, '');
+    if (!argv[i]?.startsWith('--') || !allowed.includes(key) || (key !== 'field' && options[key] !== undefined) || !argv[i + 1] || argv[i + 1].startsWith('--')) throw new UsageError('Invalid browser option. See rtxexec --help.');
+    if (key === 'field') {
+      const value = argv[i + 1]; const split = value.indexOf('=');
+      const field = value.slice(0, split); const selector = value.slice(split + 1);
+      if (split < 1 || !/^[A-Za-z][A-Za-z0-9_]{0,63}$/.test(field) || !selector || selector.length > 4096 || ['constructor', 'prototype', '__proto__'].includes(field)) throw new UsageError('Use --field fieldName=selector.');
+      options.fields ||= [];
+      if (options.fields.some((entry) => entry.name === field || entry.selector === selector) || options.fields.length >= 32) throw new UsageError('Use up to 32 distinct fields and selectors.');
+      options.fields.push({ name: field, selector });
+    } else options[key] = argv[i + 1];
+  }
+  if (!/^\d{1,5}$/.test(options.cdp || '') || Number(options.cdp) < 1 || Number(options.cdp) > 65535) throw new UsageError('Provide a local CDP port with --cdp.');
+  if (command === 'browser-login' && (!reference?.startsWith('secret://') || !/^[a-zA-Z0-9_-]{1,128}$/.test(options.tab || '') || (!options['username-selector'] && !options['password-selector']))) throw new UsageError('Provide a secret reference, --tab from browser-tabs, and at least one username/password selector.');
+  if (command === 'browser-fill' && (!reference?.startsWith('secret://') || reference.includes('#') || !/^[a-zA-Z0-9_-]{1,128}$/.test(options.tab || '') || !options.fields?.length)) throw new UsageError('Provide an item reference, --tab and at least one --field name=selector.');
+  if (options.sso && (!options.sso.startsWith('secret://') || options.sso.includes('#') || options.sso.length > 1024)) throw new UsageError('Use --sso secret://provider with a linked Login item.');
+  return { command, reference, ...options };
+}
+
+export async function browserTargets(port, fetchImpl = fetch) {
+  const response = await fetchImpl(`http://127.0.0.1:${port}/json/list`, { redirect: 'error', signal: AbortSignal.timeout(5000) });
+  if (!response.ok) throw new UsageError('Could not list browser tabs.');
+  let targets;
+  try { targets = await response.json(); } catch { throw new UsageError('Invalid CDP target response.'); }
+  if (!Array.isArray(targets)) throw new UsageError('Invalid CDP target response.');
+  return targets.filter((target) => {
+    try {
+      const url = new URL(target.url);
+      return target.type === 'page' && ['http:', 'https:'].includes(url.protocol) && url.pathname !== '/cli-browser/index.html';
+    } catch { return false; }
+  });
+}
+
+export async function connectCdp(address, port, WebSocketImpl = globalThis.WebSocket) {
+  if (!WebSocketImpl) throw new UsageError('Browser login requires Node.js 22 or newer.');
+  const url = new URL(address);
+  if (url.protocol !== 'ws:' || !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname) || url.port !== String(Number(port)) || url.username || url.password) throw new UsageError('CDP must use the selected local browser port.');
+  const socket = new WebSocketImpl(url);
+  const pending = new Map(); let nextId = 0;
+  const rejectAll = () => { for (const entry of pending.values()) { clearTimeout(entry.timer); entry.reject(new Error('CDP connection ended')); } pending.clear(); };
+  socket.addEventListener('close', rejectAll);
+  socket.addEventListener('error', rejectAll);
+  socket.addEventListener('message', ({ data }) => {
+    let message; try { message = JSON.parse(data); } catch { return; }
+    const entry = pending.get(message.id); if (!entry) return;
+    pending.delete(message.id); clearTimeout(entry.timer);
+    if (message.error) entry.reject(new Error('CDP operation failed'));
+    else entry.resolve(message.result);
+  });
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { socket.close(); reject(new Error('CDP connection timeout')); }, 5000);
+    socket.addEventListener('open', () => { clearTimeout(timer); resolve(); }, { once: true });
+    socket.addEventListener('error', () => { clearTimeout(timer); reject(new Error('CDP connection failed')); }, { once: true });
+  });
+  return {
+    send(method, params = {}) {
+      return new Promise((resolve, reject) => {
+        const id = ++nextId;
+        const timer = setTimeout(() => { pending.delete(id); reject(new Error('CDP operation timeout')); }, 10000);
+        pending.set(id, { resolve, reject, timer });
+        socket.send(JSON.stringify({ id, method, params }));
+      });
+    },
+    close() { rejectAll(); socket.close(); },
+  };
+}
+
+// Fixed code executed in an isolated world. Values travel only as CDP arguments,
+// never interpolated into source or returned to the caller. Top-level forms only.
+export function fillLogin(username, password, selectors, expectedOrigin) {
+  const sameOrigin = () => location.origin === expectedOrigin;
+  const find = (selector) => { if (!selector) return null; const matches = document.querySelectorAll(selector); return matches.length === 1 ? matches[0] : null; };
+  const user = find(selectors.username); const pass = find(selectors.password); const submit = find(selectors.submit);
+  const fields = [[user, username, selectors.username], [pass, password, selectors.password]];
+  const safeForm = (element) => !element?.form || new URL(element.form.action || location.href).origin === expectedOrigin;
+  const usable = (element) => {
+    if (!element || element.disabled || element.matches(':disabled') || element.getClientRects().length === 0) return false;
+    const style = getComputedStyle(element);
+    if (style.visibility !== 'visible') return false;
+    for (let node = element; node; node = node.parentElement) {
+      if (Number(getComputedStyle(node).opacity) === 0) return false;
+    }
+    return true;
+  };
+  if (!sameOrigin()) return { error: 'origin' };
+  for (const [element, , selector] of fields) {
+    if (!selector) continue;
+    if (!(element instanceof HTMLInputElement) || element.readOnly || !usable(element) || !safeForm(element)) return { error: 'field' };
+  }
+  if (pass && pass.type !== 'password') return { error: 'password-field' };
+  if (selectors.submit && (!usable(submit) || !safeForm(submit) || (submit.formAction && new URL(submit.formAction).origin !== expectedOrigin))) return { error: 'submit' };
+  const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value').set;
+  for (const [element, value, selector] of fields) {
+    if (!selector) continue;
+    if (!sameOrigin() || !element.isConnected || !usable(element) || element.readOnly || (element === pass && element.type !== "password") || !safeForm(element)) return { error: 'changed' };
+    setter.call(element, value);
+    element.dispatchEvent(new Event('input', { bubbles: true }));
+    element.dispatchEvent(new Event('change', { bubbles: true }));
+  }
+  if (submit) {
+    if (!sameOrigin() || !submit.isConnected || !usable(submit) || !safeForm(submit) || (submit.formAction && new URL(submit.formAction).origin !== expectedOrigin)) return { error: 'changed' };
+    submit.click();
+  }
+  return { status: submit ? 'submitted' : 'filled' };
+}
+
+
+// Fill-only: submission remains an explicit, separate browser action.
+export function fillFields(values, selectors, expectedOrigin) {
+  const usable = (element) => {
+    if (!element || !element.isConnected || element.disabled || element.matches(':disabled') || element.readOnly || !element.getClientRects().length) return false;
+    if (getComputedStyle(element).visibility !== 'visible') return false;
+    for (let node = element; node; node = node.parentElement) if (Number(getComputedStyle(node).opacity) === 0) return false;
+    return !element.form || new URL(element.form.action || location.href).origin === expectedOrigin;
+  };
+  if (location.origin !== expectedOrigin) return { error: 'origin' };
+  const fields = [];
+  for (const { name, selector } of selectors) {
+    const matches = document.querySelectorAll(selector);
+    const element = matches.length === 1 ? matches[0] : null;
+    if (!usable(element) || !(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement)) return { error: 'field' };
+    if (element instanceof HTMLInputElement && ['file', 'hidden', 'checkbox', 'radio', 'button', 'submit', 'reset', 'image'].includes(element.type)) return { error: 'field' };
+    if (name === 'password' && (!(element instanceof HTMLInputElement) || element.type !== 'password')) return { error: 'password-field' };
+    if (element instanceof HTMLSelectElement && !Array.from(element.options).some(option => option.value === values[name] && !option.disabled)) return { error: 'option' };
+    if (fields.some(entry => entry.element === element)) return { error: 'duplicate' };
+    fields.push({ element, name, type: element.type });
+  }
+  for (const { element, name, type } of fields) {
+    if (location.origin !== expectedOrigin || !usable(element) || element.type !== type) return { error: 'changed' };
+    const prototype = element instanceof HTMLInputElement ? HTMLInputElement.prototype : element instanceof HTMLSelectElement ? HTMLSelectElement.prototype : HTMLTextAreaElement.prototype;
+    Object.getOwnPropertyDescriptor(prototype, 'value').set.call(element, values[name]);
+    if (element.value !== values[name]) return { error: 'value' };
+    element.dispatchEvent(new Event('input', { bubbles: true }));
+    element.dispatchEvent(new Event('change', { bubbles: true }));
+  }
+  return { status: 'filled' };
+}
+
+export async function runBrowser(plan, env, { targets = browserTargets, connect = connectCdp, resolver = resolveSecrets } = {}) {
+  const pages = await targets(plan.cdp);
+  if (plan.command === 'browser-tabs') return { tabs: pages.map(({ id, url }) => { const clean = new URL(url); clean.search = ''; clean.hash = ''; clean.username = ''; clean.password = ''; return { id, url: clean.href }; }) };
+  const target = pages.find(({ id }) => id === plan.tab);
+  if (!target) throw new UsageError('Selected browser tab is unavailable. Run browser-tabs again.');
+  const cdp = await connect(target.webSocketDebuggerUrl, plan.cdp);
+  try {
+    const { frameTree } = await cdp.send('Page.getFrameTree');
+    let origin;
+    try {
+      const url = new URL(frameTree?.frame?.url);
+      if (!['http:', 'https:'].includes(url.protocol)) throw new Error();
+      origin = url.origin;
+    } catch { throw new UsageError('Selected page is not ready. Wait for navigation and run browser-tabs again.'); }
+    const { executionContextId } = await cdp.send('Page.createIsolatedWorld', { frameId: frameTree.frame.id, worldName: 'rtxexec-login' });
+    const requested = plan.command === 'browser-fill' ? plan.fields.map(entry => entry.name) : ['username', 'password'].filter(name => plan[`${name}-selector`]);
+    const values = await resolver({ references: [plan.reference], command: 'rtxexec', browser: { origin, targetId: target.id, fields: requested, ...(plan.sso ? { ssoReference: plan.sso } : {}) } }, env);
+    const credential = values[0];
+    const fields = credential?.fields || credential;
+    if (requested.some(name => typeof fields?.[name] !== 'string' || !fields[name]) || !Array.isArray(credential?.allowedOrigins) || !credential.allowedOrigins.includes(origin)) throw new UsageError('RealTimeX did not authorize the requested fields for this website.');
+    const args = plan.command === 'browser-fill'
+      ? [Object.fromEntries(requested.map(name => [name, fields[name]])), plan.fields, origin]
+      : [fields.username || '', fields.password || '', { username: plan['username-selector'], password: plan['password-selector'], submit: plan['submit-selector'] }, origin];
+    const result = await cdp.send('Runtime.callFunctionOn', {
+      executionContextId, functionDeclaration: (plan.command === 'browser-fill' ? fillFields : fillLogin).toString(), returnByValue: true,
+      arguments: args.map((value) => ({ value })),
+    });
+    if (result.exceptionDetails || !['filled', 'submitted'].includes(result.result?.value?.status)) throw new UsageError('Form fill was not completed. Check the selected page, origin and visible form selectors; values were not printed.');
+    return { status: result.result.value.status, targetId: target.id, origin };
+  } finally { cdp.close(); }
+}

package/src/cli.js

@@ -1,3 +1,5 @@
+import { parseBrowserArguments, runBrowser } from "./browser.js";
+import { parseSshArguments, runSsh } from "./ssh.js";
 import { UsageError } from "./error.js";
 import { spawn } from 'node:child_process';
 import { constants } from 'node:os';
@@ -14,6 +16,24 @@ Usage: rtxexec [bindings] -- executable [arguments]
   --secret alias=secret://name   Substitute {{alias}} inside argument values
   --stdin secret://name          Write the exact value to child stdin, then close it
 
+Browser use (Node.js 22+, existing local CDP browser):
+  rtxexec browser-tabs --cdp <port>
+  rtxexec browser-login secret://name --cdp <port> --tab <CDP-target-id>
+    --username-selector <css> --password-selector <css> [--submit-selector <css>]
+  rtxexec browser-fill secret://name --cdp <port> --tab <CDP-target-id>
+    --field number="#card-number" --field securityCode="#cvv"
+  Add --sso secret://provider to explicitly use a linked SSO Login.
+  browser-fill fills only; use a separate authorized action to submit.
+  Named terminal fields use secret://name#field (for example #apiToken).
+  Omit either field selector for a multi-step login. No navigation or screenshots.
+  Supports top-level forms; use agent-browser to prepare the page first.
+  Filled/submitted does not mean authenticated: verify a non-secret success state.
+
+SSH/Git use:
+  rtxexec ssh secret://name -- ssh user@host
+  rtxexec ssh secret://name -- git fetch origin
+  Requires OpenSSH. Creates an owner-only temporary key, removed after exit.
+
 Manage secrets with realtimex-pp-cli or Settings > Secrets.
 Requires the running app and its terminal-session environment. No secret cache.
 Runs executables directly, without a shell. Output is UTF-8 with known values
@@ -58,6 +78,12 @@ export async function execute(plan, injected, { stdout = process.stdout, stderr
 
 export async function main(argv, { env = process.env, stdout = process.stdout, stderr = process.stderr, resolver = resolveSecrets } = {}) {
   try {
+    if (['browser-tabs', 'browser-login', 'browser-fill'].includes(argv[0])) {
+      const result = await runBrowser(parseBrowserArguments(argv), env, { resolver });
+      stdout.write(`${JSON.stringify(result)}\n`);
+      return 0;
+    }
+    if (argv[0] === "ssh") return await runSsh(parseSshArguments(argv), env, (plan, injected) => execute(plan, injected, { stdout, stderr }), { resolver });
     const plan = parseArguments(argv);
     if (plan.help) { stdout.write(help); return 0; }
     if (plan.version) { stdout.write(`${JSON.parse(readFileSync(new URL('../package.json', import.meta.url))).version}\n`); return 0; }

package/src/client.js

@@ -23,7 +23,7 @@ export async function resolveSecrets(plan, env = process.env, fetchImpl = fetch)
     response = await fetchImpl(url, {
       method: 'POST', redirect: 'error', signal: AbortSignal.timeout(15000),
       headers: { Authorization: `RealtimeX-Terminal ${token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ references: plan.references, executable: path.win32.basename(path.basename(plan.command)) }),
+      body: JSON.stringify({ references: plan.references, executable: path.win32.basename(path.basename(plan.command)), ...(plan.browser ? { browser: plan.browser } : {}), ...(plan.ssh ? { ssh: true } : {}) }),
     });
   } catch { throw new UsageError('Could not reach RealTimeX. Check that the app is running; no command was launched.'); }
   let text = '';
@@ -43,6 +43,13 @@ export async function resolveSecrets(plan, env = process.env, fetchImpl = fetch)
   try { body = JSON.parse(text); } catch { throw new UsageError('Invalid RealTimeX response; no command was launched.'); }
   if (!response.ok || body.success !== true) {
     const messages = {
+      SECRET_ORIGIN_DENIED: 'This item is not allowed on the selected website.',
+      SECRET_LOGIN_REQUIRED: 'Select a Login, Card or Identity item for browser fill.',
+      SECRET_FIELD_NOT_FOUND: 'The selected field has no saved value.',
+      SECRET_SSH_REQUIRED: 'Select an SSH key item.',
+      SECRET_SSO_INVALID: 'Select a saved Login linked to this item for SSO.',
+      SECRET_SSO_DENIED: 'The linked SSO Login is disabled or unavailable in this workspace.',
+      SECRET_BROWSER_REQUIRED: 'Use rtxexec browser-login for Login credentials.',
       SECRET_NOT_FOUND: 'A referenced secret does not exist.',
       SECRET_SCOPE_DENIED: 'A referenced secret is not available in this workspace.',
       SECRET_DISABLED: 'A referenced secret is disabled.',

package/src/ssh.js

@@ -0,0 +1,45 @@
+import { mkdtemp, writeFile, chmod, rm } from 'node:fs/promises';
+import { tmpdir, userInfo } from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { UsageError } from './error.js';
+import { resolveSecrets } from './client.js';
+
+const run = promisify(execFile);
+const quote = value => "'" + value.replace(/'/g, "'\"'\"'") + "'";
+export function parseSshArguments(argv) {
+  if (!argv[1]?.startsWith('secret://') || argv[1].includes('#') || argv[2] !== '--' || !argv[3]) throw new UsageError('Use rtxexec ssh secret://name -- ssh|git [arguments].');
+  const name = path.win32.basename(path.basename(argv[3])).replace(/\.exe$/i, '').toLowerCase();
+  if (!['ssh', 'git'].includes(name)) throw new UsageError('SSH key execution supports ssh and git.');
+  return { references: [argv[1]], command: argv[3], args: argv.slice(4), ssh: true, sshCommand: name };
+}
+
+export async function runSsh(plan, env, execute, { resolver = resolveSecrets, root = tmpdir() } = {}) {
+  const [credential] = await resolver(plan, env);
+  if (typeof credential?.privateKey !== 'string' || !credential.privateKey.includes('-----BEGIN OPENSSH PRIVATE KEY-----') || Buffer.byteLength(credential.privateKey) > 65536) throw new UsageError('RealTimeX did not provide a usable SSH key.');
+  let directory;
+  try {
+    directory = await mkdtemp(path.join(root, 'rtxexec-ssh-'));
+    if (process.platform === 'win32') {
+      // Secure the empty directory before writing material. Fail closed if ACLs
+      // cannot be set (e.g. a non-NTFS temp directory).
+      await run('icacls.exe', [directory, '/inheritance:r', '/grant:r', `${userInfo().username}:(OI)(CI)F`], { windowsHide: true });
+    } else await chmod(directory, 0o700);
+    const keyPath = path.join(directory, 'identity');
+    await writeFile(keyPath, credential.privateKey, { mode: 0o600, flag: 'wx' });
+    const sshArgs = ['-i', keyPath, '-o', 'IdentitiesOnly=yes', '-o', 'IdentityAgent=none'];
+    const childEnv = { ...env };
+    let args = plan.args;
+    if (plan.sshCommand === 'ssh') args = [...sshArgs, ...args];
+    else {
+      // Git consumes this command through its own shell. Only generated paths
+      // and fixed options are included, with POSIX quoting (also used by Git for Windows).
+      childEnv.GIT_SSH_COMMAND = ['ssh', ...sshArgs.map(value => process.platform === 'win32' ? value.replace(/\\/g, '/') : value)].map(quote).join(' ');
+      childEnv.GIT_SSH_VARIANT = 'ssh';
+    }
+    return await execute(plan, { args, env: childEnv, stdin: undefined, values: [credential.privateKey] });
+  } finally {
+    if (directory) await rm(directory, { recursive: true, force: true });
+  }
+}