feat: 添加区域切换功能，支持根据用户配置动态设置域名和API URL

mfzzf · mfzzf · commit 8277d2bab777 · 2026-03-18T18:11:05.000+08:00
diff --git a/packages/js-sdk/src/connectionConfig.ts b/packages/js-sdk/src/connectionConfig.ts
@@ -102,11 +102,11 @@ export class ConnectionConfig {
   }
 
   private static get domain() {
-    return getEnvVar('E2B_DOMAIN') || 'sandbox.ucloudai.com'
+    return getEnvVar('UCLOUD_SANDBOX_DOMAIN') || getEnvVar('E2B_DOMAIN') || 'sandbox.ucloudai.com'
   }
 
   private static get apiUrl() {
-    return getEnvVar('E2B_API_URL')
+    return getEnvVar('UCLOUD_SANDBOX_API_URL') || getEnvVar('E2B_API_URL')
   }
 
   private static get sandboxUrl() {
diff --git a/src/api.ts b/src/api.ts
@@ -3,6 +3,7 @@ import * as e2b from 'e2b'
 
 import { getUserConfig, UserConfig } from './user'
 import { asBold, asPrimary } from './utils/format'
+import { getRegionDomain, getRegionApiUrl } from './commands/region'
 
 export let apiKey = process.env.AGENTBOX_API_KEY
 export let accessToken = process.env.AGENTBOX_ACCESS_TOKEN
@@ -88,10 +89,20 @@ export function ensureAccessToken() {
 
 const userConfig = getUserConfig()
 
+// Inject region-based domain/apiUrl into env so SDK internal calls (Sandbox.list, etc.) also use them
+if (userConfig?.region) {
+  if (!process.env.UCLOUD_SANDBOX_DOMAIN) {
+    process.env.UCLOUD_SANDBOX_DOMAIN = getRegionDomain(userConfig.region)
+  }
+  if (!process.env.UCLOUD_SANDBOX_API_URL) {
+    process.env.UCLOUD_SANDBOX_API_URL = getRegionApiUrl(userConfig.region)
+  }
+}
+
 export const connectionConfig = new e2b.ConnectionConfig({
   accessToken: process.env.AGENTBOX_ACCESS_TOKEN || userConfig?.accessToken,
   apiKey: process.env.AGENTBOX_API_KEY || userConfig?.teamApiKey,
-  domain: process.env.UCLOUD_SANDBOX_DOMAIN || 'sandbox.ucloudai.com',
-  apiUrl: process.env.UCLOUD_SANDBOX_API_URL || 'https://api.sandbox.ucloudai.com',
+  domain: process.env.UCLOUD_SANDBOX_DOMAIN || getRegionDomain(userConfig?.region),
+  apiUrl: process.env.UCLOUD_SANDBOX_API_URL || getRegionApiUrl(userConfig?.region),
 })
 export const client = new e2b.ApiClient(connectionConfig)
diff --git a/src/commands/index.ts b/src/commands/index.ts
@@ -4,6 +4,7 @@ import { asPrimary } from 'src/utils/format'
 import { templateCommand } from './template'
 import { sandboxCommand } from './sandbox'
 import { authCommand } from './auth'
+import { regionCommand } from './region'
 
 export const program = new commander.Command()
   .description(
@@ -19,6 +20,7 @@ Visit ${asPrimary(
   .addCommand(authCommand)
   .addCommand(templateCommand)
   .addCommand(sandboxCommand)
+  .addCommand(regionCommand)
 
 function addDebugOption(cmd: commander.Command) {
   cmd.option('--debug', 'print Trace ID for debugging')
diff --git a/src/commands/region.ts b/src/commands/region.ts
@@ -0,0 +1,75 @@
+import * as commander from 'commander'
+import * as fs from 'fs'
+import * as path from 'path'
+import * as chalk from 'chalk'
+
+import { getUserConfig, USER_CONFIG_PATH } from 'src/user'
+
+const REGIONS = [
+  { id: 'cn-wlcb', name: 'cn-wlcb (China - North)' },
+  { id: 'us-ca', name: 'us-ca (US - West)' },
+] as const
+
+type RegionId = (typeof REGIONS)[number]['id']
+
+export function getRegionDomain(region?: string): string {
+  if (!region) return 'sandbox.ucloudai.com'
+  return `${region}.sandbox.ucloudai.com`
+}
+
+export function getRegionApiUrl(region?: string): string {
+  if (!region) return 'https://api.sandbox.ucloudai.com'
+  return `https://api.${region}.sandbox.ucloudai.com`
+}
+
+function switchRegion(region: string) {
+  const valid = REGIONS.find((r) => r.id === region)
+  if (!valid) {
+    console.error(
+      `Unknown region: ${region}\nAvailable regions: ${REGIONS.map((r) => r.id).join(', ')}`
+    )
+    process.exit(1)
+  }
+
+  const userConfig = getUserConfig() || ({} as any)
+  const updatedConfig = { ...userConfig, region }
+  fs.mkdirSync(path.dirname(USER_CONFIG_PATH), { recursive: true })
+  fs.writeFileSync(USER_CONFIG_PATH, JSON.stringify(updatedConfig, null, 2))
+
+  console.log(`Switched to region ${chalk.default.green(valid.name)}`)
+  console.log(`  Domain: ${getRegionDomain(region)}`)
+  console.log(`  API:    ${getRegionApiUrl(region)}`)
+}
+
+export const regionCommand = new commander.Command('region')
+  .description('switch region for sandbox services')
+  .argument('[region]', 'region to switch to (e.g. cn-wlcb, us-ca)')
+  .action(async (region?: string) => {
+    if (region) {
+      switchRegion(region)
+      process.exit(0)
+    }
+
+    // Interactive selection
+    const userConfig = getUserConfig()
+    const currentRegion = userConfig?.region || ''
+
+    const inquirer = await import('inquirer')
+    const { selected } = await inquirer.default.prompt([
+      {
+        name: 'selected',
+        type: 'list',
+        message: 'Select region:',
+        choices: REGIONS.map((r) => ({
+          name: r.id === currentRegion
+            ? chalk.default.green(`${r.name}  \u2713`)
+            : r.name,
+          value: r.id,
+        })),
+        default: currentRegion || REGIONS[0].id,
+      },
+    ])
+
+    switchRegion(selected)
+    process.exit(0)
+  })
diff --git a/src/commands/template/build.ts b/src/commands/template/build.ts
@@ -12,7 +12,7 @@ import {
   fallbackDockerfileName,
 } from 'src/docker/constants'
 import { configOption, pathOption, teamOption } from 'src/options'
-import { getUserConfig } from 'src/user'
+import { getUserConfig, USER_CONFIG_PATH } from 'src/user'
 import { getRoot } from 'src/utils/filesystem'
 import { wait } from 'src/utils/wait'
 import * as stripAnsi from 'strip-ansi'
@@ -28,13 +28,15 @@ import {
   asTypescript,
   withDelimiter,
 } from '../../utils/format'
-import { buildWithProxy } from './buildWithProxy'
 
 const templateCheckInterval = 500 // 0.5 sec
 
 // Custom image URI is used for Bring Your Own Compute with self-hosted Docker registry
 export const imageUriMask = process.env.UCLOUD_SANDBOX_IMAGE_URI_MASK
 
+// UHub Docker Registry
+const UHUB_REGISTRY = 'uhub.service.ucloud.cn'
+
 async function getTemplateBuildLogs({
   templateID,
   buildID,
@@ -87,18 +89,36 @@ async function requestTemplateRebuild(
   })
 }
 
-async function triggerTemplateBuild(templateID: string, buildID: string) {
+async function triggerTemplateBuild(
+  templateID: string,
+  buildID: string,
+  fromImage?: string,
+  registryCredentials?: { username: string; password: string }
+) {
   let res
   const maxRetries = 3
   for (let i = 0; i < maxRetries; i++) {
     try {
+      const body: Record<string, unknown> = {}
+      if (fromImage) {
+        body.fromImage = fromImage
+      }
+      if (registryCredentials) {
+        body.fromImageRegistry = {
+          type: 'registry',
+          username: registryCredentials.username,
+          password: registryCredentials.password,
+        }
+      }
+
       res = await client.api.POST('/templates/{templateID}/builds/{buildID}', {
         params: {
           path: {
             templateID,
             buildID,
           },
         },
+        body: body as any,
       })
 
       break
@@ -197,6 +217,8 @@ export const buildCommand = new commander.Command('build')
         noCache?: boolean
       }
     ) => {
+      let uhubRepoPath = ''
+      let uhubCreds: { username: string; password: string } | undefined
       try {
         // Display deprecation warning
         const deprecationMessage = `${asBold('DEPRECATION WARNING')}
@@ -241,7 +263,7 @@ Migration guide: ${asPrimary('https://docs.ucloud.cn/modelverse/README')}`
           })
         }
 
-        const accessToken = ensureAccessToken()
+        ensureAccessToken()
         process.stdout.write('\n')
 
         const newName = opts.name?.trim()
@@ -374,20 +396,85 @@ Migration guide: ${asPrimary('https://docs.ucloud.cn/modelverse/README')}`
         )
 
         if (imageUriMask == undefined) {
+          // Login to UHub registry — reuse saved credentials or prompt
+          const inquirer = await import('inquirer')
+          let savedConfig = getUserConfig()
+          let uhubUsername = savedConfig?.uhubUsername || ''
+          let uhubPassword = savedConfig?.uhubPassword || ''
+
+          if (uhubUsername && uhubPassword) {
+            console.log(`Using saved UHub credentials (username: ${uhubUsername})`)
+          } else {
+            console.log(`Logging in to UHub registry (${UHUB_REGISTRY})...`)
+            const answers = await inquirer.default.prompt([
+              {
+                name: 'uhubUsername',
+                type: 'input',
+                message: 'UHub username:',
+              },
+              {
+                name: 'uhubPassword',
+                type: 'password',
+                message: 'UHub password (token):',
+                mask: '*',
+              },
+            ])
+            uhubUsername = answers.uhubUsername
+            uhubPassword = answers.uhubPassword
+          }
+
           try {
             child_process.execSync(
-              `echo "${accessToken}" | docker login docker.${connectionConfig.domain} -u _sandbox_access_token --password-stdin`,
+              `docker login ${UHUB_REGISTRY} -u ${uhubUsername} --password-stdin`,
               {
-                stdio: 'inherit',
+                stdio: ['pipe', 'inherit', 'inherit'],
                 cwd: root,
+                input: uhubPassword,
               }
             )
+            uhubCreds = { username: uhubUsername, password: uhubPassword }
           } catch (err: any) {
             console.error(
-              'Docker login failed. Please try to log in with `ucloud-sandbox-cli auth login` and try again.'
+              `Docker login to ${UHUB_REGISTRY} failed. Please check your UHub credentials and try again.`
             )
+            // Clear saved credentials on failure
+            if (savedConfig) {
+              const { uhubUsername: _u, uhubPassword: _p, uhubRepo: _r, ...rest } = savedConfig
+              fs.writeFileSync(USER_CONFIG_PATH, JSON.stringify(rest, null, 2))
+            }
             process.exit(1)
           }
+
+          // Prompt for UHub namespace and repo name, reuse saved or ask
+          let uhubRepo = savedConfig?.uhubRepo || ''
+          if (uhubRepo) {
+            console.log(`Using saved UHub repo: ${uhubRepo}`)
+          } else {
+            const repoAnswer = await inquirer.default.prompt([
+              {
+                name: 'uhubNamespace',
+                type: 'input',
+                message: 'UHub namespace (e.g. ucloud-uhub):',
+                validate: (input: string) => input ? true : 'Namespace is required',
+              },
+              {
+                name: 'uhubRepoName',
+                type: 'input',
+                message: `UHub repo name:`,
+                default: templateID,
+                validate: (input: string) => input ? true : 'Repo name is required',
+              },
+            ])
+            uhubRepo = `${repoAnswer.uhubNamespace}/${repoAnswer.uhubRepoName}`
+          }
+
+          // Save all UHub settings to config
+          if (savedConfig) {
+            const updatedConfig = { ...savedConfig, uhubUsername, uhubPassword, uhubRepo }
+            fs.writeFileSync(USER_CONFIG_PATH, JSON.stringify(updatedConfig, null, 2))
+          }
+
+          uhubRepoPath = uhubRepo
         }
 
         process.stdout.write('\n')
@@ -402,7 +489,8 @@ Migration guide: ${asPrimary('https://docs.ucloud.cn/modelverse/README')}`
           templateID,
           template.buildID,
           connectionConfig.domain,
-          imageUriMask
+          imageUriMask,
+          uhubRepoPath
         )
         if (imageUriMask != undefined) {
           console.log('Using custom docker image URI:', imageUrl)
@@ -444,18 +532,15 @@ Migration guide: ${asPrimary('https://docs.ucloud.cn/modelverse/README')}`
             cwd: root,
           })
         } catch (err: any) {
-          await buildWithProxy(
-            userConfig,
-            connectionConfig,
-            accessToken,
-            template,
-            root
+          console.error(
+            `Docker push to ${UHUB_REGISTRY} failed. Please check your UHub credentials and repository permissions.`
           )
+          process.exit(1)
         }
         console.log('> Docker image pushed.\n')
 
         console.log('Triggering build...')
-        await triggerBuild(templateID, template.buildID)
+        await triggerBuild(templateID, template.buildID, imageUrl, uhubCreds)
 
         console.log(
           `> Triggered build for the sandbox template ${asFormattedSandboxTemplate(
@@ -656,20 +741,26 @@ async function requestBuildTemplate(
   return res.data
 }
 
-async function triggerBuild(templateID: string, buildID: string) {
-  await triggerTemplateBuild(templateID, buildID)
+async function triggerBuild(
+  templateID: string,
+  buildID: string,
+  fromImage?: string,
+  registryCredentials?: { username: string; password: string }
+) {
+  await triggerTemplateBuild(templateID, buildID, fromImage, registryCredentials)
 
   return
 }
 
 function dockerImageUrl(
   templateID: string,
   buildID: string,
-  defaultDomain: string,
-  imageUrlMask?: string
+  _defaultDomain: string,
+  imageUrlMask?: string,
+  uhubRepo?: string
 ): string {
   if (imageUrlMask == undefined) {
-    return `docker.${defaultDomain}/sandbox/custom-envs/${templateID}:${buildID}`
+    return `${UHUB_REGISTRY}/${uhubRepo}:${buildID}`
   }
 
   return imageUrlMask
diff --git a/src/user.ts b/src/user.ts
@@ -12,6 +12,10 @@ export interface UserConfig {
   teamId: string
   teamApiKey: string
   dockerProxySet?: boolean
+  uhubUsername?: string
+  uhubPassword?: string
+  uhubRepo?: string
+  region?: string
 }
 
 export const USER_CONFIG_PATH = path.join(os.homedir(), '.ucloud-sandbox-cli', 'config.json')

Original file line number	Diff line number	Diff line change
`@@ -102,11 +102,11 @@ export class ConnectionConfig {`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`private static get domain() {`
`105`		`- return getEnvVar('E2B_DOMAIN') \|\| 'sandbox.ucloudai.com'`
	`105`	`+ return getEnvVar('UCLOUD_SANDBOX_DOMAIN') \|\| getEnvVar('E2B_DOMAIN') \|\| 'sandbox.ucloudai.com'`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`private static get apiUrl() {`
`109`		`- return getEnvVar('E2B_API_URL')`
	`109`	`+ return getEnvVar('UCLOUD_SANDBOX_API_URL') \|\| getEnvVar('E2B_API_URL')`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`private static get sandboxUrl() {`