@algochad/archcoder 2.0.2

package/server/lib/opencode/commands.js

@@ -0,0 +1,339 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  CONFIG_FILE,
+  OPENCODE_CONFIG_DIR,
+  COMMAND_DIR,
+  COMMAND_SCOPE,
+  ensureDirs,
+  parseMdFile,
+  writeMdFile,
+  readConfigLayers,
+  writeConfig,
+  getJsonEntrySource,
+  getJsonWriteTarget,
+  isPromptFileReference,
+  resolvePromptFilePath,
+  writePromptFile,
+} from './shared.js';
+
+// ============== COMMAND SCOPE HELPERS ==============
+
+/**
+ * Ensure project-level command directory exists
+ */
+function ensureProjectCommandDir(workingDirectory) {
+  const projectCommandDir = path.join(workingDirectory, '.opencode', 'commands');
+  if (!fs.existsSync(projectCommandDir)) {
+    fs.mkdirSync(projectCommandDir, { recursive: true });
+  }
+  const legacyProjectCommandDir = path.join(workingDirectory, '.opencode', 'command');
+  if (!fs.existsSync(legacyProjectCommandDir)) {
+    fs.mkdirSync(legacyProjectCommandDir, { recursive: true });
+  }
+  return projectCommandDir;
+}
+
+/**
+ * Get project-level command path
+ */
+function getProjectCommandPath(workingDirectory, commandName) {
+  const pluralPath = path.join(workingDirectory, '.opencode', 'commands', `${commandName}.md`);
+  const legacyPath = path.join(workingDirectory, '.opencode', 'command', `${commandName}.md`);
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
+}
+
+/**
+ * Get user-level command path
+ */
+function getUserCommandPath(commandName) {
+  const pluralPath = path.join(COMMAND_DIR, `${commandName}.md`);
+  const legacyPath = path.join(OPENCODE_CONFIG_DIR, 'command', `${commandName}.md`);
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
+}
+
+/**
+ * Determine command scope based on where the .md file exists
+ * Priority: project level > user level > null (built-in only)
+ */
+function getCommandScope(commandName, workingDirectory) {
+  if (workingDirectory) {
+    const projectPath = getProjectCommandPath(workingDirectory, commandName);
+    if (fs.existsSync(projectPath)) {
+      return { scope: COMMAND_SCOPE.PROJECT, path: projectPath };
+    }
+  }
+  
+  const userPath = getUserCommandPath(commandName);
+  if (fs.existsSync(userPath)) {
+    return { scope: COMMAND_SCOPE.USER, path: userPath };
+  }
+  
+  return { scope: null, path: null };
+}
+
+/**
+ * Get the path where a command should be written based on scope
+ */
+function getCommandWritePath(commandName, workingDirectory, requestedScope) {
+  // For updates: check existing location first (project takes precedence)
+  const existing = getCommandScope(commandName, workingDirectory);
+  if (existing.path) {
+    return existing;
+  }
+  
+  // For new commands or built-in overrides: use requested scope or default to user
+  const scope = requestedScope || COMMAND_SCOPE.USER;
+  if (scope === COMMAND_SCOPE.PROJECT && workingDirectory) {
+    return { 
+      scope: COMMAND_SCOPE.PROJECT, 
+      path: getProjectCommandPath(workingDirectory, commandName) 
+    };
+  }
+  
+  return { 
+    scope: COMMAND_SCOPE.USER, 
+    path: getUserCommandPath(commandName) 
+  };
+}
+
+function getCommandSources(commandName, workingDirectory) {
+  const projectPath = workingDirectory ? getProjectCommandPath(workingDirectory, commandName) : null;
+  const projectExists = projectPath && fs.existsSync(projectPath);
+
+  const userPath = getUserCommandPath(commandName);
+  const userExists = fs.existsSync(userPath);
+
+  const mdPath = projectExists ? projectPath : (userExists ? userPath : null);
+  const mdExists = !!mdPath;
+  const mdScope = projectExists ? COMMAND_SCOPE.PROJECT : (userExists ? COMMAND_SCOPE.USER : null);
+
+  const layers = readConfigLayers(workingDirectory);
+  const jsonSource = getJsonEntrySource(layers, 'command', commandName);
+  const jsonSection = jsonSource.section;
+  const jsonPath = jsonSource.path || layers.paths.customPath || layers.paths.projectPath || layers.paths.userPath;
+  const jsonScope = jsonSource.path === layers.paths.projectPath ? COMMAND_SCOPE.PROJECT : COMMAND_SCOPE.USER;
+
+  const sources = {
+    md: {
+      exists: mdExists,
+      path: mdPath,
+      scope: mdScope,
+      fields: []
+    },
+    json: {
+      exists: jsonSource.exists,
+      path: jsonPath,
+      scope: jsonSource.exists ? jsonScope : null,
+      fields: []
+    },
+    projectMd: {
+      exists: projectExists,
+      path: projectPath
+    },
+    userMd: {
+      exists: userExists,
+      path: userPath
+    }
+  };
+
+  if (mdExists) {
+    const { frontmatter, body } = parseMdFile(mdPath);
+    sources.md.fields = Object.keys(frontmatter);
+    if (body) {
+      sources.md.fields.push('template');
+    }
+  }
+
+  if (jsonSection) {
+    sources.json.fields = Object.keys(jsonSection);
+  }
+
+  return sources;
+}
+
+function createCommand(commandName, config, workingDirectory, scope) {
+  ensureDirs();
+
+  const projectPath = workingDirectory ? getProjectCommandPath(workingDirectory, commandName) : null;
+  const userPath = getUserCommandPath(commandName);
+
+  if (projectPath && fs.existsSync(projectPath)) {
+    throw new Error(`Command ${commandName} already exists as project-level .md file`);
+  }
+
+  if (fs.existsSync(userPath)) {
+    throw new Error(`Command ${commandName} already exists as user-level .md file`);
+  }
+
+  const layers = readConfigLayers(workingDirectory);
+  const jsonSource = getJsonEntrySource(layers, 'command', commandName);
+  if (jsonSource.exists) {
+    throw new Error(`Command ${commandName} already exists in opencode.json`);
+  }
+
+  let targetPath;
+  let targetScope;
+
+  if (scope === COMMAND_SCOPE.PROJECT && workingDirectory) {
+    ensureProjectCommandDir(workingDirectory);
+    targetPath = projectPath;
+    targetScope = COMMAND_SCOPE.PROJECT;
+  } else {
+    targetPath = userPath;
+    targetScope = COMMAND_SCOPE.USER;
+  }
+
+  const { template, scope: _scopeFromConfig, ...frontmatter } = config;
+
+  writeMdFile(targetPath, frontmatter, template || '');
+  console.log(`Created new command: ${commandName} (scope: ${targetScope}, path: ${targetPath})`);
+}
+
+function updateCommand(commandName, updates, workingDirectory) {
+  ensureDirs();
+
+  const { scope, path: mdPath } = getCommandWritePath(commandName, workingDirectory);
+  const mdExists = mdPath && fs.existsSync(mdPath);
+
+  const layers = readConfigLayers(workingDirectory);
+  const jsonSource = getJsonEntrySource(layers, 'command', commandName);
+  const jsonSection = jsonSource.section;
+  const hasJsonFields = jsonSource.exists && jsonSection && Object.keys(jsonSection).length > 0;
+  const jsonTarget = jsonSource.exists
+    ? { config: jsonSource.config, path: jsonSource.path }
+    : getJsonWriteTarget(layers, workingDirectory ? COMMAND_SCOPE.PROJECT : COMMAND_SCOPE.USER);
+  let config = jsonTarget.config || {};
+
+  const isBuiltinOverride = !mdExists && !hasJsonFields;
+
+  let targetPath = mdPath;
+  let targetScope = scope;
+
+  if (!mdExists && isBuiltinOverride) {
+    targetPath = getUserCommandPath(commandName);
+    targetScope = COMMAND_SCOPE.USER;
+  }
+
+  const mdData = mdExists ? parseMdFile(mdPath) : (isBuiltinOverride ? { frontmatter: {}, body: '' } : null);
+
+  let mdModified = false;
+  let jsonModified = false;
+  const creatingNewMd = isBuiltinOverride;
+
+  for (const [field, value] of Object.entries(updates)) {
+    if (field === 'template') {
+      const normalizedValue = typeof value === 'string' ? value : (value == null ? '' : String(value));
+
+      if (mdExists || creatingNewMd) {
+        if (mdData) {
+          mdData.body = normalizedValue;
+          mdModified = true;
+        }
+        continue;
+      } else if (isPromptFileReference(jsonSection?.template)) {
+        const templateFilePath = resolvePromptFilePath(jsonSection.template);
+        if (!templateFilePath) {
+          throw new Error(`Invalid template file reference for command ${commandName}`);
+        }
+        writePromptFile(templateFilePath, normalizedValue);
+        continue;
+      } else if (isPromptFileReference(normalizedValue)) {
+        if (!config.command) config.command = {};
+        if (!config.command[commandName]) config.command[commandName] = {};
+        config.command[commandName].template = normalizedValue;
+        jsonModified = true;
+        continue;
+      }
+
+      if (!config.command) config.command = {};
+      if (!config.command[commandName]) config.command[commandName] = {};
+      config.command[commandName].template = normalizedValue;
+      jsonModified = true;
+      continue;
+    }
+
+    const inMd = mdData?.frontmatter?.[field] !== undefined;
+    const inJson = jsonSection?.[field] !== undefined;
+
+    if (inJson) {
+      if (!config.command) config.command = {};
+      if (!config.command[commandName]) config.command[commandName] = {};
+      config.command[commandName][field] = value;
+      jsonModified = true;
+    } else if (inMd || creatingNewMd) {
+      if (mdData) {
+        mdData.frontmatter[field] = value;
+        mdModified = true;
+      }
+    } else {
+      if ((mdExists || creatingNewMd) && mdData) {
+        mdData.frontmatter[field] = value;
+        mdModified = true;
+      } else {
+        if (!config.command) config.command = {};
+        if (!config.command[commandName]) config.command[commandName] = {};
+        config.command[commandName][field] = value;
+        jsonModified = true;
+      }
+    }
+  }
+
+  if (mdModified && mdData) {
+    writeMdFile(targetPath, mdData.frontmatter, mdData.body);
+  }
+
+  if (jsonModified) {
+    writeConfig(config, jsonTarget.path || CONFIG_FILE);
+  }
+
+  console.log(`Updated command: ${commandName} (scope: ${targetScope}, md: ${mdModified}, json: ${jsonModified})`);
+}
+
+function deleteCommand(commandName, workingDirectory) {
+  let deleted = false;
+
+  if (workingDirectory) {
+    const projectPath = getProjectCommandPath(workingDirectory, commandName);
+    if (fs.existsSync(projectPath)) {
+      fs.unlinkSync(projectPath);
+      console.log(`Deleted project-level command .md file: ${projectPath}`);
+      deleted = true;
+    }
+  }
+
+  const userPath = getUserCommandPath(commandName);
+  if (fs.existsSync(userPath)) {
+    fs.unlinkSync(userPath);
+    console.log(`Deleted user-level command .md file: ${userPath}`);
+    deleted = true;
+  }
+
+  const layers = readConfigLayers(workingDirectory);
+  const jsonSource = getJsonEntrySource(layers, 'command', commandName);
+  if (jsonSource.exists && jsonSource.config && jsonSource.path) {
+    if (!jsonSource.config.command) jsonSource.config.command = {};
+    delete jsonSource.config.command[commandName];
+    writeConfig(jsonSource.config, jsonSource.path);
+    console.log(`Removed command from opencode.json: ${commandName}`);
+    deleted = true;
+  }
+
+  if (!deleted) {
+    throw new Error(`Command "${commandName}" not found`);
+  }
+}
+
+export {
+  ensureProjectCommandDir,
+  getProjectCommandPath,
+  getUserCommandPath,
+  getCommandScope,
+  getCommandWritePath,
+  getCommandSources,
+  createCommand,
+  updateCommand,
+  deleteCommand,
+};

package/server/lib/opencode/index.js

@@ -0,0 +1,66 @@
+export {
+  AGENT_DIR,
+  COMMAND_DIR,
+  SKILL_DIR,
+  CONFIG_FILE,
+  AGENT_SCOPE,
+  COMMAND_SCOPE,
+  SKILL_SCOPE,
+  readConfig,
+  writeConfig,
+  readSkillSupportingFile,
+  writeSkillSupportingFile,
+  deleteSkillSupportingFile,
+} from './shared.js';
+
+export {
+  getAgentScope,
+  getAgentPermissionSource,
+  getAgentSources,
+  getAgentConfig,
+  createAgent,
+  updateAgent,
+  deleteAgent,
+} from './agents.js';
+
+export {
+  getCommandScope,
+  getCommandSources,
+  createCommand,
+  updateCommand,
+  deleteCommand,
+} from './commands.js';
+
+export {
+  getSkillSources,
+  getSkillScope,
+  discoverSkills,
+  createSkill,
+  updateSkill,
+  deleteSkill,
+} from './skills.js';
+
+export {
+  getProviderSources,
+  removeProviderConfig,
+} from './providers.js';
+
+export {
+  readAuthFile,
+  writeAuthFile,
+  removeProviderAuth,
+  getProviderAuth,
+  listProviderAuths,
+  AUTH_FILE,
+  OPENCODE_DATA_DIR,
+} from './auth.js';
+
+export { createUiAuth } from './ui-auth.js';
+
+export {
+  listMcpConfigs,
+  getMcpConfig,
+  createMcpConfig,
+  updateMcpConfig,
+  deleteMcpConfig,
+} from './mcp.js';

package/server/lib/opencode/mcp.js

@@ -0,0 +1,206 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  CONFIG_FILE,
+  AGENT_SCOPE,
+  readConfigFile,
+  readConfigLayers,
+  getJsonEntrySource,
+  getJsonWriteTarget,
+  writeConfig,
+} from './shared.js';
+
+// ============== MCP CONFIG HELPERS ==============
+
+/**
+ * Validate MCP server name
+ */
+function validateMcpName(name) {
+  if (!name || typeof name !== 'string') {
+    throw new Error('MCP server name is required');
+  }
+  if (!/^[a-z0-9][a-z0-9_-]*[a-z0-9]$|^[a-z0-9]$/.test(name)) {
+    throw new Error('MCP server name must be lowercase alphanumeric with hyphens/underscores');
+  }
+}
+
+/**
+ * List all MCP server configs from user-level opencode.json
+ */
+function resolveMcpScopeFromPath(layers, sourcePath) {
+  if (!sourcePath) return null;
+  return sourcePath === layers.paths.projectPath ? AGENT_SCOPE.PROJECT : AGENT_SCOPE.USER;
+}
+
+function ensureProjectMcpConfigPath(workingDirectory) {
+  const configDir = path.join(workingDirectory, '.opencode');
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  return path.join(configDir, 'opencode.json');
+}
+
+function listMcpConfigs(workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const mcp = layers?.mergedConfig?.mcp || {};
+
+  return Object.entries(mcp)
+    .filter(([, entry]) => entry && typeof entry === 'object' && !Array.isArray(entry))
+    .map(([name, entry]) => {
+      const source = getJsonEntrySource(layers, 'mcp', name);
+      return {
+        name,
+        ...buildMcpEntry(entry),
+        scope: resolveMcpScopeFromPath(layers, source.path),
+      };
+    });
+}
+
+/**
+ * Get a single MCP server config by name
+ */
+function getMcpConfig(name, workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const entry = layers?.mergedConfig?.mcp?.[name];
+
+  if (!entry) {
+    return null;
+  }
+  const source = getJsonEntrySource(layers, 'mcp', name);
+  return {
+    name,
+    ...buildMcpEntry(entry),
+    scope: resolveMcpScopeFromPath(layers, source.path),
+  };
+}
+
+/**
+ * Create a new MCP server config entry
+ */
+function createMcpConfig(name, mcpConfig, workingDirectory, scope) {
+  validateMcpName(name);
+
+  const layers = readConfigLayers(workingDirectory);
+  const source = getJsonEntrySource(layers, 'mcp', name);
+  if (source.exists) {
+    throw new Error(`MCP server "${name}" already exists`);
+  }
+
+  let targetPath = CONFIG_FILE;
+  let config = {};
+
+  if (scope === AGENT_SCOPE.PROJECT) {
+    if (!workingDirectory) {
+      throw new Error('Project scope requires working directory');
+    }
+    targetPath = ensureProjectMcpConfigPath(workingDirectory);
+    config = fs.existsSync(targetPath) ? readConfigFile(targetPath) : {};
+  } else {
+    const jsonTarget = getJsonWriteTarget(layers, AGENT_SCOPE.USER);
+    targetPath = jsonTarget.path || CONFIG_FILE;
+    config = jsonTarget.config || {};
+  }
+
+  if (!config.mcp || typeof config.mcp !== 'object' || Array.isArray(config.mcp)) {
+    config.mcp = {};
+  }
+
+  const { name: _ignoredName, ...entryData } = mcpConfig;
+  config.mcp[name] = buildMcpEntry(entryData);
+
+  writeConfig(config, targetPath);
+  console.log(`Created MCP server config: ${name}`);
+}
+
+/**
+ * Update an existing MCP server config entry
+ */
+function updateMcpConfig(name, updates, workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const source = getJsonEntrySource(layers, 'mcp', name);
+  const targetPath = source.path || CONFIG_FILE;
+  const config = source.config || (fs.existsSync(targetPath) ? readConfigFile(targetPath) : {});
+
+  if (!config.mcp || typeof config.mcp !== 'object' || Array.isArray(config.mcp)) {
+    config.mcp = {};
+  }
+
+  const existing = config.mcp[name] ?? {};
+  const { name: _ignoredName, ...updateData } = updates;
+
+  config.mcp[name] = buildMcpEntry({ ...existing, ...updateData });
+
+  writeConfig(config, targetPath);
+  console.log(`Updated MCP server config: ${name}`);
+}
+
+/**
+ * Delete an MCP server config entry
+ */
+function deleteMcpConfig(name, workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const source = getJsonEntrySource(layers, 'mcp', name);
+  const targetPath = source.path || CONFIG_FILE;
+  const config = source.config || (fs.existsSync(targetPath) ? readConfigFile(targetPath) : {});
+
+  if (!config.mcp || typeof config.mcp !== 'object' || config.mcp[name] === undefined) {
+    throw new Error(`MCP server "${name}" not found`);
+  }
+
+  delete config.mcp[name];
+
+  if (Object.keys(config.mcp).length === 0) {
+    delete config.mcp;
+  }
+
+  writeConfig(config, targetPath);
+  console.log(`Deleted MCP server config: ${name}`);
+}
+
+/**
+ * Build a clean MCP entry object, omitting undefined/null values
+ */
+function buildMcpEntry(data) {
+  const entry = {};
+
+  // type is required
+  entry.type = data.type === 'remote' ? 'remote' : 'local';
+
+  if (entry.type === 'local') {
+    // command must be a non-empty array of strings
+    if (Array.isArray(data.command) && data.command.length > 0) {
+      entry.command = data.command.map(String);
+    }
+  } else {
+    // remote: url required
+    if (data.url && typeof data.url === 'string') {
+      entry.url = data.url.trim();
+    }
+  }
+
+  // environment: flat Record<string, string>
+  if (data.environment && typeof data.environment === 'object' && !Array.isArray(data.environment)) {
+    const cleaned = {};
+    for (const [k, v] of Object.entries(data.environment)) {
+      if (k && v !== undefined && v !== null) {
+        cleaned[k] = String(v);
+      }
+    }
+    if (Object.keys(cleaned).length > 0) {
+      entry.environment = cleaned;
+    }
+  }
+
+  // enabled defaults to true
+  entry.enabled = data.enabled !== false;
+
+  return entry;
+}
+
+export {
+  listMcpConfigs,
+  getMcpConfig,
+  createMcpConfig,
+  updateMcpConfig,
+  deleteMcpConfig,
+};

package/server/lib/opencode/providers.js

@@ -0,0 +1,96 @@
+import {
+  CONFIG_FILE,
+  readConfigLayers,
+  isPlainObject,
+  getConfigForPath,
+  writeConfig,
+} from './shared.js';
+
+function getProviderSources(providerId, workingDirectory) {
+  const layers = readConfigLayers(workingDirectory);
+  const { userConfig, projectConfig, customConfig, paths } = layers;
+
+  const customProviders = isPlainObject(customConfig?.provider) ? customConfig.provider : {};
+  const customProvidersAlias = isPlainObject(customConfig?.providers) ? customConfig.providers : {};
+  const projectProviders = isPlainObject(projectConfig?.provider) ? projectConfig.provider : {};
+  const projectProvidersAlias = isPlainObject(projectConfig?.providers) ? projectConfig.providers : {};
+  const userProviders = isPlainObject(userConfig?.provider) ? userConfig.provider : {};
+  const userProvidersAlias = isPlainObject(userConfig?.providers) ? userConfig.providers : {};
+
+  const customExists =
+    Object.prototype.hasOwnProperty.call(customProviders, providerId) ||
+    Object.prototype.hasOwnProperty.call(customProvidersAlias, providerId);
+  const projectExists =
+    Object.prototype.hasOwnProperty.call(projectProviders, providerId) ||
+    Object.prototype.hasOwnProperty.call(projectProvidersAlias, providerId);
+  const userExists =
+    Object.prototype.hasOwnProperty.call(userProviders, providerId) ||
+    Object.prototype.hasOwnProperty.call(userProvidersAlias, providerId);
+
+  return {
+    sources: {
+      auth: { exists: false },
+      user: { exists: userExists, path: paths.userPath },
+      project: { exists: projectExists, path: paths.projectPath || null },
+      custom: { exists: customExists, path: paths.customPath }
+    }
+  };
+}
+
+function removeProviderConfig(providerId, workingDirectory, scope = 'user') {
+  if (!providerId || typeof providerId !== 'string') {
+    throw new Error('Provider ID is required');
+  }
+
+  const layers = readConfigLayers(workingDirectory);
+  let targetPath = layers.paths.userPath;
+
+  if (scope === 'project') {
+    if (!workingDirectory) {
+      throw new Error('Working directory is required for project scope');
+    }
+    targetPath = layers.paths.projectPath || targetPath;
+  } else if (scope === 'custom') {
+    if (!layers.paths.customPath) {
+      return false;
+    }
+    targetPath = layers.paths.customPath;
+  }
+
+  const targetConfig = getConfigForPath(layers, targetPath);
+  const providerConfig = isPlainObject(targetConfig.provider) ? targetConfig.provider : {};
+  const providersConfig = isPlainObject(targetConfig.providers) ? targetConfig.providers : {};
+  const removedProvider = Object.prototype.hasOwnProperty.call(providerConfig, providerId);
+  const removedProviders = Object.prototype.hasOwnProperty.call(providersConfig, providerId);
+
+  if (!removedProvider && !removedProviders) {
+    return false;
+  }
+
+  if (removedProvider) {
+    delete providerConfig[providerId];
+    if (Object.keys(providerConfig).length === 0) {
+      delete targetConfig.provider;
+    } else {
+      targetConfig.provider = providerConfig;
+    }
+  }
+
+  if (removedProviders) {
+    delete providersConfig[providerId];
+    if (Object.keys(providersConfig).length === 0) {
+      delete targetConfig.providers;
+    } else {
+      targetConfig.providers = providersConfig;
+    }
+  }
+
+  writeConfig(targetConfig, targetPath || CONFIG_FILE);
+  console.log(`Removed provider ${providerId} from config: ${targetPath}`);
+  return true;
+}
+
+export {
+  getProviderSources,
+  removeProviderConfig,
+};