farming-code 2.2.29 → 2.2.32

package/backend/workspace-directory.cjs

@@ -0,0 +1,239 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_directory_exports = {};
+__export(workspace_directory_exports, {
+  browseWorkspaceDirectory: () => browseWorkspaceDirectory,
+  createWorkspaceDirectoryRouter: () => createWorkspaceDirectoryRouter,
+  prepareWorkspaceDirectory: () => prepareWorkspaceDirectory,
+  resolveWorkspaceDirectory: () => resolveWorkspaceDirectory
+});
+module.exports = __toCommonJS(workspace_directory_exports);
+const express = require("express");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const CREATE_FORBIDDEN_CODES = /* @__PURE__ */ new Set(["EACCES", "EPERM", "EROFS"]);
+const INVALID_PATH_CODES = /* @__PURE__ */ new Set(["EINVAL", "ENAMETOOLONG"]);
+const DEFAULT_BROWSE_LIMIT = 500;
+const expressFactory = express;
+function errorCode(error) {
+  return error instanceof Error && "code" in error ? String(error.code) : "";
+}
+function resolveWorkspaceDirectory(value, homeDir = process.env.HOME || os.homedir()) {
+  const input = typeof value === "string" ? value.trim() : "";
+  if (!input) return "";
+  const expanded = input === "~" ? homeDir : input.startsWith("~/") ? path.join(homeDir, input.slice(2)) : input;
+  return path.resolve(expanded);
+}
+function workspaceDirectoryError(error, workspace) {
+  const code = errorCode(error);
+  if (CREATE_FORBIDDEN_CODES.has(code)) {
+    return {
+      status: 403,
+      body: {
+        status: "rejected",
+        code: "workspace-create-forbidden",
+        workspace,
+        message: `Farming does not have permission to create this directory: ${workspace}`
+      }
+    };
+  }
+  if (code === "ENOTDIR") {
+    return {
+      status: 409,
+      body: {
+        status: "rejected",
+        code: "workspace-parent-not-directory",
+        workspace,
+        message: `A parent path is not a directory: ${workspace}`
+      }
+    };
+  }
+  if (code === "EEXIST") {
+    return {
+      status: 409,
+      body: {
+        status: "rejected",
+        code: "workspace-not-directory",
+        workspace,
+        message: `Workspace path is not a directory: ${workspace}`
+      }
+    };
+  }
+  if (INVALID_PATH_CODES.has(code)) {
+    return {
+      status: 400,
+      body: {
+        status: "rejected",
+        code: "workspace-invalid-path",
+        workspace,
+        message: "Workspace path is invalid"
+      }
+    };
+  }
+  return {
+    status: 500,
+    body: {
+      status: "rejected",
+      code: "workspace-create-failed",
+      workspace,
+      message: `Failed to create workspace directory: ${workspace}`
+    }
+  };
+}
+async function prepareWorkspaceDirectory(value, options = {}) {
+  const workspace = resolveWorkspaceDirectory(value, options.homeDir);
+  if (!workspace) {
+    return {
+      status: 400,
+      body: {
+        status: "rejected",
+        code: "workspace-path-required",
+        workspace: "",
+        message: "Workspace path is required"
+      }
+    };
+  }
+  const fileSystem = options.fileSystem || fs.promises;
+  try {
+    const stat = await fileSystem.stat(workspace);
+    if (!stat.isDirectory()) {
+      return {
+        status: 409,
+        body: {
+          status: "rejected",
+          code: "workspace-not-directory",
+          workspace,
+          message: `Workspace path is not a directory: ${workspace}`
+        }
+      };
+    }
+    return { status: 200, body: { status: "ready", workspace } };
+  } catch (error) {
+    if (errorCode(error) !== "ENOENT") return workspaceDirectoryError(error, workspace);
+  }
+  if (options.create !== true) {
+    return {
+      status: 409,
+      body: {
+        status: "missing",
+        code: "workspace-not-found",
+        workspace,
+        message: `Workspace directory does not exist: ${workspace}`
+      }
+    };
+  }
+  try {
+    await fileSystem.mkdir(workspace, { recursive: true });
+    const stat = await fileSystem.stat(workspace);
+    if (!stat.isDirectory()) {
+      return workspaceDirectoryError({ code: "EEXIST" }, workspace);
+    }
+    return { status: 201, body: { status: "created", workspace } };
+  } catch (error) {
+    return workspaceDirectoryError(error, workspace);
+  }
+}
+async function browseWorkspaceDirectory(value, options = {}) {
+  const workspace = resolveWorkspaceDirectory(value || "~", options.homeDir);
+  const fileSystem = options.fileSystem || fs.promises;
+  let entries;
+  try {
+    const stat = await fileSystem.stat(workspace);
+    if (!stat.isDirectory()) {
+      return {
+        status: 409,
+        body: {
+          status: "rejected",
+          code: "workspace-not-directory",
+          workspace,
+          message: `Workspace path is not a directory: ${workspace}`
+        }
+      };
+    }
+    entries = await fileSystem.readdir(workspace, { withFileTypes: true });
+  } catch (error) {
+    const code = errorCode(error);
+    const forbidden = CREATE_FORBIDDEN_CODES.has(code);
+    const missing = code === "ENOENT";
+    return {
+      status: forbidden ? 403 : missing ? 404 : 500,
+      body: {
+        status: "rejected",
+        code: forbidden ? "workspace-browse-forbidden" : missing ? "workspace-not-found" : "workspace-browse-failed",
+        workspace,
+        message: forbidden ? `Farming does not have permission to read this directory: ${workspace}` : missing ? `Workspace directory does not exist: ${workspace}` : `Failed to read workspace directory: ${workspace}`
+      }
+    };
+  }
+  const directories = (await Promise.all(entries.map(async (entry) => {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) return null;
+    const childPath = path.join(workspace, entry.name);
+    if (entry.isSymbolicLink()) {
+      try {
+        const stat = await fileSystem.stat(childPath);
+        if (!stat.isDirectory()) return null;
+      } catch {
+        return null;
+      }
+    }
+    return { name: entry.name, path: childPath };
+  }))).filter((entry) => entry !== null).sort((left, right) => left.name.localeCompare(right.name));
+  const limit = Math.max(1, Math.min(Number(options.limit) || DEFAULT_BROWSE_LIMIT, DEFAULT_BROWSE_LIMIT));
+  const parentPath = path.dirname(workspace);
+  return {
+    status: 200,
+    body: {
+      status: "ready",
+      workspace,
+      parent: parentPath === workspace ? null : parentPath,
+      directories: directories.slice(0, limit),
+      truncated: directories.length > limit
+    }
+  };
+}
+function createWorkspaceDirectoryRouter(options = {}) {
+  const router = expressFactory.Router();
+  router.use(expressFactory.json({ limit: "8kb" }));
+  router.get("/browse", async (req, res) => {
+    const result = await browseWorkspaceDirectory(req.query?.path, {
+      fileSystem: options.fileSystem,
+      homeDir: options.homeDir,
+      limit: req.query?.limit
+    });
+    res.status(result.status).json(result.body);
+  });
+  router.post("/prepare", async (req, res) => {
+    const result = await prepareWorkspaceDirectory(req.body?.workspace, {
+      create: req.body?.create === true,
+      fileSystem: options.fileSystem,
+      homeDir: options.homeDir
+    });
+    res.status(result.status).json(result.body);
+  });
+  return router;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  browseWorkspaceDirectory,
+  createWorkspaceDirectoryRouter,
+  prepareWorkspaceDirectory,
+  resolveWorkspaceDirectory
+});

package/backend/workspace-discovery.cjs

@@ -0,0 +1,271 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_discovery_exports = {};
+__export(workspace_discovery_exports, {
+  discoverAgentWorkspaces: () => discoverAgentWorkspaces,
+  isTemporaryWorkspace: () => isTemporaryWorkspace,
+  normalizeWorkspacePath: () => normalizeWorkspacePath,
+  resolveEncodedProjectDirectory: () => resolveEncodedProjectDirectory
+});
+module.exports = __toCommonJS(workspace_discovery_exports);
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const DEFAULT_LIMIT = 12;
+const MAX_PROJECT_DIRS_PER_AGENT = 80;
+const MAX_FILES_PER_PROJECT = 8;
+const MAX_JSONL_LINES = 40;
+const MAX_JSON_BYTES = 128 * 1024;
+const AGENT_CONFIG_DIRS = /* @__PURE__ */ new Set([".claude", ".qwen", ".codex"]);
+const DISCOVERABLE_AGENT_NAMES = /* @__PURE__ */ new Set(["claude", "qwen", "codex"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function normalizeWorkspacePath(workspace) {
+  if (typeof workspace !== "string") return "";
+  const value = workspace.trim();
+  if (!value || value.startsWith("/var")) return "";
+  const expanded = value === "~" ? os.homedir() : value.startsWith("~/") ? path.join(os.homedir(), value.slice(2)) : value;
+  try {
+    const resolved = fs.realpathSync(expanded);
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) return "";
+    if (isTemporaryWorkspace(resolved)) return "";
+    const basename = path.basename(resolved);
+    if (AGENT_CONFIG_DIRS.has(basename)) {
+      const parent = path.dirname(resolved);
+      return fs.statSync(parent).isDirectory() ? parent : "";
+    }
+    return resolved;
+  } catch {
+    return "";
+  }
+}
+function isTemporaryWorkspace(workspace) {
+  return workspace === "/tmp" || workspace.startsWith("/tmp/") || workspace === "/private/tmp" || workspace.startsWith("/private/tmp/") || workspace === "/var/tmp" || workspace.startsWith("/var/tmp/") || workspace === "/private/var/tmp" || workspace.startsWith("/private/var/tmp/") || workspace === "/var/folders" || workspace.startsWith("/var/folders/") || workspace === "/private/var/folders" || workspace.startsWith("/private/var/folders/");
+}
+function getMtimeMs(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function sortedDirectoryEntries(dirPath) {
+  try {
+    return fs.readdirSync(dirPath, { withFileTypes: true }).map((entry) => ({
+      entry,
+      path: path.join(dirPath, entry.name),
+      mtimeMs: getMtimeMs(path.join(dirPath, entry.name))
+    })).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  } catch {
+    return [];
+  }
+}
+function collectJsonLikeFiles(rootDir, limit = MAX_FILES_PER_PROJECT) {
+  const result = [];
+  const queue = sortedDirectoryEntries(rootDir).filter((item) => item.entry.isDirectory() || item.entry.isFile());
+  while (queue.length && result.length < limit) {
+    const item = queue.shift();
+    if (!item) break;
+    if (item.entry.isDirectory()) {
+      queue.push(...sortedDirectoryEntries(item.path));
+      queue.sort((a, b) => b.mtimeMs - a.mtimeMs);
+      continue;
+    }
+    if (item.entry.isFile() && /\.(jsonl|json)$/i.test(item.entry.name)) {
+      result.push(item.path);
+    }
+  }
+  return result;
+}
+function extractCwdFromObject(value) {
+  if (!isRecord(value)) return "";
+  const direct = value.cwd || value.workdir || value.workspace;
+  if (typeof direct === "string") return direct;
+  const payload = value.payload || value.session || value.message || value.metadata || value.meta;
+  if (isRecord(payload)) {
+    return extractCwdFromObject(payload);
+  }
+  return "";
+}
+function readCwdFromJsonFile(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) return "";
+    if (filePath.endsWith(".json")) {
+      if (stat.size > MAX_JSON_BYTES) return "";
+      return extractCwdFromObject(JSON.parse(fs.readFileSync(filePath, "utf8")));
+    }
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const buffer = Buffer.alloc(Math.min(stat.size, MAX_JSON_BYTES));
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+      const content = buffer.subarray(0, bytesRead).toString("utf8");
+      const lines = content.split("\n").slice(0, MAX_JSONL_LINES);
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const cwd = extractCwdFromObject(JSON.parse(line));
+          if (cwd) return cwd;
+        } catch {
+        }
+      }
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return "";
+  }
+  return "";
+}
+function normalizeEncodedSegment(segment) {
+  return segment.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function resolveEncodedProjectDirectory(projectName) {
+  const encoded = normalizeEncodedSegment(projectName);
+  if (!encoded) return "";
+  let currentDir = path.parse(process.cwd()).root;
+  let remaining = encoded;
+  while (remaining) {
+    const children = sortedDirectoryEntries(currentDir).filter((item) => item.entry.isDirectory());
+    const match = children.map((child) => ({ child, childSlug: normalizeEncodedSegment(child.entry.name) })).filter(({ childSlug: childSlug2 }) => childSlug2 && (remaining === childSlug2 || remaining.startsWith(`${childSlug2}-`))).sort((a, b) => b.childSlug.length - a.childSlug.length)[0];
+    if (!match) return "";
+    currentDir = match.child.path;
+    const childSlug = match.childSlug;
+    remaining = remaining === childSlug ? "" : remaining.slice(childSlug.length + 1);
+  }
+  return normalizeWorkspacePath(currentDir);
+}
+function addWorkspace(resultByPath, workspace, details) {
+  const normalized = normalizeWorkspacePath(workspace);
+  if (!normalized) return;
+  const existing = resultByPath.get(normalized) || {
+    path: normalized,
+    agents: [],
+    sources: [],
+    confidence: details.confidence || "medium",
+    lastSeen: 0
+  };
+  if (!existing.agents.includes(details.agent)) existing.agents.push(details.agent);
+  if (!existing.sources.includes(details.source)) existing.sources.push(details.source);
+  existing.lastSeen = Math.max(existing.lastSeen || 0, details.lastSeen || 0);
+  if (details.confidence === "high") existing.confidence = "high";
+  resultByPath.set(normalized, existing);
+}
+function scanProjectHistory({
+  homeDir,
+  agent,
+  projectRoot,
+  resultByPath
+}) {
+  const root = path.join(homeDir, projectRoot);
+  if (!fs.existsSync(root)) return;
+  const projects = sortedDirectoryEntries(root).filter((item) => item.entry.isDirectory()).slice(0, MAX_PROJECT_DIRS_PER_AGENT);
+  projects.forEach((project) => {
+    const files = collectJsonLikeFiles(project.path, MAX_FILES_PER_PROJECT);
+    let fileWithCwd = "";
+    let cwd = "";
+    for (const file of files) {
+      cwd = readCwdFromJsonFile(file);
+      if (cwd) {
+        fileWithCwd = file;
+        break;
+      }
+    }
+    if (cwd) {
+      addWorkspace(resultByPath, cwd, {
+        agent,
+        source: `${agent}-metadata`,
+        confidence: "high",
+        lastSeen: getMtimeMs(fileWithCwd)
+      });
+      return;
+    }
+    const decoded = resolveEncodedProjectDirectory(project.entry.name);
+    if (decoded) {
+      addWorkspace(resultByPath, decoded, {
+        agent,
+        source: `${agent}-project-dir`,
+        confidence: "medium",
+        lastSeen: project.mtimeMs
+      });
+    }
+  });
+}
+function scanCodexSessions({ homeDir, resultByPath }) {
+  const root = path.join(homeDir, ".codex", "sessions");
+  if (!fs.existsSync(root)) return;
+  const files = [];
+  const queue = [root];
+  while (queue.length && files.length < 120) {
+    const current = queue.shift();
+    if (!current) break;
+    sortedDirectoryEntries(current).forEach((item) => {
+      if (item.entry.isDirectory()) {
+        queue.push(item.path);
+      } else if (item.entry.isFile() && item.entry.name.endsWith(".jsonl")) {
+        files.push(item.path);
+      }
+    });
+    files.sort((a, b) => getMtimeMs(b) - getMtimeMs(a));
+  }
+  files.slice(0, 80).forEach((file) => {
+    const cwd = readCwdFromJsonFile(file);
+    if (!cwd) return;
+    addWorkspace(resultByPath, cwd, {
+      agent: "codex",
+      source: "codex-session-meta",
+      confidence: "high",
+      lastSeen: getMtimeMs(file)
+    });
+  });
+}
+function discoverAgentWorkspaces(options = {}) {
+  const homeDir = options.homeDir || os.homedir();
+  const limit = typeof options.limit === "number" && Number.isFinite(options.limit) ? options.limit : DEFAULT_LIMIT;
+  const requestedAgent = typeof options.agent === "string" ? options.agent.trim().toLowerCase() : "";
+  const agentFilter = DISCOVERABLE_AGENT_NAMES.has(requestedAgent) ? requestedAgent : "";
+  const resultByPath = /* @__PURE__ */ new Map();
+  scanProjectHistory({
+    homeDir,
+    agent: "claude",
+    projectRoot: path.join(".claude", "projects"),
+    resultByPath
+  });
+  scanProjectHistory({
+    homeDir,
+    agent: "qwen",
+    projectRoot: path.join(".qwen", "projects"),
+    resultByPath
+  });
+  scanCodexSessions({ homeDir, resultByPath });
+  return [...resultByPath.values()].filter((item) => !agentFilter || item.agents.includes(agentFilter)).sort((a, b) => (b.lastSeen || 0) - (a.lastSeen || 0)).slice(0, Math.max(0, limit)).map((item) => ({
+    ...item,
+    exists: true
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  discoverAgentWorkspaces,
+  isTemporaryWorkspace,
+  normalizeWorkspacePath,
+  resolveEncodedProjectDirectory
+});