Bohdan Triapitsyn
10e64b4f90
* feat: WIP multirun implementation * feat(chat): replace MindMap icon with ArrowsMerge * feat(multirun): add base branch selection for worktrees * feat(mobile): add multi-run launcher overlay
1092 lines
51 KiB
TypeScript
1092 lines
51 KiB
TypeScript
import { create } from "zustand";
|
|
import { devtools, persist, createJSONStorage } from "zustand/middleware";
|
|
import type { Session } from "@opencode-ai/sdk";
|
|
import { opencodeClient } from "@/lib/opencode/client";
|
|
import { getSafeStorage } from "./utils/safeStorage";
|
|
import type { WorktreeMetadata } from "@/types/worktree";
|
|
import { archiveWorktree, getWorktreeStatus, listWorktrees, mapWorktreeToMetadata } from "@/lib/git/worktreeService";
|
|
import { useDirectoryStore } from "./useDirectoryStore";
|
|
import { checkIsGitRepository } from "@/lib/gitApi";
|
|
|
|
interface SessionState {
|
|
sessions: Session[];
|
|
currentSessionId: string | null;
|
|
lastLoadedDirectory: string | null;
|
|
isLoading: boolean;
|
|
error: string | null;
|
|
webUICreatedSessions: Set<string>;
|
|
worktreeMetadata: Map<string, WorktreeMetadata>;
|
|
availableWorktrees: WorktreeMetadata[];
|
|
}
|
|
|
|
interface SessionActions {
|
|
loadSessions: () => Promise<void>;
|
|
createSession: (title?: string, directoryOverride?: string | null, parentID?: string | null) => Promise<Session | null>;
|
|
deleteSession: (id: string, options?: { archiveWorktree?: boolean; deleteRemoteBranch?: boolean; remoteName?: string }) => Promise<boolean>;
|
|
deleteSessions: (ids: string[], options?: { archiveWorktree?: boolean; deleteRemoteBranch?: boolean; remoteName?: string; silent?: boolean }) => Promise<{ deletedIds: string[]; failedIds: string[] }>;
|
|
updateSessionTitle: (id: string, title: string) => Promise<void>;
|
|
shareSession: (id: string) => Promise<Session | null>;
|
|
unshareSession: (id: string) => Promise<Session | null>;
|
|
setCurrentSession: (id: string | null) => void;
|
|
clearError: () => void;
|
|
getSessionsByDirectory: (directory: string) => Session[];
|
|
applySessionMetadata: (sessionId: string, metadata: Partial<Session>) => void;
|
|
isOpenChamberCreatedSession: (sessionId: string) => boolean;
|
|
markSessionAsOpenChamberCreated: (sessionId: string) => void;
|
|
initializeNewOpenChamberSession: (sessionId: string, agents: Record<string, unknown>[]) => void;
|
|
setWorktreeMetadata: (sessionId: string, metadata: WorktreeMetadata | null) => void;
|
|
getWorktreeMetadata: (sessionId: string) => WorktreeMetadata | undefined;
|
|
setSessionDirectory: (sessionId: string, directory: string | null) => void;
|
|
updateSession: (session: Session) => void;
|
|
}
|
|
|
|
type SessionStore = SessionState & SessionActions;
|
|
|
|
const safeStorage = getSafeStorage();
|
|
const SESSION_SELECTION_STORAGE_KEY = "oc.sessionSelectionByDirectory";
|
|
const WORKTREE_ROOT = ".openchamber";
|
|
|
|
type SessionSelectionMap = Record<string, string>;
|
|
|
|
const readSessionSelectionMap = (): SessionSelectionMap => {
|
|
try {
|
|
const raw = safeStorage.getItem(SESSION_SELECTION_STORAGE_KEY);
|
|
if (!raw) {
|
|
return {};
|
|
}
|
|
const parsed = JSON.parse(raw);
|
|
if (!parsed || typeof parsed !== "object") {
|
|
return {};
|
|
}
|
|
return Object.entries(parsed as Record<string, unknown>).reduce<SessionSelectionMap>((acc, [directory, sessionId]) => {
|
|
if (typeof directory === "string" && typeof sessionId === "string" && directory.length > 0 && sessionId.length > 0) {
|
|
acc[directory] = sessionId;
|
|
}
|
|
return acc;
|
|
}, {});
|
|
} catch {
|
|
return {};
|
|
}
|
|
};
|
|
|
|
let sessionSelectionCache: SessionSelectionMap | null = null;
|
|
|
|
const getSessionSelectionMap = (): SessionSelectionMap => {
|
|
if (!sessionSelectionCache) {
|
|
sessionSelectionCache = readSessionSelectionMap();
|
|
}
|
|
return sessionSelectionCache;
|
|
};
|
|
|
|
const persistSessionSelectionMap = (map: SessionSelectionMap) => {
|
|
sessionSelectionCache = map;
|
|
try {
|
|
safeStorage.setItem(SESSION_SELECTION_STORAGE_KEY, JSON.stringify(map));
|
|
} catch { /* ignored */ }
|
|
};
|
|
|
|
const getStoredSessionForDirectory = (directory: string | null | undefined): string | null => {
|
|
if (!directory) {
|
|
return null;
|
|
}
|
|
const map = getSessionSelectionMap();
|
|
const selection = map[directory];
|
|
return typeof selection === "string" ? selection : null;
|
|
};
|
|
|
|
const storeSessionForDirectory = (directory: string | null | undefined, sessionId: string | null) => {
|
|
if (!directory) {
|
|
return;
|
|
}
|
|
const map = { ...getSessionSelectionMap() };
|
|
if (sessionId) {
|
|
map[directory] = sessionId;
|
|
} else {
|
|
delete map[directory];
|
|
}
|
|
persistSessionSelectionMap(map);
|
|
};
|
|
|
|
const clearInvalidSessionSelection = (directory: string | null | undefined, validIds: Iterable<string>) => {
|
|
if (!directory) {
|
|
return;
|
|
}
|
|
const storedSelection = getStoredSessionForDirectory(directory);
|
|
if (!storedSelection) {
|
|
return;
|
|
}
|
|
const validSet = new Set(validIds);
|
|
if (!validSet.has(storedSelection)) {
|
|
const map = { ...getSessionSelectionMap() };
|
|
delete map[directory];
|
|
persistSessionSelectionMap(map);
|
|
}
|
|
};
|
|
|
|
const archiveSessionWorktree = async (
|
|
metadata: WorktreeMetadata,
|
|
options?: { deleteRemoteBranch?: boolean; remoteName?: string }
|
|
) => {
|
|
const status = metadata.status ?? (await getWorktreeStatus(metadata.path).catch(() => undefined));
|
|
await archiveWorktree({
|
|
projectDirectory: metadata.projectDirectory,
|
|
path: metadata.path,
|
|
branch: metadata.branch,
|
|
force: Boolean(status?.isDirty),
|
|
deleteRemote: Boolean(options?.deleteRemoteBranch),
|
|
remote: options?.remoteName,
|
|
});
|
|
};
|
|
|
|
const normalizePath = (value?: string | null): string | null => {
|
|
if (typeof value !== "string") {
|
|
return null;
|
|
}
|
|
const trimmed = value.trim();
|
|
if (!trimmed) {
|
|
return null;
|
|
}
|
|
const replaced = trimmed.replace(/\\/g, "/");
|
|
if (replaced === "/") {
|
|
return "/";
|
|
}
|
|
return replaced.length > 1 ? replaced.replace(/\/+$/, "") : replaced;
|
|
};
|
|
|
|
const getSessionDirectory = (sessions: Session[], sessionId: string): string | null => {
|
|
const target = sessions.find((session) => session.id === sessionId);
|
|
if (!target) {
|
|
return null;
|
|
}
|
|
return normalizePath((target as { directory?: string | null }).directory ?? null);
|
|
};
|
|
|
|
const hydrateSessionWorktreeMetadata = async (
|
|
sessions: Session[],
|
|
projectDirectory: string | null,
|
|
existingMetadata: Map<string, WorktreeMetadata>
|
|
): Promise<Map<string, WorktreeMetadata> | null> => {
|
|
const normalizedProject = normalizePath(projectDirectory);
|
|
if (!normalizedProject || sessions.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
const sessionsWithDirectory = sessions
|
|
.map((session) => ({ id: session.id, directory: normalizePath((session as { directory?: string }).directory) }))
|
|
.filter((entry): entry is { id: string; directory: string } => Boolean(entry.directory));
|
|
|
|
if (sessionsWithDirectory.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
let worktreeEntries;
|
|
try {
|
|
worktreeEntries = await listWorktrees(normalizedProject);
|
|
} catch (error) {
|
|
console.debug("Failed to hydrate worktree metadata from git worktree list:", error);
|
|
return null;
|
|
}
|
|
|
|
if (!Array.isArray(worktreeEntries) || worktreeEntries.length === 0) {
|
|
let mutated = false;
|
|
const next = new Map(existingMetadata);
|
|
sessionsWithDirectory.forEach(({ id }) => {
|
|
if (next.delete(id)) {
|
|
mutated = true;
|
|
}
|
|
});
|
|
return mutated ? next : null;
|
|
}
|
|
|
|
const worktreeMapByPath = new Map<string, WorktreeMetadata>();
|
|
worktreeEntries.forEach((info) => {
|
|
const metadata = mapWorktreeToMetadata(normalizedProject, info);
|
|
const normalizedPath = normalizePath(metadata.path) ?? metadata.path;
|
|
|
|
if (normalizedPath === normalizedProject) {
|
|
return;
|
|
}
|
|
|
|
worktreeMapByPath.set(normalizedPath, metadata);
|
|
});
|
|
|
|
let mutated = false;
|
|
const next = new Map(existingMetadata);
|
|
|
|
sessionsWithDirectory.forEach(({ id, directory }) => {
|
|
const metadata = worktreeMapByPath.get(directory);
|
|
if (!metadata) {
|
|
if (next.delete(id)) {
|
|
mutated = true;
|
|
}
|
|
return;
|
|
}
|
|
|
|
const previous = next.get(id);
|
|
if (!previous || previous.path !== metadata.path || previous.branch !== metadata.branch || previous.label !== metadata.label) {
|
|
next.set(id, metadata);
|
|
mutated = true;
|
|
}
|
|
});
|
|
|
|
return mutated ? next : null;
|
|
};
|
|
|
|
export const useSessionStore = create<SessionStore>()(
|
|
devtools(
|
|
persist(
|
|
(set, get) => ({
|
|
|
|
sessions: [],
|
|
currentSessionId: null,
|
|
lastLoadedDirectory: null,
|
|
isLoading: false,
|
|
error: null,
|
|
webUICreatedSessions: new Set(),
|
|
worktreeMetadata: new Map(),
|
|
availableWorktrees: [],
|
|
|
|
loadSessions: async () => {
|
|
set({ isLoading: true, error: null });
|
|
try {
|
|
const directoryStore = useDirectoryStore.getState();
|
|
const projectDirectory = directoryStore.currentDirectory ?? opencodeClient.getDirectory() ?? null;
|
|
const apiClient = opencodeClient.getApiClient();
|
|
|
|
const fetchSessions = async (directoryParam?: string | null): Promise<Session[]> => {
|
|
const response = await apiClient.session.list({
|
|
query: directoryParam ? { directory: directoryParam } : undefined,
|
|
});
|
|
return Array.isArray(response.data) ? response.data : [];
|
|
};
|
|
|
|
const normalizedProject = normalizePath(projectDirectory);
|
|
|
|
const isGitRepo = normalizedProject ? await checkIsGitRepository(normalizedProject).catch(() => false) : false;
|
|
|
|
const parentSessions = await fetchSessions(normalizedProject || null);
|
|
|
|
const subdirectorySessions: Session[] = [];
|
|
let discoveredWorktrees: WorktreeMetadata[] = [];
|
|
|
|
if (projectDirectory && isGitRepo && normalizedProject) {
|
|
const worktreeRoot = `${normalizedProject}/${WORKTREE_ROOT}`;
|
|
try {
|
|
const candidates = new Set<string>();
|
|
|
|
// Check if .openchamber directory exists before trying to list it
|
|
const projectEntries = await opencodeClient.listLocalDirectory(normalizedProject);
|
|
const worktreeDirExists = projectEntries.some(
|
|
(entry) => entry.isDirectory && entry.name === WORKTREE_ROOT
|
|
);
|
|
|
|
if (worktreeDirExists) {
|
|
const entries = await opencodeClient.listLocalDirectory(worktreeRoot);
|
|
entries
|
|
.filter((entry) => entry.isDirectory)
|
|
.forEach((entry) => {
|
|
const isAbsolutePath = /^([A-Za-z]:)?\//.test(entry.path);
|
|
const resolvedPath = isAbsolutePath ? entry.path : `${worktreeRoot}/${entry.name}`;
|
|
candidates.add(normalizePath(resolvedPath) ?? resolvedPath);
|
|
});
|
|
}
|
|
|
|
const listedWorktrees = await listWorktrees(normalizedProject);
|
|
if (Array.isArray(listedWorktrees)) {
|
|
discoveredWorktrees = listedWorktrees
|
|
.map((info) => mapWorktreeToMetadata(normalizedProject, info))
|
|
.filter((meta) => meta.path.includes(`/${WORKTREE_ROOT}/`));
|
|
discoveredWorktrees.forEach((meta) => candidates.add(meta.path));
|
|
}
|
|
|
|
if (candidates.size > 0) {
|
|
const results = await Promise.allSettled(
|
|
Array.from(candidates).map((path) => fetchSessions(path))
|
|
);
|
|
results.forEach((result) => {
|
|
if (result.status === "fulfilled" && Array.isArray(result.value)) {
|
|
subdirectorySessions.push(...result.value);
|
|
}
|
|
});
|
|
}
|
|
} catch {
|
|
|
|
discoveredWorktrees = [];
|
|
}
|
|
}
|
|
|
|
const validPaths = new Set<string>();
|
|
if (normalizedProject) {
|
|
validPaths.add(normalizedProject);
|
|
}
|
|
discoveredWorktrees.forEach((meta) => {
|
|
const normalized = normalizePath(meta.path);
|
|
if (normalized) {
|
|
validPaths.add(normalized);
|
|
}
|
|
});
|
|
|
|
const mergedSessions = [...parentSessions, ...subdirectorySessions].filter((session) => {
|
|
const rawDir = (session as { directory?: string | null }).directory ?? normalizedProject ?? null;
|
|
const normalizedDir = normalizePath(rawDir);
|
|
if (!normalizedDir) {
|
|
return false;
|
|
}
|
|
return validPaths.has(normalizedDir);
|
|
});
|
|
const stateSnapshot = get();
|
|
|
|
const previousDirectory = stateSnapshot.lastLoadedDirectory ?? null;
|
|
const directoryChanged = projectDirectory !== previousDirectory;
|
|
|
|
let nextSessions = [...mergedSessions];
|
|
let nextCurrentId = stateSnapshot.currentSessionId;
|
|
|
|
const ensureSessionPresent = (session: Session) => {
|
|
nextSessions = [session, ...nextSessions.filter((item) => item.id !== session.id)];
|
|
};
|
|
|
|
if (directoryChanged) {
|
|
nextCurrentId = nextSessions.length > 0 ? nextSessions[0].id : null;
|
|
} else {
|
|
if (nextCurrentId) {
|
|
const hasCurrent = nextSessions.some((session) => session.id === nextCurrentId);
|
|
if (!hasCurrent) {
|
|
const persistedSession = stateSnapshot.sessions.find((session) => session.id === nextCurrentId);
|
|
|
|
if (persistedSession) {
|
|
ensureSessionPresent(persistedSession);
|
|
} else {
|
|
try {
|
|
const resolvedSession = await opencodeClient.getSession(nextCurrentId);
|
|
ensureSessionPresent(resolvedSession);
|
|
} catch {
|
|
nextCurrentId = nextSessions.length > 0 ? nextSessions[0].id : null;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
nextCurrentId = nextSessions.length > 0 ? nextSessions[0].id : null;
|
|
}
|
|
}
|
|
|
|
const dedupedSessions = nextSessions.reduce<Session[]>((accumulator, session) => {
|
|
if (!accumulator.some((existing) => existing.id === session.id)) {
|
|
accumulator.push(session);
|
|
}
|
|
return accumulator;
|
|
}, []);
|
|
|
|
if (nextCurrentId && !dedupedSessions.some((session) => session.id === nextCurrentId)) {
|
|
nextCurrentId = dedupedSessions.length > 0 ? dedupedSessions[0].id : null;
|
|
}
|
|
|
|
const validSessionIds = new Set(dedupedSessions.map((session) => session.id));
|
|
|
|
const resolveSelectionDirectory = (sessionId: string | null): string | null => {
|
|
if (!sessionId) {
|
|
return null;
|
|
}
|
|
const sessionDir = getSessionDirectory(dedupedSessions, sessionId);
|
|
if (sessionDir) {
|
|
return sessionDir;
|
|
}
|
|
const persistedDir = getSessionDirectory(stateSnapshot.sessions, sessionId);
|
|
if (persistedDir) {
|
|
return persistedDir;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const selectionDirectoryKey = resolveSelectionDirectory(nextCurrentId) ?? normalizedProject ?? projectDirectory ?? null;
|
|
|
|
if (projectDirectory) {
|
|
clearInvalidSessionSelection(projectDirectory, validSessionIds);
|
|
}
|
|
|
|
if (selectionDirectoryKey) {
|
|
clearInvalidSessionSelection(selectionDirectoryKey, validSessionIds);
|
|
const storedSelection = getStoredSessionForDirectory(selectionDirectoryKey);
|
|
if (storedSelection && validSessionIds.has(storedSelection)) {
|
|
nextCurrentId = storedSelection;
|
|
}
|
|
}
|
|
|
|
let hydratedMetadata: Map<string, WorktreeMetadata> | null = null;
|
|
try {
|
|
hydratedMetadata = await hydrateSessionWorktreeMetadata(
|
|
dedupedSessions,
|
|
projectDirectory,
|
|
stateSnapshot.worktreeMetadata
|
|
);
|
|
} catch (metadataError) {
|
|
console.debug("Failed to refresh worktree metadata during session load:", metadataError);
|
|
}
|
|
|
|
const nextWorktreeMetadata = (() => {
|
|
const source = hydratedMetadata ?? stateSnapshot.worktreeMetadata;
|
|
if (!directoryChanged || !normalizedProject) {
|
|
return source;
|
|
}
|
|
|
|
const filtered = new Map<string, WorktreeMetadata>();
|
|
source.forEach((meta, key) => {
|
|
if (normalizePath(meta.projectDirectory) === normalizedProject) {
|
|
filtered.set(key, meta);
|
|
}
|
|
});
|
|
return filtered;
|
|
})();
|
|
|
|
const resolvedDirectoryForCurrent = (() => {
|
|
if (!nextCurrentId) {
|
|
return normalizedProject ?? null;
|
|
}
|
|
const metadataPath = nextWorktreeMetadata.get(nextCurrentId)?.path;
|
|
if (metadataPath) {
|
|
return normalizePath(metadataPath) ?? metadataPath;
|
|
}
|
|
const sessionDir = getSessionDirectory(dedupedSessions, nextCurrentId);
|
|
if (sessionDir) {
|
|
return sessionDir;
|
|
}
|
|
return normalizedProject ?? null;
|
|
})();
|
|
|
|
try {
|
|
opencodeClient.setDirectory(resolvedDirectoryForCurrent ?? undefined);
|
|
} catch (error) {
|
|
console.warn("Failed to sync OpenCode directory after session load:", error);
|
|
}
|
|
|
|
set({
|
|
sessions: dedupedSessions,
|
|
currentSessionId: nextCurrentId,
|
|
lastLoadedDirectory: projectDirectory,
|
|
isLoading: false,
|
|
worktreeMetadata: nextWorktreeMetadata,
|
|
availableWorktrees: discoveredWorktrees,
|
|
});
|
|
|
|
storeSessionForDirectory(resolvedDirectoryForCurrent ?? projectDirectory, nextCurrentId);
|
|
} catch (error) {
|
|
set({
|
|
error: error instanceof Error ? error.message : "Failed to load sessions",
|
|
isLoading: false,
|
|
});
|
|
}
|
|
},
|
|
|
|
createSession: async (title?: string, directoryOverride?: string | null, parentID?: string | null) => {
|
|
set({ error: null });
|
|
const directoryStore = useDirectoryStore.getState();
|
|
const fallbackDirectory = normalizePath(directoryStore.currentDirectory);
|
|
const targetDirectory = normalizePath(directoryOverride ?? opencodeClient.getDirectory() ?? fallbackDirectory);
|
|
|
|
const tempId = `temp_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
|
|
const previousState = get();
|
|
const existingIds = new Set(previousState.sessions.map((s) => s.id));
|
|
const optimisticSession: Session = {
|
|
id: tempId,
|
|
title: title || "New session",
|
|
parentID: parentID ?? undefined,
|
|
directory: targetDirectory ?? null,
|
|
projectID: (previousState.sessions[0] as { projectID?: string })?.projectID ?? "",
|
|
version: "0.0.0",
|
|
time: {
|
|
created: Date.now(),
|
|
updated: Date.now(),
|
|
},
|
|
summary: undefined,
|
|
share: undefined,
|
|
} as Session;
|
|
|
|
set((state) => ({
|
|
sessions: [optimisticSession, ...state.sessions],
|
|
currentSessionId: tempId,
|
|
webUICreatedSessions: new Set([...state.webUICreatedSessions, tempId]),
|
|
isLoading: false,
|
|
}));
|
|
|
|
if (targetDirectory) {
|
|
try {
|
|
opencodeClient.setDirectory(targetDirectory);
|
|
} catch (error) {
|
|
console.warn("Failed to sync OpenCode directory after session creation:", error);
|
|
}
|
|
}
|
|
|
|
const replaceOptimistic = (real: Session) => {
|
|
set((state) => {
|
|
const updatedSessions = state.sessions.map((item) => (item.id === tempId ? real : item));
|
|
return {
|
|
sessions: updatedSessions,
|
|
currentSessionId: real.id,
|
|
webUICreatedSessions: new Set([
|
|
...Array.from(state.webUICreatedSessions).filter((id) => id !== tempId),
|
|
real.id,
|
|
]),
|
|
};
|
|
});
|
|
storeSessionForDirectory(targetDirectory ?? null, real.id);
|
|
};
|
|
|
|
const pollForSession = async (): Promise<Session | null> => {
|
|
const apiClient = opencodeClient.getApiClient();
|
|
const attempts = 20;
|
|
for (let attempt = 0; attempt < attempts; attempt += 1) {
|
|
try {
|
|
const response = await apiClient.session.list({
|
|
query: targetDirectory ? { directory: targetDirectory } : undefined,
|
|
});
|
|
const list = Array.isArray(response.data) ? response.data : [];
|
|
const candidate = list.find((entry) => {
|
|
if (existingIds.has(entry.id)) return false;
|
|
if (title && entry.title && entry.title !== title) return false;
|
|
return true;
|
|
});
|
|
if (candidate) {
|
|
return candidate as Session;
|
|
}
|
|
} catch (pollError) {
|
|
console.debug("Session poll attempt failed:", pollError);
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, 2000));
|
|
}
|
|
return null;
|
|
};
|
|
|
|
try {
|
|
const createRequest = () => opencodeClient.createSession({ title, parentID: parentID ?? undefined });
|
|
let session: Session | null = null;
|
|
|
|
try {
|
|
session = targetDirectory
|
|
? await opencodeClient.withDirectory(targetDirectory, createRequest)
|
|
: await createRequest();
|
|
} catch (creationError) {
|
|
console.warn("Direct session create failed or timed out, falling back to polling:", creationError);
|
|
}
|
|
|
|
if (!session) {
|
|
session = await pollForSession();
|
|
}
|
|
|
|
if (session) {
|
|
replaceOptimistic(session);
|
|
return session;
|
|
}
|
|
|
|
set((state) => ({
|
|
sessions: state.sessions.filter((s) => s.id !== tempId),
|
|
currentSessionId: previousState.currentSessionId,
|
|
webUICreatedSessions: new Set(
|
|
Array.from(state.webUICreatedSessions).filter((id) => id !== tempId)
|
|
),
|
|
isLoading: false,
|
|
error: "Failed to create session",
|
|
}));
|
|
return null;
|
|
} catch (error) {
|
|
|
|
set((state) => ({
|
|
sessions: state.sessions.filter((s) => s.id !== tempId),
|
|
currentSessionId: previousState.currentSessionId,
|
|
webUICreatedSessions: new Set(
|
|
Array.from(state.webUICreatedSessions).filter((id) => id !== tempId)
|
|
),
|
|
isLoading: false,
|
|
error: error instanceof Error ? error.message : "Failed to create session",
|
|
}));
|
|
return null;
|
|
}
|
|
},
|
|
|
|
deleteSession: async (id: string, options) => {
|
|
set({ isLoading: true, error: null });
|
|
const metadata = get().worktreeMetadata.get(id);
|
|
const sessionDirectory = getSessionDirectory(get().sessions, id);
|
|
const overrideDirectory = metadata?.path ?? sessionDirectory;
|
|
let archivedMetadata: WorktreeMetadata | null = null;
|
|
try {
|
|
if (metadata && options?.archiveWorktree) {
|
|
await archiveSessionWorktree(metadata, {
|
|
deleteRemoteBranch: options?.deleteRemoteBranch,
|
|
remoteName: options?.remoteName,
|
|
});
|
|
archivedMetadata = metadata;
|
|
}
|
|
|
|
const deleteRequest = () => opencodeClient.deleteSession(id);
|
|
const success = overrideDirectory
|
|
? await opencodeClient.withDirectory(overrideDirectory, deleteRequest)
|
|
: await deleteRequest();
|
|
if (!success) {
|
|
set((state) => {
|
|
const update: Partial<SessionStore> = {
|
|
isLoading: false,
|
|
error: "Failed to delete session",
|
|
};
|
|
if (archivedMetadata) {
|
|
const nextMetadata = new Map(state.worktreeMetadata);
|
|
nextMetadata.delete(id);
|
|
update.worktreeMetadata = nextMetadata;
|
|
}
|
|
return update;
|
|
});
|
|
return false;
|
|
}
|
|
|
|
let nextCurrentId: string | null = null;
|
|
set((state) => {
|
|
const filteredSessions = state.sessions.filter((s) => s.id !== id);
|
|
nextCurrentId = state.currentSessionId === id ? null : state.currentSessionId;
|
|
const nextMetadata = new Map(state.worktreeMetadata);
|
|
nextMetadata.delete(id);
|
|
const nextAvailableWorktrees = options?.archiveWorktree && metadata
|
|
? state.availableWorktrees.filter((entry) => normalizePath(entry.path) !== normalizePath(metadata.path))
|
|
: state.availableWorktrees;
|
|
return {
|
|
sessions: filteredSessions,
|
|
currentSessionId: nextCurrentId,
|
|
isLoading: false,
|
|
worktreeMetadata: nextMetadata,
|
|
availableWorktrees: nextAvailableWorktrees,
|
|
};
|
|
});
|
|
|
|
const directoryToStore = overrideDirectory ?? opencodeClient.getDirectory() ?? null;
|
|
storeSessionForDirectory(directoryToStore, nextCurrentId);
|
|
|
|
return true;
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : "Failed to delete session";
|
|
if (archivedMetadata) {
|
|
set((state) => {
|
|
const nextMetadata = new Map(state.worktreeMetadata);
|
|
nextMetadata.delete(id);
|
|
return {
|
|
worktreeMetadata: nextMetadata,
|
|
error: message,
|
|
isLoading: false,
|
|
};
|
|
});
|
|
} else {
|
|
set({
|
|
error: message,
|
|
isLoading: false,
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
},
|
|
|
|
deleteSessions: async (
|
|
ids: string[],
|
|
options?: { archiveWorktree?: boolean; deleteRemoteBranch?: boolean; remoteName?: string; silent?: boolean }
|
|
) => {
|
|
const uniqueIds = Array.from(new Set(ids.filter((id): id is string => typeof id === "string" && id.length > 0)));
|
|
if (uniqueIds.length === 0) {
|
|
return { deletedIds: [], failedIds: [] };
|
|
}
|
|
|
|
const silent = options?.silent === true;
|
|
if (!silent) {
|
|
set({ isLoading: true, error: null });
|
|
}
|
|
const deletedIds: string[] = [];
|
|
const failedIds: string[] = [];
|
|
const archivedIds = new Set<string>();
|
|
|
|
const removedWorktrees: Array<{ path: string; projectDirectory: string }> = [];
|
|
const archivedWorktreePaths = new Set<string>();
|
|
|
|
for (const id of uniqueIds) {
|
|
try {
|
|
const metadata = get().worktreeMetadata.get(id);
|
|
const sessionDirectory = getSessionDirectory(get().sessions, id);
|
|
const overrideDirectory = metadata?.path ?? sessionDirectory;
|
|
if (metadata && options?.archiveWorktree && !archivedWorktreePaths.has(metadata.path)) {
|
|
await archiveSessionWorktree(metadata, {
|
|
deleteRemoteBranch: options?.deleteRemoteBranch,
|
|
remoteName: options?.remoteName,
|
|
});
|
|
archivedIds.add(id);
|
|
removedWorktrees.push({ path: metadata.path, projectDirectory: metadata.projectDirectory });
|
|
archivedWorktreePaths.add(metadata.path);
|
|
}
|
|
|
|
const deleteRequest = () => opencodeClient.deleteSession(id);
|
|
const success = overrideDirectory
|
|
? await opencodeClient.withDirectory(overrideDirectory, deleteRequest)
|
|
: await deleteRequest();
|
|
if (success) {
|
|
deletedIds.push(id);
|
|
if (metadata?.path && !removedWorktrees.some((entry) => entry.path === metadata.path)) {
|
|
removedWorktrees.push({ path: metadata.path, projectDirectory: metadata.projectDirectory });
|
|
}
|
|
} else {
|
|
failedIds.push(id);
|
|
}
|
|
} catch {
|
|
failedIds.push(id);
|
|
}
|
|
}
|
|
|
|
const directoryStore = useDirectoryStore.getState();
|
|
removedWorktrees.forEach(({ path, projectDirectory }) => {
|
|
if (directoryStore.currentDirectory === path) {
|
|
directoryStore.setDirectory(projectDirectory, { showOverlay: false });
|
|
}
|
|
});
|
|
|
|
const deletedSet = new Set(deletedIds);
|
|
const errorMessage = failedIds.length > 0
|
|
? (failedIds.length === uniqueIds.length ? "Failed to delete sessions" : "Failed to delete some sessions")
|
|
: null;
|
|
let nextCurrentId: string | null = null;
|
|
|
|
set((state) => {
|
|
const filteredSessions = state.sessions.filter((session) => !deletedSet.has(session.id));
|
|
if (state.currentSessionId && deletedSet.has(state.currentSessionId)) {
|
|
nextCurrentId = null;
|
|
} else {
|
|
nextCurrentId = state.currentSessionId;
|
|
}
|
|
|
|
const nextMetadata = new Map(state.worktreeMetadata);
|
|
for (const removedId of deletedSet) {
|
|
nextMetadata.delete(removedId);
|
|
}
|
|
for (const archivedId of archivedIds) {
|
|
nextMetadata.delete(archivedId);
|
|
}
|
|
|
|
const removedPaths = new Set(
|
|
removedWorktrees
|
|
.map((entry) => normalizePath(entry.path))
|
|
.filter((p): p is string => Boolean(p))
|
|
);
|
|
const nextAvailableWorktrees =
|
|
removedPaths.size > 0
|
|
? state.availableWorktrees.filter(
|
|
(entry) => !removedPaths.has(normalizePath(entry.path) ?? entry.path)
|
|
)
|
|
: state.availableWorktrees;
|
|
|
|
return {
|
|
sessions: filteredSessions,
|
|
currentSessionId: nextCurrentId,
|
|
...(silent ? {} : { isLoading: false, error: errorMessage }),
|
|
worktreeMetadata: nextMetadata,
|
|
availableWorktrees: nextAvailableWorktrees,
|
|
};
|
|
});
|
|
|
|
const directory = opencodeClient.getDirectory() ?? null;
|
|
storeSessionForDirectory(directory, nextCurrentId);
|
|
|
|
return { deletedIds, failedIds };
|
|
},
|
|
|
|
updateSessionTitle: async (id: string, title: string) => {
|
|
try {
|
|
const sessionDirectory = getSessionDirectory(get().sessions, id);
|
|
const metadata = get().worktreeMetadata.get(id);
|
|
const updateRequest = () => opencodeClient.updateSession(id, title);
|
|
const overrideDirectory = metadata?.path ?? sessionDirectory;
|
|
const updatedSession = overrideDirectory
|
|
? await opencodeClient.withDirectory(overrideDirectory, updateRequest)
|
|
: await updateRequest();
|
|
set((state) => ({
|
|
sessions: state.sessions.map((s) => (s.id === id ? updatedSession : s)),
|
|
}));
|
|
} catch (error) {
|
|
set({
|
|
error: error instanceof Error ? error.message : "Failed to update session title",
|
|
});
|
|
}
|
|
},
|
|
|
|
shareSession: async (id: string) => {
|
|
try {
|
|
const sessionDirectory = getSessionDirectory(get().sessions, id);
|
|
const apiClient = opencodeClient.getApiClient();
|
|
const metadata = get().worktreeMetadata.get(id);
|
|
const overrideDirectory = metadata?.path ?? sessionDirectory;
|
|
const shareRequest = async () => {
|
|
const directory = sessionDirectory ?? opencodeClient.getDirectory();
|
|
return apiClient.session.share({
|
|
path: { id },
|
|
query: directory ? { directory } : undefined,
|
|
});
|
|
};
|
|
const response = overrideDirectory
|
|
? await opencodeClient.withDirectory(overrideDirectory, shareRequest)
|
|
: await shareRequest();
|
|
|
|
if (response.data) {
|
|
set((state) => ({
|
|
sessions: state.sessions.map((s) => (s.id === id ? response.data : s)),
|
|
}));
|
|
return response.data;
|
|
}
|
|
return null;
|
|
} catch (error) {
|
|
set({
|
|
error: error instanceof Error ? error.message : "Failed to share session",
|
|
});
|
|
return null;
|
|
}
|
|
},
|
|
|
|
unshareSession: async (id: string) => {
|
|
try {
|
|
const sessionDirectory = getSessionDirectory(get().sessions, id);
|
|
const apiClient = opencodeClient.getApiClient();
|
|
const metadata = get().worktreeMetadata.get(id);
|
|
const overrideDirectory = metadata?.path ?? sessionDirectory;
|
|
const unshareRequest = async () => {
|
|
const directory = sessionDirectory ?? opencodeClient.getDirectory();
|
|
return apiClient.session.unshare({
|
|
path: { id },
|
|
query: directory ? { directory } : undefined,
|
|
});
|
|
};
|
|
const response = overrideDirectory
|
|
? await opencodeClient.withDirectory(overrideDirectory, unshareRequest)
|
|
: await unshareRequest();
|
|
|
|
if (response.data) {
|
|
set((state) => ({
|
|
sessions: state.sessions.map((s) => (s.id === id ? response.data : s)),
|
|
}));
|
|
return response.data;
|
|
}
|
|
return null;
|
|
} catch (error) {
|
|
set({
|
|
error: error instanceof Error ? error.message : "Failed to unshare session",
|
|
});
|
|
return null;
|
|
}
|
|
},
|
|
|
|
setCurrentSession: (id: string | null) => {
|
|
set({ currentSessionId: id, error: null });
|
|
const directory = opencodeClient.getDirectory() ?? null;
|
|
storeSessionForDirectory(directory, id);
|
|
},
|
|
|
|
clearError: () => {
|
|
set({ error: null });
|
|
},
|
|
|
|
getSessionsByDirectory: () => {
|
|
const { sessions } = get();
|
|
return sessions;
|
|
},
|
|
|
|
applySessionMetadata: (sessionId, metadata) => {
|
|
if (!sessionId || !metadata) {
|
|
return;
|
|
}
|
|
|
|
set((state) => {
|
|
const index = state.sessions.findIndex((session) => session.id === sessionId);
|
|
if (index === -1) {
|
|
return state;
|
|
}
|
|
|
|
const existingSession = state.sessions[index];
|
|
const mergedTime = metadata.time
|
|
? { ...existingSession.time, ...metadata.time }
|
|
: existingSession.time;
|
|
const mergedSummary =
|
|
metadata.summary === undefined
|
|
? existingSession.summary
|
|
: metadata.summary || undefined;
|
|
const mergedShare =
|
|
metadata.share === undefined
|
|
? existingSession.share
|
|
: metadata.share || undefined;
|
|
|
|
const mergedSession: Session = {
|
|
...existingSession,
|
|
...metadata,
|
|
time: mergedTime,
|
|
summary: mergedSummary,
|
|
share: mergedShare,
|
|
};
|
|
|
|
const hasChanged =
|
|
mergedSession.title !== existingSession.title ||
|
|
mergedSession.parentID !== existingSession.parentID ||
|
|
mergedSession.directory !== existingSession.directory ||
|
|
mergedSession.version !== existingSession.version ||
|
|
mergedSession.projectID !== existingSession.projectID ||
|
|
JSON.stringify(mergedSession.time) !== JSON.stringify(existingSession.time) ||
|
|
JSON.stringify(mergedSession.summary ?? null) !== JSON.stringify(existingSession.summary ?? null) ||
|
|
JSON.stringify(mergedSession.share ?? null) !== JSON.stringify(existingSession.share ?? null);
|
|
|
|
const sessions = [...state.sessions];
|
|
sessions[index] = hasChanged ? mergedSession : existingSession;
|
|
|
|
return hasChanged ? ({ sessions } as Partial<SessionStore>) : state;
|
|
});
|
|
},
|
|
|
|
isOpenChamberCreatedSession: (sessionId: string) => {
|
|
const { webUICreatedSessions } = get();
|
|
return webUICreatedSessions.has(sessionId);
|
|
},
|
|
|
|
markSessionAsOpenChamberCreated: (sessionId: string) => {
|
|
set((state) => {
|
|
const newOpenChamberCreatedSessions = new Set(state.webUICreatedSessions);
|
|
newOpenChamberCreatedSessions.add(sessionId);
|
|
return {
|
|
webUICreatedSessions: newOpenChamberCreatedSessions,
|
|
};
|
|
});
|
|
},
|
|
|
|
initializeNewOpenChamberSession: (sessionId: string) => {
|
|
const { markSessionAsOpenChamberCreated } = get();
|
|
|
|
markSessionAsOpenChamberCreated(sessionId);
|
|
|
|
},
|
|
|
|
setWorktreeMetadata: (sessionId: string, metadata: WorktreeMetadata | null) => {
|
|
if (!sessionId) {
|
|
return;
|
|
}
|
|
set((state) => {
|
|
const next = new Map(state.worktreeMetadata);
|
|
if (metadata) {
|
|
next.set(sessionId, metadata);
|
|
} else {
|
|
next.delete(sessionId);
|
|
}
|
|
return { worktreeMetadata: next };
|
|
});
|
|
},
|
|
|
|
getWorktreeMetadata: (sessionId: string) => {
|
|
if (!sessionId) {
|
|
return undefined;
|
|
}
|
|
return get().worktreeMetadata.get(sessionId);
|
|
},
|
|
|
|
setSessionDirectory: (sessionId: string, directory: string | null) => {
|
|
if (!sessionId) {
|
|
return;
|
|
}
|
|
|
|
const currentSessions = get().sessions;
|
|
const targetIndex = currentSessions.findIndex((session) => session.id === sessionId);
|
|
if (targetIndex === -1) {
|
|
return;
|
|
}
|
|
|
|
const existingSession = currentSessions[targetIndex];
|
|
const previousDirectory = existingSession.directory ?? null;
|
|
const normalizedDirectory = directory ?? undefined;
|
|
|
|
if (previousDirectory === (normalizedDirectory ?? null)) {
|
|
return;
|
|
}
|
|
|
|
set((state) => {
|
|
const sessions = [...state.sessions];
|
|
const updatedSession = { ...sessions[targetIndex] } as Record<string, unknown>;
|
|
if (normalizedDirectory !== undefined) {
|
|
updatedSession.directory = normalizedDirectory;
|
|
} else {
|
|
delete updatedSession.directory;
|
|
}
|
|
sessions[targetIndex] = updatedSession as Session;
|
|
return { sessions };
|
|
});
|
|
|
|
if (previousDirectory) {
|
|
storeSessionForDirectory(previousDirectory, null);
|
|
}
|
|
if (directory) {
|
|
storeSessionForDirectory(directory, sessionId);
|
|
}
|
|
|
|
},
|
|
|
|
updateSession: (session: Session) => {
|
|
set((state) => ({
|
|
sessions: state.sessions.map((s) => (s.id === session.id ? session : s)),
|
|
}));
|
|
},
|
|
}),
|
|
{
|
|
name: "session-store",
|
|
storage: createJSONStorage(() => getSafeStorage()),
|
|
partialize: (state) => ({
|
|
currentSessionId: state.currentSessionId,
|
|
sessions: state.sessions,
|
|
lastLoadedDirectory: state.lastLoadedDirectory,
|
|
webUICreatedSessions: Array.from(state.webUICreatedSessions),
|
|
worktreeMetadata: Array.from(state.worktreeMetadata.entries()),
|
|
availableWorktrees: state.availableWorktrees,
|
|
}),
|
|
merge: (persistedState, currentState) => {
|
|
const isRecord = (value: unknown): value is Record<string, unknown> =>
|
|
typeof value === "object" && value !== null;
|
|
|
|
if (!isRecord(persistedState)) {
|
|
return currentState;
|
|
}
|
|
|
|
const persistedSessions = Array.isArray(persistedState.sessions)
|
|
? (persistedState.sessions as Session[])
|
|
: currentState.sessions;
|
|
|
|
const persistedCurrentSessionId =
|
|
typeof persistedState.currentSessionId === "string" || persistedState.currentSessionId === null
|
|
? (persistedState.currentSessionId as string | null)
|
|
: currentState.currentSessionId;
|
|
|
|
const webUiSessionsArray = Array.isArray(persistedState.webUICreatedSessions)
|
|
? (persistedState.webUICreatedSessions as string[])
|
|
: [];
|
|
|
|
const persistedWorktreeEntries = Array.isArray(persistedState.worktreeMetadata)
|
|
? (persistedState.worktreeMetadata as Array<[string, WorktreeMetadata]>)
|
|
: [];
|
|
|
|
const persistedAvailableWorktrees = Array.isArray(persistedState.availableWorktrees)
|
|
? (persistedState.availableWorktrees as WorktreeMetadata[])
|
|
: currentState.availableWorktrees;
|
|
|
|
const lastLoadedDirectory =
|
|
typeof persistedState.lastLoadedDirectory === "string"
|
|
? persistedState.lastLoadedDirectory
|
|
: currentState.lastLoadedDirectory ?? null;
|
|
|
|
return {
|
|
...currentState,
|
|
...persistedState,
|
|
sessions: persistedSessions,
|
|
currentSessionId: persistedCurrentSessionId,
|
|
webUICreatedSessions: new Set(webUiSessionsArray),
|
|
worktreeMetadata: new Map(persistedWorktreeEntries),
|
|
availableWorktrees: persistedAvailableWorktrees,
|
|
lastLoadedDirectory,
|
|
};
|
|
},
|
|
}
|
|
),
|
|
{
|
|
name: "session-store",
|
|
}
|
|
)
|
|
);
|