farming-code 2.2.6

package/backend/agent-order.js

@@ -0,0 +1,162 @@
+const AGENT_ORDER_STEP = 1024;
+
+function finiteOrder(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function agentWorkspace(agent) {
+  return String(agent && (agent.projectWorkspace || agent.cwd) || '');
+}
+
+function projectOrder(agent) {
+  return finiteOrder(agent && agent.projectOrder) ?? 0;
+}
+
+function pinnedOrder(agent) {
+  return finiteOrder(agent && agent.pinnedOrder) ?? 0;
+}
+
+function compareProjectAgents(left, right) {
+  return projectOrder(right) - projectOrder(left)
+    || (Number(right && right.startedAt) || 0) - (Number(left && left.startedAt) || 0)
+    || String(left && left.id || '').localeCompare(String(right && right.id || ''));
+}
+
+function comparePinnedAgents(left, right) {
+  return pinnedOrder(left) - pinnedOrder(right)
+    || (Number(left && left.startedAt) || 0) - (Number(right && right.startedAt) || 0)
+    || String(left && left.id || '').localeCompare(String(right && right.id || ''));
+}
+
+function nextProjectOrder(agents, workspace) {
+  return Math.max(0, ...agents
+    .filter(agent => agentWorkspace(agent) === workspace)
+    .map(projectOrder)) + AGENT_ORDER_STEP;
+}
+
+function nextPinnedOrder(agents) {
+  return Math.max(0, ...agents.filter(agent => agent && agent.pinned === true).map(pinnedOrder)) + AGENT_ORDER_STEP;
+}
+
+function ensureAgentOrders(agent, agents) {
+  if (finiteOrder(agent.projectOrder) === null) {
+    agent.projectOrder = nextProjectOrder(agents, agentWorkspace(agent));
+  }
+  if (agent.pinned === true && finiteOrder(agent.pinnedOrder) === null) {
+    agent.pinnedOrder = nextPinnedOrder(agents);
+  }
+  return agent;
+}
+
+function projectAgents(agents, workspace, excludedAgentId = '') {
+  return agents
+    .filter(agent => agent && agent.id !== excludedAgentId && agentWorkspace(agent) === workspace)
+    .sort(compareProjectAgents);
+}
+
+function reorderedProjectAgentOrders(agents, agentId, beforeAgentId = '', afterAgentId = '') {
+  const target = agents.find(agent => agent && agent.id === agentId);
+  if (!target) return { error: 'Agent not found' };
+  if (target.pinned === true) return { error: 'Pinned Agents cannot be reordered inside a Project' };
+
+  const workspace = agentWorkspace(target);
+  const visible = projectAgents(agents, workspace, agentId).filter(agent => agent.pinned !== true);
+  const beforeIndex = beforeAgentId ? visible.findIndex(agent => agent.id === beforeAgentId) : -1;
+  const afterIndex = afterAgentId ? visible.findIndex(agent => agent.id === afterAgentId) : -1;
+  if (beforeAgentId && beforeIndex < 0 || afterAgentId && afterIndex < 0) {
+    return { error: 'Reorder neighbors must belong to the same Project' };
+  }
+
+  const insertIndex = afterAgentId ? afterIndex : beforeAgentId ? beforeIndex + 1 : 0;
+  const expectedBefore = insertIndex > 0 ? visible[insertIndex - 1]?.id || '' : '';
+  const expectedAfter = insertIndex < visible.length ? visible[insertIndex]?.id || '' : '';
+  if (expectedBefore !== beforeAgentId || expectedAfter !== afterAgentId) {
+    return { error: 'Reorder neighbors are stale' };
+  }
+
+  const fullOrder = projectAgents(agents, workspace, agentId);
+  let fullInsertIndex = 0;
+  if (beforeAgentId) {
+    fullInsertIndex = fullOrder.findIndex(agent => agent.id === beforeAgentId) + 1;
+  } else if (afterAgentId) {
+    fullInsertIndex = fullOrder.findIndex(agent => agent.id === afterAgentId);
+  }
+
+  const updates = new Map();
+  const orderAt = index => finiteOrder(fullOrder[index] && fullOrder[index].projectOrder) ?? 0;
+  let upper = fullInsertIndex > 0 ? orderAt(fullInsertIndex - 1) : null;
+  let lower = fullInsertIndex < fullOrder.length ? orderAt(fullInsertIndex) : null;
+  if (upper !== null && lower !== null && upper - lower <= 1) {
+    fullOrder.forEach((agent, index) => {
+      const order = (fullOrder.length - index) * AGENT_ORDER_STEP;
+      if (projectOrder(agent) !== order) updates.set(agent.id, order);
+      agent.projectOrder = order;
+    });
+    upper = fullInsertIndex > 0 ? orderAt(fullInsertIndex - 1) : null;
+    lower = fullInsertIndex < fullOrder.length ? orderAt(fullInsertIndex) : null;
+  }
+
+  const order = upper === null
+    ? (lower ?? 0) + AGENT_ORDER_STEP
+    : lower === null
+      ? upper - AGENT_ORDER_STEP
+      : Math.floor((upper + lower) / 2);
+  updates.set(target.id, order);
+  return { updates };
+}
+
+function reorderedPinnedAgentOrders(agents, agentId, beforeAgentId = '', afterAgentId = '') {
+  const target = agents.find(agent => agent && agent.id === agentId);
+  if (!target) return { error: 'Agent not found' };
+  if (target.pinned !== true) return { error: 'Only pinned Agents can be reordered in Pinned' };
+
+  const pinned = agents
+    .filter(agent => agent && agent.id !== agentId && agent.pinned === true)
+    .sort(comparePinnedAgents);
+  const beforeIndex = beforeAgentId ? pinned.findIndex(agent => agent.id === beforeAgentId) : -1;
+  const afterIndex = afterAgentId ? pinned.findIndex(agent => agent.id === afterAgentId) : -1;
+  if (beforeAgentId && beforeIndex < 0 || afterAgentId && afterIndex < 0) {
+    return { error: 'Reorder neighbors must belong to Pinned' };
+  }
+
+  const insertIndex = afterAgentId ? afterIndex : beforeAgentId ? beforeIndex + 1 : 0;
+  const expectedBefore = insertIndex > 0 ? pinned[insertIndex - 1]?.id || '' : '';
+  const expectedAfter = insertIndex < pinned.length ? pinned[insertIndex]?.id || '' : '';
+  if (expectedBefore !== beforeAgentId || expectedAfter !== afterAgentId) {
+    return { error: 'Reorder neighbors are stale' };
+  }
+
+  const updates = new Map();
+  const orderAt = index => finiteOrder(pinned[index] && pinned[index].pinnedOrder) ?? 0;
+  let previous = insertIndex > 0 ? orderAt(insertIndex - 1) : null;
+  let next = insertIndex < pinned.length ? orderAt(insertIndex) : null;
+  if (previous !== null && next !== null && next - previous <= 1) {
+    pinned.forEach((agent, index) => {
+      const order = (index + 1) * AGENT_ORDER_STEP;
+      if (pinnedOrder(agent) !== order) updates.set(agent.id, order);
+      agent.pinnedOrder = order;
+    });
+    previous = insertIndex > 0 ? orderAt(insertIndex - 1) : null;
+    next = insertIndex < pinned.length ? orderAt(insertIndex) : null;
+  }
+
+  const order = previous === null
+    ? (next ?? AGENT_ORDER_STEP) - AGENT_ORDER_STEP
+    : next === null
+      ? previous + AGENT_ORDER_STEP
+      : Math.floor((previous + next) / 2);
+  updates.set(target.id, order);
+  return { updates };
+}
+
+module.exports = {
+  AGENT_ORDER_STEP,
+  comparePinnedAgents,
+  compareProjectAgents,
+  ensureAgentOrders,
+  finiteOrder,
+  nextPinnedOrder,
+  nextProjectOrder,
+  reorderedPinnedAgentOrders,
+  reorderedProjectAgentOrders,
+};

package/backend/agent-provider-session.js

@@ -0,0 +1,287 @@
+const path = require('path');
+const { parseCommand } = require('./cli-agents');
+const {
+  createProviderSessionId,
+  createTemporaryProviderSessionId,
+  isSafeProviderSessionId,
+} = require('./provider-session-id');
+
+const CODING_SESSION_PROVIDERS = new Set(['codex', 'claude', 'opencode', 'qoder']);
+const CODEX_VALUE_OPTIONS = new Set([
+  '-a',
+  '-c',
+  '-C',
+  '-m',
+  '-s',
+  '--ask-for-approval',
+  '--cd',
+  '--config',
+  '--config-profile',
+  '--model',
+  '--profile',
+  '--sandbox',
+]);
+
+function normalizeProvider(provider) {
+  const value = String(provider || '').trim().toLowerCase();
+  return CODING_SESSION_PROVIDERS.has(value) ? value : '';
+}
+
+function providerForProgram(program) {
+  const basename = path.basename(String(program || '').trim());
+  if (basename === 'qodercli') return 'qoder';
+  return normalizeProvider(basename);
+}
+
+function sessionFromExactResumeSource(source) {
+  const match = String(source || '').match(/^(codex|claude|opencode|qoder)-history:(?:home:([A-Za-z0-9._-]+):)?([A-Za-z0-9._:-]+)$/);
+  if (!match) return null;
+  if (!isSafeProviderSessionId(match[3])) return null;
+  return {
+    provider: match[1],
+    providerHomeId: match[2] || 'default',
+    sessionId: match[3],
+  };
+}
+
+function optionTakesValue(option, valueOptions) {
+  if (!option || option.includes('=')) return false;
+  return valueOptions.has(option);
+}
+
+function firstCodexSubcommand(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) continue;
+    if (arg.startsWith('-')) {
+      if (optionTakesValue(arg, CODEX_VALUE_OPTIONS)) index += 1;
+      continue;
+    }
+    return { value: arg, index };
+  }
+  return null;
+}
+
+function codexSessionIdAfterSubcommand(args, subcommandIndex) {
+  const positional = [];
+  for (let index = subcommandIndex + 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) continue;
+    if (arg.startsWith('-')) {
+      if (optionTakesValue(arg, CODEX_VALUE_OPTIONS)) index += 1;
+      continue;
+    }
+    positional.push(arg);
+  }
+  const sessionId = positional.at(-1) || '';
+  return isSafeProviderSessionId(sessionId) ? sessionId : '';
+}
+
+function argValue(args, names) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    for (const name of names) {
+      if (arg === name) return args[index + 1] || '';
+      if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
+    }
+  }
+  return '';
+}
+
+function hasArg(args, names) {
+  return args.some(arg => names.includes(arg) || names.some(name => arg.startsWith(`${name}=`)));
+}
+
+function codexProviderSessionPlan(rawArgs) {
+  const subcommand = firstCodexSubcommand(rawArgs);
+  if (subcommand && subcommand.value === 'resume') {
+    const sessionId = codexSessionIdAfterSubcommand(rawArgs, subcommand.index);
+    if (sessionId) {
+      return {
+        id: sessionId,
+        temporary: false,
+        source: 'resume',
+      };
+    }
+  }
+
+  if (subcommand && subcommand.value === 'fork') {
+    return {
+      id: createTemporaryProviderSessionId(),
+      temporary: true,
+      source: 'codex-fork-temporary',
+      forkedFromProviderSessionId: codexSessionIdAfterSubcommand(rawArgs, subcommand.index),
+    };
+  }
+
+  if (subcommand && subcommand.value) {
+    return null;
+  }
+
+  return {
+    id: createTemporaryProviderSessionId(),
+    temporary: true,
+    source: 'codex-temporary',
+  };
+}
+
+function claudeProviderSessionPlan(rawArgs, launchArgs) {
+  const explicitSessionId = argValue(rawArgs, ['--session-id']);
+  const resumeSessionId = argValue(rawArgs, ['--resume']);
+  const isFork = hasArg(rawArgs, ['--fork-session']);
+  const isContinue = hasArg(rawArgs, ['--continue', '-c']);
+
+  if (explicitSessionId && isSafeProviderSessionId(explicitSessionId)) {
+    return {
+      id: explicitSessionId,
+      temporary: false,
+      source: 'launch-session-id',
+      forkedFromProviderSessionId: isFork && isSafeProviderSessionId(resumeSessionId) ? resumeSessionId : '',
+    };
+  }
+
+  if (resumeSessionId && isSafeProviderSessionId(resumeSessionId) && !isFork) {
+    return {
+      id: resumeSessionId,
+      temporary: false,
+      source: 'resume',
+    };
+  }
+
+  if (isContinue) {
+    return null;
+  }
+
+  const sessionId = createProviderSessionId();
+  return {
+    id: sessionId,
+    temporary: false,
+    source: isFork ? 'claude-fork-session-id' : 'claude-session-id',
+    forkedFromProviderSessionId: isFork && isSafeProviderSessionId(resumeSessionId) ? resumeSessionId : '',
+    args: ['--session-id', sessionId, ...launchArgs],
+  };
+}
+
+function qoderProviderSessionPlan(rawArgs, launchArgs) {
+  const explicitSessionId = argValue(rawArgs, ['--session-id']);
+  const resumeSessionId = argValue(rawArgs, ['--resume']);
+  const isFork = hasArg(rawArgs, ['--fork-session']);
+  const isContinue = hasArg(rawArgs, ['--continue']);
+
+  if (explicitSessionId && isSafeProviderSessionId(explicitSessionId)) {
+    return {
+      id: explicitSessionId,
+      temporary: false,
+      source: 'launch-session-id',
+      forkedFromProviderSessionId: isFork && isSafeProviderSessionId(resumeSessionId) ? resumeSessionId : '',
+    };
+  }
+
+  if (resumeSessionId && isSafeProviderSessionId(resumeSessionId) && !isFork) {
+    return {
+      id: resumeSessionId,
+      temporary: false,
+      source: 'resume',
+    };
+  }
+
+  if (isContinue) {
+    return null;
+  }
+
+  const sessionId = createProviderSessionId();
+  return {
+    id: sessionId,
+    temporary: false,
+    source: isFork ? 'qoder-fork-session-id' : 'qoder-session-id',
+    forkedFromProviderSessionId: isFork && isSafeProviderSessionId(resumeSessionId) ? resumeSessionId : '',
+    args: ['--session-id', sessionId, ...launchArgs],
+  };
+}
+
+function openCodeProviderSessionPlan(rawArgs) {
+  const sessionId = argValue(rawArgs, ['--session', '-s']);
+  if (!sessionId || !isSafeProviderSessionId(sessionId)) return null;
+  if (hasArg(rawArgs, ['--fork'])) {
+    return {
+      id: createTemporaryProviderSessionId(),
+      temporary: true,
+      source: 'opencode-fork-temporary',
+      forkedFromProviderSessionId: sessionId,
+    };
+  }
+  return {
+    id: sessionId,
+    temporary: false,
+    source: 'resume',
+  };
+}
+
+function buildAgentProviderSessionPlan({ command, program, args, source } = {}) {
+  const sourceSession = sessionFromExactResumeSource(source);
+  const rawParts = parseCommand(command);
+  const rawProgram = rawParts[0] || program || '';
+  const provider = sourceSession ? sourceSession.provider : providerForProgram(rawProgram || program);
+  if (!provider) {
+    return {
+      provider: '',
+      id: '',
+      key: '',
+      temporary: false,
+      source: '',
+      forkedFromProviderSessionId: '',
+      args: Array.isArray(args) ? args : [],
+    };
+  }
+
+  const launchArgs = Array.isArray(args) ? args : [];
+  if (sourceSession) {
+    return {
+      provider,
+      id: sourceSession.sessionId,
+      providerHomeId: sourceSession.providerHomeId || 'default',
+      temporary: false,
+      source: 'resume-source',
+      forkedFromProviderSessionId: '',
+      args: launchArgs,
+    };
+  }
+
+  const rawArgs = rawParts.slice(1);
+  let plan = null;
+  if (provider === 'codex') {
+    plan = codexProviderSessionPlan(rawArgs);
+  } else if (provider === 'claude') {
+    plan = claudeProviderSessionPlan(rawArgs, launchArgs);
+  } else if (provider === 'qoder') {
+    plan = qoderProviderSessionPlan(rawArgs, launchArgs);
+  } else if (provider === 'opencode') {
+    plan = openCodeProviderSessionPlan(rawArgs);
+  }
+
+  if (!plan || !plan.id) {
+    return {
+      provider: '',
+      id: '',
+      temporary: false,
+      source: '',
+      forkedFromProviderSessionId: '',
+      args: launchArgs,
+    };
+  }
+
+  return {
+    provider,
+    id: plan.id,
+    temporary: plan.temporary === true,
+    source: plan.source || '',
+    forkedFromProviderSessionId: plan.forkedFromProviderSessionId || '',
+    args: Array.isArray(plan.args) ? plan.args : launchArgs,
+  };
+}
+
+module.exports = {
+  buildAgentProviderSessionPlan,
+  providerForProgram,
+  sessionFromExactResumeSource,
+};