@robbiesrobotics/alice-agents 1.5.3 → 1.5.5

package/bin/alice-cloud.cjs

@@ -311,12 +311,30 @@ async function watch(args) {
   await startHeartbeatLoop(config);
 }
 
+// ── Programmatic API exports ───────────────────────────────────────────────────
+// Allow ESM callers to import these via createRequire or spawn as child process.
+module.exports = {
+  login,
+  register,
+  status,
+  unregister,
+  watch,
+  loadConfig,
+  saveConfig,
+  detectGatewayUrl,
+  readGatewayToken,
+  API_BASE,
+  CONFIG_FILE,
+};
+
 // ── CLI dispatcher ─────────────────────────────────────────────────────────────
-const commands = { login, register, status, unregister, watch };
-const cmd = process.argv[2];
+// Only run as CLI when this file is the main module (not when required/imported)
+if (require.main === module) {
+  const commands = { login, register, status, unregister, watch };
+  const cmd = process.argv[2];
 
-if (!cmd) {
-  console.log(`alice-cloud v1.0.1 — A.L.I.C.E. | Control Cloud CLI
+  if (!cmd) {
+    console.log(`alice-cloud v1.0.1 — A.L.I.C.E. | Control Cloud CLI
 
 Usage: alice-cloud <command> [options]
 
@@ -335,16 +353,17 @@ Environment:
   ALICE_SUPABASE_URL     Supabase project URL (default: xxx project)
 
 Run 'alice-cloud <command> --help' for more options.`);
-  process.exit(0);
-}
+    process.exit(0);
+  }
 
-const handler = commands[cmd];
-if (!handler) {
-  console.error(`Unknown command: ${cmd}`);
-  process.exit(1);
-}
+  const handler = commands[cmd];
+  if (!handler) {
+    console.error(`Unknown command: ${cmd}`);
+    process.exit(1);
+  }
 
-handler(process.argv.slice(3)).catch((err) => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+  handler(process.argv.slice(3)).catch((err) => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}

package/lib/installer.mjs

@@ -6,7 +6,14 @@ import { homedir } from 'node:os';
 import { configExists, mergeConfig, removeAliceAgents, detectAvailableModels } from './config-merger.mjs';
 import { scaffoldAll } from './workspace-scaffolder.mjs';
 import { readManifest, writeManifest } from './manifest.mjs';
-import { configureMissionControlCloud, getDefaultMissionControlSettings } from './mission-control.mjs';
+import {
+  configureMissionControlCloud,
+  getDefaultMissionControlSettings,
+  getCloudStatus,
+  isCloudAuthenticated,
+  isCloudRegistered,
+  configureCloudFromSupabase,
+} from './mission-control.mjs';
 import {
   promptInstallMode,
   promptUserInfo,
@@ -15,8 +22,10 @@ import {
   promptTier,
   promptLicenseKey,
   promptCloudAddon,
-  promptMissionControlToken,
-  promptMissionControlWorkerToken,
+  promptCloudSetup,
+  promptCloudReauth,
+  promptCloudHeartbeat,
+  promptCloudToken,
   confirm,
   choose,
   input,
@@ -470,11 +479,10 @@ function printSummaryWithOptions(mode, tier, agents, preset, userInfo, detectedM
     `${dim('Model:')}     ${green(modelLabel)}`,
     `${dim('User:')}      ${green(userInfo.name)}`,
     `${dim('Timezone:')}  ${green(userInfo.timezone)}`,
-    `${dim('Mission Control:')}  ${green(missionControl?.enabled ? 'cloud enabled' : 'local only')}`,
+    `${dim('Cloud:')}  ${green(missionControl?.enabled ? 'enabled' : 'local only')}`,
     ...(missionControl?.enabled
       ? [
           `${dim('Dashboard:')} ${green(missionControl.dashboardUrl)}`,
-          `${dim('Ingest:')}    ${green(missionControl.ingestUrl)}`,
         ]
       : []),
     '',
@@ -486,6 +494,119 @@ function printSummaryWithOptions(mode, tier, agents, preset, userInfo, detectedM
   console.log('');
 }
 
+/**
+ * Run inline cloud onboarding — opens browser, validates token, registers gateway.
+ * Uses alice-cloud CLI spawned as a child process (CJS ↔ ESM boundary).
+ */
+async function _runCloudOnboarding(auto, options, existingMissionControl) {
+  const { execFileSync } = await import('node:child_process');
+  const { mkdirSync, readFileSync, writeFileSync, existsSync: fsExists } = await import('node:fs');
+  const aliceCloudBin = join(__dirname, '..', 'bin', 'alice-cloud.cjs');
+  const defaults = getDefaultMissionControlSettings();
+  const cloudConfigPath = join(homedir(), '.openclaw', 'alice-cloud.json');
+
+  function readCloudJson() {
+    try { return JSON.parse(readFileSync(cloudConfigPath, 'utf8')); } catch { return {}; }
+  }
+  function writeCloudJson(data) {
+    mkdirSync(join(homedir(), '.openclaw'), { recursive: true });
+    writeFileSync(cloudConfigPath, JSON.stringify(data, null, 2));
+  }
+
+  try {
+    // Step 1: Login
+    console.log('');
+    console.log(`  ${icons.pkg} ${bold('Setting up A.L.I.C.E. Cloud...')}`);
+    console.log('');
+
+    if (auto && options.cloudSupabaseToken) {
+      // Non-interactive: use provided token
+      const cloudData = readCloudJson();
+      cloudData.supabaseToken = options.cloudSupabaseToken;
+      writeCloudJson(cloudData);
+      printStepDone('Cloud token saved');
+    } else if (!auto) {
+      // Interactive: open browser and prompt for token using our own readline
+      console.log(`  ${dim('A.L.I.C.E. Cloud uses your GitHub account for authentication.')}`);
+      console.log(`  ${dim('We\'ll open your browser to sign in, then you\'ll paste a token back here.')}`);
+      console.log('');
+
+      try {
+        const open = (await import('open')).default;
+        const supabaseUrl = 'https://xxxgvtwnlbtdgmlgccee.supabase.co';
+        const oauthUrl = `${supabaseUrl}/auth/v1/authorize?provider=github&redirect_to=${encodeURIComponent('https://alice.av3.ai/api/cloud/auth/callback')}`;
+        await open(oauthUrl);
+        console.log(`  ${green('Browser opened!')} Sign in with GitHub and copy the token shown.`);
+      } catch {
+        console.log(`  ${yellow('Could not open browser.')} Visit this URL to sign in:`);
+        console.log(`  ${cyan('https://alice.av3.ai/login')}`);
+      }
+      console.log('');
+
+      const token = await promptCloudToken();
+
+      if (token) {
+        const cloudData = readCloudJson();
+        cloudData.supabaseToken = token;
+        writeCloudJson(cloudData);
+        printStepDone('Cloud token saved');
+      } else {
+        console.log(`  ${dim('Skipped — you can authenticate later with:')} ${cyan('alice-cloud login')}`);
+      }
+    }
+
+    // Step 2: Register gateway (use child process for this — no stdin needed)
+    if (isCloudAuthenticated()) {
+      console.log('');
+      console.log(`  ${icons.pkg} ${bold('Registering gateway with A.L.I.C.E. Cloud...')}`);
+      try {
+        execFileSync(process.execPath, [aliceCloudBin, 'register'], {
+          stdio: ['ignore', 'inherit', 'inherit'],
+          timeout: 15000,
+        });
+        printStepDone('Gateway registered with A.L.I.C.E. Cloud');
+      } catch {
+        console.log(`  ${yellow('Gateway registration failed — you can retry later with:')} ${cyan('alice-cloud register')}`);
+      }
+
+      // Step 3: Ask about heartbeat daemon
+      const startHeartbeat = auto ? false : await promptCloudHeartbeat();
+      if (startHeartbeat) {
+        console.log(`  ${dim('Starting heartbeat daemon...')}`);
+        try {
+          execFileSync(process.execPath, [aliceCloudBin, 'watch', '--daemon'], {
+            stdio: ['ignore', 'inherit', 'inherit'],
+            timeout: 10000,
+          });
+          printStepDone('Heartbeat daemon started');
+        } catch {
+          console.log(`  ${dim('Could not start daemon — run:')} ${cyan('alice-cloud watch --daemon')}`);
+        }
+      }
+    } else {
+      printStepSkip('Cloud registration', 'no token provided — run `alice-cloud login` later');
+    }
+  } catch (err) {
+    console.log(`  ${icons.warn} ${yellow('Cloud setup encountered an issue: ' + (err.message || 'unknown error'))}`);
+    console.log(`  ${dim('You can complete setup later with:')} ${cyan('alice-cloud login && alice-cloud register')}`);
+  }
+
+  // Build missionControl object from whatever state we achieved
+  const cloudStatus = getCloudStatus();
+  return {
+    enabled: true,
+    provider: 'cloud',
+    dashboardUrl: existingMissionControl?.dashboardUrl || defaults.dashboardUrl,
+    ingestUrl: existingMissionControl?.ingestUrl || `${defaults.dashboardUrl}/api/v1/ingest`,
+    sourceNode: existingMissionControl?.sourceNode || defaults.sourceNode,
+    teamId: String(options.cloudTeamId || existingMissionControl?.teamId || '').trim(),
+    teamSlug: String(options.cloudTeamSlug || existingMissionControl?.teamSlug || '').trim(),
+    teamName: String(options.cloudTeamName || existingMissionControl?.teamName || '').trim(),
+    teamPlan: String(options.cloudTeamPlan || existingMissionControl?.teamPlan || '').trim(),
+    ...(cloudStatus.authenticated ? { hasIngestToken: true } : {}),
+  };
+}
+
 export async function runInstall(options = {}) {
   const auto = options.yes || false;
   const manifest = readManifest();
@@ -718,36 +839,61 @@ export async function runInstall(options = {}) {
       : cloudFlag ?? await promptCloudAddon();
 
     if (enableCloud) {
-      const defaults = getDefaultMissionControlSettings();
-      const dashboardUrl =
-        String(options.cloudDashboardUrl || existingMissionControl?.dashboardUrl || defaults.dashboardUrl).trim();
-      const ingestUrl =
-        String(options.cloudIngestUrl || existingMissionControl?.ingestUrl || `${dashboardUrl}/api/v1/ingest`).trim();
-      const ingestToken =
-        auto
-          ? String(options.cloudToken || '').trim()
-          : String(options.cloudToken || await promptMissionControlToken()).trim();
-      const workerToken =
-        auto
-          ? String(options.cloudWorkerToken || '').trim()
-          : String(options.cloudWorkerToken || await promptMissionControlWorkerToken(ingestToken)).trim();
-      const sourceNode =
-        String(options.cloudSourceNode || existingMissionControl?.sourceNode || defaults.sourceNode).trim();
-
-      missionControl = {
-        enabled: true,
-        provider: 'cloud',
-        dashboardUrl,
-        ingestUrl,
-        sourceNode,
-        teamId: String(options.cloudTeamId || existingMissionControl?.teamId || '').trim(),
-        teamSlug: String(options.cloudTeamSlug || existingMissionControl?.teamSlug || '').trim(),
-        teamName: String(options.cloudTeamName || existingMissionControl?.teamName || '').trim(),
-        teamPlan: String(options.cloudTeamPlan || existingMissionControl?.teamPlan || '').trim(),
-        hasIngestToken: !!ingestToken,
-        ingestToken,
-        workerToken,
-      };
+      const cloudStatus = getCloudStatus();
+
+      // Upgrade mode: show existing cloud status
+      if (mode === 'upgrade' && (cloudStatus.authenticated || existingMissionControl?.enabled)) {
+        console.log('');
+        console.log(`  ${icons.ok} ${green('A.L.I.C.E. Cloud is configured')}`);
+        if (cloudStatus.user) {
+          console.log(`     ${dim('User:')} ${cloudStatus.user}`);
+        }
+        if (cloudStatus.gatewayUrl) {
+          console.log(`     ${dim('Gateway:')} ${cloudStatus.gatewayUrl}`);
+        }
+        if (cloudStatus.registeredAt) {
+          console.log(`     ${dim('Registered:')} ${cloudStatus.registeredAt}`);
+        }
+        console.log('');
+
+        const reauth = auto ? false : await promptCloudReauth();
+        if (!reauth) {
+          // Keep existing config — use Supabase config if available, fall back to legacy
+          if (cloudStatus.authenticated) {
+            missionControl = {
+              enabled: true,
+              provider: 'cloud',
+              dashboardUrl: existingMissionControl?.dashboardUrl || 'https://alice.av3.ai',
+              ingestUrl: existingMissionControl?.ingestUrl || 'https://alice.av3.ai/api/v1/ingest',
+              sourceNode: existingMissionControl?.sourceNode || getDefaultMissionControlSettings().sourceNode,
+            };
+          } else {
+            missionControl = { ...existingMissionControl, enabled: true };
+          }
+        } else {
+          // Re-authenticate — run alice-cloud login inline
+          missionControl = await _runCloudOnboarding(auto, options, existingMissionControl);
+        }
+      } else {
+        // Fresh install — run cloud onboarding
+        const wantsSetup = auto ? true : await promptCloudSetup();
+
+        if (wantsSetup) {
+          missionControl = await _runCloudOnboarding(auto, options, existingMissionControl);
+        } else {
+          console.log('');
+          console.log(`  ${dim('You can set up cloud later with:')} ${cyan('alice-cloud login && alice-cloud register')}`);
+          console.log('');
+          // Cloud addon enabled but setup skipped — bridge installed, no auth yet
+          missionControl = {
+            enabled: true,
+            provider: 'cloud',
+            dashboardUrl: 'https://alice.av3.ai',
+            ingestUrl: 'https://alice.av3.ai/api/v1/ingest',
+            sourceNode: getDefaultMissionControlSettings().sourceNode,
+          };
+        }
+      }
     }
   }
 
@@ -790,12 +936,12 @@ export async function runInstall(options = {}) {
 
   if (missionControl?.enabled) {
     const missionControlResult = configureMissionControlCloud(missionControl);
-    printStepDone('Mission Control cloud', missionControlResult.summary.dashboardUrl);
+    printStepDone('A.L.I.C.E. Cloud', missionControlResult.summary.dashboardUrl);
     if (!missionControlResult.summary.hasIngestToken) {
-      printStepSkip('Cloud access token not set', 'bridge installed; add token later to enable authenticated ingest');
+      printStepSkip('Cloud authentication pending', 'run `alice-cloud login && alice-cloud register` to complete setup');
     }
   } else {
-    printStepSkip('Mission Control cloud', 'not enabled for this install');
+    printStepSkip('A.L.I.C.E. Cloud', 'not enabled for this install');
   }
 
   // Scaffold workspaces

package/lib/license.mjs

@@ -168,7 +168,10 @@ export async function checkProLicense(options = {}) {
       };
     }
 
-    if (refreshed.transient) {
+    // Revalidation failed — but if the license was previously validated successfully,
+    // honor it with a grace period rather than immediately invalidating.
+    // This prevents API outages or temporary endpoint issues from breaking existing installs.
+    if (refreshed.transient || record.status === 'validated') {
       return {
         licensed: true,
         key: record.key,

package/lib/mission-control.mjs

@@ -179,3 +179,64 @@ export function getDefaultMissionControlSettings() {
 export function hasMissionControlBridgeInstalled() {
   return existsSync(join(OPENCLAW_HOME, 'extensions', BRIDGE_ID));
 }
+
+// ── Supabase-based cloud onboarding helpers ────────────────────────────────────
+
+const CLOUD_CONFIG_PATH = join(OPENCLAW_HOME, 'alice-cloud.json');
+
+export function readCloudConfig() {
+  return readJsonFile(CLOUD_CONFIG_PATH);
+}
+
+export function isCloudAuthenticated() {
+  const config = readCloudConfig();
+  return !!(config && config.supabaseToken);
+}
+
+export function isCloudRegistered() {
+  const config = readCloudConfig();
+  return !!(config && config.registration);
+}
+
+export function getCloudStatus() {
+  const config = readCloudConfig();
+  if (!config) return { authenticated: false, registered: false };
+  return {
+    authenticated: !!config.supabaseToken,
+    registered: !!config.registration,
+    user: config.user?.email || config.user?.user_metadata?.user_name || null,
+    gatewayUrl: config.registration?.gatewayUrl || null,
+    hostname: config.registration?.hostname || null,
+    registeredAt: config.registration?.registeredAt || null,
+  };
+}
+
+/**
+ * Configure cloud using Supabase auth (new flow).
+ * This preserves the existing bridge installation and MC config writing,
+ * and reads auth state from alice-cloud.json.
+ */
+export function configureCloudFromSupabase(input = {}) {
+  // Read alice-cloud.json for auth info
+  const cloudConfig = readCloudConfig() || {};
+
+  // Build settings — we still use the same bridge + MC config infrastructure,
+  // but tokens now come from Supabase auth rather than manual ingest tokens
+  const settingsInput = {
+    dashboardUrl: input.dashboardUrl || DEFAULT_DASHBOARD_URL,
+    sourceNode: input.sourceNode || hostname() || 'openclaw-local',
+    teamId: input.teamId || '',
+    teamSlug: input.teamSlug || '',
+    teamName: input.teamName || '',
+    teamPlan: input.teamPlan || '',
+    enabled: true,
+  };
+
+  // If we have a supabase token, use it as the ingest/worker token for bridge compatibility
+  if (cloudConfig.supabaseToken) {
+    settingsInput.ingestToken = cloudConfig.supabaseToken;
+    settingsInput.workerToken = cloudConfig.supabaseToken;
+  }
+
+  return configureMissionControlCloud(settingsInput);
+}

package/lib/prompter.mjs

@@ -128,27 +128,33 @@ export async function promptLicenseKey() {
 
 export async function promptCloudAddon() {
   console.log('');
-  console.log('  Mission Control Cloud add-on');
-  console.log('  Hosted dashboard, telemetry sync, and cloud memory for Pro users.');
+  console.log('  A.L.I.C.E. Cloud add-on');
+  console.log('  Remote monitoring, fleet management, and cloud sync for Pro users.');
   console.log('');
-  return confirm('  Enable the Mission Control Cloud add-on on this machine?', true);
+  return confirm('  Enable A.L.I.C.E. Cloud on this machine?', true);
 }
 
-export async function promptMissionControlToken() {
+export async function promptCloudSetup() {
   console.log('');
-  console.log('  Enter your Mission Control Ingest Token from your purchase email.');
-  console.log('  It looks like: mc_ingest_[64 hex chars]');
-  console.log('  You can find it in the "A.L.I.C.E. Pro License Delivered" email.');
-  console.log('  Press Enter to skip — you can add it later.');
+  console.log('  A.L.I.C.E. Cloud connects your local gateway to alice.av3.ai');
+  console.log('  for remote monitoring, fleet management, and cloud sync.');
   console.log('');
-  return input('  Mission Control Ingest Token', '');
+  return confirm('  Would you like to set up A.L.I.C.E. Cloud now?', true);
 }
 
-export async function promptMissionControlWorkerToken(ingestToken = '') {
-  if (!ingestToken) return '';
+export async function promptCloudReauth() {
   console.log('');
-  console.log('  Enter your Mission Control Worker Token from the same purchase email.');
-  console.log('  It looks like: mc_worker_[64 hex chars]');
+  return confirm('  Re-authenticate with A.L.I.C.E. Cloud?', false);
+}
+
+export async function promptCloudHeartbeat() {
+  return confirm('  Start the heartbeat daemon (keeps cloud connection alive)?', true);
+}
+
+export async function promptCloudToken() {
+  console.log('');
+  console.log('  After logging in via your browser, paste the access token here.');
+  console.log('  Press Enter to skip — you can run `alice-cloud login` later.');
   console.log('');
-  return input('  Mission Control Worker Token', '');
+  return input('  Access token', '');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbiesrobotics/alice-agents",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "A.L.I.C.E. \u2014 31 AI agents for OpenClaw. One conversation, one team.",
   "bin": {
     "alice-agents": "bin/alice-install.mjs",