@oar-sh/oar 0.9.15 → 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/relay-asks.mjs

@@ -0,0 +1,145 @@
+// Questions that don't block: remote_relay's `ask` puts a question for the
+// owner into a session (a card there and in the Inbox) and returns at once;
+// the asking session keeps working and is told the answer later, as a relay
+// event (question_answered).
+//
+// One ask is `{ id, kind: 'ask', session, question, options, recommendation,
+// detail, urgency, status, answer, choice, createdBy, creator, ... }`. Its
+// `status` is pending until the owner answers or dismisses it, or the agent
+// that asked withdraws it.
+//
+// Every text of an ask is written by an agent, possibly on another relay:
+// whoever shows it shows it as plain text.
+//
+// SDK-free and side-effect free: imported by the server, the remote_relay
+// contract and the browser.
+
+// The kind a question card carries in /api/relay-questions and the Inbox:
+// `ask` (this feature), `approval` (a relay's Allow / Deny card on its own
+// agent's call, context.source 'remote_relay'), `ask_user` (every other card a
+// turn waits on).
+export const RELAY_QUESTION_KINDS = Object.freeze(['ask', 'ask_user', 'approval']);
+export const RELAY_ASK_KIND = 'ask';
+
+export const RELAY_ASK_URGENCIES = Object.freeze(['normal', 'now']);
+export const RELAY_ASK_STATUSES = Object.freeze(['pending', 'answered', 'dismissed', 'withdrawn', 'cancelled']);
+// What the Inbox lists under its divider (for answeredKeepMs).
+export const RELAY_ASK_CLOSED_STATUSES = Object.freeze(['answered', 'dismissed']);
+
+// Socket event the relay sends on every change of an ask (`{ ask }`) and
+// of the Inbox's count (`{ pending }`).
+export const RELAY_ASK_SOCKET_EVENT = 'relay_ask_updated';
+
+export const RELAY_ASK_LIMITS = Object.freeze({
+  questionMax: 500,
+  optionsMax: 8,
+  optionMax: 120,
+  recommendationMax: 300,
+  detailMax: 2000,
+  // Pending asks one conversation may have asked (for itself and others), and
+  // pending asks one session may have open.
+  pendingPerConversation: 20,
+  // How long an answered or dismissed ask stays in the Inbox, under its divider.
+  answeredKeepMs: 24 * 60 * 60_000,
+  // Closed asks are kept this long, then pruned.
+  closedKeepMs: 7 * 24 * 60 * 60_000,
+  // The asking relay looks for answers to its asks on a paired relay this often.
+  remotePollMs: 5_000,
+  remotePollFailingMs: 30_000,
+  listMax: 200,
+});
+
+// Ask ids carry this prefix: the question routes tell them from cards by it.
+export const RELAY_ASK_ID_PREFIX = 'ask_';
+
+export function isRelayAskId(value) {
+  return /^ask_[a-z0-9]{6,40}$/.test(String(value ?? '').trim());
+}
+
+function toText(value) {
+  return String(value ?? '').trim();
+}
+
+// Control characters of agent text go; line breaks stay in the detail only.
+const CONTROLS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u2028\u2029]+/g;
+
+function oneLine(value) {
+  return String(value ?? '').replace(CONTROLS, ' ').replace(/[\r\n\t]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function multiLine(value) {
+  return String(value ?? '').replace(/\r\n?/g, '\n').replace(CONTROLS, ' ').replace(/[ \t]+\n/g, '\n').trim();
+}
+
+function invalid(error) {
+  return { ok: false, error };
+}
+
+/**
+ * An ask as an agent writes it, checked: `{ ok, value: { question, options,
+ * recommendation, detail, urgency } }` or `{ ok:false, error }`. Too long is
+ * refused, never cut: the owner decides on the words the agent chose. The
+ * recommendation may name an option (matched case-insensitively, then given
+ * the option's spelling) or be free text.
+ */
+export function normalizeRelayAskInput(input = {}) {
+  const source = input && typeof input === 'object' ? input : {};
+  const question = oneLine(source.question);
+  if (!question) return invalid('ask needs question (the question for the owner, at most 500 characters)');
+  if (question.length > RELAY_ASK_LIMITS.questionMax) {
+    return invalid(`question is longer than ${RELAY_ASK_LIMITS.questionMax} characters; put the background in detail`);
+  }
+  let rawOptions = source.options;
+  if (rawOptions === undefined || rawOptions === null || rawOptions === '') rawOptions = [];
+  if (typeof rawOptions === 'string') rawOptions = rawOptions.split(/\r?\n/);
+  if (!Array.isArray(rawOptions)) return invalid('options must be a list of short labels');
+  const options = [];
+  for (const raw of rawOptions) {
+    if (typeof raw !== 'string' && typeof raw !== 'number') return invalid('options must be a list of short labels');
+    const label = oneLine(raw);
+    if (!label) continue;
+    if (label.length > RELAY_ASK_LIMITS.optionMax) return invalid(`an option is longer than ${RELAY_ASK_LIMITS.optionMax} characters: "${label.slice(0, 40)}…"`);
+    if (options.some((option) => option.toLowerCase() === label.toLowerCase())) continue;
+    options.push(label);
+  }
+  if (options.length > RELAY_ASK_LIMITS.optionsMax) return invalid(`options takes at most ${RELAY_ASK_LIMITS.optionsMax} labels`);
+  let recommendation = oneLine(source.recommendation);
+  if (recommendation.length > RELAY_ASK_LIMITS.recommendationMax) {
+    return invalid(`recommendation is longer than ${RELAY_ASK_LIMITS.recommendationMax} characters`);
+  }
+  const named = options.find((option) => option.toLowerCase() === recommendation.toLowerCase());
+  if (named) recommendation = named;
+  const detail = multiLine(source.detail);
+  if (detail.length > RELAY_ASK_LIMITS.detailMax) return invalid(`detail is longer than ${RELAY_ASK_LIMITS.detailMax} characters`);
+  const urgency = toText(source.urgency).toLowerCase() || 'normal';
+  if (!RELAY_ASK_URGENCIES.includes(urgency)) return invalid(`urgency must be one of: ${RELAY_ASK_URGENCIES.join(', ')}`);
+  return { ok: true, value: { question, options, recommendation, detail, urgency } };
+}
+
+/**
+ * The owner's answer to an ask: `{ ok, value: { answer, choice } }` or
+ * `{ ok:false, error }`. `choice` is the option picked (its own spelling),
+ * `answer` the text the asker reads: the typed text, else the choice.
+ */
+export function normalizeRelayAskAnswer(ask, { answer = '', choice = '' } = {}) {
+  const options = Array.isArray(ask?.options) ? ask.options : [];
+  const wanted = oneLine(choice);
+  let picked = '';
+  if (wanted) {
+    picked = options.find((option) => option.toLowerCase() === wanted.toLowerCase()) || '';
+    if (!picked) return invalid(`"${wanted.slice(0, 80)}" is not an option of this question`);
+  }
+  const text = multiLine(answer).slice(0, RELAY_ASK_LIMITS.detailMax);
+  if (!picked && !text) return invalid('An answer needs a choice or some text');
+  // A typed text that is an option counts as that choice.
+  if (!picked) picked = options.find((option) => option.toLowerCase() === oneLine(text).toLowerCase()) || '';
+  return { ok: true, value: { answer: text || picked, choice: picked } };
+}
+
+/** The kind of a formatted question card (a row of /api/relay-questions). */
+export function relayQuestionKind(question) {
+  const kind = toText(question?.kind);
+  if (RELAY_QUESTION_KINDS.includes(kind)) return kind;
+  const context = question && typeof question.context === 'object' && question.context ? question.context : {};
+  return toText(context.source) === 'remote_relay' ? 'approval' : 'ask_user';
+}