@oar-sh/oar 0.9.15 → 0.9.17

package/server/deepseek-worker/deepseek-claude-backend.mjs

@@ -0,0 +1,433 @@
+// The DeepSeek backend of the Claude session runner: everything that differs
+// when the CLI the runner drives talks to DeepSeek's Anthropic-compatible
+// endpoint instead of Anthropic.
+//
+// - The CLI's environment: the endpoint and the key as Claude Code's
+//   documented ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN, a Claude Code state
+//   directory of its own, no nonessential traffic, and nothing of the host's
+//   Claude login or of another Anthropic configuration. The endpoint, the
+//   key and everything else that routes the CLI's requests or decides whom
+//   it trusts (DEEPSEEK_CLI_PINNED_ENV: provider switches, credentials,
+//   proxies, TLS) are pinned again in the CLI's flag settings
+//   (liveFlagSettings), over the settings of the chat's folder.
+// - The model: DeepSeek's ids, with Claude Code's `[1m]` suffix so the CLI
+//   plans with the 1M window; helper calls (titles, summaries) go to flash.
+//   Claude Code's model aliases are pinned to the session's model
+//   (ANTHROPIC_MODEL, ANTHROPIC_DEFAULT_OPUS/SONNET/FABLE_MODEL,
+//   CLAUDE_CODE_SUBAGENT_MODEL, CLAUDE_CODE_WORKFLOW_SUBAGENT_MODEL), so a
+//   sub-agent asked for as "opus" runs on it and not, by DeepSeek's mapping
+//   of a Claude id, on V4 Pro; a model switch respawns the CLI for the pins.
+//   A Claude id the CLI still names (a session spawned before the pins) is
+//   read as the DeepSeek model DeepSeek serves it with (deepseekServedModel).
+// - The effort: DeepSeek's low/high/max, which Claude Code sends as
+//   `output_config.effort` with adaptive thinking (captured 2026-10-24). It
+//   is applied at spawn (CLAUDE_CODE_EFFORT_LEVEL), so a change respawns the
+//   CLI between turns on the same session. There is no thinking-off level:
+//   Claude Code never sends `thinking: {type: disabled}` for these models.
+// - What it reports: no Claude plan usage and no Claude usage limit, but the
+//   CLI's token totals per model after each turn (POST
+//   /api/deepseek-plan-usage) for the DeepSeek card's estimated spend; images
+//   only to models that take them; DeepSeek's errors in its own words.
+//
+// Source for the endpoint and the variables: DeepSeek's Claude Code guide
+// (api-docs.deepseek.com, quick_start/agent_integrations/claude_code).
+
+import { deepseekAnthropicBaseUrl } from '../../shared/deepseek-api.mjs';
+import { isHostClaudeSessionVariable } from '../../shared/host-claude-session-env.mjs';
+import {
+  DEEPSEEK_PROVIDER_TYPE,
+  DEFAULT_DEEPSEEK_MODEL,
+  deepseekModelAcceptsImages,
+  deepseekReasoningEffortFor,
+  deepseekServedModel,
+  isDeepSeekModelId,
+} from '../../shared/deepseek-models.mjs';
+
+const LONG_CONTEXT_SUFFIX = '[1m]';
+const LONG_CONTEXT_SUFFIX_PATTERN = /\[1m\]$/i;
+// Claude Code's helper model; DeepSeek's guide points it at flash.
+const HELPER_MODEL = 'deepseek-flash';
+// Claude Code's alias for its helper model. The other aliases ("opus",
+// "sonnet", "fable", and a sub-agent without a model) resolve to the pins
+// spawnEnv sets, that is to the session's model.
+const HELPER_ALIAS = 'haiku';
+// Where Claude Code reads the model behind each of its aliases, and the model
+// of sub-agents and workflow agents (the bundled CLI, 2026-10-24). All pinned
+// to the session's model; CLAUDE_CODE_SUBAGENT_MODEL_FORCE is left unset, so
+// a sub-agent asked for as "haiku" still runs on the helper model.
+const SESSION_MODEL_VARIABLES = Object.freeze([
+  'ANTHROPIC_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_FABLE_MODEL',
+  'CLAUDE_CODE_SUBAGENT_MODEL',
+  'CLAUDE_CODE_WORKFLOW_SUBAGENT_MODEL',
+]);
+const HELPER_MODEL_VARIABLES = Object.freeze(['ANTHROPIC_DEFAULT_HAIKU_MODEL', 'ANTHROPIC_SMALL_FAST_MODEL']);
+
+// Variables that would point the CLI at another Anthropic configuration or
+// hand it another credential. Every ANTHROPIC_* is dropped as well.
+const FOREIGN_CLI_VARIABLES = Object.freeze([
+  'CLAUDE_CODE_OAUTH_TOKEN',
+  'CLAUDE_CODE_USE_BEDROCK',
+  'CLAUDE_CODE_USE_VERTEX',
+  'CLAUDE_CODE_USE_FOUNDRY',
+  'CLAUDE_CODE_USE_ANTHROPIC_AWS',
+  'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
+  'CLAUDE_CODE_USE_MANTLE',
+  'CLAUDE_CODE_USE_GATEWAY',
+  'CLAUDE_CODE_SKIP_BEDROCK_AUTH',
+  'CLAUDE_CODE_SKIP_VERTEX_AUTH',
+  'CLAUDE_CODE_SKIP_FOUNDRY_AUTH',
+  'CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH',
+  'CLAUDE_CODE_SKIP_ANTHROPIC_GOOGLE_CLOUD_AUTH',
+  'CLAUDE_CODE_SKIP_MANTLE_AUTH',
+  'CLAUDE_CODE_SUBAGENT_MODEL',
+  'CLAUDE_CODE_SUBAGENT_MODEL_FORCE',
+  'CLAUDE_CODE_WORKFLOW_SUBAGENT_MODEL',
+  'CLAUDE_CODE_EFFORT_LEVEL',
+  'CLAUDE_CODE_AUTO_COMPACT_WINDOW',
+  // Claude Code's subprocess env scrub, if the host exports it: it forces the
+  // permission mode to default (a chat in plan mode could edit files) and
+  // runs every Bash command in a bubblewrap sandbox.
+  'CLAUDE_CODE_SUBPROCESS_ENV_SCRUB',
+  // What the relay hands its worker (session-worker-launch-service.mjs,
+  // TMUX_WORKER_EXPORTED_ENV_VARS): the worker's own settings, which neither
+  // Claude Code nor anything the agent runs reads. A shell of the agent's
+  // that starts a relay of its own would take the worker's kind, folders and
+  // tools file for its own. The relay's Claude configuration
+  // (CLAUDE_CONFIG_DIR, replaced below; CLAUDE_CODE_EXECUTABLE) is not on it.
+  'COPILOT_ALLOW_ALL',
+  'GITHUB_COPILOT_PROMPT_MODE_EXTENSIONS',
+  'COPILOT_SDK_PATH',
+  'EXTENSION_PATH',
+  'COPILOT_MODEL',
+  'COPILOT_RELAY_MODEL',
+  'CLAUDE_RELAY_MODEL',
+  'CLAUDE_CLOUD_RELAY_MODEL',
+  'CURSOR_RELAY_MODEL',
+  'CURSOR_AGENT_STORE_DIR',
+  'GROK_RELAY_MODEL',
+  'GROK_CLI_COMMAND',
+  'GROK_ALWAYS_APPROVE',
+  'SESSION_ID',
+  'COPILOT_WORKSPACE_ROOT',
+  'INIT_CWD',
+]);
+// The same by prefix: the relay's folders, config, tools file, worker kind
+// and log file (COPILOT_WEB_RELAY_*), the Copilot provider settings, every
+// DeepSeek setting of the worker's (the key included: the CLI gets it as
+// ANTHROPIC_AUTH_TOKEN) and the relay's own OAR_* switches.
+const FOREIGN_CLI_PREFIXES = Object.freeze(['ANTHROPIC_', 'COPILOT_WEB_RELAY_', 'COPILOT_PROVIDER_', 'DEEPSEEK_', 'OAR_']);
+
+/**
+ * Every variable through which the env of the chat folder's settings
+ * (.claude/settings.json, settings.local.json) could send the CLI's requests,
+ * and with them the key, somewhere else, or change whom the CLI trusts on the
+ * way: the endpoints, the provider switches, the credentials, the proxies and
+ * the TLS trust. liveFlagSettings pins each one in the flag settings layer,
+ * which the CLI applies over the folder's, to the value the CLI was spawned
+ * with: the worker's own, else the other case's for a proxy variable, else ''.
+ * '' is unset to the CLI for each of these (truthy or trimmed reads), except
+ * SSL_CERT_FILE and SSL_CERT_DIR: '' empties OpenSSL's and Node's system
+ * store, so those two are pinned only when the worker sets them.
+ *
+ * Source: the names Claude Code 2.1.304 (the bundled CLI) reads, by a grep
+ * of the binary; the CLI's own lists of endpoints (with their selection
+ * switches and companions) and credentials are in it as they are there. A
+ * deny-list, because a settings layer can only pin names known in advance.
+ * Left out, each for its reason: the model variables (same endpoint, same
+ * key), what the CLI already drops from a folder's settings or from all
+ * settings (CLAUDE_CONFIG_DIR, CLAUDE_CODE_CUSTOM_OAUTH_URL, the OTEL
+ * exporter endpoints, ANTHROPIC_UNIX_SOCKET, the host-managed provider
+ * switches, the file-descriptor credentials), a provider's own SDK settings
+ * (AWS_*, GOOGLE_*, AZURE_*, read only for the provider the switches here
+ * turn off), NODE_OPTIONS (at runtime the CLI reads only its system-CA
+ * flags, which add no CA), and what routes only other programs' traffic
+ * (NPM_CONFIG_*, GIT_*, the resolver's variables).
+ */
+export const DEEPSEEK_CLI_PINNED_ENV = Object.freeze([
+  // Endpoints: the CLI's list, its fallback and the headers sent with them.
+  'ANTHROPIC_BASE_URL',
+  '_CLAUDE_CODE_ASSUME_FIRST_PARTY_BASE_URL',
+  'ANTHROPIC_CUSTOM_HEADERS',
+  'ANTHROPIC_BEDROCK_BASE_URL',
+  'ANTHROPIC_VERTEX_BASE_URL',
+  'ANTHROPIC_FOUNDRY_BASE_URL',
+  'ANTHROPIC_AWS_BASE_URL',
+  'ANTHROPIC_GOOGLE_CLOUD_BASE_URL',
+  'ANTHROPIC_BEDROCK_MANTLE_BASE_URL',
+  'CLAUDE_CODE_API_BASE_URL',
+  'CLAUDE_CODE_ARTIFACTS_API_BASE_URL',
+  'CLAUDE_CODE_ARTIFACTS_API_TOKEN',
+  'CLAUDE_CODE_ARTIFACT_ASSET_BASE_URL',
+  'CLAUDE_CODE_ARTIFACT_LIVE_BASE_URL',
+  'CLAUDE_CODE_ARTIFACT_SYNC_BASE_URL',
+  'CLAUDE_CODE_ARTIFACT_VIEWER_BASE_URL',
+  'CLAUDE_CODE_MEMORY_API_BASE_URL',
+  'CLAUDE_CODE_MEMORY_API_TOKEN',
+  // Provider switches.
+  'CLAUDE_CODE_USE_BEDROCK',
+  'CLAUDE_CODE_USE_VERTEX',
+  'CLAUDE_CODE_USE_FOUNDRY',
+  'CLAUDE_CODE_USE_ANTHROPIC_AWS',
+  'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
+  'CLAUDE_CODE_USE_MANTLE',
+  'CLAUDE_CODE_USE_GATEWAY',
+  'CLAUDE_CODE_SKIP_BEDROCK_AUTH',
+  'CLAUDE_CODE_SKIP_VERTEX_AUTH',
+  'CLAUDE_CODE_SKIP_FOUNDRY_AUTH',
+  'CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH',
+  'CLAUDE_CODE_SKIP_ANTHROPIC_GOOGLE_CLOUD_AUTH',
+  'CLAUDE_CODE_SKIP_MANTLE_AUTH',
+  // Credentials: the CLI's list, the OAuth login, the federation profile and
+  // the proxy credential helper.
+  'ANTHROPIC_API_KEY',
+  'ANTHROPIC_AUTH_TOKEN',
+  'CLAUDE_CODE_OAUTH_TOKEN',
+  'AWS_BEARER_TOKEN_BEDROCK',
+  'ANTHROPIC_FOUNDRY_API_KEY',
+  'ANTHROPIC_FOUNDRY_AUTH_TOKEN',
+  'ANTHROPIC_AWS_API_KEY',
+  'CLAUDE_CODE_OAUTH_REFRESH_TOKEN',
+  'CLAUDE_CODE_OAUTH_SCOPES',
+  'CLAUDE_CODE_OAUTH_CLIENT_ID',
+  'ANTHROPIC_PROFILE',
+  'ANTHROPIC_IDENTITY_TOKEN',
+  'ANTHROPIC_IDENTITY_TOKEN_FILE',
+  'ANTHROPIC_FEDERATION_RULE_ID',
+  'ANTHROPIC_ORGANIZATION_ID',
+  'ANTHROPIC_SERVICE_ACCOUNT_ID',
+  'ANTHROPIC_SCOPE',
+  'ANTHROPIC_WORKSPACE_ID',
+  'CLAUDE_CODE_ENABLE_PROXY_AUTH_HELPER',
+  // Proxies: the CLI reads both cases, the lower one first.
+  'HTTPS_PROXY',
+  'https_proxy',
+  'HTTP_PROXY',
+  'http_proxy',
+  'ALL_PROXY',
+  'all_proxy',
+  'NO_PROXY',
+  'no_proxy',
+  'CLAUDE_CODE_HTTPS_PROXY',
+  'CLAUDE_CODE_HTTP_PROXY',
+  // TLS trust and the client certificate.
+  'NODE_TLS_REJECT_UNAUTHORIZED',
+  'NODE_EXTRA_CA_CERTS',
+  'CLAUDE_CODE_CERT_STORE',
+  'CLAUDE_CODE_CLIENT_CERT',
+  'CLAUDE_CODE_CLIENT_KEY',
+  'CLAUDE_CODE_CLIENT_KEY_PASSPHRASE',
+  'SSL_CERT_FILE',
+  'SSL_CERT_DIR',
+]);
+// The two of DEEPSEEK_CLI_PINNED_ENV for which '' is not unset (see there).
+const PINNED_ONLY_WHEN_SET = new Set(['SSL_CERT_FILE', 'SSL_CERT_DIR']);
+// The proxy variables the CLI and the tools it runs read in either case.
+const OTHER_CASE = new Map(
+  ['HTTPS_PROXY', 'HTTP_PROXY', 'ALL_PROXY', 'NO_PROXY'].flatMap((name) => [
+    [name, name.toLowerCase()],
+    [name.toLowerCase(), name],
+  ]),
+);
+
+/**
+ * The pins of DEEPSEEK_CLI_PINNED_ENV for a CLI spawned with `cliEnv`: the
+ * value it was spawned with, else the other case's (a proxy the worker sets
+ * as https_proxy holds for HTTPS_PROXY as well), else ''.
+ */
+export function deepseekPinnedEnv(cliEnv = {}) {
+  const pins = {};
+  for (const name of DEEPSEEK_CLI_PINNED_ENV) {
+    const own = cliEnv[name] ?? cliEnv[OTHER_CASE.get(name)];
+    if (own !== undefined) pins[name] = String(own);
+    else if (!PINNED_ONLY_WHEN_SET.has(name)) pins[name] = '';
+  }
+  return pins;
+}
+
+/**
+ * Whether a variable of the worker's stays out of the CLI's environment:
+ * another Anthropic configuration or credential, the relay's settings for
+ * its worker, or the host Claude Code session's variables when the relay was
+ * started from inside one (shared/host-claude-session-env.mjs; the launcher
+ * drops those for every worker, the backend again, so a CLI talking to
+ * DeepSeek never reads itself as a child of the host's session, however the
+ * worker was started).
+ */
+function isForeignCliVariable(key) {
+  return FOREIGN_CLI_VARIABLES.includes(key)
+    || FOREIGN_CLI_PREFIXES.some((prefix) => key.startsWith(prefix))
+    || isHostClaudeSessionVariable(key);
+}
+
+function text(value) {
+  return String(value ?? '').trim();
+}
+
+function withoutSuffix(value) {
+  return text(value).replace(LONG_CONTEXT_SUFFIX_PATTERN, '');
+}
+
+/**
+ * The relay's id of a model the CLI names: "deepseek-flash[1m]" →
+ * "deepseek-flash"; a Claude id ("claude-opus-5-5", from a CLI spawned
+ * without the alias pins) → the DeepSeek model that served it; anything else
+ * as given, without the suffix.
+ */
+export function deepseekRelayModel(value) {
+  return deepseekServedModel(value) || withoutSuffix(value);
+}
+
+/** The id the CLI gets: the relay's id with the 1M suffix. */
+export function deepseekCliModel(value) {
+  const model = deepseekRelayModel(value);
+  return model ? `${model}${LONG_CONTEXT_SUFFIX}` : '';
+}
+
+/**
+ * The DeepSeek model a sub-agent runs on, from what the runner knows of it:
+ * the model its own frames name (a DeepSeek id, or a Claude id DeepSeek
+ * served), else the alias the spawning tool pinned ("haiku" is the helper
+ * model, every other alias the session's model), else the session's model.
+ */
+export function deepseekSubagentModel(value, sessionModel = '') {
+  const served = deepseekServedModel(value);
+  if (served) return served;
+  if (withoutSuffix(value).toLowerCase() === HELPER_ALIAS) return HELPER_MODEL;
+  return deepseekRelayModel(sessionModel);
+}
+
+/** The session model a CLI is pinned to, in the CLI's terms; unknown or none is the default model. */
+function pinnedCliModel(model) {
+  const relayModel = deepseekRelayModel(model);
+  return deepseekCliModel(isDeepSeekModelId(relayModel) ? relayModel : DEFAULT_DEEPSEEK_MODEL);
+}
+
+/**
+ * `{ code, guidance }` for a failed request DeepSeek has its own advice for,
+ * or null. Read from the HTTP status the result reports, else from the
+ * status the CLI quotes in its error text ("API Error: 402 …").
+ */
+export function describeDeepSeekFailure(errorText, { status = null } = {}) {
+  const message = text(errorText);
+  const code = Number(status);
+  if (code === 402 || /\b402\b|insufficient[ _]balance/i.test(message)) {
+    return {
+      code: 'deepseek-balance',
+      guidance: 'The DeepSeek account balance is used up. Top it up at https://platform.deepseek.com/top_up, then send the message again.',
+    };
+  }
+  if (code === 401 || /\b401\b|authentication[_ ]error|invalid api key/i.test(message)) {
+    return {
+      code: 'deepseek-api-key',
+      guidance: 'DeepSeek did not accept the API key. Check it in Settings → Providers → DeepSeek, then send the message again.',
+    };
+  }
+  if (code === 429 || /\b429\b|rate[_ ]limit/i.test(message)) {
+    return {
+      code: 'deepseek-rate-limit',
+      guidance: 'DeepSeek is at its concurrency limit for this account. Send the message again in a moment.',
+    };
+  }
+  return null;
+}
+
+export function createDeepSeekClaudeBackend({ env = process.env } = {}) {
+  const apiKey = text(env.DEEPSEEK_API_KEY);
+  const anthropicBaseUrl = deepseekAnthropicBaseUrl(text(env.DEEPSEEK_BASE_URL));
+  const configDir = text(env.DEEPSEEK_CLAUDE_CONFIG_DIR);
+
+  /** DeepSeek's level for a requested effort; unset and unknown are high. */
+  function effortFor(value) {
+    return deepseekReasoningEffortFor(value) || 'high';
+  }
+
+  /**
+   * The CLI's environment. Built from the worker's own (which must not reach
+   * the CLI as it is: it carries DEEPSEEK_API_KEY and possibly the host's
+   * Anthropic settings), so every Anthropic variable is replaced. `model` is
+   * the session's model, which every alias is pinned to.
+   */
+  function spawnEnv(baseEnv = process.env, { effort = '', model = '' } = {}) {
+    if (!apiKey) throw new Error('deepseek-api-key-not-configured');
+    if (!configDir) throw new Error('deepseek-config-dir-not-configured');
+    const next = {};
+    for (const [key, value] of Object.entries(baseEnv || {})) {
+      if (isForeignCliVariable(key)) continue;
+      next[key] = value;
+    }
+    next.ANTHROPIC_BASE_URL = anthropicBaseUrl;
+    next.ANTHROPIC_AUTH_TOKEN = apiKey;
+    // Every alias Claude Code resolves on its own ("opus", a sub-agent
+    // without a model) lands on the session's model: without a pin the CLI
+    // sends a Claude id, which DeepSeek serves by its own mapping
+    // (claude-opus → V4 Pro), off the model the chat is locked to.
+    const sessionModel = pinnedCliModel(model);
+    for (const key of SESSION_MODEL_VARIABLES) next[key] = sessionModel;
+    for (const key of HELPER_MODEL_VARIABLES) next[key] = HELPER_MODEL;
+    next.CLAUDE_CONFIG_DIR = configDir;
+    next.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
+    next.CLAUDE_CODE_EFFORT_LEVEL = effortFor(effort);
+    return next;
+  }
+
+  return {
+    id: DEEPSEEK_PROVIDER_TYPE,
+    providerType: DEEPSEEK_PROVIDER_TYPE,
+    label: 'DeepSeek',
+    configDir,
+    defaultModel: DEFAULT_DEEPSEEK_MODEL,
+    // Neither is DeepSeek's: Claude's plan windows and its usage limit.
+    reportsPlanUsage: false,
+    reportsUsageLimit: false,
+    // What it reports instead: the CLI's token totals per model, by the
+    // relay's model ids (relayModel); the relay books what each report adds.
+    // Claude Code's `total_cost_usd` is at Claude's prices and is not sent.
+    usageRoute: '/api/deepseek-plan-usage',
+
+    // A Claude id is not a model of DeepSeek's to request, only one it may
+    // have served (relayModel).
+    isModel: (value) => isDeepSeekModelId(withoutSuffix(value)),
+    cliModel: deepseekCliModel,
+    relayModel: deepseekRelayModel,
+    subagentModel: deepseekSubagentModel,
+    acceptsImages: (model) => deepseekModelAcceptsImages(deepseekRelayModel(model)),
+    describeFailure: describeDeepSeekFailure,
+
+    effortFor,
+    /** The SDK's `effort` option: DeepSeek's level. */
+    effortOption: effortFor,
+    /** DeepSeek always thinks (see the effort note above). */
+    thinkingEnabled: () => true,
+    /**
+     * What only a fresh CLI takes, the effort and the model the aliases are
+     * pinned to: a change respawns it between turns. `model` is the turn's
+     * resolved model (the runner's, not the message's alone).
+     */
+    spawnKey: (message = {}, { model = '' } = {}) => `${effortFor(message.reasoningEffort)} ${pinnedCliModel(model)}`,
+
+    spawnEnv,
+
+    /**
+     * The CLI's routing, trust and credentials once more, in its flag
+     * settings layer, which outranks the settings of the chat's folder: a
+     * .claude/settings.json or settings.local.json there whose
+     * env.ANTHROPIC_BASE_URL, proxy or CA points elsewhere would otherwise
+     * get the DeepSeek key as its bearer token (scripts/deepseek-cli-proof.mjs).
+     * Every variable of DEEPSEEK_CLI_PINNED_ENV holds the value of `cliEnv`,
+     * the environment the CLI was spawned with (spawnEnv), or is blanked, and
+     * so is an apiKeyHelper of the folder's. The key may not go on the
+     * command line, so the adapter sends these over the control channel
+     * before the first message (startClaudeSession).
+     */
+    liveFlagSettings(cliEnv = spawnEnv(env)) {
+      if (!apiKey) throw new Error('deepseek-api-key-not-configured');
+      return {
+        env: { ...deepseekPinnedEnv(cliEnv), ANTHROPIC_BASE_URL: anthropicBaseUrl, ANTHROPIC_AUTH_TOKEN: apiKey },
+        apiKeyHelper: '',
+      };
+    },
+  };
+}

package/server/deepseek-worker/deepseek-session-worker.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// DeepSeek session worker: the Claude session worker with its CLI pointed at
+// DeepSeek's Anthropic-compatible endpoint (deepseek-claude-backend.mjs). The
+// relay's launch puts the key in DEEPSEEK_API_KEY (through the owner-only
+// secret file under tmux) and names the worker's own Claude Code state
+// directory in DEEPSEEK_CLAUDE_CONFIG_DIR.
+import fs from 'node:fs';
+
+import { installWorkerLogFile, installWorkerLogRedaction } from '../../shared/worker-runtime/worker-log-file.mjs';
+import { runClaudeSessionWorker } from '../claude-worker/claude-session-worker-main.mjs';
+import { createDeepSeekClaudeBackend } from './deepseek-claude-backend.mjs';
+
+installWorkerLogFile();
+// The key never shows in this worker's console or log, whatever the CLI or
+// the agent prints (installed after the log file, so its copy is redacted too).
+installWorkerLogRedaction({ secrets: [process.env.DEEPSEEK_API_KEY] });
+
+const backend = createDeepSeekClaudeBackend({ env: process.env });
+
+// The worker reads the CLI's state too (the transcript a resume needs, the
+// workflow files): it has to look where its CLI writes, never in the host's
+// ~/.claude. The directory holds sessions, so only this user may open it.
+if (backend.configDir) {
+  fs.mkdirSync(backend.configDir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(backend.configDir, 0o700); } catch {}
+  process.env.CLAUDE_CONFIG_DIR = backend.configDir;
+}
+
+runClaudeSessionWorker({
+  logTag: 'deepseek-worker',
+  workerName: 'deepseek-session-worker',
+  defaultModel: String(process.env.DEEPSEEK_RELAY_MODEL || '').trim() || backend.defaultModel,
+  backend,
+}).catch((error) => {
+  console.error('deepseek-session-worker fatal:', error?.stack || error?.message || error);
+  process.exit(1);
+});

package/server/migrations/0019-relay-event-subscription-options.mjs

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * Migration: options of relay event subscriptions.
+ *
+ * Columns on `relay_event_subscriptions` (all NULL = off, as before):
+ *
+ * - `digest_minutes`: the subscription's non-urgent events are held and
+ *   delivered as one row every N minutes; `digest_last_at` is when its last
+ *   such row went out (the next one is due N minutes after it).
+ * - `quiet_hours_json`: `{ from, to, tz }`; non-urgent events in the window
+ *   are held until it ends.
+ * - `exclude_json`: session ids an "all" subscription leaves out.
+ *
+ * `relay_event_own_prompts`: the prompts a watcher sent through send or
+ * create_session (`message_id` is the prompt's), and when it received the
+ * finished reply (`received_at`): the turn_end of such a turn is not
+ * delivered to it again. Rows go after a day.
+ *
+ * Held events are ordinary undelivered `relay_events` rows: they and the
+ * timers rebuilt from them survive a restart without anything more here.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0019-relay-event-subscription-options.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const RELAY_EVENT_OPTION_COLUMNS = Object.freeze([
+  ['digest_minutes', 'INTEGER'],
+  ['digest_last_at', 'TEXT'],
+  ['quiet_hours_json', 'TEXT'],
+  ['exclude_json', 'TEXT'],
+]);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function migrateRelayEventSubscriptionOptions(db) {
+  if (!tableExists(db, 'relay_event_subscriptions')) {
+    throw new Error('relay_event_subscriptions is missing (migration 0011 has not run)');
+  }
+  const present = new Set(db.prepare(`PRAGMA table_info(relay_event_subscriptions)`).all().map((column) => column.name));
+  let columnsAdded = 0;
+  for (const [name, type] of RELAY_EVENT_OPTION_COLUMNS) {
+    if (present.has(name)) continue;
+    db.exec(`ALTER TABLE relay_event_subscriptions ADD COLUMN ${name} ${type}`);
+    columnsAdded += 1;
+  }
+  let tablesAdded = 0;
+  if (!tableExists(db, 'relay_event_own_prompts')) {
+    db.exec(`
+      CREATE TABLE relay_event_own_prompts (
+        message_id              TEXT PRIMARY KEY,
+        watcher_conversation_id TEXT NOT NULL,
+        relay_id                TEXT NOT NULL DEFAULT 'self',
+        session_id              TEXT NOT NULL,
+        created_at              TEXT NOT NULL,
+        received_at             TEXT
+      )
+    `);
+    tablesAdded += 1;
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_relay_event_own_prompts_created
+    ON relay_event_own_prompts(created_at)
+  `);
+  return { applied: columnsAdded > 0 || tablesAdded > 0, columnsAdded, tablesAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateRelayEventSubscriptionOptions(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0019 on ${dbPath}`);
+    console.log(result.applied
+      ? `  relay event subscription options: columns added ${result.columnsAdded}, tables added ${result.tablesAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0019 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0020-conversation-may-create-sessions.mjs

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * Migration: the owner's "agents in this conversation may start sessions".
+ *
+ * `may_create_sessions` is 1 when the owner allowed the agents of a session
+ * that an agent started to start sessions on this relay themselves (the
+ * remote_relay tool's one-level rule is lifted for it); NULL or 0 otherwise.
+ * Only the owner sets it, in the conversation's settings or through the
+ * preferences route; no agent can.
+ *
+ * Additive and idempotent. Safe to run on every boot. Rolling back needs no
+ * data change: older code ignores the column and keeps the one-level rule.
+ *
+ * Usage: node server/migrations/0020-conversation-may-create-sessions.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function migrateConversationMayCreateSessions(db) {
+  if (!tableExists(db, 'conversations')) {
+    throw new Error('conversations is missing (the base schema has not run)');
+  }
+  const present = new Set(db.prepare(`PRAGMA table_info(conversations)`).all().map((column) => column.name));
+  if (present.has('may_create_sessions')) return { applied: false, columnsAdded: 0 };
+  db.exec(`ALTER TABLE conversations ADD COLUMN may_create_sessions INTEGER`);
+  return { applied: true, columnsAdded: 1 };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateConversationMayCreateSessions(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0020 on ${dbPath}`);
+    console.log(result.applied
+      ? `  may create sessions: columns added ${result.columnsAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0020 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}