@symbo.ls/cli 2.33.12 → 2.33.13

package/bin/fs.js

@@ -18,24 +18,90 @@ const {
 } = utils.default || utils
 
 let singleFileKeys = ['designSystem', 'state', 'files', 'dependencies']
-const directoryKeys = [
-  'components',
-  'snippets',
-  'pages',
-  'functions',
-  'methods'
-]
-
-const defaultExports = [
-  'pages',
-  'designSystem',
-  'state',
-  'files',
-  'dependencies',
-  'schema'
-]
-
-export async function createFs(
+const directoryKeys = ['components', 'snippets', 'pages', 'functions', 'methods']
+
+const defaultExports = ['pages', 'designSystem', 'state', 'files', 'dependencies', 'schema']
+
+// Minimal reserved identifier set to avoid invalid named exports like "export const default"
+const RESERVED_IDENTIFIERS = new Set(['default'])
+function isReservedIdentifier (name) {
+  return RESERVED_IDENTIFIERS.has(name)
+}
+
+// Keys that should never be materialized as files inside collection directories
+const SKIP_ENTRY_KEYS = new Set(['__order', 'schema'])
+function shouldSkipEntryKey (name) {
+  return SKIP_ENTRY_KEYS.has(name) || isReservedIdentifier(name)
+}
+
+function reorderWithOrderKeys (input) {
+  if (Array.isArray(input)) {
+    return input.map(reorderWithOrderKeys)
+  }
+  if (!input || typeof input !== 'object') return input
+  const hasOrder = Array.isArray(input.__order)
+  const originalKeys = Object.keys(input)
+  const orderedKeys = []
+  if (hasOrder) {
+    for (let i = 0; i < input.__order.length; i++) {
+      const k = input.__order[i]
+      if (k === '__order') continue
+      if (originalKeys.includes(k) && !orderedKeys.includes(k)) {
+        orderedKeys.push(k)
+      }
+    }
+  }
+  for (let i = 0; i < originalKeys.length; i++) {
+    const k = originalKeys[i]
+    if (k === '__order') continue
+    if (!orderedKeys.includes(k)) orderedKeys.push(k)
+  }
+  const out = {}
+  for (let i = 0; i < orderedKeys.length; i++) {
+    const k = orderedKeys[i]
+    out[k] = reorderWithOrderKeys(input[k])
+  }
+  if (hasOrder) {
+    out.__order = input.__order.slice()
+  } else if (Object.prototype.hasOwnProperty.call(input, '__order')) {
+    // Preserve explicit empty/non-array __order semantics at the end
+    out.__order = input.__order
+  }
+  return out
+}
+
+async function removeStaleFiles(body, targetDir) {
+  for (const key of directoryKeys) {
+    const dirPath = path.join(targetDir, key)
+    if (!fs.existsSync(dirPath)) continue
+
+    const existingFiles = await fs.promises.readdir(dirPath)
+    const currentEntries = body[key] ? Object.keys(body[key])
+      // Drop meta/reserved identifiers like "__order" and "default"
+      .filter(entry => !shouldSkipEntryKey(entry))
+      .map(entry => {
+      // Apply the same transformations as in createKeyDirectoryAndFiles
+      let fileName = entry
+      if (fileName.startsWith('/')) fileName = fileName.slice(1)
+      if (fileName === '') fileName = 'main'
+      if (fileName.includes('*')) fileName = 'fallback'
+      return `${fileName.replace('/', '-')}.js`
+    }) : []
+
+    // Don't remove index.js
+    const filesToCheck = existingFiles.filter(file => file !== 'index.js')
+
+    for (const file of filesToCheck) {
+      if (!currentEntries.includes(file)) {
+        const filePath = path.join(dirPath, file)
+        console.log(chalk.yellow(`Removing stale file: ${path.join(key, file)}`))
+        await fs.promises.unlink(filePath)
+      }
+    }
+  }
+}
+
+export async function createFs (
   body,
   distDir = path.join(process.cwd(), 'smbls'),
   opts = {}
@@ -84,54 +150,72 @@ export async function createFs(
 
   if (filesExist) {
     const cacheDir = path.join(distDir, '.cache')
-    await fs.promises.mkdir(cacheDir, { recursive: true })
 
-    const cachePromises = [
-      ...directoryKeys.map((key) =>
-        createKeyDirectoryAndFiles(key, body, cacheDir, true)
-      ),
-      ...singleFileKeys.map((key) => {
-        if (body[key] && typeof body[key] === 'object') {
-          return createSingleFileFolderAndFile(key, body[key], cacheDir, true)
-        }
-        return undefined
-      })
-    ]
+    try {
+      await fs.promises.mkdir(cacheDir, { recursive: true })
 
-    await Promise.all(cachePromises)
-    await generateIndexjsFile(
-      joinArrays(directoryKeys, singleFileKeys),
-      cacheDir,
-      'root'
-    )
+      if (update) {
+        await removeStaleFiles(body, targetDir)
+      }
 
-    const diffs = await findDiff(cacheDir, targetDir)
-    if (diffs.length > 0) {
-      console.log('Differences found:')
-      diffs.forEach((diff) => {
-        console.log(chalk.green(`File: ${diff.file}`))
-        console.log(chalk.yellow('Diff:'))
-        console.log(chalk.yellow(diff.diff))
-        console.log('---')
-      })
-      if (!update) {
-        const { consent } = await askForConsent()
-        if (consent) {
+      const cachePromises = [
+        ...directoryKeys.map((key) =>
+          createKeyDirectoryAndFiles(key, body, cacheDir, true)
+        ),
+        ...singleFileKeys.map((key) => {
+          if (body[key] && typeof body[key] === 'object') {
+            return createSingleFileFolderAndFile(key, body[key], cacheDir, true)
+          }
+          return undefined
+        })
+      ]
+
+      await Promise.all(cachePromises)
+      await generateIndexjsFile(
+        joinArrays(directoryKeys, singleFileKeys),
+        cacheDir,
+        'root'
+      )
+
+      const diffs = await findDiff(cacheDir, targetDir)
+      if (diffs.length > 0) {
+        console.log('Differences found:')
+        diffs.forEach((diff) => {
+          console.log(chalk.green(`File: ${diff.file}`))
+          console.log(chalk.yellow('Diff:'))
+          console.log(chalk.yellow(diff.diff))
+          console.log('---')
+        })
+        if (!update) {
+          const { consent } = await askForConsent()
+          if (consent) {
+            await overrideFiles(cacheDir, targetDir)
+            console.log('Files overridden successfully.')
+          } else {
+            console.log('Files not overridden.')
+          }
+        } else {
           await overrideFiles(cacheDir, targetDir)
           console.log('Files overridden successfully.')
-        } else {
-          console.log('Files not overridden.')
+          console.log()
+          console.log(chalk.dim('\n----------------\n'))
         }
       } else {
-        await overrideFiles(cacheDir, targetDir)
-        console.log('Files overridden successfully.')
+        console.log('No differences found.')
         console.log()
         console.log(chalk.dim('\n----------------\n'))
       }
-    } else {
-      console.log('No differences found.')
-      console.log()
-      console.log(chalk.dim('\n----------------\n'))
+
+      // Clean up cache directory
+      await fs.promises.rm(cacheDir, { recursive: true, force: true })
+    } catch (error) {
+      // Make sure we clean up even if there's an error
+      try {
+        await fs.promises.rm(cacheDir, { recursive: true, force: true })
+      } catch (cleanupError) {
+        // Ignore cleanup errors
+      }
+      throw error // Re-throw the original error
     }
   }
 
@@ -142,7 +226,10 @@ export async function createFs(
     const dirs = []
 
     if (body[key] && isObject(body[key])) {
-      const promises = Object.entries(body[key]).map(
+      const promises = Object.entries(body[key])
+        // Skip meta/reserved identifier entries (e.g. "__order", "default")
+        .filter(([entryKey]) => !shouldSkipEntryKey(entryKey))
+        .map(
         async ([entryKey, value]) => {
           // if pages
           if (entryKey.startsWith('/')) entryKey = entryKey.slice(1)
@@ -165,7 +252,9 @@ export async function createFs(
       childKey.includes('-') || childKey.includes('/')
         ? removeChars(toCamelCase(childKey))
         : childKey
-    const filePath = path.join(dirPath, `${childKey.replaceAll('/', '-')}.js`)
+    // Avoid reserved identifiers that break ESM syntax, e.g. "export const default"
+    const safeItemKey = isReservedIdentifier(itemKey) ? `_${itemKey}` : itemKey
+    const filePath = path.join(dirPath, `${childKey.replace('/', '-')}.js`)
 
     if (!update && fs.existsSync(filePath)) {
       return
@@ -174,13 +263,13 @@ export async function createFs(
     const itemKeyInvalid = itemKey.includes('.')
     const validKey = itemKeyInvalid
       ? `const ${removeChars(toTitleCase(itemKey))}`
-      : `export const ${itemKey}`
+      : `export const ${safeItemKey}`
 
     let stringifiedContent
     if (isString(value)) {
       stringifiedContent = `${validKey} = ${value}`
     } else {
-      const content = deepDestringifyFunctions(value)
+      const content = reorderWithOrderKeys(deepDestringifyFunctions(value))
       // console.log('ON DEEPDESTR:')
       // console.log(content.components.Configuration)
       stringifiedContent = `${validKey} = ${objectToString(content)};`
@@ -203,7 +292,7 @@ export { ${removeChars(toTitleCase(itemKey))} as '${itemKey}' }`
     }
 
     if (isString(data)) data = { default: data }
-    const content = deepDestringifyFunctions(data)
+    const content = reorderWithOrderKeys(deepDestringifyFunctions(data))
     const stringifiedContent = `export default ${objectToString(content)};`
 
     await fs.promises.writeFile(filePath, stringifiedContent, 'utf8')

package/bin/index.js

@@ -13,6 +13,7 @@ import './create.js'
 import './login.js'
 import './push.js'
 import './link-packages.js'
+import './collab.js'
 
 const args = process.argv
 program.parse(args)

package/bin/install.js

@@ -4,20 +4,10 @@ import chalk from 'chalk'
 import { loadModule } from './require.js'
 import { exec } from 'child_process'
 import { program } from './program.js'
-
+import { loadSymbolsConfig } from '../helpers/symbolsConfig.js'
 const PACKAGE_PATH = process.cwd() + '/package.json'
-const RC_PATH = process.cwd() + '/symbols.json'
-const LOCAL_CONFIG_PATH = process.cwd() + '/node_modules/@symbo.ls/init/dynamic.json'
-const DEFAULT_REMOTE_CONFIG_PATH = 'https://api.symbols.app/' // eslint-disable-line
-
-const pkg = loadModule(PACKAGE_PATH)
-const rcFile = loadModule(RC_PATH) // eslint-disable-line
-const localConfig = loadModule(LOCAL_CONFIG_PATH) // eslint-disable-line
 
-let rc = {}
-try {
-  rc = loadModule(RC_PATH) // eslint-disable-line
-} catch (e) { console.error('Please include symbols.json to your root of respository') }
+const pkg = await loadModule(PACKAGE_PATH, { json: true, silent: true })
 
 const makeCommand = (packageManager, packageName) => {
   return packageManager === 'yarn'
@@ -28,13 +18,10 @@ const makeCommand = (packageManager, packageName) => {
 }
 
 export const installFromCli = async (options) => {
-  if (!rcFile || !localConfig) {
-    console.error('symbols.json not found in the root of the repository')
-    return
-  }
+  const symbolsConfig = await loadSymbolsConfig()
 
-  const framework = rcFile.framework || options.framework
-  const packageManager = rcFile.packageManager || options.packageManager
+  const framework = symbolsConfig.framework || options.framework
+  const packageManager = symbolsConfig.packageManager || options.packageManager
 
   // const packageName = `@symbo.ls/${mode || 'uikit'}`
   const packageName = framework === 'react' ? '@symbo.ls/react' : 'smbls'
@@ -63,7 +50,7 @@ export const installFromCli = async (options) => {
 }
 
 program
-  .version(pkg.version ?? 'unknown')
+  .version(pkg && pkg.version ? pkg.version : 'unknown')
 
 program
   .command('install')

package/bin/login.js

@@ -1,56 +1,25 @@
 'use strict'
 
 import inquirer from 'inquirer'
-import fs from 'fs'
-import path from 'path'
-import os from 'os'
 import chalk from 'chalk'
 import { program } from './program.js'
-import { getApiUrl } from '../helpers/config.js'
+import { getApiUrl, saveCliConfig, loadCliConfig } from '../helpers/config.js'
+import { CredentialManager } from '../helpers/credentialManager.js'
 
-const RC_FILE = '.smblsrc'
-
-// Helper to manage credentials
-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 {
-      fs.writeFileSync(this.rcPath, JSON.stringify(credentials, null, 2))
-      return true
-    } catch (err) {
-      console.error('Failed to save credentials:', err)
-      return false
-    }
-  }
-
-  // Get stored auth token
-  getAuthToken () {
-    const creds = this.loadCredentials()
-    return creds.authToken
-  }
-
-  // Clear stored credentials
-  clearCredentials () {
-    try {
-      fs.unlinkSync(this.rcPath)
-      return true
-    } catch (err) {
-      return false
-    }
+function websiteFromApi(apiBaseUrl) {
+  try {
+    const u = new URL(apiBaseUrl)
+    const host = u.host
+    if (apiBaseUrl.startsWith('http://localhost')) return 'http://localhost:1024'
+    if (host === 'api.dev.symbols.app') return 'https://dev.symbols.app'
+    if (host === 'api.staging.symbols.app') return 'https://staging.symbols.app'
+    if (host === 'api.test.symbols.app') return 'https://test.symbols.app'
+    if (host === 'api.symbols.app') return 'https://symbols.app'
+    // Fallback: strip leading api.
+    if (host.startsWith('api.')) return `https://${host.replace(/^api\./, '')}`
+    return `${u.protocol}//${host}`
+  } catch (_) {
+    return 'https://symbols.app'
   }
 }
 
@@ -58,29 +27,38 @@ program
   .command('login')
   .description('Sign in to Symbols')
   .action(async () => {
-    console.log('yo login')
-
-    console.log(getApiUrl())
+    console.log(chalk.cyan('\n🔑 Welcome to Symbols CLI'))
+    console.log(chalk.white('\nPlease sign in with your Symbols account:'))
+    console.log(chalk.dim('Don\'t have an account? Visit https://symbols.app/signup\n'))
 
     // Prompt for credentials
+    const currentConfig = loadCliConfig()
     const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'apiBaseUrl',
+        message: 'API Base URL:',
+        default: currentConfig.apiBaseUrl || getApiUrl(),
+        validate: input => /^https?:\/\//.test(input) || '❌ Please enter a valid URL'
+      },
       {
         type: 'input',
         name: 'email',
-        message: 'Enter your email:',
-        validate: input => input.includes('@') || 'Please enter a valid email'
+        message: 'Email:',
+        validate: input => input.includes('@') || '❌ Please enter a valid email address'
       },
       {
         type: 'password',
         name: 'password',
-        message: 'Enter your password:',
-        validate: input => input.length >= 6 || 'Password must be at least 6 characters'
+        message: 'Password:',
+        validate: input => input.length >= 6 || '❌ Password must be at least 6 characters'
       }
     ])
 
     try {
       // Make login request
-      const response = await fetch(`${getApiUrl()}/auth/login`, {
+      console.log(chalk.dim('\nAuthenticating...'))
+      const response = await fetch(`${answers.apiBaseUrl}/core/auth/login`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json'
@@ -94,21 +72,63 @@ program
       const data = await response.json()
 
       if (!response.ok) {
-        throw new Error(data.error || 'Authentication failed')
+        const msg = data?.message || data?.error || `Authentication failed (${response.status})`
+        const err = new Error(msg)
+        err.response = { status: response.status, data }
+        throw err
       }
 
+      // Extract token from various possible shapes
+      const user = data?.data?.user || data?.user
+      const tokens = data?.data?.tokens || data?.tokens || {}
+      const token =
+        tokens?.accessToken ||
+        data?.token ||
+        data?.accessToken ||
+        data?.jwt ||
+        data?.data?.token ||
+        data?.data?.accessToken ||
+        data?.data?.jwt
+      if (!token) {
+        throw new Error('Login succeeded but no token was returned by the server')
+      }
+      const refreshToken = tokens?.refreshToken || null
+      const accessTokenExp = tokens?.accessTokenExp?.expiresAt || null
+
       // Save credentials
       const credManager = new CredentialManager()
       credManager.saveCredentials({
-        authToken: data.token,
-        userId: data.userId,
-        email: answers.email
+        authToken: token,
+        refreshToken,
+        authTokenExpiresAt: accessTokenExp,
+        userId: user?.id || data?.userId,
+        email: user?.email || answers.email
       })
 
-      console.log(chalk.green('\nSuccessfully logged in!'))
-      console.log(chalk.dim(`Credentials saved to ${credManager.rcPath}`))
+      // Persist API base URL to local config
+      saveCliConfig({ apiBaseUrl: answers.apiBaseUrl })
+
+      console.log(chalk.green('\n✨ Successfully logged in!'))
+      console.log(chalk.white('\nYou can now use Symbols CLI commands:'))
+      console.log(chalk.cyan('  smbls fetch    ') + chalk.dim('Fetch your design system'))
+      console.log(chalk.cyan('  smbls sync     ') + chalk.dim('Sync local changes'))
+      console.log(chalk.cyan('  smbls push     ') + chalk.dim('Push updates to Symbols'))
+      console.log(chalk.cyan('  smbls collab   ') + chalk.dim('Connect to team on platform in realtime'))
+
+      console.log(chalk.dim(`\nCredentials saved to ${credManager.rcPath}`))
+      console.log(chalk.dim('For more commands, run: smbls --help\n'))
+
     } catch (error) {
-      console.error(chalk.red('\nLogin failed:'), error.message)
+      const website = websiteFromApi(answers.apiBaseUrl)
+      console.log(chalk.red('\n❌ Login failed'))
+      console.log(chalk.white('\nError:'))
+      console.log(chalk.yellow(error.message || 'Unknown error'))
+
+      console.log(chalk.white('\nNeed help?'))
+      console.log(chalk.dim(`• Reset password: ${website}/reset-password`))
+      console.log(chalk.dim('• Contact support: support@symbols.app'))
+      console.log(chalk.dim(`• Documentation: ${website}/docs/cli\n`))
+
       process.exit(1)
     }
   })