cowork-os 0.3.66 → 0.3.69

package/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.69] - 2026-02-11
+
+### Fixed
+- `npm install -g cowork-os` could fail on macOS with `fsevents` (`binding.gyp not found`) due an npm 11 rebuild edge case triggered by `playwright`.
+- Switched runtime browser dependency to `playwright-core` via npm alias (`playwright` package name preserved in code) to avoid the failing `fsevents` install path.
+- Added launcher self-heal: on first run, `cowork-os` now verifies direct runtime dependencies and repairs missing packages with a script-free npm install pass before boot.
+- Moved `@types/jszip` to `devDependencies` and excluded `@types/*` from runtime dependency checks to avoid unnecessary first-run repair installs.
+- Moved `@electron/rebuild` to runtime dependencies so native fallback rebuild works in npm-installed environments.
+- Fixed native setup fallback to locate `@electron/rebuild` via package exports (instead of resolving blocked subpaths), so fallback rebuild actually runs when needed.
+- `cowork-os` first run now uses the shell retry wrapper for native setup, reducing one-shot startup failures when macOS kills a setup attempt under memory pressure.
+
+## [0.3.68] - 2026-02-11
+
+### Fixed
+- `cowork-os` CLI startup could still fail with `better-sqlite3` ABI mismatch on first launch.
+- Launcher now validates `better-sqlite3` by opening an in-memory database (not just requiring the module) and runs native setup when needed.
+- Native setup script now resolves hoisted dependencies correctly (Electron and `better-sqlite3`) so it works in npm-installed layouts.
+
+## [0.3.67] - 2026-02-11
+
+### Added
+- Added npm CLI command support: `cowork-os`, `coworkctl`, `coworkd`, and `coworkd-node`.
+
+### Fixed
+- Fixed launcher script to resolve the Electron binary correctly (`require('electron')` instead of `require.resolve`).
+- Included `dist/` in published npm files so the `cowork-os` command can start without requiring a local build step.
+- Moved `electron` to runtime dependencies so CLI launch works after normal npm install.
+
 ## [0.3.66] - 2026-02-11
 
 ### Fixed

package/README.md

@@ -53,6 +53,25 @@ Your AI needs a secure home. CoWork OS provides the runtime, security layers, an
 - If the app closes immediately with a `dyld` signature error, run: `codesign --force --deep --sign - "/Applications/CoWork OS.app"`
 - `spctl --add` / `spctl --enable` are deprecated on newer macOS and may show "This operation is no longer supported"
 
+### From npm (CLI Launch)
+
+```bash
+# Install into a local folder
+mkdir -p /tmp/cowork-run
+cd /tmp/cowork-run
+npm install cowork-os@latest --no-audit --no-fund
+
+# Start app
+npx cowork-os
+```
+
+You can also install globally and launch directly:
+
+```bash
+npm install -g cowork-os
+cowork-os
+```
+
 ### From GitHub Source (Development)
 
 #### Prerequisites

package/bin/cowork.js

@@ -1,43 +1,186 @@
 #!/usr/bin/env node
 
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
 const packageDir = path.resolve(__dirname, '..');
-const electronPath = require.resolve('electron');
+const packageJsonPath = path.join(packageDir, 'package.json');
 const mainPath = path.join(packageDir, 'dist', 'electron', 'electron', 'main.js');
 const args = process.argv.slice(2);
+const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 
-// Check if the app has been built
-if (!fs.existsSync(mainPath)) {
-  console.log('CoWork-OSS: Building application...');
-  const build = spawn('npm', ['run', 'build'], {
+function buildAppAndLaunch() {
+  console.log('[cowork-os] Build artifacts not found, running npm run build...');
+  const build = spawn(npmCmd, ['run', 'build'], {
     cwd: packageDir,
     stdio: 'inherit',
-    shell: true
+    shell: process.platform === 'win32',
   });
 
-  build.on('close', (code) => {
-    if (code === 0) {
-      launchApp();
-    } else {
-      console.error('Build failed. Please run "npm run build" manually.');
-      process.exit(1);
+  build.on('exit', (code) => {
+    if (code !== 0) {
+      console.error('[cowork-os] Build failed. Run `npm run build` and retry.');
+      process.exit(code || 1);
     }
+    launchApp();
   });
+}
+
+if (fs.existsSync(mainPath)) {
+  prepareAndLaunchApp();
 } else {
-  launchApp();
+  buildAppAndLaunch();
+}
+
+function listMissingRuntimeDeps() {
+  if (!fs.existsSync(packageJsonPath)) return [];
+
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  } catch {
+    return [];
+  }
+
+  const deps = pkg && pkg.dependencies && typeof pkg.dependencies === 'object'
+    ? pkg.dependencies
+    : {};
+
+  const missing = [];
+  for (const dep of Object.keys(deps)) {
+    if (dep.startsWith('@types/')) continue;
+    try {
+      require.resolve(dep, { paths: [packageDir] });
+    } catch {
+      missing.push({ name: dep, version: deps[dep] });
+    }
+  }
+
+  return missing;
 }
 
-function launchApp() {
-  const electron = spawn(electronPath, [mainPath, ...args], {
+function ensureRuntimeDeps() {
+  const missing = listMissingRuntimeDeps();
+  if (missing.length === 0) return true;
+
+  const installArgs = [
+    'install',
+    '--no-save',
+    '--no-audit',
+    '--no-fund',
+    '--ignore-scripts',
+    ...missing.map((dep) => `${dep.name}@${dep.version}`)
+  ];
+
+  console.log(
+    `[cowork-os] Missing runtime dependencies detected (${missing.length}); repairing install...`
+  );
+  const res = spawnSync(npmCmd, installArgs, {
     cwd: packageDir,
     stdio: 'inherit',
-    env: { ...process.env, ELECTRON_DISABLE_SECURITY_WARNINGS: 'true' }
+    shell: process.platform === 'win32',
+    env: process.env,
   });
 
-  electron.on('close', (code) => {
-    process.exit(code);
+  return res.status === 0;
+}
+
+function resolveElectronBinary() {
+  try {
+    return require('electron');
+  } catch {
+    return null;
+  }
+}
+
+function isBetterSqliteReady(electronBinary) {
+  const probe = spawnSync(
+    electronBinary,
+    [
+      '-e',
+      "const Database=require('better-sqlite3');const db=new Database(':memory:');db.close();process.stdout.write('ok')",
+    ],
+    {
+      cwd: packageDir,
+      env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
+      stdio: 'pipe',
+      encoding: 'utf8',
+    }
+  );
+
+  return probe.status === 0;
+}
+
+function runNativeSetup(onDone) {
+  const setupScript = path.join(packageDir, 'scripts', 'setup_native.mjs');
+  const retryScript = path.join(packageDir, 'scripts', 'setup_native_retry.sh');
+  if (!fs.existsSync(setupScript)) {
+    console.error('[cowork-os] Missing native setup script at scripts/setup_native.mjs');
+    process.exit(1);
+  }
+
+  console.log('[cowork-os] Preparing native modules for Electron (first run)...');
+  const setupCommand = fs.existsSync(retryScript)
+    ? (process.platform === 'win32' ? process.execPath : 'sh')
+    : process.execPath;
+  const setupArgs = fs.existsSync(retryScript)
+    ? (process.platform === 'win32' ? [setupScript] : [retryScript])
+    : [setupScript];
+  const setup = spawn(setupCommand, setupArgs, {
+    cwd: packageDir,
+    stdio: 'inherit',
+    env: process.env,
+  });
+
+  setup.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    if (code !== 0) {
+      process.exit(code || 1);
+      return;
+    }
+    onDone();
+  });
+}
+
+function prepareAndLaunchApp() {
+  if (!ensureRuntimeDeps()) {
+    console.error('[cowork-os] Failed to repair runtime dependencies.');
+    process.exit(1);
+  }
+
+  const electronBinary = resolveElectronBinary();
+  if (!electronBinary) {
+    console.error(
+      '[cowork-os] Electron runtime is missing. Reinstall with:\n' +
+      '  npm install cowork-os@latest\n'
+    );
+    process.exit(1);
+  }
+
+  if (isBetterSqliteReady(electronBinary)) {
+    launchApp(electronBinary);
+    return;
+  }
+
+  runNativeSetup(() => launchApp(electronBinary));
+}
+
+function launchApp(electronBinary) {
+  const electron = spawn(electronBinary, [packageDir, ...args], {
+    cwd: packageDir,
+    stdio: 'inherit',
+    env: process.env
+  });
+
+  electron.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code || 0);
   });
 }

package/dist/electron/electron/activity/ActivityRepository.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityRepository = void 0;
+const uuid_1 = require("uuid");
+/**
+ * Safely parse JSON with error handling
+ */
+function safeJsonParse(jsonString, defaultValue, context) {
+    if (!jsonString)
+        return defaultValue;
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (error) {
+        console.error(`Failed to parse JSON${context ? ` in ${context}` : ''}:`, error);
+        return defaultValue;
+    }
+}
+/**
+ * Repository for managing activity feed entries in the database
+ */
+class ActivityRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Create a new activity entry
+     */
+    create(request) {
+        const now = Date.now();
+        const activity = {
+            id: (0, uuid_1.v4)(),
+            workspaceId: request.workspaceId,
+            taskId: request.taskId,
+            agentRoleId: request.agentRoleId,
+            actorType: request.actorType,
+            activityType: request.activityType,
+            title: request.title,
+            description: request.description,
+            metadata: request.metadata,
+            isRead: false,
+            isPinned: false,
+            createdAt: now,
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO activity_feed (
+        id, workspace_id, task_id, agent_role_id, actor_type,
+        activity_type, title, description, metadata,
+        is_read, is_pinned, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(activity.id, activity.workspaceId, activity.taskId || null, activity.agentRoleId || null, activity.actorType, activity.activityType, activity.title, activity.description || null, activity.metadata ? JSON.stringify(activity.metadata) : null, activity.isRead ? 1 : 0, activity.isPinned ? 1 : 0, activity.createdAt);
+        return activity;
+    }
+    /**
+     * Find an activity by ID
+     */
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM activity_feed WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToActivity(row) : undefined;
+    }
+    /**
+     * List activities with optional filtering
+     */
+    list(query) {
+        const conditions = ['workspace_id = ?'];
+        const params = [query.workspaceId];
+        if (query.taskId) {
+            conditions.push('task_id = ?');
+            params.push(query.taskId);
+        }
+        if (query.agentRoleId) {
+            conditions.push('agent_role_id = ?');
+            params.push(query.agentRoleId);
+        }
+        if (query.activityType) {
+            if (Array.isArray(query.activityType)) {
+                conditions.push(`activity_type IN (${query.activityType.map(() => '?').join(', ')})`);
+                params.push(...query.activityType);
+            }
+            else {
+                conditions.push('activity_type = ?');
+                params.push(query.activityType);
+            }
+        }
+        if (query.actorType) {
+            conditions.push('actor_type = ?');
+            params.push(query.actorType);
+        }
+        if (query.isRead !== undefined) {
+            conditions.push('is_read = ?');
+            params.push(query.isRead ? 1 : 0);
+        }
+        if (query.isPinned !== undefined) {
+            conditions.push('is_pinned = ?');
+            params.push(query.isPinned ? 1 : 0);
+        }
+        let sql = `SELECT * FROM activity_feed WHERE ${conditions.join(' AND ')} ORDER BY created_at DESC`;
+        if (query.limit) {
+            sql += ` LIMIT ${query.limit}`;
+            if (query.offset) {
+                sql += ` OFFSET ${query.offset}`;
+            }
+        }
+        const stmt = this.db.prepare(sql);
+        const rows = stmt.all(...params);
+        return rows.map((row) => this.mapRowToActivity(row));
+    }
+    /**
+     * Get unread count for a workspace
+     */
+    getUnreadCount(workspaceId) {
+        const stmt = this.db.prepare('SELECT COUNT(*) as count FROM activity_feed WHERE workspace_id = ? AND is_read = 0');
+        const result = stmt.get(workspaceId);
+        return result.count;
+    }
+    /**
+     * Mark an activity as read
+     */
+    markRead(id) {
+        const stmt = this.db.prepare('UPDATE activity_feed SET is_read = 1 WHERE id = ?');
+        const result = stmt.run(id);
+        return result.changes > 0;
+    }
+    /**
+     * Mark all activities as read for a workspace
+     */
+    markAllRead(workspaceId) {
+        const stmt = this.db.prepare('UPDATE activity_feed SET is_read = 1 WHERE workspace_id = ? AND is_read = 0');
+        const result = stmt.run(workspaceId);
+        return result.changes;
+    }
+    /**
+     * Toggle pin status of an activity
+     */
+    togglePin(id) {
+        const existing = this.findById(id);
+        if (!existing)
+            return undefined;
+        const newPinned = !existing.isPinned;
+        const stmt = this.db.prepare('UPDATE activity_feed SET is_pinned = ? WHERE id = ?');
+        stmt.run(newPinned ? 1 : 0, id);
+        return { ...existing, isPinned: newPinned };
+    }
+    /**
+     * Delete an activity
+     */
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM activity_feed WHERE id = ?');
+        const result = stmt.run(id);
+        return result.changes > 0;
+    }
+    /**
+     * Delete all activities for a workspace (optionally by age)
+     */
+    deleteOld(workspaceId, olderThanMs) {
+        if (olderThanMs) {
+            const cutoff = Date.now() - olderThanMs;
+            const stmt = this.db.prepare('DELETE FROM activity_feed WHERE workspace_id = ? AND created_at < ? AND is_pinned = 0');
+            const result = stmt.run(workspaceId, cutoff);
+            return result.changes;
+        }
+        else {
+            const stmt = this.db.prepare('DELETE FROM activity_feed WHERE workspace_id = ? AND is_pinned = 0');
+            const result = stmt.run(workspaceId);
+            return result.changes;
+        }
+    }
+    /**
+     * Map database row to Activity object
+     */
+    mapRowToActivity(row) {
+        return {
+            id: row.id,
+            workspaceId: row.workspace_id,
+            taskId: row.task_id || undefined,
+            agentRoleId: row.agent_role_id || undefined,
+            actorType: row.actor_type,
+            activityType: row.activity_type,
+            title: row.title,
+            description: row.description || undefined,
+            metadata: safeJsonParse(row.metadata, undefined, 'activity.metadata'),
+            isRead: row.is_read === 1,
+            isPinned: row.is_pinned === 1,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.ActivityRepository = ActivityRepository;