532 lines
17 KiB
TypeScript
532 lines
17 KiB
TypeScript
import { create } from 'zustand';
|
|
import { devtools } from 'zustand/middleware';
|
|
import { opencodeClient } from '@/lib/opencode/client';
|
|
import type { DirectorySwitchResult } from '@/lib/opencode/client';
|
|
import { getDesktopHomeDirectory } from '@/lib/desktop';
|
|
import { updateDesktopSettings } from '@/lib/persistence';
|
|
import { startConfigUpdate, finishConfigUpdate, updateConfigUpdateMessage } from '@/lib/configUpdate';
|
|
import { useSessionStore } from '@/stores/useSessionStore';
|
|
import { refreshAfterOpenCodeRestart } from '@/stores/useAgentsStore';
|
|
import { useCommandsStore } from '@/stores/useCommandsStore';
|
|
import { useFileSearchStore } from '@/stores/useFileSearchStore';
|
|
import { emitConfigChange } from '@/lib/configSync';
|
|
import { streamDebugEnabled } from '@/stores/utils/streamDebug';
|
|
import { getSafeStorage } from './utils/safeStorage';
|
|
|
|
interface DirectoryStore {
|
|
|
|
currentDirectory: string;
|
|
directoryHistory: string[];
|
|
historyIndex: number;
|
|
homeDirectory: string;
|
|
hasPersistedDirectory: boolean;
|
|
isHomeReady: boolean;
|
|
isSwitchingDirectory: boolean;
|
|
|
|
setDirectory: (path: string, options?: { showOverlay?: boolean }) => void;
|
|
goBack: () => void;
|
|
goForward: () => void;
|
|
goToParent: () => void;
|
|
goHome: () => Promise<void>;
|
|
synchronizeHomeDirectory: (path: string) => void;
|
|
}
|
|
|
|
let cachedHomeDirectory: string | null = null;
|
|
const safeStorage = getSafeStorage();
|
|
const persistedLastDirectory = safeStorage.getItem('lastDirectory');
|
|
const initialHasPersistedDirectory =
|
|
typeof persistedLastDirectory === 'string' && persistedLastDirectory.length > 0;
|
|
|
|
const notifyOpenCodeWorkingDirectory = (path: string, options?: { showOverlay?: boolean }) => {
|
|
const showOverlay = options?.showOverlay ?? true;
|
|
if (showOverlay) {
|
|
startConfigUpdate('Switching project directory…');
|
|
}
|
|
|
|
return opencodeClient.setOpenCodeWorkingDirectory(path).catch((error) => {
|
|
console.warn('Failed to synchronize OpenCode working directory:', error);
|
|
throw error;
|
|
});
|
|
};
|
|
|
|
const scheduleDirectoryFollowUp = (
|
|
restartPromise: Promise<DirectorySwitchResult | null>,
|
|
options: { showOverlay: boolean },
|
|
onComplete?: (result: DirectorySwitchResult | null) => void
|
|
) => {
|
|
const { showOverlay } = options;
|
|
|
|
const reloadSessions = () => {
|
|
try {
|
|
useSessionStore.getState().loadSessions();
|
|
} catch (err) {
|
|
console.error('Failed to reload sessions after directory change:', err);
|
|
}
|
|
};
|
|
|
|
void (async () => {
|
|
let result: DirectorySwitchResult | null = null;
|
|
|
|
try {
|
|
result = await restartPromise;
|
|
} catch (error) {
|
|
console.error('Failed to update OpenCode working directory:', error);
|
|
if (showOverlay) {
|
|
updateConfigUpdateMessage('Failed to switch directory. Please try again.');
|
|
await new Promise((resolve) => setTimeout(resolve, 1500));
|
|
finishConfigUpdate();
|
|
}
|
|
onComplete?.(result);
|
|
reloadSessions();
|
|
return;
|
|
}
|
|
|
|
try {
|
|
if (result && result.restarted) {
|
|
try {
|
|
if (typeof window !== 'undefined' && window.localStorage) {
|
|
window.localStorage.removeItem('commands-store');
|
|
}
|
|
} catch (storageError) {
|
|
console.warn('Failed to reset commands-store cache:', storageError);
|
|
}
|
|
|
|
await refreshAfterOpenCodeRestart({ message: 'Refreshing OpenCode configuration…' });
|
|
|
|
try {
|
|
await useCommandsStore.getState().loadCommands();
|
|
|
|
try {
|
|
emitConfigChange('commands', { source: 'useCommandsStore' });
|
|
} catch (syncError) {
|
|
console.warn('Failed to emit command configuration change:', syncError);
|
|
}
|
|
} catch (commandError) {
|
|
console.warn('Failed to reload commands after directory change:', commandError);
|
|
}
|
|
} else if (showOverlay) {
|
|
finishConfigUpdate();
|
|
}
|
|
} catch (error) {
|
|
console.error('Failed to refresh configuration after directory change:', error);
|
|
if (showOverlay) {
|
|
updateConfigUpdateMessage('Failed to refresh configuration. Please reload manually.');
|
|
await new Promise((resolve) => setTimeout(resolve, 1500));
|
|
finishConfigUpdate();
|
|
}
|
|
} finally {
|
|
onComplete?.(result);
|
|
reloadSessions();
|
|
}
|
|
})();
|
|
};
|
|
|
|
const invalidateFileSearchCache = (scope?: string | null) => {
|
|
try {
|
|
useFileSearchStore.getState().invalidateDirectory(scope);
|
|
} catch (error) {
|
|
console.warn('Failed to invalidate file search cache:', error);
|
|
}
|
|
};
|
|
|
|
const normalizeDirectoryPath = (value: string): string => {
|
|
const trimmed = value.trim();
|
|
if (!trimmed) {
|
|
return trimmed;
|
|
}
|
|
const normalized = trimmed.replace(/\\/g, '/');
|
|
if (normalized.length > 1) {
|
|
return normalized.replace(/\/+$/, '');
|
|
}
|
|
return normalized;
|
|
};
|
|
|
|
const resolveTildePath = (path: string, homeDir?: string | null): string => {
|
|
const trimmed = path.trim();
|
|
if (!trimmed.startsWith('~')) {
|
|
return trimmed;
|
|
}
|
|
if (trimmed === '~') {
|
|
return homeDir || trimmed;
|
|
}
|
|
if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
|
|
return homeDir ? `${homeDir}${trimmed.slice(1)}` : trimmed;
|
|
}
|
|
return trimmed;
|
|
};
|
|
|
|
const resolveDirectoryPath = (path: string, homeDir?: string | null): string => {
|
|
const expanded = resolveTildePath(path, homeDir);
|
|
return normalizeDirectoryPath(expanded);
|
|
};
|
|
|
|
const getHomeDirectory = () => {
|
|
|
|
if (typeof window !== 'undefined') {
|
|
const storedHome = safeStorage.getItem('homeDirectory') || cachedHomeDirectory || null;
|
|
const saved = safeStorage.getItem('lastDirectory');
|
|
if (saved) {
|
|
return resolveDirectoryPath(saved, storedHome);
|
|
}
|
|
|
|
if (cachedHomeDirectory) return cachedHomeDirectory;
|
|
|
|
const desktopHome =
|
|
(typeof window.__OPENCHAMBER_HOME__ === 'string' && window.__OPENCHAMBER_HOME__.length > 0
|
|
? window.__OPENCHAMBER_HOME__
|
|
: window.opencodeDesktop && typeof window.opencodeDesktop.homeDirectory === 'string'
|
|
? window.opencodeDesktop.homeDirectory
|
|
: null);
|
|
|
|
if (desktopHome && desktopHome.length > 0) {
|
|
cachedHomeDirectory = desktopHome;
|
|
safeStorage.setItem('homeDirectory', desktopHome);
|
|
return desktopHome;
|
|
}
|
|
|
|
if (storedHome) {
|
|
cachedHomeDirectory = storedHome;
|
|
return storedHome;
|
|
}
|
|
}
|
|
|
|
const nodeHome = typeof process !== 'undefined' && process?.env?.HOME;
|
|
if (nodeHome) {
|
|
return nodeHome;
|
|
}
|
|
return process?.cwd?.() || '/';
|
|
};
|
|
|
|
|
|
const normalizeHomeCandidate = (value?: string | null) => {
|
|
if (typeof value !== 'string') {
|
|
return null;
|
|
}
|
|
const trimmed = value.trim();
|
|
if (!trimmed) {
|
|
return null;
|
|
}
|
|
const normalized = trimmed.replace(/\\/g, '/');
|
|
if (normalized.length > 1) {
|
|
const withoutTrailingSlash = normalized.replace(/\/+$/, '');
|
|
if (withoutTrailingSlash && withoutTrailingSlash.length > 0) {
|
|
if (withoutTrailingSlash === '/') {
|
|
return null;
|
|
}
|
|
return withoutTrailingSlash;
|
|
}
|
|
}
|
|
if (normalized === '/' || normalized.length === 0) {
|
|
return null;
|
|
}
|
|
return normalized;
|
|
};
|
|
|
|
const persistResolvedHome = (resolved: string) => {
|
|
cachedHomeDirectory = resolved;
|
|
if (typeof window !== 'undefined') {
|
|
safeStorage.setItem('homeDirectory', resolved);
|
|
}
|
|
void updateDesktopSettings({ homeDirectory: resolved });
|
|
return resolved;
|
|
};
|
|
|
|
const initializeHomeDirectory = async () => {
|
|
const acceptCandidate = (candidate?: string | null) => {
|
|
const normalized = normalizeHomeCandidate(candidate);
|
|
return normalized ? persistResolvedHome(normalized) : null;
|
|
};
|
|
|
|
try {
|
|
const fsHome = await opencodeClient.getFilesystemHome();
|
|
const resolved = acceptCandidate(fsHome);
|
|
if (resolved) {
|
|
return resolved;
|
|
}
|
|
} catch (filesystemError) {
|
|
console.warn('Failed to obtain filesystem home directory:', filesystemError);
|
|
}
|
|
|
|
try {
|
|
const info = await opencodeClient.getSystemInfo();
|
|
const resolved = acceptCandidate(info?.homeDirectory);
|
|
if (resolved) {
|
|
return resolved;
|
|
}
|
|
} catch (error) {
|
|
console.warn('Failed to get home directory from system info:', error);
|
|
}
|
|
|
|
try {
|
|
const desktopHome = await getDesktopHomeDirectory();
|
|
const resolved = acceptCandidate(desktopHome);
|
|
if (resolved) {
|
|
return resolved;
|
|
}
|
|
} catch (desktopError) {
|
|
console.warn('Failed to obtain desktop-integrated home directory:', desktopError);
|
|
}
|
|
|
|
const fallback = getHomeDirectory();
|
|
const resolvedFallback = acceptCandidate(fallback);
|
|
if (resolvedFallback) {
|
|
return resolvedFallback;
|
|
}
|
|
|
|
return fallback;
|
|
};
|
|
|
|
const initialHomeDirectory = getHomeDirectory();
|
|
if (initialHomeDirectory) {
|
|
opencodeClient.setDirectory(initialHomeDirectory);
|
|
}
|
|
const initialIsHomeReady = Boolean(initialHomeDirectory && initialHomeDirectory !== '/');
|
|
|
|
export const useDirectoryStore = create<DirectoryStore>()(
|
|
devtools(
|
|
(set, get) => ({
|
|
|
|
currentDirectory: initialHomeDirectory,
|
|
directoryHistory: [initialHomeDirectory],
|
|
historyIndex: 0,
|
|
homeDirectory: initialHomeDirectory,
|
|
hasPersistedDirectory: initialHasPersistedDirectory,
|
|
isHomeReady: initialIsHomeReady,
|
|
isSwitchingDirectory: false,
|
|
|
|
setDirectory: (path: string, options?: { showOverlay?: boolean }) => {
|
|
const homeDir = cachedHomeDirectory || get().homeDirectory || safeStorage.getItem('homeDirectory');
|
|
const resolvedPath = resolveDirectoryPath(path, homeDir);
|
|
if (streamDebugEnabled()) {
|
|
console.log('[DirectoryStore] setDirectory called with path:', resolvedPath);
|
|
}
|
|
const showOverlay = options?.showOverlay ?? true;
|
|
|
|
opencodeClient.setDirectory(resolvedPath);
|
|
invalidateFileSearchCache();
|
|
const restartPromise = notifyOpenCodeWorkingDirectory(resolvedPath, { showOverlay });
|
|
if (streamDebugEnabled()) {
|
|
console.log('[DirectoryStore] notifyOpenCodeWorkingDirectory initiated');
|
|
}
|
|
|
|
set((state) => {
|
|
|
|
const newHistory = [...state.directoryHistory.slice(0, state.historyIndex + 1), resolvedPath];
|
|
|
|
safeStorage.setItem('lastDirectory', resolvedPath);
|
|
|
|
void updateDesktopSettings({ lastDirectory: resolvedPath });
|
|
|
|
return {
|
|
currentDirectory: resolvedPath,
|
|
directoryHistory: newHistory,
|
|
historyIndex: newHistory.length - 1,
|
|
hasPersistedDirectory: true,
|
|
isHomeReady: true,
|
|
isSwitchingDirectory: true,
|
|
};
|
|
});
|
|
|
|
scheduleDirectoryFollowUp(restartPromise, { showOverlay }, () => {
|
|
set((state) => {
|
|
if (state.currentDirectory !== resolvedPath) {
|
|
return {};
|
|
}
|
|
if (!state.isSwitchingDirectory) {
|
|
return {};
|
|
}
|
|
return { isSwitchingDirectory: false };
|
|
});
|
|
});
|
|
},
|
|
|
|
goBack: () => {
|
|
const state = get();
|
|
if (state.historyIndex > 0) {
|
|
const newIndex = state.historyIndex - 1;
|
|
const newDirectory = state.directoryHistory[newIndex];
|
|
|
|
opencodeClient.setDirectory(newDirectory);
|
|
invalidateFileSearchCache();
|
|
const restartPromise = notifyOpenCodeWorkingDirectory(newDirectory);
|
|
|
|
safeStorage.setItem('lastDirectory', newDirectory);
|
|
|
|
void updateDesktopSettings({ lastDirectory: newDirectory });
|
|
|
|
set({
|
|
currentDirectory: newDirectory,
|
|
historyIndex: newIndex,
|
|
hasPersistedDirectory: true,
|
|
isHomeReady: true,
|
|
isSwitchingDirectory: true,
|
|
});
|
|
|
|
scheduleDirectoryFollowUp(restartPromise, { showOverlay: true }, () => {
|
|
set((state) => {
|
|
if (state.currentDirectory !== newDirectory) {
|
|
return {};
|
|
}
|
|
if (!state.isSwitchingDirectory) {
|
|
return {};
|
|
}
|
|
return { isSwitchingDirectory: false };
|
|
});
|
|
});
|
|
}
|
|
},
|
|
|
|
goForward: () => {
|
|
const state = get();
|
|
if (state.historyIndex < state.directoryHistory.length - 1) {
|
|
const newIndex = state.historyIndex + 1;
|
|
const newDirectory = state.directoryHistory[newIndex];
|
|
|
|
opencodeClient.setDirectory(newDirectory);
|
|
invalidateFileSearchCache();
|
|
const restartPromise = notifyOpenCodeWorkingDirectory(newDirectory);
|
|
|
|
safeStorage.setItem('lastDirectory', newDirectory);
|
|
|
|
void updateDesktopSettings({ lastDirectory: newDirectory });
|
|
|
|
set({
|
|
currentDirectory: newDirectory,
|
|
historyIndex: newIndex,
|
|
hasPersistedDirectory: true,
|
|
isHomeReady: true,
|
|
isSwitchingDirectory: true,
|
|
});
|
|
|
|
scheduleDirectoryFollowUp(restartPromise, { showOverlay: true }, () => {
|
|
set((state) => {
|
|
if (state.currentDirectory !== newDirectory) {
|
|
return {};
|
|
}
|
|
if (!state.isSwitchingDirectory) {
|
|
return {};
|
|
}
|
|
return { isSwitchingDirectory: false };
|
|
});
|
|
});
|
|
}
|
|
},
|
|
|
|
goToParent: () => {
|
|
const { currentDirectory, setDirectory } = get();
|
|
const homeDir = cachedHomeDirectory || get().homeDirectory || getHomeDirectory();
|
|
|
|
if (currentDirectory === homeDir || currentDirectory === '/') {
|
|
return;
|
|
}
|
|
|
|
const cleanPath = currentDirectory.endsWith('/')
|
|
? currentDirectory.slice(0, -1)
|
|
: currentDirectory;
|
|
|
|
const lastSlash = cleanPath.lastIndexOf('/');
|
|
if (lastSlash === -1) {
|
|
const home = cachedHomeDirectory || getHomeDirectory();
|
|
setDirectory(home);
|
|
} else if (lastSlash === 0) {
|
|
setDirectory('/');
|
|
} else {
|
|
setDirectory(cleanPath.substring(0, lastSlash));
|
|
}
|
|
},
|
|
|
|
goHome: async () => {
|
|
const homeDir =
|
|
cachedHomeDirectory ||
|
|
get().homeDirectory ||
|
|
(await initializeHomeDirectory());
|
|
get().setDirectory(homeDir);
|
|
},
|
|
|
|
synchronizeHomeDirectory: (homePath: string) => {
|
|
const state = get();
|
|
const resolvedHome = homePath;
|
|
cachedHomeDirectory = resolvedHome;
|
|
const needsUpdate = state.homeDirectory !== resolvedHome;
|
|
const savedLastDirectory = safeStorage.getItem('lastDirectory');
|
|
const hasSavedLastDirectory = typeof savedLastDirectory === 'string' && savedLastDirectory.length > 0;
|
|
const shouldReplaceCurrent =
|
|
!hasSavedLastDirectory &&
|
|
(
|
|
state.currentDirectory === '/' ||
|
|
state.currentDirectory === state.homeDirectory ||
|
|
!state.currentDirectory
|
|
);
|
|
|
|
if (!needsUpdate && !shouldReplaceCurrent) {
|
|
if (!state.isHomeReady) {
|
|
set({ isHomeReady: true });
|
|
}
|
|
return;
|
|
}
|
|
|
|
const resolvedReady = typeof resolvedHome === 'string' && resolvedHome !== '' && resolvedHome !== '/';
|
|
|
|
const resolvedCurrent = state.currentDirectory
|
|
? resolveDirectoryPath(state.currentDirectory, resolvedHome)
|
|
: state.currentDirectory;
|
|
const resolvedHistory = state.directoryHistory.map((entry) => resolveDirectoryPath(entry, resolvedHome));
|
|
const historyChanged = resolvedHistory.some((entry, index) => entry !== state.directoryHistory[index]);
|
|
const currentChanged = Boolean(resolvedCurrent && resolvedCurrent !== state.currentDirectory);
|
|
|
|
const updates: Partial<DirectoryStore> = {
|
|
homeDirectory: resolvedHome,
|
|
hasPersistedDirectory: hasSavedLastDirectory,
|
|
isHomeReady: resolvedReady
|
|
};
|
|
|
|
if (shouldReplaceCurrent) {
|
|
updates.currentDirectory = resolvedHome;
|
|
updates.directoryHistory = [resolvedHome];
|
|
updates.historyIndex = 0;
|
|
updates.isSwitchingDirectory = true;
|
|
} else if (currentChanged || historyChanged) {
|
|
updates.currentDirectory = resolvedCurrent as string;
|
|
updates.directoryHistory = resolvedHistory;
|
|
updates.historyIndex = Math.min(state.historyIndex, resolvedHistory.length - 1);
|
|
updates.isSwitchingDirectory = true;
|
|
}
|
|
|
|
set(() => updates as Partial<DirectoryStore>);
|
|
|
|
if ((shouldReplaceCurrent || currentChanged) && resolvedReady) {
|
|
const nextDirectory = shouldReplaceCurrent ? resolvedHome : (resolvedCurrent as string);
|
|
opencodeClient.setDirectory(nextDirectory);
|
|
invalidateFileSearchCache();
|
|
safeStorage.setItem('lastDirectory', nextDirectory);
|
|
void updateDesktopSettings({ lastDirectory: nextDirectory });
|
|
|
|
const restartPromise = notifyOpenCodeWorkingDirectory(nextDirectory, { showOverlay: false });
|
|
scheduleDirectoryFollowUp(restartPromise, { showOverlay: false }, () => {
|
|
set((state) => {
|
|
if (state.currentDirectory !== nextDirectory) {
|
|
return {};
|
|
}
|
|
if (!state.isSwitchingDirectory) {
|
|
return {};
|
|
}
|
|
return { isSwitchingDirectory: false };
|
|
});
|
|
});
|
|
}
|
|
|
|
void updateDesktopSettings({ homeDirectory: resolvedHome });
|
|
}
|
|
}),
|
|
{
|
|
name: 'directory-store'
|
|
}
|
|
)
|
|
);
|
|
|
|
if (typeof window !== 'undefined') {
|
|
initializeHomeDirectory().then((home) => {
|
|
useDirectoryStore.getState().synchronizeHomeDirectory(home);
|
|
});
|
|
}
|