cowork-os 0.3.67 → 0.3.70

package/CHANGELOG.md

@@ -7,6 +7,24 @@ 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

package/README.md

@@ -55,12 +55,17 @@ Your AI needs a secure home. CoWork OS provides the runtime, security layers, an
 
 ### From npm (CLI Launch)
 
+Use this flow to test like a first-time user in a clean folder:
+
 ```bash
 # Install into a local folder
 mkdir -p /tmp/cowork-run
 cd /tmp/cowork-run
 npm install cowork-os@latest --no-audit --no-fund
 
+# Ensure no previously running CoWork instance is active
+pkill -f '/cowork-os' || true
+
 # Start app
 npx cowork-os
 ```
@@ -69,6 +74,22 @@ You can also install globally and launch directly:
 
 ```bash
 npm install -g cowork-os
+
+# Optional: verify installed version
+npm list -g cowork-os --depth=0
+
+# Ensure no previously running CoWork instance is active
+pkill -f '/cowork-os' || true
+
+cowork-os
+```
+
+If the app opens but shows `vUnknown` or `Error invoking remote method 'app:getVersion'`, you likely connected to an older already-running instance.
+
+Run:
+
+```bash
+pkill -f '/cowork-os' || true
 cowork-os
 ```
 
@@ -117,16 +138,66 @@ The packaged app will be in the `release/` directory.
 
 ### Linux VPS (Headless / Server Mode)
 
-Run CoWork OS without a GUI and manage it remotely via the WebSocket Control Plane (Web UI + CLI):
+If this is your first VPS install, start here (Node-only, no Docker):
+
+1. On your VPS (SSH terminal), connect and verify Node version:
+
+```bash
+ssh user@your-vps
+node -v
+npm -v
+```
+
+`cowork-os` requires Node `>=22.12.0`. If you see `v20`/`v21`, upgrade first:
+
+```bash
+curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
+sudo apt-get install -y nodejs
+node -v
+```
+
+2. Install and start CoWork OS (local install, no sudo needed):
+
+```bash
+mkdir -p ~/cowork-run
+cd ~/cowork-run
+npm init -y >/dev/null
+npm install cowork-os@latest --no-audit --no-fund
+
+export COWORK_IMPORT_ENV_SETTINGS=1
+export OPENAI_API_KEY=your_key_here   # or ANTHROPIC_API_KEY=your_key_here
+npx coworkd-node --print-control-plane-token
+```
+
+Keep this terminal open. It runs the server and prints your Control Plane token.
+
+If you see `sh: 1: tsc: not found` right after `npx coworkd-node`, you are on an older broken npm publish. Upgrade and retry:
+
+```bash
+npm install cowork-os@latest --no-audit --no-fund
+```
+
+3. On your local machine (second terminal), create the SSH tunnel:
+
+```bash
+ssh -N -L 18789:127.0.0.1:18789 user@your-vps
+```
+
+If local port `18789` is busy:
+
+```bash
+ssh -N -L 28789:127.0.0.1:18789 user@your-vps
+```
+
+4. Open the web UI in your browser:
+
+- `http://127.0.0.1:18789/` (or `http://127.0.0.1:28789/` if you used 28789)
+- Paste the token from step 1
+
+For production/persistent setup and Docker/systemd options, use:
 
-- Overview / positioning: `docs/self-hosting.md`
 - Guide: `docs/vps-linux.md`
-- Start (Node-only, no Electron/Xvfb): `node bin/coworkd-node.js`
-- Start (headless Electron): `node bin/coworkd.js`
-- Web UI (via tunnel): `http://127.0.0.1:18789/`
-- Headless creds: set `COWORK_IMPORT_ENV_SETTINGS=1` + `OPENAI_API_KEY`/`ANTHROPIC_API_KEY` (see guide)
-- Docker: `docker compose up --build -d`
-- systemd templates: `deploy/systemd/`
+- Overview: `docs/self-hosting.md`
 
 ---
 

package/bin/cowork.js

@@ -1,10 +1,11 @@
 #!/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 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';
@@ -27,23 +28,148 @@ function buildAppAndLaunch() {
 }
 
 if (fs.existsSync(mainPath)) {
-  launchApp();
+  prepareAndLaunchApp();
 } else {
   buildAppAndLaunch();
 }
 
-function launchApp() {
-  let electronBinary;
+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 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',
+    shell: process.platform === 'win32',
+    env: process.env,
+  });
+
+  return res.status === 0;
+}
+
+function resolveElectronBinary() {
   try {
-    electronBinary = require('electron');
+    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 --include=dev\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',