The Problem

Developers who rely on Claude Code must work from a terminal, which makes it hard to visualise multi‑step tasks, track session history, and approve tool actions. The lack of a graphical front‑end forces users to switch contexts and manually inspect logs.

What This Does

Claude‑Cowork packages Claude Code inside an Electron desktop shell and adds a React UI. The UI lives under src/ui/ (e.g., src/ui/App.tsx, src/ui/components/). Core Electron logic is in src/electron/ (main.ts, ipc‑handlers.ts, libs/runner.ts). The app stores session data in a local SQLite file via src/electron/libs/session‑store.ts. Configuration is shared with Claude Code through ~/.claude/settings.json, so no extra credential handling is required.

How It Is Wired

Execution begins in src/electron/main.ts, which creates the browser window and loads index.html. The UI bootstrap is src/ui/main.tsx, which renders <App /> from src/ui/App.tsx.

  • UI → Electron IPC: UI components call ipcInvoke (defined in src/electron/preload.cts) to request actions such as createSession, runClaude, or listSessions.
  • IPC handlers (src/electron/ipc-handlers.ts) forward those calls to library modules:
  • runClaude → src/electron/libs/runner.ts (runs the Claude model, streams tokens).
  • Session CRUD → src/electron/libs/session-store.ts (reads/writes SQLite).
  • The most‑used hub is src/ui/store/useAppStore.ts, imported by five UI files and exposing createSession, updateSession, and emit. emit funnels events to src/electron/ipc-handlers.ts, which then invoke the appropriate library function.

The import graph shows 25 internal modules with 38 edges; two cycles involve src/electron/util.ts ↔ src/electron/pathResolver.ts. The highest‑instability module is src/electron/main.ts (instability 1, imports 7 other modules but none import it).

Database interaction is limited to src/electron/libs/session-store.ts (13 functions, 5 class/type definitions) and src/electron/test.ts (utility reads). No other external I/O is present.

How To Use It

# Clone the repo (use the exact URL)
git clone https://github.com/moses-y/Claude-Cowork
cd Claude-Cowork

# Install dependencies (the project ships a bun.lock; bun is the documented tool)
bun install          # or npm ci if you prefer npm

# Development mode – launches Electron with hot‑reloading
bun run dev

# Build production binaries (examples from README)
bun run dist:mac     # macOS
bun run dist:win     # Windows
bun run dist:linux   # Linux

Prerequisites:

  • Node 18+ or Bun (as used by the scripts).
  • A working Claude Code installation with a valid ~/.claude/settings.json.

No additional environment variables are required; the app reads the existing Claude settings file.

Real‑World Use

A developer can open the app, click “New Session”, point it at a project directory, and ask Claude to “refactor this module”. Claude streams the updated code in the UI, the developer approves the tool call via the decision panel, and the changes are written directly to the filesystem. The session is persisted in SQLite, allowing the developer to resume later or audit the history.

Code Health & Issues

  • HIGH – Missing LICENSE – No LICENSE file; default “all rights reserved” blocks reuse.
  • HIGH – No test suite – 25 source files, only one test file; regressions are unchecked.
  • HIGH – No CI workflow – No .github/workflows; builds and tests are never automated.
  • MEDIUM – Dependabot disabled – No dependabot.yml; vulnerable dependencies stay unpatched.
  • LOW – Missing repo conventions – No .editorconfig, .gitattributes, or formatter config, risking inconsistent formatting.
  • HIGH – Import cycles – src/electron/util.ts ↔ src/electron/pathResolver.ts create a circular dependency; break the cycle by extracting shared helpers.
  • HIGH – Duplicated type definitions – Types duplicated in src/electron/types.ts and src/ui/types.ts (and repeated logic in two UI components). Consolidate into a shared module.
  • MEDIUM – Deep nesting & high branching – DecisionPanel.tsx and Sidebar.tsx have nesting depth 6; EventCard.tsx contains 99 branch points across 325 lines, making future changes error‑prone.

The Bottom Line

Claude‑Cowork delivers a functional Electron front‑end that makes Claude Code usable as a desktop assistant, with clear separation between UI, IPC, and persistence layers. However, the codebase suffers from architectural smells (cycles, duplicated types) and lacks basic production safeguards (license, tests, CI). It is suitable for teams willing to invest in refactoring and adding the missing DevOps scaffolding.