Codex/storage optimization

.github/workflows/build.yml

@@ -44,7 +44,7 @@ jobs:
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           npx vite build
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          npx electron-builder --win dir nsis --x64 --publish never
+          npx electron-builder --win dir nsis portable --x64 --publish never
 
       - name: Smoke test packaged Windows paths
         run: npm run smoke:packaged-binaries

.github/workflows/release.yml

@@ -449,7 +449,7 @@ jobs:
           npm run build:platform-native-helpers
           npx tsc
           npx vite build
-          npx electron-builder --win dir nsis --x64 --publish never
+          npx electron-builder --win dir nsis portable --x64 --publish never
 
       - name: Smoke test packaged Windows x64 paths
         run: npm run smoke:packaged-binaries

.github/workflows/winget-releaser.yml

@@ -20,7 +20,7 @@ jobs:
       - uses: vedantmgoyal9/winget-releaser@v2
         with:
           identifier: Webadderall.Recordly
-          installers-regex: 'windows\-x64\.exe$'
+          installers-regex: 'windows\-setup\-x64\.exe$'
           version: ${{ steps.tag.outputs.tag }}
           release-tag: ${{ steps.tag.outputs.tag }}
           token: ${{ secrets.WINGET_ACC_TOKEN }}

electron-builder.json5

@@ -103,12 +103,18 @@
   },
   "win": {
     "target": [
-      "nsis"
+      "nsis",
+      "portable"
     ],
-    "icon": "icons/icons/win/icon.ico"
-    ,
-    "executableName": "Recordly",
-    "artifactName": "${productName}-windows-${arch}.${ext}"
+    "icon": "icons/icons/win/icon.ico",
+    "executableName": "Recordly"
+  },
+  "nsis": {
+    "oneClick": false,
+    "allowToChangeInstallationDirectory": true,
+    "artifactName": "${productName}-windows-setup-${arch}.${ext}"
+  },
+  "portable": {
+    "artifactName": "${productName}-windows-portable-${arch}.${ext}"
   }
 }
-

electron/appPaths.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { app } from "electron";
+import { getActiveWorkspaceLayout, initializeWorkspaceStorage } from "./storageSettings";
 
 if (process.env["VITE_DEV_SERVER_URL"]) {
 	const devUserDataPath = path.join(app.getPath("appData"), "Recordly-dev");
@@ -8,4 +9,9 @@ if (process.env["VITE_DEV_SERVER_URL"]) {
 }
 
 export const USER_DATA_PATH = app.getPath("userData");
+export const INITIAL_WORKSPACE_LAYOUT = initializeWorkspaceStorage(app, USER_DATA_PATH);
 export const RECORDINGS_DIR = path.join(USER_DATA_PATH, "recordings");
+
+export function getConfiguredWorkspaceLayout() {
+	return getActiveWorkspaceLayout();
+}

electron/electron-env.d.ts

@@ -858,6 +858,44 @@ interface Window {
 			message?: string;
 			error?: string;
 		}>;
+		getStorageStatus: () => Promise<{
+			success: boolean;
+			workspaceRoot?: string | null;
+			recordingsDir?: string;
+			projectsDir?: string;
+			tempDir?: string;
+			cacheDir?: string;
+			configuredTempDir?: string;
+			configuredCacheDir?: string;
+			restartRequired?: boolean;
+			initializationError?: string | null;
+			usage?: {
+				recordingsBytes: number;
+				projectsBytes: number;
+				tempBytes: number;
+				cacheBytes: number;
+				totalBytes: number;
+			} | null;
+			error?: string;
+		}>;
+		chooseWorkspaceDirectory: () => Promise<{
+			success: boolean;
+			canceled?: boolean;
+			workspaceRoot?: string;
+			recordingsDir?: string;
+			projectsDir?: string;
+			tempDir?: string;
+			cacheDir?: string;
+			restartRequired?: boolean;
+			error?: string;
+		}>;
+		openWorkspaceDirectory: () => Promise<{ success: boolean; error?: string }>;
+		cleanupRecordlyTemporaryFiles: () => Promise<{
+			success: boolean;
+			removedCount?: number;
+			removedBytes?: number;
+			error?: string;
+		}>;
 		getShortcuts: () => Promise<Record<string, unknown> | null>;
 		saveShortcuts: (shortcuts: unknown) => Promise<{ success: boolean; error?: string }>;
 		getAppSetting: (key: string) => unknown;

electron/ipc/project/manager.ts

@@ -9,7 +9,6 @@ import {
 	MAX_RECENT_PROJECTS,
 	PROJECT_FILE_EXTENSION,
 	PROJECT_THUMBNAIL_SUFFIX,
-	PROJECTS_DIRECTORY_NAME,
 	RECENT_PROJECTS_FILE,
 	RECORDINGS_SETTINGS_FILE,
 } from "../constants";
@@ -24,7 +23,7 @@ import {
 } from "../state";
 import type { ProjectLibraryEntry, RecordingSessionData } from "../types";
 import {
-	getRecordingsDir,
+	getProjectsStorageDir,
 	normalizePath,
 	normalizeVideoSourcePath,
 	parseJsonWithByteOrderMark,
@@ -239,9 +238,7 @@ export async function resolveProjectMediaSources(
 }
 
 export async function getProjectsDir() {
-	const projectsDir = path.join(await getRecordingsDir(), PROJECTS_DIRECTORY_NAME);
-	await fs.mkdir(projectsDir, { recursive: true });
-	return projectsDir;
+	return getProjectsStorageDir();
 }
 
 export async function persistRecordingsDirectorySetting(nextDir: string) {

electron/ipc/recording/prune.ts

@@ -6,11 +6,11 @@ import {
 	COMPANION_AUDIO_LAYOUTS,
 	LEGACY_PROJECT_FILE_EXTENSIONS,
 	PROJECT_FILE_EXTENSION,
-	PROJECTS_DIRECTORY_NAME,
 } from "../constants";
 import { currentVideoPath } from "../state";
 import {
 	getRecordingsDir,
+	getProjectsStorageDir,
 	getTelemetryPathForVideo,
 	isAutoRecordingPath,
 	normalizePath,
@@ -39,8 +39,7 @@ export async function hasSiblingProjectFile(videoPath: string) {
 export { isAutoRecordingPath };
 
 async function loadSavedProjectMediaPaths() {
-	const recordingsDir = await getRecordingsDir();
-	const projectsDir = path.join(recordingsDir, PROJECTS_DIRECTORY_NAME);
+	const projectsDir = await getProjectsStorageDir();
 	const protectedPaths = new Set<string>();
 	const candidateExtensions = new Set([
 		PROJECT_FILE_EXTENSION,

electron/ipc/recording/windows.test.ts

@@ -1,8 +1,15 @@
 import { EventEmitter } from "node:events";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { PassThrough } from "node:stream";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { setWindowsCaptureOutputBuffer, setWindowsCaptureTargetPath } from "../state";
-import { waitForWindowsCaptureStop } from "./windows";
+import {
+	describeWindowsCaptureStartFailure,
+	prepareWindowsCaptureTempDirectory,
+	waitForWindowsCaptureStop,
+} from "./windows";
 
 vi.mock("electron", () => ({
 	app: {
@@ -25,6 +32,48 @@ class FakeCaptureProcess extends EventEmitter {
 	});
 }
 
+const temporaryRoots: string[] = [];
+
+afterEach(async () => {
+	await Promise.all(
+		temporaryRoots.splice(0).map((root) => fs.rm(root, { recursive: true, force: true })),
+	);
+});
+
+describe("Windows capture temporary storage", () => {
+	it("accepts a writable Unicode temporary directory and removes its probe file", async () => {
+		const root = await fs.mkdtemp(path.join(os.tmpdir(), "recordly-windows-temp-"));
+		temporaryRoots.push(root);
+		const unicodeDirectory = path.join(root, "录屏 临时目录");
+
+		const status = await prepareWindowsCaptureTempDirectory(unicodeDirectory, 0);
+
+		expect(status.directory).toBe(path.resolve(unicodeDirectory));
+		expect(await fs.readdir(unicodeDirectory)).toEqual([]);
+	});
+
+	it("rejects a temporary directory that does not have the required free space", async () => {
+		const root = await fs.mkdtemp(path.join(os.tmpdir(), "recordly-windows-space-"));
+		temporaryRoots.push(root);
+
+		await expect(
+			prepareWindowsCaptureTempDirectory(root, Number.MAX_SAFE_INTEGER),
+		).rejects.toThrow("Recordly needs at least");
+	});
+
+	it("prefers the native helper error and includes an actionable temporary path", () => {
+		const detail = describeWindowsCaptureStartFailure(
+			new Error("Native helper exited"),
+			"INFO: Initializing\nERROR: Failed to initialize Media Foundation encoder\n",
+			"D:\\RecordlyTemp",
+		);
+
+		expect(detail).toContain("ERROR: Failed to initialize Media Foundation encoder");
+		expect(detail).toContain("D:\\RecordlyTemp");
+		expect(detail).toContain("choose another Recordly storage location");
+	});
+});
+
 describe("waitForWindowsCaptureStop", () => {
 	beforeEach(() => {
 		setWindowsCaptureOutputBuffer("");

electron/ipc/recording/windows.ts

@@ -1,6 +1,8 @@
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
+import path from "node:path";
 import { BrowserWindow } from "electron";
 import { getWindowsCaptureExePath } from "../paths/binaries";
 import {
@@ -13,13 +15,91 @@ import {
 	windowsCaptureTargetPath,
 	windowsNativeCaptureActive,
 } from "../state";
-import {
-	AudioSyncAdjustment,
-} from "../types";
+import { AudioSyncAdjustment } from "../types";
 import { moveFileWithOverwrite } from "../utils";
 import { emitRecordingInterrupted } from "./events";
 
 const WINDOWS_CAPTURE_STOP_TIMEOUT_MS = 45_000;
+export const MIN_WINDOWS_CAPTURE_TEMP_FREE_BYTES = 512 * 1024 * 1024;
+
+export type WindowsCaptureTempStatus = {
+	directory: string;
+	freeBytes: number | null;
+};
+
+function formatStorageSize(bytes: number) {
+	if (!Number.isFinite(bytes) || bytes < 0) {
+		return "an unknown amount of space";
+	}
+
+	if (bytes >= 1024 * 1024 * 1024) {
+		return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+	}
+
+	return `${Math.max(0, Math.round(bytes / (1024 * 1024)))} MB`;
+}
+
+export async function prepareWindowsCaptureTempDirectory(
+	tempDirectory: string,
+	minimumFreeBytes = MIN_WINDOWS_CAPTURE_TEMP_FREE_BYTES,
+): Promise<WindowsCaptureTempStatus> {
+	const directory = path.resolve(tempDirectory);
+	let probePath: string | null = null;
+
+	try {
+		await fs.mkdir(directory, { recursive: true });
+		probePath = path.join(directory, `.recordly-write-test-${process.pid}-${randomUUID()}.tmp`);
+		await fs.writeFile(probePath, "Recordly temporary storage probe", { flag: "wx" });
+	} catch (error) {
+		throw new Error(
+			`Recordly cannot write to its temporary folder (${directory}). Choose another storage location or check the folder permissions. ${String(error)}`,
+		);
+	} finally {
+		if (probePath) {
+			await fs.rm(probePath, { force: true }).catch(() => undefined);
+		}
+	}
+
+	let freeBytes: number | null = null;
+	try {
+		const stats = await fs.statfs(directory);
+		const reportedFreeBytes = Number(stats.bavail) * Number(stats.bsize);
+		freeBytes = Number.isFinite(reportedFreeBytes) ? reportedFreeBytes : null;
+	} catch {
+		// Older Windows filesystems may not report capacity through statfs. The
+		// successful write probe is still enough to safely attempt capture.
+	}
+
+	if (freeBytes !== null && freeBytes < minimumFreeBytes) {
+		throw new Error(
+			`Recordly needs at least ${formatStorageSize(minimumFreeBytes)} free in its temporary folder (${directory}), but only ${formatStorageSize(freeBytes)} is available. Free disk space or choose another storage location.`,
+		);
+	}
+
+	return { directory, freeBytes };
+}
+
+export function describeWindowsCaptureStartFailure(
+	error: unknown,
+	processOutput: string,
+	tempDirectory: string,
+) {
+	const outputLines = processOutput
+		.split(/\r?\n/u)
+		.map((line) => line.trim())
+		.filter(Boolean);
+	const helperError = [...outputLines]
+		.reverse()
+		.find((line) => line.startsWith("ERROR:") || line.startsWith("WARNING:"));
+	const errorMessage = error instanceof Error ? error.message : String(error);
+	const detail = helperError ?? errorMessage;
+
+	if (/temporary folder|free disk space|folder permissions/iu.test(detail)) {
+		return detail;
+	}
+
+	return `${detail} Temporary folder: ${path.resolve(tempDirectory)}. If this folder is on a full or restricted drive, choose another Recordly storage location.`;
+}
 
 export type NativeWindowsVideoPaddingResult = {
 	padded: boolean;
@@ -135,7 +215,9 @@ export function waitForWindowsCaptureStop(
 
 		const onClose = (code: number | null) => {
 			finish(() => {
-				const match = windowsCaptureOutputBuffer.match(/Recording stopped\. Output path: (.+)/);
+				const match = windowsCaptureOutputBuffer.match(
+					/Recording stopped\. Output path: (.+)/,
+				);
 				if (match?.[1]) {
 					resolve(match[1].trim());
 					return;
@@ -254,9 +336,7 @@ export async function muxNativeWindowsVideoWithAudio(
 		}
 	}
 
-	console.log(
-		`[PERF:MAIN] muxNativeWindowsVideoWithAudio: COMPLETED in ${Date.now() - start}ms`,
-	);
+	console.log(`[PERF:MAIN] muxNativeWindowsVideoWithAudio: COMPLETED in ${Date.now() - start}ms`);
 
 	return {
 		muxed: false,