Copy files to tmpdir

CHANGELOG.md

@@ -8,6 +8,7 @@
 
 ### Added
 - highlight the first unread message upon opening a chat #4525
+- copy files to internal tmp dir before opening attachements #4498
 - enable notifications on mentions in muted chats #4538
 - always show accounts with unread messages, even when they're normally scrolled out of view #4536
 

packages/frontend/src/components/message/messageFunctions.ts

@@ -28,12 +28,13 @@ export function onDownload(msg: Type.Message) {
   }
 }
 
-export function openAttachmentInShell(msg: Type.Message) {
-  if (!msg.file) {
+export async function openAttachmentInShell(msg: Type.Message) {
+  if (!msg.file || !msg.fileName) {
     log.error('message has no file to open:', msg)
     throw new Error('message has no file to open')
   }
-  if (!runtime.openPath(msg.file)) {
+  const tmpFile = await runtime.copyFileToInternalTmpDir(msg.fileName, msg.file)
+  if (!runtime.openPath(tmpFile)) {
     log.info(
       "file couldn't be opened, try saving it in a different place and try to open it from there"
     )

packages/runtime/runtime.ts

@@ -121,6 +121,10 @@ export interface Runtime {
   writeClipboardToTempFile(name?: string): Promise<string>
   writeTempFileFromBase64(name: string, content: string): Promise<string>
   writeTempFile(name: string, content: string): Promise<string>
+  copyFileToInternalTmpDir(
+    fileName: string,
+    sourcePath: string
+  ): Promise<string>
   removeTempFile(path: string): Promise<void>
   getWebxdcDiskUsage(accountId: number): Promise<{
     total_size: number

packages/target-browser/runtime-browser/runtime.ts

@@ -361,6 +361,12 @@ class BrowserRuntime implements Runtime {
       ).json()
     ).path
   }
+  async copyFileToInternalTmpDir(
+    _fileName: string,
+    _sourcePath: string
+  ): Promise<string> {
+    throw new Error('Method not implemented')
+  }
   async removeTempFile(name: string): Promise<void> {
     await fetch(`/backend-api/removeTempFile`, {
       method: 'POST',

packages/target-electron/runtime-electron/runtime.ts

@@ -224,6 +224,16 @@ class ElectronRuntime implements Runtime {
   writeTempFile(name: string, content: string): Promise<string> {
     return ipcBackend.invoke('app.writeTempFile', name, content)
   }
+  copyFileToInternalTmpDir(
+    fileName: string,
+    sourcePath: string
+  ): Promise<string> {
+    return ipcBackend.invoke(
+      'app.copyFileToInternalTmpDir',
+      fileName,
+      sourcePath
+    )
+  }
   removeTempFile(path: string): Promise<void> {
     return ipcBackend.invoke('app.removeTempFile', path)
   }

packages/target-electron/src/application-constants.ts

@@ -100,3 +100,8 @@ export const ALLOWED_ACCOUNT_FOLDERS = [
   'dc.db-blobs',
   'stickers',
 ]
+
+// folder inside account dir to store files
+// temporary when opened in another application
+// cleared on app start
+export const INTERNAL_TMP_DIR_NAME = 'tmp'

packages/target-electron/src/cleanup_temp_dir.ts

@@ -2,7 +2,12 @@ import { app } from 'electron'
 import { mkdir, readdir, rm, rmdir } from 'fs/promises'
 import { join } from 'path'
 import { getLogger } from '../../shared/logger.js'
-import { getDraftTempDir } from './application-constants.js'
+import {
+  getDraftTempDir,
+  getAccountsPath,
+  INTERNAL_TMP_DIR_NAME,
+} from './application-constants.js'
+import { readdirSync } from 'fs'
 
 const log = getLogger('main/cleanup_temp_dir')
 
@@ -39,3 +44,39 @@ export async function cleanupDraftTempDir() {
     log.error('Cleanup of old temp files failed: ', error)
   }
 }
+
+/**
+ * clean tmp directory in all accounts
+ */
+export async function cleanupInternalTempDirs() {
+  try {
+    let deletedTmpDirs = 0
+    const tmpDirents = readdirSync(getAccountsPath(), {
+      withFileTypes: true,
+    })
+      .filter(dirent => dirent.isDirectory())
+      .flatMap(accountDir => {
+        return readdirSync(join(accountDir.parentPath, accountDir.name), {
+          withFileTypes: true,
+        }).filter(
+          tmpDir =>
+            tmpDir.isDirectory() && tmpDir.name === INTERNAL_TMP_DIR_NAME
+        )
+      })
+    if (tmpDirents.length > 0) {
+      deletedTmpDirs = (
+        await Promise.all(
+          tmpDirents.map(tmpDir =>
+            rm(join(tmpDir.parentPath, tmpDir.name), {
+              recursive: true,
+              force: true,
+            })
+          )
+        )
+      ).length
+    }
+    log.info(`Deleted ${deletedTmpDirs} internal tmp directories`)
+  } catch (error) {
+    log.error('Cleanup of internal temp dirs failed: ', error)
+  }
+}

packages/target-electron/src/index.ts

@@ -133,7 +133,10 @@ import { updateTrayIcon, hideDeltaChat, showDeltaChat } from './tray.js'
 import './notifications.js'
 import { acceptThemeCLI } from './themes.js'
 import { webxdcStartUpCleanup } from './deltachat/webxdc.js'
-import { cleanupDraftTempDir } from './cleanup_temp_dir.js'
+import {
+  cleanupDraftTempDir,
+  cleanupInternalTempDirs,
+} from './cleanup_temp_dir.js'
 
 app.ipcReady = false
 app.isQuitting = false
@@ -198,7 +201,7 @@ async function onReady([_appReady, _loadedState, _appx, _webxdc_cleanup]: [
     log.error('Cleanup of old logfiles failed: ', err)
   )
   cleanupDraftTempDir()
-
+  cleanupInternalTempDirs()
   // NOTE: Make sure to use `powerMonitor` only when electron signals it is ready
   initialisePowerMonitor()
 }

packages/target-electron/src/ipc.ts

@@ -21,6 +21,7 @@ import {
   getDraftTempDir,
   getLogsPath,
   htmlDistDir,
+  INTERNAL_TMP_DIR_NAME,
 } from './application-constants.js'
 import { LogHandler } from './log-handler.js'
 import { ExtendedAppMainProcess } from './types.js'
@@ -256,6 +257,9 @@ export async function init(cwd: string, logHandler: LogHandler) {
   ipcMain.handle('app.writeTempFile', (_ev, name, content) =>
     writeTempFile(name, content)
   )
+  ipcMain.handle('app.copyFileToInternalTmpDir', (_ev, name, pathToFile) => {
+    return copyFileToInternalTmpDir(name, pathToFile)
+  })
   ipcMain.handle('app.removeTempFile', (_ev, path) => removeTempFile(path))
 
   ipcMain.handle('electron.shell.openExternal', (_ev, url) =>
@@ -388,6 +392,24 @@ export async function writeTempFile(
   return pathToFile
 }
 
+export async function copyFileToInternalTmpDir(
+  fileName: string,
+  sourcePath: string
+): Promise<string> {
+  const sourceFileName = basename(sourcePath)
+  const sourceDir = dirname(sourcePath)
+  let destinationDir = join(sourceDir, '..', INTERNAL_TMP_DIR_NAME)
+  if (sourceFileName !== fileName) {
+    // this is the case, when we copy a file that has an identifier
+    //  as name (given during the file deduplications process)
+    destinationDir = join(destinationDir, sourceFileName)
+  }
+  await mkdir(destinationDir, { recursive: true })
+  const targetPath = join(destinationDir, fileName)
+  await copyFile(sourcePath, targetPath)
+  return targetPath
+}
+
 async function removeTempFile(path: string) {
   if (
     path.indexOf(rawApp.getPath('temp')) === -1 ||

packages/target-tauri/runtime-tauri/runtime.ts

@@ -438,6 +438,12 @@ class TauriRuntime implements Runtime {
   writeTempFile(_name: string, _content: string): Promise<string> {
     throw new Error('Method not implemented.43')
   }
+  copyFileToInternalTmpDir(
+    _fileName: string,
+    _sourcePath: string
+  ): Promise<string> {
+    throw new Error('Method not implemented.44b')
+  }
   removeTempFile(_path: string): Promise<void> {
     throw new Error('Method not implemented.44')
   }