vps-work 2.5.0 → 2.5.1

package/dist/packages/vps-work/src/core/vps-service-auth.js

@@ -0,0 +1,382 @@
+import { request } from 'undici';
+import { VertuError } from './errors.js';
+import { agentKeyAccount, deleteSecret, getSecret, isKeychainAvailable, setSecret, vpsSessionTokenAccount, } from './keychain.js';
+import { DEFAULT_VPS_SERVICE_BASE_URL } from './sales-query-client.js';
+import { readVpsServiceConfig, writeVpsServiceConfig, } from './vps-service-config.js';
+import { CLI_AUTH_CHANNEL } from './cli-bin.js';
+import { VERTU_EXPECTED_USER_ID_ENV } from './vertu-agent-env.js';
+/** 过期时间是否仍有效；空或不可解析按长期有效处理（兼容旧逻辑）。 */
+function notExpired(expiresAt) {
+    const trimmed = expiresAt?.trim();
+    if (!trimmed) {
+        return true;
+    }
+    const parsed = Date.parse(trimmed);
+    if (!Number.isFinite(parsed)) {
+        return true;
+    }
+    return parsed > Date.now();
+}
+/**
+ * 综合本地配置与宿主环境变量，解析当前 vps-service 鉴权状态。
+ * 优先使用有效的登录 session；否则回落到有效的长效/代理 agent key。
+ */
+export function resolveVpsAuthState(cfg, env) {
+    const sessionToken = cfg.sessionToken?.trim() || undefined;
+    const sessionActive = Boolean(sessionToken) && notExpired(cfg.expiresAt);
+    const agentKey = env.appKey?.trim() || cfg.agentAppKey?.trim() || undefined;
+    const agentAppId = env.appId?.trim() || cfg.agentAppId?.trim() || null;
+    const agentKeyValid = Boolean(agentKey) && agentKey.startsWith('vta_') && notExpired(cfg.agentKeyExpiresAt);
+    const login = cfg.login?.trim() || env.login?.trim() || null;
+    if (sessionActive) {
+        return {
+            mode: 'session',
+            active: true,
+            token: sessionToken ?? null,
+            login,
+            agentAppId,
+            expiresAt: cfg.expiresAt?.trim() || null,
+            neverExpires: false,
+        };
+    }
+    if (agentKeyValid) {
+        return {
+            mode: 'agent',
+            active: true,
+            token: agentKey ?? null,
+            login,
+            agentAppId,
+            expiresAt: cfg.agentKeyExpiresAt?.trim() || null,
+            neverExpires: !cfg.agentKeyExpiresAt?.trim(),
+        };
+    }
+    return {
+        mode: 'none',
+        active: false,
+        token: null,
+        login,
+        agentAppId,
+        expiresAt: null,
+        neverExpires: false,
+    };
+}
+function stringOrNull(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function numberOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function pickFromUserOrInfo(user, info, camel, snake) {
+    return stringOrNull(user[camel]) ?? stringOrNull(info?.[snake]);
+}
+/** 从服务端 user / userinfo 提取企业身份字段。 */
+export function pickVpsServiceUserInfo(user, userinfo) {
+    return {
+        userId: numberOrNull(user.userId) ?? numberOrNull(userinfo?.user_id),
+        tenantId: pickFromUserOrInfo(user, userinfo, 'tenantId', 'tenant_id'),
+        tenantName: pickFromUserOrInfo(user, userinfo, 'tenantName', 'tenant_name'),
+        tenantType: pickFromUserOrInfo(user, userinfo, 'tenantType', 'tenant_type'),
+        membershipId: pickFromUserOrInfo(user, userinfo, 'membershipId', 'membership_id'),
+        membershipRole: pickFromUserOrInfo(user, userinfo, 'membershipRole', 'membership_role'),
+        productProfile: pickFromUserOrInfo(user, userinfo, 'productProfile', 'product_profile'),
+        login: stringOrNull(user.login) ?? stringOrNull(userinfo?.login) ?? '',
+        employeeName: stringOrNull(user.employeeName) ?? stringOrNull(userinfo?.employee_name),
+        departmentName: stringOrNull(user.departmentName) ?? stringOrNull(userinfo?.department_name),
+        departmentPath: stringOrNull(user.departmentPath) ?? stringOrNull(userinfo?.department_path),
+        role: stringOrNull(user.role) ?? stringOrNull(userinfo?.role),
+    };
+}
+function normalizeServiceRoot(url) {
+    let trimmed = url.trim().replace(/\/+$/, '');
+    if (!/^https?:\/\//i.test(trimmed)) {
+        trimmed = `https://${trimmed}`;
+    }
+    return trimmed;
+}
+export async function loginVpsServiceWithPassword(serviceBaseUrl, login, password) {
+    const base = normalizeServiceRoot(serviceBaseUrl);
+    const headers = {
+        'content-type': 'application/json',
+        accept: 'application/json',
+        'x-vertu-auth-channel': CLI_AUTH_CHANNEL,
+        'user-agent': CLI_AUTH_CHANNEL,
+    };
+    const res = await request(`${base}/v1/auth/login`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ login, password }),
+    });
+    const text = await res.body.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new VertuError(`Vertu 登录失败：非 JSON 响应（HTTP ${res.statusCode}）`);
+    }
+    if (res.statusCode >= 400) {
+        const errMsg = data && typeof data === 'object' && 'error' in data
+            ? String(data.error)
+            : `HTTP ${res.statusCode}`;
+        throw new VertuError(`Vertu 登录失败：${errMsg}`);
+    }
+    if (!data || typeof data !== 'object') {
+        throw new VertuError('Vertu 登录失败：响应格式无效');
+    }
+    const payload = data;
+    const token = payload.token?.trim();
+    const expiresAt = payload.expires_at?.trim();
+    const userLogin = payload.user?.login?.trim() ?? login;
+    if (!token || !expiresAt) {
+        throw new VertuError('Vertu 登录失败：未返回 token（请升级服务端）');
+    }
+    return {
+        login: userLogin,
+        token,
+        expiresAt,
+        user: (payload.user ?? {}),
+    };
+}
+/** 查询当前会话用户（GET /v1/auth/me）。 */
+export async function fetchVpsServiceMe(serviceBaseUrl, sessionToken) {
+    const base = normalizeServiceRoot(serviceBaseUrl);
+    const expectedUserId = process.env[VERTU_EXPECTED_USER_ID_ENV]?.trim();
+    const res = await request(`${base}/v1/auth/me`, {
+        method: 'GET',
+        headers: {
+            accept: 'application/json',
+            authorization: `Bearer ${sessionToken}`,
+            'x-vertu-auth-channel': CLI_AUTH_CHANNEL,
+            'user-agent': CLI_AUTH_CHANNEL,
+            ...(expectedUserId && /^[1-9]\d*$/.test(expectedUserId)
+                ? { 'x-vertu-expected-user-id': expectedUserId }
+                : {}),
+        },
+    });
+    const text = await res.body.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new VertuError(`Vertu 身份查询失败：非 JSON 响应（HTTP ${res.statusCode}）`);
+    }
+    if (res.statusCode >= 400) {
+        throw new VertuError(`Vertu 身份查询失败：HTTP ${res.statusCode}`);
+    }
+    const payload = data;
+    if (!payload.user || typeof payload.user !== 'object') {
+        throw new VertuError('Vertu 身份查询失败：响应缺少 user');
+    }
+    return pickVpsServiceUserInfo(payload.user, payload.userinfo);
+}
+export async function bindVpsServiceAgentCredential(serviceBaseUrl, sessionToken, appId) {
+    const base = normalizeServiceRoot(serviceBaseUrl);
+    const res = await request(`${base}/v1/auth/agent-bind`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            accept: 'application/json',
+            authorization: `Bearer ${sessionToken}`,
+            'x-vertu-auth-channel': CLI_AUTH_CHANNEL,
+            'user-agent': CLI_AUTH_CHANNEL,
+        },
+        body: JSON.stringify({ app_id: appId }),
+    });
+    const text = await res.body.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new VertuError(`Agent 绑定失败：非 JSON（HTTP ${res.statusCode}）`);
+    }
+    if (res.statusCode >= 400) {
+        const errMsg = data && typeof data === 'object' && 'error' in data
+            ? String(data.error)
+            : `HTTP ${res.statusCode}`;
+        throw new VertuError(`Agent 绑定失败：${errMsg}`);
+    }
+    if (!data || typeof data !== 'object') {
+        throw new VertuError('Agent 绑定失败：响应无效');
+    }
+    const payload = data;
+    const boundAppId = payload.app_id?.trim();
+    const appKey = payload.app_key?.trim();
+    const login = payload.login?.trim();
+    // 长效密钥 expires_at 返回 null，属正常情况，不作为缺失校验。
+    const expiresAt = payload.expires_at?.trim() || null;
+    if (!boundAppId || !appKey || !login) {
+        throw new VertuError('Agent 绑定失败：缺少 app_key（请先执行数据库迁移 005）');
+    }
+    return { appId: boundAppId, appKey, login, expiresAt };
+}
+export async function persistVpsServiceAgentCredential(serviceBaseUrl, bound) {
+    const root = normalizeServiceRoot(serviceBaseUrl);
+    const existing = await readVpsServiceConfig();
+    if (existing.agentAppId && existing.agentAppId !== bound.appId) {
+        if (await isKeychainAvailable()) {
+            await deleteSecret(agentKeyAccount(root, existing.agentAppId));
+        }
+    }
+    if (await isKeychainAvailable()) {
+        await setSecret(agentKeyAccount(root, bound.appId), bound.appKey);
+    }
+    await writeVpsServiceConfig({
+        version: 1,
+        baseUrl: root,
+        login: bound.login,
+        sessionToken: existing.sessionToken,
+        expiresAt: existing.expiresAt,
+        apiKey: existing.apiKey,
+        agentAppId: bound.appId,
+        agentAppKey: bound.appKey,
+        agentKeyExpiresAt: bound.expiresAt ?? undefined,
+    });
+}
+export async function loadStoredAgentKey(serviceBaseUrl, appId) {
+    const root = normalizeServiceRoot(serviceBaseUrl);
+    const config = await readVpsServiceConfig();
+    if (normalizeServiceRoot(config.baseUrl ?? '') === root &&
+        config.agentAppId === appId &&
+        config.agentAppKey?.trim()) {
+        return config.agentAppKey.trim();
+    }
+    if (!(await isKeychainAvailable())) {
+        return undefined;
+    }
+    const raw = await getSecret(agentKeyAccount(root, appId));
+    return raw?.trim() || undefined;
+}
+export async function persistVpsServiceSession(serviceBaseUrl, session) {
+    const existing = await readVpsServiceConfig();
+    const root = normalizeServiceRoot(serviceBaseUrl);
+    if (await isKeychainAvailable()) {
+        await setSecret(vpsSessionTokenAccount(root), session.token);
+    }
+    const next = {
+        version: 1,
+        baseUrl: root,
+        login: session.login,
+        sessionToken: session.token,
+        expiresAt: session.expiresAt,
+        apiKey: existing.apiKey,
+        agentAppId: existing.agentAppId,
+        agentAppKey: existing.agentAppKey,
+        agentKeyExpiresAt: existing.agentKeyExpiresAt,
+    };
+    await writeVpsServiceConfig(next);
+}
+export async function clearVpsServiceSession(forgetLogin = false) {
+    const existing = await readVpsServiceConfig();
+    await writeVpsServiceConfig({
+        version: 1,
+        baseUrl: existing.baseUrl,
+        apiKey: existing.apiKey,
+        login: forgetLogin ? undefined : existing.login,
+    });
+}
+export async function logoutVpsServiceRemote() {
+    const existing = await readVpsServiceConfig();
+    const token = existing.sessionToken?.trim();
+    const base = existing.baseUrl?.trim();
+    if (!token || !base) {
+        return;
+    }
+    const root = normalizeServiceRoot(base);
+    try {
+        await request(`${root}/v1/auth/logout`, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${token}`,
+                'x-vertu-auth-channel': CLI_AUTH_CHANNEL,
+                'user-agent': CLI_AUTH_CHANNEL,
+            },
+        });
+    }
+    catch {
+        /* 仍清除本地会话 */
+    }
+}
+function parseJsonObject(text, statusCode, label) {
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new VertuError(`${label}失败：非 JSON（HTTP ${statusCode}）`);
+    }
+    if (statusCode >= 400) {
+        const errMsg = data && typeof data === 'object' && 'error' in data
+            ? String(data.error)
+            : `HTTP ${statusCode}`;
+        throw new VertuError(`${label}失败：${errMsg}`);
+    }
+    if (!data || typeof data !== 'object') {
+        throw new VertuError(`${label}失败：响应无效`);
+    }
+    return data;
+}
+/** 列出当前账号可切换的企业。 */
+export async function fetchVpsServiceTenants(serviceBaseUrl, sessionToken) {
+    const base = normalizeServiceRoot(serviceBaseUrl);
+    const res = await request(`${base}/v1/bootstrap`, {
+        method: 'GET',
+        headers: {
+            accept: 'application/json',
+            authorization: `Bearer ${sessionToken}`,
+            'x-vertu-auth-channel': CLI_AUTH_CHANNEL,
+            'user-agent': CLI_AUTH_CHANNEL,
+        },
+    });
+    const payload = parseJsonObject(await res.body.text(), res.statusCode, '企业列表');
+    const tenants = payload.tenants;
+    if (!Array.isArray(tenants)) {
+        throw new VertuError('企业列表失败：响应缺少 tenants');
+    }
+    return tenants.map((item) => {
+        const row = item;
+        return {
+            id: stringOrNull(row.id) ?? '',
+            key: stringOrNull(row.key) ?? undefined,
+            name: stringOrNull(row.name) ?? '',
+            type: stringOrNull(row.type) ?? 'internal',
+            membership_id: stringOrNull(row.membership_id) ?? '',
+            role: stringOrNull(row.role) ?? 'member',
+            active: row.active === true,
+        };
+    });
+}
+/** 切换当前 membership，返回新会话 token。 */
+export async function switchVpsServiceTenant(serviceBaseUrl, sessionToken, tenantId) {
+    const base = normalizeServiceRoot(serviceBaseUrl);
+    const res = await request(`${base}/v1/auth/tenant/switch`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            accept: 'application/json',
+            authorization: `Bearer ${sessionToken}`,
+            'x-vertu-auth-channel': CLI_AUTH_CHANNEL,
+            'user-agent': CLI_AUTH_CHANNEL,
+        },
+        body: JSON.stringify({ tenant_id: tenantId }),
+    });
+    const payload = parseJsonObject(await res.body.text(), res.statusCode, '切换企业');
+    const token = stringOrNull(payload.token);
+    const expiresAt = stringOrNull(payload.expires_at);
+    const user = (payload.user && typeof payload.user === 'object'
+        ? payload.user
+        : {});
+    if (!token || !expiresAt) {
+        throw new VertuError('切换企业失败：未返回 token');
+    }
+    return {
+        login: stringOrNull(user.login) ?? '',
+        token,
+        expiresAt,
+        user,
+    };
+}
+export function defaultVpsServiceLoginUrl() {
+    return DEFAULT_VPS_SERVICE_BASE_URL;
+}

package/dist/packages/vps-work/src/core/vps-service-config.js

@@ -0,0 +1,83 @@
+import { mkdir, writeFile, chmod } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { z } from 'zod';
+import { configFilePath, vpsServiceConfigFilePath } from './paths.js';
+import { readUtf8File } from '../utils/read-text.js';
+const VpsServiceConfigSchema = z.object({
+    version: z.literal(1).default(1),
+    baseUrl: z.string().url().optional(),
+    login: z.string().optional(),
+    sessionToken: z.string().optional(),
+    expiresAt: z.string().optional(),
+    agentAppId: z.string().optional(),
+    /** 代理密钥明文（文件态）；keychain 不可用的服务运行时（如 Hermes）从此处读取。 */
+    agentAppKey: z.string().optional(),
+    agentKeyExpiresAt: z.string().optional(),
+    apiKey: z.string().optional(),
+});
+export const EMPTY_VPS_SERVICE_CONFIG = { version: 1 };
+async function tryRestrictPermissions(path) {
+    if (process.platform === 'win32') {
+        return;
+    }
+    try {
+        await chmod(path, 0o600);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+async function migrateLegacySalesQueryBlock() {
+    try {
+        const raw = await readUtf8File(configFilePath());
+        const parsed = JSON.parse(raw);
+        const legacy = parsed.salesQuery;
+        if (!legacy?.baseUrl && !legacy?.apiKey) {
+            return null;
+        }
+        const migrated = {
+            version: 1,
+            baseUrl: legacy.baseUrl,
+            apiKey: legacy.apiKey,
+        };
+        await writeVpsServiceConfig(migrated);
+        const rawAgain = await readUtf8File(configFilePath());
+        const obj = JSON.parse(rawAgain);
+        if ('salesQuery' in obj) {
+            delete obj.salesQuery;
+            await writeFile(configFilePath(), `${JSON.stringify(obj, null, 2)}\n`, {
+                encoding: 'utf8',
+                mode: 0o600,
+            });
+            await tryRestrictPermissions(configFilePath());
+        }
+        return migrated;
+    }
+    catch {
+        return null;
+    }
+}
+export async function readVpsServiceConfig() {
+    const path = vpsServiceConfigFilePath();
+    try {
+        const raw = await readUtf8File(path);
+        return VpsServiceConfigSchema.parse(JSON.parse(raw));
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+        const migrated = await migrateLegacySalesQueryBlock();
+        if (migrated) {
+            return migrated;
+        }
+        return { ...EMPTY_VPS_SERVICE_CONFIG };
+    }
+}
+export async function writeVpsServiceConfig(config) {
+    const path = vpsServiceConfigFilePath();
+    await mkdir(dirname(path), { recursive: true });
+    const payload = VpsServiceConfigSchema.parse(config);
+    await writeFile(path, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await tryRestrictPermissions(path);
+}

package/dist/packages/vps-work/src/core/vps-service-http.js

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { CLI_AUTH_CHANNEL, CLI_KEYCHAIN_SERVICE } from './cli-bin.js';
+import { readVertuAgentEnvFromProcess, VERTU_ACCESS_TOKEN_ENV, VERTU_EXPECTED_USER_ID_ENV, } from './vertu-agent-env.js';
+import { vpsServiceConfigFilePath } from './paths.js';
+const KEYCHAIN_SERVICE_NAME = CLI_KEYCHAIN_SERVICE;
+const DEFAULT_VPS_SERVICE_ORIGIN = 'https://vps-service.vertu.cn';
+const HERMES_TENANT_API_HOST = 'tenant-api';
+const HERMES_TENANT_API_PORT = '8080';
+let dotenvCache = null;
+function readDotenv() {
+    if (dotenvCache) {
+        return dotenvCache;
+    }
+    const out = {};
+    dotenvCache = out;
+    return out;
+}
+function envTrim(key) {
+    const v = (process.env[key] ?? readDotenv()[key])?.trim();
+    return v || undefined;
+}
+function isVpsSessionExpired(expiresAt) {
+    if (!expiresAt) {
+        return true;
+    }
+    const parsed = Date.parse(expiresAt);
+    return !Number.isFinite(parsed) || parsed <= Date.now() + 30_000;
+}
+function isAgentKeyExpired(expiresAt) {
+    if (!expiresAt) {
+        return true;
+    }
+    const parsed = Date.parse(expiresAt);
+    return !Number.isFinite(parsed) || parsed <= Date.now() + 30_000;
+}
+function normalizeServiceRoot(url) {
+    const raw = url?.trim();
+    if (!raw) {
+        return undefined;
+    }
+    let trimmed = raw.replace(/\/+$/, '');
+    if (!/^https?:\/\//i.test(trimmed)) {
+        trimmed = `https://${trimmed}`;
+    }
+    return trimmed;
+}
+function parsedCredentialOrigin(raw) {
+    const normalized = normalizeServiceRoot(raw);
+    if (!normalized)
+        return undefined;
+    try {
+        const url = new URL(normalized);
+        const loopback = ['localhost', '127.0.0.1', '[::1]', '::1'].includes(url.hostname.toLowerCase());
+        const hermesTenantApi = url.protocol === 'http:'
+            && url.hostname.toLowerCase() === HERMES_TENANT_API_HOST
+            && url.port === HERMES_TENANT_API_PORT;
+        if (url.username || url.password || (url.protocol !== 'https:' && !(url.protocol === 'http:' && (loopback || hermesTenantApi)))) {
+            return undefined;
+        }
+        return url.origin.toLowerCase();
+    }
+    catch {
+        return undefined;
+    }
+}
+function readMacKeychainAgentKeySync(serviceBaseUrl, appId) {
+    const root = normalizeServiceRoot(serviceBaseUrl);
+    const agentAppId = appId?.trim();
+    if (process.platform !== 'darwin' || !root || !agentAppId) {
+        return undefined;
+    }
+    try {
+        const account = `vps-agent:${root}:${agentAppId}`;
+        const raw = execFileSync('security', ['find-generic-password', '-s', KEYCHAIN_SERVICE_NAME, '-a', account, '-w'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return raw.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readVpsServiceConnectionSync() {
+    const path = vpsServiceConfigFilePath();
+    if (!existsSync(path)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        const baseUrl = parsed.baseUrl?.trim() || undefined;
+        const agentAppId = parsed.agentAppId?.trim() || undefined;
+        return {
+            baseUrl,
+            sessionToken: parsed.sessionToken?.trim() || undefined,
+            expiresAt: parsed.expiresAt?.trim() || undefined,
+            agentAppId,
+            agentAppKey: parsed.agentAppKey?.trim() ||
+                readMacKeychainAgentKeySync(baseUrl, agentAppId),
+            agentKeyExpiresAt: parsed.agentKeyExpiresAt?.trim() || undefined,
+            login: parsed.login?.trim() || undefined,
+            apiKey: parsed.apiKey?.trim() || undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * 凭证只绑定到官方地址或明确配置的 HTTPS/loopback origin。
+ * 临时 `--base-url` 不会自动成为可信目标，避免把 Session/Agent Key 发往任意站点。
+ */
+export function isTrustedVpsServiceCredentialTarget(serviceBaseUrl) {
+    if (!serviceBaseUrl?.trim())
+        return true;
+    const targetOrigin = parsedCredentialOrigin(serviceBaseUrl);
+    if (!targetOrigin)
+        return false;
+    const fileCfg = readVpsServiceConnectionSync();
+    const agentEnv = readVertuAgentEnvFromProcess();
+    const configured = [
+        DEFAULT_VPS_SERVICE_ORIGIN,
+        fileCfg.baseUrl,
+        agentEnv.serviceUrl,
+        envTrim('VERTU_SALES_QUERY_URL'),
+        ...(envTrim('VERTU_VPS_SERVICE_TRUSTED_ORIGINS') ?? '').split(',').map((item) => item.trim()),
+    ];
+    const trustedOrigins = new Set(configured.map(parsedCredentialOrigin).filter((item) => Boolean(item)));
+    return trustedOrigins.has(targetOrigin);
+}
+/** vps-service 请求鉴权头（session / 智能体 key / API Key）。 */
+export function vpsServiceAuthHeaders(serviceBaseUrl) {
+    const headers = {
+        'x-vertu-auth-channel': CLI_AUTH_CHANNEL,
+        'user-agent': CLI_AUTH_CHANNEL,
+    };
+    if (!isTrustedVpsServiceCredentialTarget(serviceBaseUrl)) {
+        return headers;
+    }
+    const expectedUserId = envTrim(VERTU_EXPECTED_USER_ID_ENV);
+    if (expectedUserId && /^[1-9]\d*$/.test(expectedUserId)) {
+        headers['x-vertu-expected-user-id'] = expectedUserId;
+    }
+    const fileCfg = readVpsServiceConnectionSync();
+    const agentEnv = readVertuAgentEnvFromProcess();
+    const accessTokenEnv = envTrim(VERTU_ACCESS_TOKEN_ENV);
+    const persistedSessionToken = fileCfg.sessionToken && !isVpsSessionExpired(fileCfg.expiresAt)
+        ? fileCfg.sessionToken
+        : undefined;
+    // keychain 不可用的服务运行时（如 Hermes）从文件读取明文 agent key 作为兜底。
+    const agentAppKey = agentEnv.appKey ?? fileCfg.agentAppKey;
+    const agentAppId = agentEnv.appId ?? fileCfg.agentAppId;
+    const agentLogin = agentEnv.login ?? fileCfg.login;
+    const persistedAgentKeyValid = agentAppKey &&
+        agentAppKey.startsWith('vta_') &&
+        (!fileCfg.agentKeyExpiresAt || !isAgentKeyExpired(fileCfg.agentKeyExpiresAt));
+    const serviceApiKey = envTrim('VERTU_VPS_SERVICE_API_KEY') ?? envTrim('VERTU_SALES_QUERY_API_KEY') ?? fileCfg.apiKey;
+    if (accessTokenEnv) {
+        headers.authorization = `Bearer ${accessTokenEnv}`;
+    }
+    else if (agentEnv.appKey) {
+        // Agent/Skill hosts must not inherit a different human identity from a
+        // workstation's persisted session. Send an explicitly injected key even
+        // when malformed so authentication fails closed instead of falling back.
+        headers.authorization = `Bearer ${agentEnv.appKey}`;
+        if (agentAppId) {
+            headers['x-vertu-agent-app-id'] = agentAppId;
+        }
+        if (agentLogin) {
+            headers['x-vertu-user-login'] = encodeURIComponent(agentLogin);
+        }
+    }
+    else if (persistedSessionToken) {
+        headers.authorization = `Bearer ${persistedSessionToken}`;
+    }
+    else if (persistedAgentKeyValid) {
+        headers.authorization = `Bearer ${agentAppKey}`;
+        if (agentAppId) {
+            headers['x-vertu-agent-app-id'] = agentAppId;
+        }
+        if (agentLogin) {
+            headers['x-vertu-user-login'] = encodeURIComponent(agentLogin);
+        }
+    }
+    else if (serviceApiKey) {
+        headers.authorization = `Bearer ${serviceApiKey}`;
+    }
+    return headers;
+}

package/dist/packages/vps-work/src/utils/at-file.js

@@ -0,0 +1,34 @@
+import { VertuError } from '../core/errors.js';
+import { readStdinText, readUtf8File } from './read-text.js';
+/**
+ * Resolve the curl-style `@file` / `@-` shorthand into the actual payload string.
+ *
+ *   `@-`           → read entire process.stdin (UTF-8, BOM stripped)
+ *   `@<path>`      → read file at <path> (UTF-8, BOM stripped)
+ *   `@@<rest>`     → escape: literal value `@<rest>` (rare, but unambiguous)
+ *   anything else  → returned verbatim
+ *
+ * Why: Windows PowerShell 5.1 mangles double quotes when forwarding to a native
+ * command (Win32 `CreateProcess`), so any `--<flag> '[["a","b"]]'`-style call
+ * silently arrives at node with the inner quotes stripped. `@file` / `@-` is
+ * the universally reliable shape because the path / pipe contents never travel
+ * through the shell's argument quoter.
+ */
+export async function expandAtFileToken(token, source) {
+    if (!token.startsWith('@'))
+        return token;
+    if (token.startsWith('@@'))
+        return token.slice(1); // literal-`@` escape
+    const ref = token.slice(1);
+    if (ref.length === 0)
+        return token; // bare '@' isn't a reference; let server validate
+    try {
+        const raw = ref === '-' ? await readStdinText() : await readUtf8File(ref);
+        // Strip a single trailing newline (parity with bash `$(cat file)`); preserves
+        // the more common editor-saved-with-trailing-newline case without surprising users.
+        return raw.replace(/\r?\n$/u, '');
+    }
+    catch (err) {
+        throw new VertuError(`Cannot read ${source} ${ref}: ${err.message}`);
+    }
+}