@newsails/veil-cli 1.0.1

package/cli/index.js

@@ -0,0 +1,443 @@
+#!/usr/bin/env node
+'use strict';
+
+// ── Node version check (must be first) ───────────────────────────────────────
+const [major] = process.version.slice(1).split('.').map(Number);
+if (major < 18) {
+  console.error(`VeilCLI requires Node.js 18+. Current: ${process.version}`);
+  process.exit(1);
+}
+
+// ── Set CWD and version in context singleton ──────────────────────────────────
+const context = require('../utils/context');
+const pkg = require('../package.json');
+context.setVersion(pkg.version);
+
+const { parseCliArgs, USAGE } = require('./parser');
+const fmt = require('./formatter');
+const path = require('path');
+const fs = require('fs');
+
+const args = parseCliArgs(process.argv.slice(2));
+
+// ── Command dispatch ──────────────────────────────────────────────────────────
+(async () => {
+  switch (args.command) {
+    case 'help':
+      console.log(USAGE);
+      process.exit(0);
+      break;
+
+    case 'version':
+      console.log(`VeilCLI v${pkg.version}`);
+      process.exit(0);
+      break;
+
+    case 'check-for-update':
+      await cmdCheckForUpdate();
+      break;
+
+    case 'start':
+      await cmdStart(args.args);
+      break;
+
+    case 'run':
+      await cmdRun(args.args);
+      break;
+
+    case 'stop':
+      await cmdStop(args.args);
+      break;
+
+    case 'status':
+      await cmdStatus(args.args);
+      break;
+
+    case 'agents':
+      await cmdAgents(args.subcommand, args.args);
+      break;
+
+    case 'login':
+      await cmdLogin(args.args);
+      break;
+
+    case 'import':
+      await cmdImport(args.args);
+      break;
+
+    case 'dashboard':
+      await cmdDashboard(args.args);
+      break;
+
+    default:
+      fmt.error(`Unknown command: ${args.command}`);
+      console.log('\n' + USAGE);
+      process.exit(1);
+  }
+})().catch(err => {
+  fmt.error(err.message);
+  process.exit(1);
+});
+
+// ── Command implementations ───────────────────────────────────────────────────
+
+async function cmdCheckForUpdate() {
+  const https = require('https');
+  const current = pkg.version;
+
+  const latest = await new Promise((resolve, reject) => {
+    const req = https.get(
+      `https://registry.npmjs.org/${pkg.name}/latest`,
+      { headers: { Accept: 'application/json' } },
+      (res) => {
+        let body = '';
+        res.on('data', (chunk) => { body += chunk; });
+        res.on('end', () => {
+          try { resolve(JSON.parse(body).version); }
+          catch { reject(new Error('Failed to parse npm registry response')); }
+        });
+      }
+    );
+    req.on('error', reject);
+    req.setTimeout(8000, () => { req.destroy(new Error('Request timed out')); });
+  });
+
+  if (latest === current) {
+    console.log(`No updates available (current: v${current})`);
+  } else {
+    console.log(`New update exists: v${latest}  (current: v${current})`);
+  }
+  process.exit(0);
+}
+
+async function cmdStart({ port, folder, secret, ably }) {
+  const cwd = folder ? path.resolve(folder) : process.cwd();
+  context.setCwd(cwd);
+
+  const { loadSettings } = require('../utils/settings');
+  const cliOverrides = {};
+  if (port) cliOverrides.port = parseInt(port, 10);
+  if (secret) cliOverrides.secret = secret;
+  if (ably) cliOverrides.ably = { enabled: true };
+
+  const settings = loadSettings({ cwd, cliOverrides });
+
+  // Startup recovery: mark stale processing tasks as failed
+  const db = require('../infrastructure/database');
+  db.recoverStaleTasks(cwd);
+
+  // Start scheduler
+  const { createScheduler } = require('../infrastructure/scheduler');
+  const scheduler = createScheduler();
+
+  // Auto-start daemons
+  const { listAgents, loadAgent } = require('../core/agent');
+  const agents = listAgents({ cwd });
+  for (const agentSummary of agents) {
+    if (agentSummary.modes.includes('daemon')) {
+      try {
+        const agent = loadAgent({ cwd, name: agentSummary.name });
+        if (agent.modes?.daemon?.enabled && agent.modes?.daemon?.cron) {
+          scheduler.startDaemon({ agentName: agentSummary.name, agent, cwd, settings });
+          fmt.info(`Auto-started daemon: ${agentSummary.name}`);
+        }
+      } catch (err) {
+        fmt.warn(`Failed to auto-start daemon ${agentSummary.name}: ${err.message}`);
+      }
+    }
+  }
+
+  // Start REST server
+  const { startServer } = require('../api/server');
+  const listenPort = settings.port || 5050;
+
+  const server = await startServer({ settings, scheduler, port: listenPort });
+
+  // Write PID file
+  const paths = require('../utils/paths');
+  const pidFile = paths.getPidFilePath(cwd);
+  fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+  fs.writeFileSync(pidFile, String(process.pid), 'utf8');
+
+  fmt.success(`VeilCLI v${pkg.version} started on port ${listenPort}`);
+  fmt.info(`Project: ${cwd}`);
+  fmt.info(`Agents: ${agents.length} | PID: ${process.pid}`);
+
+  // Graceful shutdown
+  const shutdown = () => {
+    fmt.info('Shutting down...');
+    scheduler.stopAll();
+    server.close(() => {
+      try { fs.unlinkSync(pidFile); } catch {}
+      db.closeDb();
+      fmt.success('Shutdown complete');
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(1), 5000);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+async function cmdRun({ agent, input, timeout, session, output, 'output-format': outputFormat }) {
+  if (!agent) { fmt.error('--agent is required'); process.exit(1); }
+  if (!input) { fmt.error('--input is required'); process.exit(1); }
+
+  const cwd = process.cwd();
+  context.setCwd(cwd);
+
+  const { loadSettings } = require('../utils/settings');
+  const settings = loadSettings({ cwd });
+  if (timeout) settings.maxDurationSeconds = parseInt(timeout, 10);
+
+  const db = require('../infrastructure/database');
+  const { runTask } = require('../core/router');
+
+  const taskId = db.createTask({
+    agentName: agent,
+    input,
+    priority: 'normal',
+    instanceFolder: cwd,
+    sessionId: session || null,
+  });
+
+  fmt.info(`Running task ${taskId} with agent "${agent}"${session ? ` (continuing session ${session})` : ''}...`);
+
+  try {
+    const result = await runTask({ taskId, cwd, settings });
+    const data = {
+      taskId,
+      sessionId: result.sessionId,
+      agent,
+      status: result.status,
+      output: result.output,
+      timestamp: new Date().toISOString(),
+    };
+
+    if (result.status === 'finished') {
+      writeOutput(data, output, outputFormat || 'json');
+      process.exit(0);
+    } else {
+      data.error = result.error || 'Task did not finish';
+      writeOutput(data, output, outputFormat || 'json');
+      process.exit(1);
+    }
+  } catch (err) {
+    const data = { error: err.message, timestamp: new Date().toISOString() };
+    writeOutput(data, output, outputFormat || 'json');
+    process.exit(1);
+  }
+}
+
+function writeOutput(data, outputFile, format) {
+  let content;
+  if (format === 'md') {
+    const { output, ...meta } = data;
+    const yamlLines = Object.entries(meta)
+      .filter(([, v]) => v !== undefined && v !== null)
+      .map(([k, v]) => `${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`);
+    content = `---\n${yamlLines.join('\n')}\n---\n\n${output || ''}`;
+  } else {
+    content = JSON.stringify(data, null, 2);
+  }
+
+  if (outputFile) {
+    fs.writeFileSync(outputFile, content, 'utf8');
+    fmt.success(`Output written to ${outputFile}`);
+  } else {
+    console.log(content);
+  }
+}
+
+async function cmdStop() {
+  const cwd = process.cwd();
+  const paths = require('../utils/paths');
+  const pidFile = paths.getPidFilePath(cwd);
+
+  if (!fs.existsSync(pidFile)) {
+    fmt.error('No running server found (no PID file at .veil/runtime.pid)');
+    process.exit(1);
+  }
+
+  const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+  try {
+    process.kill(pid, 'SIGTERM');
+    fmt.success(`Sent SIGTERM to process ${pid}`);
+  } catch (err) {
+    fmt.error(`Failed to stop server: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function cmdStatus() {
+  const cwd = process.cwd();
+  const paths = require('../utils/paths');
+  const pidFile = paths.getPidFilePath(cwd);
+
+  if (!fs.existsSync(pidFile)) {
+    fmt.warn('No running server (no PID file found)');
+    return;
+  }
+
+  const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+  try {
+    process.kill(pid, 0); // Existence check
+    fmt.success(`Server is running (PID: ${pid})`);
+  } catch {
+    fmt.warn(`PID file exists but process ${pid} is not running (stale PID file)`);
+  }
+}
+
+async function cmdAgents(subcommand, { name }) {
+  const cwd = process.cwd();
+  context.setCwd(cwd);
+
+  const { listAgents, loadAgent } = require('../core/agent');
+
+  if (subcommand === 'list' || !subcommand) {
+    const agents = listAgents({ cwd });
+    fmt.header(`Agents (${agents.length})`);
+    if (agents.length === 0) {
+      fmt.info('No agents found. Add agents to .veil/agents/<name>/');
+    } else {
+      fmt.table(agents, ['name', 'description', 'model', 'source']);
+    }
+    return;
+  }
+
+  if (subcommand === 'inspect') {
+    if (!name) { fmt.error('Agent name required: veil agents inspect <name>'); process.exit(1); }
+    try {
+      const agent = loadAgent({ cwd, name });
+      fmt.header(`Agent: ${agent.name}`);
+      fmt.info(`Description: ${agent.description || '(none)'}`);
+      fmt.info(`Model: ${agent.model}`);
+      fmt.info(`Folder: ${agent.agentFolder}`);
+      fmt.info(`Modes: ${Object.keys(agent.modes || {}).filter(m => agent.modes[m]?.enabled).join(', ') || '(none enabled)'}`);
+      if (agent.agentMd) {
+        fmt.header('AGENT.md');
+        console.log(agent.agentMd.slice(0, 500) + (agent.agentMd.length > 500 ? '\n...(truncated)' : ''));
+      }
+    } catch (err) {
+      fmt.error(err.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (subcommand === 'create') {
+    fmt.info('Interactive agent creation is not yet implemented. Create .veil/agents/<name>/agent.json manually.');
+    fmt.info('See examples/agents/hello/ for a minimal valid example.');
+    return;
+  }
+
+  fmt.error(`Unknown agents subcommand: ${subcommand}`);
+  process.exit(1);
+}
+
+async function cmdLogin({ key, global: isGlobal }) {
+  if (!key) { fmt.error('--key is required'); process.exit(1); }
+
+  const cwd = process.cwd();
+  const paths = require('../utils/paths');
+  const targetDir = isGlobal ? paths.getGlobalConfigDir() : paths.getProjectConfigDir(cwd);
+  const authPath = path.join(targetDir, 'auth.json');
+
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  let existing = {};
+  try { existing = JSON.parse(fs.readFileSync(authPath, 'utf8')); } catch {}
+
+  existing.models = existing.models || {};
+  existing.models.main = existing.models.main || {};
+  existing.models.main.api_key = key;
+
+  fs.writeFileSync(authPath, JSON.stringify(existing, null, 2), 'utf8');
+  fmt.success(`API key saved to ${authPath}`);
+}
+
+async function cmdImport({ type, source }) {
+  if (!type || !source) { fmt.error('--type and --source are required'); process.exit(1); }
+  fmt.info(`Import adapter for "${type}" is not yet fully implemented.`);
+  fmt.info(`Source: ${source}`);
+}
+
+async function cmdDashboard({ port, api, secret }) {
+  const listenPort = port ? parseInt(port, 10) : 8080;
+  if (isNaN(listenPort) || listenPort < 1 || listenPort > 65535) {
+    fmt.error(`Invalid port: ${port}`);
+    process.exit(1);
+  }
+
+  const http = require('http');
+  const uiDir = path.join(__dirname, '..', 'ui');
+
+  if (!fs.existsSync(uiDir)) {
+    fmt.error(`UI folder not found: ${uiDir}`);
+    fmt.info('Make sure the ui/ folder exists at the repo root.');
+    process.exit(1);
+  }
+
+  const MIME = {
+    '.html': 'text/html; charset=utf-8',
+    '.js':   'application/javascript; charset=utf-8',
+    '.css':  'text/css; charset=utf-8',
+    '.json': 'application/json',
+    '.png':  'image/png',
+    '.ico':  'image/x-icon',
+    '.svg':  'image/svg+xml',
+    '.woff2':'font/woff2',
+  };
+
+  const server = http.createServer((req, res) => {
+    let urlPath = req.url.split('?')[0];
+    if (urlPath === '/') urlPath = '/index.html';
+
+    const safePath = path.normalize(urlPath).replace(/^(\.\.[\/\\])+/, '');
+    let filePath   = path.join(uiDir, safePath);
+    const ext      = path.extname(filePath).toLowerCase();
+
+    if (!ext || !fs.existsSync(filePath)) {
+      filePath = path.join(uiDir, 'index.html');
+    }
+
+    try {
+      let content = fs.readFileSync(filePath);
+      const mime  = MIME[path.extname(filePath).toLowerCase()] || 'text/plain';
+
+      // Inject API pre-connect config into index.html when --api is provided
+      if (api && path.extname(filePath).toLowerCase() === '.html') {
+        const inject = `<script>window.__VEIL_API__=${JSON.stringify(api)};window.__VEIL_SECRET__=${JSON.stringify(secret || '')};</script>`;
+        content = Buffer.from(content.toString().replace('</head>', inject + '</head>'));
+      }
+
+      res.writeHead(200, {
+        'Content-Type':  mime,
+        'Cache-Control': 'no-cache',
+      });
+      res.end(content);
+    } catch {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not found');
+    }
+  });
+
+  server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      fmt.error(`Port ${listenPort} is already in use. Use --port to specify a different port.`);
+    } else {
+      fmt.error(`Server error: ${err.message}`);
+    }
+    process.exit(1);
+  });
+
+  server.listen(listenPort, '127.0.0.1', () => {
+    fmt.success(`Dashboard available at http://localhost:${listenPort}`);
+    fmt.info(`Serving: ${uiDir}`);
+    if (api) fmt.info(`Pre-connecting to API: ${api}`);
+    fmt.info('Press Ctrl+C to stop.');
+  });
+
+  process.on('SIGINT',  () => { server.close(); process.exit(0); });
+  process.on('SIGTERM', () => { server.close(); process.exit(0); });
+}

package/cli/parser.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const { parseArgs } = require('util');
+
+const USAGE = `
+VeilCLI — Enterprise autonomous agent runtime
+
+Usage:
+  veil start [--port <n>] [--folder <path>] [--secret <s>] [--ably]
+  veil run --agent <name> --input "<text>" [--session <id>] [--timeout <s>] [--output <file>] [--output-format json|md]
+  veil stop
+  veil status
+  veil agents list
+  veil agents inspect <name>
+  veil agents create
+  veil login --key <token> [--global]
+  veil import --type <type> --source <path>
+  veil dashboard [--port <n>] [--api <url>] [--secret <s>]
+
+Commands:
+  start         Start the REST API server
+  run           Run a one-shot task and exit
+  stop          Gracefully stop the running server
+  status        Show running server info
+  agents        Manage agents (list, inspect, create)
+  login         Store API credentials
+  import        Import agents from Claude Code / other formats
+  dashboard     Launch the browser-based GUI (default port: 8080)
+                 Use --api to pre-connect to a specific Veil API URL
+
+Options:
+  --port        Port to listen on (default: 5050 for start, 8080 for dashboard)
+  --api         Veil API base URL to pre-connect (e.g. http://localhost:5051)
+  --folder      Project folder (default: current directory)
+  --secret      API secret for auth header
+  --ably        Enable Ably remote access
+  --agent       Agent name (for run command)
+  --input       Task input text (for run command)
+  --session     Continue from existing session ID (for run command)
+  --timeout     Timeout in seconds (for run command)
+  --output      Write output to file instead of stdout (for run command)
+  --output-format  Output format: json (default) or md (for run command)
+  --key         API key (for login command)
+  --global      Apply globally to ~/.veil/ (for login command)
+  --type        Import type: claude-code|raw (for import command)
+  --source      Source path (for import command)
+  --help, -h          Show this help
+  --version           Show version
+  --check-for-update  Check if a newer version is available on npm
+`.trim();
+
+/**
+ * Parse CLI arguments.
+ * @param {string[]} argv - process.argv.slice(2)
+ * @returns {{ command: string, subcommand?: string, args: Object }}
+ */
+function parseCliArgs(argv) {
+  if (!argv || argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
+    return { command: 'help', args: {} };
+  }
+
+  if (argv[0] === '--version') {
+    return { command: 'version', args: {} };
+  }
+
+  if (argv[0] === '--check-for-update') {
+    return { command: 'check-for-update', args: {} };
+  }
+
+  const command = argv[0];
+  const rest = argv.slice(1);
+
+  // Handle subcommands (e.g. `agents list`, `agents inspect <name>`)
+  if (command === 'agents') {
+    const subcommand = rest[0] || 'list';
+    const argName = rest[1]; // e.g. agent name for inspect
+    return { command: 'agents', subcommand, args: { name: argName } };
+  }
+
+  // Parse flags for remaining commands
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: rest,
+      options: {
+        port:    { type: 'string' },
+        folder:  { type: 'string' },
+        secret:  { type: 'string' },
+        api:     { type: 'string' },
+        ably:    { type: 'boolean', default: false },
+        agent:   { type: 'string' },
+        input:   { type: 'string' },
+        timeout: { type: 'string' },
+        session: { type: 'string' },
+        output:  { type: 'string' },
+        'output-format': { type: 'string' },
+        key:     { type: 'string' },
+        global:  { type: 'boolean', default: false },
+        type:    { type: 'string' },
+        source:  { type: 'string' },
+        help:    { type: 'boolean', short: 'h', default: false },
+      },
+      allowPositionals: true,
+      strict: false,
+    });
+  } catch {
+    return { command, args: {} };
+  }
+
+  return { command, args: parsed.values };
+}
+
+module.exports = { parseCliArgs, USAGE };

package/config/config.json

@@ -0,0 +1,10 @@
+{
+  "name": "VeilCLI",
+  "version": "1.0.0",
+  "description": "Enterprise autonomous agent runtime",
+  "defaultPort": 5050,
+  "configDirName": ".veil",
+  "dbFileName": "data.db",
+  "pidFileName": "runtime.pid",
+  "globalConfigDir": "~/.veil"
+}