nodebbs 0.2.0 → 0.3.0-beta.0

package/dist/commands/pack/index.js

@@ -4,7 +4,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { getTemplatePath } from '../../utils/template.js';
-import { checkDocker } from '../../utils/docker.js';
+import { checkDocker, getComposeFiles, runCompose } from '../../utils/docker.js';
+import { getDeploymentMode } from '../../utils/selection.js';
 export default class Pack extends Command {
     static description = '生成离线部署包';
     static flags = {
@@ -19,63 +20,66 @@ export default class Pack extends Command {
         const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nodebbs-pack-'));
         this.log(`正在准备构建环境: ${tmpDir}`);
         try {
+            const mode = await getDeploymentMode();
+            if (mode !== 'source') {
+                this.error('打包命令仅支持源码部署模式。请在 NodeBBS 项目根目录下运行 (需要包含 package.json 和源代码)。');
+            }
             // 2. 导出配置文件
-            // 这里我们需要获取当前的 docker-compose.yml 和 prod 配置
-            // 假设用户当前目录下有这些文件，或者我们就用内置模板？
-            // 更好的方式是：如果在当前目录找到了配置文件，就用当前的；否则用内置模板。
-            // 但既然是打包，通常是想把当前开发好的代码打包。
-            // 所以我们假设在项目根目录运行。
-            if (!fs.existsSync('docker-compose.yml')) {
-                // TODO: 从 templates 复制 (简化起见，我们假设用户在项目根目录，或者我们强制要求)
-                // 如果没找到，我们实际上无法 build api/web，因为 build context 需要源码。
-                // 所以必须要求在项目根目录运行。
-                this.error('请在 NodeBBS 项目根目录下运行此命令 (需要包含 docker-compose.yml 和源代码)。');
+            // 使用 getComposeFiles 获取准确的配置文件路径 (包含 base 和 override)
+            // 默认打包生产环境配置
+            const { files, isBuiltIn } = await getComposeFiles('production');
+            if (isBuiltIn) {
+                console.warn('当前目录未找到 docker-compose.yml，将使用内置模板。');
             }
-            // 3. 构建镜像
-            this.log('正在构建应用镜像 (这可能通过需要几分钟)...');
-            await execa('docker', ['compose', 'build'], { stdio: 'inherit' });
+            // 3. 构建应用镜像
+            this.log('正在构建应用镜像 (这可能需要几分钟)...');
+            // 注意：如果使用内置模板，context 可能是错的，但 build 命令通常需要 context。
+            // getComposeFiles 返回的 file path 是绝对路径。
+            // 如果是 isBuiltIn，说明用的是 cli/templates/docker-compose.yml
+            // 在 source 模式下，如果必须用内置模板作为 base，我们需要确保 build context 正确。
+            // 如果我们只是为了获取 content，那没问题。但 docker compose build 需要 context。
+            // 我们之前 manual check 的时候，如果 missing local file, we fallback to template path.
+            // runCompose 会 handle -f arguments.
+            // 这里为了简单，我们直接运行 build。
+            // 但要注意，如果 isBuiltIn，runCompose 会自动加 --project-directory cwd
+            // 这里我们主要目的是打包，所以 build 应该基于 cwd。
+            // 原有逻辑直接 execa('docker', ['compose', 'build'])，这依赖于 cwd 下有 docker-compose.yml。
+            // 如果 cwd 下没有，我们需要传 -f。
+            // 所以这里应该使用 runCompose 来执行 build，以确保参数一致性
+            await runCompose(files, ['build'], isBuiltIn);
             // 4. 拉取依赖镜像
             this.log('正在确保数据库镜像已下载...');
             await execa('docker', ['pull', 'postgres:16-alpine'], { stdio: 'inherit' });
             await execa('docker', ['pull', 'redis:7-alpine'], { stdio: 'inherit' });
             // 5. 导出镜像
             this.log('正在导出镜像到文件 (nodebbs-images.tar)...');
-            // 获取实际的镜像名，这里假设 docker-compose build 生成的镜像名符合预期
-            // 通常是 <dir>_api 和 <dir>_web，或者我们在 compose 文件里指定了 image name?
-            // 查看 template: 没有指定 image name，所以默认为 ${dirname}-api。
-            // 为了确保准确，我们可以解析 docker compose config 的输出，或者强制指定 image name。
-            // 更稳妥的方式：直接 save 指定的服务镜像。
-            // docker compose images -q 可以获取 ID。
             // 获取所有相关镜像的列表
             const projectName = path.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9]/g, '');
-            const images = [
-                'postgres:16-alpine',
-                'redis:7-alpine',
-                `${projectName}-api`, // 默认命名规则
-                `${projectName}-web`
-            ];
-            // 我们最好通过 docker compose config 来确认镜像名，但这比较复杂。
+            // 我们最好通过 docker compose config 来确认镜像名
             // 简单策略：先 save postgres 和 redis，对于 api 和 web，我们先 tag 一下以确保名字固定。
             await execa('docker', ['tag', `${projectName}-api`, 'nodebbs-api:latest']);
             await execa('docker', ['tag', `${projectName}-web`, 'nodebbs-web:latest']);
             const imagesToSave = ['postgres:16-alpine', 'redis:7-alpine', 'nodebbs-api:latest', 'nodebbs-web:latest'];
             await execa('docker', ['save', '-o', path.join(tmpDir, 'nodebbs-images.tar'), ...imagesToSave], { stdio: 'inherit' });
-            // 6. 复制配置文件 (并进行修改)
-            // 读取 docker-compose.yml 并移除开发环境的源码挂载
-            // 这是一个关键步骤，因为在离线/生产环境中，我们不应该挂载 ./apps/xxx/src，
-            // 否则会覆盖掉镜像内构建好的代码，导致 "Cannot find module" 错误。
-            let composeContent = fs.readFileSync('docker-compose.yml', 'utf-8');
+            // 6. 复制配置文件 (并进行修改) - 移除源码挂载，适配离线环境
+            // files[0] -> Base
+            // files[1] -> Override (Optional)
+            const baseFile = files[0];
+            let composeContent = fs.readFileSync(baseFile, 'utf-8');
             const lines = composeContent.split('\n');
             const cleanedLines = lines.map(line => {
                 // 移除 api 和 web 的源码挂载
-                if (line.includes('./apps/api/src') || line.includes('./apps/web/src')) {
+                if (line.match(/- \.\/apps\/.*\/src:\/app\/apps\/.*\/src/)) {
                     return line.replace(/^/, '# [OFFLINE-PACK-REMOVED] ');
                 }
                 return line;
             });
             fs.writeFileSync(path.join(tmpDir, 'docker-compose.yml'), cleanedLines.join('\n'));
-            if (fs.existsSync('docker-compose.prod.yml')) {
-                fs.copyFileSync('docker-compose.prod.yml', path.join(tmpDir, 'docker-compose.prod.yml'));
+            // 处理 Override 文件 (files[1])
+            // 我们的 install.sh 期望 docker-compose.prod.yml
+            if (files.length > 1) {
+                const overrideFile = files[1];
+                fs.copyFileSync(overrideFile, path.join(tmpDir, 'docker-compose.prod.yml'));
             }
             if (fs.existsSync('.env')) {
                 this.warn('检测到 .env 文件，出于安全考虑，不会默认打包 .env 文件。请在部署时手动配置环境变量。');
@@ -100,14 +104,9 @@ if [ ! -f .env ]; then
     echo "警告: 未找到 .env 文件，将使用默认配置或报错。请先复制 .env.example 为 .env 并修改配置。"
 fi
 
-# 修改 image 名称以匹配 load 进来的 tag (如果 compose 文件里没写 image，它会尝试 build)
-# 为了避免 build，我们需要修改 docker-compose.yml 或者使用环境变量 override
-# 最简单的办法：我们在 install 脚本里，强制用 docker run 或者修改 compose 文件?
-# 这里的难点是 compose file 里写的是 build: .
-# 离线环境没法 build。
-# 解决方案：生成一个专门的 docker-compose.offline.yml
-
-cat > docker-compose.override.yml <<EOF
+# 启动服务 (强制使用离线镜像)
+# 我们需要覆盖 build 配置，强制使用 image
+cat > docker-compose.offline.yml <<EOF
 services:
   api:
     build: !reset
@@ -117,7 +116,21 @@ services:
     image: nodebbs-web:latest
 EOF
 
-docker compose -f docker-compose.yml -f docker-compose.prod.yml -f docker-compose.override.yml up -d
+# 注意：这里假设第二个文件总是 docker-compose.prod.yml
+# 如果没有 override，命令可能会报错吗？
+# 我们在 pack 的时候，只要 files > 1，就生成了 docker-compose.prod.yml
+# 如果只有 base，install.sh 里的 -f docker-compose.prod.yml 会报错。
+# 应该动态生成 install.sh 或者在这里加判断。
+# 简单起见，我们确保 docker-compose.prod.yml 存在 (即使只是空的内容或者仅包含 version?)
+# 或者在 install.sh 里判断文件是否存在。
+
+COMPOSE_Args="-f docker-compose.yml"
+if [ -f docker-compose.prod.yml ]; then
+    COMPOSE_Args="$COMPOSE_Args -f docker-compose.prod.yml"
+fi
+COMPOSE_Args="$COMPOSE_Args -f docker-compose.offline.yml"
+
+docker compose $COMPOSE_Args up -d
 
 echo "部署完成！"
 `;
@@ -138,7 +151,9 @@ echo "部署完成！"
         }
         finally {
             // 清理临时目录
-            fs.rmSync(tmpDir, { recursive: true, force: true });
+            if (fs.existsSync(tmpDir)) {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
         }
     }
 }

package/dist/commands/restart/index.js

@@ -1,9 +1,10 @@
 import { Command } from '@oclif/core';
 import { runCompose, getComposeFiles } from '../../utils/docker.js';
 import { logger } from '../../utils/logger.js';
-import { EnvFlag, selectEnvironment } from '../../utils/selection.js';
+import { EnvFlag, selectEnvironment, getDeploymentMode } from '../../utils/selection.js';
+import { initImageEnv } from '../../utils/env.js';
 export default class Restart extends Command {
-    static description = '重启所有服务 (up --force-recreate)';
+    static description = '重启服务';
     static flags = {
         env: EnvFlag,
     };
@@ -13,12 +14,17 @@ export default class Restart extends Command {
         const env = await selectEnvironment(flags.env);
         const { files, isBuiltIn } = await getComposeFiles(env);
         logger.info('正在重启服务 (使用现有镜像)...');
-        logger.info('环境: ' + env);
-        // 使用 up -d --force-recreate 可以：
-        // 1. 如果服务不存在，则创建并启动
-        // 2. 如果服务已存在，则强制重启
+        // 确保镜像配置存在
+        await initImageEnv();
+        const mode = await getDeploymentMode();
+        logger.info(`环境: ${env} (${mode === 'image' ? '镜像部署' : '源码部署'})`);
         // 3. 不会执行构建 (除非镜像不存在)
-        await runCompose(files, ['up', '-d', '--force-recreate'], isBuiltIn);
+        // 在镜像模式下，我们需要确保不尝试构建 (哪怕镜像丢失，应该是 pull 而不是 build)
+        const args = ['up', '-d', '--force-recreate'];
+        if (mode === 'image') {
+            args.push('--no-build');
+        }
+        await runCompose(files, args, isBuiltIn);
         logger.success('服务已重启');
     }
 }

package/dist/commands/start/index.js

@@ -1,12 +1,12 @@
 import { Command, Flags } from '@oclif/core';
 import { confirm } from '@inquirer/prompts';
 import { checkDocker, runCompose, waitForHealth, execCompose, getComposeFiles } from '../../utils/docker.js';
-import { initEnv, checkEnv } from '../../utils/env.js';
+import { initEnv, checkEnv, initDockerIgnore, initImageEnv } from '../../utils/env.js';
 import { logger } from '../../utils/logger.js';
 import dotenv from 'dotenv';
-import { EnvFlag, selectEnvironment } from '../../utils/selection.js';
+import { EnvFlag, selectEnvironment, getDeploymentMode } from '../../utils/selection.js';
 export default class Start extends Command {
-    static description = '开始部署';
+    static description = '启动服务';
     static flags = {
         env: EnvFlag,
         build: Flags.boolean({
@@ -49,6 +49,9 @@ export default class Start extends Command {
         await checkDocker();
         // initEnv 保证 .env 存在（或退出）
         await initEnv();
+        // 确保 .dockerignore 存在
+        await initDockerIgnore();
+        await initImageEnv();
         await checkEnv(env);
         if (!flags.build) {
             const continueDeploy = await confirm({
@@ -61,15 +64,31 @@ export default class Start extends Command {
             }
         }
         // 4. 构建并启动服务
+        const mode = await getDeploymentMode();
         if (flags.build) {
-            logger.info('正在重新构建并启动服务...');
-            await runCompose(composeFiles, ['up', '-d', '--build'], isBuiltIn);
-            logger.success('服务已重新构建并启动');
+            if (mode === 'image') {
+                logger.warning('镜像部署模式下不支持重新构建，将尝试拉取最新镜像...');
+                await runCompose(composeFiles, ['pull'], isBuiltIn);
+                await runCompose(composeFiles, ['up', '-d'], isBuiltIn);
+                logger.success('服务已更新并启动');
+            }
+            else {
+                logger.info('正在重新构建并启动服务...');
+                await runCompose(composeFiles, ['up', '-d', '--build'], isBuiltIn);
+                logger.success('服务已重新构建并启动');
+            }
         }
         else {
-            logger.info('正在构建 Docker 镜像...');
-            await runCompose(composeFiles, ['build', '--no-cache'], isBuiltIn);
-            logger.success('镜像构建完成');
+            if (mode === 'source') {
+                logger.info('正在构建 Docker 镜像...');
+                await runCompose(composeFiles, ['build', '--no-cache'], isBuiltIn);
+                logger.success('镜像构建完成');
+            }
+            else {
+                logger.info('检测到镜像部署模式，跳过本地构建...');
+                // 可选：在这里也可以尝试 pull 一下，或者让 up -d 自动处理
+                // await runCompose(composeFiles, ['pull'], isBuiltIn)
+            }
             logger.info('正在启动服务...');
             await runCompose(composeFiles, ['up', '-d'], isBuiltIn);
             logger.success('服务启动指令已发送');
@@ -98,7 +117,7 @@ export default class Start extends Command {
         }
         logger.header(flags.build ? '启动成功！' : 'NodeBBS 启动成功！');
         // 6. 显示信息
-        logger.info(`环境: ${env}`);
+        logger.info(`环境: ${env} (${mode === 'image' ? '镜像部署' : '源码部署'})`);
         const envConfig = dotenv.config().parsed || {};
         const webPort = envConfig.WEB_PORT || '3100';
         const apiPort = envConfig.API_PORT || '7100';

package/dist/commands/upgrade/index.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class Upgrade extends Command {
+    static description: string;
+    static flags: {
+        env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/upgrade/index.js

@@ -0,0 +1,39 @@
+import { Command } from '@oclif/core';
+import { runCompose, getComposeFiles } from '../../utils/docker.js';
+import { logger } from '../../utils/logger.js';
+import { EnvFlag, selectEnvironment, getDeploymentMode } from '../../utils/selection.js';
+import { initImageEnv } from '../../utils/env.js';
+import Start from '../start/index.js';
+export default class Upgrade extends Command {
+    static description = '升级服务';
+    static flags = {
+        env: EnvFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(Upgrade);
+        // 1. 检查部署模式
+        const mode = await getDeploymentMode();
+        if (mode === 'source') {
+            logger.info('当前为源码部署模式，执行重建...');
+            const args = ['--build'];
+            if (flags.env)
+                args.push('--env', flags.env);
+            await Start.run(args);
+            return;
+        }
+        // 2. 镜像模式：拉取更新并重启
+        logger.header('NodeBBS 服务升级');
+        // 选择环境 (通常需要与运行中一致，这里重新选择以防万一，或者可以复用 restart 的逻辑不传 env 则自选)
+        //为了简单，我们遵循 restart 的模式
+        const env = await selectEnvironment(flags.env);
+        // 确保镜像配置存在
+        await initImageEnv();
+        const { files, isBuiltIn } = await getComposeFiles(env);
+        logger.info('正在拉取最新镜像...');
+        await runCompose(files, ['pull'], isBuiltIn);
+        logger.success('镜像已更新');
+        logger.info('正在重新启动服务...');
+        await runCompose(files, ['up', '-d'], isBuiltIn);
+        logger.success('服务已升级并启动');
+    }
+}

package/dist/interactive.js

@@ -29,7 +29,7 @@ export async function runInteractive(root) {
     }
     await navigate(tree, [], config);
 }
-const GLOBAL_PRIORITY = ['start', 'stop', 'restart', 'rebuild', 'status', 'logs', 'shell', 'db', 'pack'];
+const GLOBAL_PRIORITY = ['start', 'stop', 'restart', 'upgrade', 'status', 'logs', 'shell', 'db', 'pack'];
 const SCOPED_PRIORITIES = {
     'logs': ['all', 'web', 'api', 'db', 'redis'],
 };

package/dist/templates/docker-compose.build.yml

@@ -0,0 +1,10 @@
+services:
+  api:
+    build:
+      context: .
+      dockerfile: apps/api/Dockerfile
+
+  web:
+    build:
+      context: .
+      dockerfile: apps/web/Dockerfile

package/dist/templates/docker-compose.lowmem.yml

@@ -3,17 +3,10 @@
 # 使用方式: docker compose -f docker-compose.yml -f docker-compose.lowmem.yml up -d
 
 services:
-  # PostgreSQL 数据库 - 低内存优化
+  # PostgreSQL - 低内存优化
   postgres:
     restart: always
-    ports: []  # 不暴露端口到主机，只在内部网络访问
-    environment:
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
-    healthcheck:
-      interval: 30s
-      timeout: 10s
-      retries: 5
-      start_period: 40s
+    ports: []
     deploy:
       resources:
         limits:
@@ -28,24 +21,19 @@ services:
         max-size: "5m"
         max-file: "2"
 
-  # Redis 缓存 - 低内存优化
+  # Redis - 低内存优化
   redis:
     restart: always
+    ports: []
     command: >
       redis-server
-      --requirepass ${REDIS_PASSWORD}
+      --requirepass ${REDIS_PASSWORD:-redis_password}
       --appendonly yes
       --appendfsync everysec
       --maxmemory 128mb
       --maxmemory-policy allkeys-lru
       --save 900 1
       --save 300 10
-    ports: []  # 不暴露端口到主机
-    healthcheck:
-      interval: 30s
-      timeout: 10s
-      retries: 5
-      start_period: 20s
     deploy:
       resources:
         limits:
@@ -60,21 +48,12 @@ services:
         max-size: "5m"
         max-file: "2"
 
-  # API 服务 - 低内存优化
+  # API - 低内存优化
   api:
     restart: always
     environment:
-      USER_CACHE_TTL: ${USER_CACHE_TTL:-300}
-      JWT_SECRET: ${JWT_SECRET}
-      CORS_ORIGIN: ${CORS_ORIGIN}
-      APP_URL: ${APP_URL}
-      # Node.js 内存限制
+      # 严格限制 Node.js 内存
       NODE_OPTIONS: "--max-old-space-size=384"
-    volumes:
-      - api_uploads:/app/apps/api/uploads
-    healthcheck:
-      start_period: 90s  # 低内存环境启动更慢
-      interval: 60s
     deploy:
       resources:
         limits:
@@ -89,21 +68,12 @@ services:
         max-size: "10m"
         max-file: "3"
 
-  # Web 前端服务 - 低内存优化
+  # Web - 低内存优化
   web:
     restart: always
-    build:
-      args:
-        NEXT_PUBLIC_API_URL: ${NEXT_PUBLIC_API_URL}
-        NEXT_PUBLIC_APP_URL: ${NEXT_PUBLIC_APP_URL}
     environment:
-      NEXT_PUBLIC_API_URL: ${NEXT_PUBLIC_API_URL}
-      NEXT_PUBLIC_APP_URL: ${NEXT_PUBLIC_APP_URL}
-      # Node.js 内存限制
+      # 严格限制 Node.js 内存
       NODE_OPTIONS: "--max-old-space-size=384"
-    healthcheck:
-      start_period: 90s  # 低内存环境启动更慢
-      interval: 60s
     deploy:
       resources:
         limits:
@@ -118,9 +88,4 @@ services:
         max-size: "10m"
         max-file: "3"
 
-# 网络配置
-networks:
-  nodebbs-network:
-    ipam:
-      config:
-        - subnet: 172.28.0.0/16
+

package/dist/templates/docker-compose.prod.yml

@@ -3,17 +3,10 @@
 # 本文件只包含与 docker-compose.yml 的差异部分
 
 services:
-  # PostgreSQL 数据库 - 生产环境优化
+  # PostgreSQL - 生产环境安全与资源优化
   postgres:
     restart: always
-    ports: []  # 生产环境不暴露端口到主机，只在内部网络访问
-    environment:
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}  # 生产环境必须设置强密码
-    healthcheck:
-      interval: 30s
-      timeout: 10s
-      retries: 5
-      start_period: 40s
+    ports: []  # 安全：不暴露端口到主机
     deploy:
       resources:
         limits:
@@ -28,9 +21,10 @@ services:
         max-size: "10m"
         max-file: "3"
 
-  # Redis 缓存 - 生产环境优化
+  # Redis - 生产环境安全与资源优化
   redis:
     restart: always
+    ports: []  # 安全：不暴露端口到主机
     command: >
       redis-server
       --requirepass ${REDIS_PASSWORD}
@@ -38,12 +32,6 @@ services:
       --appendfsync everysec
       --maxmemory 256mb
       --maxmemory-policy allkeys-lru
-    ports: []  # 生产环境不暴露端口到主机
-    healthcheck:
-      interval: 30s
-      timeout: 10s
-      retries: 5
-      start_period: 20s
     deploy:
       resources:
         limits:
@@ -58,19 +46,12 @@ services:
         max-size: "10m"
         max-file: "3"
 
-  # API 服务 - 生产环境优化
+  # API - 生产环境资源优化
   api:
     restart: always
     environment:
-      USER_CACHE_TTL: ${USER_CACHE_TTL:-300}  # 生产环境缓存时间更长
-      JWT_SECRET: ${JWT_SECRET}  # 生产环境必须设置
-      CORS_ORIGIN: ${CORS_ORIGIN}  # 生产环境必须明确设置
-      APP_URL: ${APP_URL}  # 生产环境实际域名
-      NODE_OPTIONS: "--max-old-space-size=512"  # 限制 Node.js 内存使用
-    volumes:
-      - api_uploads:/app/apps/api/uploads  # 生产环境不挂载源代码
-    healthcheck:
-      start_period: 60s
+      # 生产环境特有配置
+      NODE_OPTIONS: "--max-old-space-size=512"
     deploy:
       resources:
         limits:
@@ -85,19 +66,12 @@ services:
         max-size: "20m"
         max-file: "5"
 
-  # Web 前端服务 - 生产环境优化
+  # Web - 生产环境资源优化
   web:
     restart: always
-    build:
-      args:
-        NEXT_PUBLIC_API_URL: ${NEXT_PUBLIC_API_URL}
-        NEXT_PUBLIC_APP_URL: ${NEXT_PUBLIC_APP_URL}
     environment:
-      NEXT_PUBLIC_API_URL: ${NEXT_PUBLIC_API_URL}
-      NEXT_PUBLIC_APP_URL: ${NEXT_PUBLIC_APP_URL}
-      NODE_OPTIONS: "--max-old-space-size=512"  # 限制 Node.js 内存使用
-    healthcheck:
-      start_period: 60s
+      # 生产环境特有配置
+      NODE_OPTIONS: "--max-old-space-size=512"
     deploy:
       resources:
         limits:
@@ -112,9 +86,4 @@ services:
         max-size: "20m"
         max-file: "5"
 
-# 网络 - 生产环境使用固定子网
-networks:
-  nodebbs-network:
-    ipam:
-      config:
-        - subnet: 172.28.0.0/16
+

package/dist/templates/docker-compose.yml

@@ -11,7 +11,7 @@ services:
       TZ: Asia/Shanghai
     volumes:
       - postgres_data:/var/lib/postgresql/data
-      - ${INIT_DB_PATH:-./scripts/init-db.sql}:/docker-entrypoint-initdb.d/init.sql:ro
+
     ports:
       - "${POSTGRES_PORT:-5432}:5432"
     healthcheck:
@@ -45,8 +45,9 @@ services:
   # API 服务
   api:
     build:
-      context: .  # 从 monorepo 根目录构建（turbo prune 需要完整的 workspace）
+      context: ../../
       dockerfile: apps/api/Dockerfile
+    image: ${API_IMAGE:-nodebbs-api:local}
     container_name: nodebbs-api
     restart: unless-stopped
     environment:
@@ -64,7 +65,7 @@ services:
       TZ: Asia/Shanghai
     volumes:
       - api_uploads:/app/apps/api/uploads
-      - ./apps/api/src:/app/apps/api/src:ro
+      # - ./apps/api/src:/app/apps/api/src:ro
     ports:
       - "${API_PORT:-7100}:7100"
     depends_on:
@@ -84,19 +85,16 @@ services:
   # Web 前端服务
   web:
     build:
-      context: .  # 从 monorepo 根目录构建（turbo prune 需要完整的 workspace）
+      context: ../../
       dockerfile: apps/web/Dockerfile
-      args:
-        NEXT_PUBLIC_API_URL: ${NEXT_PUBLIC_API_URL:-http://localhost:7100}
-        NEXT_PUBLIC_APP_URL: ${NEXT_PUBLIC_APP_URL:-http://localhost:3100}
+    image: ${WEB_IMAGE:-nodebbs-web:local}
     container_name: nodebbs-web
     restart: unless-stopped
     environment:
       NODE_ENV: production
       APP_NAME: ${APP_NAME:-nodebbs}
       PORT: 3100
-      NEXT_PUBLIC_API_URL: ${NEXT_PUBLIC_API_URL:-http://localhost:7100}
-      NEXT_PUBLIC_APP_URL: ${NEXT_PUBLIC_APP_URL:-http://localhost:3100}
+      SERVER_API_URL: ${SERVER_API_URL:-http://api:7100}
       TZ: Asia/Shanghai
     ports:
       - "${WEB_PORT:-3100}:3100"