@shawnstack/quickforge 1.7.6 → 1.7.8

package/server/auto-archive.mjs

@@ -1,8 +1,8 @@
-import { atomicSessionValueUpdate, atomicUpdate, readSessionValue, readStore } from './storage.mjs'
+import { atomicSessionValueUpdate, atomicUpdate, atomicSessionRecordUpdate, isSessionStateAuthoritative, readSessionValue, readStore } from './storage.mjs'
 import { logger } from './utils/logger.mjs'
 import { withSessionPersistenceLock } from './session-persistence-lock.mjs'
 
-const defaultStorage = { atomicSessionValueUpdate, atomicUpdate, readSessionValue, readStore }
+const defaultStorage = { atomicSessionValueUpdate, atomicUpdate, atomicSessionRecordUpdate, readSessionValue, readStore, isSessionStateAuthoritative }
 
 export const AUTO_ARCHIVE_SETTINGS_KEY = 'auto-archive-settings'
 export const AUTO_ARCHIVE_AFTER_MS = 30 * 24 * 60 * 60 * 1000
@@ -75,35 +75,48 @@ async function archiveInactiveSessionsUnlocked(options = {}) {
   }
 
   const archivedSessionIds = []
-  for (const sessionId of candidates) {
-    const updatedSession = await storage.atomicSessionValueUpdate(sessionId, (session) => {
-      const activityTime = sessionActivityTime(session)
-      if (session.archivedAt || activityTime === null || activityTime >= cutoff) return session
-      return { ...session, archivedAt }
-    })
-    if (!updatedSession || updatedSession.archivedAt !== archivedAt) continue
-
-    let metadataArchived = false
-    await storage.atomicUpdate('sessions-metadata', (current) => {
-      const metadata = current[sessionId]
-      const activityTime = sessionActivityTime(metadata, updatedSession)
-      if (!metadata || metadata.archivedAt || metadata.messageCount === 0 || metadata.taskStatus === 'running' || activityTime === null || activityTime >= cutoff) {
+  if (typeof storage.atomicSessionRecordUpdate === 'function' && await storage.isSessionStateAuthoritative()) {
+    // Authoritative: archive body + metadata in one SQLite transaction (CAS
+    // retried on concurrent metadata-only changes), so no half-archived state.
+    for (const sessionId of candidates) {
+      const updated = await storage.atomicSessionRecordUpdate(sessionId, ({ state, metadata }) => {
+        const activityTime = sessionActivityTime(metadata, state)
+        if (state.archivedAt || metadata.archivedAt || metadata.messageCount === 0 || metadata.taskStatus === 'running' || activityTime === null || activityTime >= cutoff) return null
+        return { state: { ...state, archivedAt }, metadata: { ...metadata, archivedAt } }
+      })
+      if (updated?.state?.archivedAt === archivedAt) archivedSessionIds.push(sessionId)
+    }
+  } else {
+    for (const sessionId of candidates) {
+      const updatedSession = await storage.atomicSessionValueUpdate(sessionId, (session) => {
+        const activityTime = sessionActivityTime(session)
+        if (session.archivedAt || activityTime === null || activityTime >= cutoff) return session
+        return { ...session, archivedAt }
+      })
+      if (!updatedSession || updatedSession.archivedAt !== archivedAt) continue
+
+      let metadataArchived = false
+      await storage.atomicUpdate('sessions-metadata', (current) => {
+        const metadata = current[sessionId]
+        const activityTime = sessionActivityTime(metadata, updatedSession)
+        if (!metadata || metadata.archivedAt || metadata.messageCount === 0 || metadata.taskStatus === 'running' || activityTime === null || activityTime >= cutoff) {
+          return current
+        }
+        current[sessionId] = { ...metadata, archivedAt }
+        metadataArchived = true
         return current
-      }
-      current[sessionId] = { ...metadata, archivedAt }
-      metadataArchived = true
-      return current
-    })
-
-    if (metadataArchived) {
-      archivedSessionIds.push(sessionId)
-    } else {
-      await storage.atomicSessionValueUpdate(sessionId, (session) => {
-        if (session.archivedAt !== archivedAt) return session
-        const next = { ...session }
-        delete next.archivedAt
-        return next
       })
+
+      if (metadataArchived) {
+        archivedSessionIds.push(sessionId)
+      } else {
+        await storage.atomicSessionValueUpdate(sessionId, (session) => {
+          if (session.archivedAt !== archivedAt) return session
+          const next = { ...session }
+          delete next.archivedAt
+          return next
+        })
+      }
     }
   }
 

package/server/auto-compaction.mjs

@@ -175,6 +175,46 @@ export function buildAutoCompactLoopMessages(session, messages) {
   return [summaryMessage, ...source.slice(tailStart)]
 }
 
+function messageTimestampMs(message) {
+  const value = message?.timestamp
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string') {
+    const parsed = Date.parse(value)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return 0
+}
+
+function minimumProviderUsageIndex(session, messages) {
+  if (!session?.contextCompaction?.summaryMessage) return 0
+  const source = Array.isArray(messages) ? messages : []
+  const compactedUpToIndex = Math.min(source.length, Math.max(0, Number(session.contextCompaction.compactedUpToIndex) || 0))
+  let tailStart = compactedUpToIndex
+  while (tailStart < source.length && isToolResultMessage(source[tailStart])) tailStart += 1
+
+  const compactedAt = Date.parse(session.contextCompaction.compactedAt || '')
+  if (Number.isFinite(compactedAt)) {
+    const firstNewMessageIndex = source.findIndex((message) => messageTimestampMs(message) > compactedAt)
+    if (firstNewMessageIndex >= 0) return Math.max(1, firstNewMessageIndex - tailStart + 1)
+  }
+
+  const sourceMessageCount = Number(session.contextCompaction.sourceMessageCount)
+  if (Number.isFinite(sourceMessageCount) && sourceMessageCount > 0 && source.length >= sourceMessageCount) {
+    return Math.max(1, sourceMessageCount - tailStart + 1)
+  }
+  return source.length - tailStart + 1
+}
+
+export function hasNewMessagesSinceCompaction(session, messages) {
+  if (!session?.contextCompaction?.summaryMessage) return true
+  const source = Array.isArray(messages) ? messages : []
+  const sourceMessageCount = Number(session.contextCompaction.sourceMessageCount)
+  if (Number.isFinite(sourceMessageCount) && sourceMessageCount > 0 && source.length > sourceMessageCount) return true
+
+  const compactedAt = Date.parse(session.contextCompaction.compactedAt || '')
+  return Number.isFinite(compactedAt) && source.some((message) => messageTimestampMs(message) > compactedAt)
+}
+
 export async function compactSessionInPlace({
   session,
   messages,
@@ -308,6 +348,7 @@ export function estimateSessionContextUsage(session, messages = session?.agent?.
     messages: loopMessages,
     tools: session.agent.state.tools,
     model: session.model,
+    minimumProviderUsageIndex: minimumProviderUsageIndex(session, sourceMessages),
   })
   value.isCompacted = loopMessages !== sourceMessages
   value.originalMessageCount = sourceMessages.length
@@ -332,6 +373,7 @@ export async function maybeAutoCompactSession({ session, messages, signal, emitS
     messages: loopMessages,
     tools: session.agent.state.tools,
     model: session.model,
+    minimumProviderUsageIndex: minimumProviderUsageIndex(session, messages),
   })
   if (!usage.contextWindow) return { compacted: false, usage, reason: 'missing_context_window' }
   if (!shouldCompactContextByPercent(usage, settings.thresholdPercent)) return { compacted: false, usage, reason: 'below_threshold' }
@@ -341,7 +383,7 @@ export async function maybeAutoCompactSession({ session, messages, signal, emitS
   if (session.lastAutoCompactAt && now - session.lastAutoCompactAt < AUTO_COMPACT_MIN_INTERVAL_MS) {
     return { compacted: false, usage, reason: 'recently_compacted' }
   }
-  if (session.contextCompaction?.sourceMessageCount && messages.length <= session.contextCompaction.sourceMessageCount + 2) {
+  if (!hasNewMessagesSinceCompaction(session, messages)) {
     return { compacted: false, usage, reason: 'not_enough_new_messages' }
   }
 

package/server/cloud/auto-approval.mjs

@@ -0,0 +1,155 @@
+// 短时、一次性的远程 Agent 自动批准意图（仅内存态）。
+//
+// 安全边界：
+// - 意图（arm）仅在两种情况下创建：① 本机用户在 Cloud 设置页显式将服务从
+//   disabled 切换为 enabled 时由 routes/cloud.mjs 创建；② qf-agent 首次进入
+//   authorizing 且当前无有效意图（none/expired）时，由 qf-agent-process 在
+//   “本机生命周期启动 + 本机存在有效 desktop 云会话”时自动创建
+//   （见 beginAgentAutoApprovalWithDesktopSession）。
+// - 认证远程客户端（非本机请求）触发的云服务开关切换/配置变更以
+//   autoApprovalPolicy: 'manual' 启动 agent，该生命周期内（含其自动重启）
+//   不会自动创建意图，也不会自动批准，仍需本机操作。
+// - 意图绝不落盘：不写 agent identity，也不触碰 storage/security/cloud-identity.json。
+// - user_code 只在 Node 内存中流转，用于调用云端 authorize API，不进入公开状态；
+//   desktop Access Token 仅由 CloudIdentityManager 内存持有并注入请求，不复制、不暴露。
+// - 一次性：意图只批准第一个捕获的 user_code；成功后即消耗，失败需显式重试。
+import { CloudApiError } from './client.mjs'
+import { getCloudRuntime } from './runtime.mjs'
+
+export const AGENT_AUTO_APPROVAL_TTL_MS = 10 * 60_000
+
+let intent = null // { expiresAt, status: 'armed'|'pending'|'consumed'|'failed', userCode, error }
+let inflight = null
+
+function safeErrorText(value) {
+  const text = String(value?.message || value || '').trim()
+  if (!text) return null
+  return text
+    .replace(/\bBearer\s+\S+/gi, 'Bearer [redacted]')
+    .replace(/\b(token|secret|password|api[_-]?key|private[_-]?key)\s*[:=]\s*\S+/gi, '$1=[redacted]')
+    .replace(/https?:\/\/\S+/gi, '[url]')
+    .slice(0, 300)
+}
+
+// 返回公开可展示的意图状态；不包含 user_code、token 或身份信息。
+export function getAgentAutoApprovalState({ now = Date.now() } = {}) {
+  if (!intent) return { status: 'none' }
+  if (Number(intent.expiresAt) <= now) return { status: 'expired' }
+  if (intent.status === 'failed') return { status: 'failed', error: intent.error }
+  return { status: intent.status }
+}
+
+export function armAgentAutoApproval({ ttlMs = AGENT_AUTO_APPROVAL_TTL_MS, now = Date.now() } = {}) {
+  intent = {
+    expiresAt: now + Math.max(1_000, Number(ttlMs) || AGENT_AUTO_APPROVAL_TTL_MS),
+    status: 'armed',
+    userCode: null,
+    error: null,
+  }
+  inflight = null
+  return getAgentAutoApprovalState({ now })
+}
+
+export function clearAgentAutoApproval() {
+  intent = null
+  inflight = null
+}
+
+// 默认执行器：复用桌面端 CloudIdentityManager.withAccessToken 调云端固定接口
+// POST /v1/remote/agents/authorize，Bearer desktop access token，body { userCode }。
+export async function defaultAuthorizeAgent(userCode, { signal } = {}) {
+  const runtime = await getCloudRuntime()
+  if (!runtime?.identity || !runtime?.client) {
+    throw new CloudApiError('QuickForge Cloud is not connected.', { status: 401, code: 'cloud_not_connected' })
+  }
+  return runtime.identity.withAccessToken((token) => runtime.client.authorizeRemoteAgent(token, userCode, signal), { signal })
+}
+
+// qf-agent 进入 authorizing 并捕获 user_code 时调用；意图未 armed/已过期/已处理时跳过。
+// 并发去重：同一意图在途调用合并为同一个 Promise；一次性消费由状态机保证。
+export function beginAgentAutoApproval(userCode, { now = Date.now(), authorize = defaultAuthorizeAgent } = {}) {
+  const state = getAgentAutoApprovalState({ now })
+  if (state.status === 'none' || state.status === 'expired' || state.status === 'consumed' || state.status === 'failed') {
+    return Promise.resolve({ status: state.status, error: state.error })
+  }
+  if (intent.status === 'armed') {
+    const code = String(userCode || '').trim()
+    if (!code) return Promise.resolve({ status: 'skipped' })
+    intent.status = 'pending'
+    intent.userCode = code
+  }
+  if (inflight) return inflight
+  const activeIntent = intent
+  inflight = (async () => {
+    try {
+      const response = await authorize(activeIntent.userCode)
+      if (response && typeof response === 'object' && response.ok !== true) {
+        throw new CloudApiError('QuickForge Cloud did not confirm the agent authorization.', { code: 'invalid_authorize_response' })
+      }
+      if (intent === activeIntent) activeIntent.status = 'consumed'
+      return { status: 'consumed' }
+    } catch (error) {
+      const errorText = safeErrorText(error)
+      if (intent === activeIntent) {
+        activeIntent.status = 'failed'
+        activeIntent.error = errorText
+      }
+      return { status: 'failed', error: errorText }
+    } finally {
+      if (intent === activeIntent) inflight = null
+    }
+  })()
+  return inflight
+}
+
+// 仅允许对 failed 意图重试（保留原 user_code，用户无需打开授权页/输入码）。
+export function retryAgentAutoApproval({ now = Date.now(), authorize = defaultAuthorizeAgent } = {}) {
+  if (!intent || intent.status !== 'failed') {
+    return Promise.resolve(getAgentAutoApprovalState({ now }))
+  }
+  intent.status = 'pending'
+  return beginAgentAutoApproval(intent.userCode, { now, authorize })
+}
+
+// 默认 desktop 会话检查：runtime 已配置 identity，且本地凭据公开状态含有效
+// Session（hasSession）并未绑定到其他 Cloud URL（无 sessionServiceMismatch）。
+// 只读公开状态，不触发 refresh，也不发起网络请求。
+async function defaultHasDesktopSession() {
+  try {
+    const runtime = await getCloudRuntime()
+    if (!runtime?.identity) return false
+    const status = await runtime.identity.status()
+    return Boolean(status?.hasSession) && status?.sessionServiceMismatch !== true
+  } catch {
+    return false
+  }
+}
+
+// qf-agent 首次进入 authorizing 且无有效意图（begin 返回 none/expired）时调用：
+// 由本机生命周期启动（policy !== 'manual'）且存在有效 desktop 云会话时，自动
+// 创建同样短时、一次性的意图并立即尝试批准；否则保持原有状态。已有
+// armed/pending/consumed/failed 意图时直接返回现有结果，不重复 arm。
+export async function beginAgentAutoApprovalWithDesktopSession(userCode, {
+  policy = 'auto',
+  now = Date.now(),
+  authorize = defaultAuthorizeAgent,
+  hasDesktopSession = defaultHasDesktopSession,
+} = {}) {
+  const first = await beginAgentAutoApproval(userCode, { now, authorize })
+  if (first.status !== 'none' && first.status !== 'expired') return first
+  if (policy === 'manual') return first
+  let eligible = false
+  try {
+    eligible = (await hasDesktopSession()) === true
+  } catch {
+    // 会话检查失败视为无有效 desktop 会话，不自动 arm
+  }
+  if (!eligible) return first
+  armAgentAutoApproval({ now })
+  return beginAgentAutoApproval(userCode, { now, authorize })
+}
+
+export function resetAgentAutoApprovalForTests() {
+  intent = null
+  inflight = null
+}

package/server/cloud/client.mjs

@@ -90,6 +90,11 @@ export class CloudClient {
   revokeInstallation(token, installationId, signal) {
     return this.request(`v1/installations/${encodeURIComponent(installationId)}`, { method: 'DELETE', token, signal })
   }
+  authorizeRemoteAgent(token, userCode, signal) {
+    return this.request('v1/remote/agents/authorize', {
+      method: 'POST', token, body: { userCode }, signal,
+    })
+  }
   chat(token, payload, idempotencyKey, signal) {
     return this.request('v1/chat/completions', {
       method: 'POST', token, body: payload,

package/server/cloud/config.mjs

@@ -1,14 +1,9 @@
-import net from 'node:net'
-
 const DEFAULT_TIMEOUT_MS = 10_000
 
-function isLoopbackHost(hostname) {
-  const host = String(hostname || '').toLowerCase().replace(/^\[|\]$/g, '')
-  if (host === 'localhost' || host.endsWith('.localhost')) return true
-  const ip = net.isIP(host)
-  if (ip === 4) return host.startsWith('127.')
-  if (ip === 6) return host === '::1' || host === '0:0:0:0:0:0:0:1'
-  return false
+function invalidUrl(message) {
+  const error = new Error(message)
+  error.statusCode = 400
+  return error
 }
 
 export function parseCloudBaseUrl(value, _options = {}) {
@@ -19,19 +14,16 @@ export function parseCloudBaseUrl(value, _options = {}) {
   try {
     url = new URL(raw)
   } catch {
-    throw new Error('QUICKFORGE_CLOUD_URL must be a valid URL.')
+    throw invalidUrl('QuickForge Cloud URL must be a valid URL.')
   }
 
   if (url.username || url.password || url.search || url.hash) {
-    throw new Error('QUICKFORGE_CLOUD_URL must not contain credentials, query parameters, or fragments.')
+    throw invalidUrl('QuickForge Cloud URL must not contain credentials, query parameters, or fragments.')
   }
   if (url.protocol !== 'https:' && url.protocol !== 'http:') {
-    throw new Error('QUICKFORGE_CLOUD_URL must use http or https.')
-  }
-  if (url.protocol === 'http:' && !isLoopbackHost(url.hostname)) {
-    throw new Error('QUICKFORGE_CLOUD_URL over HTTP is only allowed for loopback hosts.')
+    throw invalidUrl('QuickForge Cloud URL must use http or https.')
   }
-  if (url.pathname.includes('..')) throw new Error('QUICKFORGE_CLOUD_URL contains an unsafe path.')
+  if (url.pathname.includes('..')) throw invalidUrl('QuickForge Cloud URL contains an unsafe path.')
   url.pathname = `${url.pathname.replace(/\/+$/, '')}/`
   return url
 }

package/server/cloud/qf-agent-process.mjs

@@ -3,6 +3,8 @@ import { chmodSync, existsSync, promises as fs, statSync } from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { dataDir } from '../storage.mjs'
+import { getNetworkProxyConfig } from '../network-proxy.mjs'
+import { beginAgentAutoApprovalWithDesktopSession, clearAgentAutoApproval, getAgentAutoApprovalState } from './auto-approval.mjs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -26,6 +28,7 @@ let stopPromise = null
 let lifecycleGeneration = 0
 let versionCheckChild = null
 let launchOptions = null
+let identityInvalidation = null
 let status = createStatus()
 
 function createStatus(overrides = {}) {
@@ -239,6 +242,27 @@ function safeVerificationUrl(value) {
   }
 }
 
+// 从 qf-agent 结构化日志安全提取一次性授权 user_code：优先 record.userCode/user_code，
+// 否则从 verificationUriComplete（兼容 verificationUri）的 query 参数提取。
+// 仅用于服务端自动批准流程，绝不进入公开 qf-agent 状态。
+export function extractUserCodeFromVerification(record) {
+  if (!record || typeof record !== 'object') return null
+  const direct = record.userCode ?? record.user_code
+  if (typeof direct === 'string' && direct.trim()) return direct.trim().slice(0, 64)
+  const raw = record.verificationUriComplete ?? record.verificationUri
+  if (typeof raw !== 'string' || !raw.trim()) return null
+  try {
+    const url = new URL(raw)
+    for (const key of ['user_code', 'userCode', 'code']) {
+      const value = url.searchParams.get(key)
+      if (typeof value === 'string' && value.trim()) return value.trim().slice(0, 64)
+    }
+  } catch {
+    // 非 URL 视为无效，不自动批准
+  }
+  return null
+}
+
 export function parseQfAgentLogLine(line) {
   const text = String(line || '').trim()
   if (!text) return null
@@ -255,6 +279,8 @@ export function parseQfAgentLogLine(line) {
   if (message.includes('等待设备授权')) {
     result.status = 'authorizing'
     result.verificationUriComplete = safeVerificationUrl(record.verificationUriComplete)
+    const userCode = extractUserCodeFromVerification(record)
+    if (userCode) result.userCode = userCode
   } else if (message.includes('信令已连接')) {
     result.status = 'running'
     result.verificationUriComplete = null
@@ -264,9 +290,112 @@ export function parseQfAgentLogLine(line) {
 
   const level = String(record.level || record.severity || '').toLowerCase()
   if (['error', 'fatal', 'panic'].includes(level)) result.error = safeErrorMessage(message) || 'qf-agent reported an error.'
+  if (isIdentityInvalidationRecord(record)) result.identityInvalidated = true
   return Object.keys(result).length ? result : null
 }
 
+const IDENTITY_INVALIDATION_MARKERS = [
+  'invalid_refresh_token',
+  'refresh_token_reused',
+  'installation_revoked',
+  'refresh token 已失效',
+]
+
+// 仅在结构化 warn/error/fatal/panic 日志中识别身份失效错误码与既有终态提示；
+// 普通文本、info 日志或无关 warning/error 不会触发。
+export function isIdentityInvalidationRecord(record) {
+  if (!record || typeof record !== 'object') return false
+  const level = String(record.level || record.severity || '').toLowerCase()
+  if (!['warn', 'error', 'fatal', 'panic'].includes(level)) return false
+  const fields = [record.msg, record.message, record.error, record.err]
+  if (!fields.some((value) => typeof value === 'string')) return false
+  const haystack = fields.filter((value) => typeof value === 'string').join('\n')
+  return IDENTITY_INVALIDATION_MARKERS.some((marker) => haystack.includes(marker))
+}
+
+// 仅当 QuickForge 配置为 manual 且 proxyUrl 非空时返回注入给 qf-agent 的代理 env；
+// NO_PROXY 保留父进程已有条目并至少加入回环地址与 serverUrl 主机名。
+export function buildQfAgentProxyEnv(serverUrl, config, env = process.env) {
+  if (!config || config.mode !== 'manual' || !config.proxyUrl) return null
+  let hostname = null
+  try {
+    hostname = new URL(serverUrl).hostname
+  } catch {
+    // serverUrl 非法时保持 null，不向 NO_PROXY 追加主机名
+  }
+  const existing = new Set()
+  for (const key of ['NO_PROXY', 'no_proxy']) {
+    const value = typeof env?.[key] === 'string' ? env[key] : ''
+    for (const item of value.split(',')) {
+      const trimmed = item.trim()
+      if (trimmed) existing.add(trimmed)
+    }
+  }
+  const parts = ['localhost', '127.0.0.1', '::1']
+  if (hostname) parts.push(hostname)
+  for (const item of existing) {
+    if (!parts.includes(item)) parts.push(item)
+  }
+  return {
+    HTTP_PROXY: config.proxyUrl,
+    HTTPS_PROXY: config.proxyUrl,
+    ALL_PROXY: config.proxyUrl,
+    NO_PROXY: parts.join(','),
+  }
+}
+
+async function resolveProxyEnvironment(serverUrl) {
+  try {
+    const { config } = await getNetworkProxyConfig()
+    return buildQfAgentProxyEnv(serverUrl, config, process.env)
+  } catch {
+    return null
+  }
+}
+
+// 仅清理当前 runtime 专属 identityDir/identity.json，绝不触碰
+// storage/security/cloud-identity.json。优先 rename 到同目录临时 invalid 文件并尽快删除；
+// Windows EPERM 安全 fallback unlink；ENOENT 幂等；只处理普通文件，不跟随 symlink。
+async function isolateInvalidIdentity(identityDir) {
+  const file = path.join(identityDir, 'identity.json')
+  let stat
+  try {
+    stat = await fs.lstat(file)
+  } catch (error) {
+    if (error?.code === 'ENOENT') return
+    throw error
+  }
+  if (!stat.isFile()) return
+  const invalidFile = `${file}.invalid-${process.pid}-${Date.now()}`
+  try {
+    await fs.rename(file, invalidFile)
+  } catch (error) {
+    if (error?.code === 'ENOENT') return
+    if (error?.code !== 'EPERM') throw error
+    try {
+      await fs.unlink(file)
+    } catch (unlinkError) {
+      if (unlinkError?.code !== 'ENOENT') throw unlinkError
+    }
+    return
+  }
+  try {
+    await fs.unlink(invalidFile)
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error
+  }
+}
+
+// 命中身份失效后每 lifecycle 至多一次：标记身份重置、设置可操作状态并主动终止子进程。
+function handleIdentityInvalidation(activeChild, generation, identityDir) {
+  if (!isCurrentLifecycle(generation) || identityInvalidation?.generation === generation) return
+  identityInvalidation = { generation, identityDir }
+  setStatus({ status: 'authorizing', verificationUriComplete: null, error: null })
+  if (activeChild && child === activeChild) {
+    void terminateChild(activeChild).catch(() => {})
+  }
+}
+
 function consumeLines(stream, onLine) {
   let buffered = ''
   stream?.setEncoding('utf8')
@@ -410,6 +539,7 @@ async function launchQfAgent(generation) {
 
   let spawned
   try {
+    const proxyEnv = await resolveProxyEnvironment(serverUrl)
     spawned = spawn(executable, [], {
       windowsHide: true,
       shell: false,
@@ -420,6 +550,7 @@ async function launchQfAgent(generation) {
         QF_CLOUD_AGENT_DATA_DIR: identityDir,
         QF_CLOUD_AGENT_QF_URL: serverUrl,
         QF_CLOUD_AGENT_OWNER_PID: String(ownerPid),
+        ...(proxyEnv || {}),
       },
     })
     await new Promise((resolve, reject) => {
@@ -439,11 +570,24 @@ async function launchQfAgent(generation) {
     child = null
     childStartedAt = 0
     if (stableRun) restartCount = 0
-    void clearOwnLock().then(() => {
+    const invalid = identityInvalidation?.generation === generation ? identityInvalidation : null
+    if (invalid) identityInvalidation = null
+    void clearOwnLock().then(async () => {
       if (!isCurrentLifecycle(generation)) {
         setStatus({ status: 'stopped', pid: null, verificationUriComplete: null })
         return
       }
+      if (invalid) {
+        try {
+          await isolateInvalidIdentity(invalid.identityDir)
+        } catch {
+          // 隔离失败：保留重启计数，由 MAX_CONSECUTIVE_RESTARTS 兜底约束重试
+        }
+        if (!isCurrentLifecycle(generation)) return
+        // 无论隔离是否成功都不重置 restartCount：若新身份仍被云端拒绝，
+        // 重启预算逐次消耗至 MAX_CONSECUTIVE_RESTARTS 停止，避免隔离清零导致无界循环；
+        // 稳定运行（STABLE_RUN_MS）仍是唯一自然重置边界。
+      }
       scheduleRestart(generation)
     }).catch(() => {
       if (isCurrentLifecycle(generation)) scheduleRestart(generation)
@@ -453,7 +597,15 @@ async function launchQfAgent(generation) {
   const onLine = (line) => {
     if (!isCurrentLifecycle(generation) || child !== spawned) return
     const update = parseQfAgentLogLine(line)
-    if (update) setStatus(update)
+    if (update) {
+      const { identityInvalidated, userCode, ...statusUpdate } = update
+      if (Object.keys(statusUpdate).length > 0) setStatus(statusUpdate)
+      if (identityInvalidated) handleIdentityInvalidation(spawned, generation, identityDir)
+      // userCode 仅供服务端自动批准使用，绝不进入公开状态。无有效意图（none/expired）
+      // 时由本机 desktop 云会话自动 arm+代批；'manual'（认证远程客户端触发的生命周期）
+      // 不自动批准。
+      if (userCode) void beginAgentAutoApprovalWithDesktopSession(userCode, { policy: launchOptions?.autoApprovalPolicy }).catch(() => {})
+    }
   }
   consumeLines(spawned.stdout, onLine)
   consumeLines(spawned.stderr, onLine)
@@ -487,7 +639,7 @@ function beginLaunch(generation) {
   return pending
 }
 
-export async function startQfAgent({ serverUrl, ownerPid, cloudUrl }) {
+export async function startQfAgent({ serverUrl, ownerPid, cloudUrl, autoApprovalPolicy }) {
   if (process.env.QUICKFORGE_QF_AGENT_ENABLED === '0') {
     setStatus({ enabled: false, status: 'disabled', serverUrl: null, pid: null, verificationUriComplete: null, error: null })
     return getQfAgentStatus()
@@ -500,6 +652,10 @@ export async function startQfAgent({ serverUrl, ownerPid, cloudUrl }) {
     serverUrl: new URL(serverUrl).href,
     ownerPid: Number(ownerPid),
     cloudUrl: new URL(cloudUrl).href,
+    // 'manual'：由认证远程客户端触发的配置变更启动，禁止自动创建批准意图；
+    // 默认 'auto'：本机生命周期事件（启动恢复、本机 URL 切换、普通/隔离重启）
+    // 允许在首次 authorizing 时依据本机 desktop 会话自动 arm。
+    autoApprovalPolicy: autoApprovalPolicy === 'manual' ? 'manual' : 'auto',
   }
   if (!Number.isInteger(options.ownerPid) || options.ownerPid <= 0) {
     setStatus({ status: 'error', error: 'qf-agent owner PID is invalid.' })
@@ -511,6 +667,7 @@ export async function startQfAgent({ serverUrl, ownerPid, cloudUrl }) {
   stopRequested = false
   stopPromise = null
   restartCount = 0
+  identityInvalidation = null
   setStatus({ enabled: true, error: null })
   try {
     return await beginLaunch(generation)
@@ -523,6 +680,7 @@ export async function startQfAgent({ serverUrl, ownerPid, cloudUrl }) {
 }
 
 export async function stopQfAgent({ disabled = false } = {}) {
+  if (disabled) clearAgentAutoApproval()
   if (stopPromise) {
     const result = await stopPromise
     if (disabled && result.status !== 'disabled') {
@@ -534,6 +692,7 @@ export async function stopQfAgent({ disabled = false } = {}) {
   stopRequested = true
   lifecycleGeneration += 1
   launchOptions = null
+  identityInvalidation = null
   if (restartTimer) {
     clearTimeout(restartTimer)
     restartTimer = null
@@ -566,6 +725,7 @@ export function getQfAgentStatus() {
     pid: status.pid,
     verificationUriComplete: status.verificationUriComplete,
     error: status.error,
+    autoApproval: getAgentAutoApprovalState(),
     updatedAt: status.updatedAt,
   }
 }

package/server/cloud/service-config.mjs

@@ -4,7 +4,7 @@ import { parseCloudBaseUrl } from './config.mjs'
 export const CLOUD_SERVICE_SETTINGS_KEY = 'quickforge-cloud-service'
 export const CLOUD_SERVICE_SCHEMA_VERSION = 1
 export const CLOUD_SERVICE_TYPE = 'quickforge-cloud'
-export const DEFAULT_CLOUD_URL = 'http://127.0.0.1:8082/'
+export const DEFAULT_CLOUD_URL = 'https://qf.shawnstack.com/'
 
 function savedServiceRecord(settings) {
   const value = settings?.[CLOUD_SERVICE_SETTINGS_KEY]