background-agents 0.1.1 → 0.1.2

package/README.md

@@ -1,34 +1,42 @@
-# Coding Agents SDK
+# Background Agents SDK
 
-A unified TypeScript interface for AI coding agents—Claude, Codex, Gemini, and OpenCode. Commands run in secure [Daytona](https://daytona.io) sandboxes by default, with real-time PTY streaming.
+A TypeScript SDK for running AI coding agents (Claude, Codex, Gemini, Goose, OpenCode, Pi) in secure [Daytona](https://daytona.io) sandboxes. Designed for background execution with polling-based event streaming.
 
 ```typescript
 import { Daytona } from "@daytonaio/sdk"
 import { createSession } from "background-agents"
 
 const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
-const sandbox = await daytona.create({ envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY } })
-const session = await createSession("claude", { sandbox })
+const sandbox = await daytona.create()
 
-for await (const event of session.run("Hello!")) {
-  if (event.type === "token") process.stdout.write(event.text)
-  if (event.type === "end") break
+const session = await createSession("claude", {
+  sandbox,
+  env: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY }
+})
+
+await session.start("Refactor the auth module")
+
+// Poll for events
+while (await session.isRunning()) {
+  const { events } = await session.getEvents()
+  for (const event of events) {
+    if (event.type === "token") process.stdout.write(event.text)
+  }
+  await new Promise(r => setTimeout(r, 1000))
 }
 
 await sandbox.delete()
 ```
 
-Same pattern for any provider: create a sandbox, create a session, stream events, then tear down. Swap the provider name and env keys as needed.
-
 ---
 
 ## Features
 
-- **Secure by default** — Execution runs in isolated Daytona sandboxes
-- **Real-time streaming** — PTY-based streaming for live token output
-- **Unified API** — One interface for [Claude](https://docs.anthropic.com/en/docs/claude-code), [Codex](https://developers.openai.com/codex/cli), [Gemini](https://geminicli.com/docs/), and [OpenCode](https://opencode.ai/docs/)
-- **Zero-friction setup** — Provider CLI is installed when you create a session (`skipInstall: true` to skip). Env and Codex login run on every `run()`.
-- **Session persistence** — Resume conversations across runs
+- **Secure sandboxed execution** — Agents run in isolated Daytona sandboxes
+- **Background execution** — Start agents, poll for events, survive restarts
+- **Unified API** — One interface for [Claude](https://docs.anthropic.com/en/docs/claude-code), [Codex](https://developers.openai.com/codex/cli), [Gemini](https://geminicli.com/docs/), [Goose](https://block.github.io/goose/docs/), [OpenCode](https://opencode.ai/docs/), and [Pi](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent)
+- **Zero-friction setup** — Provider CLI auto-installed in sandbox
+- **Session persistence** — Resume conversations across runs and restarts
 
 ---
 
@@ -36,16 +44,29 @@ Same pattern for any provider: create a sandbox, create a session, stream events
 
 | Provider | Status | Auth |
 |----------|--------|------|
-| [Claude](https://docs.anthropic.com/en/docs/claude-code) | ✅ | `ANTHROPIC_API_KEY` |
+| [Claude](https://docs.anthropic.com/en/docs/claude-code) | ✅ | `ANTHROPIC_API_KEY` or `CLAUDE_CODE_CREDENTIALS` |
 | [Codex](https://developers.openai.com/codex/cli) | ✅ | `OPENAI_API_KEY` |
+| [Goose](https://block.github.io/goose/docs/) | ✅ | Provider-specific (e.g. `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`) |
 | [OpenCode](https://opencode.ai/docs/) | ✅ | Provider-specific (e.g. `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GOOGLE_API_KEY`) |
-| [Gemini](https://geminicli.com/docs/) | 🚧 | `GOOGLE_API_KEY` |
+| [Gemini](https://geminicli.com/docs/) | ✅ | `GEMINI_API_KEY` |
+| [Pi](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) | ✅ | Provider-specific (e.g. `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`) |
+
+### CLI reference commands
+
+| Provider | CLI Command |
+|----------|-------------|
+| Claude | `claude -p --output-format stream-json --verbose --dangerously-skip-permissions "prompt"` |
+| Codex | `codex exec --json --skip-git-repo-check --yolo "prompt"` |
+| Goose | `goose run --output-format stream-json --text "prompt"` |
+| OpenCode | `opencode run --format json --variant medium "prompt"` |
+| Gemini | `gemini --output-format stream-json --yolo -p "prompt"` |
+| Pi | `pi --mode json -p "prompt"` |
 
 ---
 
 ## Prerequisites
 
-A [Daytona](https://daytona.io) API key (or [run locally](#local-mode-dangerous) without a sandbox).
+A [Daytona](https://daytona.io) API key for secure sandboxed execution.
 
 ```bash
 export DAYTONA_API_KEY=dtn_your_api_key
@@ -56,125 +77,87 @@ export DAYTONA_API_KEY=dtn_your_api_key
 ## Installation
 
 ```bash
-npm install background-agents
-```
-
-For sandboxed execution, also install the Daytona SDK:
-
-```bash
-npm install @daytonaio/sdk
-```
-
-**Next.js:** Merge the SDK's Next config so native deps (e.g. `ssh2` / `cpu-features`) are not bundled:
-
-```js
-// next.config.js or next.config.mjs
-import codeagentsdk from 'background-agents/next.config'
-export default { ...codeagentsdk, ...yourConfig }
+npm install background-agents @daytonaio/sdk
 ```
 
 ---
 
 ## Quick start
 
-**1. Create a sandbox** — Pass provider API keys via the sandbox; the SDK does not read your host env.
-
 ```typescript
 import { Daytona } from "@daytonaio/sdk"
 import { createSession } from "background-agents"
 
+// 1. Create sandbox
 const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
-const sandbox = await daytona.create({
-  envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY },
-})
-```
+const sandbox = await daytona.create()
 
-**2. Create a session** — The provider CLI is installed in the sandbox (unless `skipInstall: true`).
-
-```typescript
+// 2. Create session
 const session = await createSession("claude", {
   sandbox,
+  env: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY },
   model: "sonnet",
-  timeout: 120,
   systemPrompt: "You are a helpful coding assistant.",
 })
-```
 
-**3. Stream responses**
+// 3. Start a task
+await session.start("Create a hello world script")
 
-```typescript
-for await (const event of session.run("Hello!")) {
-  if (event.type === "token") process.stdout.write(event.text)
-  if (event.type === "tool_start") console.log(`\n[Tool: ${event.name}]`)
-  if (event.type === "end") break
+// 4. Poll for events
+while (await session.isRunning()) {
+  const { events } = await session.getEvents()
+  for (const event of events) {
+    if (event.type === "token") process.stdout.write(event.text)
+    if (event.type === "tool_start") console.log(`\n[Tool: ${event.name}]`)
+    if (event.type === "end") console.log("\nDone.")
+  }
+  await new Promise(r => setTimeout(r, 1000))
 }
-```
-
-**4. Cleanup**
 
-```typescript
+// 5. Cleanup
 await sandbox.delete()
 ```
 
-**Optional: Git workflow** — Use the [Daytona Git SDK](https://www.daytona.io/docs/en/typescript-sdk/git/) to clone before and push after:
-
-```typescript
-const repoPath = "workspace/repo"
-await sandbox.git.clone("https://github.com/user/repo.git", repoPath)
-// ... run session ...
-await sandbox.git.push(repoPath)
-```
-
 ---
 
-## Full example
+## Restart-tolerant workflows
 
-End-to-end example with event handling and cleanup:
+The SDK is designed for long-running tasks that may outlive your server process. Persist `sandbox.id` and `session.id`, then reattach after restart.
 
 ```typescript
 import { Daytona } from "@daytonaio/sdk"
-import { createSession } from "background-agents"
+import { createSession, getSession } from "background-agents"
 
-async function main() {
-  const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
-  const sandbox = await daytona.create({
-    envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY },
-  })
-
-  try {
-    const session = await createSession("claude", { sandbox })
-
-    for await (const event of session.run("List /tmp then write /tmp/out.txt with 'done'")) {
-      switch (event.type) {
-        case "token":
-          process.stdout.write(event.text)
-          break
-        case "tool_start":
-          console.log("\n🛠️", event.name, event.input ?? "")
-          break
-        case "end":
-          console.log("\nDone.")
-          break
-      }
-    }
-  } finally {
-    await sandbox.delete()
-  }
-}
+const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY! })
+const sandbox = await daytona.create()
 
-main()
-```
+// Start a task
+const session = await createSession("claude", {
+  sandbox,
+  env: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY! },
+  model: "sonnet",
+})
+await session.start("Do a long-running refactor...")
+
+// Persist these IDs, then exit
+const sandboxId = sandbox.id
+const sessionId = session.id  // Save this to reattach later
+
+// --- After restart ---
 
-### CLI commands (reference)
+// Reattach to existing session
+const sandbox = await daytona.get(sandboxId)
+const session = await getSession(sessionId, { sandbox })
 
-Each provider is invoked via its CLI. Optional flags in brackets.
+// Continue polling
+const { events, running } = await session.getEvents()
+for (const event of events) {
+  if (event.type === "token") process.stdout.write(event.text)
+}
 
-| Provider | Command |
-|----------|---------|
-| **Claude** | `claude -p --output-format stream-json --verbose --dangerously-skip-permissions` `[--model <m>] [--resume <id>]` `<prompt>` |
-| **Codex** | `codex exec --json --skip-git-repo-check --yolo` `[--model <m>] [resume <id>]` `<prompt>` |
-| **OpenCode** | `opencode run --format json --variant medium -m <model>` `[-s <id>]` `<prompt>` (via `bash -lc "…"`) |
-| **Gemini** | `gemini -p --output-format stream-json --yolo` `[--model <m>] [--resume <id>]` `<prompt>` |
+// Cancel if needed
+await session.cancel()
+```
 
 ---
 
@@ -182,180 +165,108 @@ Each provider is invoked via its CLI. Optional flags in brackets.
 
 ### `createSession(provider, options)`
 
-Creates a session with the given provider and options (e.g. `sandbox`, `model`, `timeout`). Installs the provider CLI in the sandbox before returning unless `skipInstall: true`. Codex login runs automatically on each `run()` when needed.
+Creates a session. The provider CLI is installed automatically.
 
 ```typescript
 const session = await createSession("claude", {
-  sandbox,
-  model: "sonnet",
-  timeout: 120,
+  sandbox,                                    // Daytona sandbox
+  env: { ANTHROPIC_API_KEY: "sk-..." },      // Environment variables
+  model: "sonnet",                            // Optional: model name
+  systemPrompt: "You are helpful.",           // Optional: system prompt
 })
 ```
 
-### `session.run(prompt)`
+### `session.start(prompt)`
 
-Returns an async iterable of events. Stream and handle them uniformly across providers.
+Starts a background task. Returns immediately with process info.
 
 ```typescript
-for await (const event of session.run("Hello")) {
-  // event.type: "session" | "token" | "tool_start" | "tool_delta" | "tool_end" | "end" | "agent_crashed"
-}
+const { pid, outputFile } = await session.start("Your task here")
 ```
 
-### Event stream
+### `session.getEvents()`
 
-| Event | Description | Fields |
-|-------|-------------|--------|
-| `session` | Session started (for resumption) | `id: string` |
-| `token` | Streamed assistant text | `text: string` |
-| `tool_start` | Tool invoked | `name: string`, `input?: unknown` |
-| `tool_delta` | Streaming tool input | `text: string` |
-| `tool_end` | Tool finished | `output?: string` |
-| `end` | Turn complete | — |
-| `agent_crashed` | Process exited without completing (crash/kill) | `message?: string`, `output?: string` (raw tail of stdout/stderr; often not JSONL) |
+Polls for new events since last call.
 
 ```typescript
-type Event =
-  | { type: "session"; id: string }
-  | { type: "token"; text: string }
-  | { type: "tool_start"; name: string; input?: unknown }
-  | { type: "tool_delta"; text: string }
-  | { type: "tool_end"; output?: string }
-  | { type: "end" }
-  | { type: "agent_crashed"; message?: string; output?: string }
+const { events, running } = await session.getEvents()
+// events: Event[] - new events since last poll
+// running: boolean - true if agent is still running
 ```
 
-### Normalized tool names
+### `session.isRunning()`
 
-Tool names are normalized across providers. Each has a defined `tool_start` input and `tool_end` output.
+Returns `true` while the agent is running.
 
-| Tool | `tool_start` input | Claude | Codex | OpenCode |
-|------|--------------------|:------:|:-----:|:--------:|
-| **write** | `{ file_path, content?, kind }` | ✅ | ✅ | ✅ |
-| **read** | `{ file_path }` | ✅ | — | ✅ |
-| **edit** | `{ file_path, ... }` | ✅ | — | ✅ |
-| **glob** | `{ pattern }` | ✅ | — | ✅ |
-| **grep** | `{ pattern, path? }` | ✅ | — | ✅ |
-| **shell** | `{ command, description? }` | ✅ | ✅ | ✅ |
+### `session.cancel()`
 
----
+Kills the running agent process.
 
-## Model selection
+### `getSession(sessionId, options)`
 
-Set `model` when creating the session.
-
-| Provider | Example | Docs |
-|----------|---------|------|
-| **Claude** | `model: "sonnet"` or `"opus"`, `"haiku"` | [Claude Code models](https://code.claude.com/docs/en/model-config) |
-| **Codex** | `model: "gpt-4o"` or `"o1"`, `"o3"` | [Codex CLI models](https://developers.openai.com/codex/models) |
-| **OpenCode** | `model: "openai/gpt-4o"` (provider/model) | [OpenCode models](https://opencode.ai/docs/models/) |
-| **Gemini** | `model: "gemini-2.0-flash"` or `"gemini-1.5-pro"` | [Gemini CLI model](https://geminicli.com/docs/cli/model) |
-
----
-
-## Sandboxed background sessions
-
-For long-running or restart-tolerant flows: start the agent in the sandbox, write the event stream to log files there, and poll with **getEvents**. All state except the session ID lives in the sandbox.
-
-- **Session ID** — One UUID per background session; host stores only this.
-- **start()** — Returns immediately with `{ executionId, pid, outputFile }`; the agent runs in the background.
-- **isRunning()** — True while the turn is in progress, false after.
-- **Crash detection** — If the process exits without completing, **getEvents** returns an `agent_crashed` event. You can treat it like `end` to stop polling and show a warning.
-
-**Example:** start, persist `sandboxId` and `backgroundSessionId`, then reattach after a restart.
+Reattaches to an existing session by ID.
 
 ```typescript
-import { Daytona } from "@daytonaio/sdk"
-import { createBackgroundSession, getBackgroundSession } from "background-agents"
-
-const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY! })
-const sandbox = await daytona.create({
-  envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY! },
-})
-
-const bgSession = await createBackgroundSession("claude", {
-  sandbox,
-  model: "sonnet",
-  // Optional: per-session system prompt (applied once, persisted across turns).
-  systemPrompt: "You are a helpful coding assistant.",
-})
-await bgSession.start("Do a long-running refactor...")
-// Persist sandbox.id and bgSession.id, then exit.
-
-// --- After restart ---
-const sandboxAgain = await daytona.get(sandboxId)
-const bgAgain = await getBackgroundSession({
-  sandbox: sandboxAgain,
-  backgroundSessionId,
-  // Re-apply session options so the provider is recreated with the same model
-  // and system prompt when reattaching.
-  model: "sonnet",
-  systemPrompt: "You are a helpful coding assistant.",
-})
-
-async function poll() {
-  const { events } = await bgAgain.getEvents()
-  for (const e of events) {
-    if (e.type === "token") process.stdout.write(e.text)
-    else if (e.type === "tool_start") console.log("[Tool]", e.name)
-  }
-  if (!(await bgAgain.isRunning())) return
-  setTimeout(poll, 2000)
-}
-poll()
-
-await bgAgain.cancel() // kill agent in sandbox (no-op if stopped)
+const session = await getSession(
+  sessionId,   // session.id from createSession()
+  { sandbox }
+)
 ```
 
 ---
 
-## Local mode (dangerous)
+## Event types
 
-Runs the provider CLI on your machine instead of a sandbox. Only use when you fully trust the code.
+| Event | Description | Fields |
+|-------|-------------|--------|
+| `session` | Session started | `id: string` |
+| `token` | Streamed text | `text: string` |
+| `tool_start` | Tool invoked | `name: string`, `input?: unknown` |
+| `tool_delta` | Tool streaming | `text: string` |
+| `tool_end` | Tool finished | `output?: string` |
+| `end` | Task complete | `error?: string` |
+| `agent_crashed` | Process crashed | `message?: string`, `output?: string` |
 
 ```typescript
-const session = await createSession("claude", { dangerouslyAllowLocalExecution: true })
-for await (const event of session.run("Hello")) {
-  if (event.type === "token") process.stdout.write(event.text)
-}
+type Event =
+  | { type: "session"; id: string }
+  | { type: "token"; text: string }
+  | { type: "tool_start"; name: string; input?: unknown }
+  | { type: "tool_delta"; text: string }
+  | { type: "tool_end"; output?: string }
+  | { type: "end"; error?: string }
+  | { type: "agent_crashed"; message?: string; output?: string }
 ```
 
 ---
 
-## Interactive REPL
-
-```bash
-# Claude (default)
-DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npx tsx scripts/repl.ts
-
-# Other providers
-npx tsx scripts/repl.ts --provider codex   # OPENAI_API_KEY
-npx tsx scripts/repl.ts --provider opencode
-npx tsx scripts/repl.ts --provider gemini  # GEMINI_API_KEY (or GOOGLE_API_KEY)
-
-# Polling-based (background session)
-DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npx tsx scripts/repl-polling.ts
-```
+## Model selection
 
-```bash
-npx tsx scripts/repl.ts -h   # help; providers: claude, codex, opencode, gemini
-```
+| Provider | Example | Docs |
+|----------|---------|------|
+| **Claude** | `model: "sonnet"` | [Claude Code models](https://code.claude.com/docs/en/model-config) |
+| **Codex** | `model: "gpt-4o"` | [Codex CLI models](https://developers.openai.com/codex/models) |
+| **Goose** | `model: "gpt-4o"` | [Goose providers](https://block.github.io/goose/docs/getting-started/providers) |
+| **OpenCode** | `model: "openai/gpt-4o"` | [OpenCode models](https://opencode.ai/docs/models/) |
+| **Gemini** | `model: "gemini-2.0-flash"` | [Gemini CLI model](https://geminicli.com/docs/cli/model) |
+| **Pi** | `model: "sonnet"` or `model: "openai/gpt-4o"` | [Pi CLI models](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent#providers--models) |
 
 ---
 
 ## How it works
 
-1. **Sandbox** — You create a Daytona sandbox and pass it to `createSession`.
-2. **CLI** — Provider CLI is installed in the sandbox at session creation (unless `skipInstall: true`). Each `run()` sets env and, for Codex, runs `codex login --with-api-key`.
-3. **PTY** — Commands run in a PTY for real-time streaming.
-4. **Events** — JSON from the CLI is parsed into typed events.
-5. **Cleanup** — You call `sandbox.delete()` when done.
+1. **Sandbox** — Create a Daytona sandbox for isolated execution
+2. **CLI install** — Provider CLI is installed in the sandbox automatically
+3. **Background execution** — Agent runs via `nohup`, outputs to a log file
+4. **Polling** — SDK polls the log file for new JSON events
+5. **Completion** — A `.done` file signals when the agent finishes
+6. **Cleanup** — You call `sandbox.delete()` when done
 
 ```
 ┌─────────────┐     ┌──────────────────────────────────────┐
 │   Your App  │────▶│          Daytona Sandbox             │
-│             │◀────│  ┌─────────────┐    ┌─────────────┐  │
-│             │     │  │  PTY Stream │◀──▶│  Agent CLI  │  │
+│             │     │  ┌─────────────┐    ┌─────────────┐  │
+│  (polling)  │◀────│  │  Log File   │◀───│  Agent CLI  │  │
 │             │     │  └─────────────┘    └─────────────┘  │
 └─────────────┘     └──────────────────────────────────────┘
 ```
@@ -364,36 +275,57 @@ npx tsx scripts/repl.ts -h   # help; providers: claude, codex, opencode, gemini
 
 ## Debug mode
 
-Set `CODING_AGENTS_DEBUG=1` (or any non-empty value) to log debugging information to stderr:
+Set `CODING_AGENTS_DEBUG=1` to enable debug logging:
+
+```bash
+CODING_AGENTS_DEBUG=1 npx tsx your-script.ts
+```
+
+---
+
+## Claude OAuth credentials
 
-- **Agent lifecycle** — when sessions and background sessions are created, when runs start and end
-- **Background agents** — when a turn starts (session dir, turn number, output file), when the background process is started (pid), and each time events are polled (cursor, event count)
-- **Unparsed output** — any CLI line that didn’t parse as an event (helps spot hangs where the agent prints something the SDK doesn’t recognize)
+Claude can authenticate via `ANTHROPIC_API_KEY` or `CLAUDE_CODE_CREDENTIALS`. The latter uses OAuth credentials from a Claude Pro/Max subscription.
+
+First, sign in locally:
 
 ```bash
-CODING_AGENTS_DEBUG=1 npx tsx scripts/repl-polling.ts
+claude auth login
 ```
 
+Then retrieve your credentials:
+
+| OS | Command |
+|----|---------|
+| macOS | `security find-generic-password -s "Claude Code-credentials" -w` |
+| Linux | `cat ~/.claude/.credentials.json` |
+| Windows | `type %USERPROFILE%\.claude\.credentials.json` |
+
+Pass the output as `CLAUDE_CODE_CREDENTIALS`. The SDK automatically writes it to `~/.claude/.credentials.json` in the sandbox.
+
 ---
 
 ## Development
 
+Build, test, and iterate locally. Start by installing dependencies and running the unit test suite:
+
 ```bash
 npm install
 npm run build
-npm test                    # unit tests (integration/sandbox-background skipped without keys)
-DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npm run test -- tests/integration/sandbox-background.test.ts   # real sandbox background test
-DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npx tsx scripts/test-sdk-full.ts   # integration
-DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npx tsx scripts/repl.ts            # REPL
+npm test
 ```
 
+For integration and end-to-end testing, see [TESTING.md](./TESTING.md).
+
+For testing scenarios, you can use the deterministic Eliza agent, which requires no provider API key.
+
 ---
 
 ## Resources
 
 **Sandbox** — [Daytona Docs](https://www.daytona.io/docs/) · [Daytona GitHub](https://github.com/daytonaio/daytona)
 
-**Agents** — [Claude Code](https://docs.anthropic.com/en/docs/claude-code) · [Codex CLI](https://developers.openai.com/codex/cli) · [Gemini CLI](https://geminicli.com/docs/) · [OpenCode](https://opencode.ai/docs/)
+**Agents** — [Claude Code](https://docs.anthropic.com/en/docs/claude-code) · [Codex CLI](https://developers.openai.com/codex/cli) · [Gemini CLI](https://geminicli.com/docs/) · [Goose](https://block.github.io/goose/docs/) · [OpenCode](https://opencode.ai/docs/) · [Pi](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent)
 
 ---
 

package/dist/agents/claude/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Claude Code CLI Agent Definition
+ */
+import type { AgentDefinition } from "../../core/agent";
+/**
+ * Claude Code CLI agent definition.
+ *
+ * Interacts with the Claude CLI tool which outputs JSON lines in stream-json format.
+ */
+export declare const claudeAgent: AgentDefinition;
+//# sourceMappingURL=index.d.ts.map

package/dist/agents/claude/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/claude/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAyC,MAAM,kBAAkB,CAAA;AAwC9F;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,eAqDzB,CAAA"}

package/dist/agents/claude/index.js

@@ -0,0 +1,78 @@
+/**
+ * Claude Code CLI Agent Definition
+ */
+import { parseClaudeLine } from "./parser";
+import { CLAUDE_TOOL_MAPPINGS } from "./tools";
+/** Claude credentials directory */
+const CLAUDE_CREDENTIALS_DIR = "/home/daytona/.claude";
+/** Claude credentials file */
+const CLAUDE_CREDENTIALS_FILE = "/home/daytona/.claude/.credentials.json";
+/** Environment variable name for Claude Code credentials */
+const CLAUDE_CODE_CREDENTIALS_ENV = "CLAUDE_CODE_CREDENTIALS";
+/**
+ * Claude agent-specific setup: write credentials from environment variable.
+ *
+ * When CLAUDE_CODE_CREDENTIALS environment variable is set, this function
+ * writes its contents to ~/.claude/.credentials.json. This allows credentials
+ * to be passed via environment variable instead of writing the file manually.
+ *
+ * The value should be the JSON content of the credentials file, e.g.:
+ * {"claudeAiOauth":{"accessToken":"sk-ant-oa..."}}
+ */
+async function claudeSetup(sandbox, env) {
+    const credentialsJson = env[CLAUDE_CODE_CREDENTIALS_ENV];
+    if (!credentialsJson || !sandbox.executeCommand)
+        return;
+    // Escape single quotes for shell command
+    const safeCredentials = credentialsJson.replace(/'/g, "'\\''");
+    // Create directory and write credentials file with secure permissions
+    await sandbox.executeCommand(`mkdir -p '${CLAUDE_CREDENTIALS_DIR}' && echo '${safeCredentials}' > '${CLAUDE_CREDENTIALS_FILE}' && chmod 600 '${CLAUDE_CREDENTIALS_FILE}'`, 30);
+}
+/**
+ * Claude Code CLI agent definition.
+ *
+ * Interacts with the Claude CLI tool which outputs JSON lines in stream-json format.
+ */
+export const claudeAgent = {
+    name: "claude",
+    toolMappings: CLAUDE_TOOL_MAPPINGS,
+    capabilities: {
+        supportsSystemPrompt: true,
+        supportsResume: true,
+        setup: claudeSetup,
+    },
+    buildCommand(options) {
+        const args = [];
+        // Print mode for non-interactive usage
+        args.push("-p");
+        // Add output format flag for JSON streaming (requires --verbose)
+        args.push("--output-format", "stream-json", "--verbose");
+        // Skip permission prompts when already running in a sandbox
+        args.push("--dangerously-skip-permissions");
+        // Apply system prompt via native CLI flag when provided
+        if (options.systemPrompt) {
+            args.push("--system-prompt", options.systemPrompt);
+        }
+        // Add model if specified (e.g., "sonnet", "opus", "claude-sonnet-4-5-20250929")
+        if (options.model) {
+            args.push("--model", options.model);
+        }
+        // Resume session if provided
+        if (options.sessionId) {
+            args.push("--resume", options.sessionId);
+        }
+        // Add the prompt if provided
+        if (options.prompt) {
+            args.push(options.prompt);
+        }
+        return {
+            cmd: "claude",
+            args,
+            env: options.env,
+        };
+    },
+    parse(line, _context) {
+        return parseClaudeLine(line, this.toolMappings);
+    },
+};
+//# sourceMappingURL=index.js.map