refactor: unify CLI session flow and remove dead settings/OAuth paths

Author: LIU9293

packages/agents/claude/client.ts

@@ -7,12 +7,11 @@ import {
   runCliJsonCommand,
   type SessionEnvironment as RuntimeSessionEnvironment,
 } from "../runtime/base";
-import { getOrCreateThreadSession } from "../runtime/thread-session";
+import { createCliThreadSessionManager } from "../runtime/cli-session";
 import type {
   OpenCodeMessage,
   OpenCodeMessageContext,
   OpenCodeOptions,
-  OpenCodeSessionInfo,
 } from "../types";
 
 export type SessionEnvironment = RuntimeSessionEnvironment;
@@ -50,52 +49,13 @@ function isValidUuid(value: string): boolean {
   return uuidRegex.test(value);
 }
 
-export async function createSession(workingPath: string, env?: SessionEnvironment): Promise<string> {
-  const sessionId = crypto.randomUUID();
-  runtime.setSessionEnvironment(sessionId, env ?? {});
-  newSessions.add(sessionId);
-  log.info("Created Claude session", { sessionId, workingPath });
-  return sessionId;
-}
-
-export async function getOrCreateSession(
-  channelId: string,
-  threadId: string,
-  workingPath: string,
-  env: SessionEnvironment = {}
-): Promise<OpenCodeSessionInfo> {
-  return getOrCreateThreadSession({
-    channelId,
-    threadId,
-    providerId: "claudecode",
-    workingPath,
-    env,
-    createSession,
-    getSessionEnvironment: (sessionId) => runtime.getSessionEnvironment(sessionId),
-    setSessionEnvironment: (sessionId, nextEnv) => {
-      runtime.setSessionEnvironment(sessionId, nextEnv);
-    },
-    validateSessionId: isValidUuid,
-    onInvalidSessionId: (existingSession) => {
-      log.info("Invalid Claude session id found; generating new session", {
-        channelId,
-        threadId,
-        workingPath,
-        existingSession,
-      });
-    },
-    onEnvironmentChanged: () => {
-      log.info("Claude session environment changed; creating new session", {
-        channelId,
-        threadId,
-        workingPath,
-      });
-    },
-    onCreatingSession: () => {
-      log.info("Creating new Claude session for thread", { channelId, threadId, workingPath });
-    },
-  });
-}
+export const { createSession, getOrCreateSession } = createCliThreadSessionManager({
+  providerId: "claudecode",
+  providerName: "Claude",
+  runtime,
+  newSessions,
+  validateSessionId: isValidUuid,
+});
 
 function extractJsonPayload(output: string): string {
   const trimmed = output.trim();

packages/agents/codex/client.ts

@@ -8,15 +8,19 @@ import {
   runCliJsonCommand,
   type SessionEnvironment as RuntimeSessionEnvironment,
 } from "../runtime/base";
-import { getOrCreateThreadSession } from "../runtime/thread-session";
+import { createCliThreadSessionManager } from "../runtime/cli-session";
 import type {
   OpenCodeMessage,
   OpenCodeMessageContext,
   OpenCodeOptions,
-  OpenCodeSessionInfo,
 } from "../types";
 
 const runtime = new CliAgentRuntime("Codex");
+export const { createSession, getOrCreateSession } = createCliThreadSessionManager({
+  providerId: "codex",
+  providerName: "Codex",
+  runtime,
+});
 
 export type SessionEnvironment = RuntimeSessionEnvironment;
 
@@ -153,43 +157,6 @@ function parseCodexResponse(output: string): {
   return { text, threadId };
 }
 
-export async function createSession(workingPath: string, env?: SessionEnvironment): Promise<string> {
-  const sessionId = crypto.randomUUID();
-  runtime.setSessionEnvironment(sessionId, env ?? {});
-  log.info("Created Codex session", { sessionId, workingPath });
-  return sessionId;
-}
-
-export async function getOrCreateSession(
-  channelId: string,
-  threadId: string,
-  workingPath: string,
-  env: SessionEnvironment = {}
-): Promise<OpenCodeSessionInfo> {
-  return getOrCreateThreadSession({
-    channelId,
-    threadId,
-    providerId: "codex",
-    workingPath,
-    env,
-    createSession,
-    getSessionEnvironment: (sessionId) => runtime.getSessionEnvironment(sessionId),
-    setSessionEnvironment: (sessionId, nextEnv) => {
-      runtime.setSessionEnvironment(sessionId, nextEnv);
-    },
-    onEnvironmentChanged: () => {
-      log.info("Codex session environment changed; creating new session", {
-        channelId,
-        threadId,
-        workingPath,
-      });
-    },
-    onCreatingSession: () => {
-      log.info("Creating new Codex session for thread", { channelId, threadId, workingPath });
-    },
-  });
-}
-
 export async function sendMessage(
   channelId: string,
   sessionId: string,

packages/agents/gemini/client.ts

@@ -8,12 +8,11 @@ import {
   runCliJsonCommand,
   type SessionEnvironment as RuntimeSessionEnvironment,
 } from "../runtime/base";
-import { getOrCreateThreadSession } from "../runtime/thread-session";
+import { createCliThreadSessionManager } from "../runtime/cli-session";
 import type {
   OpenCodeMessage,
   OpenCodeMessageContext,
   OpenCodeOptions,
-  OpenCodeSessionInfo,
 } from "../types";
 
 export type SessionEnvironment = RuntimeSessionEnvironment;
@@ -39,6 +38,12 @@ type GeminiJsonRecord = {
 
 const runtime = new CliAgentRuntime("Gemini");
 const newSessions = new Set<string>();
+export const { createSession, getOrCreateSession } = createCliThreadSessionManager({
+  providerId: "gemini",
+  providerName: "Gemini",
+  runtime,
+  newSessions,
+});
 
 function resolveGeminiBinary(): string {
   if (typeof Bun !== "undefined" && Bun.which("gemini")) return "gemini";
@@ -158,44 +163,6 @@ function parseGeminiResponse(output: string): {
   return { text, sessionId };
 }
 
-export async function createSession(workingPath: string, env?: SessionEnvironment): Promise<string> {
-  const sessionId = crypto.randomUUID();
-  runtime.setSessionEnvironment(sessionId, env ?? {});
-  newSessions.add(sessionId);
-  log.info("Created Gemini session", { sessionId, workingPath });
-  return sessionId;
-}
-
-export async function getOrCreateSession(
-  channelId: string,
-  threadId: string,
-  workingPath: string,
-  env: SessionEnvironment = {}
-): Promise<OpenCodeSessionInfo> {
-  return getOrCreateThreadSession({
-    channelId,
-    threadId,
-    providerId: "gemini",
-    workingPath,
-    env,
-    createSession,
-    getSessionEnvironment: (sessionId) => runtime.getSessionEnvironment(sessionId),
-    setSessionEnvironment: (sessionId, nextEnv) => {
-      runtime.setSessionEnvironment(sessionId, nextEnv);
-    },
-    onEnvironmentChanged: () => {
-      log.info("Gemini session environment changed; creating new session", {
-        channelId,
-        threadId,
-        workingPath,
-      });
-    },
-    onCreatingSession: () => {
-      log.info("Creating new Gemini session for thread", { channelId, threadId, workingPath });
-    },
-  });
-}
-
 export async function sendMessage(
   channelId: string,
   sessionId: string,

packages/agents/goose/client.ts

@@ -8,12 +8,11 @@ import {
   runCliJsonCommand,
   type SessionEnvironment as RuntimeSessionEnvironment,
 } from "../runtime/base";
-import { getOrCreateThreadSession } from "../runtime/thread-session";
+import { createCliThreadSessionManager } from "../runtime/cli-session";
 import type {
   OpenCodeMessage,
   OpenCodeMessageContext,
   OpenCodeOptions,
-  OpenCodeSessionInfo,
 } from "../types";
 
 export type SessionEnvironment = RuntimeSessionEnvironment;
@@ -43,6 +42,12 @@ type GooseJsonRecord = {
 
 const runtime = new CliAgentRuntime("Goose");
 const newSessions = new Set<string>();
+export const { createSession, getOrCreateSession } = createCliThreadSessionManager({
+  providerId: "goose",
+  providerName: "Goose",
+  runtime,
+  newSessions,
+});
 
 function resolveGooseBinary(): string {
   if (typeof Bun !== "undefined" && Bun.which("goose")) return "goose";
@@ -192,44 +197,6 @@ export function parseGooseResponse(output: string): {
   return { text, sessionId };
 }
 
-export async function createSession(workingPath: string, env?: SessionEnvironment): Promise<string> {
-  const sessionId = crypto.randomUUID();
-  runtime.setSessionEnvironment(sessionId, env ?? {});
-  newSessions.add(sessionId);
-  log.info("Created Goose session", { sessionId, workingPath });
-  return sessionId;
-}
-
-export async function getOrCreateSession(
-  channelId: string,
-  threadId: string,
-  workingPath: string,
-  env: SessionEnvironment = {}
-): Promise<OpenCodeSessionInfo> {
-  return getOrCreateThreadSession({
-    channelId,
-    threadId,
-    providerId: "goose",
-    workingPath,
-    env,
-    createSession,
-    getSessionEnvironment: (sessionId) => runtime.getSessionEnvironment(sessionId),
-    setSessionEnvironment: (sessionId, nextEnv) => {
-      runtime.setSessionEnvironment(sessionId, nextEnv);
-    },
-    onEnvironmentChanged: () => {
-      log.info("Goose session environment changed; creating new session", {
-        channelId,
-        threadId,
-        workingPath,
-      });
-    },
-    onCreatingSession: () => {
-      log.info("Creating new Goose session for thread", { channelId, threadId, workingPath });
-    },
-  });
-}
-
 export async function sendMessage(
   channelId: string,
   sessionId: string,

packages/agents/kilo/client.ts

@@ -8,12 +8,11 @@ import {
   runCliJsonCommand,
   type SessionEnvironment as RuntimeSessionEnvironment,
 } from "../runtime/base";
-import { getOrCreateThreadSession } from "../runtime/thread-session";
+import { createCliThreadSessionManager } from "../runtime/cli-session";
 import type {
   OpenCodeMessage,
   OpenCodeMessageContext,
   OpenCodeOptions,
-  OpenCodeSessionInfo,
 } from "../types";
 
 export type SessionEnvironment = RuntimeSessionEnvironment;
@@ -82,6 +81,15 @@ function isValidKiloSessionId(value: string): boolean {
   return value.startsWith("ses");
 }
 
+export const { createSession, getOrCreateSession } = createCliThreadSessionManager({
+  providerId: "kilo",
+  providerName: "Kilo",
+  runtime,
+  newSessions,
+  sessionIdFactory: buildKiloSessionId,
+  validateSessionId: isValidKiloSessionId,
+});
+
 function buildModelArg(model?: OpenCodeOptions["model"]): string | undefined {
   if (!model?.modelID) return undefined;
   const providerID = model.providerID?.trim() || "openai";
@@ -282,53 +290,6 @@ function extractKiloFinalResponse(output: string): string {
   return text || cleaned.trim();
 }
 
-export async function createSession(workingPath: string, env?: SessionEnvironment): Promise<string> {
-  const sessionId = buildKiloSessionId();
-  runtime.setSessionEnvironment(sessionId, env ?? {});
-  newSessions.add(sessionId);
-  log.info("Created Kilo session", { sessionId, workingPath });
-  return sessionId;
-}
-
-export async function getOrCreateSession(
-  channelId: string,
-  threadId: string,
-  workingPath: string,
-  env: SessionEnvironment = {}
-): Promise<OpenCodeSessionInfo> {
-  return getOrCreateThreadSession({
-    channelId,
-    threadId,
-    providerId: "kilo",
-    workingPath,
-    env,
-    createSession,
-    getSessionEnvironment: (sessionId) => runtime.getSessionEnvironment(sessionId),
-    setSessionEnvironment: (sessionId, nextEnv) => {
-      runtime.setSessionEnvironment(sessionId, nextEnv);
-    },
-    validateSessionId: isValidKiloSessionId,
-    onInvalidSessionId: (existingSession) => {
-      log.info("Invalid Kilo session id found; generating new session", {
-        channelId,
-        threadId,
-        workingPath,
-        existingSession,
-      });
-    },
-    onEnvironmentChanged: () => {
-      log.info("Kilo session environment changed; creating new session", {
-        channelId,
-        threadId,
-        workingPath,
-      });
-    },
-    onCreatingSession: () => {
-      log.info("Creating new Kilo session for thread", { channelId, threadId, workingPath });
-    },
-  });
-}
-
 export async function sendMessage(
   channelId: string,
   sessionId: string,