@muyichengshayu/promptx 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+## 0.1.6
+
+- 新增多租户 Relay 子域名接入能力，一个 Relay 进程即可同时服务多个同事的远程访问。
+- 新增 `promptx relay tenant add/list/remove` 与 `promptx relay start/stop/restart/status`，补齐 Relay 的租户管理和后台运维命令。
+- 完善 Relay 转发稳定性与诊断信息，修复远程请求体转发问题，并增加更清晰的 host、tenant 与拒绝原因日志。
+- README 精简为入口说明，详细 Relay 部署与使用流程迁移到 `docs/relay-quickstart.md`。
+- 修复 Windows 开发环境下 `pnpm dev` / `pnpm dev:tailscale` 可能报 `spawn EINVAL` 的问题。
+
+## 0.1.5
+
+- 本轮提示词支持按新数据结构展示图片块，新的图文输入在会话区可直接看到附图预览。
+- 修复旧库升级时 `prompt_blocks_json` 字段缺失导致服务启动报错的问题，补齐增量迁移。
+- 优化项目管理交互：运行中也可打开“管理项目”，管理弹窗优先选中当前项目，编辑表单能正确回填。
+- 简化项目选择器与项目列表状态展示，减少无意义抖动和过重高亮；新建任务按钮不再因列表加载短暂禁用。
+
+## 0.1.4
+
+- 修复 Windows 下通过 npm 安装后的正式版在启动服务、发送请求和执行辅助命令时频繁弹出黑色控制台窗口的问题。
+- 为 PromptX、Codex、Git 与发布检查相关的 Windows 子进程统一补充隐藏窗口选项，减少系统级弹窗干扰。
+
+## 0.1.3
+
+- 修复工作台输入区在输入法候选、实时刷新和快速发送场景下的尾字丢失问题。
+- 修复设置面板首次打开时版本信息不加载、一直停留在“读取中...”的问题。
+
+## 0.1.2
+
+- 设置面板增加版本信息展示，并在读取失败时显示明确状态。
+- CLI 新增 `version`、`--version`、`-v` 版本查询，同时兼容 `-versioin`。
+- README 补充说明：禅道扩展目前需要下载或克隆仓库源码后手动加载。
+
+## 0.1.1
+
+- 修复工作台中“代码变更”入口、执行过程“查看”按钮和任务卡文件数徽标的闪烁问题。
+- 优化任务列表刷新时的代码变更摘要复用逻辑，减少界面抖动。

package/README.md

@@ -36,12 +36,18 @@ promptx doctor
 promptx start
 promptx status
 promptx stop
+promptx relay start
 ```
 
 ```bash
 promptx doctor
 ```
 
+其中：
+
+- `promptx start`：启动本机 PromptX 工作台
+- `promptx relay start`：启动公网中转服务，适合部署到你自己的云服务器
+
 ## 使用方式
 
 1. 打开工作台，新建或选择一个任务
@@ -50,6 +56,21 @@ promptx doctor
 4. 点击发送，把当前内容交给 Codex
 5. 在中间继续查看执行过程，并按需多轮发送
 
+## 远程访问 Relay（预览）
+
+如果你希望在手机上远程访问自己电脑上的 PromptX，或想在云端部署多租户 Relay，请直接查看：
+
+- `docs/relay-quickstart.md`
+
+文档里已经整理好这些内容：
+
+- 本地 PromptX 接入 Relay
+- 云端 Relay 启动与后台管理
+- 多租户子域名接入
+- `promptx relay tenant add/list/remove`
+- `promptx relay start/stop/restart/status`
+- Nginx、DNS、健康检查与常见排查
+
 ## 禅道扩展
 
 仓库内置了禅道 Chrome 扩展：`apps/zentao-extension`

package/apps/server/src/index.js

@@ -57,6 +57,8 @@ import {
   searchWorkspaceEntries,
 } from './workspaceFiles.js'
 import { ensurePromptxStorageReady, serverRootDir } from './appPaths.js'
+import { createRelayClient } from './relayClient.js'
+import { getRelayConfigForClient, isRelayConfigManagedByEnv, writeStoredRelayConfig } from './relayConfig.js'
 import { createSseHub } from './sseHub.js'
 
 const app = Fastify({ logger: true })
@@ -80,6 +82,13 @@ function readPromptxVersion() {
 }
 
 const promptxVersion = readPromptxVersion()
+const relayConfig = getRelayConfigForClient()
+const relayClient = createRelayClient({
+  logger: app.log,
+  appVersion: promptxVersion,
+  localBaseUrl: process.env.PROMPTX_RELAY_LOCAL_BASE_URL || `http://127.0.0.1:${port}`,
+  ...relayConfig,
+})
 
 let lastExpiredPurgeAt = 0
 const sseHub = createSseHub()
@@ -338,6 +347,32 @@ app.get('/api/meta', async () => ({
   visibilityOptions: VISIBILITY_OPTIONS,
 }))
 
+app.get('/api/relay/status', async () => ({
+  relay: relayClient.getStatus(),
+}))
+
+app.get('/api/relay/config', async () => ({
+  config: {
+    ...getRelayConfigForClient(),
+  },
+  managedByEnv: isRelayConfigManagedByEnv(),
+  relay: relayClient.getStatus(),
+}))
+
+app.put('/api/relay/config', async (request) => {
+  const savedConfig = writeStoredRelayConfig(request.body || {})
+  relayClient.updateConfig({
+    ...savedConfig,
+    localBaseUrl: process.env.PROMPTX_RELAY_LOCAL_BASE_URL || `http://127.0.0.1:${port}`,
+  })
+
+  return {
+    config: getRelayConfigForClient(),
+    managedByEnv: isRelayConfigManagedByEnv(),
+    relay: relayClient.getStatus(),
+  }
+})
+
 app.get('/api/events/stream', async (request, reply) => {
   reply.hijack()
   const requestOrigin = request.headers.origin
@@ -915,10 +950,11 @@ app.setErrorHandler((error, request, reply) => {
 markInterruptedCodexRuns()
 purgeExpiredContent(true)
 
-app.listen({ port, host }).then(() => {
-  app.log.info(`server running at http://${host}:${port}`)
-  buildServerAccessUrls(host, port).forEach((message) => {
-    app.log.info(message)
-  })
-})
+app.listen({ port, host }).then(() => {
+  app.log.info(`server running at http://${host}:${port}`)
+  buildServerAccessUrls(host, port).forEach((message) => {
+    app.log.info(message)
+  })
+  relayClient.start()
+})
 

package/apps/server/src/relayClient.js

@@ -0,0 +1,431 @@
+import process from 'node:process'
+import WebSocket from 'ws'
+
+import {
+  buildRelayWebSocketUrl,
+  createRelayRequestId,
+  decodeChunk,
+  encodeChunk,
+  sanitizeProxyHeaders,
+} from './relayProtocol.js'
+
+const DEFAULT_RECONNECT_DELAY_MS = 3_000
+const REQUEST_CANCEL_REASON = 'relay_request_cancelled'
+
+function createDisabledStatus() {
+  return {
+    enabled: false,
+    connected: false,
+    relayUrl: '',
+    websocketUrl: '',
+    deviceId: '',
+    lastConnectedAt: '',
+    lastDisconnectedAt: '',
+    lastCloseCode: 0,
+    lastCloseReason: '',
+    lastError: '',
+  }
+}
+
+function normalizeCloseReason(reason = '') {
+  const normalized = String(reason || '').trim()
+  if (!normalized) {
+    return ''
+  }
+
+  const reasonMap = {
+    invalid_tenant: '当前 Relay 域名未匹配到租户',
+    invalid_token: '设备令牌不匹配',
+    invalid_device: '设备 ID 不匹配',
+    missing_hello: '缺少设备认证报文',
+    missing_auth: '设备认证超时',
+    replaced_by_new_connection: '已被新的设备连接替换',
+    config_updated: '配置已更新，正在重连',
+  }
+
+  return reasonMap[normalized] || normalized
+}
+
+function readRelayClientConfig({
+  relayUrl = process.env.PROMPTX_RELAY_URL,
+  deviceId = process.env.PROMPTX_RELAY_DEVICE_ID,
+  deviceToken = process.env.PROMPTX_RELAY_DEVICE_TOKEN,
+  enabled = process.env.PROMPTX_RELAY_ENABLED,
+  localBaseUrl = process.env.PROMPTX_RELAY_LOCAL_BASE_URL,
+} = {}) {
+  const normalizedRelayUrl = String(relayUrl || '').trim()
+  const normalizedDeviceId = String(deviceId || '').trim()
+  const normalizedDeviceToken = String(deviceToken || '').trim()
+  const hasExplicitEnabled = typeof enabled === 'boolean'
+    || (typeof enabled !== 'undefined' && String(enabled || '').trim() !== '')
+  const normalizedEnabled = hasExplicitEnabled ? String(enabled).trim().toLowerCase() : ''
+  const shouldEnable = hasExplicitEnabled
+    ? !['0', 'false', 'off', 'no'].includes(normalizedEnabled)
+    : Boolean(normalizedRelayUrl && normalizedDeviceId && normalizedDeviceToken)
+
+  return {
+    enabled: shouldEnable && Boolean(normalizedRelayUrl && normalizedDeviceId && normalizedDeviceToken),
+    relayUrl: normalizedRelayUrl,
+    websocketUrl: buildRelayWebSocketUrl(normalizedRelayUrl),
+    deviceId: normalizedDeviceId,
+    deviceToken: normalizedDeviceToken,
+    localBaseUrl: String(localBaseUrl || 'http://127.0.0.1:3000').trim() || 'http://127.0.0.1:3000',
+  }
+}
+
+function createRelayClient({
+  relayUrl,
+  deviceId,
+  deviceToken,
+  localBaseUrl,
+  logger = console,
+  appVersion = '0.0.0',
+} = {}) {
+  let config = readRelayClientConfig({
+    relayUrl,
+    deviceId,
+    deviceToken,
+    localBaseUrl,
+  })
+
+  const status = {
+    ...createDisabledStatus(),
+    enabled: config.enabled,
+    relayUrl: config.relayUrl,
+    websocketUrl: config.websocketUrl,
+    deviceId: config.deviceId,
+  }
+
+  let socket = null
+  let stopped = false
+  let reconnectTimer = null
+  let requestMap = new Map()
+  let authenticated = false
+
+  function updateStatus(patch = {}) {
+    Object.assign(status, patch)
+  }
+
+  function syncStatusFromConfig() {
+    updateStatus({
+      enabled: config.enabled,
+      relayUrl: config.relayUrl,
+      websocketUrl: config.websocketUrl,
+      deviceId: config.deviceId,
+    })
+  }
+
+  syncStatusFromConfig()
+
+  function logInfo(message, extra) {
+    if (extra) {
+      logger.info?.(extra, message)
+      return
+    }
+    logger.info?.(message)
+  }
+
+  function logWarn(message, extra) {
+    if (extra) {
+      logger.warn?.(extra, message)
+      return
+    }
+    logger.warn?.(message)
+  }
+
+  function logError(message, extra) {
+    if (extra) {
+      logger.error?.(extra, message)
+      return
+    }
+    logger.error?.(message)
+  }
+
+  function sendFrame(payload = {}) {
+    if (!socket || socket.readyState !== WebSocket.OPEN) {
+      return false
+    }
+
+    socket.send(JSON.stringify(payload))
+    return true
+  }
+
+  async function forwardLocalResponse(requestId, response) {
+    sendFrame({
+      type: 'response.start',
+      requestId,
+      status: response.status,
+      statusText: response.statusText,
+      headers: sanitizeProxyHeaders(response.headers, ['content-encoding']),
+    })
+
+    if (response.body) {
+      for await (const chunk of response.body) {
+        sendFrame({
+          type: 'response.body',
+          requestId,
+          chunk: encodeChunk(chunk),
+        })
+      }
+    } else {
+      const bodyBuffer = Buffer.from(await response.arrayBuffer())
+      if (bodyBuffer.length) {
+        sendFrame({
+          type: 'response.body',
+          requestId,
+          chunk: encodeChunk(bodyBuffer),
+        })
+      }
+    }
+
+    sendFrame({
+      type: 'response.end',
+      requestId,
+    })
+  }
+
+  async function dispatchLocalRequest(record) {
+    const bodyBuffer = Buffer.concat(record.bodyChunks)
+    const controller = new AbortController()
+    record.controller = controller
+    requestMap.set(record.requestId, record)
+
+    try {
+      const targetUrl = new URL(record.path, config.localBaseUrl)
+      const response = await fetch(targetUrl, {
+        method: record.method,
+        headers: sanitizeProxyHeaders(record.headers, ['cookie']),
+        body: ['GET', 'HEAD'].includes(record.method) || !bodyBuffer.length ? undefined : bodyBuffer,
+        signal: controller.signal,
+      })
+
+      await forwardLocalResponse(record.requestId, response)
+    } catch (error) {
+      const errorCode = error?.name === 'AbortError' ? REQUEST_CANCEL_REASON : 'relay_local_request_failed'
+      sendFrame({
+        type: 'response.error',
+        requestId: record.requestId,
+        code: errorCode,
+        message: error?.message || '本地 PromptX 请求失败。',
+      })
+    } finally {
+      requestMap.delete(record.requestId)
+    }
+  }
+
+  function handleIncomingFrame(rawPayload = '') {
+    let payload
+    try {
+      payload = JSON.parse(String(rawPayload || ''))
+    } catch {
+      return
+    }
+
+    if (payload.type === 'request.start') {
+      requestMap.set(payload.requestId, {
+        requestId: String(payload.requestId || createRelayRequestId()),
+        method: String(payload.method || 'GET').toUpperCase(),
+        path: String(payload.path || '/'),
+        headers: payload.headers || {},
+        bodyChunks: [],
+        controller: null,
+      })
+      return
+    }
+
+    if (payload.type === 'request.body') {
+      const record = requestMap.get(payload.requestId)
+      if (!record) {
+        return
+      }
+      record.bodyChunks.push(decodeChunk(payload.chunk))
+      return
+    }
+
+    if (payload.type === 'request.end') {
+      const record = requestMap.get(payload.requestId)
+      if (!record) {
+        return
+      }
+      dispatchLocalRequest(record).catch((error) => {
+        sendFrame({
+          type: 'response.error',
+          requestId: record.requestId,
+          code: 'relay_dispatch_failed',
+          message: error?.message || 'Relay 转发失败。',
+        })
+        requestMap.delete(record.requestId)
+      })
+      return
+    }
+
+    if (payload.type === 'request.cancel') {
+      const record = requestMap.get(payload.requestId)
+      record?.controller?.abort()
+    }
+  }
+
+  function scheduleReconnect() {
+    if (stopped || reconnectTimer || !config.enabled) {
+      return
+    }
+
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null
+      connect().catch(() => {})
+    }, DEFAULT_RECONNECT_DELAY_MS)
+  }
+
+  async function connect() {
+    if (!config.enabled) {
+      return
+    }
+    if (stopped || socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING) {
+      return
+    }
+
+    socket = new WebSocket(config.websocketUrl)
+    authenticated = false
+
+    socket.on('open', () => {
+      sendFrame({
+        type: 'hello',
+        deviceId: config.deviceId,
+        deviceToken: config.deviceToken,
+        version: appVersion,
+      })
+      logInfo(`[relay] WebSocket 已建立，等待设备认证 ${config.relayUrl}`)
+    })
+
+    socket.on('message', (payload, isBinary) => {
+      if (isBinary) {
+        return
+      }
+      let message = null
+      try {
+        message = JSON.parse(payload.toString('utf8'))
+      } catch {
+        return
+      }
+
+      if (message?.type === 'hello.ack') {
+        authenticated = true
+        updateStatus({
+          connected: true,
+          lastConnectedAt: new Date().toISOString(),
+          lastCloseCode: 0,
+          lastCloseReason: '',
+          lastError: '',
+        })
+        logInfo(`[relay] 已连接 ${config.relayUrl}`)
+        return
+      }
+      handleIncomingFrame(JSON.stringify(message))
+    })
+
+    socket.on('close', (code, reason) => {
+      const wasAuthenticated = authenticated
+      const closeReason = normalizeCloseReason(reason?.toString('utf8'))
+      const nextError = closeReason && closeReason !== '配置已更新，正在重连'
+        ? `${wasAuthenticated ? 'Relay 已断开' : 'Relay 连接被拒绝'}：${closeReason}`
+        : (!wasAuthenticated && code && code !== 1000 ? `Relay 连接已关闭（code=${code}）` : '')
+
+      updateStatus({
+        connected: false,
+        lastDisconnectedAt: new Date().toISOString(),
+        lastCloseCode: Number(code || 0),
+        lastCloseReason: closeReason,
+        ...(nextError ? { lastError: nextError } : {}),
+      })
+      socket = null
+      authenticated = false
+      logWarn('[relay] 连接已关闭', {
+        code: Number(code || 0),
+        reason: closeReason || 'none',
+        authenticated: wasAuthenticated,
+      })
+      scheduleReconnect()
+    })
+
+    socket.on('error', (error) => {
+      updateStatus({
+        lastError: error?.message || 'Relay 连接失败。',
+      })
+      logWarn('[relay] 连接异常', {
+        error: error?.message || String(error || ''),
+      })
+    })
+  }
+
+  return {
+    start() {
+      stopped = false
+      if (!config.enabled) {
+        syncStatusFromConfig()
+        return
+      }
+      connect().catch((error) => {
+        updateStatus({
+          lastError: error?.message || 'Relay 连接失败。',
+        })
+        logError('[relay] 初次连接失败', {
+          error: error?.message || String(error || ''),
+        })
+        scheduleReconnect()
+      })
+    },
+    stop() {
+      stopped = true
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer)
+        reconnectTimer = null
+      }
+      requestMap.forEach((record) => {
+        record.controller?.abort()
+      })
+      requestMap = new Map()
+      socket?.close()
+      socket = null
+      authenticated = false
+      updateStatus({
+        connected: false,
+      })
+    },
+    updateConfig(nextConfig = {}) {
+      const previousEnabled = config.enabled
+      config = readRelayClientConfig({
+        ...config,
+        ...nextConfig,
+      })
+      syncStatusFromConfig()
+      updateStatus({
+        lastError: '',
+      })
+
+      if (!config.enabled) {
+        this.stop()
+        return
+      }
+
+      if (!previousEnabled) {
+        this.start()
+        return
+      }
+
+      if (socket) {
+        socket.close(1012, 'config_updated')
+      } else {
+        this.start()
+      }
+    },
+    getStatus() {
+      return { ...status }
+    },
+  }
+}
+
+export {
+  createDisabledStatus,
+  createRelayClient,
+  readRelayClientConfig,
+}

package/apps/server/src/relayConfig.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { ensurePromptxStorageReady } from './appPaths.js'
+
+const RELAY_CONFIG_FILE = 'relay-config.json'
+
+function getRelayConfigPath() {
+  const { dataDir } = ensurePromptxStorageReady()
+  return path.join(dataDir, RELAY_CONFIG_FILE)
+}
+
+function normalizeRelayConfig(input = {}) {
+  const relayUrl = String(input?.relayUrl || '').trim()
+  const deviceId = String(input?.deviceId || '').trim()
+  const deviceToken = String(input?.deviceToken || '').trim()
+  const enabled = typeof input?.enabled === 'boolean'
+    ? input.enabled
+    : !['0', 'false', 'off', 'no'].includes(String(input?.enabled || '').trim().toLowerCase())
+
+  return {
+    relayUrl,
+    deviceId,
+    deviceToken,
+    enabled: Boolean(enabled && relayUrl && deviceId && deviceToken),
+  }
+}
+
+function readStoredRelayConfig() {
+  const filePath = getRelayConfigPath()
+
+  try {
+    const payload = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    return normalizeRelayConfig(payload)
+  } catch {
+    return normalizeRelayConfig()
+  }
+}
+
+function writeStoredRelayConfig(input = {}) {
+  const filePath = getRelayConfigPath()
+  const normalized = normalizeRelayConfig(input)
+  fs.writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8')
+  return normalized
+}
+
+function getRelayConfigForClient() {
+  const stored = readStoredRelayConfig()
+  const relayUrl = String(process.env.PROMPTX_RELAY_URL || stored.relayUrl || '').trim()
+  const deviceId = String(process.env.PROMPTX_RELAY_DEVICE_ID || stored.deviceId || '').trim()
+  const deviceToken = String(process.env.PROMPTX_RELAY_DEVICE_TOKEN || stored.deviceToken || '').trim()
+  const envEnabled = String(process.env.PROMPTX_RELAY_ENABLED || '').trim()
+  const managedByEnv = isRelayConfigManagedByEnv()
+  const enabled = envEnabled
+    ? !['0', 'false', 'off', 'no'].includes(envEnabled.toLowerCase())
+    : managedByEnv
+      ? Boolean(relayUrl && deviceId && deviceToken)
+      : Boolean(stored.enabled)
+
+  return normalizeRelayConfig({
+    relayUrl,
+    deviceId,
+    deviceToken,
+    enabled,
+  })
+}
+
+function isRelayConfigManagedByEnv() {
+  return Boolean(
+    String(process.env.PROMPTX_RELAY_URL || '').trim()
+    || String(process.env.PROMPTX_RELAY_DEVICE_ID || '').trim()
+    || String(process.env.PROMPTX_RELAY_DEVICE_TOKEN || '').trim()
+    || String(process.env.PROMPTX_RELAY_ENABLED || '').trim()
+  )
+}
+
+export {
+  getRelayConfigForClient,
+  getRelayConfigPath,
+  isRelayConfigManagedByEnv,
+  normalizeRelayConfig,
+  readStoredRelayConfig,
+  writeStoredRelayConfig,
+}