farming-code 2.2.7 → 2.2.8

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.
package/README.md CHANGED
@@ -9,279 +9,177 @@
9
9
  ![Node](https://img.shields.io/badge/node-%3E%3D22-339933?logo=nodedotjs&logoColor=white)
10
10
  ![Platform](https://img.shields.io/badge/platform-macOS%20%7C%20Linux-555)
11
11
 
12
- Farming is a remote browser workspace for AI coding agents. The current public product line is **Farming 2**.
12
+ Farming is a browser workspace for supervising AI coding agents on a development machine. It keeps several live agents, structured conversations, real terminals, project files, review, history, and runtime controls in one place—without moving the repository or agent processes into the browser.
13
13
 
14
- It brings remote terminal sessions, Codex / Claude Code, project-scoped agents, open editors, file search, lightweight editing, git review tools, usage signals, and machine status into one browser page. The goal is to reduce the context switching that usually happens between SSH, an IDE, browser tabs, monitoring pages, and separate agent panels.
14
+ Run Farming beside the coding CLIs you already use, then return to the same work from a desktop or phone. Closing the browser does not stop the agents; the native PTY host can also preserve live terminal sessions while the Farming server restarts.
15
15
 
16
- Farming is designed around remote hosting. Agents, shells, project files, and git state keep running on the remote machine. A desktop browser is good for editing, reviewing, searching, and long follow-up sessions; a mobile browser is good for checking progress, switching sessions, and sending a short intervention while away from the desk.
16
+ ## Two Interfaces, One Runtime
17
17
 
18
- The browser exposes two live interfaces over the same backend: Farming Code at `/farming/code/` and the original CRT interface at `/farming/crt/`. `/farming/` continues to open Farming Code. If Code cannot start or render, the failure view keeps the live CRT interface visible behind the bounded error details, without restarting running agents.
18
+ Farming 2 provides two complete browser interfaces over the same agents and sessions.
19
19
 
20
- For a product-oriented introduction, screenshots, and the architecture diagram, see the [Farming 2 Wiki](https://github.com/zhuwenzhuang/farming/wiki/English).
20
+ ### Farming Code
21
21
 
22
- ![Farming Code workspace](./docs/products/code/assets/01-code-workspace.png)
22
+ The default workbench for reading conversations, intervening in tasks, editing files, and reviewing an evolving change.
23
23
 
24
- > If you are an AI agent contributing to this repository, read [AGENTS.md](./AGENTS.md) first.
24
+ ![Farming Code structured Chat](./docs/products/code/assets/11-code-agent-process.png)
25
25
 
26
- ## Why Farming Exists
26
+ ### Farming CRT
27
27
 
28
- Current AI-agent interfaces are often chat-session lists. They are not great at showing which long-running task matters now, which agent is waiting, which one is stale, and where a human should intervene.
28
+ A keyboard-first control room for watching many agents, opening structured Chat or raw Terminal, searching history, and reading live usage telemetry.
29
29
 
30
- Farming first solves the practical workbench problem: put the tools needed to supervise coding agents into one remote UI. Longer term, it explores attention management through a Main Agent that can observe, coordinate, and summarize multiple child agents.
30
+ ![Farming CRT dashboard](./docs/products/crt/assets/01-crt-dashboard.png)
31
31
 
32
- ## Farming 2
33
-
34
- Farming 2 turns the project into a remote coding workbench:
35
-
36
- - start and manage Codex, Claude, OpenCode, Qoder, bash, and zsh sessions in the browser;
37
- - discover and resume local Codex, Claude, OpenCode, and Qoder session history, then reconnect it to live Farming terminals;
38
- - group agents by project;
39
- - open Project Files with Open Editors, file tree, search, Monaco editing, Markdown/image preview, git changes, diff, and blame;
40
- - click terminal `path:line` references and HTTP URLs;
41
- - set Codex / Claude launch profiles for permissions, model, and speed where the underlying runtime supports them; App Server Codex updates permissions on its current thread, while terminal-owned sessions restart and resume when they already have a provider session id, or start fresh when no resumable id exists yet;
42
- - attach text and images to composer messages;
43
- - view lightweight usage, context, token-rate, quota, and CPU/MEM signals where available;
44
- - access the same remote service from desktop and mobile browsers.
45
-
46
- Screenshots, install details, and product notes are in [Farming 2 product guide](./docs/products/code/README.md).
47
-
48
- ## Quick Start
49
-
50
- The easiest path is the npm package. Run Farming on the same development machine where `codex` or `claude` already works in a normal shell.
51
-
52
- ```bash
53
- npm install --global farming-code
54
- farming daemon
55
- ```
56
-
57
- Farming defaults to port `6694`, base path `/farming`, config directory `~/.farming`, and token auth. The first authenticated start generates a random readable token and stores it in `~/.farming/.session-token`; later restarts and upgrades reuse that token unless `FARMING_TOKEN` is explicitly set. In Chinese time zones this is a Chinese haiku-style passphrase by default; Japanese time zones use Japanese haiku-style passphrases, and other time zones use English passphrases. The startup log prints a URL like:
58
-
59
- ```text
60
- http://linux-host:6694/farming?token=<startup-token>
61
- ```
32
+ | | Farming Code | Farming CRT |
33
+ | --- | --- | --- |
34
+ | Best for | Long follow-ups, files, editing, diffs, review | At-a-glance monitoring, keyboard control, terminal work, telemetry |
35
+ | Live session | Structured Chat and real PTY Terminal | Phosphor Chat and real xterm Terminal |
36
+ | Navigation | Project sidebar, Search, History, Files | Stable Agent bays and keyboard-driven consoles |
37
+ | Appearance | Light and dark | CRT effects, terminal font size, optional Dynamic Heat |
38
+ | Entry | `/farming/code/` or `/farming/` | `/farming/crt/` |
62
39
 
63
- Open that URL in a desktop or mobile browser, click `New Agent`, choose `Codex`, `Claude Code`, `bash`, or `zsh`, select a workspace, and start working.
40
+ Switching interfaces does not restart or duplicate an Agent. If Farming Code cannot start or render, its bounded diagnostic view leaves the live CRT surface available rather than hiding the running sessions.
64
41
 
65
- ## Downloads
42
+ The complete current capability map and screenshot tour are in the [Farming 2 product overview](./docs/products/README.md). See the focused [Farming Code guide](./docs/products/code/README.md) and [Farming CRT guide](./docs/products/crt/README.md) for the full workflows.
66
43
 
67
- The npm package is the default distribution. GitHub release artifacts remain available for manual installation.
44
+ ## What You Can Do
68
45
 
69
- Farming uses these practical deployment shapes:
46
+ - Group live agents by project, pin important work, rename sessions, track unread activity, and archive or resume work.
47
+ - Use structured ACP Chat for Codex, Claude Code, OpenCode, and Qoder. Plans, reasoning, tools, permission requests, embedded terminals, child sessions, attachments, queued follow-ups, and exact change summaries remain available without overwhelming the final answer.
48
+ - Open a real PTY Terminal when exact CLI behavior matters. Chat / Terminal changes the actual runtime and safely resumes the same provider session when its identity is available.
49
+ - Change supported live Codex model, reasoning, Fast, Ultra, and permission settings. Terminal changes are applied to the running workflow before the next message rather than being limited to a future launch profile.
50
+ - Browse Project Files, Open Editors, search with ripgrep, edit with Monaco, preview Markdown and images, follow `path:line` links, inspect git changes, diffs, and blame.
51
+ - Review one evolving change across revisions, keep findings tied to the compared revision, mark files reviewed, and inspect meaningful deltas instead of treating every Agent turn as a separate review.
52
+ - Search live Agents and the supported provider-session archive, then open, continue, restore, or resume the matching work.
53
+ - Observe CPU/MEM, token-rate, context, quota, provider usage, and CRT daily/live token telemetry when the provider exposes the required data.
54
+ - Use the same service from desktop and mobile browsers, with layouts designed for the amount of attention available on each device.
70
55
 
71
- | Environment | Artifact | When to use it |
72
- | --- | --- | --- |
73
- | macOS and Linux | `npm install --global farming-code` | Default path. Requires Node.js 22 or newer and a system runtime that can load `node-pty`. |
74
- | Standalone use | platform CLI from GitHub Releases | Manual installation for environments that do not want npm; upgrades remain manual. |
75
- | Directory deployment | `farming-<version>-<platform>-<arch>.tar.gz` | App bundle with production dependencies and launcher scripts; it uses the target system runtime. |
76
- | Legacy Linux x64 (glibc < 2.28) | `farming-<version>-linux-x64-legacy-glibc228.tar.gz` | First-install bootstrap with a pinned glibc 2.28 runtime. It installs Farming under `~/.farming/npm`; later one-click updates use npm like the default installation. A Node.js 22 executable and npm are still required. |
77
- | Custom older Linux build | `farming-<version>-linux-x64-glibc217.tar.gz` | Separately built bundle that rebuilds `node-pty` against a glibc 2.17 baseline; it still needs a usable target Node.js runtime. |
56
+ ![Farming Code project files and blame](./docs/products/code/assets/04-files-editor-blame.png)
78
57
 
79
- If you want Farming to launch Codex or Claude Code, install and log in to those CLIs on the same machine first. Farming hosts their CLI sessions; it does not replace their installation or account setup.
58
+ ![Farming Review](./docs/products/code/assets/10-review-workflow.png)
80
59
 
81
- ## Architecture
60
+ ## Supported Agent Paths
82
61
 
83
- ```text
84
- Browser skins
85
- React + Vite + Monaco + terminal renderer
86
- |
87
- | HTTP / WebSocket
88
- v
89
- Farming core
90
- Express server + token auth + agent manager + session providers
91
- |
92
- | native pty host + session engine
93
- v
94
- Execution environment
95
- bash / zsh / Codex / Claude Code
96
- ```
62
+ Farming discovers installed CLIs on the host. The richer structured runtime currently applies to providers with ACP support; other detected coding agents remain first-class terminal sessions.
97
63
 
98
- The backend owns agent lifecycle, WebSocket state sync, session engines, workspace file APIs, session providers, model/profile discovery, usage collection, and configuration. Frontend skins organize those capabilities into different experiences. New interactive sessions use the native pty host by default, keeping node-pty agent processes outside the Farming server process so the server and browser can reconnect to live terminals. The native pty host persists across Farming server restarts unless `FARMING_NATIVE_PTY_HOST_PERSIST=0` is set, then exits after an idle grace period once no live sessions or clients remain. Set `FARMING_SESSION_ENGINE=local` only when debugging the in-process node-pty engine.
64
+ | Agent | Structured Chat | Native Terminal | History / resume |
65
+ | --- | --- | --- | --- |
66
+ | Codex | ACP | Yes | Yes |
67
+ | Claude Code | ACP | Yes | Yes |
68
+ | OpenCode | ACP | Yes | Yes |
69
+ | Qoder | ACP | Yes | Yes |
70
+ | Qwen Code | — | Yes | CLI-dependent |
71
+ | Aider | — | Yes | CLI-dependent |
72
+ | GitHub Copilot CLI | — | Yes | CLI-dependent |
73
+ | Amazon Q | — | Yes | CLI-dependent |
74
+ | bash / zsh | — | Yes | No provider-session resume |
99
75
 
100
- The browser terminal renderer defaults to xterm.js. The older Ghostty web renderer is still kept as an explicit debug path through `localStorage.farmingTerminalEngine = 'ghostty'`.
76
+ Farming hosts CLIs that already work on the same machine. It does not replace provider installation, login, or account configuration.
101
77
 
102
- ## Install And Run
78
+ ## Quick Start
103
79
 
104
- ### Install From npm
80
+ Install Node.js 22 or newer, install and sign in to at least one supported coding CLI, then run:
105
81
 
106
82
  ```bash
107
83
  npm install --global farming-code
108
84
  farming daemon
109
85
  ```
110
86
 
111
- Open **Settings → Updates** to check and install a newer npm version in one click. Farming installs the new package while the current server is still running, restarts only after installation succeeds, and attempts to restore the previous version if the new server cannot start. The equivalent manual command is `npm install --global farming-code@latest`.
112
-
113
- ### Build From Source
114
-
115
- ```bash
116
- npm install
117
- npm run release:cli
118
- ```
119
-
120
- To build an app bundle:
87
+ Farming defaults to port `6694`, base path `/farming`, config directory `~/.farming`, and token authentication. The startup log prints a URL similar to:
121
88
 
122
- ```bash
123
- npm install
124
- npm run release:app
89
+ ```text
90
+ http://development-host:6694/farming?token=<startup-token>
125
91
  ```
126
92
 
127
- The standard app bundle includes production dependencies and launcher scripts, and uses the target system runtime as installed.
128
-
129
- For Linux x64 systems whose glibc is older than 2.28, build the release asset that carries the pinned legacy runtime:
93
+ Open it, choose **New Agent**, select an Agent and workspace, and start in Chat or Terminal. Useful daemon commands are:
130
94
 
131
95
  ```bash
132
- npm run release:app:legacy-linux
96
+ farming status
97
+ farming url
98
+ farming logs
99
+ farming stop
133
100
  ```
134
101
 
135
- The resulting `farming-<version>-linux-x64-legacy-glibc228.tar.gz` is a bootstrap package. It extracts the runtime to `~/.farming/glibc228`, installs the bundled Farming release into the private prefix `~/.farming/npm`, and writes a stable compatibility launcher at `~/.farming/bin/farming`. Later updates install `farming-code` into that same prefix through npm, then restart with the compatibility launcher; the tarball is not downloaded again for ordinary application updates.
102
+ The first authenticated start stores a readable random token in `~/.farming/.session-token`; restarts and upgrades reuse it unless `FARMING_TOKEN` overrides it. Token language defaults to the host time zone: Chinese, Japanese, or English.
136
103
 
137
- For a separately built `node-pty` ABI baseline, run the following command inside a clean Linux x64 builder that has glibc 2.17, Node.js 22+, GCC/G++, Make, and Python 3:
104
+ ![Start an Agent](./docs/products/code/assets/02-start-agent-picker.png)
138
105
 
139
- ```bash
140
- npm run release:app:linux-compat
141
- ```
106
+ ## Desktop And Mobile
142
107
 
143
- The command forces `node-pty` to build from source and rejects the archive unless its native module requires no newer than glibc 2.17. Install it remotely with `FARMING_REMOTE=user@host FARMING_RELEASE_TARBALL=<archive> npm run release:remote:linux-compat`. This ABI-focused bundle still uses the target machine's Node.js and libc.
108
+ Desktop keeps the project, conversation, files, and review close together. Mobile focuses one conversation, terminal, or file at a time and moves navigation into a drawer, making it useful for checking progress and sending a short intervention.
144
109
 
145
- When a clean source checkout is already present on a provisioned Linux x64 builder host, `scripts/build-linux-compat-release-on-builder.sh` automates the remaining container build, ABI verification, packaged bash-agent smoke, and artifact output. Set `FARMING_COMPAT_IMAGE` to an image that already exists on that host. The script uses `--pull=never` and disables container networking by default so release builds reuse existing images and caches instead of downloading infrastructure implicitly; set `FARMING_COMPAT_ALLOW_NETWORK=1` only when an intentional cache refresh is required.
110
+ <p align="center">
111
+ <img src="./docs/products/code/assets/05-mobile-agent-chat.jpg" alt="Farming Code on mobile" width="320">
112
+ &nbsp;&nbsp;
113
+ <img src="./docs/products/crt/assets/09-crt-mobile-dashboard.jpg" alt="Farming CRT on mobile" width="320">
114
+ </p>
146
115
 
147
- ### Run A Single-File CLI
116
+ ## Installation And Updates
148
117
 
149
- ```bash
150
- chmod +x farming
151
- ./farming daemon
152
- ```
118
+ The npm package is the default distribution. **Settings → Updates** can upgrade npm installations in place: Farming installs the new package while the current server stays alive, restarts only after installation succeeds, and attempts rollback when the new server cannot start.
153
119
 
154
- By default it listens on port `6694`, serves under `/farming`, creates `~/.farming`, enables token auth, and prints a browser URL containing the startup token.
120
+ GitHub Releases also provide standalone CLI and directory bundles. Legacy Linux x64 hosts can use the `linux-x64-legacy-glibc228` first-install bootstrap; subsequent application updates use the same private npm prefix. A separately built glibc 2.17 ABI bundle remains available for controlled environments. See [GitHub Releases](https://github.com/zhuwenzhuang/farming/releases) for current assets and release notes.
155
121
 
156
- Useful commands:
157
-
158
- ```bash
159
- ./farming status
160
- ./farming logs
161
- ./farming url
162
- ./farming stop
163
- ```
164
-
165
- ### Run An App Bundle
166
-
167
- ```bash
168
- tar -xzf farming-<version>-linux-x64.tar.gz
169
- cd farming-<version>-linux-x64
170
- ./farming
171
- ```
172
-
173
- The standard bundle uses the target machine's ordinary Node.js and native runtime. On a legacy Linux x64 host, download the `-legacy-glibc228.tar.gz` bundle instead and run `./farming` once. After bootstrap, use `~/.farming/bin/farming`; that stable launcher keeps npm updates, server restarts, and PTY child processes on the bundled compatibility runtime.
174
-
175
- ## Development
122
+ Source development:
176
123
 
177
124
  ```bash
178
125
  npm install
179
126
  npm start
180
127
  ```
181
128
 
182
- For trusted local development only, token auth can be disabled:
183
-
184
- ```bash
185
- npm run start:no-auth
186
- ```
187
-
188
- ## Configuration
189
-
190
- Runtime settings are stored in `~/.farming/settings.json`.
191
- Agent session metadata is stored separately in `~/.farming/sessions/`. Farming
192
- uses stable `fsess_*` files for its own Agent records; live `agent-...` ids and
193
- Codex / Claude provider session ids are stored as metadata on those records.
194
- The main Projects page membership lives in `sessions/index.json` and is exposed
195
- as `mainPageSessionKeys` only for API compatibility.
196
- Archived run history is stored in `~/.farming/history/runs.json`, not in
197
- `settings.json`.
198
- Theme overrides, the startup token, server pid/state/log files, and native pty
199
- host logs live under the same config directory.
200
-
201
- Common settings:
129
+ For trusted local development only, `npm run start:no-auth` disables token authentication.
202
130
 
203
- - `defaultLaunchAgent`
204
- - `agentLaunchProfiles.codex`
205
- - `agentLaunchProfiles.claude`
206
- - `agentHomes` (home metadata for Codex, Claude, OpenCode, and Qoder; each provider keeps a non-removable `default` home)
207
- - `workspaceHistory`
208
- - `dangerouslySkipAgentPermissionsByDefault` (launch supported coding agents such as Codex, Claude, OpenCode, Qoder, Qwen, Aider, GitHub Copilot CLI, and Amazon Q with their provider-specific dangerous permission-skip flags by default)
131
+ ## How It Works
209
132
 
210
- Native terminal sessions are owned by a Farming pty host reached through a local socket derived from `configDir`. By default the host is preserved during server shutdown so a restarted Farming server can recover live terminals; after the last live session and client disappear, the host shuts itself down after a short idle grace period. Set `FARMING_NATIVE_PTY_HOST_PERSIST=0` to tie the host lifetime to the server process. Terminal work should target the native pty host and xterm.js path.
211
-
212
- Update behavior follows the installation method. npm installations and legacy Linux installations bootstrapped from `-legacy-glibc228.tar.gz` read versions from the npm registry and provide one-click upgrades in **Settings → Updates**. They install into their existing npm prefix while the old service remains alive, then restart and roll back on startup failure. Source checkouts update through Git, and standalone CLI artifacts are replaced manually. Standard app-bundle installations remain a directory-deployment path and may use a trusted HTTP(S) package directory or manifest URL stored as `settings.updateUrl`.
213
-
214
- The simplest source is an HTTP(S) directory URL ending in `/` that lists platform-tagged `farming-<version>-<platform>-<arch>.tar.gz` app bundles and an adjacent `<bundle>.sha256` file for every bundle. Farming verifies the selected bundle's SHA-256 and archive layout before extraction, then runs its installer.
215
-
216
- Example deployment templates:
133
+ ```text
134
+ Farming Code / Farming CRT
135
+ React, Monaco, xterm.js, CRT browser skin
136
+ │ HTTP + WebSocket
137
+
138
+ Farming core
139
+ auth, Agent manager, ACP, history, files, review, usage
140
+ │ native PTY host + session providers
141
+
142
+ Development host
143
+ repositories, shells, Codex, Claude Code, OpenCode, Qoder, ...
144
+ ```
217
145
 
218
- - `config/farming.deploy.env.example`
219
- - `config/farming.install.env.example`
146
+ The backend owns lifecycle, authentication, session routing, workspace boundaries, history, and configuration. Interactive terminal sessions use a separate native PTY host by default, allowing browser and server reconnection without replacing the live process. The browser terminal renderer defaults to xterm.js; the Ghostty web adapter remains an explicit debug path.
220
147
 
221
- Real `.env` files are ignored by git.
148
+ Runtime settings live in `~/.farming/settings.json`. Farming session metadata, the project membership index, archived runs, theme settings, update state, logs, and the startup token use separate files under `~/.farming/`. External provider histories remain read-only integrations.
222
149
 
223
150
  ## Security
224
151
 
225
- Farming controls real terminals and agent processes on the target machine. Run it on trusted development hosts and trusted networks. Do not expose it directly to the public internet without an additional layer such as VPN, SSH tunnel, HTTPS reverse proxy, or network ACLs.
226
-
227
- The startup token protects both HTTP and WebSocket traffic. It is generated on first authenticated startup, persisted in `~/.farming/.session-token`, and reused across restarts and upgrades. The generated token is designed to be easier to copy than a long hexadecimal secret: Chinese time zones get a Chinese haiku-style passphrase by default, Japanese time zones get a Japanese haiku-style passphrase, and other time zones get an English passphrase. `FARMING_TOKEN_LOCALE=zh|ja|en|auto` can override generation behavior for a new token.
228
-
229
- `FARMING_DISABLE_AUTH=1` is only for trusted local development. Terminal-owned Codex / Claude sessions apply a permission change by restarting with the selected CLI flags, resuming when a provider session id is available and starting fresh otherwise. App Server Codex applies the new approval and sandbox policy to its existing thread without a CLI restart.
230
-
231
- See [SECURITY.md](./SECURITY.md) for the reporting policy and deployment notes.
152
+ Farming controls real terminals and files on the target machine. Run it on a trusted development host and trusted network. Do not expose it directly to the public internet without a VPN, SSH tunnel, HTTPS reverse proxy, or equivalent access control.
232
153
 
233
- ## Troubleshooting
154
+ Token authentication protects HTTP and WebSocket traffic. `FARMING_DISABLE_AUTH=1` is only for trusted local development. Workspace file APIs validate paths against the selected project root. See [SECURITY.md](./SECURITY.md) for reporting and deployment guidance.
234
155
 
235
- - **No `codex` or `claude` option works**: verify the CLI is installed, logged in, and runnable from a normal shell on the same host.
236
- - **Native PTY cannot start**: verify the target system's Node.js and packaged `node-pty` runtime are compatible. On Linux x64 with glibc older than 2.28, use the `-legacy-glibc228` app bundle.
237
- - **Port already in use**: pass `--port <port>` or let the default daemon mode choose the next available port when no explicit port is provided.
238
- - **Phone cannot connect**: use the network URL printed by the server and make sure the phone can reach the target machine.
239
- - **Lost the token URL**: run `./farming url`, or check `./farming logs`.
240
-
241
- ## Repository Layout
242
-
243
- ```text
244
- farming/
245
- ├── .gitattributes # Source archive export rules
246
- ├── backend/ # Node.js server, session engines, and backend APIs
247
- ├── src/ # React + Vite frontend; Farming Code helpers live under src/components/code/
248
- ├── frontend/skins/crt/ # Independent live CRT entry, app, and visual effects
249
- ├── frontend/*.js # Shared terminal/session browser bridges
250
- ├── docs/products/code/ # Farming Code product docs and screenshots
251
- ├── docs/products/crt/ # CRT skin layout docs
252
- ├── config/ # deployment / install templates
253
- ├── scripts/ # release, deployment, screenshots, tests
254
- ├── tests/e2e/ # Playwright browser flows
255
- ├── pkg.config.cjs
256
- └── bin/farming
257
- ```
156
+ ## Documentation
258
157
 
259
- `releases/` is a local packaging output directory and is not committed.
158
+ - [Farming 2 product overview and capability map](./docs/products/README.md)
159
+ - [Farming Code guide](./docs/products/code/README.md)
160
+ - [Farming CRT guide](./docs/products/crt/README.md)
161
+ - [Mobile guide](./docs/products/code/mobile-guide.md)
162
+ - [ACP runtime](./docs/products/code/acp-runtime.md)
163
+ - [Review foundation](./docs/products/code/review-foundation.md)
164
+ - [Release history](https://github.com/zhuwenzhuang/farming/releases)
165
+ - [Contributor instructions](./AGENTS.md)
260
166
 
261
- ## Tests
262
-
263
- ```bash
264
- npm run check
265
- ```
266
-
267
- Common individual checks:
167
+ ## Development Checks
268
168
 
269
169
  ```bash
270
170
  npm test
271
171
  npm run typecheck
272
172
  npm run lint
173
+ FARMING_BASE_PATH=/farming npm run build
273
174
  npm run test:e2e:playwright
274
175
  ```
275
176
 
276
- ## Authors
177
+ Product screenshots are generated from an anonymous demo workspace with real browser flows:
277
178
 
278
- - [zhuwenzhuang](https://github.com/zhuwenzhuang)
279
- - [l4wei](https://github.com/l4wei)
280
-
281
- ## Contributing
282
-
283
- Issues and pull requests are welcome. Start with [CONTRIBUTING.md](./CONTRIBUTING.md), and keep user-facing docs updated when behavior or packaging changes.
179
+ ```bash
180
+ npm run docs:product:screenshots
181
+ ```
284
182
 
285
183
  ## License
286
184
 
287
- Farming is released under the MIT License. See [LICENSE](./LICENSE).
185
+ Farming is released under the [MIT License](./LICENSE). Third-party notices are listed in [THIRD_PARTY_NOTICES.md](./THIRD_PARTY_NOTICES.md).