feat: add Zoo remote control bridge

.gitignore

@@ -59,3 +59,6 @@ qdrant_storage/
 plans/
 
 roo-cli-*.tar.gz*
+
+# Local Cursor agent rules/settings (not shared)
+.cursor/

PRIVACY.md

@@ -1,6 +1,6 @@
 # Zoo Code Privacy Policy
 
-**Last Updated: August 15th, 2026**
+**Last Updated: October 21st, 2026**
 
 Zoo Code respects your privacy and is committed to transparency about how we
 handle your data. Below is a simple breakdown of where key pieces of data
@@ -15,20 +15,30 @@ go—and, importantly, where they don't.
   provider (proxy mode), your code may transit Zoo Code servers only to forward
   it to the upstream provider. We do not store your code; it is deleted
   immediately after forwarding. Otherwise, your code is sent directly to the
-  provider. AI providers may store data per their privacy policies.
+  provider. AI providers may store data per their privacy policies. Remote
+  control, described below, is separate: that task transcript is stored for 7
+  days.
 - **Commands**: Any commands executed through Zoo Code happen on your local
   environment. However, when you use AI-powered features, the relevant code and
   context from your commands may be transmitted to your chosen AI model provider
-  (e.g., OpenAI, Anthropic, OpenRouter) to generate responses. We do not have
-  access to or store this data, but AI providers may process it per their
-  privacy policies.
+  (e.g., OpenAI, Anthropic, OpenRouter) to generate responses. We do not store
+  that model-request context, but AI providers may process it per their privacy
+  policies. Remote control, described below, is separate: that task transcript
+  is stored for 7 days.
 - **Prompts & AI Requests**: When you use AI-powered features, your prompts and
   relevant project context are sent to your chosen AI model provider (e.g.,
   OpenAI, Anthropic, OpenRouter) to generate responses. We do not store or
   process this data. These AI providers have their own privacy policies and may
   store data per their terms of service. If you choose Zoo Code Cloud as the
   provider (proxy mode), prompts may transit Zoo Code servers only to forward
-  them to the upstream model and are not stored.
+  them to the upstream model and are not stored. Remote control, described
+  below, is separate: that task transcript is stored for 7 days.
+- **Remote control**: Turning on remote control is optional. When you do, Zoo
+  Code sends that task's conversation, the file contents included in the task,
+  and command output to your Zoo account. Zoo stores that transcript for 7 days
+  so you can view the task and approve, reply, or otherwise control it from the
+  Zoo dashboard, then deletes it. This storage is separate from model-provider
+  requests and from telemetry. Ending the remote session stops further uploads.
 - **API Keys & Credentials**: If you enter an API key (e.g., to connect an AI
   model), it is stored locally on your device and never sent to us or any third
   party, except the provider you have chosen.

packages/core/src/index.ts

@@ -3,3 +3,4 @@ export * from "./debug-log/index.js"
 export * from "./message-utils/index.js"
 export * from "./task-history/index.js"
 export * from "./worktree/index.js"
+export * from "./zoo-remote-control/index.js"

packages/core/src/zoo-remote-control/ZooRemoteControlClient.ts

@@ -0,0 +1,124 @@
+import { partitionRemoteCommands } from "./bridgeHelpers.js"
+import type {
+	ZooRemoteCommandAck,
+	ZooRemoteCommandsResponse,
+	ZooRemoteEvent,
+	ZooRemotePresence,
+	ZooRemoteSnapshot,
+} from "./types.js"
+
+const REQUEST_TIMEOUT_MS = 30_000
+
+export type ZooRemoteControlClientOptions = {
+	getBaseUrl: () => string
+	getSessionToken: () => string
+	fetchFn?: typeof fetch
+	log?: (message: string) => void
+}
+
+/**
+ * Thin HTTP client for /api/extension/remote/* using the Zoo session token.
+ * Callers treat route-missing 404 as "server not ready" and back off.
+ * Ack 404 (command_not_found) must not use the same backoff path.
+ */
+export class ZooRemoteControlClient {
+	private readonly getBaseUrl: () => string
+	private readonly getSessionToken: () => string
+	private readonly fetchFn: typeof fetch
+	private readonly log: (message: string) => void
+
+	constructor(options: ZooRemoteControlClientOptions) {
+		this.getBaseUrl = options.getBaseUrl
+		this.getSessionToken = options.getSessionToken
+		this.fetchFn = options.fetchFn ?? fetch
+		this.log = options.log ?? (() => {})
+	}
+
+	async postPresence(presence: ZooRemotePresence): Promise<{ ok: boolean; status: number }> {
+		return this.request("POST", "/api/extension/remote/presence", presence)
+	}
+
+	async postEvents(instanceId: string, events: ZooRemoteEvent[]): Promise<{ ok: boolean; status: number }> {
+		return this.request("POST", "/api/extension/remote/events", { instanceId, events })
+	}
+
+	async postSnapshot(snapshot: ZooRemoteSnapshot): Promise<{ ok: boolean; status: number }> {
+		return this.request("POST", "/api/extension/remote/snapshot", snapshot)
+	}
+
+	async getCommands(instanceId: string): Promise<{
+		ok: boolean
+		status: number
+		body?: ZooRemoteCommandsResponse
+	}> {
+		const result = await this.requestJson(
+			"GET",
+			`/api/extension/remote/commands?instanceId=${encodeURIComponent(instanceId)}`,
+			undefined,
+			{ parse: (data: unknown) => data },
+		)
+		if (!result.ok || result.body === undefined) return { ok: result.ok, status: result.status }
+
+		const batch = partitionRemoteCommands(result.body)
+		if (!batch) {
+			this.log(`[ZooRemoteControl] GET /api/extension/remote/commands failed: invalid command envelope`)
+			return { ok: false, status: 0 }
+		}
+		return { ok: true, status: result.status, body: batch }
+	}
+
+	async ackCommand(ack: ZooRemoteCommandAck): Promise<{ ok: boolean; status: number }> {
+		return this.request("POST", `/api/extension/remote/commands/${encodeURIComponent(ack.commandId)}/ack`, ack)
+	}
+
+	private async request(method: string, path: string, body?: unknown): Promise<{ ok: boolean; status: number }> {
+		const result = await this.requestJson(method, path, body)
+		return { ok: result.ok, status: result.status }
+	}
+
+	private async requestJson<T>(
+		method: string,
+		path: string,
+		body: unknown | undefined,
+		schema?: { parse: (data: unknown) => T },
+	): Promise<{ ok: boolean; status: number; body?: T }> {
+		const token = this.getSessionToken()
+		if (!token) {
+			return { ok: false, status: 401 }
+		}
+
+		const url = `${this.getBaseUrl().replace(/\/$/, "")}${path}`
+
+		try {
+			const response = await this.fetchFn(url, {
+				method,
+				headers: {
+					Authorization: `Bearer ${token}`,
+					Accept: "application/json",
+					...(body !== undefined ? { "Content-Type": "application/json" } : {}),
+				},
+				signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+				...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+			})
+
+			if (!response.ok) {
+				if (response.status !== 404) {
+					this.log(`[ZooRemoteControl] ${method} ${path} -> ${response.status}`)
+				}
+				return { ok: false, status: response.status }
+			}
+
+			if (!schema) {
+				return { ok: true, status: response.status }
+			}
+
+			const json: unknown = await response.json()
+			return { ok: true, status: response.status, body: schema.parse(json) }
+		} catch (error) {
+			this.log(
+				`[ZooRemoteControl] ${method} ${path} failed: ${error instanceof Error ? error.message : String(error)}`,
+			)
+			return { ok: false, status: 0 }
+		}
+	}
+}