weaver-work-cli 0.1.0

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

@@ -0,0 +1,594 @@
+import { execFile } from 'node:child_process';
+import { createServer } from 'node:http';
+import { CliError, ExitCode } from '../../../core/errors.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';
+const DEFAULT_AGENT_TYPE = 'weaver-work-cli';
+function asOptions(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function optionString(options, ...keys) {
+    for (const key of keys) {
+        const value = options[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return '';
+}
+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 cookieString(value) {
+    if (!value)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        return Object.entries(value)
+            .filter(([, cookieValue]) => cookieValue !== undefined && cookieValue !== null && cookieValue !== '')
+            .map(([name, cookieValue]) => `${name}=${String(cookieValue)}`)
+            .join('; ');
+    }
+    return '';
+}
+function cookieValue(rawCookie, name) {
+    const match = rawCookie.match(new RegExp(`${name}=([^;]+)`));
+    return match?.[1] || '';
+}
+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>',
+        ].join('\n');
+    }
+    const lines = [
+        'Logged in.',
+        'userId: ' + status.userId,
+        'tenantKey: ' + (status.tenantKey || ''),
+        'tenantName: ' + (status.tenantName || ''),
+        'department: ' + (status.department || ''),
+        'subcompany: ' + (status.subcompany || ''),
+        'position: ' + (status.position || ''),
+        'version: ' + (status.version || ''),
+        'agentType: ' + (status.agentType || ''),
+        'baseUrl: ' + status.baseUrl,
+        'profile: ' + status.profile,
+        'authFile: ' + status.authFile,
+    ];
+    if ('valid' in status) {
+        lines.push('valid: ' + String(status.valid));
+    }
+    return lines.join('\n');
+}
+function formatLoginResult(result) {
+    return [
+        'Saved E10 auth.',
+        'userId: ' + result.userId,
+        'tenantKey: ' + result.tenantKey,
+        'tenantName: ' + result.tenantName,
+        'baseUrl: ' + result.baseUrl,
+        'profile: ' + result.profile,
+        'authFile: ' + result.authFile,
+    ].join('\n');
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function esc(value) {
+    return String(value ?? '')
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+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] };
+    execFile(command.file, command.args, (error) => {
+        if (error) {
+            ctx.logger.warn('Could not open browser automatically. Copy the login URL manually.');
+        }
+    });
+}
+async function readJsonObject(resp) {
+    const data = await resp.json().catch(() => ({}));
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+}
+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` : 'e10-login',
+            origin: baseUrl,
+        },
+        redirect: 'manual',
+    });
+    const data = await resp.json().catch(() => ({}));
+    return readTeamsCheckUserInfo(resp, data);
+}
+async function oidcExchange(code, redirectUri, baseUrl, tenantKeyFallback, agentTypeFallback, profileHint) {
+    const base = normalizeUrl(baseUrl);
+    const tokenParams = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code,
+        redirect_uri: redirectUri,
+    });
+    const tokenResp = await fetch(`${base}/papi/sso/oauth2.0/accessToken`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/x-www-form-urlencoded' },
+        body: tokenParams.toString(),
+        redirect: 'manual',
+    });
+    const tokenData = await readJsonObject(tokenResp);
+    if (tokenResp.status >= 400) {
+        const message = readString(tokenData, 'message', 'msg', 'error_description', 'error') || `OAuth token exchange failed: ${tokenResp.status}`;
+        throw new CliError(message, ExitCode.AuthError);
+    }
+    let eteamsId = readString(tokenData, 'eteamsId', 'eteamsid');
+    let userId = readString(tokenData, 'id', 'userId', 'employeeId');
+    let rawCookies = cookieString(tokenData.cookies || tokenData.cookie) || extractRawSetCookie(tokenResp);
+    let agentType = agentTypeFallback || readString(tokenData, 'agentType', 'agent_type');
+    let version = readString(tokenData, 'version', 'baselineVersion');
+    const accessToken = readString(tokenData, 'access_token', 'accessToken');
+    if (!eteamsId)
+        eteamsId = cookieValue(rawCookies, 'ETEAMSID');
+    if (accessToken && (!eteamsId || !userId || !rawCookies || !version || !agentType)) {
+        const profileResp = await fetch(`${base}/papi/sso/oauth2.0/profile?access_token=${encodeURIComponent(accessToken)}`, {
+            method: 'POST',
+            headers: { accept: 'application/json' },
+            redirect: 'manual',
+        });
+        const profileData = await readJsonObject(profileResp);
+        const profileRawCookies = cookieString(profileData.cookies || profileData.cookie) || extractRawSetCookie(profileResp);
+        if (!eteamsId)
+            eteamsId = readString(profileData, 'eteamsId', 'eteamsid') || cookieValue(profileRawCookies, 'ETEAMSID');
+        if (!userId)
+            userId = readString(profileData, 'id', 'userId', 'employeeId');
+        if (!rawCookies)
+            rawCookies = profileRawCookies;
+        if (!agentType)
+            agentType = readString(profileData, 'agentType', 'agent_type');
+        if (!version)
+            version = readString(profileData, 'version', 'baselineVersion');
+    }
+    if (!eteamsId) {
+        throw new CliError('Could not resolve ETEAMSID from OAuth response.', ExitCode.AuthError);
+    }
+    const userInfo = await resolveUserInfo(base, eteamsId, rawCookies, agentType).catch(() => ({
+        userId: '',
+        tenantKey: '',
+        tenantName: '',
+        department: '',
+        subcompany: '',
+        position: '',
+    }));
+    const tenantKey = readString(tokenData, 'tenant_key', 'tenantKey')
+        || userInfo.tenantKey
+        || tenantKeyFallback;
+    const authData = {
+        cookies: { ETEAMSID: eteamsId, raw: rawCookies },
+        userId: userInfo.userId || userId || 'unknown',
+        tenantKey,
+        tenantName: userInfo.tenantName,
+        department: userInfo.department,
+        subcompany: userInfo.subcompany,
+        position: userInfo.position,
+        agentType,
+        version,
+        baseUrl: base,
+        passportUrl: base,
+        cookieSavedAt: Date.now(),
+    };
+    const profile = profileHint || profileNameFromUrl(base);
+    setActiveProfile(profile);
+    const authFile = saveAuthFile(authData, profile);
+    saveProfileConfig(base, base, profile, tenantKey);
+    return {
+        userId: authData.userId,
+        tenantKey,
+        tenantName: authData.tenantName || '',
+        department: authData.department || '',
+        subcompany: authData.subcompany || '',
+        position: authData.position || '',
+        eteamsId,
+        baseUrl: base,
+        passportUrl: base,
+        profile,
+        authFile,
+        agentType,
+        version,
+    };
+}
+async function runBrowserLogin(ctx, options) {
+    const commandOpts = asOptions(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 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;
+    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 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()}`;
+    ctx.logger.info('Open browser login: ' + loginUrl);
+    ctx.logger.info('Waiting for E10 authorization callback...');
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        let timer = null;
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            const complete = () => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            };
+            try {
+                server.close(complete);
+            }
+            catch {
+                complete();
+            }
+        };
+        const server = createServer(async (req, res) => {
+            const callbackUrl = new URL(req.url || '/', `http://127.0.0.1:${port}`);
+            if (callbackUrl.pathname !== '/callback') {
+                res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+                res.end('Not found');
+                return;
+            }
+            const error = callbackUrl.searchParams.get('error');
+            const code = callbackUrl.searchParams.get('code');
+            const redirectAgentType = explicitAgentType
+                || callbackUrl.searchParams.get('agent_type')
+                || callbackUrl.searchParams.get('agentType')
+                || agentType;
+            if (error) {
+                const message = callbackUrl.searchParams.get('error_description') || error;
+                res.writeHead(400, { 'content-type': 'text/html; charset=utf-8' });
+                res.end(`<h1>Authorization failed</h1><p>${esc(message)}</p>`);
+                finish(new CliError('OAuth authorization failed: ' + message, ExitCode.AuthError));
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { 'content-type': 'text/html; charset=utf-8' });
+                res.end('<h1>Login failed</h1><p>Missing authorization code.</p>');
+                finish(new CliError('No authorization code received.', ExitCode.AuthError));
+                return;
+            }
+            try {
+                const result = await oidcExchange(code, redirectUri, baseUrl, tenantKey, redirectAgentType, profileFromGlobal);
+                res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+                res.end(`<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>weaver-work-cli login</title><style>body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Arial,sans-serif;background:#f6f7f9;color:#20242a;display:grid;place-items:center;min-height:100vh;margin:0}.card{background:#fff;border:1px solid #e6e8ec;border-radius:8px;padding:28px 32px;box-shadow:0 8px 32px rgba(18,24,40,.08);min-width:320px;text-align:center}.title{font-size:20px;font-weight:600;margin-bottom:8px}.desc{color:#667085;font-size:14px;line-height:22px}.user{color:#98a2b3;font-size:12px;margin-top:12px}</style></head><body><main class="card"><div class="title">Login completed</div><div class="desc">You can close this page and return to the terminal.</div><div class="user">${esc(result.userId)}</div></main></body></html>`);
+                finish(null, result);
+            }
+            catch (exchangeError) {
+                const message = exchangeError instanceof Error ? exchangeError.message : String(exchangeError);
+                res.writeHead(500, { 'content-type': 'text/html; charset=utf-8' });
+                res.end(`<h1>Login failed</h1><p>${esc(message)}</p>`);
+                finish(exchangeError);
+            }
+        });
+        server.on('error', (error) => {
+            const message = error.code === 'EADDRINUSE'
+                ? `Port ${port} is already in use. Retry with --port ${port + 1}.`
+                : error.code === 'EACCES'
+                    ? `Port ${port} is not accessible. Retry with another --port.`
+                    : error.message;
+            finish(new CliError(message, ExitCode.UsageError));
+        });
+        server.listen(port, '127.0.0.1', () => {
+            ctx.logger.info('Local callback server: ' + redirectUri);
+            openUrlInBrowser(loginUrl, ctx);
+        });
+        timer = setTimeout(() => {
+            finish(new CliError('Login timed out after 5 minutes.', ExitCode.AuthError));
+        }, 300_000);
+    });
+}
+function sessionToCachedUser(session, profile) {
+    return {
+        employeeId: session.userId,
+        tenantKey: session.tenantKey,
+        tenantName: session.tenantName,
+        department: session.department,
+        subcompany: session.subcompany,
+        position: session.position,
+        version: session.version,
+        baseUrl: session.getBaseUrl(),
+        profile,
+        eteamsId: session.eteamsId,
+        agentType: session.agentType,
+        cookie: session.cookieHeader(),
+        userAgent: session.uaHeader(),
+    };
+}
+function formatWhoami(title, data) {
+    return [
+        title,
+        'employeeId: ' + (data.employeeId || ''),
+        'tenantKey: ' + (data.tenantKey || ''),
+        'tenantName: ' + (data.tenantName || ''),
+        'department: ' + (data.department || ''),
+        'subcompany: ' + (data.subcompany || ''),
+        'position: ' + (data.position || ''),
+        'version: ' + (data.version || ''),
+        'baseUrl: ' + (data.baseUrl || ''),
+        'profile: ' + (data.profile || ''),
+        'ETEAMSID: ' + (data.eteamsId || ''),
+        'cookie: ' + (data.cookie || ''),
+        'User-Agent: ' + (data.userAgent || ''),
+    ].join('\n');
+}
+function registerBrowserLoginCommand(auth, action, name, description) {
+    auth.command(name)
+        .description(description)
+        .option('--base-url <url>', 'E10 base URL')
+        .option('--tenant-key <key>', 'Tenant key fallback after login')
+        .option('--port <n>', 'Local OAuth callback port', '19800')
+        .option('--agent_type <value>', 'Agent type sent to E10 authorize endpoint')
+        .option('--agent-type <value>', 'Alias of --agent_type')
+        .action(action(async (ctx, options) => {
+        const result = await runBrowserLogin(ctx, options);
+        ctx.output.write(result, { text: formatLoginResult(result) });
+    }));
+}
+export function registerE10AuthCommands(parent, action) {
+    const auth = parent.command('auth').description('E10 auth and profile management');
+    auth.command('root')
+        .description('Print the E10 auth root directory')
+        .action(action((ctx) => {
+        const root = getE10AuthRoot();
+        ctx.output.write({ root }, { text: root });
+    }));
+    auth.command('status')
+        .description('Show E10 login status')
+        .option('--no-check', 'skip remote session validity check')
+        .action(action(async (ctx, options) => {
+        const opts = ctx.getGlobalOptions();
+        const commandOpts = asOptions(options);
+        const authFile = findAuthFile(ctx.cwd, opts);
+        const session = authFile ? E10AuthSession.fromFile(authFile, opts.baseUrl, opts.passportUrl) : null;
+        const valid = session && commandOpts.check !== false ? await session.checkValid() : undefined;
+        const status = session
+            ? {
+                loggedIn: true,
+                userId: session.userId,
+                tenantKey: session.tenantKey,
+                tenantName: session.tenantName,
+                department: session.department,
+                subcompany: session.subcompany,
+                position: session.position,
+                version: session.version,
+                agentType: session.agentType,
+                baseUrl: session.getBaseUrl(),
+                passportUrl: session.getPassportUrl(),
+                profile: opts.profile || getActiveProfile(),
+                authFile,
+                hasEteamsId: Boolean(session.eteamsId),
+                valid,
+            }
+            : {
+                loggedIn: false,
+                profile: opts.profile || getActiveProfile(),
+                authFile,
+            };
+        ctx.output.write(status, { text: formatAuthStatus(status) });
+    }));
+    auth.command('set')
+        .description('Save E10 auth from an ETEAMSID cookie')
+        .requiredOption('--eteamsid <id>', 'ETEAMSID cookie value')
+        .option('--base-url <url>', 'E10 base URL')
+        .option('--passport-url <url>', 'E10 passport URL; defaults to base URL')
+        .option('--tenant-key <key>', 'Tenant key fallback')
+        .option('--agent_type <value>', 'Agent type used in cookie and User-Agent')
+        .option('--agent-type <value>', 'Alias of --agent_type')
+        .action(action(async (ctx, options) => {
+        const globalOptions = ctx.getGlobalOptions();
+        const commandOpts = asOptions(options);
+        const profileFromGlobal = globalOptions.profile;
+        const cfg = readProfileConfig(profileFromGlobal || getActiveProfile());
+        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 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,
+            baseUrl,
+            passportUrl,
+            cookieSavedAt: Date.now(),
+        };
+        const authFile = saveAuthFile(authData, profile);
+        saveProfileConfig(baseUrl, passportUrl, profile, tenantKey);
+        const result = {
+            ...userInfo,
+            tenantKey,
+            eteamsId,
+            baseUrl,
+            passportUrl,
+            profile,
+            authFile,
+            agentType,
+            version: '',
+        };
+        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');
+    auth.command('logout')
+        .alias('clear')
+        .description('Clear saved E10 auth for the current or selected profile')
+        .action(action((ctx) => {
+        const opts = ctx.getGlobalOptions();
+        const result = clearProfileAuthFile(opts.profile || getActiveProfile());
+        const text = result.cleared
+            ? 'Cleared E10 auth.\nprofile: ' + result.profile + '\nauthFile: ' + result.authFile
+            : 'No E10 auth to clear.\nprofile: ' + result.profile + '\nauthFile: ' + result.authFile;
+        ctx.output.write(result, { text });
+    }));
+    auth.command('whoami')
+        .description('Show cached or live E10 user information')
+        .option('--json', 'print output as JSON')
+        .option('--live', 'call teamsCheck for live user information')
+        .action(action(async (ctx, options) => {
+        const opts = ctx.getGlobalOptions();
+        const commandOpts = asOptions(options);
+        const json = commandOpts.json === true;
+        const live = commandOpts.live === true;
+        const authFile = findAuthFile(ctx.cwd, opts);
+        const session = authFile ? E10AuthSession.fromFile(authFile, opts.baseUrl, opts.passportUrl) : null;
+        if (!session || !session.eteamsId)
+            throw new CliError('E10 auth not found.', ExitCode.AuthError);
+        const profile = opts.profile || getActiveProfile();
+        const cached = sessionToCachedUser(session, profile);
+        if (!live) {
+            ctx.output.write(cached, {
+                json,
+                text: formatWhoami('Current E10 user (cached)', cached),
+            });
+            return;
+        }
+        const base = session.getBaseUrl();
+        const resp = await fetch(`${base}/api/baseserver/layout/teamsCheck?clientType=not_xinchuang&client=WEB&domainName=${encodeURIComponent(base)}`, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                eteamsid: session.eteamsId,
+                cookie: session.cookieHeader(),
+                'user-agent': session.uaHeader(),
+                origin: base,
+            },
+            redirect: 'manual',
+        });
+        const raw = await resp.json().catch(() => ({}));
+        if (json || ctx.getGlobalOptions().json) {
+            ctx.output.write(raw, { json: true });
+            return;
+        }
+        const userInfo = readTeamsCheckUserInfo(resp, raw);
+        const liveData = {
+            ...cached,
+            employeeId: userInfo.userId || cached.employeeId,
+            tenantKey: userInfo.tenantKey || cached.tenantKey,
+            tenantName: userInfo.tenantName || cached.tenantName,
+            department: userInfo.department || cached.department,
+            subcompany: userInfo.subcompany || cached.subcompany,
+            position: userInfo.position || cached.position,
+        };
+        ctx.output.write(liveData, { text: formatWhoami('Current E10 user (live)', liveData) });
+    }));
+    auth.command('export-weaver-env')
+        .description('Print WEAVER_* shell exports for the active E10 auth')
+        .action(action(async (ctx) => {
+        const session = await E10AuthSession.fromOptions(ctx.getGlobalOptions(), ctx.cwd);
+        if (!session)
+            throw new CliError('E10 auth not found.', ExitCode.AuthError);
+        const value = {
+            WEAVER_BASE_URL: session.getBaseUrl(),
+            WEAVER_ETEAMSID: session.eteamsId,
+            WEAVER_COOKIE: session.cookieHeader(),
+            WEAVER_USER_AGENT: session.uaHeader(),
+            WEAVER_AGENT_TYPE: session.agentType,
+        };
+        if (ctx.getGlobalOptions().json) {
+            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 profile = auth.command('profile').description('Manage E10 profiles');
+    profile.command('list')
+        .description('List E10 profiles')
+        .action(action((ctx) => {
+        const active = getActiveProfile();
+        const profiles = listProfiles().map((name) => ({
+            name,
+            active: name === active,
+            dir: getProfileDir(name),
+        }));
+        ctx.output.write({ active, profiles });
+    }));
+    profile.command('use')
+        .description('Switch active E10 profile; creates it if missing')
+        .argument('<name>', 'profile name')
+        .action(action((ctx, name) => {
+        if (typeof name !== 'string')
+            throw new CliError('profile name must be a string', ExitCode.UsageError);
+        setActiveProfile(name);
+        const result = {
+            active: name,
+            dir: getProfileDir(name),
+            authFile: getProfileAuthPath(name),
+        };
+        ctx.output.write(result, { text: 'Active E10 profile: ' + name + '\n' + 'dir: ' + result.dir });
+    }));
+    profile.command('current')
+        .description('Print active E10 profile')
+        .action(action((ctx) => {
+        const active = getActiveProfile();
+        ctx.output.write({ active, dir: getProfileDir(active) }, { text: active });
+    }));
+    return auth;
+}