🤖 Integrate init hooks with Runtime.createWorkspace()

Connects the init hooks system (PR #228) with the Runtime abstraction so
workspace creation progress and init hook output stream to the frontend.

**Init Hook Utilities (src/runtime/initHook.ts):**

- checkInitHookExists(): Check if .cmux/init is executable
- getInitHookPath(): Get init hook path for project
- LineBuffer class: Line-buffered streaming (handles incomplete lines)
- createLineBufferedLoggers(): Creates stdout/stderr line buffers

**Runtime Integration:**

- InitLogger interface: logStep(), logStdout(), logStderr(), logComplete()
- WorkspaceCreationParams extended with initLogger
- LocalRuntime: Runs init hook locally via bash, streams output
- SSHRuntime: Runs init hook on remote host, streams via Web Streams

**IPC Bridge:**

- IpcMain creates InitLogger that bridges to InitStateManager
- Runtime owns workspace creation entirely (no IPC branching)
- Creation steps logged: "Creating worktree...", "Running init hook..."
- Real-time streaming to frontend via existing init channels

**Testing:**

- 7 unit tests for LineBuffer and createLineBufferedLoggers
- Integration tests updated with mockInitLogger
- All 770 tests passing

Generated with `cmux`

Author: ammar-agent

src/runtime/initHook.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from "bun:test";
+import { LineBuffer, createLineBufferedLoggers } from "./initHook";
+import type { InitLogger } from "./Runtime";
+
+describe("LineBuffer", () => {
+  it("should buffer incomplete lines", () => {
+    const lines: string[] = [];
+    const buffer = new LineBuffer((line) => lines.push(line));
+
+    buffer.append("hello ");
+    expect(lines).toEqual([]);
+
+    buffer.append("world\n");
+    expect(lines).toEqual(["hello world"]);
+  });
+
+  it("should handle multiple lines in one chunk", () => {
+    const lines: string[] = [];
+    const buffer = new LineBuffer((line) => lines.push(line));
+
+    buffer.append("line1\nline2\nline3\n");
+    expect(lines).toEqual(["line1", "line2", "line3"]);
+  });
+
+  it("should handle incomplete line at end", () => {
+    const lines: string[] = [];
+    const buffer = new LineBuffer((line) => lines.push(line));
+
+    buffer.append("line1\nline2\nincomplete");
+    expect(lines).toEqual(["line1", "line2"]);
+
+    buffer.flush();
+    expect(lines).toEqual(["line1", "line2", "incomplete"]);
+  });
+
+  it("should skip empty lines", () => {
+    const lines: string[] = [];
+    const buffer = new LineBuffer((line) => lines.push(line));
+
+    buffer.append("\nline1\n\nline2\n\n");
+    expect(lines).toEqual(["line1", "line2"]);
+  });
+
+  it("should handle flush with no buffered data", () => {
+    const lines: string[] = [];
+    const buffer = new LineBuffer((line) => lines.push(line));
+
+    buffer.append("line1\n");
+    expect(lines).toEqual(["line1"]);
+
+    buffer.flush();
+    expect(lines).toEqual(["line1"]); // No change
+  });
+});
+
+describe("createLineBufferedLoggers", () => {
+  it("should create separate buffers for stdout and stderr", () => {
+    const stdoutLines: string[] = [];
+    const stderrLines: string[] = [];
+
+    const mockLogger: InitLogger = {
+      logStep: () => {},
+      logStdout: (line) => stdoutLines.push(line),
+      logStderr: (line) => stderrLines.push(line),
+      logComplete: () => {},
+    };
+
+    const loggers = createLineBufferedLoggers(mockLogger);
+
+    loggers.stdout.append("out1\nout2\n");
+    loggers.stderr.append("err1\nerr2\n");
+
+    expect(stdoutLines).toEqual(["out1", "out2"]);
+    expect(stderrLines).toEqual(["err1", "err2"]);
+  });
+
+  it("should handle incomplete lines and flush separately", () => {
+    const stdoutLines: string[] = [];
+    const stderrLines: string[] = [];
+
+    const mockLogger: InitLogger = {
+      logStep: () => {},
+      logStdout: (line) => stdoutLines.push(line),
+      logStderr: (line) => stderrLines.push(line),
+      logComplete: () => {},
+    };
+
+    const loggers = createLineBufferedLoggers(mockLogger);
+
+    loggers.stdout.append("incomplete");
+    loggers.stderr.append("also incomplete");
+
+    expect(stdoutLines).toEqual([]);
+    expect(stderrLines).toEqual([]);
+
+    loggers.stdout.flush();
+    expect(stdoutLines).toEqual(["incomplete"]);
+    expect(stderrLines).toEqual([]); // stderr not flushed yet
+
+    loggers.stderr.flush();
+    expect(stderrLines).toEqual(["also incomplete"]);
+  });
+});

src/runtime/initHook.ts

@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+import * as path from "path";
+import type { InitLogger } from "./Runtime";
+
+/**
+ * Check if .cmux/init hook exists and is executable
+ * @param projectPath - Path to the project root
+ * @returns true if hook exists and is executable, false otherwise
+ */
+export async function checkInitHookExists(projectPath: string): Promise<boolean> {
+  const hookPath = path.join(projectPath, ".cmux", "init");
+
+  try {
+    await fsPromises.access(hookPath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the init hook path for a project
+ */
+export function getInitHookPath(projectPath: string): string {
+  return path.join(projectPath, ".cmux", "init");
+}
+
+/**
+ * Line-buffered logger that splits stream output into lines and logs them
+ * Handles incomplete lines by buffering until a newline is received
+ */
+export class LineBuffer {
+  private buffer = "";
+  private readonly logLine: (line: string) => void;
+
+  constructor(logLine: (line: string) => void) {
+    this.logLine = logLine;
+  }
+
+  /**
+   * Process a chunk of data, splitting on newlines and logging complete lines
+   */
+  append(data: string): void {
+    this.buffer += data;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? ""; // Keep last incomplete line
+    for (const line of lines) {
+      if (line) this.logLine(line);
+    }
+  }
+
+  /**
+   * Flush any remaining buffered data (called when stream closes)
+   */
+  flush(): void {
+    if (this.buffer) {
+      this.logLine(this.buffer);
+      this.buffer = "";
+    }
+  }
+}
+
+/**
+ * Create line-buffered loggers for stdout and stderr
+ * Returns an object with append and flush methods for each stream
+ */
+export function createLineBufferedLoggers(initLogger: InitLogger) {
+  const stdoutBuffer = new LineBuffer((line) => initLogger.logStdout(line));
+  const stderrBuffer = new LineBuffer((line) => initLogger.logStderr(line));
+
+  return {
+    stdout: {
+      append: (data: string) => stdoutBuffer.append(data),
+      flush: () => stdoutBuffer.flush(),
+    },
+    stderr: {
+      append: (data: string) => stderrBuffer.append(data),
+      flush: () => stderrBuffer.flush(),
+    },
+  };
+}
+

src/services/ipcMain.ts

@@ -31,6 +31,7 @@ import { secretsToRecord } from "@/types/secrets";
 import { DisposableTempDir } from "@/services/tempDir";
 import { BashExecutionService } from "@/services/bashExecutionService";
 import { InitStateManager } from "@/services/initStateManager";
+import { createRuntime } from "@/runtime/runtimeFactory";
 
 /**
  * IpcMain - Manages all IPC handlers and service coordination
@@ -272,13 +273,41 @@ export class IpcMain {
         // Generate stable workspace ID (stored in config, not used for directory name)
         const workspaceId = this.config.generateStableId();
 
-        // Create the git worktree with the workspace name as directory name
-        const result = await createWorktree(this.config, projectPath, branchName, {
+        // Create runtime for workspace creation (defaults to local)
+        const workspacePath = this.config.getWorkspacePath(projectPath, branchName);
+        const runtimeConfig = { type: "local" as const, workdir: workspacePath };
+        const runtime = createRuntime(runtimeConfig);
+
+        // Start init tracking (creates in-memory state + emits init-start event)
+        // This MUST complete before workspace creation returns so replayInit() finds state
+        this.initStateManager.startInit(workspaceId, projectPath);
+
+        // Create InitLogger that bridges to InitStateManager
+        const initLogger = {
+          logStep: (message: string) => {
+            this.initStateManager.appendOutput(workspaceId, message, false);
+          },
+          logStdout: (line: string) => {
+            this.initStateManager.appendOutput(workspaceId, line, false);
+          },
+          logStderr: (line: string) => {
+            this.initStateManager.appendOutput(workspaceId, line, true);
+          },
+          logComplete: (exitCode: number) => {
+            void this.initStateManager.endInit(workspaceId, exitCode);
+          },
+        };
+
+        // Create workspace through runtime abstraction
+        const result = await runtime.createWorkspace({
+          projectPath,
+          branchName,
           trunkBranch: normalizedTrunkBranch,
-          workspaceId: branchName, // Use name for directory (workspaceId param is misnamed, it's directoryName)
+          workspaceId: branchName, // Use name for directory
+          initLogger,
         });
 
-        if (result.success && result.path) {
+        if (result.success && result.workspacePath) {
           const projectName =
             projectPath.split("/").pop() ?? projectPath.split("\\").pop() ?? "unknown";
 
@@ -304,7 +333,7 @@ export class IpcMain {
             }
             // Add workspace to project config with full metadata
             projectConfig.workspaces.push({
-              path: result.path!,
+              path: result.workspacePath!,
               id: workspaceId,
               name: branchName,
               createdAt: metadata.createdAt,
@@ -325,13 +354,8 @@ export class IpcMain {
           const session = this.getOrCreateSession(workspaceId);
           session.emitMetadata(completeMetadata);
 
-          // Start optional .cmux/init hook (waits for state creation, then returns)
-          // This ensures replayInit() will find state when frontend subscribes
-          await this.startWorkspaceInitHook({
-            projectPath,
-            worktreePath: result.path,
-            workspaceId,
-          });
+          // Init hook has already been run by the runtime
+          // No need to call startWorkspaceInitHook here anymore
 
           // Return complete metadata with paths for frontend
           return {
@@ -839,6 +863,7 @@ export class IpcMain {
           // All IPC bash calls are from UI (background operations) - use truncate to avoid temp file spam
           const bashTool = createBashTool({
             cwd: namedPath,
+            runtime: createRuntime({ type: "local", workdir: namedPath }),
             secrets: secretsToRecord(projectSecrets),
             niceness: options?.niceness,
             tempDir: tempDir.path,

src/services/tools/file_edit_operation.test.ts

@@ -1,15 +1,7 @@
 import { describe, it, expect } from "bun:test";
 import { executeFileEditOperation } from "./file_edit_operation";
-<<<<<<< HEAD
 import { WRITE_DENIED_PREFIX } from "@/types/tools";
-import { LocalRuntime } from "@/runtime/LocalRuntime";
-||||||| parent of a522bfce (🤖 Integrate runtime config with workspace metadata and AIService)
-import { WRITE_DENIED_PREFIX } from "./fileCommon";
-import { LocalRuntime } from "@/runtime/LocalRuntime";
-=======
-import { WRITE_DENIED_PREFIX } from "./fileCommon";
 import { createRuntime } from "@/runtime/runtimeFactory";
->>>>>>> a522bfce (🤖 Integrate runtime config with workspace metadata and AIService)
 
 const TEST_CWD = "/tmp";
 

src/types/runtime.ts

@@ -0,0 +1,17 @@
+/**
+ * Runtime configuration types for workspace execution environments
+ */
+
+export type RuntimeConfig =
+  | {
+      type: "local";
+      /** Working directory on local host */
+      workdir: string;
+    }
+  | {
+      type: "ssh";
+      /** SSH host (can be hostname, user@host, or SSH config alias) */
+      host: string;
+      /** Working directory on remote host */
+      workdir: string;
+    };

src/utils/runtime/fileExists.ts

@@ -0,0 +1,16 @@
+import type { Runtime } from "@/runtime/Runtime";
+
+/**
+ * Check if a path exists using runtime.stat()
+ * @param runtime Runtime instance to use
+ * @param path Path to check
+ * @returns True if path exists, false otherwise
+ */
+export async function fileExists(runtime: Runtime, path: string): Promise<boolean> {
+  try {
+    await runtime.stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}