weaver-work-cli 0.1.2 → 0.1.5

package/dist/internal/e10/auth/commands.js

@@ -4,7 +4,14 @@ import { CliError, ExitCode } from '../../../core/errors.js';
 import { clearInvoiceTokenForSession } from '../../../shortcuts/invoice/host.js';
 import { buildE10CookieHeader, E10AuthSession, clearProfileAuthFile, extractRawSetCookie, findAuthFile, getActiveProfile, getProfileAuthPath, getProfileDir, listProfiles, profileNameFromUrl, readProfileConfig, readTeamsCheckUserInfo, saveAuthFile, saveProfileConfig, setActiveProfile, } from './session.js';
 import { getE10AuthRoot } from './paths.js';
+import { XIAOE_AGENT_TYPE, hasXiaoEEnv, resolveXiaoEPreferredBaseUrl, resolveXiaoEUnifiedLoginCredential, } from './xiaoe.js';
+export { DEFAULT_E10_BASE_URL, XIAOE_AGENT_TYPE, hasXiaoEEnv, resolveXiaoEDefaultBaseUrl, resolveXiaoEPreferredBaseUrl, resolveXiaoEUnifiedLoginCredential, } from './xiaoe.js';
 const DEFAULT_AGENT_TYPE = 'weaver-work-cli';
+const EXPLICIT_AGENT_TYPE_ENV_KEYS = [
+    'WEAVER_AGENT_TYPE',
+    'WORKBUDDY_AGENT_TYPE',
+    'CODEX_AGENT_TYPE',
+];
 function asOptions(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -16,6 +23,32 @@ function optionString(options, ...keys) {
     }
     return '';
 }
+function envString(env, ...keys) {
+    for (const key of keys) {
+        const value = env[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return '';
+}
+function hasEnvPrefix(env, prefix) {
+    return Object.keys(env).some((key) => key === prefix || key.startsWith(`${prefix}_`));
+}
+function inferAgentTypeFromEnv(env) {
+    if (hasXiaoEEnv(env))
+        return XIAOE_AGENT_TYPE;
+    if (hasEnvPrefix(env, 'WORKBUDDY'))
+        return 'workbuddy';
+    if (hasEnvPrefix(env, 'CODEX'))
+        return 'codex';
+    return '';
+}
+export function resolveAgentType(options = {}, env = process.env) {
+    return optionString(options, 'agentType', 'agent_type')
+        || envString(env, ...EXPLICIT_AGENT_TYPE_ENV_KEYS)
+        || inferAgentTypeFromEnv(env)
+        || DEFAULT_AGENT_TYPE;
+}
 function normalizeUrl(value) {
     return value.replace(/\/+$/, '');
 }
@@ -50,8 +83,8 @@ function formatAuthStatus(status) {
     if (!status.loggedIn) {
         return [
             'Not logged in.',
-            'Run: weaver-work-cli auth login --base-url <url>',
-            'Or:  weaver-work-cli auth set --eteamsid <id> --base-url <url>',
+            'Run: weaver-work-cli auth login --base-url <url> --agent_type <agent_type>',
+            'Or:  weaver-work-cli auth set --eteamsid <id> --base-url <url> --agent_type <agent_type>',
         ].join('\n');
     }
     const lines = [
@@ -93,9 +126,27 @@ async function clearInvoiceTokenCache(profile, authData) {
         userId: authData.userId,
     }).catch(() => false);
 }
-function shellQuote(value) {
+function posixShellQuote(value) {
     return `'${value.replace(/'/g, "'\\''")}'`;
 }
+function powershellQuote(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function resolveWeaverEnvShell(shell, platform = process.platform) {
+    if (shell === 'auto')
+        return platform === 'win32' ? 'powershell' : 'posix';
+    if (shell === 'posix' || shell === 'powershell')
+        return shell;
+    throw new CliError('Invalid --shell value. Use auto, posix, or powershell.', ExitCode.UsageError);
+}
+export function formatWeaverEnvExports(value, shell = 'auto', platform = process.platform) {
+    const resolved = resolveWeaverEnvShell(shell, platform);
+    return Object.entries(value)
+        .map(([name, envValue]) => resolved === 'powershell'
+        ? `$env:${name} = ${powershellQuote(envValue)}`
+        : `export ${name}=${posixShellQuote(envValue)}`)
+        .join('\n');
+}
 function esc(value) {
     return String(value ?? '')
         .replace(/&/g, '&amp;')
@@ -104,18 +155,32 @@ function esc(value) {
         .replace(/"/g, '&quot;')
         .replace(/'/g, '&#39;');
 }
+export function resolveBrowserOpenCommand(url, platform = process.platform) {
+    if (platform === 'win32') {
+        return { file: 'rundll32.exe', args: ['url.dll,FileProtocolHandler', url] };
+    }
+    if (platform === 'darwin')
+        return { file: 'open', args: [url] };
+    return { file: 'xdg-open', args: [url] };
+}
 function openUrlInBrowser(url, ctx) {
-    const command = process.platform === 'win32'
-        ? { file: 'cmd', args: ['/c', 'start', '', url] }
-        : process.platform === 'darwin'
-            ? { file: 'open', args: [url] }
-            : { file: 'xdg-open', args: [url] };
+    const command = resolveBrowserOpenCommand(url);
     execFile(command.file, command.args, (error) => {
         if (error) {
             ctx.logger.warn('Could not open browser automatically. Copy the login URL manually.');
         }
     });
 }
+export function buildE10AuthorizeUrl(baseUrl, redirectUri, agentType) {
+    const authorizeParams = new URLSearchParams({
+        redirect_uri: redirectUri,
+        response_type: 'code',
+        access_type: 'agent',
+        agent_type: agentType,
+        from: agentType,
+    });
+    return `${baseUrl}/papi/sso/oauth2.0/authorize?${authorizeParams.toString()}`;
+}
 async function readJsonObject(resp) {
     const data = await resp.json().catch(() => ({}));
     return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
@@ -136,6 +201,69 @@ async function resolveUserInfo(baseUrl, eteamsId, rawCookie = '', agentType = ''
     const data = await resp.json().catch(() => ({}));
     return readTeamsCheckUserInfo(resp, data);
 }
+async function saveEteamsIdLogin(input) {
+    const baseUrl = normalizeUrl(input.baseUrl);
+    const passportUrl = normalizeUrl(input.passportUrl || baseUrl);
+    const userInfo = await resolveUserInfo(baseUrl, input.eteamsId, input.rawCookie || '', input.agentType);
+    if (!userInfo.userId) {
+        throw new CliError('Could not resolve userId. Check whether ETEAMSID is valid for this E10 domain.', ExitCode.AuthError);
+    }
+    const tenantKey = userInfo.tenantKey || input.tenantKeyFallback;
+    const profile = input.profileHint || profileNameFromUrl(baseUrl);
+    setActiveProfile(profile);
+    const cookies = { ETEAMSID: input.eteamsId };
+    if (input.rawCookie)
+        cookies.raw = input.rawCookie;
+    const authData = {
+        cookies,
+        userId: userInfo.userId,
+        tenantKey,
+        tenantName: userInfo.tenantName,
+        department: userInfo.department,
+        subcompany: userInfo.subcompany,
+        position: userInfo.position,
+        agentType: input.agentType,
+        version: input.version || '',
+        baseUrl,
+        passportUrl,
+        cookieSavedAt: Date.now(),
+    };
+    await clearInvoiceTokenCache(profile, authData);
+    const authFile = saveAuthFile(authData, profile);
+    saveProfileConfig(baseUrl, passportUrl, profile, tenantKey);
+    return {
+        ...userInfo,
+        tenantKey,
+        eteamsId: input.eteamsId,
+        baseUrl,
+        passportUrl,
+        profile,
+        authFile,
+        agentType: input.agentType,
+        version: input.version || '',
+    };
+}
+async function tryXiaoEUnifiedLogin(ctx, baseUrl, tenantKeyFallback, profileHint) {
+    const credential = resolveXiaoEUnifiedLoginCredential(baseUrl, ctx.env);
+    if (!credential)
+        return null;
+    ctx.logger.info('Detected XiaoE unified login for this E10 domain. Trying XiaoE auth...');
+    try {
+        return await saveEteamsIdLogin({
+            baseUrl,
+            passportUrl: baseUrl,
+            eteamsId: credential.eteamsId,
+            tenantKeyFallback,
+            agentType: XIAOE_AGENT_TYPE,
+            profileHint,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.logger.warn('XiaoE unified login failed; falling back to browser OAuth. ' + message);
+        return null;
+    }
+}
 async function oidcExchange(code, redirectUri, baseUrl, tenantKeyFallback, agentTypeFallback, profileHint) {
     const base = normalizeUrl(baseUrl);
     const tokenParams = new URLSearchParams({
@@ -235,25 +363,27 @@ async function runBrowserLogin(ctx, options) {
     const globalOptions = ctx.getGlobalOptions();
     const profileFromGlobal = globalOptions.profile;
     const cfg = readProfileConfig(profileFromGlobal || getActiveProfile());
-    const baseUrl = normalizeUrl(optionString(commandOpts, 'baseUrl') || globalOptions.baseUrl || cfg.baseUrl || '');
+    const explicitBaseUrl = optionString(commandOpts, 'baseUrl') || globalOptions.baseUrl || '';
+    const baseUrl = resolveXiaoEPreferredBaseUrl({
+        explicitBaseUrl,
+        profileBaseUrl: cfg.baseUrl,
+        env: ctx.env,
+    });
     const tenantKey = optionString(commandOpts, 'tenantKey');
     const portText = optionString(commandOpts, 'port') || '19800';
     const port = Number.parseInt(portText, 10);
     const explicitAgentType = optionString(commandOpts, 'agentType', 'agent_type');
-    const agentType = explicitAgentType || DEFAULT_AGENT_TYPE;
+    const agentType = resolveAgentType(commandOpts, ctx.env);
     if (!baseUrl)
         throw new CliError('Missing --base-url', ExitCode.UsageError);
     if (!Number.isInteger(port) || port <= 0 || port > 65535) {
         throw new CliError('Invalid --port value', ExitCode.UsageError);
     }
+    const xiaoEResult = await tryXiaoEUnifiedLogin(ctx, baseUrl, tenantKey, profileFromGlobal);
+    if (xiaoEResult)
+        return xiaoEResult;
     const redirectUri = `http://127.0.0.1:${port}/callback`;
-    const authorizeParams = new URLSearchParams({
-        redirect_uri: redirectUri,
-        response_type: 'code',
-        access_type: 'agent',
-        agent_type: agentType,
-    });
-    const loginUrl = `${baseUrl}/papi/sso/oauth2.0/authorize?${authorizeParams.toString()}`;
+    const loginUrl = buildE10AuthorizeUrl(baseUrl, redirectUri, agentType);
     ctx.logger.info('Open browser login: ' + loginUrl);
     ctx.logger.info('Waiting for E10 authorization callback...');
     return await new Promise((resolve, reject) => {
@@ -290,6 +420,7 @@ async function runBrowserLogin(ctx, options) {
             const redirectAgentType = explicitAgentType
                 || callbackUrl.searchParams.get('agent_type')
                 || callbackUrl.searchParams.get('agentType')
+                || callbackUrl.searchParams.get('from')
                 || agentType;
             if (error) {
                 const message = callbackUrl.searchParams.get('error_description') || error;
@@ -439,51 +570,26 @@ export function registerE10AuthCommands(parent, action) {
         const baseUrl = normalizeUrl(optionString(commandOpts, 'baseUrl') || globalOptions.baseUrl || cfg.baseUrl || '');
         const passportUrl = normalizeUrl(optionString(commandOpts, 'passportUrl') || globalOptions.passportUrl || cfg.passportUrl || baseUrl);
         const tenantKeyFallback = optionString(commandOpts, 'tenantKey');
-        const agentType = optionString(commandOpts, 'agentType', 'agent_type');
+        const agentType = resolveAgentType(commandOpts, ctx.env);
         const eteamsId = optionString(commandOpts, 'eteamsid');
         if (!baseUrl)
             throw new CliError('Missing --base-url', ExitCode.UsageError);
         if (!eteamsId)
             throw new CliError('Missing --eteamsid', ExitCode.UsageError);
         ctx.logger.info('Resolving E10 user information...');
-        const userInfo = await resolveUserInfo(baseUrl, eteamsId, '', agentType);
-        if (!userInfo.userId) {
-            throw new CliError('Could not resolve userId. Check whether ETEAMSID is valid.', ExitCode.AuthError);
-        }
-        const tenantKey = userInfo.tenantKey || tenantKeyFallback;
-        const profile = profileFromGlobal || profileNameFromUrl(baseUrl);
-        setActiveProfile(profile);
-        const authData = {
-            cookies: { ETEAMSID: eteamsId },
-            userId: userInfo.userId,
-            tenantKey,
-            tenantName: userInfo.tenantName,
-            department: userInfo.department,
-            subcompany: userInfo.subcompany,
-            position: userInfo.position,
-            agentType,
+        const result = await saveEteamsIdLogin({
             baseUrl,
             passportUrl,
-            cookieSavedAt: Date.now(),
-        };
-        await clearInvoiceTokenCache(profile, authData);
-        const authFile = saveAuthFile(authData, profile);
-        saveProfileConfig(baseUrl, passportUrl, profile, tenantKey);
-        const result = {
-            ...userInfo,
-            tenantKey,
             eteamsId,
-            baseUrl,
-            passportUrl,
-            profile,
-            authFile,
+            tenantKeyFallback,
             agentType,
-            version: '',
-        };
+            profileHint: profileFromGlobal,
+        });
         ctx.output.write(result, { text: formatLoginResult(result) });
     }));
     registerBrowserLoginCommand(auth, action, 'login', 'Open browser OAuth2.0 login and save E10 auth');
     registerBrowserLoginCommand(auth, action, 'oidc', 'Alias of auth login for OAuth2.0 browser login');
+    registerBrowserLoginCommand(auth, action, 'xiaoe', 'Try XiaoE unified login before browser OAuth2.0 login');
     auth.command('logout')
         .alias('clear')
         .description('Clear saved E10 auth for the current or selected profile')
@@ -558,7 +664,9 @@ export function registerE10AuthCommands(parent, action) {
     }));
     auth.command('export-weaver-env')
         .description('Print WEAVER_* shell exports for the active E10 auth')
-        .action(action(async (ctx) => {
+        .option('--shell <shell>', 'Shell syntax: auto, posix, or powershell', 'auto')
+        .action(action(async (ctx, options) => {
+        const commandOpts = asOptions(options);
         const session = await E10AuthSession.fromOptions(ctx.getGlobalOptions(), ctx.cwd);
         if (!session)
             throw new CliError('E10 auth not found.', ExitCode.AuthError);
@@ -573,11 +681,8 @@ export function registerE10AuthCommands(parent, action) {
             ctx.output.write(value);
             return;
         }
-        ctx.output.raw(`export WEAVER_BASE_URL=${shellQuote(value.WEAVER_BASE_URL)}`);
-        ctx.output.raw(`export WEAVER_ETEAMSID=${shellQuote(value.WEAVER_ETEAMSID)}`);
-        ctx.output.raw(`export WEAVER_COOKIE=${shellQuote(value.WEAVER_COOKIE)}`);
-        ctx.output.raw(`export WEAVER_USER_AGENT=${shellQuote(value.WEAVER_USER_AGENT)}`);
-        ctx.output.raw(`export WEAVER_AGENT_TYPE=${shellQuote(value.WEAVER_AGENT_TYPE)}`);
+        const shell = optionString(commandOpts, 'shell') || 'auto';
+        ctx.output.raw(formatWeaverEnvExports(value, shell));
     }));
     const profile = auth.command('profile').description('Manage E10 profiles');
     profile.command('list')

package/dist/internal/e10/auth/xiaoe.js

@@ -0,0 +1,268 @@
+import { CliError, ExitCode } from '../../../core/errors.js';
+import { buildE10CookieHeader, E10AuthSession, profileNameFromUrl, readTeamsCheckUserInfo, saveAuthFile, saveProfileConfig, setActiveProfile, } from './session.js';
+export const DEFAULT_E10_BASE_URL = 'https://www.e-cology.com.cn';
+export const XIAOE_AGENT_TYPE = 'Xiao.E';
+const XIAOE_UNIFIED_LOGIN_MAP_ENV_KEYS = [
+    'XIAOE_E10_AUTH_MAP',
+    'XIAOE_E10_DOMAIN_ETEAMSID_MAP',
+    'XIAOE_DOMAIN_ETEAMSID_MAP',
+    'XIAOE_UNIFIED_LOGIN_MAP',
+];
+const XIAOE_SINGLE_DOMAIN_ENV_KEYS = [
+    'XIAOE_DOMAIN',
+    'XIAOE_E10_DOMAIN',
+    'XIAOE_BASE_URL',
+    'XIAOE_E10_BASE_URL',
+];
+const XIAOE_DEFAULT_DOMAIN_ENV_KEYS = [
+    'XIAOE_DEFAULT_DOMAIN',
+    'XIAOE_DEFAULT_BASE_URL',
+    'XIAOE_E10_DEFAULT_DOMAIN',
+    'XIAOE_E10_DEFAULT_BASE_URL',
+];
+const XIAOE_SINGLE_ETEAMSID_ENV_KEYS = [
+    'XIAOE_ETEAMSID',
+    'XIAOE_ETEAM_ID',
+    'XIAOE_ETEAMID',
+    'XIAOE_E10_ETEAMSID',
+    'XIAOE_E10_ETEAM_ID',
+];
+function envString(env, ...keys) {
+    for (const key of keys) {
+        const value = env[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return '';
+}
+function hasEnvPrefix(env, prefix) {
+    return Object.keys(env).some((key) => key === prefix || key.startsWith(`${prefix}_`));
+}
+export function hasXiaoEEnv(env = process.env) {
+    return hasEnvPrefix(env, 'XIAOE');
+}
+function normalizeUrl(value) {
+    return value.replace(/\/+$/, '');
+}
+function readString(data, ...keys) {
+    for (const key of keys) {
+        const value = data[key];
+        if (typeof value === 'string' && value)
+            return value;
+        if (typeof value === 'number')
+            return String(value);
+    }
+    return '';
+}
+function normalizeDomainKey(value) {
+    const raw = normalizeUrl(value.trim());
+    if (!raw)
+        return null;
+    try {
+        const url = new URL(raw.includes('://') ? raw : `https://${raw}`);
+        return {
+            raw: raw.toLowerCase(),
+            origin: normalizeUrl(url.origin).toLowerCase(),
+            host: url.hostname.toLowerCase(),
+        };
+    }
+    catch {
+        return {
+            raw: raw.toLowerCase(),
+            origin: raw.toLowerCase(),
+            host: '',
+        };
+    }
+}
+function domainMatches(baseUrl, candidate) {
+    const base = normalizeDomainKey(baseUrl);
+    const target = normalizeDomainKey(candidate);
+    if (!base || !target)
+        return false;
+    return base.origin === target.origin
+        || base.raw === target.raw
+        || Boolean(base.host && target.host && base.host === target.host);
+}
+function readXiaoECredentialRecord(value, source, fallbackBaseUrl = '') {
+    const baseUrl = readString(value, 'domain', 'baseUrl', 'base_url', 'url', 'host') || fallbackBaseUrl;
+    const eteamsId = readString(value, 'eteamsId', 'eteamsid', 'ETEAMSID', 'eteamId', 'eteam_id', 'eTeamId');
+    if (!baseUrl || !eteamsId)
+        return null;
+    return { baseUrl: normalizeUrl(baseUrl), eteamsId, source };
+}
+function parseXiaoEUnifiedLoginMap(raw, source) {
+    const value = raw.trim();
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .map((entry) => entry && typeof entry === 'object' && !Array.isArray(entry)
+                ? readXiaoECredentialRecord(entry, source)
+                : null)
+                .filter((entry) => Boolean(entry));
+        }
+        if (parsed && typeof parsed === 'object') {
+            const record = parsed;
+            const direct = readXiaoECredentialRecord(record, source);
+            if (direct)
+                return [direct];
+            return Object.entries(record)
+                .map(([baseUrl, entry]) => {
+                if (typeof entry === 'string' || typeof entry === 'number') {
+                    return { baseUrl: normalizeUrl(baseUrl), eteamsId: String(entry), source };
+                }
+                if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+                    return readXiaoECredentialRecord(entry, source, baseUrl);
+                }
+                return null;
+            })
+                .filter((entry) => Boolean(entry));
+        }
+    }
+    catch {
+        // Fall through to compact text formats.
+    }
+    return value
+        .split(/[;,\n]+/u)
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map((entry) => {
+        const delimiter = entry.includes('|') ? '|' : entry.includes('=') ? '=' : '';
+        if (delimiter) {
+            const index = entry.indexOf(delimiter);
+            const baseUrl = entry.slice(0, index).trim();
+            const eteamsId = entry.slice(index + delimiter.length).trim();
+            return baseUrl && eteamsId ? { baseUrl: normalizeUrl(baseUrl), eteamsId, source } : null;
+        }
+        const parts = entry.split(/\s+/u).filter(Boolean);
+        return parts.length === 2 ? { baseUrl: normalizeUrl(parts[0]), eteamsId: parts[1], source } : null;
+    })
+        .filter((entry) => Boolean(entry));
+}
+function listXiaoEUnifiedLoginCredentials(env = process.env) {
+    const candidates = [];
+    for (const key of XIAOE_UNIFIED_LOGIN_MAP_ENV_KEYS) {
+        const raw = envString(env, key);
+        if (raw)
+            candidates.push(...parseXiaoEUnifiedLoginMap(raw, key));
+    }
+    const singleDomain = envString(env, ...XIAOE_SINGLE_DOMAIN_ENV_KEYS);
+    const singleEteamsId = envString(env, ...XIAOE_SINGLE_ETEAMSID_ENV_KEYS);
+    if (singleDomain && singleEteamsId) {
+        candidates.push({
+            baseUrl: normalizeUrl(singleDomain),
+            eteamsId: singleEteamsId,
+            source: `${XIAOE_SINGLE_DOMAIN_ENV_KEYS[0]}+${XIAOE_SINGLE_ETEAMSID_ENV_KEYS[0]}`,
+        });
+    }
+    return candidates;
+}
+export function resolveXiaoEUnifiedLoginCredential(baseUrl, env = process.env) {
+    const candidates = listXiaoEUnifiedLoginCredentials(env);
+    return candidates.find((candidate) => domainMatches(baseUrl, candidate.baseUrl)) || null;
+}
+export function resolveXiaoEDefaultBaseUrl(env = process.env) {
+    const explicitDefault = envString(env, ...XIAOE_DEFAULT_DOMAIN_ENV_KEYS);
+    if (explicitDefault)
+        return normalizeUrl(explicitDefault);
+    const firstCredential = listXiaoEUnifiedLoginCredentials(env)[0];
+    if (firstCredential?.baseUrl)
+        return normalizeUrl(firstCredential.baseUrl);
+    return hasXiaoEEnv(env) ? DEFAULT_E10_BASE_URL : '';
+}
+export function resolveXiaoEPreferredBaseUrl(options) {
+    const env = options.env || process.env;
+    const explicit = normalizeUrl(options.explicitBaseUrl || '');
+    if (explicit)
+        return explicit;
+    const xiaoEDefault = resolveXiaoEDefaultBaseUrl(env);
+    if (hasXiaoEEnv(env))
+        return xiaoEDefault || normalizeUrl(options.profileBaseUrl || '');
+    return normalizeUrl(options.profileBaseUrl || '') || xiaoEDefault;
+}
+async function resolveUserInfo(baseUrl, eteamsId, rawCookie = '', agentType = '') {
+    const resp = await fetch(`${baseUrl}/api/baseserver/layout/teamsCheck?clientType=not_xinchuang&client=WEB&domainName=${encodeURIComponent(baseUrl)}`, {
+        method: 'POST',
+        headers: {
+            accept: 'application/json',
+            'content-type': 'application/json',
+            eteamsid: eteamsId,
+            cookie: buildE10CookieHeader(rawCookie, eteamsId, agentType),
+            'user-agent': agentType ? `AgentType=${agentType},IsAgent=true` : 'weaver-work-cli',
+            origin: baseUrl,
+        },
+        redirect: 'manual',
+    });
+    const data = await resp.json().catch(() => ({}));
+    return readTeamsCheckUserInfo(resp, data);
+}
+async function saveXiaoEUnifiedLogin(input) {
+    const baseUrl = normalizeUrl(input.baseUrl);
+    const userInfo = await resolveUserInfo(baseUrl, input.eteamsId, '', XIAOE_AGENT_TYPE);
+    if (!userInfo.userId) {
+        throw new CliError('Could not resolve userId. Check whether XiaoE unified login is valid for this E10 domain.', ExitCode.AuthError);
+    }
+    const tenantKey = userInfo.tenantKey || input.tenantKeyFallback || '';
+    const profile = input.profileHint || profileNameFromUrl(baseUrl);
+    setActiveProfile(profile);
+    const authData = {
+        cookies: { ETEAMSID: input.eteamsId },
+        userId: userInfo.userId,
+        tenantKey,
+        tenantName: userInfo.tenantName,
+        department: userInfo.department,
+        subcompany: userInfo.subcompany,
+        position: userInfo.position,
+        agentType: XIAOE_AGENT_TYPE,
+        version: '',
+        baseUrl,
+        passportUrl: baseUrl,
+        cookieSavedAt: Date.now(),
+        loginSource: 'xiaoe-unified',
+    };
+    const authFile = saveAuthFile(authData, profile);
+    saveProfileConfig(baseUrl, baseUrl, profile, tenantKey);
+    const session = new E10AuthSession(authData, authFile);
+    return {
+        session,
+        result: {
+            ...userInfo,
+            tenantKey,
+            eteamsId: input.eteamsId,
+            baseUrl,
+            passportUrl: baseUrl,
+            profile,
+            authFile,
+            agentType: XIAOE_AGENT_TYPE,
+            version: '',
+        },
+    };
+}
+export async function tryXiaoEUnifiedLogin(options = {}) {
+    const env = options.env || process.env;
+    const baseUrl = resolveXiaoEPreferredBaseUrl({
+        explicitBaseUrl: options.baseUrl,
+        env,
+    });
+    if (!baseUrl)
+        return null;
+    const credential = resolveXiaoEUnifiedLoginCredential(baseUrl, env);
+    if (!credential)
+        return null;
+    options.logger?.info('Detected XiaoE unified login for this E10 domain. Trying XiaoE auth...');
+    try {
+        return await saveXiaoEUnifiedLogin({
+            baseUrl,
+            eteamsId: credential.eteamsId,
+            tenantKeyFallback: options.tenantKeyFallback,
+            profileHint: options.profileHint,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        options.logger?.warn('XiaoE unified login failed; falling back to standard E10 auth. ' + message);
+        return null;
+    }
+}

package/dist/internal/e10/context.js

@@ -1,13 +1,27 @@
 import { CliError, ExitCode } from '../../core/errors.js';
 import { E10AuthSession } from './auth/session.js';
+import { hasXiaoEEnv, tryXiaoEUnifiedLogin } from './auth/xiaoe.js';
 import { E10ApiClient } from './client.js';
+function shouldPreferXiaoEUnifiedLogin(options, env) {
+    return hasXiaoEEnv(env) && !options.auth && !options.profile;
+}
 export async function getE10Session(ctx) {
-    return E10AuthSession.fromOptions(ctx.getGlobalOptions(), ctx.cwd);
+    const options = ctx.getGlobalOptions();
+    if (shouldPreferXiaoEUnifiedLogin(options, ctx.env)) {
+        const xiaoELogin = await tryXiaoEUnifiedLogin({
+            env: ctx.env,
+            baseUrl: options.baseUrl,
+            logger: ctx.logger,
+        });
+        if (xiaoELogin)
+            return xiaoELogin.session;
+    }
+    return E10AuthSession.fromOptions(options, ctx.cwd);
 }
 export async function requireE10Session(ctx) {
     const session = await getE10Session(ctx);
     if (!session) {
-        throw new CliError('E10 auth not found. Ask the user for the E10 login domain (base URL), then run: weaver-work-cli auth login --base-url <url>.', ExitCode.AuthError);
+        throw new CliError('E10 auth not found. In XiaoE, run weaver-work-cli auth xiaoe first; if unified login is unavailable, ask the user for the E10 login domain (base URL), then run: weaver-work-cli auth login --base-url <url> --agent_type <agent_type>.', ExitCode.AuthError);
     }
     return session;
 }

package/dist/internal/e10/index.js

@@ -1,2 +1,3 @@
 export { E10ApiClient } from './client.js';
 export { getE10Client, getE10Session, requireE10Client, requireE10Session } from './context.js';
+export { E10ApiError, E10RequestRuntime, createE10RequestRuntime } from './request-runtime.js';