Bump version to 0.1.6 and add comprehensive crash logging system with process lifecycle tracking

- Bump version from 0.1.5 to 0.1.6 in package.json
- Add crash-logger module with JSON-based log persistence to ~/.open-cowork/logs/crash-YYYY-MM-DD.log
- Implement payload normalization with depth limiting, truncation (20k chars), and Error/Array/Object serialization
- Add crash event handlers for uncaughtException, unhandledRejection, child-process-gone, render-process-gone, unresponsive, and did-fail

Author: 239573049

package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-cowork",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "An Electron application with React and TypeScript",
   "main": "./out/main/index.js",
   "author": "example.com",

src/main/crash-logger.ts

@@ -0,0 +1,130 @@
+import { app } from 'electron'
+import { appendFileSync, mkdirSync } from 'fs'
+import { release } from 'os'
+import { join } from 'path'
+import { getDataDir } from './db/database'
+
+const LOG_DIR = join(getDataDir(), 'logs')
+const MAX_PAYLOAD_CHARS = 20_000
+const MAX_OBJECT_KEYS = 80
+const MAX_ARRAY_ITEMS = 50
+const MAX_DEPTH = 4
+
+type JsonRecord = Record<string, unknown>
+
+function ensureLogDir(): void {
+  mkdirSync(LOG_DIR, { recursive: true })
+}
+
+function getLogFilePath(now: Date): string {
+  const date = now.toISOString().slice(0, 10)
+  return join(LOG_DIR, `crash-${date}.log`)
+}
+
+function getAppVersionSafe(): string {
+  try {
+    return app.getVersion()
+  } catch {
+    return 'unknown'
+  }
+}
+
+function normalizeUnknown(value: unknown, depth = 0): unknown {
+  if (depth > MAX_DEPTH) return '[max-depth-exceeded]'
+  if (value == null) return value
+
+  const t = typeof value
+  if (t === 'string' || t === 'number' || t === 'boolean') return value
+  if (t === 'bigint') return String(value)
+  if (value instanceof Error) {
+    const out: JsonRecord = {
+      name: value.name,
+      message: value.message,
+      stack: value.stack,
+    }
+    const withCause = value as Error & { cause?: unknown }
+    if (withCause.cause !== undefined) {
+      out.cause = normalizeUnknown(withCause.cause, depth + 1)
+    }
+    return out
+  }
+
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_ARRAY_ITEMS).map((item) => normalizeUnknown(item, depth + 1))
+  }
+
+  if (t === 'object') {
+    const out: JsonRecord = {}
+    const entries = Object.entries(value as Record<string, unknown>).slice(0, MAX_OBJECT_KEYS)
+    for (const [k, v] of entries) {
+      out[k] = normalizeUnknown(v, depth + 1)
+    }
+    return out
+  }
+
+  return String(value)
+}
+
+function truncatePayload(payload: unknown): unknown {
+  try {
+    const raw = JSON.stringify(payload)
+    if (raw.length <= MAX_PAYLOAD_CHARS) return payload
+    return {
+      truncated: true,
+      totalChars: raw.length,
+      preview: raw.slice(0, MAX_PAYLOAD_CHARS),
+    }
+  } catch {
+    return payload
+  }
+}
+
+export interface CrashLogEntry {
+  timestamp: string
+  event: string
+  pid: number
+  ppid: number
+  appVersion: string
+  platform: NodeJS.Platform
+  osRelease: string
+  versions: {
+    electron?: string
+    node?: string
+    chrome?: string
+    v8?: string
+  }
+  payload?: unknown
+}
+
+export function writeCrashLog(event: string, payload?: unknown): void {
+  try {
+    ensureLogDir()
+    const now = new Date()
+    const entry: CrashLogEntry = {
+      timestamp: now.toISOString(),
+      event,
+      pid: process.pid,
+      ppid: process.ppid,
+      appVersion: getAppVersionSafe(),
+      platform: process.platform,
+      osRelease: release(),
+      versions: {
+        electron: process.versions.electron,
+        node: process.versions.node,
+        chrome: process.versions.chrome,
+        v8: process.versions.v8,
+      },
+      ...(payload === undefined
+        ? {}
+        : { payload: truncatePayload(normalizeUnknown(payload)) }),
+    }
+    appendFileSync(getLogFilePath(now), `${JSON.stringify(entry)}\n`, 'utf8')
+  } catch (err) {
+    console.error('[CrashLogger] Failed to write crash log:', err)
+  }
+}
+
+export function getCrashLogDir(): string {
+  return LOG_DIR
+}
+

src/main/index.ts

@@ -25,6 +25,7 @@ import { PluginManager } from './plugins/plugin-manager'
 import { registerMcpHandlers } from './ipc/mcp-handlers'
 import { McpManager } from './mcp/mcp-manager'
 import { closeDb } from './db/database'
+import { writeCrashLog, getCrashLogDir } from './crash-logger'
 
 import { createFeishuService } from './plugins/providers/feishu/feishu-service'
 import { createDingTalkService } from './plugins/providers/dingtalk/dingtalk-service'
@@ -39,6 +40,10 @@ let mainWindow: BrowserWindow | null = null
 let tray: Tray | null = null
 let isQuiting = false
 
+function recordCrash(event: string, details: unknown): void {
+  writeCrashLog(event, details)
+}
+
 function configureChromiumCachePaths(): void {
   const sessionDataPath = join(app.getPath('userData'), 'session-data')
   const diskCachePath = join(sessionDataPath, 'Cache')
@@ -50,6 +55,7 @@ function configureChromiumCachePaths(): void {
     app.commandLine.appendSwitch('disk-cache-dir', diskCachePath)
   } catch (error) {
     console.error('[Main] Failed to configure Chromium cache paths:', error)
+    recordCrash('configure_chromium_cache_failed', { error })
   }
 }
 
@@ -221,6 +227,44 @@ function createWindow(): void {
 
   })
 
+  window.webContents.on('render-process-gone', (_event, details) => {
+    const crashInfo = {
+      windowId: window.id,
+      webContentsId: window.webContents.id,
+      url: window.webContents.getURL(),
+      details,
+    }
+    console.error('[Main] Window render process gone:', crashInfo)
+    recordCrash('window_render_process_gone', crashInfo)
+  })
+
+  window.webContents.on('unresponsive', () => {
+    const hangInfo = {
+      windowId: window.id,
+      webContentsId: window.webContents.id,
+      url: window.webContents.getURL(),
+    }
+    console.error('[Main] Renderer became unresponsive:', hangInfo)
+    recordCrash('window_renderer_unresponsive', hangInfo)
+  })
+
+  window.webContents.on(
+    'did-fail-load',
+    (_event, errorCode, errorDescription, validatedURL, isMainFrame) => {
+      if (!isMainFrame || errorCode === -3) return
+      const failInfo = {
+        windowId: window.id,
+        webContentsId: window.webContents.id,
+        url: window.webContents.getURL(),
+        validatedURL,
+        errorCode,
+        errorDescription,
+      }
+      console.error('[Main] Renderer failed to load:', failInfo)
+      recordCrash('window_did_fail_load', failInfo)
+    }
+  )
+
 
 
   // HMR for renderer base on electron-vite cli.
@@ -249,16 +293,23 @@ function createWindow(): void {
 
 process.on('uncaughtException', (err) => {
 
-  console.error('[Main] Uncaught exception:', err.message)
+  console.error('[Main] Uncaught exception:', err)
+  recordCrash('main_uncaught_exception', { error: err })
 
 })
 
 process.on('unhandledRejection', (reason) => {
 
   console.error('[Main] Unhandled rejection:', reason)
+  recordCrash('main_unhandled_rejection', { reason })
 
 })
 
+app.on('child-process-gone', (_event, details) => {
+  console.error('[Main] App child-process-gone:', details)
+  recordCrash('app_child_process_gone', { details })
+})
+
 configureChromiumCachePaths()
 
 const gotSingleInstanceLock = app.requestSingleInstanceLock()
@@ -273,6 +324,12 @@ if (gotSingleInstanceLock) {
 
   app.whenReady().then(() => {
 
+  recordCrash('app_started', {
+    userDataPath: app.getPath('userData'),
+    crashLogDir: getCrashLogDir(),
+  })
+  console.log(`[CrashLogger] Logs will be written to ${getCrashLogDir()}`)
+
   // Set app user model id for windows
 
   electronApp.setAppUserModelId('com.electron')