@axhub/genie 0.2.10 → 0.2.12

package/server/utils/shellCommand.js

@@ -0,0 +1,70 @@
+import os from 'os';
+
+function quoteForPosix(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function quoteForPowerShell(value) {
+  return `"${String(value).replace(/`/g, '``').replace(/"/g, '`"')}"`;
+}
+
+function buildPosixProviderCommand({ provider = 'claude', sessionId = null, hasSession = false } = {}) {
+  const normalizedProvider = String(provider || 'claude').trim().toLowerCase();
+  const normalizedSessionId = typeof sessionId === 'string' ? sessionId.trim() : '';
+  const shouldResume = Boolean(hasSession && normalizedSessionId);
+
+  switch (normalizedProvider) {
+    case 'codex':
+      return shouldResume ? `codex resume ${quoteForPosix(normalizedSessionId)}` : 'codex';
+    case 'gemini':
+      return shouldResume ? `npx -y @google/gemini-cli --resume ${quoteForPosix(normalizedSessionId)}` : 'npx -y @google/gemini-cli';
+    case 'opencode':
+      return shouldResume ? `opencode --session ${quoteForPosix(normalizedSessionId)}` : 'opencode';
+    case 'claude':
+    default:
+      return shouldResume ? `claude --resume ${quoteForPosix(normalizedSessionId)} || claude` : 'claude';
+  }
+}
+
+function buildPowerShellProviderCommand({ provider = 'claude', sessionId = null, hasSession = false } = {}) {
+  const normalizedProvider = String(provider || 'claude').trim().toLowerCase();
+  const normalizedSessionId = typeof sessionId === 'string' ? sessionId.trim() : '';
+  const shouldResume = Boolean(hasSession && normalizedSessionId);
+
+  switch (normalizedProvider) {
+    case 'codex':
+      return shouldResume ? `codex resume ${quoteForPowerShell(normalizedSessionId)}` : 'codex';
+    case 'gemini':
+      return shouldResume ? `npx -y @google/gemini-cli --resume ${quoteForPowerShell(normalizedSessionId)}` : 'npx -y @google/gemini-cli';
+    case 'opencode':
+      return shouldResume ? `opencode --session ${quoteForPowerShell(normalizedSessionId)}` : 'opencode';
+    case 'claude':
+    default:
+      return shouldResume
+        ? `claude --resume ${quoteForPowerShell(normalizedSessionId)}; if ($LASTEXITCODE -ne 0) { claude }`
+        : 'claude';
+  }
+}
+
+export function buildShellCommand({
+  projectPath,
+  provider = 'claude',
+  sessionId = null,
+  hasSession = false,
+  initialCommand = null,
+  isPlainShell = false,
+  platform = os.platform()
+}) {
+  const projectDirectory = String(projectPath || '').trim();
+  const isWindows = platform === 'win32';
+  const cdCommand = isWindows
+    ? `Set-Location -Path ${quoteForPowerShell(projectDirectory)}`
+    : `cd ${quoteForPosix(projectDirectory)}`;
+  const providerCommand = isPlainShell
+    ? String(initialCommand || '')
+    : isWindows
+      ? buildPowerShellProviderCommand({ provider, sessionId, hasSession })
+      : buildPosixProviderCommand({ provider, sessionId, hasSession });
+
+  return `${cdCommand}; ${providerCommand}`;
+}

package/shared/acpCapabilities.js

@@ -0,0 +1,393 @@
+export const ACP_CAPABILITY_KEYS = ['model', 'mode', 'thought_level'];
+export const ACP_CAPABILITY_CACHE_TTL_MS = 30 * 60 * 1000;
+export const ACP_DEFAULT_CAPABILITY_SCHEMA_VERSION = 1;
+
+function cloneJsonValue(value) {
+  if (value === undefined) return undefined;
+  return JSON.parse(JSON.stringify(value));
+}
+
+function normalizeString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeAcpCommandKey(command) {
+  return normalizeString(command?.name ?? command?.command ?? command?.id)
+    .replace(/^\/+/, '')
+    .toLowerCase();
+}
+
+function normalizeCapabilityOption(option, index = 0) {
+  if (option == null) return null;
+
+  if (typeof option === 'string' || typeof option === 'number' || typeof option === 'boolean') {
+    const value = String(option).trim();
+    return value ? { value, label: value, description: '', order: index } : null;
+  }
+
+  if (typeof option !== 'object' || Array.isArray(option)) return null;
+
+  const rawValue = option.value ?? option.id ?? option.modeId ?? option.const ?? option.enum?.[0] ?? option.name;
+  const value = normalizeString(rawValue);
+  if (!value) return null;
+
+  return {
+    value,
+    label: normalizeString(option.label ?? option.title ?? option.name ?? option.description) || value,
+    description: normalizeString(option.description),
+    ...(option.default === true ? { default: true } : {}),
+    order: Number.isInteger(option.order) ? option.order : index
+  };
+}
+
+function collectSelectOptions(options) {
+  if (!Array.isArray(options)) return [];
+
+  return options.flatMap((option, index) => {
+    if (Array.isArray(option?.options)) {
+      return option.options.map((item, childIndex) => normalizeCapabilityOption(item, childIndex)).filter(Boolean);
+    }
+    return normalizeCapabilityOption(option, index) || [];
+  });
+}
+
+function collectSchemaOptions(schema) {
+  if (!schema || typeof schema !== 'object') return [];
+
+  const direct =
+    (Array.isArray(schema.options) && schema.options) ||
+    (Array.isArray(schema.enum) && schema.enum) ||
+    (Array.isArray(schema.oneOf) && schema.oneOf) ||
+    (Array.isArray(schema.anyOf) && schema.anyOf) ||
+    [];
+
+  return collectSelectOptions(direct);
+}
+
+function dedupeOptions(options = []) {
+  const seen = new Set();
+  return options.filter((option) => {
+    const value = normalizeString(option?.value);
+    if (!value || seen.has(value)) return false;
+    seen.add(value);
+    return true;
+  });
+}
+
+export function normalizeAcpConfigOptions(value) {
+  const configOptions = Array.isArray(value?.configOptions)
+    ? value.configOptions
+    : Array.isArray(value)
+      ? value
+      : [];
+
+  return configOptions
+    .filter((option) => {
+      if (!option || typeof option !== 'object') return false;
+      return normalizeString(option.key ?? option.id ?? option.category);
+    })
+    .map((option) => ({
+      key: normalizeString(option.key ?? option.id ?? option.category),
+      id: normalizeString(option.id ?? option.key),
+      category: normalizeString(option.category),
+      type: normalizeString(option.type),
+      name: normalizeString(option.name),
+      description: normalizeString(option.description),
+      value: cloneJsonValue(option.value ?? option.currentValue),
+      currentValue: cloneJsonValue(option.currentValue),
+      options: Array.isArray(option.options) ? cloneJsonValue(option.options) : [],
+      schema: option.schema && typeof option.schema === 'object' ? cloneJsonValue(option.schema) : null
+    }));
+}
+
+export function normalizeAcpModeState(value) {
+  if (!value || typeof value !== 'object') return null;
+
+  const availableModes = Array.isArray(value.availableModes)
+    ? value.availableModes
+        .map((mode, index) => {
+          if (!mode || typeof mode !== 'object') return null;
+          const id = normalizeString(mode.id ?? mode.modeId ?? mode.value);
+          if (!id) return null;
+          return {
+            id,
+            name: normalizeString(mode.name ?? mode.label ?? id) || id,
+            description: mode.description == null ? null : String(mode.description),
+            order: index
+          };
+        })
+        .filter(Boolean)
+    : [];
+  const currentModeId = normalizeString(value.currentModeId ?? value.currentMode?.modeId ?? value.currentMode?.id);
+
+  if (!availableModes.length && !currentModeId) return null;
+
+  return {
+    availableModes,
+    currentModeId: currentModeId || availableModes[0]?.id || null
+  };
+}
+
+export function normalizeAcpTokenUsage(value) {
+  if (!value || typeof value !== 'object') return null;
+
+  if (value.used == null || (value.total == null && value.size == null)) {
+    return null;
+  }
+
+  const used = Number(value.used);
+  const total = Number(value.total ?? value.size);
+  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(total) || total < 0) {
+    return null;
+  }
+
+  const safeUsed = Math.round(used);
+  const safeTotal = Math.round(total);
+  const percentage = safeTotal > 0
+    ? Math.min(100, Math.max(0, Math.round((safeUsed / safeTotal) * 100)))
+    : 0;
+
+  return {
+    used: safeUsed,
+    total: safeTotal,
+    percentage,
+    remaining: Math.max(0, safeTotal - safeUsed),
+    cost: value.cost && typeof value.cost === 'object' ? cloneJsonValue(value.cost) : null
+  };
+}
+
+export function normalizeAcpAvailableCommands(value) {
+  const availableCommands = Array.isArray(value?.availableCommands)
+    ? value.availableCommands
+    : Array.isArray(value)
+      ? value
+      : [];
+
+  return availableCommands
+    .map((command) => {
+      if (!command || typeof command !== 'object' || Array.isArray(command)) {
+        return null;
+      }
+
+      const name = normalizeString(command.name ?? command.command ?? command.id).replace(/^\/+/, '');
+      if (!name) return null;
+
+      return {
+        name,
+        description: command.description == null ? '' : String(command.description),
+        input: command.input && typeof command.input === 'object' ? cloneJsonValue(command.input) : null,
+        source: 'acp'
+      };
+    })
+    .filter(Boolean);
+}
+
+function capabilityFromConfigOption(option) {
+  const key = normalizeString(option?.category) || normalizeString(option?.key);
+  if (!ACP_CAPABILITY_KEYS.includes(key)) return null;
+
+  const currentValueOption = normalizeCapabilityOption(option.currentValue);
+  const valueOption = normalizeCapabilityOption(option.value);
+  const options = dedupeOptions([
+    ...collectSelectOptions(option.options),
+    ...collectSchemaOptions(option.schema),
+    ...(currentValueOption ? [currentValueOption] : valueOption ? [valueOption] : [])
+  ]);
+  const currentValue = currentValueOption?.value || valueOption?.value || options.find((item) => item.default)?.value || '';
+
+  return {
+    key,
+    configId: normalizeString(option.id) || normalizeString(option.key) || key,
+    configKey: normalizeString(option.key) || normalizeString(option.id) || key,
+    category: normalizeString(option.category) || key,
+    description: normalizeString(option.description),
+    value: option.value === undefined ? null : cloneJsonValue(option.value),
+    currentValue,
+    options,
+    schema: option.schema && typeof option.schema === 'object' ? cloneJsonValue(option.schema) : null
+  };
+}
+
+function capabilityFromModeState(modeState) {
+  const normalized = normalizeAcpModeState(modeState);
+  if (!normalized) return null;
+
+  return {
+    key: 'mode',
+    description: '',
+    value: normalized.currentModeId,
+    currentValue: normalized.currentModeId || '',
+    options: normalized.availableModes.map((mode, index) => ({
+      value: mode.id,
+      label: mode.name || mode.id,
+      description: mode.description || '',
+      order: index
+    })),
+    modeState: normalized
+  };
+}
+
+function mergeCapability(previous, next) {
+  if (!previous) return next || null;
+  if (!next) return previous;
+
+  const options = Array.isArray(next.options)
+    ? dedupeOptions(next.options)
+    : dedupeOptions(Array.isArray(previous.options) ? previous.options : []);
+
+  return {
+    ...previous,
+    ...next,
+    options,
+    currentValue: Object.prototype.hasOwnProperty.call(next, 'currentValue')
+      ? (next.currentValue || '')
+      : (previous.currentValue || '')
+  };
+}
+
+export function buildAcpCapabilities({
+  configOptions = [],
+  modeState = null,
+  tokenUsage = null,
+  availableCommands = [],
+  provider = null,
+  source = 'session',
+  agentVersion = null,
+  updatedAt = null
+} = {}) {
+  const capabilities = {};
+
+  for (const option of normalizeAcpConfigOptions(configOptions)) {
+    const capability = capabilityFromConfigOption(option);
+    if (capability) {
+      capabilities[capability.key] = mergeCapability(capabilities[capability.key], capability);
+    }
+  }
+
+  const modeCapability = capabilityFromModeState(modeState);
+  if (modeCapability) {
+    capabilities.mode = mergeCapability(capabilities.mode, modeCapability);
+  }
+
+  return {
+    provider: provider ? normalizeString(provider).toLowerCase() : null,
+    source,
+    updatedAt: updatedAt || new Date().toISOString(),
+    ttl: ACP_CAPABILITY_CACHE_TTL_MS,
+    agentVersion: agentVersion || null,
+    capabilities,
+    metadata: {
+      tokenUsage: normalizeAcpTokenUsage(tokenUsage),
+      availableCommands: normalizeAcpAvailableCommands(availableCommands)
+    }
+  };
+}
+
+function mergeAcpAvailableCommands(previousCommands = [], nextCommands = []) {
+  const merged = [];
+  const seen = new Set();
+
+  for (const command of [
+    ...normalizeAcpAvailableCommands(nextCommands),
+    ...normalizeAcpAvailableCommands(previousCommands)
+  ]) {
+    const key = normalizeAcpCommandKey(command);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    merged.push(command);
+  }
+
+  return merged;
+}
+
+export function mergeAcpCapabilitySnapshots(previous = null, next = null) {
+  if (!previous) return next || null;
+  if (!next) return previous;
+
+  const capabilities = { ...(previous.capabilities || {}) };
+  for (const key of ACP_CAPABILITY_KEYS) {
+    capabilities[key] = mergeCapability(capabilities[key], next.capabilities?.[key]);
+  }
+
+  return {
+    ...previous,
+    ...next,
+    capabilities,
+    metadata: {
+      ...(previous.metadata || {}),
+      ...(next.metadata || {}),
+      tokenUsage: next.metadata?.tokenUsage || previous.metadata?.tokenUsage || null,
+      availableCommands: mergeAcpAvailableCommands(
+        previous.metadata?.availableCommands,
+        next.metadata?.availableCommands
+      )
+    }
+  };
+}
+
+function normalizeCapabilitySnapshot(provider, snapshot, { source = null, updatedAt = null } = {}) {
+  if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot)) {
+    return null;
+  }
+
+  const normalizedProvider = normalizeString(snapshot.provider || provider).toLowerCase();
+  if (!normalizedProvider) {
+    return null;
+  }
+
+  return {
+    ...cloneJsonValue(snapshot),
+    provider: normalizedProvider,
+    source: source || normalizeString(snapshot.source) || 'generated-default',
+    updatedAt: normalizeString(snapshot.updatedAt) || updatedAt || new Date().toISOString(),
+    ttl: Number.isFinite(Number(snapshot.ttl)) && Number(snapshot.ttl) > 0
+      ? Number(snapshot.ttl)
+      : ACP_CAPABILITY_CACHE_TTL_MS,
+    agentVersion: snapshot.agentVersion || null,
+    capabilities: snapshot.capabilities && typeof snapshot.capabilities === 'object'
+      ? cloneJsonValue(snapshot.capabilities)
+      : {},
+    metadata: snapshot.metadata && typeof snapshot.metadata === 'object'
+      ? {
+          ...cloneJsonValue(snapshot.metadata),
+          tokenUsage: normalizeAcpTokenUsage(snapshot.metadata.tokenUsage),
+          availableCommands: normalizeAcpAvailableCommands(snapshot.metadata.availableCommands)
+        }
+      : {
+          tokenUsage: null,
+          availableCommands: []
+        }
+  };
+}
+
+export function normalizeAcpDefaultCapabilityRegistry(value = {}) {
+  const generatedAt = normalizeString(value?.generatedAt) || new Date().toISOString();
+  const providers = {};
+  const rawProviders = value?.providers && typeof value.providers === 'object'
+    ? value.providers
+    : {};
+
+  for (const [providerName, snapshot] of Object.entries(rawProviders)) {
+    const normalized = normalizeCapabilitySnapshot(providerName, snapshot, {
+      source: 'generated-default',
+      updatedAt: generatedAt
+    });
+    if (normalized) {
+      providers[normalized.provider] = normalized;
+    }
+  }
+
+  return {
+    schemaVersion: Number(value?.schemaVersion) || ACP_DEFAULT_CAPABILITY_SCHEMA_VERSION,
+    generatedAt,
+    providers
+  };
+}
+
+export function getAcpDefaultCapabilitySnapshot(registry, provider) {
+  const normalizedRegistry = normalizeAcpDefaultCapabilityRegistry(registry);
+  const normalizedProvider = normalizeString(provider).toLowerCase();
+  return normalizedProvider
+    ? normalizedRegistry.providers[normalizedProvider] || null
+    : null;
+}

package/shared/acpDefaultCapabilities.generated.json

@@ -0,0 +1,141 @@
+{
+  "schemaVersion": 1,
+  "generatedAt": "2026-05-14T03:19:23.238Z",
+  "providers": {
+    "codex": {
+      "provider": "codex",
+      "source": "generated-default",
+      "updatedAt": "2026-05-14T03:19:23.238Z",
+      "ttl": 1800000,
+      "agentVersion": null,
+      "capabilities": {
+        "model": {
+          "key": "model",
+          "description": "Choose which model Codex should use",
+          "value": "gpt-5.5",
+          "currentValue": "gpt-5.5",
+          "options": [
+            {
+              "value": "gpt-5.5",
+              "label": "GPT-5.5",
+              "description": "Frontier model for complex coding, research, and real-world work.",
+              "order": 0
+            },
+            {
+              "value": "gpt-5.4",
+              "label": "gpt-5.4",
+              "description": "Strong model for everyday coding.",
+              "order": 1
+            },
+            {
+              "value": "gpt-5.4-mini",
+              "label": "GPT-5.4-Mini",
+              "description": "Small, fast, and cost-efficient model for simpler coding tasks.",
+              "order": 2
+            },
+            {
+              "value": "gpt-5.3-codex",
+              "label": "gpt-5.3-codex",
+              "description": "Coding-optimized model.",
+              "order": 3
+            },
+            {
+              "value": "gpt-5.2",
+              "label": "gpt-5.2",
+              "description": "Optimized for professional work and long-running agents.",
+              "order": 4
+            }
+          ],
+          "schema": null
+        },
+        "mode": {
+          "key": "mode",
+          "description": "Choose an approval and sandboxing preset for your session",
+          "value": "auto",
+          "currentValue": "auto",
+          "options": [
+            {
+              "value": "read-only",
+              "label": "Read Only",
+              "description": "Codex can read files in the current workspace. Approval is required to edit files or access the internet.",
+              "order": 0
+            },
+            {
+              "value": "auto",
+              "label": "Default",
+              "description": "Codex can read and edit files in the current workspace, and run commands. Approval is required to access the internet or edit other files. (Identical to Agent mode)",
+              "order": 1
+            },
+            {
+              "value": "full-access",
+              "label": "Full Access",
+              "description": "Codex can edit files outside this workspace and access the internet without asking for approval. Exercise caution when using.",
+              "order": 2
+            }
+          ],
+          "schema": null,
+          "modeState": {
+            "availableModes": [
+              {
+                "id": "read-only",
+                "name": "Read Only",
+                "description": "Codex can read files in the current workspace. Approval is required to edit files or access the internet.",
+                "order": 0
+              },
+              {
+                "id": "auto",
+                "name": "Default",
+                "description": "Codex can read and edit files in the current workspace, and run commands. Approval is required to access the internet or edit other files. (Identical to Agent mode)",
+                "order": 1
+              },
+              {
+                "id": "full-access",
+                "name": "Full Access",
+                "description": "Codex can edit files outside this workspace and access the internet without asking for approval. Exercise caution when using.",
+                "order": 2
+              }
+            ],
+            "currentModeId": "auto"
+          }
+        },
+        "thought_level": {
+          "key": "thought_level",
+          "description": "Choose how much reasoning effort the model should use",
+          "value": "xhigh",
+          "currentValue": "xhigh",
+          "options": [
+            {
+              "value": "low",
+              "label": "Low",
+              "description": "Fast responses with lighter reasoning",
+              "order": 0
+            },
+            {
+              "value": "medium",
+              "label": "Medium",
+              "description": "Balances speed and reasoning depth for everyday tasks",
+              "order": 1
+            },
+            {
+              "value": "high",
+              "label": "High",
+              "description": "Greater reasoning depth for complex problems",
+              "order": 2
+            },
+            {
+              "value": "xhigh",
+              "label": "Xhigh",
+              "description": "Extra high reasoning depth for complex problems",
+              "order": 3
+            }
+          ],
+          "schema": null
+        }
+      },
+      "metadata": {
+        "tokenUsage": null,
+        "availableCommands": []
+      }
+    }
+  }
+}