openyida 2026.7.18 → 2026.7.21

package/lib/app/update-form-config.js

@@ -4,6 +4,7 @@ const { loadAuthData, triggerLogin, resolveBaseUrl, httpPost, requestWithAutoLog
 const { t } = require('../core/i18n');
 const { buildYidaTitleI18n, normalizeYidaLocale, resolveContentLocale } = require('../core/yida-i18n');
 const { banner, step, label, success, fail, warn, info, error, result, usage } = require('../core/chalk');
+const { throwCommandError, throwUsage } = require('../core/command-errors');
 
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -24,7 +25,7 @@ function parseArgs() {
     info(t('update_form_config.params_label'));
     label(t('update_form_config.param_is_render_nav'), '');
     label(t('update_form_config.param_title'), '');
-    process.exit(1);
+    throwUsage(t('update_form_config.usage'), t('update_form_config.example'));
   }
   return {
     appType: args[0],
@@ -218,10 +219,11 @@ async function main() {
     }
   } else {
     fail(t('common.request_failed_label'));
-    process.exit(1);
+    throwCommandError(t('common.request_failed_label'));
   }
 }
 
 main().catch((err) => {
   error(t('common.exception', err.message));
+  process.exitCode = err && err.exitCode ? err.exitCode : 1;
 });

package/lib/asset/asset-cmd.js

@@ -24,6 +24,7 @@ const {
   detectImageGenerator,
   getMaterialSourcingGuidance,
 } = require('./ai-image');
+const { throwCommandError, throwStatus } = require('../core/command-errors');
 
 function printHelp() {
   console.log(`
@@ -110,8 +111,9 @@ function runStatus(options) {
 
 async function runVerifyUrl(options) {
   if (!options.urls.length) {
-    console.error('错误：请至少提供一个图片 URL。用法：openyida asset verify-url <url> [<url> ...]');
-    process.exit(1);
+    throwCommandError('错误：请至少提供一个图片 URL。用法：openyida asset verify-url <url> [<url> ...]', {
+      code: 'ASSET_VERIFY_URL_INVALID_ARGUMENTS',
+    });
   }
   const results = await verifyImageUrls(options.urls, {
     minBytes: options.minBytes,
@@ -132,7 +134,12 @@ async function runVerifyUrl(options) {
       ' reason=' + r.reason
     );
   });
-  if (!allOk) {process.exit(1);}
+  if (!allOk) {
+    throwCommandError('图片 URL 校验失败', {
+      code: 'ASSET_VERIFY_URL_FAILED',
+      details: { results },
+    });
+  }
 }
 
 async function runResolve(options) {
@@ -164,7 +171,12 @@ async function runResolve(options) {
     result.materialGaps.forEach((g) => console.log('  - ' + g));
   }
   // 非 final 时以非零退出码提示调用方（生成链路可据此拦截「最终版」）
-  if (result.materialStatus !== 'final') {process.exit(2);}
+  if (result.materialStatus !== 'final') {
+    throwStatus('素材未达到 final 状态', 2, {
+      code: 'ASSET_MATERIAL_NOT_FINAL',
+      details: result,
+    });
+  }
 }
 
 function runGenerate(options) {
@@ -208,9 +220,10 @@ async function run(args) {
       runGenerate(options);
       break;
     default:
-      console.error('未知子命令: ' + options.subCommand);
       printHelp();
-      process.exit(1);
+      throwCommandError('未知子命令: ' + options.subCommand, {
+        code: 'ASSET_UNKNOWN_SUBCOMMAND',
+      });
   }
 }
 

package/lib/auth/oauth-loopback.js

@@ -2,7 +2,10 @@
 
 const crypto = require('crypto');
 const http = require('http');
-const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
 
 const CALLBACK_PATH = '/oauth/callback';
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
@@ -11,30 +14,336 @@ function randomToken(bytes = 24) {
   return crypto.randomBytes(bytes).toString('base64url');
 }
 
-function openBrowser(url) {
-  if (process.env.OPENYIDA_NO_BROWSER === '1') {
-    return false;
+const CHROMIUM_MAC_BUNDLES = {
+  'com.google.chrome': 'com.google.Chrome',
+  'com.microsoft.edgemac': 'com.microsoft.edgemac',
+  'com.brave.browser': 'com.brave.Browser',
+  'com.operasoftware.opera': 'com.operasoftware.Opera',
+  'com.vivaldi.vivaldi': 'com.vivaldi.Vivaldi',
+  'org.chromium.chromium': 'org.chromium.Chromium',
+};
+
+// Only these browser families have a known reliable new-window launch path.
+// Anything else (unknown/unsupported default browser) must fall back.
+const SUPPORTED_BROWSER_FAMILIES = new Set(['chromium', 'firefox', 'safari']);
+
+// Chromium accepts `--new-window`; Firefox uses the single-dash `-new-window`.
+function newWindowFlag(family) {
+  return family === 'firefox' ? '-new-window' : '--new-window';
+}
+
+function appleScriptSafe(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function classifyMacBundleId(bundleId) {
+  if (!bundleId) {
+    return null;
+  }
+  const id = String(bundleId).toLowerCase();
+  if (id === 'com.apple.safari') {
+    return { family: 'safari' };
+  }
+  if (id === 'org.mozilla.firefox') {
+    return { family: 'firefox', bundleId: 'org.mozilla.firefox' };
+  }
+  if (CHROMIUM_MAC_BUNDLES[id]) {
+    return { family: 'chromium', bundleId: CHROMIUM_MAC_BUNDLES[id] };
+  }
+  return null;
+}
+
+function classifyWindowsProgId(progId) {
+  if (!progId) {
+    return null;
+  }
+  const id = String(progId).toLowerCase();
+  if (id.includes('firefox')) {
+    return 'firefox';
+  }
+  if (
+    id.startsWith('chromehtml') ||
+    id.startsWith('msedge') ||
+    id.startsWith('bravehtml') ||
+    id.startsWith('opera') ||
+    id.includes('vivaldi') ||
+    id.includes('chromium')
+  ) {
+    return 'chromium';
+  }
+  return null;
+}
+
+function classifyLinuxDesktop(name) {
+  if (!name) {
+    return null;
+  }
+  const id = String(name).toLowerCase();
+  if (id.includes('firefox')) {
+    return 'firefox';
+  }
+  if (
+    id.includes('chrome') ||
+    id.includes('chromium') ||
+    id.includes('brave') ||
+    id.includes('edge') ||
+    id.includes('opera') ||
+    id.includes('vivaldi')
+  ) {
+    return 'chromium';
+  }
+  return null;
+}
+
+function parseMacDefaultBrowser(defaultsOutput) {
+  if (!defaultsOutput) {
+    return null;
+  }
+  // The secure plist is an array of dicts; each `}` closes one handler entry.
+  const blocks = String(defaultsOutput).split('}');
+  for (const block of blocks) {
+    if (/LSHandlerURLScheme\s*=\s*https\b/i.test(block)) {
+      const match = block.match(/LSHandlerRole(?:All|Viewer)\s*=\s*"?([\w.-]+)"?/i);
+      if (match) {
+        return match[1].toLowerCase();
+      }
+    }
+  }
+  return null;
+}
+
+function parseWindowsProgId(regOutput) {
+  if (!regOutput) {
+    return null;
+  }
+  const match = String(regOutput).match(/ProgId\s+REG_\w+\s+(\S+)/i);
+  return match ? match[1] : null;
+}
+
+function parseWindowsCommandExec(regOutput) {
+  if (!regOutput) {
+    return null;
+  }
+  const match = String(regOutput).match(/REG_\w+\s+(.+)$/m);
+  if (!match) {
+    return null;
+  }
+  const value = match[1].trim();
+  if (value.startsWith('"')) {
+    const end = value.indexOf('"', 1);
+    if (end > 1) {
+      return value.slice(1, end);
+    }
+  }
+  return value.split(/\s+/)[0] || null;
+}
+
+function parseLinuxExec(desktopContent) {
+  if (!desktopContent) {
+    return null;
+  }
+  const match = String(desktopContent).match(/^Exec=(.+)$/m);
+  if (!match) {
+    return null;
+  }
+  // Drop desktop-entry field codes (%u %U %f %F ...) then take the executable.
+  const withoutCodes = match[1].replace(/%[a-zA-Z]/g, '').trim();
+  const first = withoutCodes.match(/^"([^"]+)"|^(\S+)/);
+  if (!first) {
+    return null;
+  }
+  return first[1] || first[2] || null;
+}
+
+function runCapture(command, args) {
+  try {
+    const result = spawnSync(command, args, {
+      encoding: 'utf8',
+      timeout: 2500,
+      windowsHide: true,
+    });
+    if (result && typeof result.stdout === 'string' && result.stdout.length > 0) {
+      return result.stdout;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+// Detect the system default browser so we can open a real new window.
+// Returns { family, bundleId? , execPath? } or null when detection fails or
+// the default browser is not a supported family (unknown ProgId/desktop/bundle).
+// `deps` allows injecting command runner / file reader for deterministic tests.
+function detectDefaultBrowser(platform = process.platform, deps = {}) {
+  const run = deps.run || runCapture;
+  const readFile = deps.readFile || ((filePath) => fs.readFileSync(filePath, 'utf8'));
+  const homedir = deps.homedir || os.homedir;
+  try {
+    if (platform === 'darwin') {
+      const output = run('defaults', [
+        'read',
+        'com.apple.LaunchServices/com.apple.launchservices.secure',
+      ]);
+      return classifyMacBundleId(parseMacDefaultBrowser(output));
+    }
+    if (platform === 'win32') {
+      const progOutput = run('reg', [
+        'query',
+        'HKCU\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\https\\UserChoice',
+        '/v',
+        'ProgId',
+      ]);
+      const progId = parseWindowsProgId(progOutput);
+      const family = classifyWindowsProgId(progId);
+      // Unknown ProgId (e.g. IE.HTTP or any browser we don't map) -> fall back.
+      if (!family) {
+        return null;
+      }
+      const commandOutput =
+        run('reg', ['query', `HKCU\\Software\\Classes\\${progId}\\shell\\open\\command`, '/ve']) ||
+        run('reg', ['query', `HKEY_CLASSES_ROOT\\${progId}\\shell\\open\\command`, '/ve']);
+      const execPath = parseWindowsCommandExec(commandOutput);
+      if (!execPath) {
+        return null;
+      }
+      return { family, execPath };
+    }
+    // linux and other unix-like desktops
+    const desktop = run('xdg-settings', ['get', 'default-web-browser']);
+    const name = desktop ? desktop.trim() : '';
+    if (!name) {
+      return null;
+    }
+    const family = classifyLinuxDesktop(name);
+    // Unknown .desktop (e.g. some non-browser or unmapped browser) -> fall back.
+    if (!family) {
+      return null;
+    }
+    const candidates = [
+      path.join(homedir(), '.local/share/applications', name),
+      path.join('/usr/share/applications', name),
+      path.join('/usr/local/share/applications', name),
+    ];
+    for (const candidate of candidates) {
+      try {
+        const content = readFile(candidate);
+        const execPath = parseLinuxExec(content);
+        if (execPath) {
+          return { family, execPath };
+        }
+      } catch {
+        // try the next candidate location
+      }
+    }
+    return null;
+  } catch {
+    return null;
   }
+}
 
-  let command = 'xdg-open';
-  let args = [url];
-  if (process.platform === 'darwin') {
-    command = 'open';
-  } else if (process.platform === 'win32') {
-    command = 'cmd';
-    args = ['/c', 'start', '', url];
+function resolveBrowserLauncher(url, platform = process.platform, openMode = 'legacy', browser = null) {
+  if (openMode === 'newWindow' && browser && SUPPORTED_BROWSER_FAMILIES.has(browser.family)) {
+    if (platform === 'darwin') {
+      if (browser.family === 'safari') {
+        // Safari has no CLI new-window flag; AppleScript opens a new window.
+        const safeUrl = appleScriptSafe(url);
+        return {
+          command: 'osascript',
+          args: [
+            '-e',
+            `tell application "Safari" to make new document with properties {URL:"${safeUrl}"}`,
+            '-e',
+            'tell application "Safari" to activate',
+          ],
+        };
+      }
+      if (browser.bundleId) {
+        // `open -b <bundle> -n --args --new-window <url>` forces a new window
+        // in the specific Chromium/Firefox app instead of a new tab.
+        return {
+          command: 'open',
+          args: ['-b', browser.bundleId, '-n', '--args', newWindowFlag(browser.family), url],
+        };
+      }
+    } else if (browser.execPath) {
+      return {
+        command: browser.execPath,
+        args: [newWindowFlag(browser.family), url],
+      };
+    }
   }
 
+  if (platform === 'darwin') {
+    return { command: 'open', args: [url] };
+  }
+  if (platform === 'win32') {
+    // rundll32 hands the URL to the default browser as a single argument.
+    // Going through `cmd /c start` would let cmd.exe treat the `&` in the
+    // OAuth URL as command separators and truncate the query string after
+    // redirect_uri, dropping client_id/state and breaking login.
+    return { command: 'rundll32', args: ['url.dll,FileProtocolHandler', url] };
+  }
+  return { command: 'xdg-open', args: [url] };
+}
+
+function launchBrowserLauncher(launcher, onError) {
   try {
-    const child = spawn(command, args, {
+    const child = spawn(launcher.command, launcher.args, {
       detached: true,
       stdio: 'ignore',
     });
     child.unref();
+    if (onError) {
+      child.once('error', onError);
+    }
     return true;
   } catch {
+    if (onError) {
+      onError();
+    }
+    return false;
+  }
+}
+
+function openBrowser(url) {
+  if (process.env.OPENYIDA_NO_BROWSER === '1') {
     return false;
   }
+
+  const platform = process.platform;
+  const legacyLauncher = resolveBrowserLauncher(url, platform, 'legacy');
+  const runLegacy = () => launchBrowserLauncher(legacyLauncher);
+
+  let browser = null;
+  try {
+    browser = detectDefaultBrowser(platform);
+  } catch {
+    browser = null;
+  }
+
+  // Default browser detected and supported → open a real new window in that
+  // browser, falling back to the plain default-browser open if launch errors.
+  if (browser && SUPPORTED_BROWSER_FAMILIES.has(browser.family)) {
+    const newWindowLauncher = resolveBrowserLauncher(url, platform, 'newWindow', browser);
+    let fallbackUsed = false;
+    const runFallback = () => {
+      if (fallbackUsed) {
+        return false;
+      }
+      fallbackUsed = true;
+      return runLegacy();
+    };
+
+    const launched = launchBrowserLauncher(newWindowLauncher, runFallback);
+    if (!launched) {
+      return runFallback();
+    }
+    return true;
+  }
+
+  // Detection failed → fall back to the system default browser (new tab).
+  return runLegacy();
 }
 
 function buildDingtalkOAuthUrl(options) {
@@ -59,8 +368,45 @@ function buildDingtalkOAuthUrl(options) {
   return url.toString();
 }
 
-function responseHtml(title, body) {
-  return `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head><body><h3>${title}</h3><p>${body}</p></body></html>`;
+function responseHtml(title, body, options = {}) {
+  const {
+    autoClose = false,
+    autoCloseDelayMs = 1200,
+    staticHint = 'You can close this page and return to the terminal.',
+  } = options;
+
+  const closeScript = autoClose ? `
+    <script>
+      (function() {
+        const delay = Math.max(0, ${Number(autoCloseDelayMs)});
+        function forceClose() {
+          try {
+            if (window.opener && !window.opener.closed && window.opener.focus) {
+              window.opener.focus();
+            }
+          } catch (err) {}
+
+          try {
+            window.close();
+          } catch (err) {}
+
+          if (!window.closed) {
+            try {
+              window.open('', '_self').close();
+            } catch (err) {}
+          }
+        }
+
+        setTimeout(forceClose, delay);
+      })();
+    </script>
+  ` : '';
+
+  const closeHint = autoClose
+    ? ''
+    : `<p>${staticHint}</p>`;
+
+  return `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head><body><h3>${title}</h3><p>${body}</p>${closeHint}${closeScript}</body></html>`;
 }
 
 function runDingtalkLoopback(options = {}) {
@@ -115,7 +461,13 @@ function runDingtalkLoopback(options = {}) {
 
       res.statusCode = 200;
       res.setHeader('content-type', 'text/html; charset=utf-8');
-      res.end(responseHtml('OpenYida login completed', 'You can close this page and return to the terminal.'));
+      res.end(responseHtml(
+        'OpenYida login completed',
+        'Login callback received. Returning to terminal.',
+        {
+          autoClose: true,
+        }
+      ));
       finish(null, {
         code,
         authCode,
@@ -152,5 +504,14 @@ function runDingtalkLoopback(options = {}) {
 module.exports = {
   runDingtalkLoopback,
   buildDingtalkOAuthUrl,
+  resolveBrowserLauncher,
+  detectDefaultBrowser,
+  classifyMacBundleId,
+  classifyWindowsProgId,
+  classifyLinuxDesktop,
+  parseMacDefaultBrowser,
+  parseWindowsProgId,
+  parseWindowsCommandExec,
+  parseLinuxExec,
   CALLBACK_PATH,
 };

package/lib/auth/token-auth.js

@@ -13,8 +13,10 @@ const {
 const { runDingtalkLoopback } = require('./oauth-loopback');
 const {
   clearTokenSession,
+  isHostInjectedTokenMode,
   loadTokenSession,
   maskToken,
+  normalizeTokenSession,
   saveTokenSession,
 } = require('./token-store');
 
@@ -35,6 +37,7 @@ function appendPath(baseUrl, path) {
 
 function getArgEndpoint(options = {}) {
   return options.endpoint ||
+    (options.env && options.env.OPENYIDA_ENDPOINT) ||
     null;
 }
 
@@ -49,7 +52,8 @@ function resolveTokenBaseUrl(options = {}) {
   }
 
   const { config } = getCurrentEnvConfig(options.projectRoot);
-  const baseUrl = normalizeBaseUrl(process.env.OPENYIDA_ENDPOINT || config.baseUrl, null);
+  const env = options.env || process.env;
+  const baseUrl = normalizeBaseUrl(env.OPENYIDA_ENDPOINT || config.baseUrl, null);
   if (!baseUrl) {
     throw new Error('missing base_url: pass --endpoint or set OPENYIDA_ENDPOINT');
   }
@@ -299,18 +303,29 @@ async function tokenLogin(options = {}) {
 function tokenStatus(options = {}) {
   const session = loadTokenSession(options);
   if (!session || (!session.access_token && !session.refresh_token)) {
-    return {
+    const env = options.env || process.env;
+    const hostInjected = isHostInjectedTokenMode(env);
+    const status = {
       ok: false,
       auth_mode: 'token',
+      auth_source: hostInjected ? 'env' : undefined,
       status: 'not_logged_in',
       can_auto_use: false,
-      token_file: require('./token-store').getTokenFilePath(options),
+      failure_reason: hostInjected ? 'env_token_missing' : undefined,
+      message: hostInjected
+        ? 'host-injected token is missing. Ask the host to inject OPENYIDA_ACCESS_TOKEN or OPENYIDA_REFRESH_TOKEN.'
+        : undefined,
     };
+    if (!hostInjected) {
+      status.token_file = require('./token-store').getTokenFilePath(options);
+    }
+    return status;
   }
   if (!session.access_token && session.refresh_token) {
     return {
       ok: true,
       auth_mode: 'token',
+      auth_source: session.auth_source,
       status: 'refresh_required',
       can_auto_use: true,
       refresh_token: maskToken(session.refresh_token),
@@ -324,6 +339,7 @@ function tokenStatus(options = {}) {
     // whether this access token must be refreshed.
     ok: true,
     auth_mode: 'token',
+    auth_source: session.auth_source,
     status: 'ok',
     can_auto_use: true,
     token_type: session.token_type,
@@ -343,6 +359,7 @@ async function tokenRefresh(options = {}) {
     return {
       ok: false,
       auth_mode: 'token',
+      auth_source: session && session.auth_source,
       status: 'missing_refresh_token',
       can_auto_use: false,
     };
@@ -380,6 +397,20 @@ async function tokenRefresh(options = {}) {
       message: normalized.message || 'auth service did not return access_token',
     };
   }
+  const env = options.env || process.env;
+  if (isHostInjectedTokenMode(env) && session.auth_source === 'env') {
+    env.OPENYIDA_ACCESS_TOKEN = normalized.access_token;
+    if (normalized.refresh_token) {
+      env.OPENYIDA_REFRESH_TOKEN = normalized.refresh_token;
+    }
+    if (normalized.expires_at) {
+      env.OPENYIDA_ACCESS_TOKEN_EXPIRES_AT = String(normalized.expires_at);
+    }
+    return normalizeTokenSession({
+      ...normalized,
+      auth_source: 'env',
+    });
+  }
   return saveTokenSession(normalized, options);
 }
 

package/lib/auth/token-store.js

@@ -119,17 +119,27 @@ function saveTokenSession(session, options = {}) {
   return normalized;
 }
 
+function isHostInjectedTokenMode(env = process.env) {
+  const authEnabled = String(env.YIDA_AUTH_ENABLED || '').trim().toLowerCase();
+  return ['1', 'true', 'yes', 'on'].includes(authEnabled);
+}
+
 function loadEnvTokenSession(env = process.env) {
+  const accessToken = String(env.OPENYIDA_ACCESS_TOKEN || '').trim();
   const refreshToken = String(env.OPENYIDA_REFRESH_TOKEN || '').trim();
-  if (!refreshToken) {
+  if (!accessToken && !refreshToken) {
     return null;
   }
   return normalizeTokenSession({
+    access_token: accessToken,
     refresh_token: refreshToken,
     base_url: env.OPENYIDA_ENDPOINT,
     client_id: env.OPENYIDA_TOKEN_CLIENT_ID,
     corp_id: env.OPENYIDA_TOKEN_CORP_ID,
     user_id: env.OPENYIDA_TOKEN_USER_ID,
+    token_type: env.OPENYIDA_TOKEN_TYPE,
+    expires_at: env.OPENYIDA_ACCESS_TOKEN_EXPIRES_AT,
+    expires_in: env.OPENYIDA_ACCESS_TOKEN_EXPIRES_IN,
     auth_source: 'env',
   });
 }
@@ -147,24 +157,31 @@ function loadLocalTokenSession(options = {}) {
 }
 
 function loadTokenSession(options = {}) {
+  const env = options.env || process.env;
+  const envSession = loadEnvTokenSession(env);
+  if (isHostInjectedTokenMode(env)) {
+    return envSession;
+  }
+
   const localSession = loadLocalTokenSession(options);
-  const envSession = loadEnvTokenSession(options.env || process.env);
   if (!localSession && !envSession) {
     return null;
   }
 
   const localAccessToken = localSession && localSession.access_token;
   const localRefreshToken = localSession && localSession.refresh_token;
+  const envAccessToken = envSession && envSession.access_token;
   const envRefreshToken = envSession && envSession.refresh_token;
   const usesLocal = Boolean(localAccessToken || localRefreshToken);
   const usesEnv = Boolean(
-    !localRefreshToken && envRefreshToken
+    (!localAccessToken && !localRefreshToken && envAccessToken) ||
+    (!localRefreshToken && envRefreshToken)
   );
 
   return normalizeTokenSession({
     ...(envSession || {}),
     ...(localSession || {}),
-    access_token: localAccessToken,
+    access_token: localAccessToken || (!localSession && envAccessToken),
     refresh_token: localRefreshToken || envRefreshToken,
     auth_source: usesLocal && usesEnv ? 'mixed' : (usesLocal ? 'local' : 'env'),
   });
@@ -210,6 +227,7 @@ module.exports = {
   normalizeTokenSession,
   loadEnvTokenSession,
   loadLocalTokenSession,
+  isHostInjectedTokenMode,
   isAccessTokenUsable,
   maskToken,
   resolveEnvName,