Skip to content

Image Pipeline Playground

9.2 KB
Raw Blame
const { app, BrowserWindow, dialog, ipcMain, Menu, shell } = require('electron')
const { spawn } = require('node:child_process')
const http = require('node:http')
const net = require('node:net')
const path = require('node:path')
const fs = require('node:fs')

const IMAGE_EXTENSIONS = ['png', 'jpg', 'jpeg', 'bmp', 'tif', 'tiff', 'webp', 'gif']

const DEFAULT_BACKEND_PORT = 8000
const DEFAULT_VITE_PORT = 5173
/** Vite HMR UI — only when launched with `electron . --dev` (npm run desktop). */
const useViteDev = process.argv.includes('--dev') && !app.isPackaged
const isDev = useViteDev || !app.isPackaged

/** @type {import('node:child_process').ChildProcess | null} */
let backendProcess = null
/** @type {import('node:child_process').ChildProcess | null} */
let viteProcess = null
/** @type {BrowserWindow | null} */
let mainWindow = null
let backendPort = DEFAULT_BACKEND_PORT
let vitePort = DEFAULT_VITE_PORT

function repoRoot() {
  // desktop/src -> desktop -> repo
  return path.resolve(__dirname, '..', '..')
}

function serverBinaryName() {
  return process.platform === 'win32' ? 'image-pipes-server.exe' : 'image-pipes-server'
}

function packagedServerPath() {
  return path.join(process.resourcesPath, 'server', serverBinaryName())
}

function findFreePort(startPort) {
  return new Promise((resolve, reject) => {
    const tryPort = (port) => {
      const server = net.createServer()
      server.unref()
      server.on('error', (error) => {
        if (error.code === 'EADDRINUSE' && port < startPort + 40) {
          tryPort(port + 1)
        } else {
          reject(error)
        }
      })
      server.listen(port, '127.0.0.1', () => {
        server.close(() => resolve(port))
      })
    }
    tryPort(startPort)
  })
}

function waitForHttpOk(port, pathName, label, timeoutMs = 90000) {
  const started = Date.now()
  return new Promise((resolve, reject) => {
    const tick = () => {
      const req = http.get(
        { host: '127.0.0.1', port, path: pathName, timeout: 1500 },
        (res) => {
          res.resume()
          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 500) {
            resolve()
            return
          }
          retry()
        },
      )
      req.on('error', retry)
      req.on('timeout', () => {
        req.destroy()
        retry()
      })
    }
    const retry = () => {
      if (Date.now() - started > timeoutMs) {
        reject(new Error(`${label} did not become ready in time`))
        return
      }
      setTimeout(tick, 400)
    }
    tick()
  })
}

function buildBackendEnv(port) {
  const dataDir = path.join(app.getPath('userData'), 'data')
  fs.mkdirSync(dataDir, { recursive: true })
  const env = {
    ...process.env,
    IMAGE_PIPES_HOST: '127.0.0.1',
    IMAGE_PIPES_PORT: String(port),
    IMAGE_PIPES_DATA_DIR: dataDir,
    IMAGE_PIPES_LOG_LEVEL: isDev ? 'info' : 'warning',
    PYTHONUNBUFFERED: '1',
  }

  // Production / non-Vite desktop: FastAPI serves the built SPA.
  if (!useViteDev) {
    const frontendDist = path.join(repoRoot(), 'frontend', 'dist')
    if (fs.existsSync(frontendDist)) {
      env.IMAGE_PIPES_FRONTEND_DIST = frontendDist
    }
  }

  if (app.isPackaged) {
    const packagedDist = path.join(process.resourcesPath, 'server', 'frontend', 'dist')
    if (fs.existsSync(packagedDist)) {
      env.IMAGE_PIPES_FRONTEND_DIST = packagedDist
    }
  }

  return env
}

function attachProcessLogs(child, label) {
  const log = (chunk) => {
    const text = chunk.toString()
    if (text.trim()) console.log(`[${label}] ${text.trimEnd()}`)
  }
  child.stdout?.on('data', log)
  child.stderr?.on('data', log)
}

function spawnBackend(port) {
  const env = buildBackendEnv(port)
  const cwdBackend = path.join(repoRoot(), 'backend')

  if (app.isPackaged) {
    const binary = packagedServerPath()
    if (!fs.existsSync(binary)) {
      throw new Error(
        `Packaged backend missing at ${binary}. Rebuild with scripts/build-desktop.`,
      )
    }
    backendProcess = spawn(binary, [], {
      cwd: path.dirname(binary),
      env,
      stdio: ['ignore', 'pipe', 'pipe'],
      windowsHide: true,
    })
  } else {
    const runServer = path.join(cwdBackend, 'run_server.py')
    backendProcess = spawn('uv', ['run', 'python', runServer], {
      cwd: cwdBackend,
      env,
      stdio: ['ignore', 'pipe', 'pipe'],
      shell: process.platform === 'win32',
      windowsHide: true,
    })
  }

  attachProcessLogs(backendProcess, 'backend')
  backendProcess.on('exit', (code, signal) => {
    console.log(`[backend] exited code=${code} signal=${signal}`)
    backendProcess = null
  })
}

function spawnVite(port, apiPort) {
  const frontendDir = path.join(repoRoot(), 'frontend')
  viteProcess = spawn('npm', ['run', 'dev', '--', '--host', '127.0.0.1', '--port', String(port)], {
    cwd: frontendDir,
    env: {
      ...process.env,
      IMAGE_PIPES_API_PROXY: `http://127.0.0.1:${apiPort}`,
      IMAGE_PIPES_VITE_PORT: String(port),
    },
    stdio: ['ignore', 'pipe', 'pipe'],
    shell: process.platform === 'win32',
    windowsHide: true,
  })

  attachProcessLogs(viteProcess, 'vite')
  viteProcess.on('exit', (code, signal) => {
    console.log(`[vite] exited code=${code} signal=${signal}`)
    viteProcess = null
  })
}

function stopProcess(child) {
  if (!child || child.killed || child.pid == null) return
  try {
    if (process.platform === 'win32') {
      spawn('taskkill', ['/pid', String(child.pid), '/f', '/t'], {
        stdio: 'ignore',
        windowsHide: true,
      })
    } else {
      child.kill('SIGTERM')
    }
  } catch (error) {
    console.error('Failed to stop process', error)
  }
}

function stopChildren() {
  stopProcess(viteProcess)
  viteProcess = null
  stopProcess(backendProcess)
  backendProcess = null
}

function uiUrl() {
  if (useViteDev) return `http://127.0.0.1:${vitePort}`
  return `http://127.0.0.1:${backendPort}`
}

function registerDesktopIpc() {
  ipcMain.handle('desktop:openImages', async () => {
    const result = await dialog.showOpenDialog(mainWindow ?? undefined, {
      title: 'Choose images',
      properties: ['openFile', 'multiSelections'],
      filters: [
        { name: 'Images', extensions: IMAGE_EXTENSIONS },
        { name: 'All Files', extensions: ['*'] },
      ],
    })
    if (result.canceled) return { canceled: true, paths: [] }
    return { canceled: false, paths: result.filePaths }
  })

  ipcMain.handle('desktop:openFolder', async () => {
    const result = await dialog.showOpenDialog(mainWindow ?? undefined, {
      title: 'Choose image folder',
      properties: ['openDirectory'],
    })
    if (result.canceled || result.filePaths.length === 0) {
      return { canceled: true, path: null }
    }
    return { canceled: false, path: result.filePaths[0] }
  })

  ipcMain.handle('desktop:pickFolder', async () => {
    const result = await dialog.showOpenDialog(mainWindow ?? undefined, {
      title: 'Choose output folder',
      properties: ['openDirectory', 'createDirectory'],
    })
    if (result.canceled || result.filePaths.length === 0) {
      return { canceled: true, path: null }
    }
    return { canceled: false, path: result.filePaths[0] }
  })

  ipcMain.handle('desktop:revealInFolder', async (_event, targetPath) => {
    if (typeof targetPath !== 'string' || !targetPath.trim()) {
      throw new Error('Path is required')
    }
    shell.showItemInFolder(path.resolve(targetPath))
  })
}

async function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1440,
    height: 920,
    minWidth: 1100,
    minHeight: 720,
    show: false,
    backgroundColor: '#0f0f0f',
    title: 'Image Pipes',
    webPreferences: {
      preload: path.join(__dirname, 'preload.cjs'),
      contextIsolation: true,
      nodeIntegration: false,
      sandbox: true,
    },
  })

  mainWindow.once('ready-to-show', () => mainWindow?.show())
  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
    void shell.openExternal(url)
    return { action: 'deny' }
  })

  await mainWindow.loadURL(uiUrl())

  if (useViteDev) {
    mainWindow.webContents.openDevTools({ mode: 'detach' })
  }

  mainWindow.on('closed', () => {
    mainWindow = null
  })
}

async function bootstrap() {
  backendPort = await findFreePort(DEFAULT_BACKEND_PORT)
  spawnBackend(backendPort)
  await waitForHttpOk(backendPort, '/api/health', 'Backend')

  if (useViteDev) {
    vitePort = await findFreePort(DEFAULT_VITE_PORT)
    spawnVite(vitePort, backendPort)
    await waitForHttpOk(vitePort, '/', 'Vite')
  }

  await createWindow()
}

app.whenReady().then(() => {
  Menu.setApplicationMenu(null)
  registerDesktopIpc()
  void bootstrap().catch(async (error) => {
    console.error(error)
    stopChildren()
    await dialog.showErrorBox(
      'Image Pipes failed to start',
      `${error instanceof Error ? error.message : String(error)}\n\n` +
        (useViteDev
          ? 'Dev tip: run `uv sync` in backend/ and `npm install` in frontend/.'
          : 'Dev tip: run `uv sync` in backend/ and `npm run build` in frontend/.'),
    )
    app.quit()
  })
})

app.on('before-quit', () => {
  stopChildren()
})

app.on('window-all-closed', () => {
  stopChildren()
  if (process.platform !== 'darwin') app.quit()
})

app.on('activate', () => {
  if (BrowserWindow.getAllWindows().length === 0 && backendProcess) {
    void createWindow()
  }
})