Support headless Codex OAuth import for HF Spaces

Dockerfile

@@ -24,6 +24,7 @@ RUN git clone --depth 1 --branch "${OPENCLAW_REF}" "${OPENCLAW_REPO}" . \
     && pnpm install --frozen-lockfile \
     && pnpm build
 COPY setup-hf-config.mjs /app/setup-hf-config.mjs
+COPY import-auth-profiles.mjs /app/import-auth-profiles.mjs
 COPY sync-external-storage.mjs /app/sync-external-storage.mjs
 ENV OPENCLAW_PREFER_PNPM=1
 RUN pnpm ui:build
@@ -44,6 +45,7 @@ RUN printf '%s\n' \
     '  mkdir -p /home/user/.openclaw' \
     'fi' \
     'node /app/setup-hf-config.mjs' \
+    'node /app/import-auth-profiles.mjs' \
     'if [ "${OPENCLAW_ENABLE_GEMINI_CLI_AUTH:-1}" = "1" ]; then' \
     '  node /app/openclaw.mjs plugins enable google-gemini-cli-auth >/tmp/openclaw-gemini-cli.log 2>&1 || true' \
     'fi' \

README.md

@@ -46,7 +46,7 @@ When the logs show `listening on ws://0.0.0.0:7860`, open your Space’s URL (e.
 - **The startup script now writes both `primary` and `fallbacks`.**
 - **Codex fallback only works if Codex itself is already authenticated and usable.** If `openai-codex/gpt-5.4` still lacks auth, fallback will still fail when traffic reaches it.
 - **OpenCode Zen** also works well in Hugging Face Spaces. Set `OPENCODE_API_KEY` and use a default model such as `opencode/claude-opus-4-6`.
-- **Codex auth remains the special case**: if your `openai-codex/gpt-5.4` path depends on OAuth-backed credentials, use a separate environment that can complete the login flow first, or expect the Codex fallback to fail.
+- **Codex auth remains the special case**: in headless Spaces, the reliable path is to complete Codex OAuth elsewhere, then import the resulting OpenClaw auth profile via a Space Secret (see below). Running the interactive OAuth flow inside the Space is usually unreliable.
 - **Telegram minimal setup** only needs `TELEGRAM_BOT_TOKEN`.
 - **Telegram advanced settings** are optional and only needed when you want allowlists, group restrictions, or mention-only behavior.
 
@@ -145,12 +145,19 @@ The startup script `setup-hf-config.mjs` reads the following from **Secrets** or
 | Env variable | Config path | Format |
 |--------------|------------|--------|
 | `OPENCLAW_MODEL_PRIMARY` | `agents.defaults.model.primary` | Primary model ref string |
+| `OPENCLAW_DEFAULT_MODEL` | `agents.defaults.model.primary` | Legacy alias for primary model |
+| `OPENCLAW_HF_DEFAULT_MODEL` | `agents.defaults.model.primary` | Legacy alias for primary model |
 | `OPENCLAW_MODEL_FALLBACK_1` | `agents.defaults.model.fallbacks[0]` | First fallback model ref |
 | `OPENCLAW_MODEL_FALLBACK_2` | `agents.defaults.model.fallbacks[1]` | Second fallback model ref |
+| `OPENCLAW_FALLBACK_MODELS` | `agents.defaults.model.fallbacks` | Comma-separated fallback model refs |
 | `OPENCLAW_GATEWAY_TOKEN` | `gateway.auth.mode` + `gateway.auth.token` | Any string |
 | `OPENCLAW_GATEWAY_PASSWORD` | `gateway.auth.mode` + `gateway.auth.password` | Any string (token wins if both set) |
 | `OPENCLAW_GATEWAY_TRUSTED_PROXIES` | `gateway.trustedProxies` | Comma-separated IPs |
 | `OPENCLAW_CONTROL_UI_ALLOWED_ORIGINS` | `gateway.controlUi.allowedOrigins` | Comma-separated origins (e.g. `https://you.hf.space`) |
+| `OPENCLAW_CONTROL_UI_ALLOWED_ORIGIN` | `gateway.controlUi.allowedOrigins` | Legacy single-origin alias |
+| `OPENCLAW_AUTH_PROFILES_JSON_B64` | startup auth import | Base64-encoded full `auth-profiles.json` exported from another OpenClaw host |
+| `OPENCLAW_OPENAI_CODEX_PROFILE_B64` | startup auth import | Base64-encoded JSON object for one `openai-codex:default` profile |
+| `OPENCLAW_LEGACY_OAUTH_JSON_B64` | startup auth import | Base64-encoded legacy `credentials/oauth.json` import file |
 | `OPENCLAW_ENABLE_GEMINI_CLI_AUTH` | startup plugin bootstrap | `1` / `0`; enables `google-gemini-cli-auth` before gateway start |
 | `TELEGRAM_BOT_TOKEN` | `channels.telegram.botToken` | BotFather token |
 | `OPENCLAW_TELEGRAM_DM_POLICY` | `channels.telegram.dmPolicy` | `pairing` \| `allowlist` \| `open` \| `disabled` |
@@ -176,6 +183,29 @@ The startup script `setup-hf-config.mjs` reads the following from **Secrets** or
 | `OPENCLAW_CONTROL_UI_ENABLED` | `gateway.controlUi.enabled` | `0` to disable Control UI. |
 | `OPENCLAW_CODEX_OAUTH_*` | auth profile store | Depends on upstream OpenClaw support and your runtime's ability to complete the OAuth flow with persistent auth storage. |
 
+### Headless Codex OAuth import for Spaces
+
+For `openai-codex/gpt-5.4` on Hugging Face Spaces, the reliable path is:
+
+1. Complete `openclaw models auth login --provider openai-codex` on another machine.
+2. Copy the resulting `~/.openclaw/agents/main/agent/auth-profiles.json`.
+3. Base64-encode it and store it in a Space Secret named `OPENCLAW_AUTH_PROFILES_JSON_B64`.
+4. On startup, this repo imports that file into the Space state automatically.
+
+If you only want the Codex profile instead of the whole file, you can provide a single profile JSON object in `OPENCLAW_OPENAI_CODEX_PROFILE_B64`.
+
+Example encoding command:
+
+```bash
+base64 -w0 ~/.openclaw/agents/main/agent/auth-profiles.json
+```
+
+After restart, verify in Space logs that startup printed something like:
+
+```text
+[openclaw-hf-auth-import] imported=auth-profiles profiles=...
+```
+
 To add more, extend `setup-hf-config.mjs` (or your copy) to read the env, parse it, and set the corresponding keys on `config.gateway` or `config.agents` before `fs.writeFileSync`. Schema reference: [Configuration](https://docs.openclaw.ai/gateway/configuration).
 
 ## Optional Space variables (build args)

import-auth-profiles.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+const home = process.env.OPENCLAW_HOME || process.env.HOME || '/home/user';
+const stateDir = path.join(home, '.openclaw');
+const agentDir = path.join(stateDir, 'agents', 'main', 'agent');
+const authProfilesPath = path.join(agentDir, 'auth-profiles.json');
+const legacyOauthPath = path.join(stateDir, 'credentials', 'oauth.json');
+
+function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); }
+function parseJson(raw, label) {
+  try { return JSON.parse(raw); } catch (err) { throw new Error(`Failed to parse ${label}: ${err.message}`); }
+}
+function writeJson(p, data) { ensureDir(path.dirname(p)); fs.writeFileSync(p, JSON.stringify(data, null, 2) + '\n', 'utf8'); }
+function readFileMaybe(p) { try { return fs.readFileSync(p, 'utf8'); } catch { return ''; } }
+
+function normalizeAuthProfiles(data) {
+  if (!data || typeof data !== 'object') throw new Error('auth profiles payload must be a JSON object');
+  if (!data.profiles || typeof data.profiles !== 'object') throw new Error('auth profiles payload missing profiles object');
+  return {
+    version: typeof data.version === 'number' ? data.version : 1,
+    profiles: data.profiles,
+    usageStats: data.usageStats && typeof data.usageStats === 'object' ? data.usageStats : {},
+  };
+}
+
+function upsertCodexProfile(existing, codexProfile) {
+  const next = normalizeAuthProfiles(existing && typeof existing === 'object' ? existing : { profiles: {} });
+  next.profiles['openai-codex:default'] = {
+    ...next.profiles['openai-codex:default'],
+    ...codexProfile,
+    provider: 'openai-codex',
+  };
+  return next;
+}
+
+const authProfilesB64 = process.env.OPENCLAW_AUTH_PROFILES_JSON_B64?.trim();
+const authProfilesJson = process.env.OPENCLAW_AUTH_PROFILES_JSON?.trim();
+const codexProfileB64 = process.env.OPENCLAW_OPENAI_CODEX_PROFILE_B64?.trim();
+const codexProfileJson = process.env.OPENCLAW_OPENAI_CODEX_PROFILE_JSON?.trim();
+const legacyOauthB64 = process.env.OPENCLAW_LEGACY_OAUTH_JSON_B64?.trim();
+const legacyOauthJson = process.env.OPENCLAW_LEGACY_OAUTH_JSON?.trim();
+
+let imported = 'none';
+let detail = '';
+
+if (authProfilesB64 || authProfilesJson) {
+  const raw = authProfilesJson || Buffer.from(authProfilesB64, 'base64').toString('utf8');
+  const parsed = normalizeAuthProfiles(parseJson(raw, 'OPENCLAW_AUTH_PROFILES_JSON(_B64)'));
+  writeJson(authProfilesPath, parsed);
+  imported = 'auth-profiles';
+  detail = `profiles=${Object.keys(parsed.profiles).length}`;
+} else if (codexProfileB64 || codexProfileJson) {
+  const raw = codexProfileJson || Buffer.from(codexProfileB64, 'base64').toString('utf8');
+  const codexProfile = parseJson(raw, 'OPENCLAW_OPENAI_CODEX_PROFILE_JSON(_B64)');
+  const existingRaw = readFileMaybe(authProfilesPath);
+  const existing = existingRaw ? parseJson(existingRaw, authProfilesPath) : { version: 1, profiles: {}, usageStats: {} };
+  const merged = upsertCodexProfile(existing, codexProfile);
+  writeJson(authProfilesPath, merged);
+  imported = 'codex-profile';
+  detail = 'profile=openai-codex:default';
+} else if (legacyOauthB64 || legacyOauthJson) {
+  const raw = legacyOauthJson || Buffer.from(legacyOauthB64, 'base64').toString('utf8');
+  const parsed = parseJson(raw, 'OPENCLAW_LEGACY_OAUTH_JSON(_B64)');
+  writeJson(legacyOauthPath, parsed);
+  imported = 'legacy-oauth';
+  detail = 'wrote credentials/oauth.json';
+}
+
+console.log(`[openclaw-hf-auth-import] imported=${imported}${detail ? ' ' + detail : ''} path=${authProfilesPath}`);

setup-hf-config.mjs

@@ -61,13 +61,18 @@ function readIndexedEnv(prefix) {
 }
 
 const fallbackModelsFromIndexedEnv = readIndexedEnv("OPENCLAW_MODEL_FALLBACK_");
+const fallbackModelsFromCsv = parseCsv(process.env.OPENCLAW_FALLBACK_MODELS?.trim());
 const defaultModel =
   process.env.OPENCLAW_MODEL_PRIMARY?.trim() ||
+  process.env.OPENCLAW_DEFAULT_MODEL?.trim() ||
+  process.env.OPENCLAW_HF_DEFAULT_MODEL?.trim() ||
   "huggingface/Qwen/Qwen3-8B";
 const fallbackModels =
   fallbackModelsFromIndexedEnv.length > 0
     ? fallbackModelsFromIndexedEnv
-    : ["huggingface/deepseek-ai/DeepSeek-R1", "openai-codex/gpt-5.4"];
+    : fallbackModelsFromCsv.length > 0
+      ? fallbackModelsFromCsv
+      : ["huggingface/deepseek-ai/DeepSeek-R1", "openai-codex/gpt-5.4"];
 const gatewayToken = readGatewayToken();
 const gatewayPassword = process.env.OPENCLAW_GATEWAY_PASSWORD?.trim();
 const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN?.trim();
@@ -97,7 +102,11 @@ const trustedProxies =
     ? parseCsv(trustedProxiesRaw)
     : DEFAULT_HF_TRUSTED_PROXY_IPS;
 // Comma-separated origins allowed for Control UI/WebSocket (e.g. https://your-space.hf.space)
-const allowedOriginsRaw = process.env.OPENCLAW_CONTROL_UI_ALLOWED_ORIGINS?.trim();
+const allowedOriginsRaw = (
+  process.env.OPENCLAW_CONTROL_UI_ALLOWED_ORIGINS?.trim() ||
+  process.env.OPENCLAW_CONTROL_UI_ALLOWED_ORIGIN?.trim() ||
+  ''
+);
 const allowedOrigins = parseCsv(allowedOriginsRaw);
 
 let config = {};