vibe-coding-master 0.3.9 → 0.3.11

package/README.md

@@ -142,6 +142,7 @@ Important container notes:
 - Make sure the container has network access to Claude services and to the translation provider if translation is enabled.
 - VCM accepts normal Git repositories by checking `.git` directly. It also supports `.git` files that point to worktree gitdirs.
 - VCM uses per-command `git -c safe.directory=...` for Git metadata reads and does not require global `git config --global --add safe.directory`.
+- Set `VCM_SANDBOX=devcontainer` so VCM-managed Codex Reviewer sessions rely on the container boundary and do not start Codex's nested Linux sandbox.
 - Treat the container as the sandbox boundary, especially when using relaxed Claude Code permission modes.
 
 ## Basic Usage
@@ -257,8 +258,8 @@ Gateway rules:
 Gateway state is stored locally under:
 
 ```text
-~/.vcm/gateway/settings.json
-~/.vcm/gateway/audit.jsonl
+<vcmDataDir>/gateway/settings.json
+<vcmDataDir>/gateway/audit.jsonl
 ```
 
 ### Bind Weixin
@@ -384,11 +385,13 @@ The task header does not include a manual `Refresh` button. Task status, role st
 Translation settings are local and stored in:
 
 ```text
-~/.vcm/settings.json
+<vcmDataDir>/settings.json
 ```
 
 The same file stores recent repository paths. The translation API key is stored locally under `translation.secrets.apiKey`; it is not written to the connected repository, `.ai/vcm/handoffs`, raw terminal logs, or git diffs.
 
+VCM resolves `vcmDataDir` from `VCM_DATA_DIR`. If `VCM_DATA_DIR` is unset or empty, VCM uses `~/.vcm`. In Dev Containers, set `VCM_DATA_DIR=/workspace/.ai/vcm` and `VCM_SANDBOX=devcontainer` through `containerEnv` so VCM app state survives container rebuilds and VCM-managed Codex Reviewer sessions do not run a nested Codex sandbox.
+
 The sidebar `Settings` section also stores the UI theme preference in this file. The default is `system`, which follows the OS/browser color-scheme preference; users can cycle between `System`, `Light`, and `Dark`.
 
 The same sidebar also has a `Flow pause alert` toggle. It is on by default and controls the local alert that fires when VCM detects that the current role flow has stopped advancing. Short flows use a weak reminder: the soft two-note chime plays 3 times, 1.4 seconds apart. Flows lasting 2 minutes or longer use a strong reminder: VCM shows an alert dialog and repeats the chime until the user confirms it. The alert sound reuses one browser audio context so repeated reminders remain reliable in stricter browsers such as Safari. Safari users may still need to manually set `Safari > Website Settings > Auto-Play > Allow All Auto-Play`; Chrome is recommended for the most reliable alert sound behavior. The `Try alert` button always triggers the strong reminder for testing.
@@ -479,7 +482,7 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 # VCM:END
 ```
 
-`.ai/vcm/` is the active VCM local control area, and `.claude/worktrees/` is the Claude-compatible task worktree area. VCM keeps the task index in app-local project state under `~/.vcm/projects/`; each task runtime repo keeps its own session, message, orchestration, and translation state.
+`.ai/vcm/` is the active VCM local control area, and `.claude/worktrees/` is the Claude-compatible task worktree area. VCM keeps the task index in app-local project state under `<vcmDataDir>/projects/`; each task runtime repo keeps its own session, message, orchestration, and translation state.
 
 VCM also JSON-merges `.claude/settings.json` to install Claude Code `PreToolUse`, `UserPromptSubmit`, `Stop`, and `PermissionRequest` hooks plus a managed `env.BASH_DEFAULT_TIMEOUT_MS` so foreground watch windows fit inside the Bash tool timeout. The hooks post directly to the local VCM backend, so roles do not need a VCM CLI command to confirm delivery or report turn completion. The `Stop` hook forwards the backend response to Claude Code, which lets VCM block turn-end while a validation job is still running. When Codex Review Gates are installed, VCM also writes `.ai/codex/.codex/config.toml` and `.ai/codex/.codex/hooks.json` so the embedded Codex Reviewer terminal can POST `UserPromptSubmit` and `Stop` events back to VCM.
 
@@ -606,8 +609,8 @@ Embedded terminal output is still written to raw role log files under `.ai/vcm/h
 For a connected repository, VCM uses:
 
 ```text
-~/.vcm/projects/<project-id>/config.json
-~/.vcm/projects/<project-id>/tasks/<task>.json
+<vcmDataDir>/projects/<project-id>/config.json
+<vcmDataDir>/projects/<project-id>/tasks/<task>.json
 <baseRepoRoot>/.claude/worktrees/<task>/
 <taskRepoRoot>/.ai/vcm/sessions/<task>.json
 <taskRepoRoot>/.ai/vcm/messages/<task>.jsonl
@@ -621,7 +624,17 @@ For a connected repository, VCM uses:
 <taskRepoRoot>/.ai/vcm/handoffs/logs/{project-manager,architect,coder,reviewer}.log
 ```
 
-The project config is stored under `~/.vcm` so it is durable local app state and is not hidden inside a Git-ignored repository directory. For worktree-backed tasks, `taskRepoRoot` is `<baseRepoRoot>/.claude/worktrees/<task>`; for inline tasks, `taskRepoRoot` is the connected base repo.
+The project config is stored under `vcmDataDir` so it is durable local app state. `vcmDataDir` is `VCM_DATA_DIR` when set, otherwise `~/.vcm`. For Dev Containers, prefer:
+
+```json
+{
+  "containerEnv": {
+    "VCM_DATA_DIR": "/workspace/.ai/vcm"
+  }
+}
+```
+
+For worktree-backed tasks, `taskRepoRoot` is `<baseRepoRoot>/.claude/worktrees/<task>`; for inline tasks, `taskRepoRoot` is the connected base repo.
 
 Because handoffs are scoped to `taskRepoRoot` without an extra task-name directory, VCM allows only one active inline task per connected repository. Use the default worktree mode for parallel tasks.
 

package/dist/backend/api/codex-hook-routes.js

@@ -6,4 +6,11 @@ export function registerCodexHookRoutes(app, deps) {
         await deps.codexHookService.handleStopHook(request.body);
         return {};
     });
+    app.post("/api/hooks/codex-translator", async (request) => {
+        return deps.codexHookService.handleHook(request.body);
+    });
+    app.post("/api/hooks/codex-translator/stop", async (request) => {
+        await deps.codexHookService.handleStopHook(request.body);
+        return {};
+    });
 }

package/dist/backend/api/codex-translation-routes.js

@@ -0,0 +1,50 @@
+import { VcmError } from "../errors.js";
+export function registerCodexTranslationRoutes(app, deps) {
+    app.get("/api/translation/codex/state", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.codexTranslationService.getState(project.repoRoot);
+    });
+    app.get("/api/translation/codex/source-files", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.codexTranslationService.browseSourceFiles(project.repoRoot, {
+            path: request.query.path,
+            query: request.query.query,
+            limit: request.query.limit === undefined ? undefined : Number(request.query.limit)
+        });
+    });
+    app.post("/api/translation/codex/files", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.codexTranslationService.createFileJob(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/bootstrap", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.codexTranslationService.createBootstrapRun(project.repoRoot, request.body);
+    });
+    app.get("/api/translation/codex/files/:jobId", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.codexTranslationService.readFileJobOutput(project.repoRoot, request.params.jobId);
+    });
+    app.post("/api/translation/codex/files/:jobId/promote", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const targetPath = request.body?.targetPath?.trim();
+        if (!targetPath) {
+            throw new VcmError({
+                code: "TRANSLATION_PROMOTE_TARGET_REQUIRED",
+                message: "Promote target path is required.",
+                statusCode: 400
+            });
+        }
+        return deps.codexTranslationService.promoteFileJob(project.repoRoot, request.params.jobId, targetPath);
+    });
+}
+async function requireCurrentProject(projectService) {
+    const project = await projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({
+            code: "PROJECT_NOT_CONNECTED",
+            message: "Connect a repository first.",
+            statusCode: 409
+        });
+    }
+    return project;
+}

package/dist/backend/cli/install-vcm-harness.js

@@ -6,7 +6,7 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
-import { renderCodexAgentsHarnessRules, renderCodexArchitecturePlanPrompt, renderCodexCliConfigHarnessRules, renderCodexConfigHarnessRules, renderCodexFinalDiffPrompt, renderCodexHooksHarnessRules, renderCodexReviewResultSchema, renderCodexValidationAdequacyPrompt, renderRequestCodexReviewTool, renderVcmCodexReviewGateSkillRules } from "../templates/harness/codex-review.js";
+import { renderCodexAgentsHarnessRules, renderCodexArchitecturePlanPrompt, renderCodexCliConfigHarnessRules, renderCodexConfigHarnessRules, renderCodexFinalDiffPrompt, renderCodexHooksHarnessRules, renderCodexReviewResultSchema, renderCodexTranslatorAgentsHarnessRules, renderCodexTranslatorConfigHarnessRules, renderCodexValidationAdequacyPrompt, renderRequestCodexReviewTool, renderVcmCodexReviewGateSkillRules } from "../templates/harness/codex-review.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
 import { renderGitignoreHarnessRules } from "../templates/harness/gitignore.js";
 import { renderProjectManagerHarnessRules } from "../templates/harness/project-manager-agent.js";
@@ -109,6 +109,13 @@ const MANAGED_FILES = [
         commentStyle: "html",
         category: "codex-reviewer-agent",
         content: renderCodexAgentsHarnessRules()
+    },
+    {
+        path: ".ai/codex-translator/AGENTS.md",
+        title: "VCM Codex Translator",
+        commentStyle: "html",
+        category: "codex-translator-agent",
+        content: renderCodexTranslatorAgentsHarnessRules()
     }
 ];
 const DURABLE_DOC_TEMPLATES = [
@@ -186,6 +193,24 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderCodexHooksHarnessRules()
     },
+    {
+        path: ".ai/codex-translator/config.toml",
+        category: "codex-translator-config",
+        mode: 0o644,
+        content: renderCodexTranslatorConfigHarnessRules()
+    },
+    {
+        path: ".ai/codex-translator/.codex/config.toml",
+        category: "codex-translator-hooks",
+        mode: 0o644,
+        content: renderCodexCliConfigHarnessRules()
+    },
+    {
+        path: ".ai/codex-translator/.codex/hooks.json",
+        category: "codex-translator-hooks",
+        mode: 0o644,
+        content: renderCodexHooksHarnessRules("codex-translator")
+    },
     {
         path: ".ai/codex/prompts/architecture-plan-gate.md",
         category: "codex-review-prompt",
@@ -432,6 +457,9 @@ function fixedDirectories() {
         ".ai/codex/.codex/",
         ".ai/codex/prompts/",
         ".ai/codex/schemas/",
+        ".ai/codex-translator/",
+        ".ai/codex-translator/.codex/",
+        ".ai/vcm/translations/",
         ".ai/vcm/codex-reviews/",
         ".ai/tools/",
         ".ai/generated/"

package/dist/backend/gateway/gateway-settings-service.js

@@ -1,10 +1,11 @@
 import path from "node:path";
-import { homedir } from "node:os";
+import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
 const MAX_DEDUPE_IDS = 1000;
 export function createGatewaySettingsService(deps) {
-    const settingsPath = deps.settingsPath ?? path.join(homedir(), ".vcm", "gateway", "settings.json");
-    const auditPath = deps.auditPath ?? path.join(homedir(), ".vcm", "gateway", "audit.jsonl");
+    const dataDir = resolveVcmDataDir();
+    const settingsPath = deps.settingsPath ?? path.join(dataDir, "gateway", "settings.json");
+    const auditPath = deps.auditPath ?? path.join(dataDir, "gateway", "audit.jsonl");
     const now = deps.now ?? (() => new Date().toISOString());
     let cachedSettings = null;
     async function loadSettings() {

package/dist/backend/server.js

@@ -12,6 +12,7 @@ import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createCodexReviewService } from "./services/codex-review-service.js";
+import { createCodexTranslationService } from "./services/codex-translation-service.js";
 import { createHarnessService, createScriptFixedHarnessInstaller } from "./services/harness-service.js";
 import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
 import { createNodePtyTerminalRuntime } from "./runtime/node-pty-runtime.js";
@@ -37,6 +38,7 @@ import { registerArtifactRoutes } from "./api/artifact-routes.js";
 import { registerClaudeHookRoutes } from "./api/claude-hook-routes.js";
 import { registerCodexHookRoutes } from "./api/codex-hook-routes.js";
 import { registerCodexReviewRoutes } from "./api/codex-review-routes.js";
+import { registerCodexTranslationRoutes } from "./api/codex-translation-routes.js";
 import { registerHarnessRoutes } from "./api/harness-routes.js";
 import { registerMessageRoutes } from "./api/message-routes.js";
 import { registerProjectRoutes } from "./api/project-routes.js";
@@ -69,6 +71,10 @@ export async function createServer(deps, options = {}) {
         projectService: deps.projectService,
         codexReviewService: deps.codexReviewService
     });
+    registerCodexTranslationRoutes(app, {
+        projectService: deps.projectService,
+        codexTranslationService: deps.codexTranslationService
+    });
     registerProjectRoutes(app, { projectService: deps.projectService });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
@@ -169,7 +175,8 @@ export function createDefaultServerDeps(options = {}) {
         artifactService,
         projectService,
         taskService,
-        apiUrl: options.apiUrl
+        apiUrl: options.apiUrl,
+        sandboxMode: process.env.VCM_SANDBOX
     });
     const commandDispatcher = createCommandDispatcher({
         runtime,
@@ -205,12 +212,18 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         roundService
     });
+    const codexTranslationService = createCodexTranslationService({
+        fs,
+        runtime,
+        sessionService
+    });
     const transcripts = createClaudeTranscriptService();
     const translationService = createTranslationService({
         runtime,
         sessionRegistry: registry,
         transcripts,
         sessionService,
+        codexTranslationService,
         fs,
         projectService,
         appSettings,
@@ -250,7 +263,8 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         sessionService,
-        roundService
+        roundService,
+        codexTranslationService
     });
     const diagnosticsService = createDiagnosticsService({
         appRoot: getAppRoot(),
@@ -270,6 +284,7 @@ export function createDefaultServerDeps(options = {}) {
         codexHookService,
         messageService,
         codexReviewService,
+        codexTranslationService,
         roundService,
         statusService,
         translationService,

package/dist/backend/services/app-settings-service.js

@@ -1,13 +1,13 @@
 import path from "node:path";
-import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
 import { createDefaultLaunchTemplate } from "../../shared/types/app-settings.js";
 import { CLAUDE_MODEL_OPTIONS, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
+import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const MAX_RECENT_REPOSITORIES = 5;
 export function createAppSettingsService(deps) {
-    const settingsPath = deps.settingsPath ?? path.join(homedir(), ".vcm", "settings.json");
+    const settingsPath = deps.settingsPath ?? path.join(resolveVcmDataDir(), "settings.json");
     const settingsRoot = path.dirname(settingsPath);
     const projectIndexPath = path.join(settingsRoot, "projects", "index.json");
     let cachedSettings = null;

package/dist/backend/services/artifact-service.js

@@ -42,7 +42,8 @@ export function createArtifactService(fs) {
                     architect: path.posix.join(logsDir, "architect.log"),
                     coder: path.posix.join(logsDir, "coder.log"),
                     reviewer: path.posix.join(logsDir, "reviewer.log"),
-                    "codex-reviewer": path.posix.join(logsDir, "codex-reviewer.log")
+                    "codex-reviewer": path.posix.join(logsDir, "codex-reviewer.log"),
+                    "codex-translator": path.posix.join(logsDir, "codex-translator.log")
                 },
                 messageRoutePaths: getDefaultMessageRoutePaths(messagesDir),
                 architecturePlanPath: path.posix.join(handoffDir, "architecture-plan.md"),

package/dist/backend/services/codex-hook-service.js

@@ -1,9 +1,9 @@
+import { isCodexRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
-const CODEX_REVIEWER_ROLE = "codex-reviewer";
 export function createCodexHookService(deps) {
     async function getHookContext(input) {
-        if (input.role !== CODEX_REVIEWER_ROLE) {
+        if (!isCodexRoleName(input.role)) {
             throw new VcmError({
                 code: "CODEX_HOOK_ROLE_INVALID",
                 message: `Unknown Codex hook role: ${input.role}`,
@@ -14,7 +14,7 @@ export function createCodexHookService(deps) {
         if (!project) {
             throw new VcmError({
                 code: "PROJECT_NOT_CONNECTED",
-                message: "Connect a repository before accepting Codex Reviewer hooks.",
+                message: "Connect a repository before accepting Codex hooks.",
                 statusCode: 409
             });
         }
@@ -32,14 +32,14 @@ export function createCodexHookService(deps) {
         if (eventName !== expectedEventName) {
             throw new VcmError({
                 code: "CODEX_HOOK_EVENT_UNSUPPORTED",
-                message: `Unsupported Codex Reviewer hook event for this endpoint: ${eventName}`,
+                message: `Unsupported Codex hook event for this endpoint: ${eventName}`,
                 statusCode: 400
             });
         }
         const context = await getHookContext(input);
         const session = await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
             taskSlug: input.taskSlug,
-            role: CODEX_REVIEWER_ROLE,
+            role: input.role,
             eventName,
             sessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
@@ -51,14 +51,17 @@ export function createCodexHookService(deps) {
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
             taskSlug: input.taskSlug,
-            role: CODEX_REVIEWER_ROLE,
+            role: input.role,
             eventName
         });
+        if (input.role === "codex-translator") {
+            await deps.codexTranslationService?.handleCodexHook(context.project.repoRoot, eventName, input.taskSlug);
+        }
         return {
             ok: true,
             eventName,
             taskSlug: input.taskSlug,
-            role: CODEX_REVIEWER_ROLE,
+            role: input.role,
             sessionUpdated: Boolean(session)
         };
     }
@@ -77,9 +80,9 @@ function parseHookEvent(value) {
     }
     throw new VcmError({
         code: "CODEX_HOOK_EVENT_UNSUPPORTED",
-        message: `Unsupported Codex Reviewer hook event: ${String(value)}`,
+        message: `Unsupported Codex hook event: ${String(value)}`,
         statusCode: 400,
-        hint: "VCM accepts Codex Reviewer UserPromptSubmit and Stop hooks only."
+        hint: "VCM accepts Codex UserPromptSubmit and Stop hooks only."
     });
 }
 function stringOrUndefined(value) {