Merge branch 'main' into ryan/upgrade_to_zod_4

Author: ryans-posthog

apps/code/src/main/services/agent/schemas.ts

@@ -49,6 +49,7 @@ export const startSessionInput = z.object({
   additionalDirectories: z.array(z.string()).optional(),
   customInstructions: z.string().max(2000).optional(),
   effort: effortLevelSchema.optional(),
+  model: z.string().optional(),
 });
 
 export type StartSessionInput = z.infer<typeof startSessionInput>;
@@ -292,3 +293,10 @@ export const getGatewayModelsInput = z.object({
 });
 
 export const getGatewayModelsOutput = z.array(modelOptionSchema);
+
+export const getPreviewConfigOptionsInput = z.object({
+  apiHost: z.string(),
+  adapter: z.enum(["claude", "codex"]),
+});
+
+export const getPreviewConfigOptionsOutput = z.array(sessionConfigOptionSchema);

apps/code/src/main/services/agent/service.ts

@@ -14,11 +14,16 @@ import {
 } from "@agentclientprotocol/sdk";
 import { isMcpToolReadOnly } from "@posthog/agent";
 import { hydrateSessionJsonl } from "@posthog/agent/adapters/claude/session/jsonl-hydration";
+import { getEffortOptions } from "@posthog/agent/adapters/claude/session/models";
 import { Agent } from "@posthog/agent/agent";
+import { getAvailableModes } from "@posthog/agent/execution-mode";
 import {
+  DEFAULT_GATEWAY_MODEL,
   fetchGatewayModels,
   formatGatewayModelName,
   getProviderName,
+  isAnthropicModel,
+  isOpenAIModel,
 } from "@posthog/agent/gateway-models";
 import { getLlmGatewayUrl } from "@posthog/agent/posthog-api";
 import type { OnLogCallback } from "@posthog/agent/types";
@@ -189,6 +194,8 @@ interface SessionConfig {
   customInstructions?: string;
   /** Effort level for Claude sessions */
   effort?: EffortLevel;
+  /** Model to use for the session (e.g. "claude-sonnet-4-6") */
+  model?: string;
 }
 
 interface ManagedSession {
@@ -465,9 +472,10 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
       permissionMode,
       customInstructions,
       effort,
+      model,
     } = config;
 
-    // Preview sessions don't need a real repo — use a temp directory
+    // Preview config doesn't need a real repo — use a temp directory
     const repoPath = taskId === "__preview__" ? tmpdir() : rawRepoPath;
 
     if (!isRetry) {
@@ -638,6 +646,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
             sessionId: existingSessionId,
             systemPrompt,
             ...(permissionMode && { permissionMode }),
+            ...(model != null && { model }),
             claudeCode: {
               options: {
                 ...(additionalDirectories?.length && {
@@ -669,6 +678,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
             taskRunId,
             systemPrompt,
             ...(permissionMode && { permissionMode }),
+            ...(model != null && { model }),
             claudeCode: {
               options: {
                 ...(additionalDirectories?.length && { additionalDirectories }),
@@ -1362,6 +1372,7 @@ For git operations while detached:
       customInstructions:
         "customInstructions" in params ? params.customInstructions : undefined,
       effort: "effort" in params ? params.effort : undefined,
+      model: "model" in params ? params.model : undefined,
     };
   }
 
@@ -1513,4 +1524,98 @@ For git operations while detached:
       return getModelTier(a.modelId) - getModelTier(b.modelId);
     });
   }
+
+  async getPreviewConfigOptions(
+    apiHost: string,
+    adapter: "claude" | "codex" = "claude",
+  ): Promise<SessionConfigOption[]> {
+    const gatewayUrl = getLlmGatewayUrl(apiHost);
+    const gatewayModels = await fetchGatewayModels({ gatewayUrl });
+
+    const modelFilter = adapter === "codex" ? isOpenAIModel : isAnthropicModel;
+
+    const modelOptions = gatewayModels
+      .filter((model) => modelFilter(model))
+      .map((model) => ({
+        value: model.id,
+        name: formatGatewayModelName(model),
+        description: `Context: ${model.context_window.toLocaleString()} tokens`,
+      }));
+
+    const defaultModel =
+      adapter === "codex"
+        ? (modelOptions[0]?.value ?? "")
+        : DEFAULT_GATEWAY_MODEL;
+
+    const resolvedModelId = modelOptions.some((o) => o.value === defaultModel)
+      ? defaultModel
+      : (modelOptions[0]?.value ?? defaultModel);
+
+    if (!modelOptions.some((o) => o.value === resolvedModelId)) {
+      modelOptions.unshift({
+        value: resolvedModelId,
+        name: resolvedModelId,
+        description: "Custom model",
+      });
+    }
+
+    const modeOptions = getAvailableModes().map((mode) => ({
+      value: mode.id,
+      name: mode.name,
+      description: mode.description ?? undefined,
+    }));
+
+    const configOptions: SessionConfigOption[] = [
+      {
+        id: "mode",
+        name: "Approval Preset",
+        type: "select",
+        currentValue: "plan",
+        options: modeOptions,
+        category: "mode",
+        description:
+          "Choose an approval and sandboxing preset for your session",
+      },
+      {
+        id: "model",
+        name: "Model",
+        type: "select",
+        currentValue: resolvedModelId,
+        options: modelOptions,
+        category: "model",
+        description: "Choose which model Claude should use",
+      },
+    ];
+
+    if (adapter === "codex") {
+      configOptions.push({
+        id: "reasoning_effort",
+        name: "Reasoning Level",
+        type: "select",
+        currentValue: "high",
+        options: [
+          { value: "low", name: "Low" },
+          { value: "medium", name: "Medium" },
+          { value: "high", name: "High" },
+        ],
+        category: "thought_level",
+        description: "Controls how much reasoning effort the model uses",
+      });
+    } else {
+      const effortOpts = getEffortOptions(resolvedModelId);
+      if (effortOpts) {
+        configOptions.push({
+          id: "effort",
+          name: "Effort",
+          type: "select",
+          currentValue: "high",
+          options: effortOpts,
+          category: "thought_level",
+          description: "Controls how much effort Claude puts into its response",
+        });
+      }
+    }
+
+    return configOptions;
+  }
 }

apps/code/src/main/services/git/create-pr-saga.ts

@@ -66,25 +66,28 @@ export class CreatePrSaga extends Saga<CreatePrSagaInput, CreatePrSagaOutput> {
     let { commitMessage, prTitle, prBody } = input;
 
     if (input.branchName) {
-      this.deps.onProgress(
-        "creating-branch",
-        `Creating branch ${input.branchName}...`,
+      const currentBranch = await this.readOnlyStep("get-original-branch", () =>
+        this.deps.getCurrentBranch(directoryPath),
       );
 
-      const originalBranch = await this.readOnlyStep(
-        "get-original-branch",
-        () => this.deps.getCurrentBranch(directoryPath),
-      );
+      // on retry, do not attempt to re-create the branch
+      if (currentBranch !== input.branchName) {
+        this.deps.onProgress(
+          "creating-branch",
+          `Creating branch ${input.branchName}...`,
+        );
 
-      await this.step({
-        name: "creating-branch",
-        execute: () => this.deps.createBranch(directoryPath, input.branchName!),
-        rollback: async () => {
-          if (originalBranch) {
-            await this.deps.checkoutBranch(directoryPath, originalBranch);
-          }
-        },
-      });
+        await this.step({
+          name: "creating-branch",
+          execute: () =>
+            this.deps.createBranch(directoryPath, input.branchName!),
+          rollback: async () => {
+            if (currentBranch) {
+              await this.deps.checkoutBranch(directoryPath, currentBranch);
+            }
+          },
+        });
+      }
     }
 
     const changedFiles = await this.readOnlyStep("check-changes", () =>

apps/code/src/main/trpc/routers/agent.ts

@@ -8,6 +8,8 @@ import {
   cancelSessionInput,
   getGatewayModelsInput,
   getGatewayModelsOutput,
+  getPreviewConfigOptionsInput,
+  getPreviewConfigOptionsOutput,
   listSessionsInput,
   listSessionsOutput,
   notifySessionContextInput,
@@ -193,4 +195,11 @@ export const agentRouter = router({
     .input(getGatewayModelsInput)
     .output(getGatewayModelsOutput)
     .query(({ input }) => getService().getGatewayModels(input.apiHost)),
+
+  getPreviewConfigOptions: publicProcedure
+    .input(getPreviewConfigOptionsInput)
+    .output(getPreviewConfigOptionsOutput)
+    .query(({ input }) =>
+      getService().getPreviewConfigOptions(input.apiHost, input.adapter),
+    ),
 });

apps/code/src/main/utils/fixPath.ts

@@ -3,13 +3,24 @@
  * (/usr/bin:/bin:/usr/sbin:/sbin) instead of the user's shell PATH which
  * includes /opt/homebrew/bin, ~/.local/bin, etc.
  *
- * This reads the PATH from the user's default shell (in interactive login mode)
- * and applies it to process.env.PATH so child processes have access to
+ * This reads the PATH from the user's default shell (in login mode) and
+ * applies it to process.env.PATH so child processes have access to
  * user-installed binaries.
+ *
+ * IMPORTANT: We use `-lc` (login, non-interactive) instead of `-ilc`
+ * (interactive login) to avoid loading the user's full .zshrc which may
+ * include heavy plugins (Oh My Zsh, NVM, thefuck, etc.) that spawn
+ * subprocesses and cause zombie process chains when the timeout kills
+ * only the parent shell.
+ *
+ * See: https://github.com/PostHog/code/issues/1399
  */
 
-import { execSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { userInfo } from "node:os";
+import { dirname, join } from "node:path";
+import { app } from "electron";
 
 const DELIMITER = "_SHELL_ENV_DELIMITER_";
 
@@ -25,6 +36,9 @@ const ANSI_REGEX =
   // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional for ANSI stripping
   /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-ntqry=><~]))/g;
 
+/** Max age of cached PATH before re-resolving (1 hour) */
+const CACHE_MAX_AGE_MS = 60 * 60 * 1000;
+
 function stripAnsi(str: string): string {
   return str.replace(ANSI_REGEX, "");
 }
@@ -50,20 +64,75 @@ function detectDefaultShell(): string {
   return process.env.SHELL || "/bin/sh";
 }
 
+function getCachePath(): string {
+  return join(app.getPath("userData"), "shell-env-cache.json");
+}
+
+function readCachedPath(): string | undefined {
+  try {
+    const cachePath = getCachePath();
+    if (!existsSync(cachePath)) {
+      return undefined;
+    }
+
+    const raw = readFileSync(cachePath, "utf-8");
+    const cache = JSON.parse(raw) as { path: string; timestamp: number };
+
+    if (Date.now() - cache.timestamp > CACHE_MAX_AGE_MS) {
+      return undefined;
+    }
+
+    return cache.path;
+  } catch {
+    return undefined;
+  }
+}
+
+function writeCachedPath(resolvedPath: string): void {
+  try {
+    const cachePath = getCachePath();
+    const dir = dirname(cachePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(
+      cachePath,
+      JSON.stringify({ path: resolvedPath, timestamp: Date.now() }),
+      "utf-8",
+    );
+  } catch {
+    // Cache write failure is non-fatal
+  }
+}
+
 function executeShell(shell: string): string | undefined {
   const command = `echo -n "${DELIMITER}"; env; echo -n "${DELIMITER}"; exit`;
 
   try {
-    return execSync(`${shell} -ilc '${command}'`, {
+    const result = spawnSync(shell, ["-lc", command], {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["ignore", "pipe", "ignore"],
+      // Kill the entire process group on timeout, not just the parent shell.
+      // This prevents orphaned children (node -v, printf, tail, sed) from
+      // surviving as zombies.
+      killSignal: "SIGKILL",
       env: {
         ...process.env,
         // Disable Oh My Zsh auto-update which can block
         DISABLE_AUTO_UPDATE: "true",
+        // Signal to user's shell config that we're resolving the environment.
+        // Users with heavy configs can check this and fast-exit:
+        //   [[ -n "$POSTHOG_CODE_RESOLVING_ENVIRONMENT" ]] && return
+        POSTHOG_CODE_RESOLVING_ENVIRONMENT: "1",
       },
     });
+
+    if (result.status !== 0 && !result.stdout) {
+      return undefined;
+    }
+
+    return result.stdout || undefined;
   } catch {
     return undefined;
   }
@@ -110,11 +179,20 @@ export function fixPath(): void {
     return;
   }
 
+  // Try cached PATH first (instant, no shell spawn)
+  const cached = readCachedPath();
+  if (cached) {
+    process.env.PATH = cached;
+    return;
+  }
+
   const shell = detectDefaultShell();
   const shellPath = getShellPath(shell);
 
   if (shellPath) {
-    process.env.PATH = stripAnsi(shellPath);
+    const cleaned = stripAnsi(shellPath);
+    process.env.PATH = cleaned;
+    writeCachedPath(cleaned);
   } else {
     process.env.PATH = buildFallbackPath();
   }