cowork-os 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-os",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "CoWork OS - The most complete open-source AI assistant platform",
   "overrides": {
     "@whiskeysockets/baileys": {
@@ -117,6 +117,7 @@
     "discord.js": "^14.25.1",
     "docx": "^9.5.2",
     "e2b": "^2.12.1",
+    "electron": "^40.4.1",
     "electron-updater": "^6.3.9",
     "ethers": "^6.16.0",
     "eventsource": "^4.1.0",
@@ -165,7 +166,6 @@
     "@vitest/coverage-v8": "^4.0.18",
     "concurrently": "^9.2.1",
     "cross-env": "^10.1.0",
-    "electron": "^40.4.1",
     "electron-builder": "^26.7.0",
     "eslint": "^9.39.2",
     "globals": "^17.3.0",

package/scripts/setup_native.mjs

@@ -24,22 +24,34 @@ import process from "node:process";
 
 const BETTER_SQLITE3_VERSION = "12.6.2";
 const NPM_CMD = process.platform === "win32" ? "npm.cmd" : "npm";
-const cwdRequire = (() => {
-  try {
-    return createRequire(path.join(process.cwd(), "package.json"));
-  } catch {
-    return createRequire(import.meta.url);
-  }
-})();
+const cwdRequire = createRequire(path.join(process.cwd(), "package.json"));
+const scriptRequire = createRequire(import.meta.url);
 
 function resolveFromCwd(specifier) {
+  // Try CWD first (dev/source builds), then script location (global npm install)
   try {
     return cwdRequire.resolve(specifier);
   } catch {
-    return null;
+    try {
+      return scriptRequire.resolve(specifier);
+    } catch {
+      return null;
+    }
   }
 }
 
+/**
+ * Find a file inside an npm package directory by resolving the package's
+ * package.json first (which is always resolvable regardless of exports maps),
+ * then constructing the file path directly.
+ */
+function resolvePackageFile(packageName, filePath) {
+  const pkgJson = resolveFromCwd(`${packageName}/package.json`);
+  if (!pkgJson) return null;
+  const candidate = path.join(path.dirname(pkgJson), filePath);
+  return fs.existsSync(candidate) ? candidate : null;
+}
+
 function getElectronBinaryPath() {
   try {
     const electronBinary = cwdRequire("electron");
@@ -254,7 +266,7 @@ function main() {
   const attempt = (attemptJobs) => {
     const env = baseEnvWithJobs(attemptJobs);
     const installRootDir = getInstallRootDir();
-    const electronInstallScript = resolveFromCwd("electron/install.js");
+    const electronInstallScript = resolvePackageFile("electron", "install.js");
     const electronBinary = getElectronBinaryPath();
 
     if (!electronInstallScript) {
@@ -319,10 +331,12 @@ function main() {
     }
 
     // 3) Fallback: electron-rebuild.
-    const electronRebuildEntry = resolveFromCwd("@electron/rebuild");
-    const electronRebuildCli = electronRebuildEntry
-      ? path.join(path.dirname(electronRebuildEntry), "cli.js")
-      : null;
+    const electronRebuildCli = resolvePackageFile("@electron/rebuild", "cli.js")
+      || (() => {
+        // Fallback: try resolving the main entry and deriving cli.js
+        const entry = resolveFromCwd("@electron/rebuild");
+        return entry ? path.join(path.dirname(entry), "cli.js") : null;
+      })();
     if (!electronRebuildCli || !fs.existsSync(electronRebuildCli)) {
       console.log(
         "[cowork] @electron/rebuild is not installed; skipping fallback rebuild."

package/src/electron/agent/__tests__/executor-step-failures.test.ts

@@ -222,6 +222,7 @@ function createExecutorWithLLMHandler(handler: (messages: Any[]) => LLMResponse)
         kind: "none",
       },
     })),
+    getContextUtilization: vi.fn().mockReturnValue({ utilization: 0 }),
     getAvailableTokens: vi.fn().mockReturnValue(1_000_000),
   };
   executor.checkBudgets = vi.fn();
@@ -879,13 +880,13 @@ describe("TaskExecutor executeStep failure handling", () => {
     expect((executor as Any).conversationHistory.at(-1)?.content).toContain("This is attempt 2");
   });
 
-  it("does not re-run recovery plan insertion for the same failing signature twice", async () => {
+  it("does not auto-insert recovery plan steps for repeated failure signatures", async () => {
     const executor = createExecutorWithStubs(
       [
         toolUseResponse("run_command", { command: "exit 1" }),
-        textResponse("done"),
+        textResponse(""),
         toolUseResponse("run_command", { command: "exit 1" }),
-        textResponse("done"),
+        textResponse(""),
       ],
       {
         run_command: { success: false, error: "cannot complete this task without a workaround" },
@@ -903,23 +904,22 @@ describe("TaskExecutor executeStep failure handling", () => {
     await (executor as Any).executeStep(failedStep);
     await (executor as Any).executeStep(failedStep);
 
-    expect(handlePlanRevisionSpy).toHaveBeenCalledTimes(1);
-    expect(failedStep.status).toBe("failed");
-    expect(executor.planRevisionCount).toBe(1);
+    expect(handlePlanRevisionSpy).not.toHaveBeenCalled();
+    expect(executor.planRevisionCount).toBe(0);
     const planDescriptions = executor.plan.steps.map((step: Any) => step.description);
     expect(
-      planDescriptions.filter((desc: string) => desc.includes("alternative toolchain")).length,
-    ).toBe(1);
-    expect(planDescriptions.length).toBe(4);
+      planDescriptions.some((desc: string) => desc.includes("alternative toolchain")),
+    ).toBe(false);
+    expect(planDescriptions.length).toBe(2);
   });
 
-  it("adds recovery steps again when failure reason changes after a retry", async () => {
+  it("does not auto-insert recovery steps even when failure reason changes between retries", async () => {
     const executor = createExecutorWithStubs(
       [
         toolUseResponse("run_command", { command: "exit 1" }),
-        textResponse("done"),
+        textResponse(""),
         toolUseResponse("run_command", { command: "exit 1" }),
-        textResponse("done"),
+        textResponse(""),
       ],
       {},
     );
@@ -948,18 +948,18 @@ describe("TaskExecutor executeStep failure handling", () => {
     await (executor as Any).executeStep(failedStep);
     await (executor as Any).executeStep(failedStep);
 
-    expect(handlePlanRevisionSpy).toHaveBeenCalledTimes(2);
+    expect(handlePlanRevisionSpy).not.toHaveBeenCalled();
     const planDescriptions = executor.plan.steps.map((step: Any) => step.description);
     expect(
-      planDescriptions.filter((desc: string) => desc.includes("alternative toolchain")).length,
-    ).toBe(2);
-    expect(planDescriptions.length).toBe(6);
-    expect(executor.planRevisionCount).toBe(2);
+      planDescriptions.some((desc: string) => desc.includes("alternative toolchain")),
+    ).toBe(false);
+    expect(planDescriptions.length).toBe(2);
+    expect(executor.planRevisionCount).toBe(0);
   });
 
-  it("adds recovery plan steps without clearing unrelated pending steps", async () => {
+  it("keeps existing plan steps unchanged when recovery insertion is not triggered", async () => {
     const executor = createExecutorWithStubs(
-      [toolUseResponse("run_command", { command: "exit 1" }), textResponse("done")],
+      [toolUseResponse("run_command", { command: "exit 1" }), textResponse("")],
       {
         run_command: { success: false, error: "exit code 1" },
       },
@@ -974,21 +974,18 @@ describe("TaskExecutor executeStep failure handling", () => {
 
     await (executor as Any).executeStep(failedStep);
 
-    expect(failedStep.status).toBe("failed");
+    expect(failedStep.status).toBe("completed");
     const planDescriptions = executor.plan.steps.map((step: Any) => step.description);
-    expect(planDescriptions).toContain(
-      "Try an alternative toolchain or different input strategy for: Run baseline task",
-    );
-    expect(planDescriptions).toContain(
-      "If normal tools are blocked, implement the smallest safe code/feature change needed to continue and complete the goal.",
-    );
+    expect(
+      planDescriptions.some((desc: string) => desc.includes("alternative toolchain")),
+    ).toBe(false);
     expect(planDescriptions).toContain("Validate output");
-    expect(planDescriptions.length).toBe(4);
+    expect(planDescriptions.length).toBe(2);
   });
 
-  it("triggers recovery on blocked-step reasons even without explicit user request", async () => {
+  it("does not auto-trigger recovery planning when user did not explicitly request recovery", async () => {
     const executor = createExecutorWithStubs(
-      [toolUseResponse("run_command", { command: "exit 1" }), textResponse("done")],
+      [toolUseResponse("run_command", { command: "exit 1" }), textResponse("")],
       {
         run_command: { success: false, error: "cannot complete this task without a workaround" },
       },
@@ -1006,10 +1003,10 @@ describe("TaskExecutor executeStep failure handling", () => {
     await (executor as Any).executeStep(failedStep);
 
     const planDescriptions = executor.plan.steps.map((step: Any) => step.description);
-    expect(planDescriptions).toContain(
-      "Try an alternative toolchain or different input strategy for: Run baseline task",
-    );
-    expect(failedStep.status).toBe("failed");
-    expect(executor.planRevisionCount).toBe(1);
+    expect(
+      planDescriptions.some((desc: string) => desc.includes("alternative toolchain")),
+    ).toBe(false);
+    expect(failedStep.status).toBe("completed");
+    expect(executor.planRevisionCount).toBe(0);
   });
 });