@symbo.ls/cli 2.33.11 → 2.33.13

package/helpers/config.js

@@ -1,27 +1,140 @@
 import fs from 'fs'
 import path from 'path'
 
-export const getApiUrl = () => {
-  if (process.env.SMBLS_API_URL) {
-    return process.env.SMBLS_API_URL
+// New configuration layout
+// .symbols/config.json  -> project runtime configuration (apiBaseUrl, projectKey|projectId, branch)
+// .symbols/lock.json    -> last pulled snapshot metadata (etag, version, projectId, branch, pulledAt)
+// Backward compatibility:
+//  - Keep reading legacy .smblsrc and symbols.json when present
+
+const CWD = process.cwd()
+const SYMBOLS_DIR = path.join(CWD, '.symbols')
+const CONFIG_PATH = path.join(SYMBOLS_DIR, 'config.json')
+const LOCK_PATH = path.join(SYMBOLS_DIR, 'lock.json')
+const PROJECT_JSON_PATH = path.join(SYMBOLS_DIR, 'project.json')
+const LEGACY_RC_PATH = path.join(CWD, '.smblsrc')
+const LEGACY_SYMBOLS_JSON = path.join(CWD, 'symbols.json')
+
+function ensureDir(dir) {
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  } catch (_) {
+    // ignore
   }
+}
 
-  const configPath = path.join(process.cwd(), '.smblsrc.json')
-  if (fs.existsSync(configPath)) {
-    try {
-      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
-      if (config.apiUrl) return config.apiUrl
-    } catch (err) {
-      // Silently fail and use defaults if config file is invalid
-    }
+function readJsonSafe(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null
+    const content = fs.readFileSync(filePath, 'utf8')
+    return JSON.parse(content)
+  } catch (_) {
+    return null
   }
+}
 
-  switch (process.env.NODE_ENV) {
-    case 'production':
-      return 'https://api.symbols.app'
-    case 'staging':
-      return 'https://api-staging.symbols.app'
-    default:
-      return 'http://localhost:8080'
+function writeJsonSafe(filePath, data) {
+  ensureDir(path.dirname(filePath))
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2))
+}
+
+export function getConfigPaths() {
+  return {
+    symbolsDir: SYMBOLS_DIR,
+    configPath: CONFIG_PATH,
+    lockPath: LOCK_PATH,
+    projectPath: PROJECT_JSON_PATH,
+    legacySmblsrc: LEGACY_RC_PATH,
+    legacySymbolsJson: LEGACY_SYMBOLS_JSON
+  }
+}
+
+export function loadCliConfig() {
+  // Env overrides first
+  const envApi =
+    process.env.SYMBOLS_API_BASE_URL ||
+    process.env.SMBLS_API_URL // backward compat
+  const envProjectKey = process.env.SYMBOLS_PROJECT_KEY
+  const envProjectId = process.env.SYMBOLS_PROJECT_ID
+  const envBranch = process.env.SYMBOLS_BRANCH
+
+  // New config layout
+  const symbolsConfig = readJsonSafe(CONFIG_PATH) || {}
+
+  // Legacy project identifiers and defaults from symbols.json
+  const legacySymbols = readJsonSafe(LEGACY_SYMBOLS_JSON) || {}
+
+  // Legacy rc might include apiUrl
+  const legacyRc = readJsonSafe(LEGACY_RC_PATH) || {}
+
+  const apiBaseUrl =
+    envApi ||
+    symbolsConfig.apiBaseUrl ||
+    legacyRc.apiUrl ||
+    // default to production if nothing set
+    'https://api.symbols.app'
+
+  const projectKey = envProjectKey || symbolsConfig.projectKey || legacySymbols.key
+  const projectId = envProjectId || symbolsConfig.projectId || null
+  const branch = envBranch || symbolsConfig.branch || legacySymbols.branch || 'main'
+
+  return {
+    apiBaseUrl,
+    projectKey,
+    projectId,
+    branch,
+    // expose raw sources for advanced usage
+    _raw: {
+      symbolsConfig,
+      legacySymbols,
+      legacyRc
+    }
   }
 }
+
+export function saveCliConfig(partial) {
+  const current = readJsonSafe(CONFIG_PATH) || {}
+  const next = { ...current, ...partial }
+  writeJsonSafe(CONFIG_PATH, next)
+  return next
+}
+
+export function readLock() {
+  return readJsonSafe(LOCK_PATH) || {}
+}
+
+export function writeLock(partial) {
+  const current = readJsonSafe(LOCK_PATH) || {}
+  const next = { ...current, ...partial }
+  writeJsonSafe(LOCK_PATH, next)
+  return next
+}
+
+export function getApiUrl() {
+  // Prefer new env var and config
+  const { apiBaseUrl } = loadCliConfig()
+  return apiBaseUrl
+}
+
+export function getProjectKeyOrId() {
+  const { projectKey, projectId } = loadCliConfig()
+  return { projectKey, projectId }
+}
+
+export function getBranch() {
+  const { branch } = loadCliConfig()
+  return branch || 'main'
+}
+
+export function ensureSymbolsDir() {
+  ensureDir(SYMBOLS_DIR)
+  return SYMBOLS_DIR
+}
+
+// Helper for legacy projects to keep version/branch updates in symbols.json
+export function updateLegacySymbolsJson(partial) {
+  const current = readJsonSafe(LEGACY_SYMBOLS_JSON) || {}
+  const next = { ...current, ...partial }
+  writeJsonSafe(LEGACY_SYMBOLS_JSON, next)
+  return next
+}

package/helpers/credentialManager.js

@@ -0,0 +1,66 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+const RC_FILE = '.smblsrc'
+
+export class CredentialManager {
+  constructor() {
+    this.rcPath = path.join(os.homedir(), RC_FILE)
+  }
+
+  // Load credentials from rc file
+  loadCredentials() {
+    try {
+      const data = fs.readFileSync(this.rcPath, 'utf8')
+      return JSON.parse(data)
+    } catch (err) {
+      return {}
+    }
+  }
+
+  // Save credentials to rc file
+  saveCredentials(credentials) {
+    try {
+      const existing = this.loadCredentials()
+      const merged = { ...existing, ...credentials }
+      fs.writeFileSync(this.rcPath, JSON.stringify(merged, null, 2))
+      return true
+    } catch (err) {
+      console.error('Failed to save credentials:', err)
+      return false
+    }
+  }
+
+  // Get stored auth token
+  getAuthToken() {
+    const envToken = process.env.SYMBOLS_TOKEN || process.env.SMBLS_TOKEN
+    if (envToken) return envToken
+    const creds = this.loadCredentials()
+    return creds.authToken || creds.token || creds.accessToken || creds.jwt
+  }
+
+  // Ensure token presence; returns token or null
+  ensureAuthToken() {
+    const token = this.getAuthToken()
+    return token || null
+  }
+
+  // Optional: get refresh token if present
+  getRefreshToken() {
+    const envToken = process.env.SYMBOLS_REFRESH_TOKEN
+    if (envToken) return envToken
+    const creds = this.loadCredentials()
+    return creds.refreshToken || null
+  }
+
+  // Clear stored credentials
+  clearCredentials() {
+    try {
+      fs.unlinkSync(this.rcPath)
+      return true
+    } catch (err) {
+      return false
+    }
+  }
+}

package/helpers/fileUtils.js

@@ -36,12 +36,18 @@ async function buildFromFile (inputFilePath, outputFilePath) {
       },
       minify: false,
       outfile: outputFilePath,
-      target: 'node14',
+      target: 'node16',
       platform: 'node',
       format: 'cjs',
       bundle: true,
       mainFields: ['module', 'main'],
-      external: ['esbuild']
+      external: ['esbuild'],
+      define: {
+        window: 'undefined',
+        document: 'undefined',
+        navigator: 'undefined',
+        global: '{}'
+      }
     })
   } catch (error) {
     console.error('Error building file:', error)

package/helpers/symbolsConfig.js

@@ -0,0 +1,35 @@
+import path from 'path'
+import chalk from 'chalk'
+import { loadModule } from '../bin/require.js'
+
+const RC_PATH = process.cwd() + '/symbols.json'
+
+export const loadSymbolsConfig = async (options = {}) => {
+  const {
+    required = true,
+    validateKey = true,
+    silent = false
+  } = options
+
+  try {
+    const config = await loadModule(RC_PATH, { json: true })
+
+    if (validateKey && (!config || !config.key)) {
+      throw new Error('Missing app key in symbols.json')
+    }
+
+    return config
+  } catch (error) {
+    if (error.message.includes('Missing app key')) {
+      console.error(chalk.bold.red('\nInvalid symbols.json configuration:'))
+      console.error(chalk.white('The file must contain a valid app key.'))
+      console.error(chalk.bold.yellow('\nExample symbols.json:'))
+      console.error(chalk.cyan(JSON.stringify({ key: 'your.app.key' }, null, 2)))
+    } else if (!silent) {
+      console.error(chalk.bold.red('Please include symbols.json in your repository root'))
+    }
+
+    if (required) process.exit(1)
+    return null
+  }
+}

package/helpers/transportUtils.js

@@ -0,0 +1,58 @@
+// Utilities for preparing data for transport to the Symbols API.
+// Mirrors the behaviour used in the web app for serialising functions.
+
+// Keys that should be skipped entirely when cloning for transport.
+// These typically contain non-serialisable metadata or runtime-only values.
+// NOTE: This list can be extended to stay in sync with the webapp if needed.
+export const FUNCTION_META_KEYS = [
+  // Internal / meta fields that should not be transported
+  '__fn',
+  '__fnMeta',
+  '__handler',
+  '__meta'
+]
+
+/**
+ * Recursively clones a value and stringifies any functions so that the
+ * result is JSON-serialisable and safe to send over the wire.
+ *
+ * This intentionally skips keys listed in FUNCTION_META_KEYS to avoid
+ * leaking internal runtime metadata.
+ *
+ * @param {any} value
+ * @param {WeakMap<object, any>} [seen]
+ * @returns {any}
+ */
+export function stringifyFunctionsForTransport (value, seen = new WeakMap()) {
+  // Primitive values or functions
+  if (value === null || typeof value !== 'object') {
+    return typeof value === 'function' ? value.toString() : value
+  }
+
+  // Handle circular references
+  if (seen.has(value)) {
+    return seen.get(value)
+  }
+
+  const clone = Array.isArray(value) ? [] : {}
+  seen.set(value, clone)
+
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      clone[i] = stringifyFunctionsForTransport(value[i], seen)
+    }
+    return clone
+  }
+
+  const keys = Object.keys(value)
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i]
+    if (!FUNCTION_META_KEYS.includes(key)) {
+      clone[key] = stringifyFunctionsForTransport(value[key], seen)
+    }
+  }
+
+  return clone
+}
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/cli",
-  "version": "2.33.11",
+  "version": "2.33.13",
   "description": "Fetch your Symbols configuration",
   "main": "bin/fetch.js",
   "author": "Symbols",
@@ -15,16 +15,18 @@
     "vpatch": "npm version patch && npm publish"
   },
   "dependencies": {
-    "@symbo.ls/fetch": "^2.33.11",
-    "@symbo.ls/init": "^2.33.11",
-    "@symbo.ls/socket": "^2.33.11",
+    "@symbo.ls/fetch": "^2.33.13",
+    "@symbo.ls/init": "^2.33.13",
+    "@symbo.ls/socket": "^2.33.13",
     "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "diff": "^5.2.0",
     "esbuild": "^0.25.1",
     "inquirer": "^12.9.0",
     "node-fetch": "^3.3.2",
+    "socket.io-client": "^4.8.1",
     "v8-compile-cache": "^2.4.0"
   },
-  "gitHead": "bd35281698ecf0b85f212fa22e3ee66a5053c2bb"
+  "gitHead": "3d34d72f2ada44fdb269644cc915d3ef84cfe360"
 }