coralos-dev 1.1.0-SNAPSHOT-11

package/README.md

@@ -0,0 +1,112 @@
+<img width="3320" height="1788" alt="image" src="https://github.com/user-attachments/assets/193afcea-8065-4549-9220-b5402e42a6dd" />
+
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/Coral-Protocol/coral-server)
+
+> [!WARNING]
+> 
+> This readme and connected documentation are a work in progress.
+
+
+<br/>
+<div align="center">
+  
+# Quickstart
+**See [our docs](https://docs.coralos.ai/welcome)** for a quickstart and introduction to Coral!
+  
+**[How to Run](#how-to-run)** ┃ **[Configuration](#configuration)** ┃ **[Contributing](#contribution-guidelines)**
+
+</div>
+<br/>
+
+## How to Run
+
+### Using npx
+
+If you have Node.js installed, you can run the server directly using `npx`:
+```bash
+npx coral-server@1.1.0 start --auth.keys=dev
+```
+
+You can also force the server to run from source code (cloning/updating the repository in `~/.coral/source`) by using the `--from-source` flag as the first argument:
+```bash
+npx coral-server --from-source start --auth.keys=dev
+```
+
+### Using Gradle
+
+Clone this repository, and in that folder run:
+```bash
+./gradlew run
+```
+
+### Using Docker
+
+A coral-server docker image is available on ghcr.io:
+
+```bash
+docker run \
+  -p 5555:5555 \
+  -e CONFIG_FILE_PATH=/config/config.toml
+  -v /path/to/your/config.toml:/config/config.toml
+  -v /var/run/docker.sock:/var/run/docker.sock # docker in docker
+  ghcr.io/coral-protocol/coral-server
+```
+
+> [!WARNING]
+> The Coral Server docker image is *very* minimal, which means the executable runtime will **not** work. All agents must use the Docker runtime, which means you **must** give your server container access to your host's docker socket.
+>
+> See [here](https://docs.coralprotocol.org/setup/coral-server-applications#docker-recommended) for more information on giving your docker container access to Docker.
+
+
+## Configuration
+
+Authentication keys are required to be configured in a `config.toml` file, e.g.:
+
+```toml
+[auth]
+keys = ["my-auth-key"]
+```
+
+The server must be given an environment variable `CONFIG_FILE_PATH` pointing to the location of the config file.
+Alternatively, you can provide configuration via command-line arguments. For example, to set the authentication keys to `["dev"]`, run the server with:
+
+```bash
+./gradlew run --args="--auth.keys=dev"
+```
+
+### Command-line Property Mapping
+
+The server uses [Hoplite](https://github.com/sksamuel/hoplite) for configuration. When using command-line arguments:
+
+- **Nested Properties:** Use dot notation to reach nested configuration blocks. For example, the `[auth]` block's `keys` property becomes `--auth.keys`.
+- **Collections (Lists/Sets):** Provide multiple values separated by commas. For example, `--auth.keys=key1,key2` will be parsed into a set containing both keys.
+- **Data Types:** Simple types (strings, booleans, numbers) are automatically converted. Booleans can be set as `--some.flag=true`.
+
+Examples:
+
+| TOML Config | Command-line Argument                  |
+| :--- |:---------------------------------------|
+| `[auth]`<br/>`keys = ["a", "b"]` | `--auth.keys=a,b`                      |
+| `[network]`<br/>`bindPort = 8080` | `--network.bind-port=8080`             |
+| `[registry]`<br/>`includeDebugAgents = true` | `--registry.include-debug-agents=true` |
+
+(camel-case forms for still work for command-line args)
+
+## Contribution Guidelines
+
+We welcome contributions! Email us at [hello@coralos.ai](mailto:hello@coralos.au) or join our Discord [here](https://discord.gg/rMQc2uWXhj) to connect with the developer team. Feel free to open issues or submit pull requests.
+
+Thanks for checking out the project, we hope you like it!
+
+### Development
+IntelliJ IDEA is recommended for development. The project uses Gradle as the build system.
+
+To clone and import the project:
+Go to File > New > Project from Version Control > Git.
+enter `git@github.com:Coral-Protocol/coral-server.git`
+Click Clone.
+
+### Running from IntelliJ IDEA
+You can click the play button next to the main method in the `Main.kt` file to run the server directly from IntelliJ IDEA.
+

package/npx/coral-server.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const { parseCliArgs, printUsage } = require('./lib/cli-parser');
+const { runServer, runFromSource } = require('./lib/runner');
+const { runSetupWizard } = require('./lib/wizard');
+const { 
+  ensureConfigProfileDir, 
+  getConfigProfilePath, 
+  generateDefaultConfig 
+} = require('./lib/config-manager');
+
+async function main() {
+  const parsed = parseCliArgs(process.argv);
+  const { command, subcommand, subcommandArgs, cliFlags, serverArgs } = parsed;
+
+  // Legacy support: no subcommand, print usage
+  if (!command) {
+    printUsage();
+    process.exit(0);
+  }
+
+  // Legacy --from-source=true as first arg (backward compat)
+  if (command === '--from-source=true' || (command && command.startsWith('--'))) {
+    // Legacy mode: treat all args as server args
+    let args = process.argv.slice(2);
+    let forceFromSource = false;
+    if (args[0] === '--from-source=true') {
+      forceFromSource = true;
+      args = args.slice(1);
+    }
+    if (forceFromSource) {
+      await runFromSource(args);
+    } else {
+      await runServer(args, null, false);
+    }
+    return;
+  }
+
+  if (command !== 'server') {
+    console.error(`Unknown command: ${command}`);
+    printUsage();
+    process.exit(1);
+  }
+
+  const configProfile = cliFlags['config-profile'] || null;
+  const forceFromSource = cliFlags['from-source'] === true || cliFlags['from-source'] === 'true';
+
+  switch (subcommand) {
+    case 'start':
+      await runServer(serverArgs, configProfile, forceFromSource);
+      break;
+
+    case 'configure': {
+      const profileName = subcommandArgs[0] || configProfile;
+      if (!profileName) {
+        console.error('Error: Please specify a profile name.');
+        console.log('Usage: npx coralos-dev server configure <profile-name>');
+        process.exit(1);
+      }
+      ensureConfigProfileDir(profileName);
+      const profilePath = getConfigProfilePath(profileName);
+      if (!fs.existsSync(profilePath)) {
+        fs.writeFileSync(profilePath, generateDefaultConfig());
+        console.log(`File created at ${profilePath}`);
+      }
+      await runSetupWizard(profileName, { hasAuthKeysArg: false, isStartCommand: false });
+      break;
+    }
+
+    default:
+      if (!subcommand) {
+        console.error('Error: Please specify a subcommand (start, configure).');
+      } else {
+        console.error(`Unknown subcommand: ${subcommand}`);
+      }
+      printUsage();
+      process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/npx/lib/cli-parser.js

@@ -0,0 +1,70 @@
+const { pkg } = require('./constants');
+
+function parseCliArgs(argv) {
+  const rawArgs = argv.slice(2);
+
+  // Split on -- separator: args before are CLI args, args after are server args
+  const doubleDashIndex = rawArgs.indexOf('--');
+  let cliArgs, serverArgs;
+
+  if (doubleDashIndex >= 0) {
+    cliArgs = rawArgs.slice(0, doubleDashIndex);
+    serverArgs = rawArgs.slice(doubleDashIndex + 1);
+  } else {
+    cliArgs = rawArgs;
+    serverArgs = [];
+  }
+
+  // Extract subcommand (e.g., "server start", "server configure")
+  let command = null;
+  let subcommand = null;
+  let subcommandArgs = [];
+  let cliFlags = {};
+
+  const positional = [];
+  for (const arg of cliArgs) {
+    if (arg.startsWith('--')) {
+      const eqIndex = arg.indexOf('=');
+      if (eqIndex >= 0) {
+        const key = arg.substring(2, eqIndex);
+        const value = arg.substring(eqIndex + 1);
+        cliFlags[key] = value;
+      } else {
+        cliFlags[arg.substring(2)] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  command = positional[0] || null;
+  subcommand = positional[1] || null;
+  subcommandArgs = positional.slice(2);
+
+  return { command, subcommand, subcommandArgs, cliFlags, serverArgs };
+}
+
+function printUsage() {
+  const version = pkg.version;
+  console.log(`coralos-dev v${version} - Coral Server CLI\n`);
+  console.log('Usage:');
+  console.log('  npx coralos-dev server start [--config-profile=<name>] [--from-source] [-- <server-args...>]');
+  console.log('  npx coralos-dev server configure <profile-name>');
+  console.log('');
+  console.log('Commands:');
+  console.log('  server start       Start the Coral server');
+  console.log('  server configure   Run the setup wizard for a config profile');
+  console.log('');
+  console.log('Options:');
+  console.log('  --config-profile=<name>   Use a named config profile from ~/.coral/config-profiles/');
+  console.log('  --from-source             Build and run from source code');
+  console.log('');
+  console.log('Examples:');
+  console.log(`  npx coralos-dev@${version} server start --config-profile=dev -- --auth.keys=dev`);
+  console.log(`  npx coralos-dev@${version} server configure dev`);
+}
+
+module.exports = {
+  parseCliArgs,
+  printUsage,
+};

package/npx/lib/config-manager.js

@@ -0,0 +1,81 @@
+const path = require('path');
+const fs = require('fs');
+const { CONFIG_PROFILES_DIR, pkg } = require('./constants');
+
+function getProfileDir(profileName) {
+  return path.join(CONFIG_PROFILES_DIR, profileName);
+}
+
+function getConfigProfilePath(profileName) {
+  return path.join(getProfileDir(profileName), `${profileName}-coral-server-config.toml`);
+}
+
+function ensureConfigProfileDir(profileName) {
+  const profileDir = getProfileDir(profileName);
+  if (!fs.existsSync(profileDir)) {
+    fs.mkdirSync(profileDir, { recursive: true });
+  }
+}
+
+function configProfileExists(profileName) {
+  return fs.existsSync(getConfigProfilePath(profileName));
+}
+
+function generateDefaultConfig() {
+  const templatePath = path.join(__dirname, '..', '..', 'default-dev-config.toml');
+  if (!fs.existsSync(templatePath)) {
+    // Fallback if template missing
+    return `# Coral Server Configuration Profile\n# Template not found at ${templatePath}\n`;
+  }
+  
+  let content = fs.readFileSync(templatePath, 'utf8');
+
+  // Remove the "reference" message (line 10 in original)
+  content = content.replace(/^# This file is a reference.*?\n/m, '');
+  // Also remove the next few lines that are part of that note if they exist
+  content = content.replace(/^# NOTE: Agent-specific configuration lives in each agent's own.*?\n/m, '');
+  content = content.replace(/^#       coral-agent.toml\..*?\n/m, '');
+
+  const header = `# Coral Server Configuration Profile
+# Generated by coralos-dev v${pkg.version}
+# Documentation: https://docs.coralos.ai/
+
+`;
+  return header + content;
+}
+
+function buildConfigFromWizardResults(providers, authKey) {
+  let config = generateDefaultConfig();
+
+  // Add auth keys if provided
+  if (authKey) {
+    const authRegex = /# \[auth\]\n# keys = \["some-secure-password"\]/m;
+    if (authRegex.test(config)) {
+      config = config.replace(authRegex, `[auth]\nkeys = ["${authKey}"]`);
+    } else {
+      config += `\n[auth]\nkeys = ["${authKey}"]\n`;
+    }
+  }
+
+  // Add providers
+  config += '\n# --- Configured LLM Providers ---\n';
+  config += '[llm-proxy.providers]\n';
+  for (const p of providers) {
+    if (p.working) {
+      config += `[llm-proxy.providers.${p.id}]\napiKey = "${p.apiKey}"\n\n`;
+    } else if (p.apiKey) {
+      config += `# [llm-proxy.providers.${p.id}]\n# apiKey = "${p.apiKey}"\n\n`;
+    }
+  }
+
+  return config;
+}
+
+module.exports = {
+  getProfileDir,
+  getConfigProfilePath,
+  ensureConfigProfileDir,
+  configProfileExists,
+  generateDefaultConfig,
+  buildConfigFromWizardResults,
+};

package/npx/lib/constants.js

@@ -0,0 +1,25 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const pkgPath = path.join(__dirname, '..', '..', 'package.json');
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+const CORAL_HOME = path.join(os.homedir(), '.coral');
+const CONFIG_PROFILES_DIR = path.join(CORAL_HOME, 'config-profiles');
+
+const LLM_PROVIDERS = [
+  { id: 'openai',     name: 'OpenAI',     envVar: 'OPENAI_API_KEY',     prefix: 'sk-' },
+  { id: 'anthropic',  name: 'Anthropic',   envVar: 'ANTHROPIC_API_KEY',  prefix: 'sk-ant-' },
+  { id: 'openrouter', name: 'OpenRouter',  envVar: 'OPENROUTER_API_KEY', prefix: 'sk-or-' },
+];
+
+const IS_WINDOWS = process.platform === 'win32';
+
+module.exports = {
+  pkg,
+  CORAL_HOME,
+  CONFIG_PROFILES_DIR,
+  LLM_PROVIDERS,
+  IS_WINDOWS,
+};

package/npx/lib/runner.js

@@ -0,0 +1,173 @@
+const { spawn, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { pkg, IS_WINDOWS } = require('./constants');
+const { getJavaVersion, askQuestion } = require('./utils');
+const { 
+  getConfigProfilePath, 
+  configProfileExists, 
+  ensureConfigProfileDir, 
+  generateDefaultConfig 
+} = require('./config-manager');
+const { handleFirstRun } = require('./wizard');
+
+async function runFromSource(args) {
+  const sourceDir = path.join(os.homedir(), '.coral', 'source');
+  const repoUrl = pkg.repository && pkg.repository.url ? pkg.repository.url.replace(/^git\+/, '') : null;
+  const version = pkg.version;
+  const gitHead = pkg.gitHead;
+
+  if (!fs.existsSync(sourceDir)) {
+    fs.mkdirSync(sourceDir, { recursive: true });
+  }
+
+  if (repoUrl) {
+    try {
+      const hasGit = spawnSync('git', ['--version']).status === 0;
+      if (hasGit) {
+        const isGit = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: sourceDir }).status === 0;
+        const isSnapshot = version.includes('SNAPSHOT');
+        const target = !isSnapshot ? (gitHead || `v${version}`) : 'master';
+
+        if (!isGit) {
+          console.log(`Initializing git repository in ${sourceDir} and fetching ${target}...`);
+          spawnSync('git', ['init'], { cwd: sourceDir, stdio: 'inherit' });
+          spawnSync('git', ['remote', 'add', 'origin', repoUrl], { cwd: sourceDir, stdio: 'inherit' });
+        }
+
+        console.log(`Fetching ${target} in ${sourceDir}...`);
+        const fetch = spawnSync('git', ['fetch', 'origin', target, '--depth', '1'], { cwd: sourceDir, stdio: 'inherit' });
+        if (fetch.status === 0) {
+          spawnSync('git', ['checkout', 'FETCH_HEAD', '--force'], { cwd: sourceDir, stdio: 'inherit' });
+        } else if (isSnapshot) {
+          const fetchMain = spawnSync('git', ['fetch', 'origin', 'main', '--depth', '1'], { cwd: sourceDir, stdio: 'inherit' });
+          if (fetchMain.status === 0) {
+            spawnSync('git', ['checkout', 'FETCH_HEAD', '--force'], { cwd: sourceDir, stdio: 'inherit' });
+          }
+        }
+      }
+    } catch (e) {
+      console.warn('Git operation failed, continuing with existing source in ' + sourceDir + ':', e.message);
+    }
+  }
+
+  const gradlewPath = path.join(sourceDir, IS_WINDOWS ? 'gradlew.bat' : 'gradlew');
+  const gradlePropsPath = path.join(sourceDir, 'gradle.properties');
+
+  if (fs.existsSync(gradlePropsPath)) {
+    let props = fs.readFileSync(gradlePropsPath, 'utf8');
+    let modified = false;
+    if (!props.includes('org.gradle.java.installations.auto-detect=true')) {
+      props += '\norg.gradle.java.installations.auto-detect=true';
+      modified = true;
+    }
+    if (!props.includes('org.gradle.java.installations.auto-download=true')) {
+      props += '\norg.gradle.java.installations.auto-download=true';
+      modified = true;
+    }
+    if (modified) {
+      fs.writeFileSync(gradlePropsPath, props);
+      console.log('Added portable Gradle properties to ' + gradlePropsPath);
+    }
+  }
+
+  if (!fs.existsSync(gradlewPath)) {
+    console.error('Error: gradlew not found in ' + sourceDir);
+    process.exit(1);
+  }
+
+  console.log('Running from source code using gradlew run...');
+  const child = spawn(gradlewPath, ['run', '--args=' + args.join(' ')], {
+    cwd: sourceDir,
+    stdio: 'inherit',
+    shell: IS_WINDOWS
+  });
+
+  child.on('exit', (code) => {
+    process.exit(code !== null ? code : 1);
+  });
+
+  const killChild = () => {
+    if (child.pid) child.kill('SIGINT');
+  };
+
+  process.on('SIGINT', killChild);
+  process.on('SIGTERM', killChild);
+}
+
+async function runServer(serverArgs, configProfile, forceFromSource) {
+  // Check if --auth.keys is in serverArgs
+  const hasAuthKeysArg = serverArgs.some(arg => arg.startsWith('--auth.keys=') || arg.includes('.auth.keys='));
+
+  // If config profile specified, add CONFIG_FILE_PATH
+  if (configProfile) {
+    const profilePath = getConfigProfilePath(configProfile);
+
+    if (!configProfileExists(configProfile)) {
+      if (process.stdin.isTTY) {
+        await handleFirstRun(configProfile, { hasAuthKeysArg, isStartCommand: true });
+      } else {
+        ensureConfigProfileDir(configProfile);
+        fs.writeFileSync(profilePath, generateDefaultConfig());
+        console.log(`File created at ${profilePath}`);
+      }
+    }
+
+    // Set the config file path environment variable for the server
+    process.env.CONFIG_FILE_PATH = profilePath;
+  }
+
+  if (forceFromSource) {
+    await runFromSource(serverArgs);
+    return;
+  }
+
+  const javaVersion = getJavaVersion();
+  const jarPath = path.join(__dirname, '..', '..', 'coral-server.jar');
+
+  if (javaVersion !== 24 && process.stdin.isTTY) {
+    console.log(`\nJava 24 is recommended, but version ${javaVersion || 'unknown'} was detected.`);
+    const answer = await askQuestion('Would you like to try running from source code? This will clone/update the repo in ~/.coral/source and use Gradle to run. (y/N): ');
+
+    if (answer.toLowerCase() === 'y') {
+      await runFromSource(serverArgs);
+      return;
+    }
+  }
+
+  // Fallback to java -jar
+  if (!fs.existsSync(jarPath)) {
+    console.error('Error: "java" command not found or version mismatch, and coral-server.jar not found at ' + jarPath);
+    process.exit(1);
+  }
+
+  const child = spawn('java', ['-jar', jarPath, ...serverArgs], {
+    stdio: 'inherit'
+  });
+
+  child.on('error', (err) => {
+    if (err.code === 'ENOENT') {
+      console.error('Error: "java" command not found. Please install Java (JRE or JDK, version 24 or later recommended).');
+    } else {
+      console.error('Error starting java:', err.message);
+    }
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    process.exit(code !== null ? code : 1);
+  });
+
+  const killChild = () => {
+    if (child.pid) child.kill('SIGINT');
+  };
+
+  process.on('SIGINT', killChild);
+  process.on('SIGTERM', killChild);
+}
+
+module.exports = {
+  runFromSource,
+  runServer,
+};

package/npx/lib/utils.js

@@ -0,0 +1,30 @@
+const { spawnSync } = require('child_process');
+const readline = require('readline');
+
+function getJavaVersion() {
+  try {
+    const result = spawnSync('java', ['-version'], { encoding: 'utf8' });
+    const output = result.stderr || result.stdout;
+    if (!output) return null;
+    const match = output.match(/(?:version|openjdk version) "(\d+)/i);
+    return match ? parseInt(match[1]) : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function askQuestion(query) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise(resolve => rl.question(query, ans => {
+    rl.close();
+    resolve(ans.trim());
+  }));
+}
+
+module.exports = {
+  getJavaVersion,
+  askQuestion,
+};

package/npx/lib/wizard.js

@@ -0,0 +1,196 @@
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const { pkg, LLM_PROVIDERS, IS_WINDOWS } = require('./constants');
+const { askQuestion } = require('./utils');
+const { 
+  getConfigProfilePath, 
+  ensureConfigProfileDir, 
+  generateDefaultConfig, 
+  buildConfigFromWizardResults 
+} = require('./config-manager');
+
+async function testLlmProvider(providerId, apiKey) {
+  try {
+    if (providerId === 'openai') {
+      const result = spawnSync('curl', [
+        '-s', '-o', '/dev/null', '-w', '%{http_code}',
+        '-H', `Authorization: Bearer ${apiKey}`,
+        'https://api.openai.com/v1/models',
+      ], { encoding: 'utf8', timeout: 15000 });
+      return result.stdout && result.stdout.trim() === '200';
+    } else if (providerId === 'anthropic') {
+      const result = spawnSync('curl', [
+        '-s', '-o', '/dev/null', '-w', '%{http_code}',
+        '-H', `x-api-key: ${apiKey}`,
+        '-H', 'anthropic-version: 2023-06-01',
+        'https://api.anthropic.com/v1/models',
+      ], { encoding: 'utf8', timeout: 15000 });
+      const code = result.stdout ? result.stdout.trim() : '';
+      return code === '200';
+    } else if (providerId === 'openrouter') {
+      const result = spawnSync('curl', [
+        '-s', '-o', '/dev/null', '-w', '%{http_code}',
+        '-H', `Authorization: Bearer ${apiKey}`,
+        'https://openrouter.ai/api/v1/models',
+      ], { encoding: 'utf8', timeout: 15000 });
+      return result.stdout && result.stdout.trim() === '200';
+    }
+  } catch (e) {
+    return false;
+  }
+  return false;
+}
+
+async function runSetupWizard(profileName, options = {}) {
+  const { hasAuthKeysArg = false, isStartCommand = false } = options;
+  const profilePath = getConfigProfilePath(profileName);
+  const version = pkg.version;
+
+  console.log(`\nWelcome! You can run through this wizard at any time by running this command:`);
+  console.log(`  npx coralos-dev@${version} server configure ${profileName}\n`);
+
+  let authKey = null;
+  if (!hasAuthKeysArg) {
+    const prompt = isStartCommand ? 
+      'Enter an API key for your Coral Server (required for auth, press Enter to skip): ' : 
+      'Enter an API key for your Coral Server (optional, press Enter to skip): ';
+    authKey = await askQuestion(prompt);
+    
+    if (!authKey && isStartCommand) {
+       console.log('\nContinuing without a key. You might need to provide one later via --auth.keys\n');
+    }
+  }
+
+  // Step 1: Coral Cloud API key
+  console.log('First, lets setup the LLM proxy.');
+  console.log('Please visit https://coralcloud.ai/account and create an API key.');
+  console.log('This will be used for running third party agents, and in the near future for LLM inference.\n');
+
+  const coralApiKey = await askQuestion('Enter your Coral Cloud API key (or press Enter to skip): ');
+
+  if (coralApiKey) {
+    try {
+      // Try to use keytar if available
+      const keytar = require('keytar');
+      await keytar.setPassword('coralos-dev', 'coral-cloud-api-key', coralApiKey);
+      console.log('API key saved securely in system keychain.\n');
+    } catch (e) {
+      console.log('Note: Could not save to system keychain (keytar not available).');
+      console.log('Please set it as an environment variable next time: export CORAL_CLOUD_API_KEY=your-key\n');
+    }
+  }
+
+  // Step 2: LLM providers
+  console.log('Please choose the LLM providers that you\'d like to use:\n');
+
+  const configuredProviders = [];
+
+  for (const provider of LLM_PROVIDERS) {
+    const apiKey = await askQuestion(`Enter API key for ${provider.name} (or press Enter to skip and set later): `);
+
+    if (!apiKey) {
+      console.log(`  Skipped ${provider.name}.\n`);
+      continue;
+    }
+
+    console.log(`  Testing ${provider.name}...`);
+    const works = await testLlmProvider(provider.id, apiKey);
+
+    if (works) {
+      console.log(`  ✓ ${provider.name} is working!\n`);
+      configuredProviders.push({ id: provider.id, apiKey, working: true });
+    } else {
+      console.log(`  ✗ ${provider.name} test failed.\n`);
+      configuredProviders.push({ id: provider.id, apiKey, working: false });
+    }
+  }
+
+  // Check if any working providers
+  const workingCount = configuredProviders.filter(p => p.working).length;
+  const failedProviders = configuredProviders.filter(p => !p.working);
+
+  if (failedProviders.length > 0) {
+    console.log('\nThe following providers failed validation:');
+    for (const p of failedProviders) {
+      const provider = LLM_PROVIDERS.find(lp => lp.id === p.id);
+      console.log(`  - ${provider.name}`);
+    }
+
+    if (workingCount === 0) {
+      console.log('\n⚠  No working LLM providers configured. It is highly recommended to have at least 1 working provider.');
+    }
+
+    const fixAnswer = await askQuestion('\nWould you like to re-enter keys for failed providers? (y/N): ');
+
+    if (fixAnswer.toLowerCase() === 'y') {
+      for (const p of failedProviders) {
+        const provider = LLM_PROVIDERS.find(lp => lp.id === p.id);
+        const newKey = await askQuestion(`Enter new API key for ${provider.name} (or press Enter to keep current): `);
+
+        if (newKey) {
+          console.log(`  Testing ${provider.name}...`);
+          const works = await testLlmProvider(p.id, newKey);
+          if (works) {
+            console.log(`  ✓ ${provider.name} is now working!\n`);
+            p.apiKey = newKey;
+            p.working = true;
+          } else {
+            console.log(`  ✗ ${provider.name} still failing. The key will be commented out in config.\n`);
+            p.apiKey = newKey;
+          }
+        }
+      }
+    } else {
+      console.log('Non-working providers will be commented out in the config file.');
+    }
+  }
+
+  // Write config
+  const config = buildConfigFromWizardResults(configuredProviders, authKey);
+  fs.writeFileSync(profilePath, config);
+  console.log(`\nConfiguration saved to ${profilePath}`);
+}
+
+async function handleFirstRun(profileName, options = {}) {
+  const profilePath = getConfigProfilePath(profileName);
+
+  ensureConfigProfileDir(profileName);
+  fs.writeFileSync(profilePath, generateDefaultConfig());
+  console.log(`File created at ${profilePath}\n`);
+
+  console.log('What next?');
+  console.log('1) Go through setup wizard? (recommended)');
+  console.log('2) Edit config with $EDITOR');
+  console.log('3) Continue to run the server with empty config');
+  console.log('4) Exit');
+
+  const choice = await askQuestion('\nChoose an option [1-4]: ');
+
+  switch (choice) {
+    case '1':
+      await runSetupWizard(profileName, options);
+      return true;
+    case '2': {
+      const editor = process.env.EDITOR || process.env.VISUAL || (IS_WINDOWS ? 'notepad' : 'vi');
+      const result = spawnSync(editor, [profilePath], { stdio: 'inherit' });
+      if (result.status !== 0) {
+        console.error('Editor exited with non-zero status.');
+      }
+      return true;
+    }
+    case '3':
+      return true;
+    case '4':
+      process.exit(0);
+      break;
+    default:
+      console.log('Invalid choice, continuing with empty config.');
+      return true;
+  }
+}
+
+module.exports = {
+  testLlmProvider,
+  runSetupWizard,
+  handleFirstRun,
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "coralos-dev",
+  "version": "1.1.0-SNAPSHOT-11",
+  "description": "Coral Server - Open Infrastructure Connecting the Internet of AI Agents",
+  "bin": {
+    "coralos-dev": "npx/coral-server.js"
+  },
+  "files": [
+    "npx/",
+    "bin/coral-server.jar"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Coral-Protocol/coral-server.git"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "server",
+    "coral"
+  ],
+  "author": "Coral Protocol",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "keytar": "^7.9.0"
+  }
+}