@jmoyers/harness 0.1.8 → 0.1.10

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 PR actions (`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,120 +44,33 @@ 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: 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).
+- Theme selection is built in (`Set a Theme`) with OpenCode-compatible presets and live preview.
+- PR actions use 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"]
-    }
-  }
-}
-```
-
-`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.
+Runtime behavior is controlled by `harness.config.jsonc`.
 
-## 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.8",
+  "version": "0.1.10",
   "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",
@@ -77,6 +79,8 @@
     "test": "bun run build:ptyd && bun test",
     "test:integration:codex-status": "bun scripts/integration-codex-status-sequence.ts",
     "test:integration:codex-status:long": "bun scripts/integration-codex-status-sequence.ts --timeout-ms 180000 --prompt \"Write three short poems titled Dawn, Voltage, and Orbit. Before each poem, perform one repository inspection action and include one factual line from that action. Use at least three total tool actions and do not edit any files.\"",
+    "test:integration:agent-prompts": "bun scripts/integration-agent-prompt-parity.ts",
+    "test:integration:agent-prompts:long": "bun scripts/integration-agent-prompt-parity.ts --timeout-ms 180000",
     "smoke:harness-ai": "bun scripts/harness-ai-smoke.ts",
     "smoke:harness-ai:parity": "bun scripts/harness-ai-parity-smoke.mts",
     "test:coverage": "bun run build:ptyd && bun test --coverage --coverage-reporter=lcov --coverage-dir .harness/coverage-bun && bun run coverage:check",

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,
+  };
+}