openwork 0.1.1-rc.4 → 0.1.1-rc.6

package/README.md

@@ -1,29 +1,23 @@
 # openwork
 
-[![CI](https://github.com/langchain-ai/openwork/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/openwork/actions/workflows/ci.yml)
-[![npm version](https://img.shields.io/npm/v/openwork.svg)](https://www.npmjs.com/package/openwork)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm][npm-badge]][npm-url] [![License: MIT][license-badge]][license-url]
 
-A tactical agent interface for [deepagentsjs](https://github.com/langchain-ai/deepagentsjs) - an opinionated harness for building deep agents with filesystem capabilities, planning, and subagent delegation.
+[npm-badge]: https://img.shields.io/npm/v/openwork.svg
+[npm-url]: https://www.npmjs.com/package/openwork
+[license-badge]: https://img.shields.io/badge/License-MIT-yellow.svg
+[license-url]: https://opensource.org/licenses/MIT
 
-![openwork screenshot](docs/screenshot.png)
-
-## Features
+A desktop interface for [deepagentsjs](https://github.com/langchain-ai/deepagentsjs) — an opinionated harness for building deep agents with filesystem capabilities planning, and subagent delegation.
 
-- **Chat Interface** - Stream conversations with your AI agent in real-time
-- **TODO Tracking** - Visual task list showing agent's planning progress
-- **Filesystem Browser** - See files the agent reads, writes, and edits
-- **Subagent Monitoring** - Track spawned subagents and their status
-- **Human-in-the-Loop** - Approve, edit, or reject sensitive tool calls
-- **Multi-Model Support** - Use Claude, GPT-4, Gemini, or local models
-- **Thread Persistence** - SQLite-backed conversation history
+![openwork screenshot](docs/screenshot.png)
 
-## Installation
+> [!CAUTION]
+> openwork gives AI agents direct access to your filesystem and the ability to execute shell commands. Always review tool calls before approving them, and only run in workspaces you trust.
 
-### npm (recommended)
+## Get Started
 
 ```bash
-# Run directly
+# Run directly with npx
 npx openwork
 
 # Or install globally
@@ -31,7 +25,7 @@ npm install -g openwork
 openwork
 ```
 
-Requires Node.js 18+. Electron is installed automatically as a dependency.
+Requires Node.js 18+.
 
 ### From Source
 
@@ -41,103 +35,21 @@ cd openwork
 npm install
 npm run dev
 ```
+Or configure them in-app via the settings panel.
 
-## Configuration
-
-### API Keys
-
-openwork supports multiple LLM providers. Set your API keys via:
-
-1. **Environment Variables** (recommended)
-   ```bash
-   export ANTHROPIC_API_KEY="sk-ant-..."
-   export OPENAI_API_KEY="sk-..."
-   export GOOGLE_API_KEY="..."
-   ```
-
-2. **In-App Settings** - Click the settings icon and enter your API keys securely.
-
-### Supported Models
-
-| Provider | Models |
-|----------|--------|
-| Anthropic | Claude Sonnet 4, Claude 3.5 Sonnet, Claude 3.5 Haiku |
-| OpenAI | GPT-4o, GPT-4o Mini |
-| Google | Gemini 2.0 Flash |
-
-## Architecture
-
-openwork is built with:
-
-- **Electron** - Cross-platform desktop framework
-- **React** - UI components with tactical/SCADA-inspired design
-- **deepagentsjs** - Agent harness with planning, filesystem, and subagents
-- **LangGraph** - State machine for agent orchestration
-- **SQLite** - Local persistence for threads and checkpoints
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                     Electron Main Process                    │
-├─────────────────────────────────────────────────────────────┤
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
-│  │ IPC Handlers│  │   SQLite    │  │   DeepAgentsJS      │ │
-│  │  - agent    │  │  - threads  │  │   - createAgent     │ │
-│  │  - threads  │  │  - runs     │  │   - checkpointer    │ │
-│  │  - models   │  │  - assists  │  │   - middleware      │ │
-│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
-└─────────────────────────────────────────────────────────────┘
-                              │
-                         IPC Bridge
-                              │
-┌─────────────────────────────────────────────────────────────┐
-│                    Electron Renderer Process                 │
-├─────────────────────────────────────────────────────────────┤
-│  ┌──────────┐  ┌─────────────────────┐  ┌───────────────┐  │
-│  │ Sidebar  │  │    Chat Interface   │  │  Right Panel  │  │
-│  │ - Threads│  │  - Messages         │  │  - TODOs      │  │
-│  │ - Model  │  │  - Tool Renderers   │  │  - Files      │  │
-│  │ - Config │  │  - Streaming        │  │  - Subagents  │  │
-│  └──────────┘  └─────────────────────┘  └───────────────┘  │
-└─────────────────────────────────────────────────────────────┘
-```
+## Supported Models
 
-## Development
-
-```bash
-# Install dependencies
-npm install
-
-# Start development server
-npm run dev
-
-# Build for production
-npm run build
-```
-
-## Releases
-
-To publish a new release:
-
-1. Create a git tag: `git tag v0.2.0`
-2. Push the tag: `git push origin v0.2.0`
-3. GitHub Actions will:
-   - Build the application
-   - Publish to npm
-   - Create a GitHub release
-
-## Design System
-
-openwork uses a tactical/SCADA-inspired design system optimized for:
-
-- **Information density** - Dense layouts for monitoring agent activity
-- **Status at a glance** - Color-coded status indicators (nominal, warning, critical)
-- **Dark mode only** - Reduced eye strain for extended sessions
-- **Monospace typography** - JetBrains Mono for data and code
+| Provider  | Models                                                            |
+| --------- | ----------------------------------------------------------------- |
+| Anthropic | Claude Opus 4.5, Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.1, Claude Sonnet 4 |
+| OpenAI    | GPT-5.2, GPT-5.1, o3, o3 Mini, o4 Mini, o1, GPT-4.1, GPT-4o       |
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development guidelines.
+We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+Report bugs via [GitHub Issues](https://github.com/langchain-ai/openwork/issues).
 
 ## License
 
-MIT License - see [LICENSE](LICENSE) for details.
+MIT — see [LICENSE](LICENSE) for details.

package/out/main/index.js

@@ -2,6 +2,7 @@
 const electron = require("electron");
 const path = require("path");
 const messages = require("@langchain/core/messages");
+const langgraph = require("@langchain/langgraph");
 const deepagents = require("deepagents");
 const Store = require("electron-store");
 const fs$1 = require("fs/promises");
@@ -11,6 +12,8 @@ const anthropic = require("@langchain/anthropic");
 const openai = require("@langchain/openai");
 const initSqlJs = require("sql.js");
 const langgraphCheckpoint = require("@langchain/langgraph-checkpoint");
+const node_child_process = require("node:child_process");
+const node_crypto = require("node:crypto");
 const uuid = require("uuid");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -817,6 +820,139 @@ class SqlJsSaver extends langgraphCheckpoint.BaseCheckpointSaver {
     }
   }
 }
+class LocalSandbox extends deepagents.FilesystemBackend {
+  /** Unique identifier for this sandbox instance */
+  id;
+  timeout;
+  maxOutputBytes;
+  env;
+  workingDir;
+  constructor(options = {}) {
+    super({
+      rootDir: options.rootDir,
+      virtualMode: options.virtualMode,
+      maxFileSizeMb: options.maxFileSizeMb
+    });
+    this.id = `local-sandbox-${node_crypto.randomUUID().slice(0, 8)}`;
+    this.timeout = options.timeout ?? 12e4;
+    this.maxOutputBytes = options.maxOutputBytes ?? 1e5;
+    this.env = options.env ?? { ...process.env };
+    this.workingDir = options.rootDir ?? process.cwd();
+  }
+  /**
+   * Execute a shell command in the workspace directory.
+   *
+   * @param command - Shell command string to execute
+   * @returns ExecuteResponse with combined output, exit code, and truncation flag
+   *
+   * @example
+   * ```typescript
+   * const result = await sandbox.execute('echo "Hello World"');
+   * // result.output: "Hello World\n"
+   * // result.exitCode: 0
+   * // result.truncated: false
+   * ```
+   */
+  async execute(command) {
+    if (!command || typeof command !== "string") {
+      return {
+        output: "Error: Shell tool expects a non-empty command string.",
+        exitCode: 1,
+        truncated: false
+      };
+    }
+    return new Promise((resolve) => {
+      const outputParts = [];
+      let totalBytes = 0;
+      let truncated = false;
+      let resolved = false;
+      const isWindows = process.platform === "win32";
+      const shell = isWindows ? "cmd.exe" : "/bin/sh";
+      const shellArgs = isWindows ? ["/c", command] : ["-c", command];
+      const proc = node_child_process.spawn(shell, shellArgs, {
+        cwd: this.workingDir,
+        env: this.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const timeoutId = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          proc.kill("SIGTERM");
+          setTimeout(() => proc.kill("SIGKILL"), 1e3);
+          resolve({
+            output: `Error: Command timed out after ${(this.timeout / 1e3).toFixed(1)} seconds.`,
+            exitCode: null,
+            truncated: false
+          });
+        }
+      }, this.timeout);
+      proc.stdout.on("data", (data) => {
+        if (truncated) return;
+        const chunk = data.toString();
+        const newTotal = totalBytes + chunk.length;
+        if (newTotal > this.maxOutputBytes) {
+          const remaining = this.maxOutputBytes - totalBytes;
+          if (remaining > 0) {
+            outputParts.push(chunk.slice(0, remaining));
+          }
+          truncated = true;
+          totalBytes = this.maxOutputBytes;
+        } else {
+          outputParts.push(chunk);
+          totalBytes = newTotal;
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        if (truncated) return;
+        const chunk = data.toString();
+        const prefixedLines = chunk.split("\n").filter((line) => line.length > 0).map((line) => `[stderr] ${line}`).join("\n");
+        if (prefixedLines.length === 0) return;
+        const withNewline = prefixedLines + (chunk.endsWith("\n") ? "\n" : "");
+        const newTotal = totalBytes + withNewline.length;
+        if (newTotal > this.maxOutputBytes) {
+          const remaining = this.maxOutputBytes - totalBytes;
+          if (remaining > 0) {
+            outputParts.push(withNewline.slice(0, remaining));
+          }
+          truncated = true;
+          totalBytes = this.maxOutputBytes;
+        } else {
+          outputParts.push(withNewline);
+          totalBytes = newTotal;
+        }
+      });
+      proc.on("close", (code, signal) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutId);
+        let output = outputParts.join("");
+        if (truncated) {
+          output += `
+
+... Output truncated at ${this.maxOutputBytes} bytes.`;
+        }
+        if (!output.trim()) {
+          output = "<no output>";
+        }
+        resolve({
+          output,
+          exitCode: signal ? null : code,
+          truncated
+        });
+      });
+      proc.on("error", (err) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutId);
+        resolve({
+          output: `Error: Failed to execute command: ${err.message}`,
+          exitCode: 1,
+          truncated: false
+        });
+      });
+    });
+  }
+}
 const BASE_SYSTEM_PROMPT = `You are an AI assistant that helps users with various tasks including coding, research, and analysis.
 
 # Core Behavior
@@ -871,11 +1007,27 @@ When delegating to subagents:
 - read_file: Read file contents
 - edit_file: Replace exact strings in files (must read first, provide unique old_string)
 - write_file: Create or overwrite files
-- ls: List directory contents (use "/" for workspace root)
+- ls: List directory contents
 - glob: Find files by pattern (e.g., "**/*.py")
 - grep: Search file contents
 
-All file paths are virtual paths relative to the workspace root, starting with /.
+All file paths should use fully qualified absolute system paths (e.g., /Users/name/project/src/file.ts).
+
+### Shell Tool
+- execute: Run shell commands in the workspace directory
+
+The execute tool runs commands directly on the user's machine. Use it for:
+- Running scripts, tests, and builds (npm test, python script.py, make)
+- Git operations (git status, git diff, git commit)
+- Installing dependencies (npm install, pip install)
+- System commands (which, env, pwd)
+
+**Important:**
+- All execute commands require user approval before running
+- Commands run in the workspace root directory
+- Avoid using shell for file reading (use read_file instead)
+- Avoid using shell for file searching (use grep/glob instead)
+- When running non-trivial commands, briefly explain what they do
 
 ## Code References
 When referencing code, use format: \`file_path:line_number\`
@@ -915,11 +1067,11 @@ function getSystemPrompt(workspacePath) {
 ### File System and Paths
 
 **IMPORTANT - Path Handling:**
-- All file paths use virtual paths starting with \`/\` (the workspace root)
-- \`/\` refers to the workspace root directory
-- Example: \`/src/index.ts\`, \`/README.md\`, \`/package.json\`
-- To list the workspace root, use \`ls("/")\`
-- Never use fully qualified system paths like \`${workspacePath}/...\`
+- All file paths use fully qualified absolute system paths
+- The workspace root is: \`${workspacePath}\`
+- Example: \`${workspacePath}/src/index.ts\`, \`${workspacePath}/README.md\`
+- To list the workspace root, use \`ls("${workspacePath}")\`
+- Always use full absolute paths for all file operations
 `;
   return workingDirSection + BASE_SYSTEM_PROMPT;
 }
@@ -970,18 +1122,37 @@ async function createAgentRuntime(options) {
   console.log("[Runtime] Model instance created:", typeof model);
   const checkpointer2 = await getCheckpointer();
   console.log("[Runtime] Checkpointer ready");
-  const backend = new deepagents.FilesystemBackend({
+  const backend = new LocalSandbox({
     rootDir: workspacePath,
-    virtualMode: true
+    virtualMode: false,
+    // Use absolute system paths for consistency with shell commands
+    timeout: 12e4,
+    // 2 minutes
+    maxOutputBytes: 1e5
+    // ~100KB
   });
   const systemPrompt = getSystemPrompt(workspacePath);
+  const filesystemSystemPrompt = `You have access to a filesystem. All file paths use fully qualified absolute system paths.
+
+- ls: list files in a directory (e.g., ls("${workspacePath}"))
+- read_file: read a file from the filesystem
+- write_file: write to a file in the filesystem
+- edit_file: edit a file in the filesystem
+- glob: find files matching a pattern (e.g., "**/*.py")
+- grep: search for text within files
+
+The workspace root is: ${workspacePath}`;
   const agent = deepagents.createDeepAgent({
     model,
     checkpointer: checkpointer2,
     backend,
-    systemPrompt
+    systemPrompt,
+    // Custom filesystem prompt for absolute paths (requires deepagents update)
+    filesystemSystemPrompt,
+    // Require human approval for all shell commands
+    interruptOn: { execute: true }
   });
-  console.log("[Runtime] Deep agent created with FilesystemBackend at:", workspacePath);
+  console.log("[Runtime] Deep agent created with LocalSandbox at:", workspacePath);
   return agent;
 }
 let db = null;
@@ -1222,19 +1393,125 @@ function registerAgentHandlers(ipcMain) {
       }
     }
   );
-  ipcMain.handle(
+  ipcMain.on(
+    "agent:resume",
+    async (event, {
+      threadId,
+      command
+    }) => {
+      const channel = `agent:stream:${threadId}`;
+      const window = electron.BrowserWindow.fromWebContents(event.sender);
+      console.log("[Agent] Received resume request:", { threadId, command });
+      if (!window) {
+        console.error("[Agent] No window found for resume");
+        return;
+      }
+      const thread = getThread(threadId);
+      const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
+      const workspacePath = metadata.workspacePath;
+      if (!workspacePath) {
+        window.webContents.send(channel, {
+          type: "error",
+          error: "Workspace path is required"
+        });
+        return;
+      }
+      const existingController = activeRuns.get(threadId);
+      if (existingController) {
+        existingController.abort();
+        activeRuns.delete(threadId);
+      }
+      const abortController = new AbortController();
+      activeRuns.set(threadId, abortController);
+      try {
+        const agent = await createAgentRuntime({ workspacePath });
+        const config = {
+          configurable: { thread_id: threadId },
+          signal: abortController.signal,
+          streamMode: ["messages", "values"],
+          recursionLimit: 1e3
+        };
+        const decisionType = command?.resume?.decision || "approve";
+        const resumeValue = { decisions: [{ type: decisionType }] };
+        const stream = await agent.stream(new langgraph.Command({ resume: resumeValue }), config);
+        for await (const chunk of stream) {
+          if (abortController.signal.aborted) break;
+          const [mode, data] = chunk;
+          window.webContents.send(channel, {
+            type: "stream",
+            mode,
+            data: JSON.parse(JSON.stringify(data))
+          });
+        }
+        window.webContents.send(channel, { type: "done" });
+      } catch (error) {
+        console.error("[Agent] Resume error:", error);
+        window.webContents.send(channel, {
+          type: "error",
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      } finally {
+        activeRuns.delete(threadId);
+      }
+    }
+  );
+  ipcMain.on(
     "agent:interrupt",
-    async (_event, { threadId, decision }) => {
+    async (event, { threadId, decision }) => {
+      const channel = `agent:stream:${threadId}`;
+      const window = electron.BrowserWindow.fromWebContents(event.sender);
+      if (!window) {
+        console.error("[Agent] No window found for interrupt response");
+        return;
+      }
       const thread = getThread(threadId);
       const metadata = thread?.metadata ? JSON.parse(thread.metadata) : {};
       const workspacePath = metadata.workspacePath;
       if (!workspacePath) {
-        throw new Error("Workspace path is required");
+        window.webContents.send(channel, {
+          type: "error",
+          error: "Workspace path is required"
+        });
+        return;
       }
-      const agent = await createAgentRuntime({ workspacePath });
-      const config = { configurable: { thread_id: threadId } };
-      if (decision.type === "approve") {
-        await agent.invoke(null, config);
+      const existingController = activeRuns.get(threadId);
+      if (existingController) {
+        existingController.abort();
+        activeRuns.delete(threadId);
+      }
+      const abortController = new AbortController();
+      activeRuns.set(threadId, abortController);
+      try {
+        const agent = await createAgentRuntime({ workspacePath });
+        const config = {
+          configurable: { thread_id: threadId },
+          signal: abortController.signal,
+          streamMode: ["messages", "values"],
+          recursionLimit: 1e3
+        };
+        if (decision.type === "approve") {
+          const stream = await agent.stream(null, config);
+          for await (const chunk of stream) {
+            if (abortController.signal.aborted) break;
+            const [mode, data] = chunk;
+            window.webContents.send(channel, {
+              type: "stream",
+              mode,
+              data: JSON.parse(JSON.stringify(data))
+            });
+          }
+          window.webContents.send(channel, { type: "done" });
+        } else if (decision.type === "reject") {
+          window.webContents.send(channel, { type: "done" });
+        }
+      } catch (error) {
+        console.error("[Agent] Interrupt error:", error);
+        window.webContents.send(channel, {
+          type: "error",
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      } finally {
+        activeRuns.delete(threadId);
       }
     }
   );

package/out/preload/index.js

@@ -21,17 +21,14 @@ const api = {
   agent: {
     // Send message and receive events via callback
     invoke: (threadId, message, onEvent) => {
-      console.log("[Preload] invoke() called", { threadId, message: message.substring(0, 50) });
       const channel = `agent:stream:${threadId}`;
       const handler = (_, data) => {
-        console.log("[Preload] Received event:", data.type);
         onEvent(data);
         if (data.type === "done" || data.type === "error") {
           electron.ipcRenderer.removeListener(channel, handler);
         }
       };
       electron.ipcRenderer.on(channel, handler);
-      console.log("[Preload] Sending agent:invoke IPC");
       electron.ipcRenderer.send("agent:invoke", { threadId, message });
       return () => {
         electron.ipcRenderer.removeListener(channel, handler);
@@ -39,10 +36,8 @@ const api = {
     },
     // Stream agent events for useStream transport
     streamAgent: (threadId, message, command, onEvent) => {
-      console.log("[Preload] streamAgent() called", { threadId, message: message.substring(0, 50) });
       const channel = `agent:stream:${threadId}`;
       const handler = (_, data) => {
-        console.log("[Preload] Received stream event:", data.type);
         onEvent(data);
         if (data.type === "done" || data.type === "error") {
           electron.ipcRenderer.removeListener(channel, handler);
@@ -50,18 +45,27 @@ const api = {
       };
       electron.ipcRenderer.on(channel, handler);
       if (command) {
-        console.log("[Preload] Sending agent:resume IPC");
         electron.ipcRenderer.send("agent:resume", { threadId, command });
       } else {
-        console.log("[Preload] Sending agent:invoke IPC");
         electron.ipcRenderer.send("agent:invoke", { threadId, message });
       }
       return () => {
         electron.ipcRenderer.removeListener(channel, handler);
       };
     },
-    interrupt: (threadId, decision) => {
-      return electron.ipcRenderer.invoke("agent:interrupt", { threadId, decision });
+    interrupt: (threadId, decision, onEvent) => {
+      const channel = `agent:stream:${threadId}`;
+      const handler = (_, data) => {
+        onEvent?.(data);
+        if (data.type === "done" || data.type === "error") {
+          electron.ipcRenderer.removeListener(channel, handler);
+        }
+      };
+      electron.ipcRenderer.on(channel, handler);
+      electron.ipcRenderer.send("agent:interrupt", { threadId, decision });
+      return () => {
+        electron.ipcRenderer.removeListener(channel, handler);
+      };
     },
     cancel: (threadId) => {
       return electron.ipcRenderer.invoke("agent:cancel", { threadId });