@shawnstack/quickforge 1.7.4 → 1.7.5

package/server/routes/cloud.mjs

@@ -0,0 +1,227 @@
+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 { isTailscaleAddress } from '../utils/network.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),
+} = {}) {
+  async function runtimeOrError() {
+    try {
+      return { runtime: await runtimeFactory() }
+    } catch (error) {
+      return { configurationError: error }
+    }
+  }
+
+  return async function handleCloudApi(req, res, url, {
+    isLocalRequest = false,
+    remoteAddress,
+    remoteAuthorized = false,
+  } = {}) {
+    const tailscaleAllowed = remoteAuthorized === true
+      && isTailscaleAddress(remoteAddress)
+    if (!isLocalRequest && !tailscaleAllowed) {
+      throw routeError('QuickForge Cloud is available only on this computer or an authorized Tailscale client.', 403, 'cloud_local_only')
+    }
+
+    requireProtectedCloudWrite(req, url.pathname)
+
+    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)
+      const nextUrl = parseCloudBaseUrl(body?.cloudUrl).href
+      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(nextUrl)
+      invalidateRuntime()
+      sendJson(res, 200, publicCloudServiceConfig(await readServiceConfig({ strict: false })))
+      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?.enabled) 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, mode: 'local', configurationError: configurationError.message })
+        return
+      }
+      if (!current?.enabled) {
+        sendJson(res, 200, { configured: false, mode: 'local' })
+        return
+      }
+      sendJson(res, 200, { configured: true, ...(await current.identity.status()) })
+      return
+    }
+
+    if (configurationError) throw routeError(configurationError.message, 503, 'cloud_configuration_error')
+    if (!current?.enabled) throw routeError('QuickForge Cloud is not configured.', 503, 'cloud_not_configured')
+
+    try {
+      if (req.method === 'POST' && url.pathname === '/api/cloud/guest/start') {
+        sendJson(res, 201, await current.identity.startGuest())
+        return
+      }
+      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
+      }
+      if (req.method === 'POST' && url.pathname === '/api/cloud/logout') {
+        await current.identity.logout()
+        invalidateRuntime()
+        sendJson(res, 200, { ok: true, mode: 'local' })
+        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

package/server/routes/scheduled-tasks.mjs

@@ -6,6 +6,7 @@ import { createAgent, getSessionEventBus, agentEvents, persistSessionState, abor
 import { agentProfileSnapshot, getAgentProfile } from '../agent-profiles.mjs'
 import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
 import { logger } from '../utils/logger.mjs'
+import { resolveModelBinding } from '../model-catalog.mjs'
 import {
   dayMs,
   formatLocalDateTime,
@@ -133,10 +134,14 @@ async function getApiKey(provider) {
   }
 }
 
-async function parseScheduledTaskInstructionWithAi(instruction, model, thinkingLevel = 'off') {
+async function parseScheduledTaskInstructionWithAi(instruction, modelInput, thinkingLevel = 'off', context = {}) {
   const text = String(instruction || '').trim()
   if (!text) return { needMoreInfo: true, question: '请输入要创建的定时任务。' }
-  if (!model) return { needMoreInfo: true, question: '请先选择用于解析任务的大模型。' }
+  if (!modelInput) return { needMoreInfo: true, question: '请先选择用于解析任务的大模型。' }
+  const { model } = await resolveModelBinding(
+    modelInput?.modelRef || modelInput?.model ? modelInput : { model: modelInput },
+    { context, legacySnapshot: modelInput?.model || modelInput },
+  )
 
   const now = new Date()
   const systemPrompt = `你是定时任务解析器。把用户的中文自然语言定时任务解析为 JSON。
@@ -529,6 +534,18 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
 
   try {
     const executionProject = await resolveExecutionProject(task)
+    const binding = task.modelRef || task.model
+      ? await resolveModelBinding(
+          task.modelRef ? { modelRef: task.modelRef } : { model: task.model },
+          {
+            context: { source: 'scheduled', allowCloud: true },
+            currentModel: task.model,
+            allowCurrentHidden: true,
+            forExecution: true,
+            legacySnapshot: task.model,
+          },
+        )
+      : null
     if (task.agentId) {
       executionAgent = await getAgentProfile(task.agentId, { projectId: executionProject?.id || null, workspaceRoot: executionProject?.path })
       if (!executionAgent) agentWarning = `Configured agent not found: ${task.agentId}`
@@ -541,7 +558,9 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
       scope: executionProject ? 'project' : 'global',
       projectId: executionProject?.id || null,
       yoloMode,
-      model: task.model,
+      model: binding?.model || task.model,
+      modelRef: binding?.modelRef || task.modelRef || null,
+      modelAccessContext: { source: 'scheduled', allowCloud: true },
       thinkingLevel: task.thinkingLevel,
       title: `[定时任务] ${task.title}`,
       agentProfile: executionAgent,
@@ -577,7 +596,7 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
     onStarted?.({ taskId: task.id, runId, sessionId })
 
     const eventBus = getSessionEventBus(sessionId)
-    const runtimeLimitMs = Math.max(1000, Math.min(Number(executionAgent?.maxRuntimeMs || 30 * 60 * 1000), 30 * 60 * 1000))
+    const runtimeLimitMs = Math.max(1000, Math.min(Number(executionAgent?.maxRuntimeMs || 60 * 60 * 1000), 60 * 60 * 1000))
     let timeout = null
     let handler = null
     let timedOut = false
@@ -770,12 +789,12 @@ export function stopScheduledTaskRunner() {
   runningTaskRunIds.clear()
 }
 
-export async function handleScheduledTasksApi(req, res, url) {
+export async function handleScheduledTasksApi(req, res, url, context = {}) {
   const parts = url.pathname.split('/').filter(Boolean)
 
   if (req.method === 'POST' && url.pathname === '/api/scheduled-tasks/parse') {
     const body = await readJsonBody(req)
-    sendJson(res, 200, await parseScheduledTaskInstructionWithAi(body?.instruction, body?.model, body?.thinkingLevel))
+    sendJson(res, 200, await parseScheduledTaskInstructionWithAi(body?.instruction, body?.modelRef ? body : body?.model, body?.thinkingLevel, context))
     return
   }
 
@@ -796,12 +815,14 @@ export async function handleScheduledTasksApi(req, res, url) {
     const now = new Date().toISOString()
     const normalized = normalizeTaskInput(parsed)
     const enabled = parsed.enabled !== false && parsed.status !== 'paused'
+    const binding = await resolveModelBinding(body, { context, legacySnapshot: body?.model })
     const task = {
       id: createId(),
       ...normalized,
       scheduleRule: normalized.scheduleRule || scheduleRuleFor(normalized),
       executionMode: normalized.executionMode || 'serial',
-      model: body?.model,
+      model: binding.model,
+      modelRef: binding.modelRef,
       thinkingLevel: body?.thinkingLevel || (body?.model?.reasoning ? 'medium' : 'off'),
       projectId: body?.projectId || null,
       projectName: body?.projectName || null,
@@ -830,6 +851,14 @@ export async function handleScheduledTasksApi(req, res, url) {
       const parsed = body?.task
       if (!parsed) throw requestError('Missing task')
       const normalized = normalizeTaskInput(parsed, existing)
+      const binding = body?.modelRef || body?.model
+        ? await resolveModelBinding(body, {
+            context,
+            currentModel: existing.model,
+            allowCurrentHidden: true,
+            legacySnapshot: body?.model,
+          })
+        : null
       const now = new Date().toISOString()
       const hasProject = Object.prototype.hasOwnProperty.call(body, 'projectId')
       const task = await updateTask(taskId, (current) => ({
@@ -837,7 +866,8 @@ export async function handleScheduledTasksApi(req, res, url) {
         ...normalized,
         scheduleRule: normalized.scheduleRule || scheduleRuleFor(normalized),
         executionMode: normalized.executionMode || 'serial',
-        model: body?.model ?? current.model,
+        model: binding?.model ?? current.model,
+        modelRef: binding?.modelRef ?? current.modelRef,
         thinkingLevel: body?.thinkingLevel ?? current.thinkingLevel,
         projectId: hasProject ? (body.projectId || null) : current.projectId,
         projectName: hasProject ? (body.projectName || null) : current.projectName,

package/server/routes/shared-conversation.mjs

@@ -1,10 +1,12 @@
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
-import { readSessionValue, readStore } from '../storage.mjs'
+import { readSessionValue } from '../storage.mjs'
+import { listModelCatalog, resolveModelBinding } from '../model-catalog.mjs'
 import { sendSessionAsset } from './session-assets.mjs'
 import { abortRun, restoreAgent, runPrompt, getSessionState, getSessionEventBus, updateSessionModel, updateSessionThinkingLevel } from '../agent-manager.mjs'
 import {
   assertShareActive,
   issueConversationShareToken,
+  onConversationShareInvalidated,
   parseCookies,
   readConversationShare,
   rollbackSharedSessionMessages,
@@ -49,6 +51,7 @@ function publicSharePayload(record) {
     scope: record.scope,
     projectId: record.projectId,
     hasPassword: Boolean(record.passwordHash),
+    allowCloudUsage: record.allowCloudUsage === true,
   }
 }
 
@@ -101,13 +104,6 @@ function sanitizeModel(model) {
   }
 }
 
-function sanitizeIncomingModel(model) {
-  if (!model || typeof model !== 'object') return null
-  const sanitized = sanitizeModel(model)
-  if (!sanitized.id || !sanitized.provider) return null
-  return sanitized
-}
-
 function sanitizeEvent(event) {
   if (!event || typeof event !== 'object') return event
   const next = { ...event }
@@ -147,6 +143,20 @@ async function handleSharedEvents(req, res, record) {
 
   writeSseEvent(res, 'state', await sharedSessionPayload(record))
 
+  let cleanedUp = false
+  let expirationTimeout
+  let removeShareInvalidationListener = () => undefined
+
+  const cleanup = () => {
+    if (cleanedUp) return
+    cleanedUp = true
+    clearInterval(keepAlive)
+    if (expirationTimeout) clearTimeout(expirationTimeout)
+    removeShareInvalidationListener()
+    eventBus.removeListener('agent_event', onAgentEvent)
+    if (!res.writableEnded) res.end()
+  }
+
   const keepAlive = setInterval(() => {
     try {
       res.write(': ping\n\n')
@@ -164,11 +174,19 @@ async function handleSharedEvents(req, res, record) {
     }
   }
 
-  const cleanup = () => {
-    clearInterval(keepAlive)
-    eventBus.removeListener('agent_event', onAgentEvent)
-    if (!res.writableEnded) res.end()
+  removeShareInvalidationListener = onConversationShareInvalidated(({ shareId }) => {
+    if (shareId === record.id) cleanup()
+  })
+  const scheduleExpiration = () => {
+    if (!record.expiresAt || cleanedUp) return
+    const delay = Date.parse(record.expiresAt) - Date.now()
+    if (delay <= 0) {
+      cleanup()
+      return
+    }
+    expirationTimeout = setTimeout(scheduleExpiration, Math.min(delay, 2_147_483_647))
   }
+  scheduleExpiration()
 
   eventBus.on('agent_event', onAgentEvent)
   req.on('close', cleanup)
@@ -269,42 +287,7 @@ async function sharedSessionPayload(record) {
   return sanitizeSession(session, record)
 }
 
-function sanitizeProvider(provider) {
-  if (!provider || typeof provider !== 'object') return null
-  const models = Array.isArray(provider.models)
-    ? provider.models.map(sanitizeModel).filter((model) => model?.id && model?.provider && model?.api)
-    : []
-  if (!models.length) return null
-  return {
-    id: provider.id || provider.name || models[0].provider,
-    name: provider.name || models[0].provider,
-    type: provider.type || models[0].api,
-    baseUrl: provider.baseUrl,
-    models,
-  }
-}
-
-async function listSharedModelProviders() {
-  const providers = await readStore('custom-providers')
-  return Object.values(providers || {}).map(sanitizeProvider).filter(Boolean)
-}
-
-async function readConfiguredModel(model) {
-  if (!model || typeof model !== 'object') return null
-  const providers = await readStore('custom-providers')
-  for (const provider of Object.values(providers || {})) {
-    if (!provider || typeof provider !== 'object') continue
-    const matched = Array.isArray(provider.models)
-      ? provider.models.find((candidate) => {
-          return candidate?.id === model.id && candidate?.provider === model.provider && candidate?.api === model.api
-        })
-      : undefined
-    if (matched) return matched
-  }
-  return null
-}
-
-export async function handleSharedConversationApi(req, res, url) {
+export async function handleSharedConversationApi(req, res, url, context = {}) {
   const parts = url.pathname.split('/').filter(Boolean)
   const shareId = decodeSegment(parts[2])
   const action = parts[3]
@@ -360,7 +343,21 @@ export async function handleSharedConversationApi(req, res, url) {
 
   if (req.method === 'GET' && action === 'models') {
     assertOperate(record)
-    sendJson(res, 200, { providers: await listSharedModelProviders() })
+    const session = await sharedSessionPayload(record)
+    const models = await listModelCatalog({
+      context: { ...context, allowCloud: record.allowCloudUsage === true },
+      currentModel: session.model,
+    })
+    const providers = []
+    for (const model of models) {
+      let provider = providers.find((item) => item.id === model.provider)
+      if (!provider) {
+        provider = { id: model.provider, name: model.provider, type: model.api, baseUrl: model.baseUrl, models: [] }
+        providers.push(provider)
+      }
+      provider.models.push(sanitizeModel(model))
+    }
+    sendJson(res, 200, { providers })
     return
   }
 
@@ -373,7 +370,14 @@ export async function handleSharedConversationApi(req, res, url) {
     assertOperate(record)
     const body = await readJsonBody(req)
     await restoreAgent(record.sessionId)
-    const result = await runPrompt(record.sessionId, messageFromBody(body, record, req), [], body?.command)
+    const result = await runPrompt(
+      record.sessionId,
+      messageFromBody(body, record, req),
+      [],
+      body?.command,
+      null,
+      { ...context, allowCloud: record.allowCloudUsage === true, source: 'shared' },
+    )
     sendJson(res, 200, result)
     return
   }
@@ -381,15 +385,15 @@ export async function handleSharedConversationApi(req, res, url) {
   if (req.method === 'POST' && action === 'model') {
     assertOperate(record)
     const body = await readJsonBody(req)
-    const model = sanitizeIncomingModel(body?.model)
-    if (!model) {
-      const error = new Error('Missing model in request body')
-      error.statusCode = 400
-      throw error
-    }
     await restoreAgent(record.sessionId)
-    const configured = await readConfiguredModel(model)
-    sendJson(res, 200, updateSessionModel(record.sessionId, configured ? sanitizeModel(configured) : model))
+    const currentModel = getSessionState(record.sessionId)?.model
+    const binding = await resolveModelBinding(body, {
+      context: { ...context, allowCloud: record.allowCloudUsage === true, source: 'shared' },
+      currentModel,
+      allowCurrentHidden: true,
+      legacySnapshot: body?.model,
+    })
+    sendJson(res, 200, updateSessionModel(record.sessionId, sanitizeModel(binding.model), binding.modelRef))
     return
   }
 

package/server/routes/shares.mjs

@@ -1,10 +1,14 @@
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readSessionValue } from '../storage.mjs'
-import { getLanUrls } from '../utils/network.mjs'
+import { getLanUrls, isTailscaleAddress } from '../utils/network.mjs'
 import {
   createConversationShare,
+  deleteConversationShare,
   listConversationShares,
+  restoreConversationShare,
   revokeConversationShare,
+  updateConversationShare,
+  updateConversationShareExpiration,
 } from '../share-store.mjs'
 
 function localBaseUrl(req, port) {
@@ -46,6 +50,13 @@ export async function handleSharesApi(req, res, url, context = {}) {
     const passwordProvided = typeof body?.password === 'string'
     const password = passwordProvided ? body.password.trim() : undefined
     const expiresAt = typeof body?.expiresAt === 'string' && body.expiresAt ? body.expiresAt : undefined
+    const allowCloudUsage = permission === 'operate' && body?.allowCloudUsage === true
+    if (allowCloudUsage && context.isLocalRequest === false
+      && !(context.remoteAuthorized === true && isTailscaleAddress(context.remoteAddress))) {
+      const error = new Error('QuickForge Cloud sharing can only be enabled locally or from an authorized Tailscale client.')
+      error.statusCode = 403
+      throw error
+    }
 
     const session = sessionId ? await readSessionValue(sessionId) : null
     if (!session) {
@@ -59,6 +70,7 @@ export async function handleSharesApi(req, res, url, context = {}) {
       permission,
       password: passwordProvided ? password : undefined,
       expiresAt,
+      allowCloudUsage,
       titleSnapshot: session.title,
       scope: session.scope,
       projectId: session.projectId,
@@ -77,6 +89,69 @@ export async function handleSharesApi(req, res, url, context = {}) {
     return
   }
 
+  if (parts.length === 4 && parts[0] === 'api' && parts[1] === 'shares') {
+    const shareId = decodeSegment(parts[2])
+    const action = parts[3]
+
+    if (req.method === 'POST' && action === 'disable') {
+      const share = await revokeConversationShare(shareId)
+      sendJson(res, 200, { ok: true, share })
+      return
+    }
+
+    if (req.method === 'POST' && action === 'restore') {
+      const body = await readJsonBody(req)
+      const expiresAt = typeof body?.expiresAt === 'string' && body.expiresAt ? body.expiresAt : undefined
+      const currentShares = await listConversationShares()
+      const current = currentShares.find((share) => share.id === shareId)
+      if (!current) {
+        const error = new Error('Share not found')
+        error.statusCode = 404
+        throw error
+      }
+      const session = current.sessionId ? await readSessionValue(current.sessionId) : null
+      if (!session) {
+        const error = new Error('Session not found')
+        error.statusCode = 404
+        throw error
+      }
+      const share = await restoreConversationShare(shareId, expiresAt)
+      sendJson(res, 200, { ok: true, share })
+      return
+    }
+
+    if (req.method === 'POST' && action === 'expiration') {
+      const body = await readJsonBody(req)
+      const expiresAt = typeof body?.expiresAt === 'string' && body.expiresAt ? body.expiresAt : undefined
+      const share = await updateConversationShareExpiration(shareId, expiresAt)
+      sendJson(res, 200, { ok: true, share })
+      return
+    }
+
+    if (req.method === 'POST' && action === 'update') {
+      const body = await readJsonBody(req)
+      const permission = body?.permission
+      const password = typeof body?.password === 'string' ? body.password : undefined
+      const expiresAt = typeof body?.expiresAt === 'string' && body.expiresAt ? body.expiresAt : undefined
+      const allowCloudUsage = body?.allowCloudUsage
+      if (allowCloudUsage === true && context.isLocalRequest === false
+        && !(context.remoteAuthorized === true && isTailscaleAddress(context.remoteAddress))) {
+        const error = new Error('QuickForge Cloud sharing can only be enabled locally or from an authorized Tailscale client.')
+        error.statusCode = 403
+        throw error
+      }
+      const share = await updateConversationShare(shareId, { permission, password, expiresAt, allowCloudUsage })
+      sendJson(res, 200, { ok: true, share })
+      return
+    }
+
+    if (req.method === 'DELETE' && action === 'permanent') {
+      const share = await deleteConversationShare(shareId)
+      sendJson(res, 200, { ok: true, share })
+      return
+    }
+  }
+
   if (req.method === 'DELETE' && parts.length === 3 && parts[0] === 'api' && parts[1] === 'shares') {
     const shareId = decodeSegment(parts[2])
     const share = await revokeConversationShare(shareId)