@jmoyers/harness 0.1.9 → 0.1.11

package/README.md

@@ -1,75 +1,40 @@
 # Harness
 
-Harness is a terminal-native workspace for running parallel coding agents on one machine, with project context, fast switching, and shared session state.
+Harness is a terminal-native workspace for running multiple coding-agent threads in parallel, without losing project context.
 
-Use it when you want to move faster than a single chat window: keep multiple threads active, review diffs quickly, and drive work from one keyboard-first control plane.
+It is built for people who want to move faster than a single chat window: implementation, review, and follow-up work can run side by side in one keyboard-first interface.
 
-## Why teams use it
+## What matters most
 
-- Run many agent threads in parallel across `codex`, `claude`, `cursor`, `terminal`, and `critique`.
-- Keep native CLI ergonomics in one keyboard-first workspace.
-- Keep long-running threads alive in the detached gateway so reconnects do not kill work.
-- Open a command palette with `ctrl+p`/`cmd+p`, live-filter registered actions, and execute context-aware thread/project/runtime controls.
-- Open a thread-scoped command palette from left-rail `[+ thread]` (same matcher/autocomplete as `ctrl+p`) to start/install agent CLIs per project.
-- Start in the Home pane by default, then jump to projects/threads from the left rail.
-- Open `Set a Theme` from the command palette to launch a second autocomplete picker of canonical OpenCode presets (plus a `default` reset option), with live preview while you navigate.
-- Open or create a GitHub pull request for the currently tracked project branch directly from the command palette.
+- Parallel threads across `codex`, `claude`, `cursor`, `terminal`, and `critique`.
+- One command palette (`ctrl+p` / `cmd+p`) to jump threads, run actions, and control workflow quickly.
+- Long-running work survives reconnects through a detached gateway.
+- Gateway control is resilient: lifecycle operations are lock-serialized per session, and missing stale records can be recovered automatically.
+- Fast left-rail navigation with automatic, readable thread titles.
+- Built-in GitHub actions (`Open GitHub`, `Show My Open Pull Requests`, `Open PR`, `Create PR`) from inside Harness.
 
 ## Demo
 
-![Harness multi-thread recording](https://raw.githubusercontent.com/jmoyers/harness/main/assets/poem-recording.gif)
+![Harness multi-thread recording](assets/harness.gif)
 
 ## Quick start
 
-### Prerequisites
+Prerequisites:
 
 - Bun `1.3.9+`
-- Rust toolchain
-- At least one installed agent CLI (`codex`, `claude`, `cursor`, or `critique`)
+- At least one agent CLI (`codex`, `claude`, `cursor`, or `critique`)
 
-### Install (npm package)
-
-> Note: Harness requires Bun. It does not work with Node.js alone.
+Install and run:
 
 ```bash
-# One-line bootstrap (installs missing Bun/Rust deps, then installs Harness globally)
+# Bootstrap install
 curl -fsSL https://raw.githubusercontent.com/jmoyers/harness/main/install.sh | bash
 
-# Run directly with bunx (no install needed)
+# Or run directly (no global install)
 bunx @jmoyers/harness@latest
 
 # Or install globally
 bun add -g --trust @jmoyers/harness
-
-# Upgrade an existing global install
-harness update
-# alias: harness upgrade
-```
-
-### Install (from source)
-
-```bash
-bun install
-bun link
-```
-
-### Uninstall
-
-```bash
-# Remove global Harness package
-bun remove --global @jmoyers/harness
-
-# Optional: remove workspace runtime artifacts (keeps harness.config.jsonc)
-if [ -n "${XDG_CONFIG_HOME:-}" ]; then
-  rm -rf "$XDG_CONFIG_HOME/harness/workspaces"
-else
-  rm -rf "$HOME/.harness/workspaces"
-fi
-```
-
-### Run
-
-```bash
 harness
 ```
 
@@ -79,121 +44,37 @@ Use a named session when you want isolated state:
 harness --session my-session
 ```
 
-## Common workflow
-
-1. Open Harness in your repo.
-2. Start parallel threads for implementation and review.
-3. Use the command palette (`ctrl+p` / `cmd+p`) to jump, run actions, and manage project context.
-4. Open the repo or PR actions from inside Harness when GitHub auth is available.
+For restart/load diagnostics, use a named session with a non-default gateway port so you do not disrupt your active workspace gateway.
 
-## Critique threads
+## Typical workflow
 
-- Available in the thread-scoped command palette (`[+ thread]`).
-- Runs with `--watch` by default.
-- Install actions are availability-aware and config-driven (`*.install.command`), opening a terminal thread to run the configured install command when a tool is missing.
-- Global command palette (`ctrl+p` / `cmd+p`) includes:
-  - `Critique AI Review: Unstaged Changes`
-  - `Critique AI Review: Staged Changes`
-  - `Critique AI Review: Current Branch vs Base`
-- These start a terminal thread and run `critique review ...`, preferring `claude` when available and otherwise using `opencode` when installed.
-- `mux.conversation.critique.open-or-create` is bound to `ctrl+g` by default.
+1. Open Harness in your repository.
+2. Start separate threads for implementation and review.
+3. Use `ctrl+p` / `cmd+p` to switch context and run project actions.
+4. Open or create a PR from the same workspace.
 
-`ctrl+g` behavior is project-aware:
+## User details
 
-- If a critique thread exists for the current project, it selects it.
-- If not, it creates and opens one in the main pane.
-
-`session.interrupt` is also surfaced as a mux keybinding action (`mux.conversation.interrupt`) so teams can bind a dedicated in-client thread interrupt shortcut without overloading quit semantics.
-
-## GitHub PR Integration
-
-When GitHub auth is available (`GITHUB_TOKEN` or an authenticated `gh` CLI), Harness can:
-
-- Detect the tracked branch for the active project and show `Open PR` (if an open PR exists) or `Create PR` in the command palette.
-- Continuously sync open PR CI/check status into the control-plane store for realtime clients.
-- If auth is unavailable, PR actions fail quietly and show a lightweight hint instead of surfacing hard errors.
-
-## API for Automation
-
-Harness exposes a typed realtime client for orchestrators, policy agents, and dashboards:
-
-```ts
-import { connectHarnessAgentRealtimeClient } from './src/control-plane/agent-realtime-api.ts';
-
-const client = await connectHarnessAgentRealtimeClient({
-  host: '127.0.0.1',
-  port: 7777,
-  subscription: { includeOutput: false },
-});
-
-client.on('session.status', ({ observed }) => {
-  console.log(observed.sessionId, observed.status);
-});
-
-await client.close();
-```
-
-Key orchestration calls are available in the same client:
-
-- `client.tasks.pull(...)`
-- `client.projects.status(projectId)`
-- `client.projects.settings.get(projectId)` / `client.projects.settings.update(projectId, update)`
-- `client.automation.getPolicy(...)` / `client.automation.setPolicy(...)`
+- Thread-scoped command palette (`[+ thread]`) can launch/install supported agent CLIs per project.
+- Critique review actions are available from the global palette and run in a terminal thread.
+- `ctrl+g` opens the project’s critique thread (or creates one if needed).
+- `ctrl` and `cmd` shortcut chords are mirrored in both directions when your terminal/OS does not reserve the combination.
+- Theme selection is built in (`Set a Theme`) with OpenCode-compatible presets and live preview.
+- API keys can be set directly from `ctrl+p` / `cmd+p` (`Set Anthropic API Key`, `Set OpenAI API Key`), with overwrite warning and paste-friendly entry.
+- `Create PR` uses either `GITHUB_TOKEN` or an authenticated `gh` CLI session.
 
 ## Configuration
 
-Runtime behavior is config-first via `harness.config.jsonc`.
-GitHub project/PR integration is enabled by default and configured under `github.*`.
-
-Example (install commands + critique defaults + hotkey override + OpenCode theme selection):
-
-```jsonc
-{
-  "codex": {
-    "install": {
-      "command": "bunx @openai/codex@latest"
-    }
-  },
-  "claude": {
-    "install": {
-      "command": "bunx @anthropic-ai/claude-code@latest"
-    }
-  },
-  "cursor": {
-    "install": {
-      "command": null
-    }
-  },
-  "critique": {
-    "launch": {
-      "defaultArgs": ["--watch"]
-    },
-    "install": {
-      "command": "bun add --global critique@latest"
-    }
-  },
-  "mux": {
-    "ui": {
-      "theme": {
-        "preset": "tokyonight",
-        "mode": "dark",
-        "customThemePath": null
-      }
-    },
-    "keybindings": {
-      "mux.conversation.critique.open-or-create": ["ctrl+g"]
-    }
-  }
-}
-```
+Runtime behavior is controlled by `harness.config.jsonc`.
 
-`mux.ui.theme.customThemePath` can point to any local JSON file that follows the OpenCode theme schema (`https://opencode.ai/theme.json`).
-Built-in presets now mirror the canonical OpenCode set (for example `aura`, `ayu`, `carbonfox`, `catppuccin`, `dracula`, `everforest`, `github`, `gruvbox`, `nightowl`, `nord`, `one-dark`, `opencode`, `tokyonight`, `vesper`, `zenburn`, and more), plus a special `default` picker option for the legacy default mux theme.
+When upgrading from a workspace-local `.harness`, Harness automatically migrates legacy config into the global config location if that global config is still uninitialized (missing, empty, or default template), then removes stale local `.harness` folders once migration targets are confirmed.
 
-## Documentation
+Common customizations:
 
-- `design.md` contains architecture and system design.
-- `agents.md` contains execution and quality rules.
+- Set install commands for `codex`, `claude`, `cursor`, and `critique`.
+- Configure critique launch defaults.
+- Customize keybindings.
+- Choose a theme preset or custom OpenCode-compatible theme file.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmoyers/harness",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "private": false,
   "repository": {
     "type": "git",
@@ -22,6 +22,7 @@
     "scripts/harness-core.ts",
     "scripts/harness-inspector.ts",
     "scripts/harness.ts",
+    "packages/harness-ai/src",
     "scripts/terminal-recording-gif-lib.ts",
     "scripts/require-bun.js",
     "native/ptyd/Cargo.lock",
@@ -53,6 +54,7 @@
     "codex:live:tail": "bun scripts/codex-live-tail.ts",
     "codex:live:snapshot": "bun scripts/codex-live-snapshot.ts",
     "control-plane:daemon": "bun scripts/control-plane-daemon.ts",
+    "gateway:stress": "bun scripts/gateway-restart-stress.ts",
     "terminal:parity": "bun scripts/terminal-parity.ts",
     "terminal:differential": "bun scripts/terminal-differential-checkpoints.ts",
     "previm:passthrough": "bun run build:ptyd",

package/packages/harness-ai/src/anthropic-client.ts

@@ -0,0 +1,99 @@
+import { parseAnthropicStreamChunk, type AnthropicStreamChunk } from './anthropic-protocol.ts';
+import { createSseEventStream } from './sse.ts';
+import type { HarnessAnthropicModel } from './types.ts';
+
+export interface AnthropicMessagesRequestBody {
+  readonly model: string;
+  readonly max_tokens?: number;
+  readonly temperature?: number;
+  readonly top_p?: number;
+  readonly stop_sequences?: string[];
+  readonly system?: string;
+  readonly messages: unknown[];
+  readonly tools?: unknown[];
+  readonly stream: true;
+}
+
+interface ParsedAnthropicStreamEvent {
+  readonly rawValue: unknown;
+  readonly chunk: AnthropicStreamChunk | null;
+  readonly parseError?: string;
+}
+
+interface AnthropicStreamResponse {
+  readonly requestBody: AnthropicMessagesRequestBody;
+  readonly responseHeaders: Headers;
+  readonly stream: ReadableStream<ParsedAnthropicStreamEvent>;
+}
+
+async function readErrorBody(response: Response): Promise<string> {
+  try {
+    return await response.text();
+  } catch {
+    return '';
+  }
+}
+
+export async function postAnthropicMessagesStream(
+  model: HarnessAnthropicModel,
+  requestBody: AnthropicMessagesRequestBody,
+  abortSignal?: AbortSignal,
+): Promise<AnthropicStreamResponse> {
+  const url = `${model.baseUrl}/messages`;
+  const requestInit: RequestInit = {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'x-api-key': model.apiKey,
+      'anthropic-version': '2023-06-01',
+      ...model.headers,
+    },
+    body: JSON.stringify(requestBody),
+  };
+  if (abortSignal !== undefined) {
+    requestInit.signal = abortSignal;
+  }
+
+  const response = await model.fetch(url, requestInit);
+
+  if (!response.ok) {
+    const errorBody = await readErrorBody(response);
+    throw new Error(`anthropic request failed (${response.status}): ${errorBody}`);
+  }
+
+  if (response.body === null) {
+    throw new Error('anthropic response body was empty');
+  }
+
+  const sseStream = createSseEventStream(response.body);
+  const parsedStream = sseStream.pipeThrough(
+    new TransformStream({
+      transform(event, controller) {
+        if (event.data === '[DONE]') {
+          return;
+        }
+
+        try {
+          const raw = JSON.parse(event.data) as unknown;
+          const parsed = parseAnthropicStreamChunk(raw);
+          controller.enqueue({
+            rawValue: raw,
+            chunk: parsed,
+          } satisfies ParsedAnthropicStreamEvent);
+        } catch (error) {
+          controller.enqueue({
+            rawValue: event.data,
+            chunk: null,
+            parseError: error instanceof Error ? error.message : String(error),
+          } satisfies ParsedAnthropicStreamEvent);
+        }
+      },
+    }),
+  );
+
+  return {
+    requestBody,
+    responseHeaders: response.headers,
+    stream: parsedStream,
+  };
+}