farming-code 2.2.30 → 2.2.32

package/backend/session-engine-bridge.js

@@ -1,129 +0,0 @@
-const EventEmitter = require('events');
-const SessionEngineRouter = require('./session-engine-router');
-
-class SessionEngineBridge extends EventEmitter {
-  constructor(configManager) {
-    super();
-    this.router = new SessionEngineRouter(configManager);
-    this.bindEngineEvents();
-  }
-
-  bindEngineEvents() {
-    Object.entries(this.router.engines).forEach(([engineName, engine]) => {
-      engine.on('session-started', (payload) => {
-        this.emit('session-started', { engineName, ...payload });
-      });
-      engine.on('session-output', (payload) => {
-        this.emit('session-output', { engineName, ...payload });
-      });
-      engine.on('session-transition', (payload) => {
-        this.emit('session-transition', { engineName, ...payload });
-      });
-      engine.on('session-sync', (payload) => {
-        this.emit('session-sync', { engineName, ...payload });
-      });
-      engine.on('session-preview', (payload) => {
-        this.emit('session-preview', { engineName, ...payload });
-      });
-      engine.on('session-title', (payload) => {
-        this.emit('session-title', { engineName, ...payload });
-      });
-      engine.on('session-activity', (payload) => {
-        this.emit('session-activity', { engineName, ...payload });
-      });
-      engine.on('session-busy-state', (payload) => {
-        this.emit('session-busy-state', { engineName, ...payload });
-      });
-      engine.on('session-exited', (payload) => {
-        this.emit('session-exited', { engineName, ...payload });
-      });
-      engine.on('session-error', (payload) => {
-        this.emit('session-error', { engineName, ...payload });
-      });
-    });
-  }
-
-  resolve(command) {
-    return this.router.resolve(command);
-  }
-
-  getEngine(name) {
-    return this.router.getEngine(name);
-  }
-
-  async createSession(command, options) {
-    const resolution = this.resolve(command);
-    await resolution.engine.createSession(options);
-    return resolution;
-  }
-
-  async sendInput(engineName, sessionId, input, options = {}) {
-    const engine = this.getEngine(engineName);
-    if (!engine) return;
-    return engine.sendInput(sessionId, input, options);
-  }
-
-  async resizeSession(engineName, sessionId, cols, rows) {
-    const engine = this.getEngine(engineName);
-    if (!engine || !engine.resizeSession) return;
-    return engine.resizeSession(sessionId, cols, rows);
-  }
-
-  async clearBuffer(engineName, sessionId) {
-    const engine = this.getEngine(engineName);
-    if (!engine || !engine.clearBuffer) return;
-    return engine.clearBuffer(sessionId);
-  }
-
-  async killSession(engineName, sessionId) {
-    const engine = this.getEngine(engineName);
-    if (!engine) return;
-    return engine.killSession(sessionId);
-  }
-
-  async getSessionState(engineName, sessionId) {
-    const engine = this.getEngine(engineName);
-    if (!engine) return null;
-    return engine.getSessionState(sessionId);
-  }
-
-  async getSessionAttachCheckpoint(engineName, sessionId) {
-    const engine = this.getEngine(engineName);
-    if (!engine || !engine.getSessionAttachCheckpoint) return null;
-    return engine.getSessionAttachCheckpoint(sessionId);
-  }
-
-  async getSessionPreview(engineName, sessionId) {
-    const engine = this.getEngine(engineName);
-    if (!engine) return '';
-    return engine.getSessionPreview(sessionId);
-  }
-
-  async recoverSessions(options = {}) {
-    const recovered = [];
-    for (const [engineName, engine] of Object.entries(this.router.engines)) {
-      if (!engine || typeof engine.recoverSessions !== 'function') continue;
-      const sessions = await engine.recoverSessions(options);
-      for (const session of sessions || []) {
-        recovered.push({ engineName, ...session });
-      }
-    }
-    return recovered;
-  }
-
-  consumeRuntimeRotations() {
-    const rotations = [];
-    for (const [engineName, engine] of Object.entries(this.router.engines)) {
-      if (!engine || typeof engine.consumeRuntimeRotation !== 'function') continue;
-      const rotation = engine.consumeRuntimeRotation();
-      if (rotation) rotations.push({ engineName, ...rotation });
-    }
-    return rotations;
-  }
-
-  dispose(options = {}) {
-    return this.router.dispose(options);
-  }
-}
-
-module.exports = SessionEngineBridge;

package/backend/session-engine-router.js

@@ -1,66 +0,0 @@
-const { getAgentSpec } = require('./cli-agents');
-const LocalSessionEngine = require('./local-session-engine');
-const NativeSessionEngine = require('./native-session-engine');
-
-class SessionEngineRouter {
-  constructor(configManager, options = {}) {
-    const configDir = configManager && configManager.farmingDir;
-    const preserveNativeHost = options.preserveNativeHost !== undefined
-      ? options.preserveNativeHost === true
-      : process.env.FARMING_NATIVE_PTY_HOST_PERSIST !== '0';
-    this.engines = {
-      native: new NativeSessionEngine({ configDir, preserveHostOnDispose: preserveNativeHost }),
-      local: new LocalSessionEngine({ configDir })
-    };
-    this.overrideEngineName = process.env.FARMING_SESSION_ENGINE || '';
-    this.defaultEngineName = options.defaultEngineName || this.overrideEngineName || 'native';
-  }
-
-  getEngine(name) {
-    return this.engines[name] || null;
-  }
-
-  resolve(command) {
-    const spec = getAgentSpec(command);
-
-    if (!spec) {
-      const engineName = this.engines[this.defaultEngineName]
-        ? this.defaultEngineName
-        : (this.engines.native ? 'native' : 'local');
-      return {
-        engine: this.engines[engineName],
-        engineName,
-        spec: null
-      };
-    }
-
-    if (!spec.supported) {
-      throw new Error(`${spec.name} is not supported in Farming yet`);
-    }
-
-    const engineName = this.overrideEngineName || spec.preferredEngine || this.defaultEngineName;
-    const engine = this.getEngine(engineName);
-
-    if (!engine) {
-      throw new Error(`No session engine available for ${spec.name}`);
-    }
-
-    return {
-      engine,
-      engineName,
-      spec
-    };
-  }
-
-  dispose(options = {}) {
-    const disposals = Object.values(this.engines).map((engine) => {
-      if (engine && typeof engine.dispose === 'function') {
-        return engine.dispose(options);
-      }
-      return undefined;
-    });
-    return Promise.allSettled(disposals);
-  }
-}
-
-module.exports = SessionEngineRouter;

package/backend/session-engine.js

@@ -1,39 +0,0 @@
-const EventEmitter = require('events');
-
-class SessionEngine extends EventEmitter {
-  async createSession(_options) {
-    throw new Error('createSession() must be implemented by subclasses');
-  }
-
-  async sendInput(_sessionId, _input) {
-    throw new Error('sendInput() must be implemented by subclasses');
-  }
-
-  async interruptSession(_sessionId, _input, _options = {}) {
-    throw new Error('interruptSession() must be implemented by subclasses');
-  }
-
-  async resizeSession(_sessionId, _cols, _rows) {
-    throw new Error('resizeSession() must be implemented by subclasses');
-  }
-
-  async clearBuffer(_sessionId) {
-    throw new Error('clearBuffer() must be implemented by subclasses');
-  }
-
-  async killSession(_sessionId) {
-    throw new Error('killSession() must be implemented by subclasses');
-  }
-
-  async getSessionState(_sessionId) {
-    throw new Error('getSessionState() must be implemented by subclasses');
-  }
-
-  async getSessionPreview(_sessionId) {
-    throw new Error('getSessionPreview() must be implemented by subclasses');
-  }
-
-  dispose() {}
-}
-
-module.exports = SessionEngine;

package/backend/session-stream-protocol.js

@@ -1,185 +0,0 @@
-function finiteNumber(value) {
-  return Number.isFinite(value) ? value : undefined;
-}
-
-function nonEmptyString(value) {
-  return typeof value === 'string' && value ? value : undefined;
-}
-
-function transitionKind(value) {
-  return value === 'resize' || value === 'clear' ? value : 'output';
-}
-
-function transitionChunks(stream, data, runtimeEpoch, outputSeq, stateRevision) {
-  if (Array.isArray(stream.chunks)) {
-    return stream.chunks.map(chunk => ({
-      kind: transitionKind(chunk.kind),
-      data: typeof chunk.data === 'string' ? chunk.data : String(chunk.data || ''),
-      runtimeEpoch: nonEmptyString(chunk.runtimeEpoch),
-      outputSeq: finiteNumber(chunk.outputSeq),
-      stateRevision: finiteNumber(chunk.stateRevision),
-      cols: finiteNumber(chunk.cols),
-      rows: finiteNumber(chunk.rows),
-    }));
-  }
-  if (stream.replace === true || !runtimeEpoch || outputSeq === undefined || stateRevision === undefined) {
-    return undefined;
-  }
-  return [{
-    kind: transitionKind(stream.kind),
-    data,
-    runtimeEpoch,
-    outputSeq,
-    stateRevision,
-    cols: finiteNumber(stream.cols),
-    rows: finiteNumber(stream.rows),
-  }];
-}
-
-function normalizeSessionStream(stream) {
-  const data = typeof stream.data === 'string' ? stream.data : String(stream.data || '');
-  const runtimeEpoch = nonEmptyString(stream.runtimeEpoch);
-  const outputSeq = finiteNumber(stream.outputSeq);
-  const stateRevision = finiteNumber(stream.stateRevision);
-  return {
-    ...stream,
-    kind: transitionKind(stream.kind),
-    data,
-    replace: stream.replace === true,
-    runtimeEpoch,
-    outputSeq,
-    stateRevision,
-    cols: finiteNumber(stream.cols),
-    rows: finiteNumber(stream.rows),
-    chunks: transitionChunks(stream, data, runtimeEpoch, outputSeq, stateRevision),
-  };
-}
-
-function coalesceSessionStream(existingStream, incomingStream) {
-  const incoming = normalizeSessionStream(incomingStream);
-  if (!existingStream) {
-    return incoming;
-  }
-
-  const existing = normalizeSessionStream(existingStream);
-  if (incoming.replace) {
-    if (
-      !existing.runtimeEpoch ||
-      !incoming.runtimeEpoch ||
-      existing.runtimeEpoch !== incoming.runtimeEpoch
-    ) {
-      return incoming;
-    }
-    const existingRevision = finiteNumber(existing.stateRevision);
-    const incomingRevision = finiteNumber(incoming.stateRevision);
-    if (
-      existing.replace &&
-      existingRevision !== undefined &&
-      incomingRevision !== undefined &&
-      existingRevision > incomingRevision
-    ) {
-      return existing;
-    }
-    if (incomingRevision === undefined) return incoming;
-    const uncoveredChunks = (existing.chunks || []).filter(chunk => (
-      chunk.runtimeEpoch === incoming.runtimeEpoch &&
-      Number.isFinite(chunk.stateRevision) &&
-      chunk.stateRevision > incomingRevision
-    ));
-    return {
-      ...incoming,
-      chunks: uncoveredChunks.length > 0 ? uncoveredChunks : undefined,
-    };
-  }
-
-  if (
-    !existing.runtimeEpoch ||
-    !incoming.runtimeEpoch ||
-    existing.runtimeEpoch !== incoming.runtimeEpoch
-  ) {
-    return incoming;
-  }
-
-  const incomingHasProof = incoming.outputSeq !== undefined && incoming.stateRevision !== undefined;
-  if (!incomingHasProof) {
-    // Do not let unproved bytes inherit a previous checkpoint's proof. The
-    // browser will enter its checkpoint barrier when it receives this stream.
-    return incoming;
-  }
-
-  if (existing.replace) {
-    return {
-      ...existing,
-      data: existing.data,
-      replace: true,
-      cols: existing.cols,
-      rows: existing.rows,
-      chunks: [
-        ...(existing.chunks || []),
-        ...(incoming.chunks || []),
-      ],
-    };
-  }
-
-  return {
-    ...existing,
-    ...incoming,
-    data: `${existing.data}${incoming.data}`,
-    replace: false,
-    runtimeEpoch: incoming.runtimeEpoch,
-    outputSeq: incoming.outputSeq,
-    stateRevision: incoming.stateRevision,
-    cols: incoming.cols ?? existing.cols,
-    rows: incoming.rows ?? existing.rows,
-    chunks: [
-      ...(existing.chunks || []),
-      ...(incoming.chunks || []),
-    ],
-  };
-}
-
-function shouldBroadcastSessionStreamImmediately(options = {}) {
-  const pendingCount = Number.isFinite(options.pendingCount) ? options.pendingCount : 0;
-  const lastBroadcastAt = Number.isFinite(options.lastBroadcastAt) ? options.lastBroadcastAt : 0;
-  const now = Number.isFinite(options.now) ? options.now : Date.now();
-  const intervalMs = Number.isFinite(options.intervalMs) ? Math.max(0, options.intervalMs) : 0;
-  return pendingCount === 0 && (lastBroadcastAt === 0 || now - lastBroadcastAt >= intervalMs);
-}
-
-function deliverSessionStreamToClients(clients, stream, options = {}) {
-  const openState = options.openState ?? 1;
-  const maxBufferedAmount = Number.isFinite(options.maxBufferedAmount)
-    ? options.maxBufferedAmount
-    : 4 * 1024 * 1024;
-  const message = options.message || JSON.stringify({
-    type: 'session-output',
-    stream,
-  });
-  const result = { sent: 0, closed: 0, skipped: 0 };
-
-  for (const client of clients || []) {
-    if (!client || client.readyState !== openState) {
-      result.skipped += 1;
-      continue;
-    }
-    if (client.streamScope === 'focused' && client.focusedAgentId !== stream.agentId) {
-      result.skipped += 1;
-      continue;
-    }
-    if (client.bufferedAmount > maxBufferedAmount) {
-      client.close(1013, 'terminal stream backpressure');
-      result.closed += 1;
-      continue;
-    }
-    client.send(message);
-    result.sent += 1;
-  }
-  return result;
-}
-
-module.exports = {
-  coalesceSessionStream,
-  deliverSessionStreamToClients,
-  normalizeSessionStream,
-  shouldBroadcastSessionStreamImmediately,
-};