@remixmate/cli 0.9.71 → 0.9.73

package/dist/auth/commands.js

@@ -1,290 +1,40 @@
-/**
- * `remixmate login | logout | whoami` command implementations.
- *
- * Security: the PrivToken value is never printed. Identity is shown by label only.
- * Env/CI behavior: when PRIV_TOKEN is set, `login` does not start the device flow.
- */
-import { parseArgv } from '../argv.js';
-import { resolveApiBaseUrl } from '../http.js';
-import { EXIT } from '../errors.js';
-import { getCredential, listCredentials, removeCredential } from './credential-store.js';
-import { resolvePrivToken } from './resolve.js';
-import { persistApproval, runDeviceFlow, writeAuthPrompt } from './device-flow-runner.js';
-import { openBrowser, pollForToken, requestDeviceCode, DeviceFlowError } from './device-flow.js';
-import { clearPending, getPending, setPending } from './pending-store.js';
-import { canAutoAuth, isAgentHost } from './environment.js';
-/**
- * Bounded wait used when an agent host runs `login` on the user's behalf. The
- * device code lives ~10 minutes, but an agent's tool call does not — blocking
- * that long guarantees the call is killed with nothing persisted. Stop early
- * and tell the caller it can simply re-run.
- */
-const AGENT_LOGIN_WAIT_MS = 90_000;
-/**
- * Explain, when the active backend has no credential, which backends DO have
- * one. Returns '' when there is nothing useful to add.
- *
- * Credentials are keyed by API base URL, so being "logged in" to
- * http://localhost:2999/api tells you nothing about production — but the bare
- * message ("not logged in") reads as if `login` had never been run.
- */
-async function describeOtherBackends(activeApiBaseUrl) {
-    const others = (await listCredentials()).filter((c) => c.apiBaseUrl !== activeApiBaseUrl);
-    if (others.length === 0)
-        return '';
-    const lines = others.map((c) => `     - ${c.apiBaseUrl}${c.userLabel ? `（${c.userLabel}）` : ''}`);
-    return (`ℹ️  当前后端：${activeApiBaseUrl}（无凭证）\n` +
-        `   已存储凭证的后端：\n${lines.join('\n')}\n` +
-        `   要使用其中之一，设置 MM_API_BASE_URL=<该地址>，或加 --api-base-url <该地址>。\n`);
-}
-async function login(apiBaseUrl) {
-    // Env token short-circuits the device flow (CI / agent-embedded hosts).
-    if ((process.env.PRIV_TOKEN ?? '').trim()) {
-        process.stdout.write('ℹ️  PRIV_TOKEN 环境变量已设置，CLI 将直接使用它，无需登录。\n');
-        return EXIT.OK;
-    }
-    // The device flow reads no keyboard input, so a TTY is not required — an
-    // agent host can run it and relay the link into chat. What IS required is a
-    // way to reach the user: canAutoAuth() rejects CI / headless, where a browser
-    // could never be opened and blocking would just hang the job.
-    if (!canAutoAuth()) {
-        process.stderr.write('❌ 当前环境无法完成浏览器授权（CI / 无桌面会话 / 已通过 REMIXMATE_NO_BROWSER_AUTH 关闭）。\n' +
-            '   请改用 PRIV_TOKEN 环境变量。\n');
-        return EXIT.NOT_AUTHENTICATED;
-    }
-    // Already authenticated for this backend?
-    const existing = await getCredential(apiBaseUrl);
-    if (existing) {
-        process.stdout.write(`✅ 已登录（${existing.userLabel ?? 'unknown'}）。如需切换账号请先运行 remixmate logout。\n`);
-        return EXIT.OK;
-    }
-    // A human at a terminal can wait out the device code's full lifetime; an
-    // agent tool call cannot (see AGENT_LOGIN_WAIT_MS). Progress goes to stdout.
-    const outcome = await runDeviceFlow(apiBaseUrl, {
-        write: (msg) => process.stdout.write(msg),
-        maxWaitMs: isAgentHost() ? AGENT_LOGIN_WAIT_MS : undefined,
-    });
-    switch (outcome.status) {
-        case 'approved':
-            process.stdout.write(`\n✅ 登录成功：${outcome.userLabel ?? ''}\n`);
-            process.stdout.write('🔒 安全提示：若你此前曾把 PrivToken 粘贴到聊天框或写进 shell 历史，建议在控制台轮换该 token。\n');
-            return EXIT.OK;
-        case 'denied':
-            process.stderr.write('❌ 授权被拒绝。\n');
-            return EXIT.NOT_AUTHENTICATED;
-        case 'error':
-            process.stderr.write(`❌ 登录失败：${outcome.message}\n`);
-            return EXIT.ERROR;
-        case 'timeout':
-            // The wait window closed, not the device code. Authorization may still be
-            // pending in the browser — re-running picks up the approval immediately.
-            process.stderr.write('⏳ 已打开授权页但未在等待窗口内完成。在浏览器点击确认后，重跑 remixmate login（或直接重跑原命令）即可。\n');
-            return EXIT.NOT_AUTHENTICATED;
-        case 'expired':
-        default:
-            process.stderr.write('❌ 设备码已过期或无效，请重新运行 remixmate login。\n');
-            return EXIT.NOT_AUTHENTICATED;
-    }
-}
-/** Default bound for one `login --wait` call, overridable with --timeout <seconds>. */
-const DEFAULT_WAIT_SECONDS = 60;
-/**
- * `login --start` — request a device code, persist it, print the link, return.
- *
- * Deliberately does NOT poll: the caller (an agent, or a script) gets the link
- * immediately and can surface it while the user takes as long as they need.
- * Approval is collected later by `login --wait`.
- */
-async function loginStart(apiBaseUrl, jsonOutput) {
-    const clientLabel = `remixmate-cli (${process.platform} ${process.arch})`;
-    let code;
-    try {
-        code = await requestDeviceCode(apiBaseUrl, clientLabel);
-    }
-    catch (err) {
-        const msg = err instanceof DeviceFlowError ? err.message : err.message;
-        process.stderr.write(`❌ 无法获取设备码：${msg}\n`);
-        return EXIT.BACKEND_UNREACHABLE;
-    }
-    await setPending({
-        apiBaseUrl,
-        deviceCode: code.deviceCode,
-        userCode: code.userCode,
-        verificationUri: code.verificationUri,
-        verificationUriComplete: code.verificationUriComplete,
-        interval: code.interval,
-        expiresAt: Date.now() + code.expiresIn * 1000,
-    });
-    if (jsonOutput) {
-        process.stdout.write(JSON.stringify({
-            status: 'pending',
-            apiBaseUrl,
-            verificationUri: code.verificationUri,
-            verificationUriComplete: code.verificationUriComplete ?? code.verificationUri,
-            userCode: code.userCode,
-            expiresIn: code.expiresIn,
-            // The device_code itself is intentionally omitted — `login --wait` reads
-            // it from the pending file, so it never has to travel through a log or
-            // an agent's context.
-        }) + '\n');
-    }
-    else {
-        writeAuthPrompt((m) => process.stdout.write(m), apiBaseUrl, code);
-        openBrowser(code.verificationUriComplete ?? code.verificationUri);
-        process.stdout.write('完成授权后运行 remixmate login --wait 收取凭证。\n');
-    }
-    return EXIT.OK;
-}
-/**
- * `login --wait [--timeout N]` — poll a previously started authorization for a
- * bounded window. Safe to call repeatedly until it reports approved or expired.
- */
-async function loginWait(apiBaseUrl, timeoutSeconds, jsonOutput) {
-    const emit = (payload, human, code) => {
-        if (jsonOutput)
-            process.stdout.write(JSON.stringify(payload) + '\n');
-        else
-            process.stdout.write(human);
-        return code;
-    };
-    const pending = await getPending(apiBaseUrl);
-    if (!pending) {
-        if (jsonOutput)
-            process.stdout.write(JSON.stringify({ status: 'no_pending', apiBaseUrl }) + '\n');
-        else
-            process.stderr.write(`❌ 没有进行中的授权（或已过期 / 属于别的后端）。请先运行 remixmate login --start。\n`);
-        return EXIT.NOT_AUTHENTICATED;
-    }
-    // Rebuild the shape pollForToken expects; expiresIn is the REMAINING lifetime
-    // so a resumed wait can never poll past the device code's real expiry.
-    const remainingSec = Math.max(1, Math.ceil((pending.expiresAt - Date.now()) / 1000));
-    let result;
-    try {
-        result = await pollForToken(apiBaseUrl, {
-            deviceCode: pending.deviceCode,
-            userCode: pending.userCode,
-            verificationUri: pending.verificationUri,
-            verificationUriComplete: pending.verificationUriComplete,
-            interval: pending.interval,
-            expiresIn: remainingSec,
-        }, { maxWaitMs: timeoutSeconds * 1000 });
-    }
-    catch (err) {
-        const msg = err instanceof DeviceFlowError ? err.message : err.message;
-        if (jsonOutput)
-            process.stdout.write(JSON.stringify({ status: 'error', message: msg }) + '\n');
-        else
-            process.stderr.write(`❌ 轮询失败：${msg}\n`);
-        return EXIT.BACKEND_UNREACHABLE;
-    }
-    if (result.status === 'approved' && result.privToken) {
-        await persistApproval(apiBaseUrl, result.privToken, result.userLabel, (m) => process.stdout.write(m));
-        await clearPending();
-        return emit({ status: 'approved', userLabel: result.userLabel, apiBaseUrl }, `✅ 登录成功：${result.userLabel ?? ''}\n`, EXIT.OK);
-    }
-    if (result.status === 'access_denied') {
-        await clearPending();
-        return emit({ status: 'denied' }, '❌ 授权被拒绝。\n', EXIT.NOT_AUTHENTICATED);
-    }
-    if (result.timedOut) {
-        // The wait window closed, not the device code — the pending state stays put
-        // so the caller can simply poll again.
-        return emit({ status: 'pending', apiBaseUrl, userCode: pending.userCode }, '⏳ 尚未完成授权。在浏览器确认后再次运行 remixmate login --wait。\n', EXIT.NOT_AUTHENTICATED);
-    }
-    await clearPending();
-    return emit({ status: 'expired' }, '❌ 设备码已过期，请重新运行 remixmate login --start。\n', EXIT.NOT_AUTHENTICATED);
-}
-async function logout(apiBaseUrl) {
-    // Drop any half-finished authorization too, so a later `--wait` can't redeem
-    // a device code the user just logged out of.
-    await clearPending();
-    const res = await removeCredential(apiBaseUrl);
-    const localNote = 'ℹ️  logout 仅清除本地凭证，不会在服务端吊销 PrivToken；如需服务端失效请轮换 token。\n';
-    if (!res.removedFile && !res.removedKeychain && !res.fileError && !res.keychainError) {
-        process.stdout.write('ℹ️  未找到已存储的凭证。\n');
-        return 0;
-    }
-    // Partial failure: keychain removed but file not cleared (Req 8.4), or vice versa.
-    if (res.fileError || res.keychainError) {
-        const which = res.fileError ? '本地文件' : '系统钥匙串';
-        process.stderr.write(`⚠️  凭证未完全清除：${which}清除失败（${res.fileError ?? res.keychainError}）。\n`);
-        process.stdout.write(localNote);
-        return 1;
-    }
-    process.stdout.write('✅ 已清除本地存储的凭证。\n');
-    process.stdout.write(localNote);
-    return 0;
-}
-/** Probe token validity against an existing authenticated endpoint (10s timeout). */
-async function verifyToken(apiBaseUrl, token) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 10_000);
-    try {
-        const resp = await fetch(`${apiBaseUrl}/remotionTemplate/registry`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'X-Priv-Token': token },
-            body: '{}',
-            signal: controller.signal,
-        });
-        const parsed = JSON.parse(await resp.text());
-        if (parsed.code === 0)
-            return 'valid';
-        if (parsed.code === 401)
-            return 'invalid';
-        return 'invalid';
-    }
-    catch {
-        return 'unreachable';
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-async function whoami(apiBaseUrl, flagToken) {
-    const resolved = await resolvePrivToken({ flag: flagToken, apiBaseUrl });
-    if (!resolved) {
-        process.stderr.write('❌ 未登录。运行 remixmate login，或设置 PRIV_TOKEN 环境变量。\n');
-        const hint = await describeOtherBackends(apiBaseUrl);
-        if (hint)
-            process.stderr.write(hint);
-        return EXIT.NOT_AUTHENTICATED;
-    }
-    const verdict = await verifyToken(apiBaseUrl, resolved.privToken);
-    if (verdict === 'unreachable') {
-        process.stderr.write('❌ 无法验证身份：后端不可达或超时（本地凭证未改动）。\n');
-        return EXIT.BACKEND_UNREACHABLE;
-    }
-    if (verdict === 'invalid') {
-        process.stderr.write(`❌ 凭证无效或已被吊销。来源：${resolved.source}\n`);
-        return EXIT.NOT_AUTHENTICATED;
-    }
-    const label = resolved.userLabel ?? '(已认证)';
-    process.stdout.write(`已认证：${label}\n来源：${resolved.source}\n后端：${apiBaseUrl}\n`);
-    return EXIT.OK;
-}
-/** Dispatch an auth verb. Returns a process exit code. */
-export async function runAuthCommand(verb, rest) {
-    const args = parseArgv(rest);
-    const apiBaseUrl = resolveApiBaseUrl(args.api_base_url);
-    const flagToken = args.token;
-    switch (verb) {
-        case 'login': {
-            const jsonOutput = args.json_output === true || args.json === true;
-            if (args.start === true)
-                return loginStart(apiBaseUrl, jsonOutput);
-            if (args.wait === true || typeof args.wait === 'string') {
-                const raw = Number(args.timeout);
-                const timeout = Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_WAIT_SECONDS;
-                return loginWait(apiBaseUrl, timeout, jsonOutput);
-            }
-            return login(apiBaseUrl);
-        }
-        case 'logout':
-            return logout(apiBaseUrl);
-        case 'whoami':
-            return whoami(apiBaseUrl, flagToken);
-        default:
-            process.stderr.write(`❌ unknown auth command: ${verb}\n`);
-            return EXIT.USAGE;
-    }
-}
+var f=Object.defineProperty;var c=(t,i)=>f(t,"name",{value:i,configurable:!0});import{parseArgv as w}from"../argv.js";import{resolveApiBaseUrl as T}from"../http.js";import{EXIT as n}from"../errors.js";import{getCredential as E,listCredentials as v,removeCredential as g}from"./credential-store.js";import{resolvePrivToken as A}from"./resolve.js";import{persistApproval as C,runDeviceFlow as N,writeAuthPrompt as _}from"./device-flow-runner.js";import{openBrowser as O,pollForToken as h,requestDeviceCode as I,DeviceFlowError as p}from"./device-flow.js";import{clearPending as l,getPending as y,setPending as x}from"./pending-store.js";import{canAutoAuth as U,isAgentHost as $}from"./environment.js";const b=9e4;async function D(t){const i=(await v()).filter(e=>e.apiBaseUrl!==t);if(i.length===0)return"";const r=i.map(e=>`     - ${e.apiBaseUrl}${e.userLabel?`（${e.userLabel}）`:""}`);return`ℹ️  当前后端：${t}（无凭证）
+   已存储凭证的后端：
+${r.join(`
+`)}
+   要使用其中之一，设置 MM_API_BASE_URL=<该地址>，或加 --api-base-url <该地址>。
+`}c(D,"describeOtherBackends");async function k(t){if((process.env.PRIV_TOKEN??"").trim())return process.stdout.write(`ℹ️  PRIV_TOKEN 环境变量已设置，CLI 将直接使用它，无需登录。
+`),n.OK;if(!U())return process.stderr.write(`❌ 当前环境无法完成浏览器授权（CI / 无桌面会话 / 已通过 REMIXMATE_NO_BROWSER_AUTH 关闭）。
+   请改用 PRIV_TOKEN 环境变量。
+`),n.NOT_AUTHENTICATED;const i=await E(t);if(i)return process.stdout.write(`✅ 已登录（${i.userLabel??"unknown"}）。如需切换账号请先运行 remixmate logout。
+`),n.OK;const r=await N(t,{write:c(e=>process.stdout.write(e),"write"),maxWaitMs:$()?b:void 0});switch(r.status){case"approved":return process.stdout.write(`
+✅ 登录成功：${r.userLabel??""}
+`),process.stdout.write(`🔒 安全提示：若你此前曾把 PrivToken 粘贴到聊天框或写进 shell 历史，建议在控制台轮换该 token。
+`),n.OK;case"denied":return process.stderr.write(`❌ 授权被拒绝。
+`),n.NOT_AUTHENTICATED;case"error":return process.stderr.write(`❌ 登录失败：${r.message}
+`),n.ERROR;case"timeout":return process.stderr.write(`⏳ 已打开授权页但未在等待窗口内完成。在浏览器点击确认后，重跑 remixmate login（或直接重跑原命令）即可。
+`),n.NOT_AUTHENTICATED;default:return process.stderr.write(`❌ 设备码已过期或无效，请重新运行 remixmate login。
+`),n.NOT_AUTHENTICATED}}c(k,"login");const L=60;async function H(t,i){const r=`remixmate-cli (${process.platform} ${process.arch})`;let e;try{e=await I(t,r)}catch(s){const a=(s instanceof p,s.message);return process.stderr.write(`❌ 无法获取设备码：${a}
+`),n.BACKEND_UNREACHABLE}return await x({apiBaseUrl:t,deviceCode:e.deviceCode,userCode:e.userCode,verificationUri:e.verificationUri,verificationUriComplete:e.verificationUriComplete,interval:e.interval,expiresAt:Date.now()+e.expiresIn*1e3}),i?process.stdout.write(JSON.stringify({status:"pending",apiBaseUrl:t,verificationUri:e.verificationUri,verificationUriComplete:e.verificationUriComplete??e.verificationUri,userCode:e.userCode,expiresIn:e.expiresIn})+`
+`):(_(s=>process.stdout.write(s),t,e),O(e.verificationUriComplete??e.verificationUri),process.stdout.write(`完成授权后运行 remixmate login --wait 收取凭证。
+`)),n.OK}c(H,"loginStart");async function K(t,i,r){const e=c((u,d,m)=>(r?process.stdout.write(JSON.stringify(u)+`
+`):process.stdout.write(d),m),"emit"),s=await y(t);if(!s)return r?process.stdout.write(JSON.stringify({status:"no_pending",apiBaseUrl:t})+`
+`):process.stderr.write(`❌ 没有进行中的授权（或已过期 / 属于别的后端）。请先运行 remixmate login --start。
+`),n.NOT_AUTHENTICATED;const a=Math.max(1,Math.ceil((s.expiresAt-Date.now())/1e3));let o;try{o=await h(t,{deviceCode:s.deviceCode,userCode:s.userCode,verificationUri:s.verificationUri,verificationUriComplete:s.verificationUriComplete,interval:s.interval,expiresIn:a},{maxWaitMs:i*1e3})}catch(u){const d=(u instanceof p,u.message);return r?process.stdout.write(JSON.stringify({status:"error",message:d})+`
+`):process.stderr.write(`❌ 轮询失败：${d}
+`),n.BACKEND_UNREACHABLE}return o.status==="approved"&&o.privToken?(await C(t,o.privToken,o.userLabel,u=>process.stdout.write(u)),await l(),e({status:"approved",userLabel:o.userLabel,apiBaseUrl:t},`✅ 登录成功：${o.userLabel??""}
+`,n.OK)):o.status==="access_denied"?(await l(),e({status:"denied"},`❌ 授权被拒绝。
+`,n.NOT_AUTHENTICATED)):o.timedOut?e({status:"pending",apiBaseUrl:t,userCode:s.userCode},`⏳ 尚未完成授权。在浏览器确认后再次运行 remixmate login --wait。
+`,n.NOT_AUTHENTICATED):(await l(),e({status:"expired"},`❌ 设备码已过期，请重新运行 remixmate login --start。
+`,n.NOT_AUTHENTICATED))}c(K,"loginWait");async function P(t){await l();const i=await g(t),r=`ℹ️  logout 仅清除本地凭证，不会在服务端吊销 PrivToken；如需服务端失效请轮换 token。
+`;if(!i.removedFile&&!i.removedKeychain&&!i.fileError&&!i.keychainError)return process.stdout.write(`ℹ️  未找到已存储的凭证。
+`),0;if(i.fileError||i.keychainError){const e=i.fileError?"本地文件":"系统钥匙串";return process.stderr.write(`⚠️  凭证未完全清除：${e}清除失败（${i.fileError??i.keychainError}）。
+`),process.stdout.write(r),1}return process.stdout.write(`✅ 已清除本地存储的凭证。
+`),process.stdout.write(r),0}c(P,"logout");async function R(t,i){const r=new AbortController,e=setTimeout(()=>r.abort(),1e4);try{const s=await fetch(`${t}/remotionTemplate/registry`,{method:"POST",headers:{"Content-Type":"application/json","X-Priv-Token":i},body:"{}",signal:r.signal}),a=JSON.parse(await s.text());return a.code===0?"valid":(a.code===401,"invalid")}catch{return"unreachable"}finally{clearTimeout(e)}}c(R,"verifyToken");async function S(t,i){const r=await A({flag:i,apiBaseUrl:t});if(!r){process.stderr.write(`❌ 未登录。运行 remixmate login，或设置 PRIV_TOKEN 环境变量。
+`);const a=await D(t);return a&&process.stderr.write(a),n.NOT_AUTHENTICATED}const e=await R(t,r.privToken);if(e==="unreachable")return process.stderr.write(`❌ 无法验证身份：后端不可达或超时（本地凭证未改动）。
+`),n.BACKEND_UNREACHABLE;if(e==="invalid")return process.stderr.write(`❌ 凭证无效或已被吊销。来源：${r.source}
+`),n.NOT_AUTHENTICATED;const s=r.userLabel??"(已认证)";return process.stdout.write(`已认证：${s}
+来源：${r.source}
+后端：${t}
+`),n.OK}c(S,"whoami");async function z(t,i){const r=w(i),e=T(r.api_base_url),s=r.token;switch(t){case"login":{const a=r.json_output===!0||r.json===!0;if(r.start===!0)return H(e,a);if(r.wait===!0||typeof r.wait=="string"){const o=Number(r.timeout),u=Number.isFinite(o)&&o>0?o:L;return K(e,u,a)}return k(e)}case"logout":return P(e);case"whoami":return S(e,s);default:return process.stderr.write(`❌ unknown auth command: ${t}
+`),n.USAGE}}c(z,"runAuthCommand");export{z as runAuthCommand};

package/dist/auth/credential-store.js

@@ -1,143 +1 @@
-/**
- * Local credential store for the remixmate CLI.
- *
- * Design (see .kiro/specs/cli-device-login/design.md):
- *   - File store at ~/.config/remixmate/credentials.json (mode 0600) is the
- *     REQUIRED, always-present implementation. Entries are keyed by API base
- *     URL so multiple accounts / backends coexist without overwriting.
- *   - The OS keychain is an OPTIONAL enhancement loaded via dynamic import().
- *     When a keychain module is available we keep the secret PrivToken there
- *     and store only non-secret metadata (+ a location marker) in the file.
- *     When it is absent or fails at runtime, the PrivToken is stored in the
- *     file instead. Either way the PrivToken value is never logged.
- *
- * No new runtime dependency is added: keychain support activates only if a
- * compatible module (`keytar`) is already importable in the host environment.
- */
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { promises as fs } from 'node:fs';
-export const CRED_DIR = join(homedir(), '.config', 'remixmate');
-export const CRED_FILE = join(CRED_DIR, 'credentials.json');
-const KEYCHAIN_SERVICE = 'remixmate-cli';
-let keychainProbe;
-/** Lazily attempt to load an optional keychain module; cache the (null) result. */
-async function loadKeychain() {
-    if (keychainProbe === undefined) {
-        keychainProbe = import('keytar')
-            .then((m) => (m.default ?? m))
-            .catch(() => null);
-    }
-    return keychainProbe;
-}
-async function readFileStore() {
-    try {
-        const raw = await fs.readFile(CRED_FILE, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (parsed && parsed.version === 1 && parsed.credentials) {
-            return { version: 1, credentials: parsed.credentials };
-        }
-    }
-    catch {
-        // Missing or unreadable/corrupt file → treat as empty store.
-    }
-    return { version: 1, credentials: {} };
-}
-async function writeFileStore(store) {
-    await fs.mkdir(CRED_DIR, { recursive: true, mode: 0o700 });
-    // Write with 0600 from the start, then chmod defensively in case the file
-    // pre-existed with looser permissions.
-    await fs.writeFile(CRED_FILE, JSON.stringify(store, null, 2), { mode: 0o600 });
-    await fs.chmod(CRED_FILE, 0o600);
-}
-/**
- * Persist a credential for `apiBaseUrl`. Prefers the keychain for the secret;
- * falls back to the file on absence or runtime failure. Returns whether the
- * keychain was used so callers can surface "keychain unavailable, used file".
- */
-export async function setCredential(apiBaseUrl, cred) {
-    const store = await readFileStore();
-    const entry = {
-        userLabel: cred.userLabel,
-        createdAt: cred.createdAt,
-        secret: 'file',
-        privToken: cred.privToken,
-    };
-    const keychain = await loadKeychain();
-    let usedKeychain = false;
-    let keychainError;
-    if (keychain) {
-        try {
-            await keychain.setPassword(KEYCHAIN_SERVICE, apiBaseUrl, cred.privToken);
-            usedKeychain = true;
-            entry.secret = 'keychain';
-            delete entry.privToken; // keep the secret out of the file
-        }
-        catch (err) {
-            keychainError = err.message;
-        }
-    }
-    store.credentials[apiBaseUrl] = entry;
-    await writeFileStore(store);
-    return { usedKeychain, keychainError };
-}
-/** Read a credential for `apiBaseUrl`, or null when none is stored. */
-export async function getCredential(apiBaseUrl) {
-    const store = await readFileStore();
-    const entry = store.credentials[apiBaseUrl];
-    if (!entry)
-        return null;
-    let privToken = entry.privToken;
-    if (entry.secret === 'keychain') {
-        const keychain = await loadKeychain();
-        const secret = keychain ? await keychain.getPassword(KEYCHAIN_SERVICE, apiBaseUrl) : null;
-        if (!secret)
-            return null; // secret expected in keychain but unavailable
-        privToken = secret;
-    }
-    if (!privToken)
-        return null;
-    return { privToken, userLabel: entry.userLabel, createdAt: entry.createdAt };
-}
-/**
- * List which backends have a stored credential, WITHOUT reading any secret.
- *
- * Credentials are keyed by API base URL, so "logged in" is per-backend. Without
- * this, a credential stored for a local dev backend while the CLI defaults to
- * production produced a bare "not logged in" — technically true, actively
- * misleading, and the exact confusion that motivated this work.
- */
-export async function listCredentials() {
-    const store = await readFileStore();
-    return Object.entries(store.credentials).map(([apiBaseUrl, entry]) => ({
-        apiBaseUrl,
-        userLabel: entry.userLabel,
-        createdAt: entry.createdAt,
-        secret: entry.secret,
-    }));
-}
-/** Remove a credential from both stores; reports per-store outcome. */
-export async function removeCredential(apiBaseUrl) {
-    const result = { removedFile: false, removedKeychain: false };
-    const keychain = await loadKeychain();
-    if (keychain) {
-        try {
-            result.removedKeychain = await keychain.deletePassword(KEYCHAIN_SERVICE, apiBaseUrl);
-        }
-        catch (err) {
-            result.keychainError = err.message;
-        }
-    }
-    const store = await readFileStore();
-    if (store.credentials[apiBaseUrl]) {
-        delete store.credentials[apiBaseUrl];
-        try {
-            await writeFileStore(store);
-            result.removedFile = true;
-        }
-        catch (err) {
-            result.fileError = err.message;
-        }
-    }
-    return result;
-}
+var k=Object.defineProperty;var i=(e,t)=>k(e,"name",{value:t,configurable:!0});import{homedir as v}from"node:os";import{join as y}from"node:path";import{promises as c}from"node:fs";const w=y(v(),".config","remixmate"),l=y(w,"credentials.json"),d="remixmate-cli";let u;async function f(){return u===void 0&&(u=import("keytar").then(e=>e.default??e).catch(()=>null)),u}i(f,"loadKeychain");async function o(){try{const e=await c.readFile(l,"utf8"),t=JSON.parse(e);if(t&&t.version===1&&t.credentials)return{version:1,credentials:t.credentials}}catch{}return{version:1,credentials:{}}}i(o,"readFileStore");async function h(e){await c.mkdir(w,{recursive:!0,mode:448}),await c.writeFile(l,JSON.stringify(e,null,2),{mode:384}),await c.chmod(l,384)}i(h,"writeFileStore");async function g(e,t){const r=await o(),n={userLabel:t.userLabel,createdAt:t.createdAt,secret:"file",privToken:t.privToken},a=await f();let s=!1,m;if(a)try{await a.setPassword(d,e,t.privToken),s=!0,n.secret="keychain",delete n.privToken}catch(p){m=p.message}return r.credentials[e]=n,await h(r),{usedKeychain:s,keychainError:m}}i(g,"setCredential");async function A(e){const r=(await o()).credentials[e];if(!r)return null;let n=r.privToken;if(r.secret==="keychain"){const a=await f(),s=a?await a.getPassword(d,e):null;if(!s)return null;n=s}return n?{privToken:n,userLabel:r.userLabel,createdAt:r.createdAt}:null}i(A,"getCredential");async function F(){const e=await o();return Object.entries(e.credentials).map(([t,r])=>({apiBaseUrl:t,userLabel:r.userLabel,createdAt:r.createdAt,secret:r.secret}))}i(F,"listCredentials");async function L(e){const t={removedFile:!1,removedKeychain:!1},r=await f();if(r)try{t.removedKeychain=await r.deletePassword(d,e)}catch(a){t.keychainError=a.message}const n=await o();if(n.credentials[e]){delete n.credentials[e];try{await h(n),t.removedFile=!0}catch(a){t.fileError=a.message}}return t}i(L,"removeCredential");export{w as CRED_DIR,l as CRED_FILE,A as getCredential,F as listCredentials,L as removeCredential,g as setCredential};

package/dist/auth/device-flow-runner.js

@@ -1,110 +1,13 @@
-/**
- * Shared Device Flow orchestration used by BOTH `remixmate login` (interactive,
- * full device-code lifetime) and the automatic browser auth that kicks in when
- * a skill call finds no token (bounded by a short wait window).
- *
- * Centralizing the request → open browser → poll → persist sequence keeps the
- * two entry points byte-for-byte consistent (Requirement 4.1/4.2) and means the
- * credential written by auto-login is indistinguishable from `login`'s.
- *
- * Security: the PrivToken value is NEVER written to the provided sink.
- */
-import { DeviceFlowError, openBrowser, pollForToken, requestDeviceCode, } from './device-flow.js';
-import { setCredential } from './credential-store.js';
-import { isAgentHost } from './environment.js';
-/**
- * Machine-readable authorization event, emitted alongside the human text when
- * an agent host is driving the CLI. Delimited by markers (rather than a bare
- * JSON line) because a skill's own stdout/stderr is interleaved on the same
- * stream — the host greps for the block, never for prose that may be reworded.
- */
-const AUTH_BLOCK_OPEN = '<<REMIXMATE_AUTH_REQUIRED';
-const AUTH_BLOCK_CLOSE = 'REMIXMATE_AUTH_REQUIRED>>';
-export function renderAuthBlock(apiBaseUrl, code) {
-    const payload = {
-        apiBaseUrl,
-        verificationUri: code.verificationUri,
-        verificationUriComplete: code.verificationUriComplete ?? code.verificationUri,
-        userCode: code.userCode,
-        expiresIn: code.expiresIn,
-    };
-    return `${AUTH_BLOCK_OPEN}\n${JSON.stringify(payload)}\n${AUTH_BLOCK_CLOSE}\n`;
-}
-/**
- * Emit the authorization prompt: a one-click link (device code pre-filled),
- * the manual fallback, and — for agent hosts — the machine-readable block.
- * Shared by `runDeviceFlow` and `login --start` so both entry points present
- * authorization identically.
- */
-export function writeAuthPrompt(write, apiBaseUrl, code) {
-    const openUrl = code.verificationUriComplete ?? code.verificationUri;
-    write(`\n🔐 需要授权 remixmate CLI，请在浏览器中打开：\n  ${openUrl}\n`);
-    if (code.verificationUriComplete) {
-        write(`（若链接无法打开：访问 ${code.verificationUri} 并输入设备码 ${code.userCode}）\n`);
-    }
-    write('\n');
-    if (isAgentHost())
-        write(renderAuthBlock(apiBaseUrl, code));
-}
-function nowSec() {
-    return Math.floor(Date.now() / 1000);
-}
-/**
- * Persist an approved PrivToken. Shared by `runDeviceFlow` and `login --wait`
- * so a credential written by either is indistinguishable. The token value is
- * never written to `write`.
- */
-export async function persistApproval(apiBaseUrl, privToken, userLabel, write) {
-    const { usedKeychain, keychainError } = await setCredential(apiBaseUrl, {
-        privToken,
-        userLabel,
-        createdAt: nowSec(),
-    });
-    if (!usedKeychain && keychainError) {
-        write('（系统钥匙串不可用，凭证已写入受保护的本地文件 ~/.config/remixmate/credentials.json）\n');
-    }
-}
-/**
- * Run one full Device Flow against `apiBaseUrl`. On approval the PrivToken is
- * persisted via setCredential (keychain or file, same as `login`) and only the
- * non-secret outcome is returned.
- */
-export async function runDeviceFlow(apiBaseUrl, opts = {}) {
-    const write = opts.write ?? ((msg) => process.stderr.write(msg));
-    const clientLabel = opts.clientLabel ?? `remixmate-cli (${process.platform} ${process.arch})`;
-    try {
-        const code = await requestDeviceCode(apiBaseUrl, clientLabel);
-        // The backend pre-fills the user code into verificationUriComplete, so the
-        // user only has to click and confirm. Lead with that link — asking someone
-        // to open a bare URL and transcribe a device code is a different (much
-        // higher) difficulty tier, and the whole point is that a non-technical user
-        // never has to touch a terminal.
-        const openUrl = code.verificationUriComplete ?? code.verificationUri;
-        // Always print the link, even when the browser auto-opens, so a host
-        // (Claude Code / Codex) can relay it into the chat.
-        writeAuthPrompt(write, apiBaseUrl, code);
-        if (openBrowser(openUrl)) {
-            write('已尝试自动打开浏览器…\n');
-        }
-        else {
-            write('无法自动打开浏览器，请手动复制上面的链接。\n');
-        }
-        write('等待授权中（可在浏览器确认）…\n');
-        const result = await pollForToken(apiBaseUrl, code, { maxWaitMs: opts.maxWaitMs });
-        if (result.status === 'approved' && result.privToken) {
-            await persistApproval(apiBaseUrl, result.privToken, result.userLabel, write);
-            return { status: 'approved', userLabel: result.userLabel };
-        }
-        if (result.status === 'access_denied')
-            return { status: 'denied' };
-        if (result.timedOut)
-            return { status: 'timeout' };
-        return { status: 'expired' };
-    }
-    catch (err) {
-        if (err instanceof DeviceFlowError) {
-            return { status: 'error', message: err.message };
-        }
-        throw err;
-    }
-}
+var c=Object.defineProperty;var o=(r,t)=>c(r,"name",{value:t,configurable:!0});import{DeviceFlowError as u,openBrowser as f,pollForToken as p,requestDeviceCode as l}from"./device-flow.js";import{setCredential as m}from"./credential-store.js";import{isAgentHost as v}from"./environment.js";const U="<<REMIXMATE_AUTH_REQUIRED",C="REMIXMATE_AUTH_REQUIRED>>";function x(r,t){const e={apiBaseUrl:r,verificationUri:t.verificationUri,verificationUriComplete:t.verificationUriComplete??t.verificationUri,userCode:t.userCode,expiresIn:t.expiresIn};return`${U}
+${JSON.stringify(e)}
+${C}
+`}o(x,"renderAuthBlock");function E(r,t,e){const s=e.verificationUriComplete??e.verificationUri;r(`
+🔐 需要授权 remixmate CLI，请在浏览器中打开：
+  ${s}
+`),e.verificationUriComplete&&r(`（若链接无法打开：访问 ${e.verificationUri} 并输入设备码 ${e.userCode}）
+`),r(`
+`),v()&&r(x(t,e))}o(E,"writeAuthPrompt");function d(){return Math.floor(Date.now()/1e3)}o(d,"nowSec");async function w(r,t,e,s){const{usedKeychain:i,keychainError:a}=await m(r,{privToken:t,userLabel:e,createdAt:d()});!i&&a&&s(`（系统钥匙串不可用，凭证已写入受保护的本地文件 ~/.config/remixmate/credentials.json）
+`)}o(w,"persistApproval");async function h(r,t={}){const e=t.write??(i=>process.stderr.write(i)),s=t.clientLabel??`remixmate-cli (${process.platform} ${process.arch})`;try{const i=await l(r,s),a=i.verificationUriComplete??i.verificationUri;E(e,r,i),f(a)?e(`已尝试自动打开浏览器…
+`):e(`无法自动打开浏览器，请手动复制上面的链接。
+`),e(`等待授权中（可在浏览器确认）…
+`);const n=await p(r,i,{maxWaitMs:t.maxWaitMs});return n.status==="approved"&&n.privToken?(await w(r,n.privToken,n.userLabel,e),{status:"approved",userLabel:n.userLabel}):n.status==="access_denied"?{status:"denied"}:n.timedOut?{status:"timeout"}:{status:"expired"}}catch(i){if(i instanceof u)return{status:"error",message:i.message};throw i}}o(h,"runDeviceFlow");export{w as persistApproval,x as renderAuthBlock,h as runDeviceFlow,E as writeAuthPrompt};