vibe64 0.1.21 → 0.1.22

package/packages/vibe64-terminals/src/server/registerRoutes.js

@@ -1,10 +1,17 @@
 import {
   codexAttachmentInputValidator,
   commandTerminalInputValidator,
+  fixCodexReportInputValidator,
   launchTargetInputValidator,
+  projectToolFixInputValidator,
+  projectToolRunInputValidator,
+  sessionTerminalFixInputValidator,
   shellTerminalInputValidator
 } from "./inputSchemas.js";
 import {
+  ACTION_RUN_PROJECT_TOOL,
+  ACTION_START_PROJECT_TOOL_FIX,
+  ACTION_START_SESSION_TERMINAL_FIX,
   ACTION_OPEN_LAUNCH_TARGET,
   ACTION_START_COMMAND_TERMINAL,
   ACTION_START_LAUNCH_TARGET_TERMINAL,
@@ -39,6 +46,61 @@ function registerRoutes(
   });
   const terminalService = () => getTerminalService(app);
 
+  routes.serviceRoute("GET", "/codex-terminal", {
+    summary: "Read global Vibe64 Codex terminal status."
+  }, () => {
+    return terminalService().globalCodexTerminalState();
+  });
+
+  routes.serviceRoute("POST", "/codex-terminal", {
+    summary: "Start a global Vibe64 Codex terminal."
+  }, () => {
+    return terminalService().startGlobalCodexTerminal();
+  });
+
+  routes.actionRoute("POST", "/tools/:toolId/run", {
+    actionId: ACTION_RUN_PROJECT_TOOL,
+    body: projectToolRunInputValidator,
+    buildInput(request) {
+      return {
+        ...routes.requestBody(request),
+        toolId: request.params.toolId
+      };
+    },
+    summary: "Run a Vibe64 project tool."
+  });
+
+  routes.actionRoute("POST", "/tools/:toolId/fix", {
+    actionId: ACTION_START_PROJECT_TOOL_FIX,
+    body: projectToolFixInputValidator,
+    buildInput(request) {
+      return {
+        ...routes.requestBody(request),
+        toolId: request.params.toolId
+      };
+    },
+    summary: "Start an ephemeral Fix Codex job for a Vibe64 project tool failure."
+  });
+
+  routes.serviceRoute("POST", "/fix-codex-jobs/:jobId/report", {
+    body: fixCodexReportInputValidator,
+    summary: "Report an ephemeral Fix Codex job result."
+  }, (request) => {
+    return terminalService().reportFixCodexJob(request.params.jobId, routes.requestBody(request));
+  });
+
+  routes.actionRoute("POST", "/sessions/:sessionId/terminal-failure-fix", {
+    actionId: ACTION_START_SESSION_TERMINAL_FIX,
+    body: sessionTerminalFixInputValidator,
+    buildInput(request) {
+      return {
+        ...routes.requestBody(request),
+        sessionId: request.params.sessionId
+      };
+    },
+    summary: "Start an ephemeral Fix Codex job for a Vibe64 session terminal failure."
+  });
+
   routes.serviceRoute("GET", "/sessions/:sessionId/launch-targets", {
     summary: "Read Vibe64 launch target status."
   }, (request) => {
@@ -110,6 +172,30 @@ function registerRoutes(
     closeSummary: "Close an Vibe64 Codex terminal."
   });
 
+  registerGlobalTerminalSnapshotRoutes(routes, {
+    close: (terminalSessionId) => terminalService().closeGlobalCodexTerminal(terminalSessionId),
+    path: "/codex-terminal/:terminalSessionId",
+    read: (terminalSessionId) => terminalService().readGlobalCodexTerminal(terminalSessionId),
+    readSummary: "Read a global Vibe64 Codex terminal snapshot.",
+    closeSummary: "Close a global Vibe64 Codex terminal."
+  });
+
+  registerToolTerminalSnapshotRoutes(routes, {
+    close: (toolId, terminalSessionId) => terminalService().closeProjectToolTerminal(toolId, terminalSessionId),
+    path: "/tools/:toolId/terminal/:terminalSessionId",
+    read: (toolId, terminalSessionId) => terminalService().readProjectToolTerminal(toolId, terminalSessionId),
+    readSummary: "Read a Vibe64 project tool terminal snapshot.",
+    closeSummary: "Close a Vibe64 project tool terminal."
+  });
+
+  registerFixTerminalSnapshotRoutes(routes, {
+    close: (jobId, terminalSessionId) => terminalService().closeFixCodexTerminal(jobId, terminalSessionId),
+    path: "/fix-codex-jobs/:jobId/terminal/:terminalSessionId",
+    read: (jobId, terminalSessionId) => terminalService().readFixCodexTerminal(jobId, terminalSessionId),
+    readSummary: "Read a Fix Codex terminal snapshot.",
+    closeSummary: "Close a Fix Codex terminal."
+  });
+
   registerTerminalSnapshotRoutes(routes, {
     close: (sessionId, terminalSessionId) => terminalService().closeCommandTerminal(sessionId, terminalSessionId),
     path: "/sessions/:sessionId/command-terminal/:terminalSessionId",
@@ -151,6 +237,26 @@ function terminalRouteInput(request) {
   };
 }
 
+function globalTerminalRouteInput(request) {
+  return {
+    terminalSessionId: request.params.terminalSessionId
+  };
+}
+
+function toolTerminalRouteInput(request) {
+  return {
+    terminalSessionId: request.params.terminalSessionId,
+    toolId: request.params.toolId
+  };
+}
+
+function fixTerminalRouteInput(request) {
+  return {
+    jobId: request.params.jobId,
+    terminalSessionId: request.params.terminalSessionId
+  };
+}
+
 function registerTerminalSnapshotRoutes(routes, {
   close,
   closeSummary,
@@ -176,7 +282,127 @@ function registerTerminalSnapshotRoutes(routes, {
   });
 }
 
+function registerGlobalTerminalSnapshotRoutes(routes, {
+  close,
+  closeSummary,
+  path,
+  read,
+  readSummary
+}) {
+  routes.serviceRoute("GET", path, {
+    failureStatus: 404,
+    successStatus: 200,
+    summary: readSummary
+  }, (request) => {
+    const input = globalTerminalRouteInput(request);
+    return read(input.terminalSessionId);
+  });
+
+  routes.serviceRoute("DELETE", path, {
+    statusCode: 200,
+    summary: closeSummary
+  }, (request) => {
+    const input = globalTerminalRouteInput(request);
+    return close(input.terminalSessionId);
+  });
+}
+
+function registerToolTerminalSnapshotRoutes(routes, {
+  close,
+  closeSummary,
+  path,
+  read,
+  readSummary
+}) {
+  routes.serviceRoute("GET", path, {
+    failureStatus: 404,
+    successStatus: 200,
+    summary: readSummary
+  }, (request) => {
+    const input = toolTerminalRouteInput(request);
+    return read(input.toolId, input.terminalSessionId);
+  });
+
+  routes.serviceRoute("DELETE", path, {
+    statusCode: 200,
+    summary: closeSummary
+  }, (request) => {
+    const input = toolTerminalRouteInput(request);
+    return close(input.toolId, input.terminalSessionId);
+  });
+}
+
+function registerFixTerminalSnapshotRoutes(routes, {
+  close,
+  closeSummary,
+  path,
+  read,
+  readSummary
+}) {
+  routes.serviceRoute("GET", path, {
+    failureStatus: 404,
+    successStatus: 200,
+    summary: readSummary
+  }, (request) => {
+    const input = fixTerminalRouteInput(request);
+    return read(input.jobId, input.terminalSessionId);
+  });
+
+  routes.serviceRoute("DELETE", path, {
+    statusCode: 200,
+    summary: closeSummary
+  }, (request) => {
+    const input = fixTerminalRouteInput(request);
+    return close(input.jobId, input.terminalSessionId);
+  });
+}
+
 function registerVibe64TerminalWebSocketRoutes(app, routes) {
+  registerTerminalWebSocketRoute(app, {
+    routePath: `${routes.routeBase}/codex-terminal/:terminalSessionId/ws`,
+    serviceId: VIBE64_TERMINALS_SERVICE,
+    serviceUnavailableMessage: VIBE64_TERMINALS_UNAVAILABLE,
+    subscribe(service, { subscriber, terminalSessionId }) {
+      return service.subscribeGlobalCodexTerminal(terminalSessionId, subscriber);
+    },
+    resize(service, { cols, rows, terminalSessionId }) {
+      return service.resizeGlobalCodexTerminal(terminalSessionId, { cols, rows });
+    },
+    write(service, { data, terminalSessionId }) {
+      return service.writeGlobalCodexTerminal(terminalSessionId, data);
+    }
+  });
+
+  registerTerminalWebSocketRoute(app, {
+    routePath: `${routes.routeBase}/fix-codex-jobs/:jobId/terminal/:terminalSessionId/ws`,
+    serviceId: VIBE64_TERMINALS_SERVICE,
+    serviceUnavailableMessage: VIBE64_TERMINALS_UNAVAILABLE,
+    subscribe(service, { jobId, subscriber, terminalSessionId }) {
+      return service.subscribeFixCodexTerminal(jobId, terminalSessionId, subscriber);
+    },
+    resize(service, { cols, jobId, rows, terminalSessionId }) {
+      return service.resizeFixCodexTerminal(jobId, terminalSessionId, { cols, rows });
+    },
+    write(service, { data, jobId, terminalSessionId }) {
+      return service.writeFixCodexTerminal(jobId, terminalSessionId, data);
+    }
+  });
+
+  registerTerminalWebSocketRoute(app, {
+    routePath: `${routes.routeBase}/tools/:toolId/terminal/:terminalSessionId/ws`,
+    serviceId: VIBE64_TERMINALS_SERVICE,
+    serviceUnavailableMessage: VIBE64_TERMINALS_UNAVAILABLE,
+    subscribe(service, { subscriber, terminalSessionId, toolId }) {
+      return service.subscribeProjectToolTerminal(toolId, terminalSessionId, subscriber);
+    },
+    resize(service, { cols, rows, terminalSessionId, toolId }) {
+      return service.resizeProjectToolTerminal(toolId, terminalSessionId, { cols, rows });
+    },
+    write(service, { data, terminalSessionId, toolId }) {
+      return service.writeProjectToolTerminal(toolId, terminalSessionId, data);
+    }
+  });
+
   registerTerminalWebSocketRoute(app, {
     routePath: `${routes.routeBase}/sessions/:sessionId/codex-terminal/:terminalSessionId/ws`,
     serviceId: VIBE64_TERMINALS_SERVICE,

package/packages/vibe64-terminals/src/server/service.js

@@ -1,7 +1,18 @@
 import { createCodexTerminalController } from "./codexTerminal.js";
-import { createCommandTerminalController } from "./commandTerminal.js";
+import {
+  createCommandTerminalController,
+  createProjectToolTerminalController
+} from "./commandTerminal.js";
 import { createLaunchTargetTerminalController } from "./launchTargetTerminal.js";
 import { createShellTerminalController } from "./shellTerminal.js";
+import {
+  projectToolFailureFixPrompt,
+  sessionTerminalFailureFixPrompt
+} from "@local/vibe64-runtime/server/terminalFailureFixRequest";
+import {
+  terminalTargetRoot,
+  terminalWorktreePath
+} from "./terminalShared.js";
 
 function createService({
   projectService,
@@ -33,6 +44,9 @@ function createService({
     projectService,
     publishSessionChanged: publishSessionChanged.launchTarget
   });
+  const projectTool = createProjectToolTerminalController({
+    projectService
+  });
   const shell = createShellTerminalController({
     projectService
   });
@@ -65,10 +79,22 @@ function createService({
       return codex.closeTerminal(sessionId, terminalSessionId);
     },
 
+    closeGlobalCodexTerminal(terminalSessionId) {
+      return codex.closeGlobalTerminal(terminalSessionId);
+    },
+
+    closeFixCodexTerminal(jobId, terminalSessionId) {
+      return codex.closeFixTerminal(jobId, terminalSessionId);
+    },
+
     closeCommandTerminal(sessionId, terminalSessionId) {
       return command.closeTerminal(sessionId, terminalSessionId);
     },
 
+    closeProjectToolTerminal(toolId, terminalSessionId) {
+      return projectTool.closeTerminal(toolId, terminalSessionId);
+    },
+
     closeLaunchTargetTerminal(sessionId, terminalSessionId) {
       return launchTarget.closeTerminal(sessionId, terminalSessionId);
     },
@@ -81,6 +107,10 @@ function createService({
       return codex.injectCodexPrompt(sessionId, handoff);
     },
 
+    injectGlobalCodexPrompt(handoff = {}) {
+      return codex.injectGlobalCodexPrompt(handoff);
+    },
+
     ensureCodexThread(sessionId) {
       return codex.ensureThread(sessionId);
     },
@@ -89,6 +119,18 @@ function createService({
       return codex.terminalState(sessionId);
     },
 
+    globalCodexTerminalState() {
+      return codex.globalTerminalState();
+    },
+
+    readGlobalCodexTerminal(terminalSessionId) {
+      return codex.readGlobalTerminal(terminalSessionId);
+    },
+
+    readFixCodexTerminal(jobId, terminalSessionId) {
+      return codex.readFixTerminal(jobId, terminalSessionId);
+    },
+
     readCodexTerminal(sessionId, terminalSessionId) {
       return codex.readTerminal(sessionId, terminalSessionId);
     },
@@ -97,6 +139,10 @@ function createService({
       return command.readTerminal(sessionId, terminalSessionId);
     },
 
+    readProjectToolTerminal(toolId, terminalSessionId) {
+      return projectTool.readTerminal(toolId, terminalSessionId);
+    },
+
     readLaunchTargetTerminal(sessionId, terminalSessionId) {
       return launchTarget.readTerminal(sessionId, terminalSessionId);
     },
@@ -117,10 +163,67 @@ function createService({
       return codex.startTerminal(sessionId);
     },
 
+    startGlobalCodexTerminal() {
+      return codex.startGlobalTerminal();
+    },
+
+    async startProjectToolFixJob(toolId, input = {}) {
+      const targetRoot = projectService.targetRoot || "";
+      return codex.startFixJob({
+        prompt: projectToolFailureFixPrompt({
+          ...input,
+          targetRoot,
+          toolId: input.toolId || toolId,
+          toolLabel: input.toolLabel || input.actionLabel
+        }),
+        scope: "project",
+        subject: input.toolLabel || input.actionLabel || toolId,
+        targetRoot
+      });
+    },
+
+    async startSessionTerminalFixJob(sessionId, input = {}) {
+      const runtime = await projectService.createRuntime();
+      const session = await runtime.getSession(sessionId);
+      const targetRoot = terminalTargetRoot(session, projectService);
+      const worktreePath = terminalWorktreePath(session);
+      return codex.startFixJob({
+        prompt: sessionTerminalFailureFixPrompt({
+          ...input,
+          currentStep: input.currentStep || session.currentStep || "",
+          sessionId: input.sessionId || sessionId,
+          stepStatus: input.stepStatus || session.stepMachine?.status || "",
+          targetRoot,
+          worktreePath
+        }),
+        scope: "session",
+        subject: input.actionLabel || input.launchTargetLabel || input.actionId || input.launchTargetId || sessionId,
+        targetRoot,
+        workdir: worktreePath || targetRoot
+      });
+    },
+
+    reportFixCodexJob(jobId, input = {}) {
+      return codex.reportFixJob(jobId, input);
+    },
+
     startCommandTerminal(sessionId, input = {}) {
       return command.startTerminal(sessionId, input);
     },
 
+    async runProjectTool(toolId, input = {}) {
+      const run = await projectService.prepareProjectToolRun(toolId, input);
+      if (run?.ok === false) {
+        return run;
+      }
+      if (run.type === "prompt") {
+        return codex.injectGlobalCodexPrompt({
+          prompt: run.prompt
+        });
+      }
+      return projectTool.startPreparedRun(toolId, run);
+    },
+
     startLaunchTargetTerminal(sessionId, input = {}) {
       return launchTarget.startTerminal(sessionId, input);
     },
@@ -137,10 +240,22 @@ function createService({
       return codex.subscribeTerminal(sessionId, terminalSessionId, subscriber);
     },
 
+    subscribeGlobalCodexTerminal(terminalSessionId, subscriber) {
+      return codex.subscribeGlobalTerminal(terminalSessionId, subscriber);
+    },
+
+    subscribeFixCodexTerminal(jobId, terminalSessionId, subscriber) {
+      return codex.subscribeFixTerminal(jobId, terminalSessionId, subscriber);
+    },
+
     subscribeCommandTerminal(sessionId, terminalSessionId, subscriber) {
       return command.subscribeTerminal(sessionId, terminalSessionId, subscriber);
     },
 
+    subscribeProjectToolTerminal(toolId, terminalSessionId, subscriber) {
+      return projectTool.subscribeTerminal(toolId, terminalSessionId, subscriber);
+    },
+
     subscribeLaunchTargetTerminal(sessionId, terminalSessionId, subscriber) {
       return launchTarget.subscribeTerminal(sessionId, terminalSessionId, subscriber);
     },
@@ -157,18 +272,42 @@ function createService({
       return codex.writeTerminal(sessionId, terminalSessionId, data);
     },
 
+    writeGlobalCodexTerminal(terminalSessionId, data) {
+      return codex.writeGlobalTerminal(terminalSessionId, data);
+    },
+
+    writeFixCodexTerminal(jobId, terminalSessionId, data) {
+      return codex.writeFixTerminal(jobId, terminalSessionId, data);
+    },
+
     resizeCodexTerminal(sessionId, terminalSessionId, size) {
       return codex.resizeTerminal(sessionId, terminalSessionId, size);
     },
 
+    resizeGlobalCodexTerminal(terminalSessionId, size) {
+      return codex.resizeGlobalTerminal(terminalSessionId, size);
+    },
+
+    resizeFixCodexTerminal(jobId, terminalSessionId, size) {
+      return codex.resizeFixTerminal(jobId, terminalSessionId, size);
+    },
+
     writeCommandTerminal(sessionId, terminalSessionId, data) {
       return command.writeTerminal(sessionId, terminalSessionId, data);
     },
 
+    writeProjectToolTerminal(toolId, terminalSessionId, data) {
+      return projectTool.writeTerminal(toolId, terminalSessionId, data);
+    },
+
     resizeCommandTerminal(sessionId, terminalSessionId, size) {
       return command.resizeTerminal(sessionId, terminalSessionId, size);
     },
 
+    resizeProjectToolTerminal(toolId, terminalSessionId, size) {
+      return projectTool.resizeTerminal(toolId, terminalSessionId, size);
+    },
+
     writeLaunchTargetTerminal(sessionId, terminalSessionId, data) {
       return launchTarget.writeTerminal(sessionId, terminalSessionId, data);
     },

package/packages/vibe64-terminals/src/server/targetToolchainTerminal.js

@@ -69,7 +69,7 @@ function targetToolchainTerminalArgs({
     ...dockerLabelArgs([
       kind ? studioDockerLabel("kind", kind) : "",
       `${STUDIO_DAEMON_PID_LABEL}=${process.pid}`,
-      studioDockerLabel("session", sessionId),
+      sessionId ? studioDockerLabel("session", sessionId) : "",
       studioDockerLabel("terminal", terminalId),
       studioDockerLabel("target", stableHash(targetRoot)),
       ...extraLabels

package/packages/vibe64-terminals/src/server/terminalShared.js

@@ -13,9 +13,12 @@ import {
 
 const CODEX_TERMINAL_NAMESPACE = "vibe64-codex";
 const CODEX_TERMINAL_NAMESPACE_PREFIX = `${CODEX_TERMINAL_NAMESPACE}:`;
+const GLOBAL_CODEX_TERMINAL_NAMESPACE = "vibe64-global-codex";
 const COMMAND_TERMINAL_NAMESPACE = "vibe64-command";
 const LAUNCH_TARGET_TERMINAL_NAMESPACE = "vibe64-launch-target";
 const SHELL_TERMINAL_NAMESPACE = "vibe64-shell";
+const TOOL_TERMINAL_NAMESPACE = "vibe64-tool";
+const FIX_CODEX_TERMINAL_NAMESPACE = "vibe64-fix-codex";
 
 function vibe64Result(operation) {
   return sharedVibe64Result(operation, {
@@ -28,10 +31,22 @@ function codexTerminalNamespace(sessionId) {
   return `${CODEX_TERMINAL_NAMESPACE}:${String(sessionId || "")}`;
 }
 
+function globalCodexTerminalNamespace() {
+  return GLOBAL_CODEX_TERMINAL_NAMESPACE;
+}
+
+function fixCodexTerminalNamespace(jobId) {
+  return `${FIX_CODEX_TERMINAL_NAMESPACE}:${String(jobId || "")}`;
+}
+
 function commandTerminalNamespace(sessionId) {
   return `${COMMAND_TERMINAL_NAMESPACE}:${String(sessionId || "")}`;
 }
 
+function toolTerminalNamespace(toolId) {
+  return `${TOOL_TERMINAL_NAMESPACE}:${String(toolId || "")}`;
+}
+
 function launchTargetTerminalNamespace(sessionId) {
   return `${LAUNCH_TARGET_TERMINAL_NAMESPACE}:${String(sessionId || "")}`;
 }
@@ -40,6 +55,21 @@ function shellTerminalNamespace(sessionId) {
   return `${SHELL_TERMINAL_NAMESPACE}:${String(sessionId || "")}`;
 }
 
+function commandInvocation({
+  args = [],
+  command = ""
+} = {}) {
+  const normalizedCommand = String(command || "").trim();
+  if (!normalizedCommand) {
+    return "";
+  }
+  const normalizedArgs = Array.isArray(args) ? args : [];
+  return [
+    normalizedCommand,
+    ...normalizedArgs.map((arg) => String(arg))
+  ].map(shellQuote).join(" ");
+}
+
 async function directoryExists(filePath = "") {
   try {
     return (await stat(filePath)).isDirectory();
@@ -97,14 +127,18 @@ export {
   CODEX_TERMINAL_NAMESPACE_PREFIX,
   vibe64Result,
   codexTerminalNamespace,
+  commandInvocation,
   commandTerminalNamespace,
   directoryExists,
+  fixCodexTerminalNamespace,
+  globalCodexTerminalNamespace,
   launchTargetTerminalNamespace,
   pathInsideOrEqual,
   shellTerminalNamespace,
   sessionTerminalCwd,
   terminalTargetRoot,
   terminalWorktreePath,
+  toolTerminalNamespace,
   dockerCommand,
   normalizePlainObject,
   shellQuote,