@chrysb/alphaclaw 0.1.0

package/lib/public/js/lib/api.js

@@ -0,0 +1,196 @@
+const authFetch = async (url, opts = {}) => {
+  const res = await fetch(url, opts);
+  if (res.status === 401) {
+    window.location.href = '/setup';
+    throw new Error('Unauthorized');
+  }
+  return res;
+};
+
+export async function fetchStatus() {
+  const res = await authFetch('/api/status');
+  return res.json();
+}
+
+export async function fetchPairings() {
+  const res = await authFetch('/api/pairings');
+  return res.json();
+}
+
+export async function approvePairing(id, channel) {
+  const res = await authFetch(`/api/pairings/${id}/approve`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ channel }),
+  });
+  return res.json();
+}
+
+export async function rejectPairing(id, channel) {
+  const res = await authFetch(`/api/pairings/${id}/reject`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ channel }),
+  });
+  return res.json();
+}
+
+export async function fetchGoogleStatus() {
+  const res = await authFetch('/api/google/status');
+  return res.json();
+}
+
+export async function checkGoogleApis() {
+  const res = await authFetch('/api/google/check');
+  return res.json();
+}
+
+export async function saveGoogleCredentials(clientId, clientSecret, email) {
+  const res = await authFetch('/api/google/credentials', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ clientId, clientSecret, email }),
+  });
+  return res.json();
+}
+
+export async function disconnectGoogle() {
+  const res = await authFetch('/api/google/disconnect', { method: 'POST' });
+  return res.json();
+}
+
+export async function restartGateway() {
+  const res = await authFetch('/api/gateway/restart', { method: 'POST' });
+  return res.json();
+}
+
+export async function fetchDashboardUrl() {
+  const res = await authFetch('/api/gateway/dashboard');
+  return res.json();
+}
+
+export async function fetchOpenclawVersion(refresh = false) {
+  const query = refresh ? '?refresh=1' : '';
+  const res = await authFetch(`/api/openclaw/version${query}`);
+  return res.json();
+}
+
+export async function updateOpenclaw() {
+  const res = await authFetch('/api/openclaw/update', { method: 'POST' });
+  return res.json();
+}
+
+export async function fetchSyncCron() {
+  const res = await authFetch('/api/sync-cron');
+  const text = await res.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    throw new Error(text || 'Could not parse sync cron response');
+  }
+  if (!res.ok) {
+    throw new Error(data.error || text || `HTTP ${res.status}`);
+  }
+  return data;
+}
+
+export async function updateSyncCron(payload) {
+  const res = await authFetch('/api/sync-cron', {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+  const text = await res.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    throw new Error(text || 'Could not parse sync cron response');
+  }
+  if (!res.ok) {
+    throw new Error(data.error || text || `HTTP ${res.status}`);
+  }
+  return data;
+}
+
+export async function fetchDevicePairings() {
+  const res = await authFetch('/api/devices');
+  return res.json();
+}
+
+export async function approveDevice(id) {
+  const res = await authFetch(`/api/devices/${id}/approve`, { method: 'POST' });
+  return res.json();
+}
+
+export async function rejectDevice(id) {
+  const res = await authFetch(`/api/devices/${id}/reject`, { method: 'POST' });
+  return res.json();
+}
+
+export async function fetchOnboardStatus() {
+  const res = await authFetch('/api/onboard/status');
+  return res.json();
+}
+
+export async function runOnboard(vars, modelKey) {
+  const res = await authFetch('/api/onboard', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ vars, modelKey }),
+  });
+  return res.json();
+}
+
+export const fetchModels = async () => {
+  const res = await authFetch('/api/models');
+  return res.json();
+};
+
+export const fetchModelStatus = async () => {
+  const res = await authFetch('/api/models/status');
+  return res.json();
+};
+
+export const setPrimaryModel = async (modelKey) => {
+  const res = await authFetch('/api/models/set', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ modelKey }),
+  });
+  return res.json();
+};
+
+export const fetchCodexStatus = async () => {
+  const res = await authFetch('/api/codex/status');
+  return res.json();
+};
+
+export const disconnectCodex = async () => {
+  const res = await authFetch('/api/codex/disconnect', { method: 'POST' });
+  return res.json();
+};
+
+export const exchangeCodexOAuth = async (input) => {
+  const res = await authFetch('/api/codex/exchange', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ input }),
+  });
+  return res.json();
+};
+
+export async function fetchEnvVars() {
+  const res = await authFetch('/api/env');
+  return res.json();
+}
+
+export async function saveEnvVars(vars) {
+  const res = await authFetch('/api/env', {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ vars }),
+  });
+  return res.json();
+}

package/lib/public/js/lib/model-config.js

@@ -0,0 +1,88 @@
+export const getModelProvider = (modelKey) => String(modelKey || "").split("/")[0] || "";
+
+export const getAuthProviderFromModelProvider = (provider) =>
+  provider === "openai-codex" ? "openai" : provider;
+
+export const kFeaturedModelDefs = [
+  {
+    label: "Opus 4.6",
+    preferredKeys: ["anthropic/claude-opus-4-6", "anthropic/claude-opus-4-5"],
+  },
+  {
+    label: "Sonnet 4.6",
+    preferredKeys: ["anthropic/claude-sonnet-4-6", "anthropic/claude-sonnet-4-5"],
+  },
+  {
+    label: "Codex 5.3",
+    preferredKeys: ["openai-codex/gpt-5.3-codex", "openai-codex/gpt-5.2-codex"],
+  },
+  {
+    label: "Gemini 3",
+    preferredKeys: ["google/gemini-3-pro-preview", "google/gemini-3-flash-preview"],
+  },
+];
+
+export const getFeaturedModels = (allModels) => {
+  const picked = [];
+  const used = new Set();
+  kFeaturedModelDefs.forEach((def) => {
+    const found = def.preferredKeys
+      .map((key) => allModels.find((model) => model.key === key))
+      .find(Boolean);
+    if (!found || used.has(found.key)) return;
+    picked.push({ ...found, featuredLabel: def.label });
+    used.add(found.key);
+  });
+  return picked;
+};
+
+export const kProviderAuthFields = {
+  anthropic: [
+    {
+      key: "ANTHROPIC_API_KEY",
+      label: "Anthropic API Key",
+      hint: "From console.anthropic.com — recommended",
+      placeholder: "sk-ant-...",
+    },
+    {
+      key: "ANTHROPIC_TOKEN",
+      label: "Anthropic Setup Token",
+      hint: "From claude setup-token (uses your Claude subscription)",
+      placeholder: "Token...",
+    },
+  ],
+  openai: [
+    {
+      key: "OPENAI_API_KEY",
+      label: "OpenAI API Key",
+      hint: "From platform.openai.com",
+      placeholder: "sk-...",
+    },
+  ],
+  google: [
+    {
+      key: "GEMINI_API_KEY",
+      label: "Gemini API Key",
+      hint: "From aistudio.google.com",
+      placeholder: "AI...",
+    },
+  ],
+};
+
+export const kProviderLabels = {
+  anthropic: "Anthropic",
+  openai: "OpenAI",
+  google: "Gemini",
+};
+
+export const kProviderOrder = ["anthropic", "openai", "google"];
+
+export const getVisibleAiFieldKeys = (provider) => {
+  const authProvider = getAuthProviderFromModelProvider(provider);
+  const fields = kProviderAuthFields[authProvider] || [];
+  return new Set(fields.map((field) => field.key));
+};
+
+export const kAllAiAuthFields = Object.values(kProviderAuthFields)
+  .flat()
+  .filter((field, idx, arr) => arr.findIndex((item) => item.key === field.key) === idx);

package/lib/public/login.html

@@ -0,0 +1,90 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OpenClaw Setup</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+  <script>
+    tailwind.config = {
+      theme: {
+        extend: {
+          colors: {
+            surface: '#141414',
+            border: '#222',
+          }
+        }
+      }
+    }
+  </script>
+</head>
+<body class="bg-[#0a0a0a] text-gray-200 min-h-screen flex items-center justify-center p-4">
+  <div class="max-w-sm w-full">
+    <div class="flex items-center gap-3 mb-6">
+      <div class="text-4xl">🦞</div>
+      <div>
+        <h1 class="text-2xl font-semibold">OpenClaw Setup</h1>
+        <p class="text-gray-500 text-sm">Enter password to continue</p>
+      </div>
+    </div>
+    <form id="login-form" class="bg-surface border border-border rounded-xl p-4 space-y-3">
+      <input
+        id="password"
+        type="password"
+        placeholder="Password"
+        autofocus
+        class="w-full bg-black/30 border border-border rounded-lg px-3 py-2 text-sm text-gray-200 outline-none focus:border-gray-500"
+      />
+      <div id="error" class="text-red-400 text-xs hidden"></div>
+      <button type="submit" class="w-full bg-white text-black text-sm font-medium px-4 py-2 rounded-lg hover:opacity-85">
+        Continue
+      </button>
+    </form>
+  </div>
+  <script>
+    const formEl = document.getElementById('login-form');
+    const submitButtonEl = formEl.querySelector('button[type="submit"]');
+
+    const setPendingState = (isPending) => {
+      submitButtonEl.disabled = isPending;
+      submitButtonEl.classList.toggle('opacity-70', isPending);
+      submitButtonEl.classList.toggle('cursor-not-allowed', isPending);
+    };
+
+    formEl.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      const password = document.getElementById('password').value;
+      const errorEl = document.getElementById('error');
+      errorEl.classList.add('hidden');
+      setPendingState(true);
+      try {
+        const res = await fetch('/api/auth/login', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ password }),
+        });
+        const data = await res.json();
+        if (data.ok) {
+          window.location.href = '/';
+        } else {
+          if (res.status === 429) {
+            const retryAfterFromHeader = Number.parseInt(res.headers.get('retry-after') || '0', 10);
+            const retryAfterSec = Number.isFinite(data.retryAfterSec) && data.retryAfterSec > 0
+              ? data.retryAfterSec
+              : (Number.isFinite(retryAfterFromHeader) && retryAfterFromHeader > 0 ? retryAfterFromHeader : 30);
+            errorEl.textContent = `Too many attempts. Try again in ${retryAfterSec}s.`;
+          } else {
+            errorEl.textContent = data.error || 'Login failed';
+          }
+          errorEl.classList.remove('hidden');
+        }
+      } catch {
+        errorEl.textContent = 'Connection error';
+        errorEl.classList.remove('hidden');
+      } finally {
+        setPendingState(false);
+      }
+    });
+  </script>
+</body>
+</html>

package/lib/public/setup.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OpenClaw Setup</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+  <script>
+    tailwind.config = {
+      theme: {
+        extend: {
+          colors: {
+            surface: '#141414',
+            border: '#222',
+          }
+        }
+      }
+    }
+  </script>
+  <style>
+    ::placeholder { color: #444 !important; opacity: 1 !important; }
+    ::-webkit-input-placeholder { color: #444 !important; }
+    ::-moz-placeholder { color: #444 !important; }
+    .scope-btn { background: #1a1a1a; color: #555; border: 1px solid #333; transition: all 0.15s; }
+    .scope-btn:hover { border-color: #555; }
+    .scope-btn.active { background: #065f46; color: #6ee7b7; border-color: #059669; }
+  </style>
+</head>
+<body class="bg-[#0a0a0a] text-gray-200 min-h-screen flex justify-center pt-12 pb-8 px-4">
+  <div id="app" class="flex justify-center w-full"></div>
+  <script type="module" src="./js/app.js"></script>
+</body>
+</html>

package/lib/scripts/systemctl

@@ -0,0 +1,56 @@
+#!/bin/bash
+# systemctl shim for Docker (no real systemd available)
+# Translates restart/stop/status into process signals so the Express wrapper handles lifecycle.
+
+ACTION=""
+UNIT=""
+for arg in "$@"; do
+  case "$arg" in
+    --user|--system|--no-pager|--quiet) ;;
+    restart|stop|start|status|enable|disable|is-active|is-enabled|daemon-reload|show) ACTION="$arg" ;;
+    *) [ -n "$ACTION" ] && [ -z "$UNIT" ] && UNIT="$arg" ;;
+  esac
+done
+
+case "$ACTION" in
+  status)
+    if [ -z "$UNIT" ]; then
+      # Bare "systemctl --user status" — systemd availability check
+      echo "● user-session"
+      echo "   Active: active (running)"
+      exit 0
+    fi
+    # Status check for a specific unit
+    if pgrep -f "openclaw gateway" >/dev/null 2>&1; then
+      echo "● ${UNIT}"
+      echo "   Active: active (running)"
+      exit 0
+    else
+      echo "● ${UNIT}"
+      echo "   Active: inactive (dead)"
+      exit 3
+    fi
+    ;;
+  is-active)
+    if pgrep -f "openclaw gateway" >/dev/null 2>&1; then
+      echo "active"
+      exit 0
+    else
+      echo "inactive"
+      exit 3
+    fi
+    ;;
+  restart|stop)
+    pkill -TERM -f "openclaw gateway" 2>/dev/null || true
+    sleep 1
+    pkill -9 -f "openclaw gateway" 2>/dev/null || true
+    rm -f /data/.openclaw/gateway.lock /data/.openclaw/gateway.pid 2>/dev/null
+    exit 0
+    ;;
+  start|enable|is-enabled|disable|daemon-reload|show)
+    exit 0
+    ;;
+  *)
+    exit 0
+    ;;
+esac

package/lib/server/auth-profiles.js

@@ -0,0 +1,101 @@
+const fs = require("fs");
+const path = require("path");
+const { AUTH_PROFILES_PATH, CODEX_PROFILE_ID } = require("./constants");
+
+const createAuthProfiles = () => {
+  const ensureAuthProfilesStore = () => {
+    let store = { version: 1, profiles: {} };
+    try {
+      if (fs.existsSync(AUTH_PROFILES_PATH)) {
+        const parsed = JSON.parse(fs.readFileSync(AUTH_PROFILES_PATH, "utf8"));
+        if (
+          parsed &&
+          typeof parsed === "object" &&
+          parsed.profiles &&
+          typeof parsed.profiles === "object"
+        ) {
+          store = {
+            version: Number(parsed.version || 1),
+            profiles: parsed.profiles,
+            order: parsed.order,
+            lastGood: parsed.lastGood,
+            usageStats: parsed.usageStats,
+          };
+        }
+      }
+    } catch {}
+    return store;
+  };
+
+  const saveAuthProfilesStore = (store) => {
+    fs.mkdirSync(path.dirname(AUTH_PROFILES_PATH), { recursive: true });
+    fs.writeFileSync(
+      AUTH_PROFILES_PATH,
+      JSON.stringify(
+        {
+          version: Number(store.version || 1),
+          profiles: store.profiles || {},
+          order: store.order,
+          lastGood: store.lastGood,
+          usageStats: store.usageStats,
+        },
+        null,
+        2,
+      ),
+    );
+  };
+
+  const listCodexProfiles = () => {
+    const store = ensureAuthProfilesStore();
+    return Object.entries(store.profiles || {})
+      .filter(([, cred]) => cred?.provider === "openai-codex")
+      .map(([id, cred]) => ({ id, cred }));
+  };
+
+  const getCodexProfile = () => {
+    const profiles = listCodexProfiles();
+    if (profiles.length === 0) return null;
+    const preferred = profiles.find((p) => p.id === CODEX_PROFILE_ID) || profiles[0];
+    return { profileId: preferred.id, ...preferred.cred };
+  };
+
+  const hasCodexOauthProfile = () => {
+    const profile = getCodexProfile();
+    return !!(profile?.access && profile?.refresh);
+  };
+
+  const upsertCodexProfile = ({ access, refresh, expires, accountId }) => {
+    const store = ensureAuthProfilesStore();
+    store.profiles[CODEX_PROFILE_ID] = {
+      type: "oauth",
+      provider: "openai-codex",
+      access,
+      refresh,
+      expires,
+      ...(accountId ? { accountId } : {}),
+    };
+    saveAuthProfilesStore(store);
+  };
+
+  const removeCodexProfiles = () => {
+    const store = ensureAuthProfilesStore();
+    let changed = false;
+    for (const [id, cred] of Object.entries(store.profiles || {})) {
+      if (cred?.provider === "openai-codex") {
+        delete store.profiles[id];
+        changed = true;
+      }
+    }
+    if (changed) saveAuthProfilesStore(store);
+    return changed;
+  };
+
+  return {
+    getCodexProfile,
+    hasCodexOauthProfile,
+    upsertCodexProfile,
+    removeCodexProfiles,
+  };
+};
+
+module.exports = { createAuthProfiles };

package/lib/server/commands.js

@@ -0,0 +1,84 @@
+const { exec } = require("child_process");
+const { OPENCLAW_DIR, GOG_KEYRING_PASSWORD } = require("./constants");
+
+const createCommands = ({ gatewayEnv }) => {
+  const shellCmd = (cmd, opts = {}) =>
+    new Promise((resolve, reject) => {
+      const { logStdout, ...execOpts } = opts;
+      const shouldLogStdout =
+        typeof logStdout === "boolean" ? logStdout : !cmd.includes("--json");
+      console.log(
+        `[onboard] Running: ${cmd
+          .replace(/ghp_[^\s"]+/g, "***")
+          .replace(/sk-[^\s"]+/g, "***")
+          .slice(0, 200)}`,
+      );
+      exec(cmd, { timeout: 60000, ...execOpts }, (err, stdout, stderr) => {
+        if (err) {
+          console.error(
+            `[onboard] Error: ${(stderr || err.message).slice(0, 300)}`,
+          );
+          return reject(err);
+        }
+        if (shouldLogStdout && stdout.trim()) {
+          console.log(`[onboard] ${stdout.trim().slice(0, 300)}`);
+        }
+        resolve(stdout.trim());
+      });
+    });
+
+  const clawCmd = (cmd, { quiet = false } = {}) =>
+    new Promise((resolve) => {
+      if (!quiet) console.log(`[wrapper] Running: openclaw ${cmd}`);
+      exec(
+        `openclaw ${cmd}`,
+        {
+          env: gatewayEnv(),
+          timeout: 15000,
+        },
+        (err, stdout, stderr) => {
+          const result = {
+            ok: !err,
+            stdout: stdout.trim(),
+            stderr: stderr.trim(),
+            code: err?.code,
+          };
+          if (!quiet && !result.ok) {
+            console.log(`[wrapper] Error: ${result.stderr.slice(0, 200)}`);
+          }
+          resolve(result);
+        },
+      );
+    });
+
+  const gogCmd = (cmd, { quiet = false } = {}) =>
+    new Promise((resolve) => {
+      if (!quiet) console.log(`[wrapper] Running: gog ${cmd}`);
+      exec(
+        `gog ${cmd}`,
+        {
+          timeout: 15000,
+          env: {
+            ...process.env,
+            XDG_CONFIG_HOME: OPENCLAW_DIR,
+            GOG_KEYRING_PASSWORD,
+          },
+        },
+        (err, stdout, stderr) => {
+          const result = {
+            ok: !err,
+            stdout: stdout.trim(),
+            stderr: stderr.trim(),
+          };
+          if (!quiet && !result.ok) {
+            console.log(`[wrapper] gog error: ${result.stderr.slice(0, 200)}`);
+          }
+          resolve(result);
+        },
+      );
+    });
+
+  return { shellCmd, clawCmd, gogCmd };
+};
+
+module.exports = { createCommands };