shadow-claw 1.51.0 → 1.52.1

package/src/share-target/pending-shares.test.ts

@@ -76,4 +76,94 @@ describe("consumePendingShares", () => {
 
     db.close();
   });
+
+  it("returns empty array when db is null or does not have transaction function", async () => {
+    expect(await consumePendingShares(null as any)).toEqual([]);
+    expect(await consumePendingShares({} as any)).toEqual([]);
+  });
+
+  it("handles NotFoundError DOMException by resolving with empty array", async () => {
+    const mockDb: any = {
+      transaction: () => {
+        throw new DOMException("Store not found", "NotFoundError");
+      },
+    };
+    const res = await consumePendingShares(mockDb);
+    expect(res).toEqual([]);
+  });
+
+  it("rejects when transaction throws other error", async () => {
+    const mockDb: any = {
+      transaction: () => {
+        throw new Error("Disk corruption");
+      },
+    };
+    await expect(consumePendingShares(mockDb)).rejects.toThrow(
+      "Disk corruption",
+    );
+  });
+
+  it("handles getAll error, clear error, and tx abort", async () => {
+    // 1. getAll error
+    const req1: any = {};
+    const mockDb1: any = {
+      transaction: () => ({
+        objectStore: () => ({
+          getAll: () => {
+            setTimeout(() => {
+              req1.error = new Error("Read error");
+              req1.onerror();
+            }, 0);
+            return req1;
+          },
+        }),
+      }),
+    };
+    await expect(consumePendingShares(mockDb1)).rejects.toThrow("Read error");
+
+    // 2. clear error
+    const req2: any = {};
+    const clearReq: any = {};
+    const mockDb2: any = {
+      transaction: () => ({
+        objectStore: () => ({
+          getAll: () => {
+            setTimeout(() => {
+              req2.result = [{ id: "x", createdAt: 1 }];
+              req2.onsuccess();
+            }, 0);
+            return req2;
+          },
+          clear: () => {
+            setTimeout(() => {
+              clearReq.error = new Error("Clear error");
+              clearReq.onerror();
+            }, 0);
+            return clearReq;
+          },
+        }),
+      }),
+    };
+    await expect(consumePendingShares(mockDb2)).rejects.toThrow("Clear error");
+
+    // 3. tx abort
+    const req3: any = {};
+    const tx3: any = {
+      objectStore: () => ({
+        getAll: () => {
+          setTimeout(() => {
+            tx3.error = new Error("Aborted error");
+            tx3.onabort();
+          }, 0);
+          return req3;
+        },
+      }),
+    };
+    const mockDb3: any = {
+      transaction: () => tx3,
+    };
+    await expect(consumePendingShares(mockDb3)).rejects.toThrow(
+      "Aborted error",
+    );
+  });
 });

package/src/shell/fs.test.ts

@@ -25,6 +25,7 @@ jest.unstable_mockModule("../storage/createGroupDirectory.js", () => ({
 }));
 
 const { ShadowClawFileSystem, createFileSystem } = await import("./fs.js");
+const { readGroupFileBytes } = await import("../storage/readGroupFileBytes.js");
 const { writeGroupFile } = await import("../storage/writeGroupFile.js");
 const { deleteGroupFile } = await import("../storage/deleteGroupFile.js");
 const { createGroupDirectory } =
@@ -97,6 +98,53 @@ describe("ShadowClawFileSystem", () => {
     });
   });
 
+  describe("appendFile", () => {
+    it("persists appended content to group storage when inside /home/user", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+      await fs.appendFile("/home/user/app.log", "log line\n");
+
+      expect(writeGroupFile).toHaveBeenCalledWith(
+        db,
+        groupId,
+        "app.log",
+        expect.anything(),
+      );
+    });
+
+    it("does not persist appended content when outside /home/user", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+      await fs.appendFile("/tmp/app.log", "log line\n");
+
+      expect(writeGroupFile).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("cp", () => {
+    it("persists copied file to group storage when destination inside /home/user", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+      const statSpy = jest
+        .spyOn(InMemoryFs.prototype, "stat")
+        .mockResolvedValue({ isDirectory: () => false } as any);
+
+      await fs.cp("/tmp/file.txt", "/home/user/copied.txt");
+
+      expect(writeGroupFile).toHaveBeenCalledWith(
+        db,
+        groupId,
+        "copied.txt",
+        expect.anything(),
+      );
+      statSpy.mockRestore();
+    });
+
+    it("does not persist copied file when destination outside /home/user", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+      await fs.cp("/home/user/file.txt", "/tmp/copied.txt");
+
+      expect(writeGroupFile).not.toHaveBeenCalled();
+    });
+  });
+
   describe("mv", () => {
     it("persists moved file under destination directory path", async () => {
       const fs = new ShadowClawFileSystem(db, groupId, {});
@@ -195,5 +243,82 @@ describe("ShadowClawFileSystem", () => {
 
       mkdirSyncSpy.mockRestore();
     });
+
+    it("loads file contents when reading created file", async () => {
+      (readGroupFileBytes as unknown as jest.Mock).mockResolvedValue(
+        Uint8Array.from([1, 2, 3]) as any,
+      );
+
+      const listMock = listGroupFiles as unknown as jest.Mock;
+      listMock.mockImplementation(async (...args: any[]) => {
+        const dir = args[2] as string;
+        if (dir === ".") {
+          return ["hello.txt"];
+        }
+        return [];
+      });
+
+      const fs = await createFileSystem(db, groupId);
+      const fileFn = (fs as any).files["/home/user/hello.txt"];
+      expect(typeof fileFn).toBe("function");
+
+      const bytes = await fileFn();
+      expect(bytes).toEqual(Uint8Array.from([1, 2, 3]));
+
+      // Fallback on read error
+      (readGroupFileBytes as unknown as jest.Mock).mockRejectedValueOnce(
+        new Error("File read error"),
+      );
+      const str = await fileFn();
+      expect(str).toBe("");
+    });
+  });
+
+  describe("rm", () => {
+    it("deletes file from storage when inside /home/user", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+
+      await fs.rm("/home/user/test.txt");
+
+      expect(deleteGroupFile).toHaveBeenCalledWith(db, groupId, "test.txt");
+    });
+
+    it("does not delete file from storage when outside /home/user", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+
+      await fs.rm("/tmp/test.txt");
+
+      expect(deleteGroupFile).not.toHaveBeenCalled();
+    });
+
+    it("silently catches errors when deleteGroupFile throws", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+      (deleteGroupFile as unknown as jest.Mock).mockRejectedValueOnce(
+        new Error("Failed to delete"),
+      );
+
+      await expect(fs.rm("/home/user/test.txt")).resolves.not.toThrow();
+    });
+  });
+
+  describe("internal path helpers", () => {
+    it("handles non-function stat, root dir joining, and workspace prefix root", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+      expect((fs as any)._isDirectoryStat({ isDirectory: true })).toBe(true);
+      expect((fs as any)._isDirectoryStat({ isDirectory: false })).toBe(false);
+      expect((fs as any)._joinPath("/", "hello.txt")).toBe("/hello.txt");
+      expect((fs as any)._toDbPath("/home/user")).toBe("");
+    });
+  });
+
+  describe("mv edge cases", () => {
+    it("deletes source when moving to outside /home/user", async () => {
+      const fs = new ShadowClawFileSystem(db, groupId, {});
+
+      await fs.mv("/home/user/file.pdf", "/tmp/file.pdf");
+
+      expect(deleteGroupFile).toHaveBeenCalledWith(db, groupId, "file.pdf");
+      expect(writeGroupFile).not.toHaveBeenCalled();
+    });
   });
 });

package/src/shell/shell.test.ts

@@ -62,4 +62,12 @@ describe("executeShell", () => {
       }),
     );
   });
+
+  it("handles errors during execution gracefully", async () => {
+    mockExec.mockRejectedValueOnce(new Error("Bash failed"));
+    const result = await executeShell({} as any, "bad command", "group1");
+
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toBe("Bash failed");
+  });
 });

package/src/subsystems/git/credentials.test.ts

@@ -233,5 +233,265 @@ describe("git credentials", () => {
       expect(creds.token).toBeUndefined();
       expect(creds.provider).toBe("generic");
     });
+
+    it("matches account by authMode when multiple accounts match host", async () => {
+      storedConfig["git_accounts"] = [
+        {
+          id: "pat-acct",
+          hostPattern: "github.com",
+          token: "enc:pat-tok",
+          authMode: "token",
+        },
+        {
+          id: "oauth-acct",
+          hostPattern: "github.com",
+          token: "enc:oauth-tok",
+          authMode: "oauth",
+        },
+      ];
+
+      const creds = await resolveGitCredentials(
+        mockDb,
+        "https://github.com/foo/bar",
+        { authMode: "oauth" },
+      );
+      expect(creds.accountId).toBe("oauth-acct");
+      expect(creds.token).toBe("oauth-tok");
+    });
+
+    it("matches legacy account without authMode when token mode requested", async () => {
+      storedConfig["git_accounts"] = [
+        {
+          id: "legacy-acct",
+          hostPattern: "github.com",
+          token: "enc:legacy-tok",
+        },
+      ];
+
+      const creds = await resolveGitCredentials(
+        mockDb,
+        "https://github.com/foo/bar",
+        { authMode: "token" },
+      );
+      expect(creds.accountId).toBe("legacy-acct");
+      expect(creds.token).toBe("legacy-tok");
+    });
+
+    it("falls back to default account matching url hostPattern when direct host match fails", async () => {
+      storedConfig["git_default_account"] = "default-match";
+      storedConfig["git_accounts"] = [
+        {
+          id: "default-match",
+          hostPattern: "ghe.internal.corp",
+          token: "enc:internal-tok",
+        },
+      ];
+
+      const creds = await resolveGitCredentials(
+        mockDb,
+        "https://ghe.internal.corp/org/repo",
+      );
+      expect(creds.accountId).toBe("default-match");
+      expect(creds.token).toBe("internal-tok");
+    });
+
+    it("falls back to first account matching authMode when no url provided", async () => {
+      storedConfig["git_accounts"] = [
+        {
+          id: "acct-pat",
+          hostPattern: "github.com",
+          token: "enc:pat-tok",
+          authMode: "token",
+        },
+        {
+          id: "acct-oauth",
+          hostPattern: "github.com",
+          token: "enc:oauth-tok",
+          authMode: "oauth",
+        },
+      ];
+
+      const creds = await resolveGitCredentials(mockDb, undefined, {
+        authMode: "oauth",
+      });
+      expect(creds.accountId).toBe("acct-oauth");
+    });
+
+    it("falls back to first account when no url and no default account", async () => {
+      storedConfig["git_accounts"] = [
+        {
+          id: "first-acct",
+          hostPattern: "github.com",
+          token: "enc:first-tok",
+        },
+      ];
+
+      const creds = await resolveGitCredentials(mockDb);
+      expect(creds.accountId).toBe("first-acct");
+    });
+
+    it("refreshes expired oauth token successfully", async () => {
+      const originalFetch = globalThis.fetch;
+      const mockFetch = jest.fn(async () => ({
+        ok: true,
+        json: async () => ({
+          accessToken: "new-access-token",
+          refreshToken: "new-refresh-token",
+          expiresIn: 3600,
+          scope: "repo read:org",
+          tokenType: "Bearer",
+        }),
+      })) as any;
+      globalThis.fetch = mockFetch;
+
+      try {
+        storedConfig["git_accounts"] = [
+          {
+            id: "oauth-refresh-acct",
+            hostPattern: "github.com",
+            provider: "github",
+            authMode: "oauth",
+            token: "enc:old-access",
+            refreshToken: "enc:old-refresh",
+            oauthProviderId: "github",
+            oauthClientId: "client-id-123",
+            oauthClientSecret: "enc:secret-123",
+            accessTokenExpiresAt: Date.now() - 1000,
+          },
+        ];
+
+        const creds = await resolveGitCredentials(
+          mockDb,
+          "https://github.com/foo/bar",
+        );
+        expect(creds.token).toBe("new-access-token");
+        expect(mockFetch).toHaveBeenCalled();
+        const updated = storedConfig["git_accounts"][0];
+        expect(updated.token).toBe("enc:new-access-token");
+        expect(updated.refreshToken).toBe("enc:new-refresh-token");
+        expect(updated.scopes).toEqual(["repo", "read:org"]);
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+
+    it("marks refresh failure and transitions to reauthRequired after threshold", async () => {
+      const originalFetch = globalThis.fetch;
+      const mockFetch = jest.fn(async () => ({
+        ok: false,
+        status: 400,
+      })) as any;
+      globalThis.fetch = mockFetch;
+
+      try {
+        storedConfig["git_accounts"] = [
+          {
+            id: "failing-oauth-acct",
+            hostPattern: "github.com",
+            provider: "github",
+            authMode: "oauth",
+            token: "enc:token",
+            refreshToken: "enc:refresh",
+            oauthProviderId: "github",
+            oauthClientId: "client-id-123",
+            oauthRefreshFailureCount: 2,
+            accessTokenExpiresAt: Date.now() - 1000,
+          },
+        ];
+
+        const creds = await resolveGitCredentials(
+          mockDb,
+          "https://github.com/foo/bar",
+          { forceRefresh: true },
+        );
+        expect(creds.reauthRequired).toBe(true);
+        expect(storedConfig["git_accounts"][0].oauthReauthRequired).toBe(true);
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+
+    it("handles fetch exception during oauth refresh gracefully", async () => {
+      const originalFetch = globalThis.fetch;
+      globalThis.fetch = jest.fn(async () => {
+        throw new Error("Network offline");
+      }) as any;
+
+      try {
+        storedConfig["git_accounts"] = [
+          {
+            id: "network-fail-acct",
+            hostPattern: "github.com",
+            provider: "github",
+            authMode: "oauth",
+            token: "enc:token",
+            refreshToken: "enc:refresh",
+            oauthProviderId: "github",
+            oauthClientId: "client-id-123",
+            accessTokenExpiresAt: Date.now() - 1000,
+          },
+        ];
+
+        const creds = await resolveGitCredentials(
+          mockDb,
+          "https://github.com/foo/bar",
+        );
+        expect(creds.token).toBe("token");
+        expect(storedConfig["git_accounts"][0].oauthRefreshFailureCount).toBe(
+          1,
+        );
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+
+    it("handles oauth response missing accessToken", async () => {
+      const originalFetch = globalThis.fetch;
+      globalThis.fetch = jest.fn(async () => ({
+        ok: true,
+        json: async () => ({}),
+      })) as any;
+
+      try {
+        storedConfig["git_accounts"] = [
+          {
+            id: "missing-token-acct",
+            hostPattern: "github.com",
+            provider: "github",
+            authMode: "oauth",
+            token: "enc:token",
+            refreshToken: "enc:refresh",
+            oauthProviderId: "github",
+            oauthClientId: "client-id-123",
+            accessTokenExpiresAt: Date.now() - 1000,
+          },
+        ];
+
+        const creds = await resolveGitCredentials(
+          mockDb,
+          "https://github.com/foo/bar",
+        );
+        expect(creds.token).toBe("token");
+        expect(storedConfig["git_accounts"][0].oauthRefreshFailureCount).toBe(
+          1,
+        );
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+
+    it("resolves full legacy config with password and user metadata", async () => {
+      storedConfig["git_token"] = "enc:pat";
+      storedConfig["git_password"] = "enc:secret-pass";
+      storedConfig["git_username"] = "myuser";
+      storedConfig["git_author_name"] = "Full Name";
+      storedConfig["git_author_email"] = "me@example.com";
+
+      const creds = await resolveGitCredentials(mockDb);
+      expect(creds.password).toBe("secret-pass");
+      expect(creds.username).toBe("myuser");
+      expect(creds.authorName).toBe("Full Name");
+      expect(creds.authorEmail).toBe("me@example.com");
+    });
   });
 });

package/src/subsystems/git/git.test.ts

@@ -572,6 +572,15 @@ describe("git", () => {
 
       expect(result).toBe("No branches found.");
     });
+
+    it("handles detached HEAD when currentBranch throws", async () => {
+      mockGit.listBranches.mockResolvedValue(["main", "feature"]);
+      mockGit.currentBranch.mockRejectedValue(new Error("HEAD is detached"));
+
+      const result = await gitListBranches({ repo: "my-repo" });
+
+      expect(result).toBe("  main\n  feature");
+    });
   });
 
   describe("gitCurrentBranch", () => {
@@ -705,6 +714,22 @@ describe("git", () => {
         }),
       );
     });
+
+    it("returns result details when push is not ok", async () => {
+      mockGit.currentBranch.mockResolvedValue("main");
+      mockGit.push.mockResolvedValue({
+        ok: false,
+        refs: { "refs/heads/main": { ok: false, error: "non-fast-forward" } },
+      });
+
+      const result = await gitPush({
+        token: "fake",
+        repo: "my-repo",
+      });
+
+      expect(result).toContain("Push result:");
+      expect(result).toContain("non-fast-forward");
+    });
   });
 
   describe("gitListRepos", () => {
@@ -732,6 +757,14 @@ describe("git", () => {
 
       expect(result).toBe("No repos cloned.");
     });
+
+    it("returns 'No repos cloned.' when readdir returns empty array", async () => {
+      mockPfs.readdir.mockResolvedValue([]);
+
+      const result = await gitListRepos();
+
+      expect(result).toBe("No repos cloned.");
+    });
   });
 
   describe("getProxyUrl", () => {
@@ -930,6 +963,37 @@ describe("git", () => {
         expect.objectContaining({ filepath: "new-file.txt" }),
       );
     });
+
+    it("reports no changes when staging with '.' and clean status matrix", async () => {
+      mockGit.statusMatrix.mockResolvedValue([["file.txt", 1, 1, 1]]);
+
+      const result = await gitAdd({ repo: "my-repo", filepath: "." });
+
+      expect(result).toBe("No changes to add in my-repo");
+    });
+
+    it("stages multiple files when filepath is an array", async () => {
+      const result = await gitAdd({
+        repo: "my-repo",
+        filepath: ["./a.txt", "b.txt"],
+      });
+
+      expect(result).toContain("a.txt, b.txt");
+      expect(mockGit.add).toHaveBeenCalledWith(
+        expect.objectContaining({ filepath: "a.txt" }),
+      );
+      expect(mockGit.add).toHaveBeenCalledWith(
+        expect.objectContaining({ filepath: "b.txt" }),
+      );
+    });
+
+    it("defaults to '.' when filepath is an empty array", async () => {
+      mockGit.statusMatrix.mockResolvedValue([["file.txt", 1, 1, 1]]);
+
+      const result = await gitAdd({ repo: "my-repo", filepath: [] });
+
+      expect(result).toBe("No changes to add in my-repo");
+    });
   });
 
   describe("makeDirHandleFs", () => {

package/src/subsystems/providers/executeNativeAiTask.test.ts

@@ -489,5 +489,83 @@ describe("executeNativeAiTask", () => {
         setHeadlessMode(false);
       }
     });
+
+    it("handles detect-language via fetch with JSON and fallback", async () => {
+      mockGetProvider.mockReturnValue({
+        id: "custom",
+        name: "Custom",
+        baseUrl: "http://localhost:8080/v1/chat/completions",
+        format: "openai",
+        defaultModel: "model-1",
+        requiresApiKey: false,
+      });
+
+      mockFormatRequest.mockReturnValue({
+        messages: [{ role: "user", content: "Detect" }],
+      });
+
+      mockParseResponse.mockReturnValue({
+        content: [{ type: "text", text: "not-json" }],
+      });
+
+      globalThis.fetch = jest.fn<any>().mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const resFallback = await executeNativeAiTask({
+        taskType: "detect-language",
+        input: { text: "Hello" },
+        providerId: "custom",
+      });
+      expect(resFallback).toEqual([
+        { detectedLanguage: "en", confidence: 0.8 },
+      ]);
+
+      // Now with valid JSON
+      mockParseResponse.mockReturnValue({
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify([
+              { detectedLanguage: "es", confidence: 0.99 },
+            ]),
+          },
+        ],
+      });
+      const resJson = await executeNativeAiTask({
+        taskType: "detect-language",
+        input: { text: "Hola" },
+        providerId: "custom",
+      });
+      expect(resJson).toEqual([{ detectedLanguage: "es", confidence: 0.99 }]);
+    });
+
+    it("throws error when provider fetch fails with non-ok status", async () => {
+      mockGetProvider.mockReturnValue({
+        id: "custom",
+        name: "Custom",
+        baseUrl: "http://localhost:8080/v1/chat/completions",
+        format: "openai",
+        defaultModel: "model-1",
+        requiresApiKey: false,
+      });
+
+      mockFormatRequest.mockReturnValue({ messages: [] });
+
+      globalThis.fetch = jest.fn<any>().mockResolvedValue({
+        ok: false,
+        status: 500,
+        text: () => Promise.resolve("Internal Error"),
+      });
+
+      await expect(
+        executeNativeAiTask({
+          taskType: "summarize",
+          input: { text: "Hello" },
+          providerId: "custom",
+        }),
+      ).rejects.toThrow("Active provider task API error 500: Internal Error");
+    });
   });
 });