openyida 2026.10.29 → 2026.10.30

package/README.md

@@ -143,6 +143,18 @@ openyida login --check-only --json
 openyida auth status
 ```
 
+In QwenWork web, `openyida login --qwenwork --json` (or ordinary `login`) reuses the sandbox identity. If cloud authentication fails, the same command falls back to OAuth; follow its authorization URL and wait for completion. Desktop and other hosts keep their existing login paths.
+
+Login supports DingTalk and QwenWork organizations, ODS and personal spaces. Sessions preserve server-provided identity classification, business domain and refresh credentials. Historical sessions default to DingTalk organizations. JSON errors include bounded diagnostics without credentials or response bodies.
+
+For QwenWork cloud identity diagnostics, run inside the actual cloud execution environment:
+
+```bash
+openyida auth qwenwork user-info --json
+```
+
+This legacy diagnostic reads the injected host credentials and reports identity and scope without printing or saving tokens. It does not create or validate a YiDA session; QwenWork organization IDs are not YiDA `corpId` values. Check the YiDA session with `openyida login --check-only --json`. See [QwenWork login guidance](yida-skills/references/qwenwork-cloud-login.md) for authentication behavior.
+
 To reuse an existing shared login profile for the current project, switch first instead of starting a new OAuth login:
 
 ```bash
@@ -457,9 +469,9 @@ When preparing a PR that needs a personal Fork, or when you ask how to support t
 
 | Command | Description |
 |---------|-------------|
-| `openyida login [target-url] [--env <name>\|--intl\|--overseas\|--global\|--yidaapps\|--alibaba] [--client-id <clientId>] [--endpoint <url>] [--no-browser]` | Login with OAuth token mode |
+| `openyida login [--qwenwork] [target-url] [--env <name>\|--intl\|--overseas\|--global\|--yidaapps\|--alibaba] [--client-id <clientId>] [--endpoint <url>] [--no-browser]` | Login with OAuth token mode |
 | `openyida logout` | Logout / unbind current project auth |
-| `openyida auth <status\|login\|refresh\|logout\|profiles\|profile switch>` | Token login state and profile management |
+| `openyida auth <status\|login\|refresh\|logout\|profiles\|profile switch\|qwenwork user-info> [--json]` | Token login state and profile management |
 | `openyida org <list\|switch> [--json] [--corp-id <corpId>]` | Organization management (list / switch existing profiles first) |
 | `openyida env [--json\|setup\|list\|show\|switch\|add\|remove] [options]` | Detect AI tool environment & token login state |
 

package/bin/yida-beta.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+'use strict';
+// beta 保持当前安装版本；环境、域名和登录态沿用标准 CLI 的解析规则。
+process.env.OPENYIDA_SKIP_UPDATE_CHECK = '1';
+require('./yida.js');

package/bin/yida.js

@@ -598,7 +598,23 @@ async function main() {
   });
   assertManagedInvocation(command, rawArgs);
   applyQuietFlag();
+  // 一次性票据只在当前进程消费，不能先自更新并重启命令。
+  switch (command) {
+    case 'login-qwenwork':
+      await require('../lib/auth/qwenwork-desktop').run(args);
+      return;
+  }
   applyGlobalEnvironmentFlags();
+  // 网页态由 CLI 消费宿主凭据；桌面态继续消费宿主准备的登录态。
+  const webLogin = (command === 'login' || (command === 'auth' && args[0] === 'login')) &&
+    require('../lib/core/qwenwork-login-guidance').isQwenWorkWebRuntime(require('../lib/core/utils').detectRuntimeCapabilities());
+  if ((command === 'login' && args.includes('--qwenwork')) || webLogin) {
+    const loginArgs = applyLoginEnvironmentFlags(command === 'auth' ? args.slice(1) : args, { inferTargetUrl: true });
+    if (hasHelpFlag(loginArgs)) { printLoginHelp(); return; }
+    assertNoUnsupportedLegacyLoginFlags(rawArgs, loginArgs);
+    await require('../lib/auth/qwenwork-login').run(loginArgs, buildTokenLoginOptions(loginArgs));
+    return;
+  }
 
   const { maybeAutoUpdate } = require('../lib/core/update');
   const updateResult = await maybeAutoUpdate({
@@ -718,6 +734,10 @@ async function main() {
 
     case 'auth': {
       const subCommand = args[0];
+      if (subCommand === 'qwenwork') {
+        await require('../lib/auth/qwenwork').run(args.slice(1));
+        break;
+      }
       const authArgs = applyLoginEnvironmentFlags(args.slice(1), { inferTargetUrl: true });
       const { getAuthStatus } = require('../lib/core/utils');
       const { tokenLogin, tokenLogout, tokenRefresh } = require('../lib/auth/token-auth');

package/lib/agent/provider-preflight.js

@@ -139,13 +139,15 @@ function probe(executable, args, rpc, options = {}) {
       child = (options.probeSpawn || spawn)(command.executable, command.args, {
         env, cwd: os.tmpdir(), shell: false, windowsHide: true,
         windowsVerbatimArguments: command.windowsVerbatimArguments,
-        detached: platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'],
+        // Finite Windows probes do not consume input. Avoid an unused redirected
+        // stdin pipe during PowerShell startup; ACP still needs its live pipe.
+        detached: platform !== 'win32', stdio: [platform === 'win32' && !rpc ? 'ignore' : 'pipe', 'pipe', 'pipe'],
       });
       signals.once('SIGINT', interrupted);
       signals.once('SIGTERM', interrupted);
       timer = setTimeout(() => { stop(); finish({ status: 'probe_timeout' }); }, options.timeoutMs || 15000);
       child.on('error', () => finish({ status: 'launch_failed' }));
-      child.stdin.on('error', () => {});
+      if (child.stdin) { child.stdin.on('error', () => {}); }
       child.stderr.on('data', chunk => { output = (output + chunk.toString()).slice(-65536); });
       child.stdout.on('data', chunk => {
         output = (output + chunk.toString()).slice(-65536);
@@ -171,7 +173,7 @@ function probe(executable, args, rpc, options = {}) {
           ? { protocolVersion: 1, clientCapabilities: {}, clientInfo: { name: 'openyida-preflight', version: '1' } }
           : { clientInfo: { name: 'openyida-preflight', version: '1' }, capabilities: {} };
         child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params }) + '\n');
-      } else { child.stdin.end(); }
+      } else if (child.stdin) { child.stdin.end(); }
     } catch { finish({ status: 'launch_failed' }); }
   });
 }

package/lib/app/custom-theme.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { createHash } = require('crypto');
 const { resolveBearerAuthHeaders } = require('../core/utils');
 const { readManagedContext, managedError } = require('../agent/managed-context');
 const { CliError } = require('../core/cli-error');
@@ -306,7 +307,26 @@ async function uploadCustomThemeFile(appType, filePath, authRef, options = {}) {
   if (!response.ok) {
     throw new Error((payload && (payload.errorMsg || payload.message)) || `主题文件上传失败: HTTP ${response.status}`);
   }
-  return payload;
+  // Hash multipart bytes, not reread files or server-supplied receipt fields.
+  if (payload?.success === false) {
+    return { ...payload, themeUpload: { requested: true, status: 'rejected', uploadedThisRun: false, appType } };
+  }
+  const upload = unwrapUploadResponse(payload);
+  return { ...payload, themeUpload: {
+    requested: true,
+    status: 'uploaded',
+    uploadedThisRun: true,
+    appType,
+    baseUrl: new URL(authRef.baseUrl).origin,
+    corpId: authRef.corpId || null,
+    sourceFileName: file.name,
+    sourceBytes: file.content.length,
+    sourceSha256: createHash('sha256').update(file.content).digest('hex'),
+    themeColor: file.themeColor,
+    cssUrl: upload.downloadUrl || upload.url,
+    cssFileName: upload.name || '',
+    resourceContentVerified: false,
+  } };
 }
 
 module.exports = {

package/lib/app/services/canvas-page-schema-builder.js

@@ -81,6 +81,10 @@ var OPENYIDA_UTIL_API_METHODS = [
 function openyidaYidaApiBridgeTargets() {
   var targets = [];
   function pushTarget(target) {
+    if (target !== window) {
+      var origin = window.location.origin;
+      if (!origin || origin === 'null' || target.location.origin !== origin) { return; }
+    }
     if (target && targets.indexOf(target) === -1) {
       targets.push(target);
     }

package/lib/app/update-app.js

@@ -566,6 +566,25 @@ function themeSettingsMatch(expected, actual) {
     ['cssUrl', 'cssFileName'].every((key) => (expectedStyle[key] || '') === (actualStyle[key] || ''));
 }
 
+function themeReadbackEvidence(params, details) {
+  const operation = params.disableCustomTheme ? 'disable'
+    : params.customThemeStyle ? 'bind_resource'
+      : params.colour || params.themeColor ? 'update_theme' : 'preserve';
+  return { ...details, scope: 'configuration_readback', operation, runtimeVerified: false };
+}
+
+function noThemeUpload(appType) {
+  return { requested: false, status: 'not_requested', uploadedThisRun: false, appType };
+}
+
+function themeFailureEvidence(themeUpload) {
+  const uncertain = themeUpload.uploadedThisRun === true || themeUpload.status === 'unknown';
+  return { themeUpload, runtimeVerification: { verified: false, status: 'not_checked' },
+    ...(uncertain ? { target: { appType: themeUpload.appType }, retrySafe: false,
+      sideEffectState: 'unknown', readbackAllowed: true } : {}),
+  };
+}
+
 function getRequestedNavigationSettings(params, payload) {
   return Object.fromEntries(['navTheme', 'layoutDirection', 'hideAppNav', 'logoSource']
     .filter((name) => params[name] !== undefined && params[name] !== null && params[name] !== '')
@@ -631,7 +650,7 @@ async function saveAppSettings(params, authRef) {
       if (themeVerified && navigationVerified) {
         return { ...response,
           ...(submittedFields ? { submittedFields } : {}),
-          ...(verifyTheme ? { themeVerification: { verified: true, ...actual } } : {}),
+          ...(verifyTheme ? { themeVerification: themeReadbackEvidence(params, { verified: true, ...actual }) } : {}),
           ...(navigationFields.length ? { navigationVerification: { verified: true, ...actualNavigation } } : {}),
         };
       }
@@ -646,8 +665,8 @@ async function saveAppSettings(params, authRef) {
     ...(submittedFields ? { submittedFields } : {}),
     errorCode: themeVerified ? 'APP_NAVIGATION_NOT_PERSISTED' : 'APP_THEME_NOT_PERSISTED',
     errorMsg: t(themeVerified ? 'update_app.navigation_not_persisted' : 'update_app.theme_not_persisted'),
-    ...(verifyTheme ? { themeVerification: themeVerified
-      ? { verified: true, ...actual } : { verified: false, expected, actual, readbackError } } : {}),
+    ...(verifyTheme ? { themeVerification: themeReadbackEvidence(params, themeVerified
+      ? { verified: true, ...actual } : { verified: false, expected, actual, readbackError }) } : {}),
     ...(navigationFields.length ? { navigationVerification: navigationVerified
       ? { verified: true, ...actualNavigation }
       : { verified: false, expected: expectedNavigation, actual: actualNavigation, readbackError } } : {}),
@@ -663,22 +682,25 @@ async function applyCustomThemeUpdate(appType, themeParams, authRef) {
   assertNavTheme(params.navTheme);
   assertLogoSource(params.logoSource);
 
-  assertCustomThemeOptions(params);
-  await checkAppStyleInjection(params, authRef);
-  const themeFile = readThemeCssFile(params.themeFile);
-  params.themeColor = themeFile.themeColor;
-  const uploadResponse = await requestWithAutoLogin(
-    (auth) => uploadCustomThemeFile(appType, params.themeFile, auth),
-    authRef
-  );
-  params.customThemeStyle = buildCustomThemeStyle(uploadResponse);
-
+  let themeUpload = { requested: true, status: 'not_started', uploadedThisRun: false, appType };
   try {
-    return await saveAppSettings(params, authRef);
+    assertCustomThemeOptions(params);
+    await checkAppStyleInjection(params, authRef);
+    readThemeCssFile(params.themeFile);
+    // Lost responses leave upload state unknown.
+    themeUpload = { ...themeUpload, status: 'unknown', uploadedThisRun: null };
+    const uploadResponse = await requestWithAutoLogin(
+      (auth) => uploadCustomThemeFile(appType, params.themeFile, auth),
+      authRef
+    );
+    if (uploadResponse.themeUpload) {themeUpload = uploadResponse.themeUpload;}
+    params.customThemeStyle = buildCustomThemeStyle(uploadResponse);
+    params.themeColor = themeUpload.themeColor;
+    return { ...await saveAppSettings(params, authRef), themeUpload };
   } catch (error) {
-    error.details = { ...error.details, appType, uploadedResource: params.customThemeStyle,
-      applicationSettingsVerified: false };
-    throw error;
+    throwCommandError(error.message, { code: error.code || 'APP_THEME_UPDATE_FAILED', exitCode: error.exitCode,
+      details: { ...error.details, appType, uploadedResource: params.customThemeStyle,
+        ...themeFailureEvidence(themeUpload), applicationSettingsVerified: false } });
   }
 }
 
@@ -767,6 +789,8 @@ async function run(args) {
         postData
       );
     }, authRef);
+  const themeUpload = params.themeFile ? response?.themeUpload : noThemeUpload(params.appType);
+  if (themeUpload?.uploadedThisRun) {params.themeColor = themeUpload.themeColor;}
 
   // Verify the persisted resource before exposing success or a mutation receipt.
   let nameVerification;
@@ -789,9 +813,10 @@ async function run(args) {
       success: true,
       appType: params.appType,
       themeVerification: response.themeVerification,
+      themeUpload,
       nameVerification,
       navigationVerification: response.navigationVerification,
-      ...(params.disableCustomTheme ? { runtimeVerification: { verified: false } } : {}),
+      runtimeVerification: { verified: false, status: 'not_checked' },
       updatedFields: {
         name: params.name || undefined,
         desc: params.desc || undefined,
@@ -810,11 +835,14 @@ async function run(args) {
     const errorMsg = response ? response.errorMsg || t('common.unknown_error') : t('common.request_failed');
     chalkResult(false, t('update_app.failed', errorMsg));
     console.log(JSON.stringify({ success: false, appType: params.appType, error: errorMsg,
+      themeUpload,
+      runtimeVerification: { verified: false, status: 'not_checked' },
       submittedFields: response && response.submittedFields,
       errorCode: response && response.errorCode, themeVerification: response && response.themeVerification,
       navigationVerification: response && response.navigationVerification }));
     throwCommandError(errorMsg, { code: response && response.errorCode,
-      details: response && (response.errorCode === 'APP_NAVIGATION_NOT_PERSISTED' ? response.navigationVerification : response.themeVerification) });
+      details: response && { ...(response.errorCode === 'APP_NAVIGATION_NOT_PERSISTED' ? response.navigationVerification : response.themeVerification),
+        ...themeFailureEvidence(themeUpload) } });
   }
 }
 

package/lib/auth/org.js

@@ -19,6 +19,10 @@ const {
   saveTokenSession,
 } = require('./token-store');
 const { tokenLogin } = require('./token-auth');
+const { sessionIdentity } = require('./session-identity');
+const { detectRuntimeCapabilities } = require('../core/utils');
+const { isQwenWorkWebRuntime } = require('../core/qwenwork-login-guidance');
+const { t } = require('../core/i18n');
 
 const LIST_CORP_INFOS_PATH = '/query/userservice/listCorpInfos.json';
 
@@ -146,6 +150,7 @@ function buildSwitchResult(status, currentSession, nextSession, message, extra =
     auth_mode: 'token',
     status,
     can_auto_use: true,
+    ...sessionIdentity(nextSession),
     previous_corp_id: currentSession && currentSession.corp_id,
     corp_id: nextSession.corp_id,
     corp_name: nextSession.corp_name,
@@ -191,6 +196,7 @@ async function switchOrganization(targetCorpId, options = {}) {
       ok: true,
       auth_mode: 'token',
       status: 'already_in_org',
+      ...sessionIdentity(currentSession),
       can_auto_use: true,
       corp_id: currentSession.corp_id,
       corp_name: currentSession.corp_name,
@@ -231,7 +237,12 @@ async function switchOrganization(targetCorpId, options = {}) {
     corpId: targetCorpId,
   };
 
-  const login = options.tokenLogin || tokenLogin;
+  const cloud = isQwenWorkWebRuntime(options.runtime || detectRuntimeCapabilities({ env: options.env || process.env }));
+  const login = options.tokenLogin || (cloud ? async opts => {
+    const { ensureQwenWorkLogin } = require('./qwenwork-login');
+    await ensureQwenWorkLogin(opts);
+    return loadTokenSession(opts);
+  } : tokenLogin);
   const temporaryLogin = createTemporaryLoginOptions(loginOptions);
   let loginResult;
   try {
@@ -266,8 +277,8 @@ async function switchOrganization(targetCorpId, options = {}) {
     'switched',
     currentSession,
     savedSession,
-    'switched organization by OAuth login',
-    { switch_source: 'oauth_login' }
+    cloud ? t('qwenwork.organization_switch_success') : 'switched organization by OAuth login',
+    { switch_source: cloud ? 'qwenwork_cloud' : 'oauth_login' }
   );
 }
 

package/lib/auth/qwenwork-client.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const { CliError } = require('../core/cli-error');
+const { t } = require('../core/i18n');
+
+const DEFAULT_TIMEOUT_MS = 20000;
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+
+function failure(code, message, stage, details = {}) {
+  return new CliError(t(`qwenwork.${message}`), {
+    code: `QWENWORK_${code}`,
+    details: { stage, ...details },
+  });
+}
+
+function pick(env, names) {
+  for (const name of names) {
+    const value = String(env[name] || '').trim();
+    if (value) {
+      return { name, value };
+    }
+  }
+  return null;
+}
+
+function normalizeBaseUrl(value) {
+  try {
+    const url = new URL(value);
+    const loopback = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+    if ((url.protocol !== 'https:' && !(url.protocol === 'http:' && loopback)) ||
+      url.username || url.password || url.search || url.hash) {
+      throw new Error('invalid_url');
+    }
+    return url.href.replace(/\/+$/, '');
+  } catch {
+    throw failure('INVALID_GATEWAY', 'invalid_url', 'resolve_credentials');
+  }
+}
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+// Do not include upstream bodies, headers or exception messages in diagnostics:
+// an authentication endpoint may echo credentials even in an error response.
+async function requestJson(method, url, accessToken, options, stage) {
+  const timeoutMs = options.timeoutMs === undefined ? DEFAULT_TIMEOUT_MS : options.timeoutMs;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw failure('INVALID_TIMEOUT', 'request_failed', stage);
+  }
+  const controller = new globalThis.AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await globalThis.fetch(url, {
+      method,
+      headers: { accept: 'application/json', authorization: `Bearer ${accessToken}` },
+      redirect: 'manual',
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      if (response.body) {
+        await response.body.cancel();
+      }
+      throw failure('HTTP_ERROR', 'request_failed', stage, { status_code: response.status });
+    }
+    const chunks = [];
+    let size = 0;
+    if (response.body) {
+      const reader = response.body.getReader();
+      let next = await reader.read();
+      while (!next.done) {
+        const { value } = next;
+        size += value.byteLength;
+        if (size > MAX_RESPONSE_BYTES) {
+          await reader.cancel();
+          throw failure('RESPONSE_TOO_LARGE', 'invalid_response', stage);
+        }
+        chunks.push(Buffer.from(value));
+        next = await reader.read();
+      }
+    }
+    let payload;
+    try {
+      payload = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    } catch {
+      throw failure('INVALID_RESPONSE', 'invalid_response', stage);
+    }
+    if (!isObject(payload) || (payload.code !== undefined && payload.code !== 'ok')) {
+      throw failure('INVALID_RESPONSE', 'invalid_response', stage);
+    }
+    return payload;
+  } catch (error) {
+    if (error && error.isCliError) {
+      throw error;
+    }
+    throw controller.signal.aborted
+      ? failure('TIMEOUT', 'request_timeout', stage)
+      : failure('NETWORK_ERROR', 'request_failed', stage);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function decodeClaims(token) {
+  try {
+    const value = JSON.parse(Buffer.from(token.split('.')[1], 'base64url').toString('utf8'));
+    return isObject(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Exchange a cloud Agent credential for an in-memory scoped user credential.
+ * This does not issue or persist an OpenYida session.
+ */
+async function exchangeQwenWorkAgentToken(options = {}) {
+  const env = options.env || process.env;
+  const agent = pick(env, ['QWENWORK_AGENT_TOKEN', 'MULE_AGENT_TOKEN', 'AGENT_TOKEN']);
+  if (!agent || /[\r\n]/.test(agent.value)) {
+    throw failure('CREDENTIAL_MISSING', 'credential_missing', 'resolve_credentials');
+  }
+  const gateway = pick(env, ['QWENWORK_GATEWAY_URL', 'MULE_GATEWAY_URL']);
+  if (!gateway) {
+    throw failure('GATEWAY_MISSING', 'gateway_missing', 'resolve_credentials');
+  }
+  const baseUrl = normalizeBaseUrl(gateway.value);
+  const response = await requestJson('POST', `${baseUrl}/api/agent-gw/token/exchange`, agent.value, options, 'exchange');
+  // The current cloud endpoint returns {token, scope, ttl} without an envelope.
+  const payload = isObject(response.data) ? response.data : response;
+  if (typeof payload.token !== 'string' || !payload.token.trim() || /\s/.test(payload.token) ||
+    typeof payload.scope !== 'string' || !Number.isFinite(payload.ttl) || payload.ttl <= 0) {
+    throw failure('INVALID_RESPONSE', 'invalid_response', 'exchange');
+  }
+  const decoded = decodeClaims(payload.token);
+  if (typeof decoded.exp === 'number' && decoded.exp * 1000 <= Date.now()) {
+    throw failure('TOKEN_EXPIRED', 'expired_token', 'exchange');
+  }
+  return {
+    access_token: payload.token,
+    base_url: baseUrl,
+    credential_source: agent.name,
+    scope: payload.scope,
+    expires_in: payload.ttl,
+    expires_at: typeof decoded.exp === 'number' ? decoded.exp * 1000 : Date.now() + payload.ttl * 1000,
+  };
+}
+
+/** Query the credential's own origin; never infer a YiDA endpoint or organization. */
+async function getQwenWorkUserInfo(credential, options = {}) {
+  const accessToken = credential && credential.access_token;
+  if (typeof accessToken !== 'string' || !accessToken || /[\r\n]/.test(accessToken)) {
+    throw failure('CREDENTIAL_MISSING', 'credential_missing', 'user_info');
+  }
+  const baseUrl = normalizeBaseUrl(credential.base_url);
+  const response = await requestJson('GET', `${baseUrl}/user/info`, accessToken, options, 'user_info');
+  if (response.code !== 'ok' || !isObject(response.data) ||
+    typeof response.data.user_id !== 'string' || !response.data.user_id.trim()) {
+    throw failure('INVALID_RESPONSE', 'invalid_response', 'user_info');
+  }
+  const env = options.env || process.env;
+  const decoded = decodeClaims(accessToken);
+  // Decoding is not local signature verification. The authenticated /user/info
+  // response establishes identity; these comparisons catch context drift.
+  for (const expected of [env.QWENWORK_USER_ID, env.MULE_USER_ID, decoded.user_id, decoded.sub]) {
+    if (expected && String(expected) !== response.data.user_id) {
+      throw failure('IDENTITY_MISMATCH', 'identity_mismatch', 'user_info');
+    }
+  }
+  const orgId = response.data.biz && response.data.biz.org_id;
+  if (orgId && decoded.biz_org_id && orgId !== decoded.biz_org_id) {
+    throw failure('IDENTITY_MISMATCH', 'identity_mismatch', 'user_info');
+  }
+  return response.data;
+}
+
+/** Safe composition for identity consumers: the returned object has no credential. */
+async function getQwenWorkIdentity(options = {}) {
+  const credential = await exchangeQwenWorkAgentToken(options);
+  const profile = await getQwenWorkUserInfo(credential, options);
+  return {
+    base_url: credential.base_url,
+    credential_source: credential.credential_source,
+    scope: credential.scope,
+    expires_in: credential.expires_in,
+    expires_at: credential.expires_at,
+    profile,
+  };
+}
+
+module.exports = { exchangeQwenWorkAgentToken, getQwenWorkUserInfo, getQwenWorkIdentity };

package/lib/auth/qwenwork-cloud.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const { sessionIdentity } = require('./session-identity');
+
+const { CliError } = require('../core/cli-error');
+const { t } = require('../core/i18n');
+const { DINGTALK_OAUTH_CLIENT_ID } = require('../core/env-manager');
+const { resolveTokenBaseUrl } = require('./token-auth');
+
+function failure(code, details = {}) {
+  return new CliError(t('qwenwork.login_check_failed'), { code: `QWENWORK_CLOUD_${code}`, details });
+}
+
+const CORP_ID = /^(?:(?:ding|yida|ps)[0-9a-f]{32}|dingd8e1123006514592)$/;
+
+// Only bounded protocol identifiers are diagnostic data; never forward the response body or message.
+function diagnostics(value, statusCode, credential = {}) {
+  const details = { stage: 'yida_exchange', status_code: statusCode };
+  if (!value || typeof value !== 'object' || Array.isArray(value)) { return details; }
+  const secrets = [credential.access_token, value.access_token, value.refresh_token, value.refreshToken].filter(token => typeof token === 'string' && token);
+  const publicValue = text => typeof text === 'string' && !secrets.some(token => text.includes(token));
+  if (publicValue(value.status) && value.status.length <= 64 && /^(?:ok|error|failure|[a-z][a-z0-9]*_[a-z0-9_]+)$/.test(value.status)
+    && !/^(?:qwex|dws)_/.test(value.status)) { details.status = value.status; }
+  if (publicValue(value.stage) && ['request', 'qwen_verify', 'token_issue'].includes(value.stage)) { details.stage = value.stage; }
+  if (publicValue(value.exchange_id) && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value.exchange_id)) {
+    details.exchange_id = value.exchange_id;
+  }
+  return details;
+}
+
+function origin(value, details = {}) {
+  try {
+    const url = new URL(value);
+    if (typeof value !== 'string' || value.length > 2048 || /\s/.test(value) || url.protocol !== 'https:' || url.username || url.password || url.pathname !== '/' || url.search || url.hash) { throw new Error(); }
+    return url.origin;
+  } catch { throw failure('ENDPOINT_INVALID', details); }
+}
+
+async function exchangeSession(credential, baseUrl, options) {
+  const controller = new AbortController();
+  const timeoutMs = options.timeoutMs === undefined ? 15000 : options.timeoutMs;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) { throw failure('INVALID_TIMEOUT'); }
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await (options.fetch || globalThis.fetch)(`${baseUrl}/openapi/cli/v1/auth/qwenwork/token`, {
+      method: 'POST', redirect: 'error', signal: controller.signal,
+      headers: { authorization: `Bearer ${credential.access_token}`, accept: 'application/json', 'content-type': 'application/json' },
+      // corp_id constrains the resulting YiDA organization or personal space for every identity type.
+      body: JSON.stringify({ gateway_url: credential.base_url, ...(options.corpId ? { corp_id: options.corpId } : {}) }),
+    });
+    const reader = response.body?.getReader();
+    if (!reader) { throw failure(response.ok ? 'RESPONSE_INVALID' : 'HTTP_ERROR', diagnostics(null, response.status)); }
+    const chunks = []; let bytes = 0;
+    try {
+      for (let part = await reader.read(); !part.done; part = await reader.read()) {
+        bytes += part.value.byteLength;
+        if (bytes > 65536) { await reader.cancel(); throw failure(response.ok ? 'RESPONSE_INVALID' : 'HTTP_ERROR', { ...diagnostics(null, response.status), reason: 'response_too_large' }); }
+        chunks.push(part.value);
+      }
+    } finally { reader.releaseLock(); }
+    let value;
+    try { value = JSON.parse(Buffer.concat(chunks).toString('utf8')); }
+    catch { throw failure(response.ok ? 'RESPONSE_INVALID' : 'HTTP_ERROR', { ...diagnostics(null, response.status), reason: 'invalid_json' }); }
+    const details = diagnostics(value, response.status, credential);
+    if (!response.ok) { throw failure('HTTP_ERROR', details); }
+    return { value, details };
+  } catch (error) {
+    // 上游正文和异常可能回显凭据，仅保留本模块生成的固定错误码。
+    if (error instanceof CliError && /^QWENWORK_CLOUD_/.test(error.code)) { throw error; }
+    throw failure(controller.signal.aborted ? 'REQUEST_TIMED_OUT' : 'REQUEST_FAILED', { stage: 'yida_exchange' });
+  } finally { clearTimeout(timer); }
+}
+
+/** 只读取本次沙箱凭据，由宜搭服务端向受信任网关验证身份。 */
+function sandboxCredential(options) {
+  const env = options.env || process.env;
+  const token = ['QWENWORK_AGENT_TOKEN', 'MULE_AGENT_TOKEN', 'AGENT_TOKEN'].map(name => env[name]).find(value => typeof value === 'string' && value);
+  if (!token) { throw new CliError(t('qwenwork.login_check_failed'), { code: 'QWENWORK_CREDENTIAL_MISSING' }); }
+  if (token.length > 4096 || /\s/.test(token)) { throw failure('CREDENTIAL_INVALID'); }
+  const gateway = env.QWENWORK_GATEWAY_URL || env.MULE_GATEWAY_URL;
+  if (!gateway) { throw new CliError(t('qwenwork.login_check_failed'), { code: 'QWENWORK_GATEWAY_MISSING' }); }
+  return { access_token: token, base_url: origin(gateway) };
+}
+
+/** 只向宜搭提交 Agent Token 和网关地址；返回会话供调用方校验后保存。 */
+async function exchangeQwenWorkCloudSession(options = {}) {
+  const baseUrl = origin(options.endpoint || (options.env || process.env).OPENYIDA_ENDPOINT || resolveTokenBaseUrl(options));
+  const credential = sandboxCredential(options);
+  try {
+    const startedAt = Date.now();
+    const { value, details } = await exchangeSession(credential, baseUrl, options);
+    if (!value || typeof value !== 'object' || Array.isArray(value)) { throw failure('RESPONSE_INVALID', { ...details, reason: 'response_shape' }); }
+    if (value.status !== 'ok') { throw failure('EXCHANGE_REJECTED', details); }
+    const env = options.env || process.env;
+    const hostTokens = ['QWENWORK_AGENT_TOKEN', 'MULE_AGENT_TOKEN', 'AGENT_TOKEN'].map(name => env[name]).filter(Boolean);
+    const validToken = token => typeof token === 'string' && !!token && !/\s/.test(token) && token.length <= 32768 && !hostTokens.includes(token);
+    // Older cloud deployments may return access-only sessions. Preserve a refresh token when supplied.
+    const refreshToken = value.refresh_token === undefined ? value.refreshToken : value.refresh_token;
+    const invalid = [
+      [value.auth_mode !== 'token', 'auth_mode'],
+      [value.can_auto_use !== true, 'can_auto_use'],
+      [value.token_type !== 'Bearer', 'token_type'],
+      [value.credential_source !== 'qwenwork_cloud', 'credential_source'],
+      [!validToken(value.access_token), 'access_token'],
+      [!Number.isInteger(value.expires_in) || value.expires_in <= 0 || value.expires_in > 1800, 'expires_in'],
+      [typeof value.corp_id !== 'string' || !CORP_ID.test(value.corp_id), 'corp_id'],
+      [typeof value.user_id !== 'string' || !value.user_id || value.user_id.trim() !== value.user_id || value.user_id.length > 256, 'user_id'],
+      [options.corpId && value.corp_id !== options.corpId, 'corp_id_mismatch'],
+      [options.userId && value.user_id !== options.userId, 'user_id_mismatch'],
+      ['exchange_ticket' in value, 'exchange_ticket'],
+      [refreshToken !== undefined && !validToken(refreshToken), 'refresh_token'],
+      [value.client_id !== undefined && value.client_id !== (options.clientId || DINGTALK_OAUTH_CLIENT_ID), 'client_id'],
+    ].find(([rejected]) => rejected);
+    if (invalid) { throw failure('RESPONSE_INVALID', { ...details, reason: invalid[1] }); }
+    return {
+      ...sessionIdentity(value),
+      auth_mode: 'token', credential_source: 'qwenwork_cloud', token_type: 'Bearer',
+      // 可信宜搭签发服务决定业务域名；认证请求仍只发往最初选择的 origin。
+      access_token: value.access_token, refresh_token: refreshToken, base_url: value.base_url === undefined ? baseUrl : origin(value.base_url, { ...details, reason: 'base_url' }),
+      client_id: options.clientId || DINGTALK_OAUTH_CLIENT_ID,
+      corp_id: value.corp_id, user_id: value.user_id,
+      user_name: typeof value.user_name === 'string' ? value.user_name : undefined,
+      expires_at: startedAt + value.expires_in * 1000,
+    };
+  } finally { credential.access_token = undefined; }
+}
+
+module.exports = { exchangeQwenWorkCloudSession };