spaps 0.7.6 → 0.7.7

package/src/home-view.js

@@ -0,0 +1,200 @@
+const chalk = require('chalk');
+
+const { DEFAULT_PORT } = require('./config');
+const { getServerRuntime } = require('./local-runtime');
+const { resolveServerUrl } = require('./auth/client');
+const { getCredentials, CREDENTIALS_PATH } = require('./auth/credentials');
+const { findUpContract } = require('./auth/client-id');
+const { resolveAuthApiKey } = require('./auth/api-key');
+
+function resolveAppContext({ cwd, runtime }) {
+  if (typeof process.env.SPAPS_CLI_CLIENT_ID === 'string' && process.env.SPAPS_CLI_CLIENT_ID.trim()) {
+    return {
+      clientId: process.env.SPAPS_CLI_CLIENT_ID.trim(),
+      source: 'SPAPS_CLI_CLIENT_ID',
+      path: null,
+    };
+  }
+
+  const contractHit = findUpContract(cwd);
+  if (contractHit) {
+    return contractHit;
+  }
+
+  const runtimeClientId = runtime?.local_mode?.test_application?.slug || null;
+  if (runtimeClientId) {
+    return {
+      clientId: runtimeClientId,
+      source: '/health/local-mode',
+      path: null,
+    };
+  }
+
+  return {
+    clientId: null,
+    source: null,
+    path: null,
+  };
+}
+
+function isLocalhostUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1';
+  } catch {
+    return false;
+  }
+}
+
+function formatSource(source, filePath) {
+  if (!source) {
+    return null;
+  }
+  return filePath ? `${source} (${filePath})` : source;
+}
+
+function formatMode(runtime) {
+  if (!runtime.running) {
+    return 'server unreachable';
+  }
+  if (!runtime.local_mode?.known) {
+    return 'mode unknown';
+  }
+  return runtime.local_mode.active ? 'local mode active' : 'application key required';
+}
+
+function buildRecommendedNext({ operator, runtime, port }) {
+  if (!operator.connected) {
+    return {
+      command: 'spaps connect',
+      reason: `No saved operator session for ${operator.server_url}.`,
+    };
+  }
+
+  if (!runtime.running) {
+    return {
+      command: isLocalhostUrl(runtime.url)
+        ? `spaps local${port !== DEFAULT_PORT ? ` --port ${port}` : ''}`
+        : 'spaps verify',
+      reason: isLocalhostUrl(runtime.url)
+        ? `No SPAPS runtime is reachable at ${runtime.url}.`
+        : `No SPAPS runtime is reachable at ${runtime.url}; verify the configured server URL.`,
+    };
+  }
+
+  return {
+    command: 'spaps verify',
+    reason: runtime.local_mode?.active
+      ? 'Confirm the local auth path and runtime hints end to end.'
+      : 'Confirm the provisioned auth path and API key wiring end to end.',
+  };
+}
+
+async function buildHomeView({ port = DEFAULT_PORT, serverUrl = null, cwd = process.cwd() } = {}) {
+  const resolvedPort = Number(port) || DEFAULT_PORT;
+  const resolvedServerUrl = resolveServerUrl({ port: resolvedPort, serverUrl });
+  const runtime = await getServerRuntime({ port: resolvedPort, serverUrl: resolvedServerUrl });
+  const storedCreds = getCredentials(resolvedServerUrl);
+  const envAccessToken =
+    typeof process.env.SPAPS_ACCESS_TOKEN === 'string' && process.env.SPAPS_ACCESS_TOKEN.trim()
+      ? process.env.SPAPS_ACCESS_TOKEN.trim()
+      : null;
+  const appContext = resolveAppContext({ cwd, runtime });
+  const apiKey = resolveAuthApiKey({ cwd });
+
+  const operator = {
+    server_url: resolvedServerUrl,
+    connected: Boolean(envAccessToken || storedCreds?.access_token),
+    source: envAccessToken ? 'SPAPS_ACCESS_TOKEN' : storedCreds?.access_token ? 'credentials' : null,
+    credentials_path: CREDENTIALS_PATH,
+    user_id: storedCreds?.user_id || null,
+    client_id: storedCreds?.client_id || null,
+    expires_at: storedCreds?.expires_at || null,
+  };
+
+  const app = {
+    client_id: appContext.clientId,
+    client_id_source: appContext.source,
+    client_id_path: appContext.path,
+    api_key_configured: Boolean(apiKey.apiKey),
+    api_key_source: apiKey.source,
+    api_key_path: apiKey.path,
+    api_key_env: apiKey.envVar || null,
+  };
+
+  return {
+    success: true,
+    command: 'home',
+    operator,
+    app,
+    runtime,
+    recommended_next: buildRecommendedNext({
+      operator,
+      runtime,
+      port: resolvedPort,
+    }),
+  };
+}
+
+function renderHomeView(view, { logo = '' } = {}) {
+  if (logo) {
+    console.log(logo);
+  }
+
+  console.log(chalk.bold('Operator'));
+  console.log('  Server:', chalk.cyan(view.operator.server_url));
+  console.log(
+    '  Session:',
+    view.operator.connected
+      ? chalk.green(`connected via ${view.operator.source || 'credentials'}`)
+      : chalk.yellow('not connected')
+  );
+  if (view.operator.client_id) {
+    console.log('  Session app:', chalk.cyan(view.operator.client_id));
+  }
+  if (view.operator.user_id) {
+    console.log('  User:', chalk.cyan(view.operator.user_id));
+  }
+
+  console.log();
+  console.log(chalk.bold('App'));
+  if (view.app.client_id) {
+    console.log('  Client id:', chalk.cyan(view.app.client_id));
+    if (view.app.client_id_source) {
+      console.log(chalk.gray(`  source: ${formatSource(view.app.client_id_source, view.app.client_id_path)}`));
+    }
+  } else {
+    console.log('  Client id:', chalk.yellow('not detected'));
+  }
+  console.log(
+    '  API key:',
+    view.app.api_key_configured
+      ? chalk.green(`configured via ${formatSource(view.app.api_key_source, view.app.api_key_path)}`)
+      : chalk.yellow('not found')
+  );
+
+  console.log();
+  console.log(chalk.bold('Runtime'));
+  if (!view.runtime.running) {
+    console.log('  Status:', chalk.red('unreachable'));
+    console.log('  Target:', chalk.cyan(view.runtime.url));
+    if (view.runtime.error?.message) {
+      console.log(chalk.gray(`  ${view.runtime.error.message}`));
+    }
+  } else {
+    console.log('  Status:', chalk.green('running'));
+    console.log('  URL:', chalk.cyan(view.runtime.url));
+    console.log('  Mode:', chalk.cyan(formatMode(view.runtime)));
+  }
+
+  console.log();
+  console.log(chalk.bold('Next'));
+  console.log('  ' + chalk.cyan(view.recommended_next.command));
+  console.log(chalk.gray(`  ${view.recommended_next.reason}`));
+  console.log();
+}
+
+module.exports = {
+  buildHomeView,
+  renderHomeView,
+};

package/src/local-runtime.js

@@ -12,6 +12,19 @@ function buildDocsUrl(port = DEFAULT_PORT) {
   return `${buildBaseUrl(port)}/docs`;
 }
 
+function normalizeServerUrl(url) {
+  return String(url || '').trim().replace(/\/+$/, '');
+}
+
+function isLocalhostUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1';
+  } catch {
+    return false;
+  }
+}
+
 function unwrapEnvelope(payload) {
   if (
     payload &&
@@ -82,9 +95,9 @@ async function requestJson({ method, url, data = null, headers = {}, timeoutMs =
   }
 }
 
-async function getServerRuntime({ port = DEFAULT_PORT, timeoutMs = REQUEST_TIMEOUT_MS } = {}) {
-  const url = buildBaseUrl(port);
-  const docs = buildDocsUrl(port);
+async function getServerRuntime({ port = DEFAULT_PORT, serverUrl = null, timeoutMs = REQUEST_TIMEOUT_MS } = {}) {
+  const url = serverUrl ? normalizeServerUrl(serverUrl) : buildBaseUrl(port);
+  const docs = `${url}/docs`;
 
   const health = await requestJson({
     method: 'GET',
@@ -99,7 +112,7 @@ async function getServerRuntime({ port = DEFAULT_PORT, timeoutMs = REQUEST_TIMEO
       url,
       docs,
       message: health.network_error ? 'Server not running' : 'Health endpoint returned an error',
-      start_command: `npx spaps local --port ${port}`,
+      start_command: isLocalhostUrl(url) ? `npx spaps local --port ${port}` : null,
       error: health.error,
     };
   }
@@ -251,6 +264,8 @@ module.exports = {
   buildBaseUrl,
   buildDocsUrl,
   getServerRuntime,
+  isLocalhostUrl,
+  normalizeServerUrl,
   provisionStarterApplication,
   readSelfServicePassword,
   requestJson,

package/src/local-server.js

@@ -20,6 +20,28 @@ const DEFAULT_RUNTIME_SOURCE = 'auto';
 const DEFAULT_AUTH_BASE_URL = 'http://localhost:5173';
 const DEFAULT_DATA_SOURCE = 'empty';
 const EXTERNAL_NETWORKS = ['reverse-proxy'];
+const DEFAULT_CORS_ALLOW_ORIGINS = [
+  'http://localhost:3000',
+  'http://127.0.0.1:3000',
+  'http://localhost:3001',
+  'http://127.0.0.1:3001',
+  'http://localhost:5173',
+  'http://127.0.0.1:5173',
+  'http://localhost:30000',
+  'http://127.0.0.1:30000',
+].join(',');
+const DEFAULT_CORS_ALLOW_HEADERS = [
+  'Accept',
+  'Accept-Language',
+  'Authorization',
+  'Content-Language',
+  'Content-Type',
+  'X-API-Key',
+  'X-Request-ID',
+  'X-SPAPS-Signature',
+  'X-SPAPS-Use-Refresh-Cookie',
+  'X-Test-User',
+].join(',');
 
 function readBundledRuntimeManifest() {
   if (!fs.existsSync(BUNDLED_RUNTIME_MANIFEST)) {
@@ -123,7 +145,14 @@ function buildComposeEnv({ port, authBaseUrl }) {
       process.env.SELF_SERVICE_PASSWORD ||
       portableRuntime.default_self_service_password ||
       'spaps_local_self_service_password',
-    CORS_ALLOW_ORIGINS: process.env.CORS_ALLOW_ORIGINS || '*',
+    CORS_ALLOW_ORIGINS:
+      process.env.CORS_ALLOW_ORIGINS ||
+      portableRuntime.default_cors_allow_origins ||
+      DEFAULT_CORS_ALLOW_ORIGINS,
+    CORS_ALLOW_HEADERS:
+      process.env.CORS_ALLOW_HEADERS ||
+      portableRuntime.default_cors_allow_headers ||
+      DEFAULT_CORS_ALLOW_HEADERS,
     LEGACY_API_KEY_AUTH_ENABLED: process.env.LEGACY_API_KEY_AUTH_ENABLED || 'true',
     SPAPS_SERVER_QUICKSTART_VERSION:
       process.env.SPAPS_SERVER_QUICKSTART_VERSION || manifest.spaps_server_quickstart_version,