farming-code 2.2.23 → 2.2.28

package/extensions/browser/frontend/useBrowserResources.ts

@@ -0,0 +1,151 @@
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { appPath } from '@/lib/base-path'
+import { projectFilesWorkspaceId } from '@/lib/project-workspaces'
+import {
+  applyBrowserResource,
+  applyBrowserResourceDeletion,
+  applyBrowserResourceSnapshot,
+  type BrowserResourceCollection,
+  type BrowserResourceDeletion,
+} from './browser-resource-state'
+import type { BrowserCapability, BrowserResource } from './types'
+
+async function browserRequest<T>(pathname: string, init?: RequestInit): Promise<T> {
+  const response = await fetch(appPath(pathname), {
+    ...init,
+    headers: {
+      Accept: 'application/json',
+      ...(init?.body ? { 'Content-Type': 'application/json' } : {}),
+      ...init?.headers,
+    },
+  })
+  const data = await response.json().catch(() => ({})) as { error?: string }
+  if (!response.ok) throw new Error(data.error || `Browser request failed (${response.status})`)
+  return data as T
+}
+
+export function useBrowserResources() {
+  const [collection, setCollection] = useState<BrowserResourceCollection>({
+    collectionRevision: 0,
+    resources: [],
+  })
+  const [capability, setCapability] = useState<BrowserCapability | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [refreshVersion, setRefreshVersion] = useState(0)
+
+  const mergeResource = useCallback((resource: BrowserResource) => {
+    setCollection(current => applyBrowserResource(current, resource))
+  }, [])
+
+  useEffect(() => {
+    let active = true
+    setLoading(true)
+    void browserRequest<BrowserCapability>('/api/browsers/capability').then(async nextCapability => {
+      if (!active) return
+      setCapability(nextCapability)
+      if (!nextCapability.available) {
+        setCollection({ collectionRevision: 0, resources: [] })
+        setLoading(false)
+        return
+      }
+      const list = await browserRequest<BrowserResourceCollection>('/api/browsers')
+      if (!active) return
+      setCollection(current => applyBrowserResourceSnapshot(current, list))
+      setLoading(false)
+    }).catch(() => {
+      if (active) setLoading(false)
+    })
+    return () => {
+      active = false
+    }
+  }, [refreshVersion])
+
+  useEffect(() => {
+    if (capability?.available !== true) return undefined
+    let active = true
+    const events = new EventSource(appPath('/api/browsers/events'))
+    events.addEventListener('resources', event => {
+      if (!active) return
+      const payload = JSON.parse((event as MessageEvent<string>).data) as BrowserResourceCollection
+      setCollection(current => applyBrowserResourceSnapshot(current, payload))
+    })
+    events.addEventListener('resource', event => {
+      if (!active) return
+      mergeResource(JSON.parse((event as MessageEvent<string>).data) as BrowserResource)
+    })
+    events.addEventListener('deleted', event => {
+      if (!active) return
+      const payload = JSON.parse((event as MessageEvent<string>).data) as BrowserResourceDeletion
+      setCollection(current => applyBrowserResourceDeletion(current, payload))
+    })
+    return () => {
+      active = false
+      events.close()
+    }
+  }, [capability?.available, mergeResource])
+
+  const create = useCallback(async (workspace: string, options: { name?: string; url?: string } = {}) => {
+    const resource = await browserRequest<BrowserResource>('/api/browsers', {
+      method: 'POST',
+      body: JSON.stringify({
+        rootId: projectFilesWorkspaceId(workspace),
+        name: options.name,
+        url: options.url,
+      }),
+    })
+    mergeResource(resource)
+    return resource
+  }, [mergeResource])
+
+  const rename = useCallback(async (id: string, name: string) => {
+    const resource = await browserRequest<BrowserResource>(`/api/browsers/${encodeURIComponent(id)}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ name }),
+    })
+    mergeResource(resource)
+    return resource
+  }, [mergeResource])
+
+  const transition = useCallback(async (id: string, operation: 'start' | 'stop') => {
+    const resource = await browserRequest<BrowserResource>(
+      `/api/browsers/${encodeURIComponent(id)}/${operation}`,
+      { method: 'POST' },
+    )
+    mergeResource(resource)
+    return resource
+  }, [mergeResource])
+
+  const remove = useCallback(async (id: string) => {
+    const deletion = await browserRequest<BrowserResourceDeletion>(
+      `/api/browsers/${encodeURIComponent(id)}`,
+      { method: 'DELETE' },
+    )
+    setCollection(current => applyBrowserResourceDeletion(current, deletion))
+  }, [])
+
+  const byWorkspace = useMemo(() => {
+    const result = new Map<string, BrowserResource[]>()
+    for (const resource of collection.resources) {
+      const current = result.get(resource.workspace) ?? []
+      current.push(resource)
+      result.set(resource.workspace, current)
+    }
+    return result
+  }, [collection.resources])
+
+  return {
+    resources: collection.resources,
+    byWorkspace,
+    capability,
+    loading,
+    create,
+    rename,
+    start: (id: string) => transition(id, 'start'),
+    stop: (id: string) => transition(id, 'stop'),
+    remove,
+    mergeResource,
+    refreshCapability: () => setRefreshVersion(version => version + 1),
+  }
+}
+
+export type BrowserResourcesController = ReturnType<typeof useBrowserResources>

package/frontend/session-bridge.js

@@ -34,17 +34,18 @@
       },
 
       sendComposerMessage(agentId, message, attachments = [], options = {}) {
-        const requestId = options.onResult
-          ? `composer-${Date.now().toString(36)}-${++composerRequestSequence}`
-          : '';
+        const requestedId = typeof options.requestId === 'string' ? options.requestId.trim() : '';
+        const requestId = requestedId
+          || globalThis.crypto?.randomUUID?.()
+          || `composer-${Date.now().toString(36)}-${++composerRequestSequence}`;
         const sent = send({
           type: 'composer-input',
           agentId,
           message,
-          ...(requestId ? { requestId } : {}),
+          requestId,
           ...(attachments.length > 0 ? { attachments } : {}),
         });
-        if (sent && requestId) composerResults.set(requestId, options.onResult);
+        if (sent && options.onResult) composerResults.set(requestId, options.onResult);
         return sent;
       },
 
@@ -58,7 +59,7 @@
       },
 
       rejectPendingComposerMessages(message = 'Connection unavailable') {
-        composerResults.forEach(callback => callback({ accepted: false, message }));
+        composerResults.forEach(callback => callback({ accepted: false, message, uncertain: true }));
         composerResults.clear();
       },
 

package/frontend/skins/crt/app.js

@@ -101,6 +101,7 @@ let structuredComposerConfigId = '';
 let structuredComposerAttachments = [];
 const structuredComposerHistory = new Map();
 const structuredComposerPendingFollowUps = new Map();
+const structuredComposerRequestIds = new Map();
 let structuredComposerHistoryIndex = -1;
 let structuredComposerCompositionEndAt = 0;
 let structuredComposerRestoreFocusAfterInterrupt = false;
@@ -6962,6 +6963,27 @@ function structuredComposerPromptAttachments() {
   ));
 }
 
+function structuredComposerRequestKey(agentId, message, attachments = []) {
+  return JSON.stringify({
+    agentId,
+    message,
+    attachments: attachments.map((attachment) => ({
+      kind: attachment.kind,
+      path: attachment.path,
+      type: attachment.type,
+    })),
+  });
+}
+
+function structuredComposerRequestId(requestKey) {
+  const existing = structuredComposerRequestIds.get(requestKey);
+  if (existing) return existing;
+  const requestId = globalThis.crypto?.randomUUID?.()
+    || `composer-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  structuredComposerRequestIds.set(requestKey, requestId);
+  return requestId;
+}
+
 function structuredComposerHistoryFor(agentId) {
   if (!agentId) return [];
   return structuredComposerHistory.get(agentId) || [];
@@ -7580,10 +7602,17 @@ function setupStructuredSessionComposer() {
     const draft = input.value;
     const message = structuredComposerMessage(draft);
     const promptAttachments = structuredComposerPromptAttachments();
+    const submittedAttachmentIds = structuredComposerAttachments.map((attachment) => attachment.id);
     if (!message && promptAttachments.length === 0) return;
     const statusNode = document.getElementById('crt-structured-composer-status');
     const completeSubmission = () => {
       addStructuredComposerHistory(agentId, draft);
+      const ownsComposer = focusedAgentId === agentId
+        && structuredSessionGeneration === generation
+        && input.value === draft
+        && structuredComposerAttachments.length === submittedAttachmentIds.length
+        && structuredComposerAttachments.every((attachment, index) => attachment.id === submittedAttachmentIds[index]);
+      if (!ownsComposer) return;
       input.value = '';
       structuredComposerAttachments = [];
       renderStructuredComposerAttachments();
@@ -7595,17 +7624,48 @@ function setupStructuredSessionComposer() {
       updateStructuredComposerState(agent);
       setTimeout(() => void refreshStructuredSession(agentId, true, generation), 160);
     };
-    const sent = action === 'send' && structuredRuntimeStatus(agent) !== 'idle'
-      ? (queueStructuredComposerFollowUp(agentId, message, promptAttachments), true)
-      : getSessionClient()?.sendComposerMessage(agentId, message, promptAttachments);
+    if (action === 'send' && structuredRuntimeStatus(agent) !== 'idle') {
+      queueStructuredComposerFollowUp(agentId, message, promptAttachments);
+      completeSubmission();
+      return;
+    }
+    const requestKey = structuredComposerRequestKey(agentId, message, promptAttachments);
+    const requestId = structuredComposerRequestId(requestKey);
+    const sent = getSessionClient()?.sendComposerMessage(agentId, message, promptAttachments, {
+      requestId,
+      onResult(result) {
+        if (result?.accepted === true) {
+          if (structuredComposerRequestIds.get(requestKey) === requestId) {
+            structuredComposerRequestIds.delete(requestKey);
+          }
+          completeSubmission();
+          return;
+        }
+        if (result?.uncertain !== true && structuredComposerRequestIds.get(requestKey) === requestId) {
+          structuredComposerRequestIds.delete(requestKey);
+        }
+        if (focusedAgentId !== agentId || structuredSessionGeneration !== generation) return;
+        if (statusNode) {
+          statusNode.textContent = result?.message || 'Submission was not accepted';
+          statusNode.classList.add('error');
+        }
+        input.focus();
+      },
+    });
     if (!sent) {
+      if (structuredComposerRequestIds.get(requestKey) === requestId) {
+        structuredComposerRequestIds.delete(requestKey);
+      }
       if (statusNode) {
         statusNode.textContent = 'Connection unavailable';
         statusNode.classList.add('error');
       }
       return;
     }
-    completeSubmission();
+    if (statusNode) {
+      statusNode.textContent = 'SENDING...';
+      statusNode.classList.remove('error');
+    }
   });
 }
 

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "farming-code",
-  "version": "2.2.23",
+  "version": "2.2.28",
   "description": "Farming Code is a self-hosted browser workspace for running and supervising AI coding agents",
   "main": "backend/server.js",
   "bin": {
-    "farming": "bin/farming"
+    "farming": "bin/farming",
+    "farming-browser": "extensions/browser/bin/farming-browser"
   },
   "files": [
     "backend/*.js",
+    "backend/farming-agent-bootstrap.zh_cn.md",
     "backend/usage-history-scanner.ts",
     "backend/acp/",
     "backend/data/",
@@ -20,6 +22,7 @@
     "frontend/skins/",
     "frontend/themes/",
     "frontend/vendor/ghostty-web/",
+    "extensions/browser/",
     "shared/",
     "LICENSE",
     "README.md",
@@ -79,18 +82,17 @@
     "check": "npm run typecheck && npm run lint && npm test"
   },
   "keywords": [
-    "ai-agent",
-    "ai-agent-workspace",
+    "coding-agent-workspace",
+    "agent-supervision",
+    "agent-orchestration",
+    "multi-agent",
     "browser-terminal",
-    "claude-code",
-    "coding-agent",
-    "codex",
-    "codex-cli",
-    "developer-tools",
-    "farming-code",
-    "remote-workspace",
+    "browser-workspace",
+    "remote-development",
     "self-hosted",
-    "terminal"
+    "codex",
+    "claude-code",
+    "opencode"
   ],
   "author": "",
   "license": "MIT",
@@ -112,6 +114,7 @@
     "@agentclientprotocol/claude-agent-acp": "0.59.0",
     "@agentclientprotocol/codex-acp": "1.1.4",
     "@agentclientprotocol/sdk": "1.2.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@xterm/addon-clipboard": "^0.2.0",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-search": "^0.16.0",
@@ -125,6 +128,7 @@
     "express": "^4.22.2",
     "ghostty-web": "^0.4.0",
     "highlight.js": "^11.11.1",
+    "html2canvas": "^1.4.1",
     "katex": "^0.17.0",
     "material-icon-theme": "^5.36.1",
     "mermaid": "^11.16.0",
@@ -141,7 +145,8 @@
     "remark-math": "^6.0.0",
     "ripgrep": "^0.3.1",
     "ws": "^8.21.0",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.0",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",

package/shared/browser-protocol.js

@@ -101,7 +101,7 @@ function validateServerMessage(value) {
     case 'error': valid = stringField(value, 'message'); break;
     case 'command-ack': valid = stringField(value, 'requestId') && stringField(value, 'command'); break;
     case 'state': valid = objectMessage(value.state) && Array.isArray(value.state.agents); break;
-    case 'composer-input-result': valid = stringField(value, 'requestId') && stringField(value, 'agentId') && typeof value.accepted === 'boolean' && stringField(value, 'message', true); break;
+    case 'composer-input-result': valid = stringField(value, 'requestId') && stringField(value, 'agentId') && typeof value.accepted === 'boolean' && stringField(value, 'message', true) && (!Object.prototype.hasOwnProperty.call(value, 'uncertain') || typeof value.uncertain === 'boolean'); break;
     case 'agent-started': valid = stringField(value, 'agentId'); break;
     case 'session-output': valid = objectMessage(value.stream) && stringField(value.stream, 'agentId'); break;
     case 'session-preview': valid = objectMessage(value.preview) && stringField(value.preview, 'agentId'); break;