Add AI-generated worktree branch naming with safe Git branch rename flow

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -23,6 +23,8 @@ import {
 
 import { CheckpointStoreLive } from "../src/checkpointing/Layers/CheckpointStore.ts";
 import { CheckpointStore } from "../src/checkpointing/Services/CheckpointStore.ts";
+import { GitCore, type GitCoreShape } from "../src/git/Services/GitCore.ts";
+import { TextGeneration, type TextGenerationShape } from "../src/git/Services/TextGeneration.ts";
 import { OrchestrationCommandReceiptRepositoryLive } from "../src/persistence/Layers/OrchestrationCommandReceipts.ts";
 import { OrchestrationEventStoreLive } from "../src/persistence/Layers/OrchestrationEventStore.ts";
 import { ProjectionCheckpointRepositoryLive } from "../src/persistence/Layers/ProjectionCheckpoints.ts";
@@ -54,6 +56,7 @@ import {
   makeTestProviderAdapterHarness,
   type TestProviderAdapterHarness,
 } from "./TestProviderAdapter.integration.ts";
+import { ServerConfig } from "../src/config.ts";
 
 function runGit(cwd: string, args: ReadonlyArray<string>) {
   return execFileSync("git", args, {
@@ -227,8 +230,17 @@ export const makeOrchestrationIntegrationHarness = Effect.gen(function* () {
   const runtimeIngestionLayer = ProviderRuntimeIngestionLive.pipe(
     Layer.provideMerge(runtimeServicesLayer),
   );
+  const gitCoreLayer = Layer.succeed(GitCore, {
+    renameBranch: (input: Parameters<GitCoreShape["renameBranch"]>[0]) =>
+      Effect.succeed({ branch: input.newBranch }),
+  } as unknown as GitCoreShape);
+  const textGenerationLayer = Layer.succeed(TextGeneration, {
+    generateBranchName: () => Effect.succeed({ branch: null }),
+  } as unknown as TextGenerationShape);
   const providerCommandReactorLayer = ProviderCommandReactorLive.pipe(
     Layer.provideMerge(runtimeServicesLayer),
+    Layer.provideMerge(gitCoreLayer),
+    Layer.provideMerge(textGenerationLayer),
   );
   const checkpointReactorLayer = CheckpointReactorLive.pipe(
     Layer.provideMerge(runtimeServicesLayer),
@@ -240,6 +252,7 @@ export const makeOrchestrationIntegrationHarness = Effect.gen(function* () {
   );
   const layer = orchestrationReactorLayer.pipe(
     Layer.provide(persistenceLayer),
+    Layer.provideMerge(ServerConfig.layerTest(workspaceDir, stateDir)),
     Layer.provideMerge(NodeServices.layer),
   );
 

apps/server/src/attachmentPaths.ts

@@ -0,0 +1,28 @@
+import path from "node:path";
+
+export const ATTACHMENTS_ROUTE_PREFIX = "/attachments";
+
+export function normalizeAttachmentRelativePath(rawRelativePath: string): string | null {
+  const normalized = path.normalize(rawRelativePath).replace(/^[/\\]+/, "");
+  if (normalized.length === 0 || normalized.startsWith("..") || normalized.includes("\0")) {
+    return null;
+  }
+  return normalized.replace(/\\/g, "/");
+}
+
+export function resolveAttachmentRelativePath(input: {
+  readonly stateDir: string;
+  readonly relativePath: string;
+}): string | null {
+  const normalizedRelativePath = normalizeAttachmentRelativePath(input.relativePath);
+  if (!normalizedRelativePath) {
+    return null;
+  }
+
+  const attachmentsRoot = path.resolve(path.join(input.stateDir, "attachments"));
+  const filePath = path.resolve(path.join(attachmentsRoot, normalizedRelativePath));
+  if (!filePath.startsWith(`${attachmentsRoot}${path.sep}`)) {
+    return null;
+  }
+  return filePath;
+}

apps/server/src/attachmentStore.test.ts

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  createAttachmentId,
+  parseThreadSegmentFromAttachmentId,
+  resolveAttachmentPathById,
+} from "./attachmentStore.ts";
+
+describe("attachmentStore", () => {
+  it("sanitizes thread ids when creating attachment ids", () => {
+    const attachmentId = createAttachmentId("thread.folder/unsafe space");
+    expect(attachmentId).toBeTruthy();
+    if (!attachmentId) {
+      return;
+    }
+
+    const threadSegment = parseThreadSegmentFromAttachmentId(attachmentId);
+    expect(threadSegment).toBeTruthy();
+    expect(threadSegment).toMatch(/^[a-z0-9_-]+$/i);
+    expect(threadSegment).not.toContain(".");
+    expect(threadSegment).not.toContain("%");
+    expect(threadSegment).not.toContain("/");
+  });
+
+  it("parses exact thread segments from attachment ids without prefix collisions", () => {
+    const fooId = "foo-00000000-0000-4000-8000-000000000001";
+    const fooBarId = "foo-bar-00000000-0000-4000-8000-000000000002";
+
+    expect(parseThreadSegmentFromAttachmentId(fooId)).toBe("foo");
+    expect(parseThreadSegmentFromAttachmentId(fooBarId)).toBe("foo-bar");
+  });
+
+  it("normalizes created thread segments to lowercase", () => {
+    const attachmentId = createAttachmentId("Thread.Foo");
+    expect(attachmentId).toBeTruthy();
+    if (!attachmentId) {
+      return;
+    }
+    expect(parseThreadSegmentFromAttachmentId(attachmentId)).toBe("thread-foo");
+  });
+
+  it("resolves attachment path by id using the extension that exists on disk", () => {
+    const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "t3code-attachment-store-"));
+    try {
+      const attachmentId = "thread-1-attachment";
+      const attachmentsDir = path.join(stateDir, "attachments");
+      fs.mkdirSync(attachmentsDir, { recursive: true });
+      const pngPath = path.join(attachmentsDir, `${attachmentId}.png`);
+      fs.writeFileSync(pngPath, Buffer.from("hello"));
+
+      const resolved = resolveAttachmentPathById({
+        stateDir,
+        attachmentId,
+      });
+      expect(resolved).toBe(pngPath);
+    } finally {
+      fs.rmSync(stateDir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns null when no attachment file exists for the id", () => {
+    const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "t3code-attachment-store-"));
+    try {
+      const resolved = resolveAttachmentPathById({
+        stateDir,
+        attachmentId: "thread-1-missing",
+      });
+      expect(resolved).toBeNull();
+    } finally {
+      fs.rmSync(stateDir, { recursive: true, force: true });
+    }
+  });
+});

apps/server/src/attachmentStore.ts

@@ -0,0 +1,110 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+
+import type { ChatAttachment } from "@t3tools/contracts";
+
+import {
+  normalizeAttachmentRelativePath,
+  resolveAttachmentRelativePath,
+} from "./attachmentPaths.ts";
+import { inferImageExtension, SAFE_IMAGE_FILE_EXTENSIONS } from "./imageMime.ts";
+
+const ATTACHMENT_FILENAME_EXTENSIONS = [...SAFE_IMAGE_FILE_EXTENSIONS, ".bin"];
+const ATTACHMENT_ID_THREAD_SEGMENT_MAX_CHARS = 80;
+const ATTACHMENT_ID_THREAD_SEGMENT_PATTERN = "[a-z0-9_]+(?:-[a-z0-9_]+)*";
+const ATTACHMENT_ID_UUID_PATTERN =
+  "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const ATTACHMENT_ID_PATTERN = new RegExp(
+  `^(${ATTACHMENT_ID_THREAD_SEGMENT_PATTERN})-(${ATTACHMENT_ID_UUID_PATTERN})$`,
+  "i",
+);
+
+export function toSafeThreadAttachmentSegment(threadId: string): string | null {
+  const segment = threadId
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/gi, "-")
+    .replace(/-+/g, "-")
+    .replace(/^[-_]+|[-_]+$/g, "")
+    .slice(0, ATTACHMENT_ID_THREAD_SEGMENT_MAX_CHARS)
+    .replace(/[-_]+$/g, "");
+  if (segment.length === 0) {
+    return null;
+  }
+  return segment;
+}
+
+export function createAttachmentId(threadId: string): string | null {
+  const threadSegment = toSafeThreadAttachmentSegment(threadId);
+  if (!threadSegment) {
+    return null;
+  }
+  return `${threadSegment}-${randomUUID()}`;
+}
+
+export function parseThreadSegmentFromAttachmentId(attachmentId: string): string | null {
+  const normalizedId = normalizeAttachmentRelativePath(attachmentId);
+  if (!normalizedId || normalizedId.includes("/") || normalizedId.includes(".")) {
+    return null;
+  }
+  const match = normalizedId.match(ATTACHMENT_ID_PATTERN);
+  if (!match) {
+    return null;
+  }
+  return match[1]?.toLowerCase() ?? null;
+}
+
+export function attachmentRelativePath(attachment: ChatAttachment): string {
+  switch (attachment.type) {
+    case "image": {
+      const extension = inferImageExtension({
+        mimeType: attachment.mimeType,
+        fileName: attachment.name,
+      });
+      return `${attachment.id}${extension}`;
+    }
+  }
+}
+
+export function resolveAttachmentPath(input: {
+  readonly stateDir: string;
+  readonly attachment: ChatAttachment;
+}): string | null {
+  return resolveAttachmentRelativePath({
+    stateDir: input.stateDir,
+    relativePath: attachmentRelativePath(input.attachment),
+  });
+}
+
+export function resolveAttachmentPathById(input: {
+  readonly stateDir: string;
+  readonly attachmentId: string;
+}): string | null {
+  const normalizedId = normalizeAttachmentRelativePath(input.attachmentId);
+  if (!normalizedId || normalizedId.includes("/") || normalizedId.includes(".")) {
+    return null;
+  }
+  for (const extension of ATTACHMENT_FILENAME_EXTENSIONS) {
+    const maybePath = resolveAttachmentRelativePath({
+      stateDir: input.stateDir,
+      relativePath: `${normalizedId}${extension}`,
+    });
+    if (maybePath && existsSync(maybePath)) {
+      return maybePath;
+    }
+  }
+  return null;
+}
+
+export function parseAttachmentIdFromRelativePath(relativePath: string): string | null {
+  const normalized = normalizeAttachmentRelativePath(relativePath);
+  if (!normalized || normalized.includes("/")) {
+    return null;
+  }
+  const extensionIndex = normalized.lastIndexOf(".");
+  if (extensionIndex <= 0) {
+    return null;
+  }
+  const id = normalized.slice(0, extensionIndex);
+  return id.length > 0 && !id.includes(".") ? id : null;
+}

apps/server/src/codexAppServerManager.test.ts

@@ -191,10 +191,7 @@ describe("sendTurn", () => {
       attachments: [
         {
           type: "image",
-          name: "error.png",
-          mimeType: "image/png",
-          sizeBytes: 1_024,
-          dataUrl: "data:image/png;base64,AAAA",
+          url: "data:image/png;base64,AAAA",
         },
       ],
       model: "gpt-5.3",
@@ -242,10 +239,7 @@ describe("sendTurn", () => {
       attachments: [
         {
           type: "image",
-          name: "diagram.png",
-          mimeType: "image/png",
-          sizeBytes: 256,
-          dataUrl: "data:image/png;base64,BBBB",
+          url: "data:image/png;base64,BBBB",
         },
       ],
     });

apps/server/src/codexAppServerManager.ts

@@ -14,7 +14,6 @@ import {
   normalizeModelSlug,
   type ProviderApprovalDecision,
   type ProviderEvent,
-  type ProviderSendTurnInput,
   type ProviderSession,
   type ProviderSessionStartInput,
   type ProviderTurnStartResult,
@@ -71,6 +70,14 @@ interface JsonRpcNotification {
   params?: unknown;
 }
 
+export interface CodexAppServerSendTurnInput {
+  readonly sessionId: ProviderSessionId;
+  readonly input?: string;
+  readonly attachments?: ReadonlyArray<{ type: "image"; url: string }>;
+  readonly model?: string;
+  readonly effort?: string;
+}
+
 export interface CodexThreadTurnSnapshot {
   id: ProviderTurnId;
   items: unknown[];
@@ -290,7 +297,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
     }
   }
 
-  async sendTurn(input: ProviderSendTurnInput): Promise<ProviderTurnStartResult> {
+  async sendTurn(input: CodexAppServerSendTurnInput): Promise<ProviderTurnStartResult> {
     const context = this.requireSession(input.sessionId);
     if (!context.session.threadId) {
       throw new Error("Session is missing a thread id.");
@@ -310,7 +317,7 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
       if (attachment.type === "image") {
         turnInput.push({
           type: "image",
-          url: attachment.dataUrl,
+          url: attachment.url,
         });
       }
     }

apps/server/src/config.ts

@@ -36,7 +36,29 @@ export interface ServerConfigShape {
  */
 export class ServerConfig extends ServiceMap.Service<ServerConfig, ServerConfigShape>()(
   "t3/config/ServerConfig",
-) {}
+) {
+  static readonly layerTest = (cwd: string, statedir: string) =>
+    Layer.effect(
+      ServerConfig,
+      Effect.gen(function* () {
+        const path = yield* Path.Path;
+        return {
+          cwd,
+          stateDir: statedir,
+          mode: "web",
+          autoBootstrapProjectFromCwd: false,
+          logWebSocketEvents: false,
+          port: 0,
+          host: undefined,
+          authToken: undefined,
+          keybindingsConfigPath: path.join(statedir, "keybindings.json"),
+          staticDir: undefined,
+          devUrl: undefined,
+          noBrowser: false,
+        };
+      }),
+    );
+}
 
 // Helpers