@oar-sh/oar 0.9.16 → 0.9.17

package/shared/deepseek-pricing.mjs

@@ -0,0 +1,146 @@
+// DeepSeek's published prices, for the usage card's estimate of what this
+// relay's DeepSeek turns cost. DeepSeek reports no cost per request, and
+// Claude Code's own `total_cost_usd` is computed at Claude's prices, so the
+// estimate is tokens times this table.
+//
+// Source: api-docs.deepseek.com/quick_start/pricing (USD) and its zh-cn page
+// (CNY), built 2026-10-19. Prices are per 1M tokens: a cache hit, a cache
+// miss (input DeepSeek had not cached) and output. Peak hours cost exactly
+// twice the off-peak price. Peak is Monday to Friday 01:00–04:00 and
+// 06:00–10:00 UTC (09:00–12:00 and 14:00–18:00 Beijing time); everything else
+// is off-peak. On Chinese public holidays DeepSeek charges off-peak prices all
+// day; the estimate doesn't know those dates, so turns at peak hours on a
+// holiday are counted at double the real price.
+//
+// A model the table does not know gets no estimate (null), never a guess.
+//
+// Claude Code's WebSearch runs on DeepSeek's Search API. Source:
+// api-docs.deepseek.com/guides/search (USD) and its zh-cn page (CNY), read
+// 2026-10-24: $0.75 / ¥5 per 1,000 successful requests for each of Search
+// and Fetch, charged from 2026-11-01 00:00 Beijing time (2026-10-31 16:00
+// UTC), no peak or off-peak. Requests before that are counted but cost 0.
+// Claude Code's WebFetch is not a Fetch request: it reads the page on the
+// relay host and sends the text to the model (plain tokens), and DeepSeek's
+// API refuses the server-side fetch tool (422, checked 2026-10-25). The Fetch
+// price stays for a fetch DeepSeek might report one day.
+
+export const DEEPSEEK_PRICING_SOURCE = Object.freeze({
+  url: 'https://api-docs.deepseek.com/quick_start/pricing',
+  date: '2026-10-19',
+});
+
+export const DEEPSEEK_SEARCH_PRICING = Object.freeze({
+  url: 'https://api-docs.deepseek.com/guides/search',
+  date: '2026-10-24',
+  chargedFrom: '2026-10-31T16:00:00.000Z',
+  // Per 1,000 successful requests, the same for a search and a fetch.
+  perThousand: Object.freeze({ USD: 0.75, CNY: 5 }),
+});
+
+export const DEEPSEEK_PRICE_CURRENCIES = Object.freeze(['USD', 'CNY']);
+
+const TOKENS_PER_PRICE_UNIT = 1_000_000;
+
+function prices(hit, miss, output) {
+  return Object.freeze({ hit, miss, output });
+}
+
+const PRICE_TABLE = Object.freeze({
+  'deepseek-flash': Object.freeze({
+    offPeak: Object.freeze({ USD: prices(0.003, 0.15, 0.60), CNY: prices(0.02, 1, 4) }),
+    peak: Object.freeze({ USD: prices(0.006, 0.30, 1.20), CNY: prices(0.04, 2, 8) }),
+  }),
+  'deepseek-v4-pro': Object.freeze({
+    offPeak: Object.freeze({ USD: prices(0.022, 0.66, 1.98), CNY: prices(0.15, 4.5, 13.5) }),
+    peak: Object.freeze({ USD: prices(0.044, 1.32, 3.96), CNY: prices(0.30, 9, 27) }),
+  }),
+});
+
+// Ids DeepSeek still accepts and serves with the Flash model.
+const PRICE_ALIASES = Object.freeze({
+  'deepseek-v4-flash': 'deepseek-flash',
+  'deepseek-v4-flash-vision-exp': 'deepseek-flash',
+});
+
+// [start, end) hours in UTC, Monday to Friday. The card shows them in the
+// browser's time zone (plan-usage-view.mjs).
+export const DEEPSEEK_PEAK_HOURS_UTC = Object.freeze([Object.freeze([1, 4]), Object.freeze([6, 10])]);
+const PEAK_HOURS_UTC = DEEPSEEK_PEAK_HOURS_UTC;
+
+function toDate(value) {
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  if (typeof value === 'number') {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  const text = String(value ?? '').trim();
+  if (!text) return null;
+  const date = new Date(text);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+/** The id the table prices a model under ("deepseek-v4-flash[1m]" → "deepseek-flash"), or '' when unknown. */
+export function deepseekPricedModel(value) {
+  const id = String(value ?? '').trim().toLowerCase().replace(/\[1m\]$/, '');
+  if (PRICE_TABLE[id]) return id;
+  return PRICE_ALIASES[id] || '';
+}
+
+/** Whether DeepSeek bills an instant at its peak price; null for an unreadable time. */
+export function isDeepSeekPeakTime(at) {
+  const date = toDate(at);
+  if (!date) return null;
+  const day = date.getUTCDay();
+  if (day === 0 || day === 6) return false;
+  const minutes = date.getUTCHours() * 60 + date.getUTCMinutes();
+  return PEAK_HOURS_UTC.some(([start, end]) => minutes >= start * 60 && minutes < end * 60);
+}
+
+/**
+ * The prices per 1M tokens for a model at an instant: `{ hit, miss, output,
+ * peak }`, or null for an unknown model, currency or time.
+ */
+export function deepseekPriceFor({ model, at, currency = 'USD' } = {}) {
+  const entry = PRICE_TABLE[deepseekPricedModel(model)];
+  const unit = String(currency ?? '').trim().toUpperCase();
+  const peak = isDeepSeekPeakTime(at);
+  if (!entry || !DEEPSEEK_PRICE_CURRENCIES.includes(unit) || peak === null) return null;
+  return { ...entry[peak ? 'peak' : 'offPeak'][unit], peak };
+}
+
+function tokenCount(value) {
+  const number = Number(value ?? 0);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+/**
+ * What the tokens of one request (or one turn) cost at DeepSeek's price for
+ * its time, in `currency` (USD or CNY). A missing count is 0. Null when the
+ * model, the currency or the time is unknown.
+ */
+export function estimateCost({ model, at, hitTokens = 0, missTokens = 0, outputTokens = 0, currency = 'USD' } = {}) {
+  const price = deepseekPriceFor({ model, at, currency });
+  if (!price) return null;
+  const cost = (
+    tokenCount(hitTokens) * price.hit
+    + tokenCount(missTokens) * price.miss
+    + tokenCount(outputTokens) * price.output
+  ) / TOKENS_PER_PRICE_UNIT;
+  // Ten decimals: enough for a single token, and no binary-float tails.
+  return Math.round(cost * 1e10) / 1e10;
+}
+
+/**
+ * What the web searches and fetches of one turn cost at the time `at`, in
+ * `currency`: 0 before DeepSeek started charging for them, null for an
+ * unreadable time or an unknown currency. Flat per request, peak or not.
+ */
+export function estimateSearchCost({ at, searchRequests = 0, fetchRequests = 0, currency = 'USD' } = {}) {
+  const date = toDate(at);
+  const unit = String(currency ?? '').trim().toUpperCase();
+  const price = DEEPSEEK_SEARCH_PRICING.perThousand[unit];
+  if (!date || price === undefined) return null;
+  if (date.getTime() < Date.parse(DEEPSEEK_SEARCH_PRICING.chargedFrom)) return 0;
+  const cost = (tokenCount(searchRequests) + tokenCount(fetchRequests)) * price / 1000;
+  return Math.round(cost * 1e10) / 1e10;
+}

package/shared/host-claude-session-env.mjs

@@ -0,0 +1,101 @@
+// The variables of a Claude Code session the relay was started from.
+//
+// A relay started from inside a Claude Code session (an agent's shell, a
+// `claude` run that starts it, a test relay an agent starts from a relay
+// worker) carries that session's variables, and so would every worker: the
+// Claude and DeepSeek workers' CLI would take itself for a child of the host's
+// session (messaging socket and token, session id, entrypoint, effort), and a
+// Copilot or Cursor worker has no use for them either. The launcher drops
+// them for every kind and on every path (session-worker-launch-service.mjs),
+// and the DeepSeek backend drops them again from its CLI's environment.
+//
+// A fixed list misses what the next CLI version adds, so the session's
+// variables are matched by family as well:
+// - the names Claude Code gives its child shells and MCP servers, those it
+//   sets on its own process (entrypoint, executable path), the markers an
+//   SDK host sets (its version and its app's name, which the CLI sends as
+//   `x-client-app`), and the per-spawn Bash cap a relay's Claude worker
+//   gives its CLI (HOST_CLAUDE_SESSION_ENV_VARS);
+// - every `CLAUDE_CODE_SESSION_*` (id, attended, access token, kind, name,
+//   origin, ...), every `CLAUDE_CODE_*_SESSION_ID` (host, remote, bridge,
+//   cloud) and every `CLAUDE_CODE_MESSAGING_*`
+//   (HOST_CLAUDE_SESSION_ENV_PATTERNS).
+// What stays is configuration: the relay's own (`CLAUDE_CONFIG_DIR`,
+// `CLAUDE_CODE_EXECUTABLE`, a login token, which the launcher hands only to
+// the Claude kinds) and the user's settings: `CLAUDE_CODE_*` ones (a
+// provider such as `CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_GIT_BASH_PATH` on
+// Windows, the `DISABLE_*`/`ENABLE_*` switches) and the SDK's
+// `CLAUDE_AGENT_SDK_*` switches (`DISABLE_BUILTIN_AGENTS`, `MCP_NO_PREFIX`,
+// `DISABLE_MCP_MANIFESTS`), which no family reaches. The settings that fall
+// in a family stay through HOST_CLAUDE_SESSION_KEEP_ENV_VARS. Every
+// `CLAUDE_AGENT_SDK_*` and family name the bundled CLI and SDK read was
+// sorted this way (2026-10-25).
+
+export const HOST_CLAUDE_SESSION_ENV_VARS = Object.freeze([
+  'CLAUDECODE',
+  'CLAUDE_CODE_SESSION_ID',
+  'CLAUDE_CODE_MESSAGING_SOCKET',
+  'CLAUDE_CODE_MESSAGING_TOKEN',
+  'CLAUDE_CODE_CHILD_SESSION',
+  'CLAUDE_CODE_ENTRYPOINT',
+  'CLAUDE_CODE_SESSION_ATTENDED',
+  'CLAUDE_CODE_EXECPATH',
+  'CLAUDE_CODE_AUTO_BACKGROUND_TIMEOUT_MS',
+  'CLAUDE_AGENT_SDK_VERSION',
+  'CLAUDE_AGENT_SDK_CLIENT_APP',
+  'CLAUDE_PID',
+  'CLAUDE_EFFORT',
+  'CLAUDE_PROJECT_DIR',
+  'CLAUDE_ENV_FILE',
+]);
+
+// Shell `case` patterns, matched against the upper-cased name in JavaScript.
+export const HOST_CLAUDE_SESSION_ENV_PATTERNS = Object.freeze([
+  'CLAUDE_CODE_SESSION_*',
+  'CLAUDE_CODE_*_SESSION_ID',
+  'CLAUDE_CODE_MESSAGING_*',
+]);
+
+// Settings inside a family: a behaviour switch and a debug log switch.
+export const HOST_CLAUDE_SESSION_KEEP_ENV_VARS = Object.freeze([
+  'CLAUDE_CODE_SESSION_START_ANNOUNCEMENTS_BEFORE_PROMPT',
+  'CLAUDE_CODE_SESSION_LOG',
+]);
+
+const EXACT = new Set(HOST_CLAUDE_SESSION_ENV_VARS);
+const KEEP = new Set(HOST_CLAUDE_SESSION_KEEP_ENV_VARS);
+const PATTERNS = HOST_CLAUDE_SESSION_ENV_PATTERNS.map((pattern) => new RegExp(
+  `^${pattern.split('*').map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*')}$`,
+));
+
+/**
+ * Whether a variable is the host Claude Code session's. Upper-cased first:
+ * Windows names are case-insensitive.
+ */
+export function isHostClaudeSessionVariable(name) {
+  const key = String(name ?? '').toUpperCase();
+  if (!key || KEEP.has(key)) return false;
+  return EXACT.has(key) || PATTERNS.some((pattern) => pattern.test(key));
+}
+
+/** The environment without the host Claude Code session's variables. */
+export function withoutHostClaudeSessionVariables(env = {}) {
+  const next = {};
+  for (const [key, value] of Object.entries(env || {})) {
+    if (!isHostClaudeSessionVariable(key)) next[key] = value;
+  }
+  return next;
+}
+
+/**
+ * A POSIX sh statement that unsets, in the shell it runs in, every variable
+ * of the host session the environment holds: the families as well as the
+ * names, for an environment the launcher never saw (a tmux server's). Names
+ * only; a value is never read.
+ */
+export function hostClaudeSessionUnsetStatement() {
+  const keep = HOST_CLAUDE_SESSION_KEEP_ENV_VARS.length ? `${HOST_CLAUDE_SESSION_KEEP_ENV_VARS.join('|')}) ;; ` : '';
+  const drop = [...HOST_CLAUDE_SESSION_ENV_VARS, ...HOST_CLAUDE_SESSION_ENV_PATTERNS].join('|');
+  return `for oar_host_var in $(env | sed -n 's/^\\([A-Za-z_][A-Za-z0-9_]*\\)=.*/\\1/p'); do `
+    + `case "$oar_host_var" in ${keep}${drop}) unset "$oar_host_var";; esac; done; unset oar_host_var;`;
+}

package/shared/model-id.mjs

@@ -77,6 +77,13 @@ export function isSafeGrokModelId(value) {
   return isSafeProviderModelId(value);
 }
 
+// DeepSeek model ids ("deepseek-flash", "deepseek-v4-pro") follow the same
+// safe-token rules; that they are DeepSeek's is checked by the provider
+// (shared/deepseek-models.mjs).
+export function isSafeDeepSeekModelId(value) {
+  return isSafeProviderModelId(value);
+}
+
 // The "[1m]" suffix marks the 1M-context variant of a Claude model. The UI
 // treats it as a context tier of the base model, not a separate model.
 export const CLAUDE_LONG_CONTEXT_SUFFIX = '[1m]';

package/shared/preview-tool-core.mjs

@@ -173,7 +173,7 @@ export async function executePreviewTool(input, { api, conversationId = '' } = {
     const response = await api('POST', '/api/previews', body);
     const existing = response?.existing === true;
     const hint = parsed.port
-      ? `Serve the app under ${response?.basePath} (the proxy strips the prefix and sends X-Forwarded-Prefix). Tell the user the URL and that the link is public.`
+      ? `Serve the app under ${response?.basePath} (the proxy strips the prefix and sends X-Forwarded-Prefix). Bind the dev server to 127.0.0.1, not 0.0.0.0: the relay's proxy reaches it there and nothing else should. Tell the user the URL and that the link is public.`
       : 'The directory is served as-is; relative asset paths work, root-absolute ones do not. Tell the user the URL and that the link is public.';
     return {
       ok: true,

package/shared/provider-routing.mjs

@@ -13,7 +13,7 @@ export const LEGACY_RELAY_PROVIDER_TYPES = Object.freeze(['github', 'openai']);
 
 // `claude-cloud` is its own provider, never an alias of `claude`: its worker
 // drives a session in Anthropic's cloud and spawns no CLI.
-export const SESSION_WORKER_PROVIDER_TYPES = Object.freeze(['claude', 'cursor', 'grok', 'claude-cloud']);
+export const SESSION_WORKER_PROVIDER_TYPES = Object.freeze(['claude', 'cursor', 'grok', 'claude-cloud', 'deepseek']);
 
 export function isLegacyRelayProviderType(value) {
   const normalized = String(value || '').trim().toLowerCase();
@@ -25,7 +25,7 @@ export function isSessionWorkerProviderType(value) {
   return SESSION_WORKER_PROVIDER_TYPES.includes(String(value || '').trim().toLowerCase());
 }
 
-/** `'claude', 'cursor', 'grok', 'claude-cloud'` — for interpolation into SQL NOT IN (...) lists. */
+/** `'claude', 'cursor', 'grok', 'claude-cloud', 'deepseek'` — for interpolation into SQL NOT IN (...) lists. */
 export function sessionWorkerProviderSqlList() {
   return SESSION_WORKER_PROVIDER_TYPES.map((provider) => `'${provider}'`).join(', ');
 }

package/shared/remote-relay-contract.mjs

@@ -154,7 +154,7 @@ export const REMOTE_RELAY_PROMPT_ACTIONS = Object.freeze(['send', 'create_sessio
 export const REMOTE_RELAY_APPROVAL_MODES = Object.freeze(['ask', 'plan']);
 
 export const REMOTE_RELAY_SESSION_SCOPES = Object.freeze(['active', 'recent', 'all']);
-export const REMOTE_RELAY_PROVIDERS = Object.freeze(['github', 'openai', 'claude', 'cursor', 'grok', 'claude-cloud']);
+export const REMOTE_RELAY_PROVIDERS = Object.freeze(['github', 'openai', 'claude', 'cursor', 'grok', 'claude-cloud', 'deepseek']);
 export const REMOTE_RELAY_MODES = Object.freeze(['plan', 'ask', 'agent', 'autopilot']);
 export const REMOTE_RELAY_IF_BUSY = Object.freeze(['queue', 'fail']);
 // Reasoning efforts differ per provider and model (none, low, medium, high,

package/shared/steer-settle-failure.mjs

@@ -85,6 +85,7 @@ export function steerAgentLabelForProvider(providerType) {
     case 'cursor': return 'Cursor';
     case 'grok': return 'Grok';
     case 'claude-cloud': return 'Claude Cloud';
+    case 'deepseek': return 'DeepSeek';
     default: return DEFAULT_STEER_AGENT_LABEL;
   }
 }

package/shared/worker-runtime/direct-openai-image.mjs

@@ -0,0 +1,128 @@
+// A turn on an OpenAI image model (`gpt-image-*`, `dall-e-*`) is no chat
+// turn: no chat runtime can serve it, and one that is handed it fails ("No
+// available capacity was found for the model", or a request rejected as
+// invalid). Both Copilot engines therefore send it straight to the relay's
+// image routes instead, and this module is the one copy of that path.
+//
+// With image continuity on (the default) the relay created an image operation
+// when the message was sent, and `POST /api/image-operations/:id/execute` does
+// everything: the provider call, the generated-image reply, and on a failure
+// the failure note or the requeue. The caller only reports the outcome. Without
+// an operation the worker calls `POST /api/openai/images/generate` and
+// publishes the reply itself.
+
+export const DIRECT_IMAGE_OUTCOMES = Object.freeze(['completed', 'executing', 'terminal', 'uncertain', 'retryable']);
+
+// The code of the error thrown when the provider refused the request outright:
+// a retry would be refused the same way, so the turn fails instead of being
+// requeued.
+export const OPENAI_IMAGE_TERMINAL_CODE = 'RELAY_OPENAI_IMAGE_TERMINAL';
+
+export function shouldUseDirectOpenAIImageApi(message = {}) {
+  const providerType = String(message?.providerType || '').trim().toLowerCase();
+  if (providerType !== 'openai') return false;
+  const model = String(message?.providerModel || message?.model || '').trim().toLowerCase();
+  return model.startsWith('gpt-image-') || model.startsWith('dall-e-');
+}
+
+export function isDirectOpenAIImageTerminalStatus(status) {
+  const numeric = Number(status);
+  if (!Number.isFinite(numeric)) return false;
+  return [400, 401, 403, 404, 409, 422, 429, 503].includes(numeric);
+}
+
+export function isOpenAIImageTerminalError(error) {
+  return String(error?.code || '').trim() === OPENAI_IMAGE_TERMINAL_CODE;
+}
+
+const isAutoModel = (value) => String(value || '').trim().toLowerCase() === 'auto';
+
+/**
+ * Run one image turn. `requestOptions` goes to every `api` call that may wait
+ * on the provider (a worker passes `{ longCall: true }`: an edit can take
+ * minutes); `responseFields` is merged into the reply the worker publishes
+ * itself (the attempt fence).
+ *
+ * Resolves `{ via: 'operation', outcome }` or `{ via: 'direct', outcome:
+ * 'completed', imageCount, model }`. Throws an error with `code`
+ * `OPENAI_IMAGE_TERMINAL_CODE` when the provider refused the direct request,
+ * and a plain error for anything else (the caller requeues).
+ */
+export async function runDirectOpenAIImageTurn({
+  api,
+  message,
+  requestOptions = {},
+  responseFields = {},
+} = {}) {
+  if (message?.imageOperationId) {
+    const result = await api(
+      'POST',
+      `/api/image-operations/${encodeURIComponent(message.imageOperationId)}/execute`,
+      { messageId: message.id },
+      requestOptions,
+    ).catch((error) => {
+      // The route answers a failure it already handled (published or
+      // requeued) with 409 or 503 and the outcome in the body.
+      if (error?.status === 409 || error?.status === 503) {
+        return error?.body || error?.payload || { outcome: error?.status === 503 ? 'retryable' : 'terminal' };
+      }
+      throw error;
+    });
+    const outcome = String(result?.outcome || '').trim().toLowerCase();
+    if (!DIRECT_IMAGE_OUTCOMES.includes(outcome)) {
+      throw new Error('Image operation returned an invalid outcome');
+    }
+    return { via: 'operation', outcome };
+  }
+
+  const requestedModel = isAutoModel(message?.model) ? '' : String(message?.model || '').trim();
+  const directModel = String(message?.providerModel || requestedModel || message?.model || '').trim();
+  const prompt = String(message?.text || '').trim();
+  if (!directModel) throw new Error('OpenAI image request is missing model');
+  if (!prompt) throw new Error('OpenAI image request is missing prompt');
+  await api('POST', '/api/activity', {
+    messageId: message.id,
+    conversationId: message.conversationId,
+    mode: message.relayMode || 'agent',
+    text: `Calling OpenAI image API directly (${directModel})`,
+  }).catch(() => {});
+  let directResult;
+  try {
+    directResult = await api('POST', '/api/openai/images/generate', {
+      messageId: message.id,
+      conversationId: message.conversationId,
+      model: directModel,
+      prompt,
+      n: message?.n,
+      size: message?.size || message?.contextTier,
+      quality: message?.quality || message?.reasoningEffort,
+      attachments: Array.isArray(message?.attachments) ? message.attachments : [],
+    }, requestOptions);
+  } catch (error) {
+    if (isDirectOpenAIImageTerminalStatus(error?.status)) {
+      const terminalError = new Error(
+        `OpenAI image request failed: ${error?.detail || `HTTP ${error?.status || 'error'}`}`,
+      );
+      terminalError.code = OPENAI_IMAGE_TERMINAL_CODE;
+      terminalError.status = error?.status;
+      terminalError.detail = error?.detail || null;
+      throw terminalError;
+    }
+    throw error;
+  }
+  const generatedImages = Array.isArray(directResult?.generatedImages) ? directResult.generatedImages : [];
+  if (!generatedImages.length) {
+    throw new Error('OpenAI image API returned no images');
+  }
+  const model = String(directResult?.model || directModel).trim() || directModel;
+  await api('POST', '/api/response', {
+    messageId: message.id,
+    conversationId: message.conversationId,
+    text: '',
+    generatedImages,
+    model,
+    modelOrigin: isAutoModel(message?.model) ? 'auto' : 'manual',
+    ...responseFields,
+  });
+  return { via: 'direct', outcome: 'completed', imageCount: generatedImages.length, model };
+}

package/shared/worker-runtime/worker-log-file.mjs

@@ -95,3 +95,63 @@ export function installWorkerLogFile({
     },
   };
 }
+
+const REDACTED_SECRET_TEXT = '[redacted]';
+// As the relay's redaction of worker posts (server/services/worker-secret-redaction.mjs):
+// a shorter value would mangle ordinary text.
+const MIN_REDACTED_SECRET_LENGTH = 8;
+
+/**
+ * Replaces each secret's exact text with `[redacted]` in what the worker
+ * writes to stdout/stderr, on every platform: the console, the Linux
+ * launcher's redirect into the worker log, and the Windows copy above (install
+ * this after installWorkerLogFile so the copy gets the redacted text). A
+ * secret split across two writes is not caught; the worker logs whole lines.
+ * Returns null when there is no secret of at least 8 characters.
+ */
+export function installWorkerLogRedaction({
+  secrets = [],
+  processImpl = process,
+} = {}) {
+  const values = [...new Set((Array.isArray(secrets) ? secrets : [])
+    .map((value) => String(value ?? '').trim())
+    .filter((value) => value.length >= MIN_REDACTED_SECRET_LENGTH))]
+    .sort((a, b) => b.length - a.length);
+  if (!values.length) return null;
+
+  const redact = (text) => {
+    let output = text;
+    for (const value of values) {
+      if (output.includes(value)) output = output.split(value).join(REDACTED_SECRET_TEXT);
+    }
+    return output;
+  };
+
+  const restores = [];
+  for (const stream of [processImpl.stdout, processImpl.stderr]) {
+    if (!stream || typeof stream.write !== 'function') continue;
+    const originalWrite = stream.write;
+    const redactingWrite = function redactingWrite(chunk, encoding, callback) {
+      if (typeof chunk === 'string') {
+        return originalWrite.call(this, redact(chunk), encoding, callback);
+      }
+      if (chunk instanceof Uint8Array) {
+        const bytes = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        if (values.some((value) => bytes.includes(value))) {
+          const done = typeof encoding === 'function' ? encoding : callback;
+          return originalWrite.call(this, redact(bytes.toString('utf8')), 'utf8', done);
+        }
+      }
+      return originalWrite.call(this, chunk, encoding, callback);
+    };
+    stream.write = redactingWrite;
+    restores.push(() => {
+      if (stream.write === redactingWrite) stream.write = originalWrite;
+    });
+  }
+  return {
+    uninstall() {
+      for (const restore of restores) restore();
+    },
+  };
+}