@shawnstack/quickforge 1.7.4 → 1.7.6

package/server/plugins/registry.mjs

@@ -16,6 +16,12 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const bundledPluginDir = path.resolve(__dirname, '..', '..', 'plugins')
 const globalPluginDir = path.join(dataDir, 'plugins')
 const legacyGlobalPluginDir = path.join(os.homedir(), '.agents', 'plugins')
+const PLUGIN_STORE_SCHEMA_VERSION = 2
+const LEGACY_BUNDLED_PLUGIN_NAMES = {
+  'openai-documents': 'documents',
+  'openai-presentations': 'presentations',
+  'openai-spreadsheets': 'spreadsheets',
+}
 export const DEFAULT_PLUGIN_TOOL_TIMEOUT_MS = 2 * 60 * 1000
 let cachedCatalog = null
 let cachedCatalogKey = null
@@ -108,13 +114,31 @@ async function listPluginDirs(root) {
 function normalizePluginStore(store) {
   const source = isPlainObject(store) ? store : {}
   return {
-    enabled: isPlainObject(source.enabled) ? source.enabled : {},
-    config: isPlainObject(source.config) ? source.config : {},
+    schemaVersion: Number.isInteger(source.schemaVersion) ? source.schemaVersion : 1,
+    enabled: isPlainObject(source.enabled) ? { ...source.enabled } : {},
+    config: isPlainObject(source.config) ? { ...source.config } : {},
+  }
+}
+
+function migratePluginStore(store) {
+  const next = normalizePluginStore(store)
+  if (next.schemaVersion >= PLUGIN_STORE_SCHEMA_VERSION) return { store: next, changed: false }
+
+  for (const [legacyName, name] of Object.entries(LEGACY_BUNDLED_PLUGIN_NAMES)) {
+    if (!(name in next.enabled) && legacyName in next.enabled) next.enabled[name] = next.enabled[legacyName]
+    if (!(name in next.config) && legacyName in next.config) next.config[name] = next.config[legacyName]
+    delete next.enabled[legacyName]
+    delete next.config[legacyName]
   }
+  next.schemaVersion = PLUGIN_STORE_SCHEMA_VERSION
+  return { store: next, changed: true }
 }
 
 async function readPluginStore() {
-  return normalizePluginStore(await readStore('plugins'))
+  const current = await readStore('plugins')
+  const migration = migratePluginStore(current)
+  if (!migration.changed) return migration.store
+  return atomicUpdate('plugins', (store) => migratePluginStore(store).store)
 }
 
 function contributionSummary(contribution) {
@@ -292,7 +316,7 @@ export async function getPluginStatus(projectContext = null) {
 
 export async function setPluginEnabled(name, enabled) {
   await atomicUpdate('plugins', (store) => {
-    const next = normalizePluginStore(store)
+    const next = migratePluginStore(store).store
     next.enabled[name] = enabled === true
     return next
   })
@@ -301,7 +325,7 @@ export async function setPluginEnabled(name, enabled) {
 
 export async function setPluginConfig(name, config) {
   await atomicUpdate('plugins', (store) => {
-    const next = normalizePluginStore(store)
+    const next = migratePluginStore(store).store
     next.config[name] = isPlainObject(config) ? config : {}
     return next
   })

package/server/public-api.mjs

@@ -68,7 +68,7 @@ function createVersionMismatchError(health, options = {}) {
   return error
 }
 
-function buildEnv(options = {}) {
+export function buildEnv(options = {}) {
   const host = normalizeHost(options.host)
   const port = getPort(options.port)
   const shareLan = options.shareLan === true
@@ -84,6 +84,10 @@ function buildEnv(options = {}) {
   if (options.workspaceDir) env.QUICKFORGE_WORKSPACE_DIR = path.resolve(options.workspaceDir)
   if (options.vitePort) env.QUICKFORGE_VITE_PORT = String(options.vitePort)
   if (options.terminal === false) env.QUICKFORGE_TERMINAL = '0'
+  if (options.qfAgentPath) env.QUICKFORGE_QF_AGENT_PATH = path.resolve(options.qfAgentPath)
+  if (options.qfAgentIdentityDir) env.QUICKFORGE_QF_AGENT_IDENTITY_DIR = path.resolve(options.qfAgentIdentityDir)
+  if (options.qfAgentEnabled !== undefined) env.QUICKFORGE_QF_AGENT_ENABLED = options.qfAgentEnabled === false ? '0' : '1'
+  if (options.runtimeKind) env.QUICKFORGE_RUNTIME_KIND = String(options.runtimeKind)
   if (options.allowRemote || shareLan) env.QUICKFORGE_ALLOW_REMOTE = '1'
   delete env.ELECTRON_RUN_AS_NODE
   delete env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
@@ -172,7 +176,7 @@ export async function startQuickForge(options = {}) {
 
   if (options.inline === true) {
     prepareQuickForgeEnv(options)
-    await import(serverScriptUrl)
+    const serverModule = await import(serverScriptUrl)
     const health = await waitForQuickForge(options)
     if (!health) throw new Error('QuickForge failed to start: health check timed out')
     return {
@@ -184,7 +188,8 @@ export async function startQuickForge(options = {}) {
       reused: false,
       inline: true,
       async stop() {
-        return false
+        await serverModule.stopQuickForgeServer()
+        return true
       },
     }
   }
@@ -242,8 +247,9 @@ export async function startQuickForge(options = {}) {
 }
 
 export async function stopQuickForge(instance) {
-  if (!instance?.child || instance.reused) return false
-  if (instance.child.killed) return false
+  if (!instance || instance.reused) return false
+  if (typeof instance.stop === 'function') return instance.stop()
+  if (!instance.child || instance.child.killed) return false
   instance.child.kill('SIGTERM')
   return true
 }

package/server/routes/agent-profiles.mjs

@@ -3,6 +3,36 @@ import { DEFAULT_AI_MAX_RETRIES } from '../ai-provider-options.mjs'
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readStore } from '../storage.mjs'
 import { logger } from '../utils/logger.mjs'
+import { resolveModelBinding } from '../model-catalog.mjs'
+
+function profileModelReference(model) {
+  if (!model || model.mode !== 'fixed') return null
+  if (model.source === 'cloud') return { version: 1, source: 'cloud', catalogId: model.catalogId || model.modelId }
+  if (model.source === 'custom') return { version: 1, source: 'custom', providerId: model.providerId, modelId: model.modelId }
+  return {
+    version: 1,
+    source: 'legacy-custom',
+    provider: model.provider,
+    modelId: model.modelId,
+    ...(model.api ? { api: model.api } : {}),
+    ...(model.baseUrl ? { baseUrl: model.baseUrl } : {}),
+  }
+}
+
+async function canonicalizeProfileModel(body, current, context) {
+  if (!body || !Object.prototype.hasOwnProperty.call(body, 'model')) return body
+  const model = body.model
+  if (!model || model.mode !== 'fixed') return body
+  if (current?.model && JSON.stringify(current.model) === JSON.stringify(model)) return body
+  const binding = await resolveModelBinding({ modelRef: profileModelReference(model) }, { context })
+  const ref = binding.modelRef
+  return {
+    ...body,
+    model: ref.source === 'cloud'
+      ? { mode: 'fixed', source: 'cloud', catalogId: ref.catalogId }
+      : { mode: 'fixed', source: 'custom', providerId: ref.providerId, modelId: ref.modelId },
+  }
+}
 import {
   agentProfileSnapshot,
   createCustomAgentProfile,
@@ -10,7 +40,7 @@ import {
   getAgentProfile,
   listAgentProfiles,
   listAvailableAgentTools,
-  updateBuiltinAgentModelOverride,
+  updateBuiltinAgentOverrides,
   updateCustomAgentProfile,
 } from '../agent-profiles.mjs'
 
@@ -65,10 +95,14 @@ function normalizeGeneratedAgentProfile(value) {
   return { name, label, description, systemPrompt }
 }
 
-async function generateAgentProfileWithAi(instruction, model, thinkingLevel = 'off') {
+async function generateAgentProfileWithAi(instruction, modelInput, thinkingLevel = 'off', context = {}) {
   const text = String(instruction || '').trim()
   if (!text) throw requestError('Please describe the agent you want to create')
-  if (!model) throw requestError('Please configure a default model first')
+  if (!modelInput) throw requestError('Please configure a default model first')
+  const { model } = await resolveModelBinding(
+    modelInput?.modelRef || modelInput?.model ? modelInput : { model: modelInput },
+    { context, legacySnapshot: modelInput?.model || modelInput },
+  )
 
   const systemPrompt = `You are a QuickForge Agent Profile generator.
 Generate only the basic definition fields for a custom Agent Profile from the user's request.
@@ -120,7 +154,7 @@ Rules:
   }
 }
 
-export async function handleAgentProfilesApi(req, res, url) {
+export async function handleAgentProfilesApi(req, res, url, context = {}) {
   const parts = url.pathname.split('/').filter(Boolean)
 
   if (req.method === 'GET' && url.pathname === '/api/agent-profiles') {
@@ -136,13 +170,13 @@ export async function handleAgentProfilesApi(req, res, url) {
 
   if (req.method === 'POST' && url.pathname === '/api/agent-profiles/ai-fill') {
     const body = await readJsonBody(req)
-    sendJson(res, 200, { agent: await generateAgentProfileWithAi(body?.instruction, body?.model, body?.thinkingLevel) })
+    sendJson(res, 200, { agent: await generateAgentProfileWithAi(body?.instruction, body?.modelRef ? body : body?.model, body?.thinkingLevel, context) })
     return
   }
 
   if (req.method === 'POST' && url.pathname === '/api/agent-profiles') {
     const body = await readJsonBody(req)
-    sendJson(res, 200, { agent: await createCustomAgentProfile(body || {}) })
+    sendJson(res, 200, { agent: await createCustomAgentProfile(await canonicalizeProfileModel(body || {}, null, context)) })
     return
   }
 
@@ -160,13 +194,16 @@ export async function handleAgentProfilesApi(req, res, url) {
       const current = await getAgentProfile(id)
       const body = await readJsonBody(req)
       if (current?.builtin) {
+        const allowedKeys = ['model', 'thinkingLevel']
         const keys = Object.keys(body || {})
-        if (keys.length !== 1 || keys[0] !== 'model') throw requestError('Built-in agents only allow model updates', 403)
-        sendJson(res, 200, { agent: agentProfileSnapshot(await updateBuiltinAgentModelOverride(id, body.model)) })
+        if (keys.length === 0 || keys.some((key) => !allowedKeys.includes(key))) {
+          throw requestError('Built-in agents only allow model and thinkingLevel updates', 403)
+        }
+        sendJson(res, 200, { agent: agentProfileSnapshot(await updateBuiltinAgentOverrides(id, await canonicalizeProfileModel(body, current, context))) })
         return
       }
       if (current?.readonly) throw requestError('Read-only agents cannot be modified from the API', 403)
-      sendJson(res, 200, { agent: await updateCustomAgentProfile(id, body || {}) })
+      sendJson(res, 200, { agent: await updateCustomAgentProfile(id, await canonicalizeProfileModel(body || {}, current, context)) })
       return
     }
 

package/server/routes/agent.mjs

@@ -1,7 +1,9 @@
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { logger } from '../utils/logger.mjs'
+import { resolveModelBinding } from '../model-catalog.mjs'
 import {
   createAgent,
+  validateAgentHarness,
   runPrompt,
   abortRun,
   steerAgent,
@@ -21,6 +23,9 @@ import {
   updateSessionYoloMode,
   updateSessionModel,
   updateSessionThinkingLevel,
+  updateSessionHarnessConfigOption,
+  updateSessionHarnessMode,
+  forkSession,
   approveToolCall,
   rejectToolCall,
   approveAutoCompact,
@@ -31,7 +36,7 @@ import {
   agentEvents,
 } from '../agent-manager.mjs'
 
-export async function handleAgentApi(req, res, url) {
+export async function handleAgentApi(req, res, url, context = {}) {
   const pathname = url.pathname
   const parts = pathname.split('/').filter(Boolean)
 
@@ -85,7 +90,7 @@ export async function handleAgentApi(req, res, url) {
       error.statusCode = 400
       throw error
     }
-    const result = await runPrompt(sessionId, message, body?.selectedCapabilities, body?.command)
+    const result = await runPrompt(sessionId, message, body?.selectedCapabilities, body?.command, null, context)
     sendJson(res, 200, result)
     return
   }
@@ -160,13 +165,23 @@ export async function handleAgentApi(req, res, url) {
   // POST /api/agents/:sessionId — create/ensure agent
   if (req.method === 'POST' && parts.length === 3) {
     const body = await readJsonBody(req)
-    const session = await createAgent(sessionId, body)
+    const harness = validateAgentHarness(body?.harness)
+    let config
+    if (harness === 'quickforge' && (body?.modelRef || body?.model)) {
+      const binding = await resolveModelBinding(body, { context, legacySnapshot: body?.model })
+      config = { ...body, harness, model: binding.model, modelRef: binding.modelRef, modelAccessContext: context, resolvePersistedModel: true }
+    } else {
+      config = { ...body, harness, modelAccessContext: context, resolvePersistedModel: true }
+    }
+    const session = await createAgent(sessionId, config)
     sendJson(res, 200, {
       sessionId: session.sessionId,
       status: session.status,
       scope: session.scope,
       title: session.title,
       source: session.source || undefined,
+      harness: session.harness,
+      harnessSessionId: session.agent.harnessSessionId || session.harnessSessionId || undefined,
       channelId: session.channelId || undefined,
       channelName: session.channelName || undefined,
       accessMode: session.accessMode,
@@ -209,13 +224,14 @@ export async function handleAgentApi(req, res, url) {
   // POST /api/agents/:sessionId/model — update session model
   if (req.method === 'POST' && subPath === 'model') {
     const body = await readJsonBody(req)
-    const model = body?.model
-    if (!model) {
-      const error = new Error('Missing model in request body')
-      error.statusCode = 400
-      throw error
-    }
-    const result = updateSessionModel(sessionId, model)
+    const currentModel = getSessionState(sessionId)?.model
+    const binding = await resolveModelBinding(body, {
+      context,
+      currentModel,
+      allowCurrentHidden: true,
+      legacySnapshot: body?.model,
+    })
+    const result = updateSessionModel(sessionId, binding.model, binding.modelRef)
     sendJson(res, 200, result)
     return
   }
@@ -234,6 +250,39 @@ export async function handleAgentApi(req, res, url) {
     return
   }
 
+  // POST /api/agents/:sessionId/harness/config-option — update an advertised Harness config option
+  if (req.method === 'POST' && subPath === 'harness/config-option') {
+    const body = await readJsonBody(req)
+    if (typeof body?.configId !== 'string' || !body.configId || body.value === undefined) {
+      const error = new Error('Missing configId or value in request body')
+      error.statusCode = 400
+      throw error
+    }
+    const result = await updateSessionHarnessConfigOption(sessionId, body.configId, body.value)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/harness/mode — update an advertised Harness mode
+  if (req.method === 'POST' && subPath === 'harness/mode') {
+    const body = await readJsonBody(req)
+    if (typeof body?.modeId !== 'string' || !body.modeId) {
+      const error = new Error('Missing modeId in request body')
+      error.statusCode = 400
+      throw error
+    }
+    const result = await updateSessionHarnessMode(sessionId, body.modeId)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/fork — fork the entire current OpenCode session
+  if (req.method === 'POST' && subPath === 'fork') {
+    const result = await forkSession(sessionId)
+    sendJson(res, 200, result)
+    return
+  }
+
   // POST /api/agents/:sessionId/rollback — roll back from a message index on the authoritative server state
   if (req.method === 'POST' && subPath === 'rollback') {
     const body = await readJsonBody(req)
@@ -244,7 +293,7 @@ export async function handleAgentApi(req, res, url) {
 
   // POST /api/agents/:sessionId/continue — continue generation from last message (retry)
   if (req.method === 'POST' && subPath === 'continue') {
-    const result = await continueSession(sessionId)
+    const result = await continueSession(sessionId, context)
     sendJson(res, 200, result)
     return
   }

package/server/routes/backup.mjs

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto'
 import { promises as fs } from 'node:fs'
 import path from 'node:path'
+import { isAuthenticatedAppClient } from '../access-policy.mjs'
 import { sendJson, readJsonBody } from '../utils/response.mjs'
 import {
   ensureStorage,
@@ -580,7 +581,13 @@ async function restoreValidatedBackup(backup, mode = 'replace') {
   return summary
 }
 
-export async function handleBackupApi(req, res, url) {
+export async function handleBackupApi(req, res, url, context = { isLocalRequest: true }) {
+  if (!isAuthenticatedAppClient(context)) {
+    const error = new Error('Backup import and export require a local or authenticated remote client.')
+    error.statusCode = 403
+    error.errorCode = 'backup_auth_required'
+    throw error
+  }
   if (req.method === 'GET' && url.pathname === '/api/backup/export') {
     await ensureStorage()
     sendJson(res, 200, await buildBackup(url.searchParams.get('scope'), {

package/server/routes/cloud.mjs

@@ -0,0 +1,246 @@
+import { getQfAgentStatus } from '../cloud/qf-agent-process.mjs'
+import { isAuthenticatedAppClient } from '../access-policy.mjs'
+import { CloudClient, CloudApiError } from '../cloud/client.mjs'
+import { parseCloudBaseUrl } from '../cloud/config.mjs'
+import { createCloudCredentialStore } from '../cloud/credential-store.mjs'
+import { getCloudRuntime, invalidateCloudRuntime } from '../cloud/runtime.mjs'
+import {
+  publicCloudServiceConfig,
+  readCloudServiceConfig,
+  saveCloudServiceConfig,
+} from '../cloud/service-config.mjs'
+import { readJsonBody, sendJson } from '../utils/response.mjs'
+
+const CLOUD_CONFIG_BODY_MAX_BYTES = 16 * 1024
+const CLOUD_ACTION_HEADER = 'x-quickforge-action'
+const CLOUD_ACTION_VALUE = 'cloud-action'
+const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS'])
+const JSON_WRITE_ROUTES = new Set([
+  'POST /api/cloud/test-connection',
+  'PUT /api/cloud/config',
+  'POST /api/cloud/identity/reset',
+  'POST /api/cloud/device/start',
+  'POST /api/cloud/device/poll',
+  'POST /api/cloud/device/cancel',
+])
+
+function routeError(message, statusCode, code) {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  error.errorCode = code
+  error.code = code
+  return error
+}
+
+function mapCloudError(error) {
+  if (!(error instanceof CloudApiError)) return error
+  const mapped = routeError(error.message, error.status || 503, error.code)
+  mapped.retryable = error.retryable
+  mapped.details = error.details
+  return mapped
+}
+
+function createDefaultRuntime() {
+  return getCloudRuntime()
+}
+
+function sameCloudUrl(left, right) {
+  try {
+    return parseCloudBaseUrl(left).href === parseCloudBaseUrl(right).href
+  } catch {
+    return false
+  }
+}
+
+function requireDangerousConfirmation(body) {
+  if (body?.confirm !== 'reset-cloud-identity') {
+    throw routeError('Explicit confirmation is required to rebuild the QuickForge Cloud identity.', 400, 'cloud_reset_confirmation_required')
+  }
+}
+
+function requireProtectedCloudWrite(req, pathname) {
+  const method = String(req.method || 'GET').toUpperCase()
+  if (SAFE_METHODS.has(method)) return
+
+  if (req.headers[CLOUD_ACTION_HEADER] !== CLOUD_ACTION_VALUE) {
+    throw routeError('QuickForge Cloud action header is required.', 403, 'cloud_action_header_required')
+  }
+
+  if (!JSON_WRITE_ROUTES.has(`${method} ${pathname}`)) return
+  const mediaType = String(req.headers['content-type'] || '').split(';', 1)[0].trim().toLowerCase()
+  if (mediaType !== 'application/json') {
+    throw routeError('QuickForge Cloud JSON requests require Content-Type: application/json.', 415, 'cloud_json_content_type_required')
+  }
+}
+
+export function createCloudRouteHandler({
+  runtimeFactory = createDefaultRuntime,
+  readServiceConfig = readCloudServiceConfig,
+  saveServiceConfig = saveCloudServiceConfig,
+  credentialStoreFactory = createCloudCredentialStore,
+  invalidateRuntime = invalidateCloudRuntime,
+  cloudClientFactory = (config) => new CloudClient(config),
+  qfAgentStatus = getQfAgentStatus,
+  onServiceConfigChanged,
+} = {}) {
+  async function runtimeOrError() {
+    try {
+      return { runtime: await runtimeFactory() }
+    } catch (error) {
+      return { configurationError: error }
+    }
+  }
+
+  return async function handleCloudApi(req, res, url, context = {}) {
+    if (!isAuthenticatedAppClient(context)) {
+      throw routeError('QuickForge Cloud is available only on this computer or an authenticated remote client.', 403, 'cloud_local_only')
+    }
+
+    requireProtectedCloudWrite(req, url.pathname)
+
+    if (req.method === 'GET' && url.pathname === '/api/cloud/remote/status') {
+      const service = await readServiceConfig({ strict: false })
+      if (!service.enabled) {
+        sendJson(res, 200, { ...qfAgentStatus(), enabled: false, status: 'disabled', serverUrl: null, pid: null, verificationUriComplete: null, error: null })
+        return
+      }
+      sendJson(res, 200, qfAgentStatus())
+      return
+    }
+
+    if (req.method === 'GET' && url.pathname === '/api/cloud/config') {
+      sendJson(res, 200, publicCloudServiceConfig(await readServiceConfig({ strict: false })))
+      return
+    }
+
+    if (req.method === 'POST' && url.pathname === '/api/cloud/test-connection') {
+      const body = await readJsonBody(req, CLOUD_CONFIG_BODY_MAX_BYTES)
+      const baseUrl = parseCloudBaseUrl(body?.cloudUrl)
+      const timeoutValue = Number(process.env.QUICKFORGE_CLOUD_TIMEOUT_MS || 10_000)
+      const client = cloudClientFactory({
+        baseUrl,
+        timeoutMs: Number.isFinite(timeoutValue) ? Math.min(60_000, Math.max(1_000, timeoutValue)) : 10_000,
+      })
+      try {
+        const [health, ready] = await Promise.all([client.health(), client.ready()])
+        sendJson(res, 200, { ok: true, cloudUrl: baseUrl.href, health, ready })
+      } catch (error) {
+        throw mapCloudError(error)
+      }
+      return
+    }
+
+    if (req.method === 'PUT' && url.pathname === '/api/cloud/config') {
+      const body = await readJsonBody(req, CLOUD_CONFIG_BODY_MAX_BYTES)
+      if (body?.enabled !== undefined && typeof body.enabled !== 'boolean') {
+        throw routeError('QuickForge Cloud enabled must be a boolean.', 400, 'cloud_enabled_invalid')
+      }
+      const currentConfig = await readServiceConfig({ strict: false })
+      const nextUrl = parseCloudBaseUrl(body?.cloudUrl === undefined ? currentConfig.cloudUrl : body.cloudUrl).href
+      const nextEnabled = body?.enabled === undefined ? currentConfig.enabled === true : body.enabled
+      const urlChanged = !sameCloudUrl(currentConfig.cloudUrl, nextUrl)
+      if (body?.cloudUrl !== undefined) {
+        const credentialStore = credentialStoreFactory()
+        const identityRecord = await credentialStore.read()
+        if (identityRecord.refreshToken || identityRecord.pendingDeviceFlow) {
+          const boundUrl = String(identityRecord.pendingDeviceFlow?.sessionCloudUrl || identityRecord.sessionCloudUrl || '').trim()
+          const sameUrl = boundUrl ? sameCloudUrl(boundUrl, nextUrl) : false
+          if (!sameUrl) {
+            throw routeError('A QuickForge Cloud session is active. Sign out first, or explicitly rebuild the identity before switching services.', 409, 'cloud_session_active')
+          }
+        }
+      }
+      await saveServiceConfig({ cloudUrl: nextUrl, enabled: nextEnabled })
+      invalidateRuntime()
+      const saved = await readServiceConfig({ strict: false })
+      const notify = context.onCloudServiceConfigChanged || onServiceConfigChanged
+      if (typeof notify === 'function') await notify(saved, { urlChanged })
+      sendJson(res, 200, publicCloudServiceConfig(saved))
+      return
+    }
+
+    if (req.method === 'POST' && url.pathname === '/api/cloud/identity/reset') {
+      const body = await readJsonBody(req, CLOUD_CONFIG_BODY_MAX_BYTES)
+      requireDangerousConfirmation(body)
+      const { runtime } = await runtimeOrError()
+      if (runtime?.identity) await runtime.identity.resetIdentity()
+      else {
+        const store = credentialStoreFactory()
+        await store.rotateInstallation()
+      }
+      invalidateRuntime()
+      sendJson(res, 200, { ok: true, mode: 'local' })
+      return
+    }
+
+    const { runtime: current, configurationError } = await runtimeOrError()
+    if (req.method === 'GET' && url.pathname === '/api/cloud/status') {
+      if (configurationError) {
+        sendJson(res, 200, { configured: false, enabled: false, mode: 'local', configurationError: configurationError.message })
+        return
+      }
+      if (!current?.enabled) {
+        const localStatus = current?.identity ? await current.identity.status() : current?.store ? await current.store.readPublic() : { mode: 'local' }
+        sendJson(res, 200, { ...localStatus, configured: Boolean(current?.config?.baseUrl), enabled: false })
+        return
+      }
+      sendJson(res, 200, { configured: true, enabled: true, ...(await current.identity.status()) })
+      return
+    }
+
+    if (configurationError) throw routeError(configurationError.message, 503, 'cloud_configuration_error')
+
+    if (req.method === 'POST' && url.pathname === '/api/cloud/logout') {
+      if (current?.identity) await current.identity.logout()
+      else if (current?.store) await current.store.clearSession({ rotateInstallationBeforeRegistration: true })
+      else await credentialStoreFactory().clearSession({ rotateInstallationBeforeRegistration: true })
+      invalidateRuntime()
+      sendJson(res, 200, { ok: true, mode: 'local' })
+      return
+    }
+
+    if (!current?.enabled) throw routeError('QuickForge Cloud is disabled.', 503, 'cloud_disabled')
+
+    try {
+      if (req.method === 'POST' && url.pathname === '/api/cloud/device/start') {
+        await readJsonBody(req, CLOUD_CONFIG_BODY_MAX_BYTES)
+        sendJson(res, 201, await current.identity.startDeviceFlow())
+        return
+      }
+      if (req.method === 'POST' && url.pathname === '/api/cloud/device/poll') {
+        await readJsonBody(req, CLOUD_CONFIG_BODY_MAX_BYTES)
+        sendJson(res, 200, await current.identity.pollDeviceFlow())
+        return
+      }
+      if (req.method === 'POST' && url.pathname === '/api/cloud/device/cancel') {
+        await readJsonBody(req, CLOUD_CONFIG_BODY_MAX_BYTES)
+        sendJson(res, 200, await current.identity.cancelDeviceFlow())
+        return
+      }
+      if (req.method === 'GET' && url.pathname === '/api/cloud/models') {
+        sendJson(res, 200, { items: await current.models.list(undefined, { refresh: true }) })
+        return
+      }
+      if (req.method === 'GET' && url.pathname === '/api/cloud/usage') {
+        sendJson(res, 200, await current.identity.usage())
+        return
+      }
+      if (req.method === 'GET' && url.pathname === '/api/cloud/installations') {
+        sendJson(res, 200, await current.identity.installations())
+        return
+      }
+      const revokeMatch = url.pathname.match(/^\/api\/cloud\/installations\/([^/]+)$/)
+      if (req.method === 'DELETE' && revokeMatch) {
+        await current.identity.revokeInstallation(decodeURIComponent(revokeMatch[1]))
+        sendJson(res, 200, { ok: true })
+        return
+      }
+    } catch (error) {
+      throw mapCloudError(error)
+    }
+
+    throw routeError('Not found', 404, 'route_not_found')
+  }
+}
+
+export const handleCloudApi = createCloudRouteHandler()

package/server/routes/models.mjs

@@ -1,4 +1,5 @@
 import { streamSimpleWithAiHttpLogging } from '../ai-http-logger.mjs'
+import { listModelCatalog } from '../model-catalog.mjs'
 import { sendJson, readJsonBody } from '../utils/response.mjs'
 import { readStore } from '../storage.mjs'
 import { logger } from '../utils/logger.mjs'
@@ -46,7 +47,12 @@ async function probeModelConnection(model, apiKeyOverride) {
   return { ok: true }
 }
 
-export async function handleModelsApi(req, res, url) {
+export async function handleModelsApi(req, res, url, context = {}) {
+  if (req.method === 'GET' && url.pathname === '/api/models/catalog') {
+    sendJson(res, 200, { models: await listModelCatalog({ context, refreshCloud: url.searchParams.get('refresh') === 'true' }) })
+    return
+  }
+
   if (req.method === 'POST' && url.pathname === '/api/models/test-connection') {
     const body = await readJsonBody(req)
     const model = body?.model