farming-code 2.2.8 → 2.2.12

package/frontend/farming-net/app.js

@@ -0,0 +1,268 @@
+(() => {
+  'use strict';
+
+  const copy = {
+    en: {
+      checking: 'Checking',
+      count: count => `${count} ${count === 1 ? 'environment' : 'environments'}`,
+      defaultSubtitle: 'All your deployed Farming workspaces, one click away.',
+      emptyBody: 'Try another name, owner, or platform.',
+      emptyTitle: 'No matching environment',
+      environments: 'Environments',
+      eyebrow: 'YOUR FARMING NETWORK',
+      failed: 'Farming Net could not load its private registry. Refresh to try again.',
+      footer: 'One portal token. Short-lived passes for enrolled Farms.',
+      justUpdated: 'Updated just now',
+      privateIndex: 'Private index',
+      reachable: 'Reachable',
+      refresh: 'Refresh',
+      scope: {
+        'this-device': 'THIS DEVICE',
+        intranet: 'INTRANET',
+        remote: 'REMOTE',
+        tunnel: 'TUNNEL',
+      },
+      searchPlaceholder: 'Search environments',
+      unknown: 'Not verified',
+    },
+    zh: {
+      checking: '检查中',
+      count: count => `${count} 个环境`,
+      defaultSubtitle: '所有已经部署的 Farming，一个入口。',
+      emptyBody: '试试搜索环境名、所有者或平台。',
+      emptyTitle: '没有匹配的环境',
+      environments: '环境',
+      eyebrow: '你的 FARMING 网络',
+      failed: 'Farming Net 暂时无法读取私有环境列表，请刷新重试。',
+      footer: '一个门户 Token，短时通行已登记的 Farming。',
+      justUpdated: '刚刚更新',
+      privateIndex: '私有门户',
+      reachable: '可访问',
+      refresh: '刷新',
+      scope: {
+        'this-device': '本机',
+        intranet: '内网',
+        remote: '远程',
+        tunnel: '隧道',
+      },
+      searchPlaceholder: '搜索环境',
+      unknown: '未确认',
+    },
+  };
+
+  const language = /^zh\b/i.test(navigator.language || '') ? 'zh' : 'en';
+  const t = copy[language];
+  const state = {
+    query: '',
+    registry: { title: 'Farming Net', subtitle: '', instances: [] },
+    availability: new Map(),
+  };
+
+  const elements = {
+    count: document.getElementById('instance-count'),
+    empty: document.getElementById('empty-state'),
+    grid: document.getElementById('instance-grid'),
+    notice: document.getElementById('notice'),
+    refresh: document.querySelector('[data-testid="net-refresh"]'),
+    search: document.querySelector('[data-testid="net-search"]'),
+    subtitle: document.getElementById('portal-subtitle'),
+    title: document.getElementById('portal-title'),
+    updated: document.getElementById('last-updated'),
+  };
+
+  function applyCopy() {
+    document.documentElement.lang = language === 'zh' ? 'zh-CN' : 'en';
+    document.querySelectorAll('[data-copy]').forEach(element => {
+      const value = t[element.dataset.copy];
+      if (typeof value === 'string') element.textContent = value;
+    });
+    document.querySelectorAll('[data-copy-placeholder]').forEach(element => {
+      const value = t[element.dataset.copyPlaceholder];
+      if (typeof value === 'string') element.setAttribute('placeholder', value);
+    });
+  }
+
+  function cardSearchText(instance) {
+    return [
+      instance.name,
+      instance.owner,
+      instance.platform,
+      instance.description,
+      ...instance.endpoints.map(endpoint => `${endpoint.label} ${endpoint.scope}`),
+    ].join(' ').toLocaleLowerCase();
+  }
+
+  function displayedInstances() {
+    const query = state.query.trim().toLocaleLowerCase();
+    const instances = [...state.registry.instances].sort((left, right) => {
+      if (left.pinned !== right.pinned) return left.pinned ? -1 : 1;
+      return left.name.localeCompare(right.name, language === 'zh' ? 'zh-CN' : 'en');
+    });
+    if (!query) return instances;
+    return instances.filter(instance => cardSearchText(instance).includes(query));
+  }
+
+  function initials(name) {
+    const parts = Array.from(String(name || '').trim());
+    return parts.slice(0, 2).join('').toUpperCase() || 'F';
+  }
+
+  function availabilityElement(instance) {
+    const status = state.availability.get(instance.id) || 'checking';
+    const element = document.createElement('span');
+    element.className = 'availability';
+    element.dataset.state = status;
+    element.dataset.testid = `net-status-${instance.id}`;
+
+    const dot = document.createElement('span');
+    dot.className = 'availability-dot';
+    dot.setAttribute('aria-hidden', 'true');
+    element.append(dot);
+
+    const label = document.createElement('span');
+    label.textContent = status === 'reachable' ? t.reachable : status === 'checking' ? t.checking : t.unknown;
+    element.append(label);
+    return element;
+  }
+
+  function endpointElement(instance, endpoint, endpointIndex) {
+    const link = document.createElement('a');
+    link.className = 'endpoint-link';
+    link.href = endpoint.launchUrl || endpoint.url;
+    link.target = '_blank';
+    link.rel = 'noopener noreferrer';
+    link.dataset.testid = endpointIndex === 0 ? `net-open-${instance.id}` : `net-open-${instance.id}-${endpointIndex + 1}`;
+
+    const label = document.createElement('span');
+    label.className = 'endpoint-label';
+    label.textContent = endpoint.label;
+    link.append(label);
+
+    const scope = document.createElement('span');
+    scope.className = 'endpoint-scope';
+    scope.textContent = t.scope[endpoint.scope] || t.scope.remote;
+    link.append(scope);
+
+    const arrow = document.createElement('span');
+    arrow.className = 'endpoint-arrow';
+    arrow.setAttribute('aria-hidden', 'true');
+    arrow.textContent = '↗';
+    link.append(arrow);
+    return link;
+  }
+
+  function instanceElement(instance) {
+    const card = document.createElement('article');
+    card.className = 'instance-card';
+    card.dataset.testid = `net-instance-card-${instance.id}`;
+
+    const topline = document.createElement('div');
+    topline.className = 'card-topline';
+    const avatar = document.createElement('div');
+    avatar.className = 'instance-avatar';
+    avatar.setAttribute('aria-hidden', 'true');
+    avatar.textContent = initials(instance.name);
+    topline.append(avatar, availabilityElement(instance));
+    card.append(topline);
+
+    const title = document.createElement('h3');
+    title.textContent = instance.name;
+    card.append(title);
+
+    const metadata = document.createElement('p');
+    metadata.className = 'instance-meta';
+    metadata.textContent = [instance.owner, instance.platform].filter(Boolean).join(' · ');
+    card.append(metadata);
+
+    const description = document.createElement('p');
+    description.className = 'instance-description';
+    description.textContent = instance.description || '\u00a0';
+    card.append(description);
+
+    const endpointList = document.createElement('div');
+    endpointList.className = 'endpoint-list';
+    instance.endpoints.forEach((endpoint, index) => endpointList.append(endpointElement(instance, endpoint, index)));
+    card.append(endpointList);
+    return card;
+  }
+
+  function render() {
+    const instances = displayedInstances();
+    elements.grid.replaceChildren(...instances.map(instanceElement));
+    elements.grid.setAttribute('aria-busy', 'false');
+    elements.empty.hidden = instances.length !== 0;
+    elements.count.textContent = t.count(instances.length);
+  }
+
+  async function probeInstance(instance) {
+    const endpoint = instance.endpoints.find(item => item.primary) || instance.endpoints[0];
+    if (!endpoint) return;
+    const controller = new window.AbortController();
+    const timeout = window.setTimeout(() => controller.abort(), 2500);
+    try {
+      const statusUrl = new URL('api/auth/status', endpoint.url);
+      await fetch(statusUrl, {
+        cache: 'no-store',
+        credentials: 'include',
+        mode: 'no-cors',
+        signal: controller.signal,
+      });
+      state.availability.set(instance.id, 'reachable');
+    } catch {
+      state.availability.set(instance.id, 'unknown');
+    } finally {
+      window.clearTimeout(timeout);
+      render();
+    }
+  }
+
+  async function loadRegistry() {
+    elements.notice.hidden = true;
+    elements.refresh.disabled = true;
+    elements.refresh.classList.add('is-loading');
+    elements.grid.setAttribute('aria-busy', 'true');
+    try {
+      const response = await fetch('api/instances', { cache: 'no-store', credentials: 'same-origin' });
+      if (!response.ok) throw new Error(`Registry request failed with ${response.status}`);
+      const registry = await response.json();
+      state.registry = registry;
+      state.availability = new Map(registry.instances.map(instance => [instance.id, 'checking']));
+      elements.title.textContent = registry.title || 'Farming Net';
+      elements.subtitle.textContent = registry.subtitle || t.defaultSubtitle;
+      document.title = registry.title || 'Farming Net';
+      elements.updated.textContent = t.justUpdated;
+      render();
+      registry.instances.forEach(instance => void probeInstance(instance));
+    } catch (error) {
+      console.error(error);
+      state.registry = { title: 'Farming Net', subtitle: '', instances: [] };
+      elements.notice.textContent = t.failed;
+      elements.notice.hidden = false;
+      render();
+    } finally {
+      elements.refresh.disabled = false;
+      elements.refresh.classList.remove('is-loading');
+    }
+  }
+
+  elements.search.addEventListener('input', event => {
+    state.query = event.target.value;
+    render();
+  });
+  elements.refresh.addEventListener('click', () => void loadRegistry());
+  document.addEventListener('keydown', event => {
+    if (event.key === '/' && document.activeElement !== elements.search) {
+      event.preventDefault();
+      elements.search.focus();
+    }
+    if (event.key === 'Escape' && document.activeElement === elements.search) {
+      elements.search.value = '';
+      state.query = '';
+      render();
+      elements.search.blur();
+    }
+  });
+
+  applyCopy();
+  void loadRegistry();
+})();

package/frontend/farming-net/index.html

@@ -0,0 +1,86 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="color-scheme" content="light dark">
+    <meta name="theme-color" content="#0d1712">
+    <meta name="description" content="A private index for deployed Farming workspaces.">
+    <link rel="icon" type="image/png" href="icon.png">
+    <link rel="stylesheet" href="app.css?v=font-spacing-1">
+    <script src="app.js?v=federated-pass-1" defer></script>
+    <title>Farming Net</title>
+  </head>
+  <body>
+    <div class="page-glow page-glow-one" aria-hidden="true"></div>
+    <div class="page-glow page-glow-two" aria-hidden="true"></div>
+
+    <div class="shell">
+      <header class="topbar">
+        <a class="brand" href="./" aria-label="Farming Net">
+          <img class="brand-icon" src="icon.png" alt="">
+          <span>Farming Net</span>
+        </a>
+        <div class="private-badge">
+          <span class="private-badge-dot" aria-hidden="true"></span>
+          <span data-copy="privateIndex">Private index</span>
+        </div>
+      </header>
+
+      <main>
+        <section class="hero" aria-labelledby="portal-title">
+          <p class="eyebrow" data-copy="eyebrow">YOUR FARMING NETWORK</p>
+          <h1 id="portal-title">Farming Net</h1>
+          <p id="portal-subtitle" class="subtitle" data-copy="defaultSubtitle">
+            All your deployed Farming workspaces, one click away.
+          </p>
+        </section>
+
+        <section class="toolbar" aria-label="Portal controls">
+          <label class="search-field" for="instance-search">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <path d="m21 21-4.35-4.35m2.35-5.15a7.5 7.5 0 1 1-15 0 7.5 7.5 0 0 1 15 0Z"></path>
+            </svg>
+            <input
+              id="instance-search"
+              data-testid="net-search"
+              type="search"
+              autocomplete="off"
+              data-copy-placeholder="searchPlaceholder"
+              placeholder="Search environments"
+            >
+            <kbd>/</kbd>
+          </label>
+          <button class="refresh-button" data-testid="net-refresh" type="button">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <path d="M20 11a8.1 8.1 0 0 0-15.5-2M4 4v5h5m-5 4a8.1 8.1 0 0 0 15.5 2M20 20v-5h-5"></path>
+            </svg>
+            <span data-copy="refresh">Refresh</span>
+          </button>
+        </section>
+
+        <section class="directory" aria-labelledby="directory-title">
+          <div class="directory-heading">
+            <h2 id="directory-title" data-copy="environments">Environments</h2>
+            <span id="instance-count" class="instance-count">—</span>
+          </div>
+
+          <div id="notice" class="notice" role="status" aria-live="polite" hidden></div>
+          <div id="instance-grid" class="instance-grid" aria-live="polite" aria-busy="true"></div>
+
+          <div id="empty-state" class="empty-state" hidden>
+            <div class="empty-mark" aria-hidden="true">⌘</div>
+            <h3 data-copy="emptyTitle">No matching environment</h3>
+            <p data-copy="emptyBody">Try another name, owner, or platform.</p>
+          </div>
+        </section>
+      </main>
+
+      <footer>
+        <span data-copy="footer">One portal token. Short-lived passes for enrolled Farms.</span>
+        <span class="footer-separator" aria-hidden="true"></span>
+        <span id="last-updated"></span>
+      </footer>
+    </div>
+  </body>
+</html>

package/frontend/reading-anchor.js

@@ -0,0 +1,198 @@
+// A skin-neutral, per-tab reading-location protocol.  Renderers own how they
+// resolve an anchor; this module owns only its stable shape and transport-safe
+// storage.  Never put terminal text in an anchor: terminal locations use a
+// short fingerprint of adjacent logical lines instead.
+(function installFarmingReadingAnchors(global) {
+  'use strict';
+
+  const VERSION = 1;
+  const STORAGE_PREFIX = 'farming.reading-anchor.v1:';
+  const SURFACES = new Set(['chat', 'terminal', 'file']);
+  const LIMITS = { id: 512, path: 2048, workspace: 2048, encoded: 1800 };
+
+  function boundedString(value, limit) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    return text && text.length <= limit && !text.includes('\0') ? text : '';
+  }
+
+  function finiteNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : null;
+  }
+
+  function normalizeAnchor(value) {
+    if (!value || typeof value !== 'object' || Number(value.version) !== VERSION) return null;
+    const surface = boundedString(value.surface, 16);
+    const resource = value.resource && typeof value.resource === 'object' ? value.resource : null;
+    const locator = value.locator && typeof value.locator === 'object' ? value.locator : null;
+    const position = value.position && typeof value.position === 'object' ? value.position : null;
+    if (!SURFACES.has(surface) || !resource || !locator || !position) return null;
+
+    if (surface === 'file') {
+      const workspace = boundedString(resource.workspace, LIMITS.workspace);
+      const path = boundedString(resource.path, LIMITS.path);
+      const line = finiteNumber(position.value);
+      const column = finiteNumber(position.column);
+      if (resource.kind !== 'file' || locator.kind !== 'file-line' || !workspace || !path || !Number.isInteger(line) || line < 1) return null;
+      return {
+        version: VERSION,
+        surface,
+        resource: { kind: 'file', workspace, path },
+        locator: { kind: 'file-line', id: path },
+        position: {
+          unit: 'line-column',
+          value: line,
+          ...(Number.isInteger(column) && column >= 1 ? { column } : {}),
+        },
+      };
+    }
+
+    const agentId = boundedString(resource.id, LIMITS.id);
+    const locatorId = boundedString(locator.id, LIMITS.id);
+    if (resource.kind !== 'agent' || !agentId || !locatorId) return null;
+    if (surface === 'chat') {
+      const fraction = finiteNumber(position.value);
+      const childId = boundedString(locator.childId, LIMITS.id);
+      if (locator.kind !== 'message' || position.unit !== 'fraction' || fraction === null || fraction < 0 || fraction > 1) return null;
+      return {
+        version: VERSION,
+        surface,
+        resource: { kind: 'agent', id: agentId },
+        locator: { kind: 'message', id: locatorId, ...(childId ? { childId } : {}) },
+        position: { unit: 'fraction', value: fraction },
+      };
+    }
+
+    const rowOffset = finiteNumber(position.value);
+    const lineCount = finiteNumber(locator.lineCount);
+    if (locator.kind !== 'terminal-lines' || position.unit !== 'row' || !Number.isInteger(rowOffset) || rowOffset < 0) return null;
+    return {
+      version: VERSION,
+      surface,
+      resource: { kind: 'agent', id: agentId },
+      locator: {
+        kind: 'terminal-lines',
+        id: locatorId,
+        ...(Number.isInteger(lineCount) && lineCount > 0 ? { lineCount } : {}),
+      },
+      position: { unit: 'row', value: rowOffset },
+    };
+  }
+
+  function keyFor(anchor) {
+    const normalized = normalizeAnchor(anchor);
+    if (!normalized) return '';
+    if (normalized.resource.kind === 'file') {
+      return `file:${normalized.resource.workspace}:${normalized.resource.path}`;
+    }
+    return `agent:${normalized.resource.id}:${normalized.surface}`;
+  }
+
+  function storageKey(key) {
+    return `${STORAGE_PREFIX}${key}`;
+  }
+
+  function save(anchor) {
+    const normalized = normalizeAnchor(anchor);
+    const key = normalized && keyFor(normalized);
+    if (!normalized || !key) return null;
+    try {
+      global.sessionStorage.setItem(storageKey(key), JSON.stringify(normalized));
+    } catch {
+      // Private browsing or an exhausted browser store must not break viewing.
+    }
+    return normalized;
+  }
+
+  function read(key) {
+    if (!key) return null;
+    try {
+      const parsed = JSON.parse(global.sessionStorage.getItem(storageKey(key)) || 'null');
+      const normalized = normalizeAnchor(parsed);
+      if (!normalized || keyFor(normalized) !== key) {
+        if (parsed) global.sessionStorage.removeItem(storageKey(key));
+        return null;
+      }
+      return normalized;
+    } catch {
+      return null;
+    }
+  }
+
+  function remove(key) {
+    if (!key) return;
+    try {
+      global.sessionStorage.removeItem(storageKey(key));
+    } catch {
+      // Best-effort only.
+    }
+  }
+
+  function agentKey(agentId, surface) {
+    return `agent:${String(agentId || '').trim()}:${surface}`;
+  }
+
+  function fileKey(workspace, path) {
+    return `file:${String(workspace || '').trim()}:${String(path || '').trim()}`;
+  }
+
+  function fingerprint(parts) {
+    const value = (Array.isArray(parts) ? parts : [parts])
+      .map(part => String(part || '').slice(0, 2048))
+      .join('\u001f');
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+      hash ^= value.charCodeAt(index);
+      hash = Math.imul(hash, 0x01000193);
+    }
+    return `fnv1a-${(hash >>> 0).toString(36)}-${value.length.toString(36)}`;
+  }
+
+  function encode(anchor) {
+    const normalized = normalizeAnchor(anchor);
+    if (!normalized) return '';
+    try {
+      const text = JSON.stringify(normalized);
+      const encoded = global.btoa(unescape(encodeURIComponent(text)))
+        .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+      return encoded.length <= LIMITS.encoded ? encoded : '';
+    } catch {
+      return '';
+    }
+  }
+
+  function decode(encoded) {
+    const compact = boundedString(encoded, LIMITS.encoded);
+    if (!compact || !/^[A-Za-z0-9_-]+$/.test(compact)) return null;
+    try {
+      const padded = compact.replace(/-/g, '+').replace(/_/g, '/') + '==='.slice((compact.length + 3) % 4);
+      return normalizeAnchor(JSON.parse(decodeURIComponent(escape(global.atob(padded)))));
+    } catch {
+      return null;
+    }
+  }
+
+  function importEncoded(encoded) {
+    const anchor = decode(encoded);
+    return anchor ? save(anchor) : null;
+  }
+
+  function importFromSearch(search) {
+    const params = new global.URLSearchParams(search || global.location.search || '');
+    return importEncoded(params.get('fra') || '');
+  }
+
+  global.FarmingReadingAnchors = {
+    VERSION,
+    agentKey,
+    fileKey,
+    save,
+    read,
+    remove,
+    fingerprint,
+    encode,
+    decode,
+    importEncoded,
+    importFromSearch,
+  };
+}(window));

package/frontend/session-bridge.js

@@ -23,7 +23,7 @@
         });
       },
 
-      sendInput(agentId, input) {
+      sendTerminalInput(agentId, input) {
         return send({
           type: 'input',
           agentId,
@@ -56,6 +56,13 @@
         });
       },
 
+      clearTerminal(agentId) {
+        return send({
+          type: 'clear-terminal',
+          agentId,
+        });
+      },
+
       killAgent(agentId) {
         return send({
           type: 'kill-agent',
@@ -63,11 +70,13 @@
         });
       },
 
-      async getSessionView(agentId) {
+      async getSessionView(agentId, options = {}) {
         const path = global.FarmingRuntimePaths
           ? global.FarmingRuntimePaths.apiPath(`/agents/${agentId}/session-view`)
           : `/api/agents/${agentId}/session-view`;
-        const response = await fetchImpl(path);
+        const response = await fetchImpl(path, {
+          ...(options.signal ? { signal: options.signal } : {}),
+        });
         if (!response.ok) {
           throw new Error(`Failed to load session view: ${response.status}`);
         }

package/frontend/session-modal-bridge.js

@@ -22,8 +22,8 @@
       };
     }
 
-    function shouldPollSessionView(sessionSource) {
-      return sessionSource === 'live-text';
+    function shouldPollSessionView(_sessionSource) {
+      return false;
     }
 
     function getDomState(documentRef) {
@@ -96,7 +96,7 @@
             return;
           }
 
-          if (fitAddon && fitAddon.fit) {
+          if (fitAddon && fitAddon.fit && options.authoritativeGeometry !== true) {
             fitAddon.fit();
           }
 
@@ -284,15 +284,8 @@
 
         startPolling(context = {}) {
           this.stopPolling();
-          if (!options.schedulePoll || !options.refreshSessionView) {
-            return null;
-          }
-
-          poller = options.schedulePoll(() => {
-            options.refreshSessionView(false, context.agentId, context.sessionToken);
-          });
-          syncPoller();
-          return poller;
+          void context;
+          return null;
         },
 
         stopPolling() {