Scheduling infrastructure for absolutely everyone.
feat: add delete recording script (#23169)
Udit Takkar9b38ed65c058
diff --git a/packages/app-store/dailyvideo/lib/scripts/deleteRecordings.ts b/packages/app-store/dailyvideo/lib/scripts/deleteRecordings.tsnew file mode 100644index 00000000000..5cd8fe909c9--- /dev/null+++ b/packages/app-store/dailyvideo/lib/scripts/deleteRecordings.ts@@ -0,0 +1,451 @@+// This script is used to delete recordings older than 6 months from Daily.co+//+// Commands to run:+// 1. Fetch recordings older than 6 months and save to JSON:+// ts-node packages/app-store/dailyvideo/lib/scripts/deleteRecordings.ts+//+// 2. Delete recordings from the JSON file (shows preview first, then prompts for confirmation):+// ts-node packages/app-store/dailyvideo/lib/scripts/deleteRecordings.ts delete++interface Recording {+ id: string;+ room_name: string;+ mtgSessionId: string;+ status: string;+ start_ts: number;+ duration: number;+ max_participants?: number;+ share_token?: string;+ s3key?: string;+ isVttEnabled?: boolean;+ tracks?: unknown[];+}++interface RecordingsResponse {+ data: Recording[];+ total_count: number;+}++async function getAllRecordingsOlderThan6Months(): Promise<Recording[]> {+ const apiKey = process.env.DAILY_API_KEY;++ if (!apiKey) {+ console.error("DAILY_API_KEY environment variable is required");+ process.exit(1);+ }++ const baseUrl = "https://api.daily.co/v1/recordings";+ const allRecordings: Recording[] = [];+ const limit = 100;++ // Calculate date 6 months ago+ const cutoffDate = new Date();+ cutoffDate.setUTCMonth(cutoffDate.getUTCMonth() - 6);+ cutoffDate.setUTCHours(0, 0, 0, 0);+ const cutoffTimestamp = Math.floor(cutoffDate.getTime() / 1000);++ console.log(+ `Fetching all recordings older than 6 months (before ${+ cutoffDate.toISOString().split("T")[0]+ }, timestamp: ${cutoffTimestamp})...`+ );++ let hasMoreRecordings = true;+ let requestCount = 0;+ const startTime = Date.now();+ let endingBefore = "OLDEST";++ while (hasMoreRecordings) {+ requestCount++;+ const elapsedTime = Date.now() - startTime;+ const expectedMinTime = (requestCount - 1) * 50;++ if (elapsedTime < expectedMinTime) {+ const delayTime = expectedMinTime - elapsedTime;+ console.log(`Rate limiting: waiting ${delayTime}ms before next request...`);+ await new Promise((resolve) => setTimeout(resolve, delayTime));+ }++ const url = new URL(baseUrl);+ url.searchParams.append("limit", limit.toString());++ if (endingBefore) {+ url.searchParams.append("ending_before", endingBefore);+ }++ let retries = 0;+ const maxRetries = 5;+ let response: Response | undefined;++ while (retries <= maxRetries) {+ try {+ console.log("url", url.toString());+ response = await fetch(url.toString(), {+ headers: {+ Authorization: `Bearer ${apiKey}`,+ "Content-Type": "application/json",+ },+ });++ if (response.ok) {+ break;+ }++ if (response.status === 404) {+ console.log("No recordings found or endpoint not available");+ return [];+ }++ if (response.status === 429) {+ if (retries < maxRetries) {+ const backoffDelay = Math.pow(2, retries) * 1000;+ console.log(+ `Rate limit exceeded (429). Retrying in ${backoffDelay / 1000}s... (attempt ${retries + 1}/${+ maxRetries + 1+ })`+ );+ await new Promise((resolve) => setTimeout(resolve, backoffDelay));+ retries++;+ continue;+ } else {+ throw new Error(`Rate limit exceeded after ${maxRetries + 1} attempts`);+ }+ }++ throw new Error(`HTTP error! status: ${response.status}`);+ } catch (error) {+ if (retries < maxRetries && (error as Error).message.includes("fetch")) {+ const backoffDelay = Math.pow(2, retries) * 1000;+ console.log(+ `Network error. Retrying in ${backoffDelay / 1000}s... (attempt ${retries + 1}/${maxRetries + 1})`+ );+ await new Promise((resolve) => setTimeout(resolve, backoffDelay));+ retries++;+ continue;+ }+ throw error;+ }+ }++ if (!response?.ok) {+ throw new Error(`Failed to fetch recordings after ${maxRetries + 1} attempts`);+ }++ const data = (await response.json()) as RecordingsResponse;++ if (!data.data || data.data.length === 0) {+ console.log("No more recordings available, ending pagination");+ hasMoreRecordings = false;+ break;+ }++ const filteredRecordings = data.data.filter((recording) => {+ return recording.start_ts < cutoffTimestamp;+ });++ allRecordings.push(...filteredRecordings);+ console.log(+ `Fetched ${data.data.length} recordings, ${filteredRecordings.length} older than 6 months (total: ${allRecordings.length})`+ );++ endingBefore = data.data[0].id;+ console.log("endingBefore", endingBefore);+ console.log("first recording in batch", data.data[0]);+ console.log("last recording in batch", data.data[data.data.length - 1]);++ if (data.data.length < limit) {+ console.log("Received fewer results than limit, reached end of data");+ hasMoreRecordings = false;+ break;+ }++ if (filteredRecordings.length === 0 && data.data.every((r) => r.start_ts >= cutoffTimestamp)) {+ console.log("Reached recordings newer than 6 months, stopping");+ hasMoreRecordings = false;+ break;+ }+ }++ return allRecordings;+}++async function saveRecordingsToJson(recordings: Recording[]): Promise<void> {+ const fs = await import("fs/promises");+ const path = await import("path");++ const simplifiedRecordings = recordings.map((recording) => ({+ id: recording.id,+ room_name: recording.room_name,+ start_ts: recording.start_ts,+ start_date: new Date(recording.start_ts * 1000).toISOString(),+ duration: recording.duration,+ status: recording.status,+ mtgSessionId: recording.mtgSessionId,+ max_participants: recording.max_participants,+ share_token: recording.share_token,+ s3key: recording.s3key,+ isVttEnabled: recording.isVttEnabled,+ }));++ const outputPath = path.join(process.cwd(), "recordings_older_than_6_months.json");++ try {+ await fs.writeFile(outputPath, JSON.stringify(simplifiedRecordings, null, 2), "utf-8");+ console.log(`\nRecordings saved to: ${outputPath}`);+ } catch (error) {+ console.error("Error saving recordings to JSON:", error);+ }+}++async function main(): Promise<void> {+ console.log("Fetching all recordings older than 6 months...");++ const recordings = await getAllRecordingsOlderThan6Months();++ const totalDurationSeconds = recordings.reduce(+ (total: number, recording: Recording) => total + recording.duration,+ 0+ );++ const totalHours = Math.floor(totalDurationSeconds / 3600);+ const remainingMinutes = Math.floor((totalDurationSeconds % 3600) / 60);+ const remainingSeconds = totalDurationSeconds % 60;++ console.log(`\nFinal result: ${recordings.length} recordings found older than 6 months`);+ console.log(+ `Total duration: ${totalDurationSeconds} seconds (${totalHours}h ${remainingMinutes}m ${remainingSeconds}s)`+ );++ await saveRecordingsToJson(recordings);++ console.log("\nLast 10 recordings (oldest first):");++ const lastTen = recordings.slice(-10);+ lastTen.forEach((recording: Recording, index: number) => {+ const startTime = new Date(recording.start_ts * 1000).toISOString();+ const durationMinutes = Math.floor(recording.duration / 60);+ const durationSeconds = recording.duration % 60;++ console.log(+ `${index + 1}. ${recording.room_name} (${+ recording.id+ }) - Started: ${startTime} - Duration: ${durationMinutes}m ${durationSeconds}s - Status: ${+ recording.status+ }`+ );+ });++ if (recordings.length > 10) {+ console.log(`\n... and ${recordings.length - 10} more recordings before these`);+ }+}++async function deleteRecording(recordingId: string, apiKey: string): Promise<boolean> {+ const url = `https://api.daily.co/v1/recordings/${recordingId}`;+ const maxRetries = 5;+ let retries = 0;++ while (retries <= maxRetries) {+ try {+ const response = await fetch(url, {+ method: "DELETE",+ headers: {+ Authorization: `Bearer ${apiKey}`,+ "Content-Type": "application/json",+ },+ });++ if (response.ok) {+ const result = await response.json();+ return result.deleted === true;+ }++ if (response.status === 404) {+ console.log(`Recording ${recordingId} not found (may have been already deleted)`);+ return true;+ }++ if (response.status === 429) {+ if (retries < maxRetries) {+ const backoffDelay = Math.pow(2, retries) * 1000;+ console.log(+ `Rate limit for ${recordingId}. Retrying in ${backoffDelay / 1000}s... (attempt ${retries + 1}/${+ maxRetries + 1+ })`+ );+ await new Promise((resolve) => setTimeout(resolve, backoffDelay));+ retries++;+ continue;+ }+ }++ console.error(`Failed to delete recording ${recordingId}: HTTP ${response.status}`);+ return false;+ } catch (error) {+ const errorMessage = (error as Error).message;++ if (+ retries < maxRetries &&+ (errorMessage.includes("fetch failed") || errorMessage.includes("TIMEOUT"))+ ) {+ const backoffDelay = Math.pow(2, retries) * 1000;+ console.log(+ `Network error for ${recordingId}. Retrying in ${backoffDelay / 1000}s... (attempt ${retries + 1}/${+ maxRetries + 1+ })`+ );+ await new Promise((resolve) => setTimeout(resolve, backoffDelay));+ retries++;+ continue;+ }++ console.error(`Error deleting recording ${recordingId} after ${retries + 1} attempts:`, error);+ return false;+ }+ }++ console.error(`Failed to delete recording ${recordingId} after ${maxRetries + 1} attempts`);+ return false;+}++async function deleteRecordingsFromJson(dryRun = false): Promise<void> {+ const apiKey = process.env.DAILY_API_KEY;++ if (!apiKey) {+ console.error("DAILY_API_KEY environment variable is required");+ process.exit(1);+ }++ const fs = await import("fs/promises");+ const path = await import("path");++ const filePath = path.join(process.cwd(), "recordings_older_than_6_months.json");++ try {+ const fileContent = await fs.readFile(filePath, "utf-8");+ const recordings = JSON.parse(fileContent) as Array<{+ id: string;+ room_name: string;+ start_date: string;+ duration: number;+ status: string;+ }>;++ console.log(`\nFound ${recordings.length} recordings to delete`);++ if (recordings.length === 0) {+ console.log("No recordings to delete");+ return;+ }++ const totalDuration = recordings.reduce((sum, rec) => sum + rec.duration, 0);+ const totalHours = Math.floor(totalDuration / 3600);+ const totalMinutes = Math.floor((totalDuration % 3600) / 60);++ console.log(`Total duration: ${totalHours}h ${totalMinutes}m`);+ console.log(`Date range: ${recordings[0].start_date} to ${recordings[recordings.length - 1].start_date}`);++ if (dryRun) {+ console.log("\n🔸 DRY RUN MODE - No recordings will be deleted");+ console.log("First 5 recordings that would be deleted:");+ recordings.slice(0, 5).forEach((rec, idx) => {+ console.log(` ${idx + 1}. ${rec.id} - ${rec.room_name} (${rec.start_date})`);+ });+ if (recordings.length > 5) {+ console.log(` ... and ${recordings.length - 5} more`);+ }+ return;+ }++ let successCount = 0;+ let failCount = 0;+ const startTime = Date.now();+ const batchSize = 10;++ for (let i = 0; i < recordings.length; i += batchSize) {+ const batch = recordings.slice(i, Math.min(i + batchSize, recordings.length));+ const batchPromises = [];++ for (const recording of batch) {+ const elapsedTime = Date.now() - startTime;+ const expectedMinTime = (successCount + failCount) * 50;++ if (elapsedTime < expectedMinTime) {+ const delayTime = expectedMinTime - elapsedTime;+ await new Promise((resolve) => setTimeout(resolve, delayTime));+ }++ const deletePromise = deleteRecording(recording.id, apiKey).then((success) => {+ if (success) {+ successCount++;+ } else {+ failCount++;+ }++ if ((successCount + failCount) % 10 === 0) {+ const progress = (((successCount + failCount) / recordings.length) * 100).toFixed(1);+ console.log(+ `Progress: ${progress}% (${successCount + failCount}/${recordings.length}), recording-id:${+ recording.id+ }`+ );+ }++ return success;+ });++ batchPromises.push(deletePromise);+ }++ await Promise.all(batchPromises);+ }++ console.log("\n✅ Deletion complete!");+ console.log(`Successfully deleted: ${successCount}`);+ console.log(`Failed to delete: ${failCount}`);+ console.log(`Total processed: ${successCount + failCount}`);++ if (failCount > 0) {+ console.log("\n⚠️ Some recordings failed to delete. Check the logs above for details.");+ }+ } catch (error) {+ console.error("Error reading or processing recordings file:", error);+ process.exit(1);+ }+}++async function mainDelete(): Promise<void> {+ const readline = (await import("readline")).createInterface({+ input: process.stdin,+ output: process.stdout,+ });++ console.log("🗑️ Daily Video Recording Deletion Tool");+ console.log("=====================================");+ console.log("This tool will delete all recordings listed in recordings_older_than_6_months.json");+ console.log("\n⚠️ WARNING: This action cannot be undone!");+ console.log("Note: Recordings in custom S3 buckets will NOT be deleted from S3.\n");++ await deleteRecordingsFromJson(true);++ const question = (query: string): Promise<string> =>+ new Promise((resolve) => readline.question(query, resolve));++ const answer = await question("\nDo you want to proceed with deletion? (yes/no): ");++ if (answer.toLowerCase() === "yes") {+ console.log("\nStarting deletion process...\n");+ await deleteRecordingsFromJson(false);+ } else {+ console.log("\nDeletion cancelled.");+ }++ readline.close();+}++const args = process.argv.slice(2);+if (args[0] === "delete") {+ mainDelete();+} else {+ main();+}