conductor-oss-native-darwin-universal 0.57.4 → 0.57.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/README.md +197 -152
  2. package/package.json +1 -1
package/README.md CHANGED
@@ -2,9 +2,9 @@
2
2
 
3
3
  # Conductor OSS
4
4
 
5
- ### The local-first control plane for AI coding agents
5
+ ### Run real AI coding agents across your repos, from one dashboard
6
6
 
7
- **One command. Markdown-native. Real terminals.**
7
+ **Real terminals. Git worktrees. Local-first control.**
8
8
 
9
9
  [![npm version](https://img.shields.io/npm/v/conductor-oss?style=flat-square&color=0ea5e9)](https://www.npmjs.com/package/conductor-oss)
10
10
  [![CI](https://img.shields.io/github/actions/workflow/status/charannyk06/conductor-oss/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/charannyk06/conductor-oss/actions/workflows/ci.yml)
@@ -16,91 +16,144 @@
16
16
 
17
17
  ---
18
18
 
19
- Conductor OSS is a local-first orchestration layer for AI coding agents. It turns Markdown kanban boards into dispatchable work, launches installed coding CLIs in isolated git worktrees, and gives you a browser dashboard for live terminal sessions, diffs, previews, recovery workflows, and multi-agent skills management.
19
+ Conductor OSS is a local-first orchestration layer for AI coding agents.
20
20
 
21
- By default, everything runs on your machine. Conductor keeps board state in Markdown, stores runtime metadata in SQLite, and leaves authentication and billing to the upstream agent CLIs.
21
+ It helps you:
22
+ - connect a repo or local folder as a workspace
23
+ - launch Claude Code, Codex, Gemini, and other coding CLIs in isolated git worktrees
24
+ - watch the agent inside a real terminal, not a fake chat shell
25
+ - review diffs, previews, retries, restores, and reviewer feedback from one dashboard
26
+ - keep project state in normal local files like `conductor.yaml`, `CONDUCTOR.md`, and `.conductor/conductor.db`
22
27
 
23
- ## Why Conductor
28
+ ## Read this first, there are two ways to use Conductor
24
29
 
25
- Running one agent in one terminal works for one task. Conductor is for the next step: multiple tasks, multiple repos, multiple agents, shared queues, session recovery, live review, and one dashboard to coordinate all of it.
30
+ A lot of confusion comes from mixing the local app and the hosted bridge flow.
26
31
 
27
- Conductor adds:
32
+ ### 1. Local dashboard on the same machine
33
+ Use this when Conductor and your repos live on the same laptop or desktop.
28
34
 
29
- - **Markdown-native planning** with `CONDUCTOR.md` boards that stay readable in Obsidian or any editor
30
- - **Dispatch orchestration** that turns tagged cards into queued agent work
31
- - **Worktree isolation** so concurrent sessions do not trample the same branch
32
- - **Native terminal sessions** over ttyd-backed PTYs instead of synthetic chat shells
33
- - **Operational visibility** through session feeds, diffs, previews, health views, and cleanup tools
34
- - **Recovery loops** with retry, restore, reviewer feedback, and session health tracking
35
+ ```bash
36
+ npx --yes --registry=https://registry.npmjs.org conductor-oss@latest
37
+ ```
35
38
 
36
- ## Quick Start
39
+ That defaults to `co start --open`.
37
40
 
38
- ### Requirements
41
+ If you do **not** pass a workspace, the launcher boots a default workspace at:
39
42
 
40
- - Node.js `>= 18`
41
- - `git`
42
- - At least one supported coding agent CLI installed and authenticated
43
+ ```text
44
+ ~/.openclaw/workspace
45
+ ```
43
46
 
44
- ### Launch
47
+ ### 2. Hosted dashboard plus paired device bridge
48
+ Use this when you want to open Conductor from another browser, another computer, or your phone while the actual work still runs on your own machine.
45
49
 
46
50
  ```bash
47
- npx --yes --registry=https://registry.npmjs.org conductor-oss@latest
51
+ curl -fsSL https://app.conductross.com/bridge/install.sh | sh -s -- --connect --dashboard-url https://app.conductross.com --relay-url https://relay.conductross.com/
48
52
  ```
49
53
 
50
- Running the package with no arguments defaults to `start --open`.
54
+ On Windows PowerShell:
55
+
56
+ ```powershell
57
+ & ([scriptblock]::Create((Invoke-RestMethod -Uri 'https://app.conductross.com/bridge/install.ps1'))) -Connect -DashboardUrl 'https://app.conductross.com' -RelayUrl 'https://relay.conductross.com/'
58
+ ```
59
+
60
+ The hosted dashboard is **not** a cloud IDE. Your repos, terminals, and agents stay on the paired machine.
61
+
62
+ ## What Conductor actually is
63
+
64
+ Conductor sits between your repos and the coding CLIs you already use.
65
+
66
+ It is:
67
+ - a dashboard for linked workspaces and running sessions
68
+ - a launcher for supported coding agent CLIs
69
+ - a git worktree manager so concurrent sessions do not stomp on each other
70
+ - a session runtime with real ttyd-backed PTYs
71
+ - a local state layer backed by SQLite
72
+ - an optional paired-device bridge for remote access to your own machine
73
+
74
+ It is **not**:
75
+ - a replacement model provider
76
+ - a hosted cloud IDE that stores your code by default
77
+ - a fake browser chat wrapper around terminal output
78
+ - dependent on one agent vendor
79
+
80
+ ## The main user flow
81
+
82
+ This is the flow the current app is built around.
51
83
 
52
- - Primary launcher URL: `http://127.0.0.1:4747`
53
- - Launcher-managed Rust backend: `http://127.0.0.1:4748` by default
54
- - The native Rust `conductor start` binary uses `4747` unless you override `--port`
55
- - When launched through `co start`, the dashboard inherits the Rust backend URL automatically so the web app can proxy skills, preview, and session routes without extra setup.
84
+ 1. Open Conductor.
85
+ 2. Add a workspace.
86
+ 3. Choose either:
87
+ - a GitHub repository you already have access to, or
88
+ - a local folder that already exists on disk
89
+ 4. Conductor links that workspace and scaffolds local state as needed.
90
+ 5. Start or resume agent sessions for that workspace.
91
+ 6. Monitor the live terminal, inspect diffs, open previews, send feedback, retry, restore, or clean up.
92
+ 7. If you like planning in Markdown, keep tasks in `CONDUCTOR.md`. If you prefer direct launches, use the dashboard or `co spawn`.
56
93
 
57
- ### Initialize an existing repo
94
+ ## Quick start
95
+
96
+ ### Option A, point Conductor at an existing repo
58
97
 
59
98
  ```bash
99
+ cd /path/to/repo
60
100
  npx --yes --registry=https://registry.npmjs.org conductor-oss@latest init
61
- npx --yes --registry=https://registry.npmjs.org conductor-oss@latest start --workspace .
101
+ npx --yes --registry=https://registry.npmjs.org conductor-oss@latest start --workspace . --open
62
102
  ```
63
103
 
64
- `init` scaffolds `conductor.yaml` and `CONDUCTOR.md`. The SQLite database at `.conductor/conductor.db` is created the first time the backend starts.
104
+ What this does:
105
+ - scaffolds `conductor.yaml`
106
+ - scaffolds `CONDUCTOR.md`
107
+ - starts the dashboard and Rust backend for that repo
65
108
 
66
- ### Global install
109
+ ### Option B, install globally
67
110
 
68
111
  ```bash
69
112
  npm install -g conductor-oss
70
- co start
113
+ co start --open
71
114
  ```
72
115
 
73
- The launcher registers three aliases: `conductor-oss`, `conductor`, and `co`.
116
+ Installed aliases:
117
+ - `conductor-oss`
118
+ - `conductor`
119
+ - `co`
74
120
 
75
- ## Supported Agents
121
+ ### Option C, guided setup
76
122
 
77
- Conductor ships adapters for the major coding CLIs it knows how to discover, launch, and monitor today.
123
+ ```bash
124
+ co setup
125
+ ```
78
126
 
79
- | Agent | CLI |
80
- |-------|-----|
81
- | Claude Code | `claude` |
82
- | Codex | `codex` |
83
- | Gemini | `gemini` |
84
- | Qwen Code | `qwen` |
85
- | Amp | `amp` |
86
- | Hermes | `hermes` |
87
- | Cursor CLI | `cursor-agent` |
88
- | OpenCode | `opencode` |
89
- | Droid | `droid` |
90
- | GitHub Copilot | `gh copilot` / `copilot` |
91
- | CCR | `ccr` |
127
+ Use this if you want a more guided first-run flow.
92
128
 
93
- ## Skills
129
+ ## What you will see in the app
94
130
 
95
- The dashboard includes a Skills tab for each session. It can install curated official skill bundles for Claude Code, Codex, Gemini, Amp, Hermes, Cursor CLI, OpenCode, Droid, Qwen Code, CCR, and GitHub Copilot.
131
+ ### Workspace entry
132
+ The dashboard starts with a workspace-first flow. You link repos first, then manage sessions from there.
133
+
134
+ ### Session detail
135
+ Each session page is built around four core surfaces:
136
+ - **Terminal**, the live interactive PTY session
137
+ - **Overview**, normalized state, metadata, and recovery actions
138
+ - **Preview**, project dev server URLs when available
139
+ - **Diff**, file changes and workspace inspection
140
+
141
+ <div align="center">
142
+
143
+ | Dashboard Overview | Session Detail |
144
+ |:---:|:---:|
145
+ | ![Dashboard](docs/screenshots/01-dashboard-overview.png) | ![Session](docs/screenshots/07-session-detail.png) |
96
146
 
97
- Skills are mapped to each agent's native folder layout, so user-scoped and workspace-scoped installs land in the right place automatically. The backend also detects custom skill folders already present on the machine and lets you activate or deactivate skills for the current session.
147
+ </div>
98
148
 
99
- If you run the dashboard outside `co start`, set `CONDUCTOR_BACKEND_URL` or `NEXT_PUBLIC_CONDUCTOR_BACKEND_URL` so the web app can reach the Rust backend. If that backend is reachable off-host and dashboard auth is enabled, also set the same `CONDUCTOR_PROXY_AUTH_SECRET` in both processes so forwarded dashboard auth headers can be verified safely.
149
+ ### Native terminal experience
150
+ Agents run in their real terminal UI.
100
151
 
101
- ## Native Terminal Experience
152
+ - Claude Code runs as Claude Code
153
+ - Codex runs as Codex
154
+ - Gemini runs as Gemini
102
155
 
103
- Conductor launches agents into their real terminal UIs. Claude Code runs as Claude Code. Codex runs as Codex. Interactive sessions are ttyd-backed PTYs, so reconnects, resize events, and terminal restore behave like a real terminal session rather than a browser chat imitation.
156
+ Conductor uses ttyd-backed PTYs so reconnects, resize events, restore, and mobile terminal behavior act like a real terminal session.
104
157
 
105
158
  <div align="center">
106
159
 
@@ -114,155 +167,148 @@ Conductor launches agents into their real terminal UIs. Claude Code runs as Clau
114
167
 
115
168
  </div>
116
169
 
117
- ## How It Works
170
+ ## Markdown board support
118
171
 
119
- ### Task Lifecycle
172
+ `CONDUCTOR.md` is still a first-class part of the product.
173
+
174
+ The default scaffold gives you a simple task lifecycle:
120
175
 
121
176
  ```text
122
177
  Inbox -> Ready to Dispatch -> Dispatching -> In Progress -> Review -> Done
123
178
  ```
124
179
 
125
- 1. Create tasks in `CONDUCTOR.md`.
126
- 2. Move work into `Ready to Dispatch`.
127
- 3. Conductor selects an agent, prepares the workspace, and launches a session.
128
- 4. The agent runs in an isolated git worktree with a compiled task prompt and any context attachments.
129
- 5. You monitor progress from the dashboard and the live terminal.
130
- 6. You review diffs, preview local apps, send feedback, retry, restore, or clean up.
131
-
132
- ### Dashboard Surfaces
133
-
134
- Each session page includes:
180
+ Use the board when you want Markdown-native planning that still maps cleanly onto session history and dispatch context.
135
181
 
136
- - **Terminal** for the live interactive PTY session
137
- - **Overview** for normalized session state, metadata, and recovery actions
138
- - **Preview** for project dev-server URLs
139
- - **Diff** for file changes and workspace inspection
182
+ If you want to skip the board for a quick run, you can still launch sessions directly with the CLI.
140
183
 
141
- <div align="center">
142
-
143
- | Dashboard Overview | Session Detail |
144
- |:---:|:---:|
145
- | ![Dashboard](docs/screenshots/01-dashboard-overview.png) | ![Session](docs/screenshots/07-session-detail.png) |
184
+ ## CLI commands most users need
146
185
 
147
- </div>
148
-
149
- ## CLI Reference
150
-
151
- The npm launcher (`co`) is the primary user-facing CLI.
152
-
153
- | Command | Description |
154
- |---------|-------------|
186
+ | Command | What it does |
187
+ |---------|---------------|
155
188
  | `co start` | Start the dashboard and Rust backend |
156
- | `co init` | Scaffold `conductor.yaml` and `CONDUCTOR.md` |
157
- | `co setup` | Guided first-run setup for agents, editors, and local tooling |
158
- | `co spawn` | Create a new session |
189
+ | `co init` | Scaffold `conductor.yaml` and `CONDUCTOR.md` in a repo |
190
+ | `co setup` | Guided first-run setup |
191
+ | `co spawn <project> [prompt]` | Start a new agent session for a project |
159
192
  | `co list` | List sessions |
160
- | `co status` | Show the current attention-oriented status board |
161
- | `co send` | Send a message to a running session |
162
- | `co feedback` | Send reviewer feedback and requeue a session |
163
- | `co retry` | Create a new attempt from an existing task or session |
164
- | `co restore` | Restore an exited session |
165
- | `co kill` | Terminate a session |
193
+ | `co status` | Show the current attention-oriented session view |
194
+ | `co send <session> <message...>` | Send a message to a running session |
195
+ | `co feedback <sessionId> <message...>` | Send reviewer feedback and requeue the session |
196
+ | `co retry <sessionOrTask>` | Start a new attempt from an existing task or session |
197
+ | `co restore <session>` | Restore an exited session |
198
+ | `co kill <session>` | Kill a session |
166
199
  | `co cleanup` | Reclaim resources from completed sessions |
167
- | `co doctor` | Inspect backend and session health |
200
+ | `co doctor` | Check backend and runtime health |
168
201
  | `co dashboard` | Open the dashboard in a browser |
169
- | `co task show <taskId>` | Inspect task attempts, parent, and child tasks |
202
+ | `co bridge setup` | Install and pair Conductor Bridge for remote access |
170
203
  | `co mcp-server` | Run Conductor as an MCP server over stdio |
204
+ | `co acp-server` | Run Conductor as an ACP server over stdio |
171
205
 
172
- A lower-level Rust CLI also exists for development and internal flows. That native binary is where the current `bridge` subcommands live.
206
+ ## Supported agents
173
207
 
174
- ## Access Control and Bridge
208
+ Conductor ships adapters for the coding CLIs it can discover and launch today.
175
209
 
176
- Conductor is local-first, but the current codebase includes several access-control and paired-device paths:
210
+ | Agent | CLI |
211
+ |-------|-----|
212
+ | Claude Code | `claude` |
213
+ | Codex | `codex` |
214
+ | Gemini | `gemini` |
215
+ | Qwen Code | `qwen` |
216
+ | Amp | `amp` |
217
+ | Hermes | `hermes` |
218
+ | Cursor CLI | `cursor-agent` |
219
+ | OpenCode | `opencode` |
220
+ | Droid | `droid` |
221
+ | GitHub Copilot | `gh copilot` or `copilot` |
222
+ | CCR | `ccr` |
177
223
 
178
- - **Verified edge auth** via Cloudflare Access JWT validation and role bindings
179
- - **Optional Clerk integration** for hosted sign-in flows in the web app
180
- - **Bridge and relay components** for paired-device flows and relay-backed terminals
224
+ The dashboard only offers agents it can discover on your machine.
181
225
 
182
- Relay deployment matters separately from web deployment. See `docs/relay-deployment.md` for the production rollout workflow and required secrets.
226
+ ## Local files Conductor creates
183
227
 
184
- What is no longer supported:
228
+ | File or directory | Purpose |
229
+ |-------------------|---------|
230
+ | `conductor.yaml` | Workspace config, project metadata, defaults, and server settings |
231
+ | `CONDUCTOR.md` | Markdown board for planning and dispatch |
232
+ | `.conductor/conductor.db` | SQLite runtime state for sessions, attempts, metadata, and coordination |
233
+ | `.conductor/rust-backend/detached/` | Detached PTY state for restore flows |
234
+ | `attachments/` | Uploaded files and generated session artifacts |
235
+ | `~/.conductor/` | Launcher runtime state and optional bridge state |
185
236
 
186
- - Public share-link remote control without an identity layer
187
- - The old tmux-first terminal model
237
+ ## Ports
188
238
 
189
- The user-facing paired-device flow is built around the companion `conductor-bridge` binary and the dashboard bridge pages. The repo also contains `bridge-cmd/`, `crates/conductor-relay/`, and native Rust `conductor bridge ...` commands for lower-level bridge and relay development.
239
+ ### Launcher defaults
240
+ When you run `co start` from the published package:
190
241
 
191
- For first-time bridge pairing, prefer the hosted installer instead of routing through `npx`:
242
+ - dashboard: `http://127.0.0.1:4747`
243
+ - Rust backend: `http://127.0.0.1:4748`
192
244
 
193
- ```bash
194
- curl -fsSL https://app.conductross.com/bridge/install.sh | sh -s -- --connect --dashboard-url https://app.conductross.com --relay-url https://relay.conductross.com/
195
- ```
245
+ ### Source checkout defaults
246
+ When you run the repo in development mode:
196
247
 
197
- On Windows PowerShell:
248
+ - dashboard: `http://127.0.0.1:3000`
249
+ - Rust backend: `http://127.0.0.1:4749`
198
250
 
199
- ```powershell
200
- & ([scriptblock]::Create((Invoke-RestMethod -Uri 'https://app.conductross.com/bridge/install.ps1'))) -Connect -DashboardUrl 'https://app.conductross.com' -RelayUrl 'https://relay.conductross.com/'
201
- ```
251
+ ## Access control, sign-in, and bridge
202
252
 
203
- ## Local Files and Runtime Artifacts
253
+ Conductor is local-first, but the codebase already includes hosted and paired-device paths.
204
254
 
205
- Conductor uses a small set of local files:
255
+ Current pieces in the repo:
256
+ - verified Cloudflare Access JWT validation and role bindings
257
+ - optional Clerk-backed sign-in flows in the web app
258
+ - bridge and relay components for paired-device terminals and remote access
206
259
 
207
- | File | Purpose |
208
- |------|---------|
209
- | `conductor.yaml` | Workspace config, project definitions, access rules, and preferences |
210
- | `CONDUCTOR.md` | Markdown kanban board for planning and dispatch |
211
- | `.conductor/conductor.db` | SQLite state for sessions, attempts, metadata, and runtime coordination |
260
+ If you run the dashboard outside `co start`, set `CONDUCTOR_BACKEND_URL` or `NEXT_PUBLIC_CONDUCTOR_BACKEND_URL` so the web app can reach the Rust backend.
212
261
 
213
- Common runtime artifacts:
262
+ If that backend is reachable off-host and dashboard auth is enabled, also set the same `CONDUCTOR_PROXY_AUTH_SECRET` in both processes so forwarded dashboard auth headers can be verified safely.
214
263
 
215
- - `.conductor/rust-backend/detached/` for restore data and detached PTY runtime state
216
- - `attachments/` for uploaded files and generated session artifacts
217
- - `~/.conductor/` for launcher runtime state and optional bridge token/state files
264
+ Relay deployment is separate from dashboard deployment. See `docs/relay-deployment.md` if you are rolling out the paired-device stack.
218
265
 
219
- ## Develop From Source
266
+ ## Develop from source
220
267
 
221
268
  ### Prerequisites
222
-
223
269
  - Rust stable toolchain
224
270
  - Bun `>= 1.2`
225
271
  - Node.js `>= 18`
226
272
  - `git`
227
273
 
228
- ### Setup
274
+ ### Install
229
275
 
230
276
  ```bash
231
277
  bun install
232
278
  ```
233
279
 
234
- ### Commands
280
+ ### Run
235
281
 
236
282
  ```bash
237
- bun run dev:full # Dashboard on 3000 + Rust backend on 4749
238
- bun run dev # Dashboard only
239
- bun run dev:backend # Backend only through the launcher path
240
- bun run build # Production build
241
- bun run typecheck # TypeScript type checking
283
+ bun run dev:full
284
+ ```
242
285
 
243
- export CONDUCTOR_DEV_DASHBOARD_PORT=3000 # optional
244
- export CONDUCTOR_DEV_BACKEND_PORT=4749 # optional
286
+ Useful scripts:
245
287
 
288
+ ```bash
289
+ bun run dev # dashboard only
290
+ bun run dev:backend # backend only through the launcher path
291
+ bun run build # production build
292
+ bun run typecheck # TypeScript type checking
246
293
  cargo test --workspace
247
294
  cargo clippy --workspace -- -D warnings
248
295
  ```
249
296
 
250
- ### Port Reference
297
+ Optional development ports:
251
298
 
252
- | Scenario | Dashboard | Rust backend |
253
- |----------|-----------|--------------|
254
- | `co start` launcher defaults | `4747` | `4748` |
255
- | Source dev scripts in this repo | `3000` | `4749` |
256
- | Native `cargo run --bin conductor -- start` | n/a | `4747` |
299
+ ```bash
300
+ export CONDUCTOR_DEV_DASHBOARD_PORT=3000
301
+ export CONDUCTOR_DEV_BACKEND_PORT=4749
302
+ ```
257
303
 
258
- ## Project Structure
304
+ ## Project structure
259
305
 
260
306
  ```text
261
307
  conductor-oss/
262
308
  ├── bridge-cmd/ # Companion bridge binary used by the pairing flow
263
309
  ├── crates/
264
310
  │ ├── conductor-cli/ # Native Rust CLI
265
- │ ├── conductor-core/ # Config, board parsing, task/session models, scaffolding
311
+ │ ├── conductor-core/ # Config, board parsing, task and session models, scaffolding
266
312
  │ ├── conductor-db/ # SQLite persistence
267
313
  │ ├── conductor-executors/ # Agent adapters and process management
268
314
  │ ├── conductor-git/ # Git and worktree operations
@@ -276,22 +322,21 @@ conductor-oss/
276
322
  │ ├── core/ # Shared TypeScript types and schemas
277
323
  │ └── web/ # Next.js dashboard
278
324
  ├── docs/
279
- │ ├── demo/ # Workflow demos
280
- │ ├── screenshots/ # Dashboard and terminal screenshots
281
- │ └── terminal-*.md # Terminal protocol and QA docs
325
+ │ ├── screenshots/ # Product screenshots
326
+ │ └── *.md # Deployment notes, QA docs, and product docs
282
327
  ├── Cargo.toml # Rust workspace
283
328
  ├── package.json # Bun workspace
284
- ├── conductor.yaml # Workspace config (user-created)
285
- └── CONDUCTOR.md # Board file (user-created)
329
+ ├── conductor.yaml # User-created workspace config
330
+ └── CONDUCTOR.md # User-created board file
286
331
  ```
287
332
 
288
- ## Known Constraints
333
+ ## Known constraints
289
334
 
290
- - Output quality depends on the upstream agent CLI you install; Conductor orchestrates it, not its model behavior
291
- - GitHub-heavy flows work best with `gh` installed and authenticated
292
- - Preview tooling depends on a project exposing a local dev server or explicit preview URL
293
- - Public remote admin links were removed; use a verified identity layer instead
294
- - Legacy tmux and legacy direct sessions are compatibility data that should be archived rather than resumed
335
+ - Output quality depends on the upstream agent CLI you install. Conductor orchestrates sessions, it does not change the underlying model quality.
336
+ - GitHub-heavy flows work best with `gh` installed and authenticated.
337
+ - Preview tooling depends on a project exposing a local dev server or explicit preview URL.
338
+ - Public share-link remote control without an identity layer is not supported.
339
+ - Legacy tmux and old direct-session data should be archived, not treated as the preferred runtime path.
295
340
 
296
341
  ## Links
297
342
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "conductor-oss-native-darwin-universal",
3
- "version": "0.57.4",
3
+ "version": "0.57.6",
4
4
  "license": "MIT",
5
5
  "private": false,
6
6
  "os": [