@wevion/cli 1.0.2 → 1.0.3

package/selftest.mjs

@@ -1,11 +1,25 @@
 // Minimal runnable check for the spec->request mapping. Run: node selftest.mjs
 import assert from 'node:assert/strict'
-import { mkdtempSync, symlinkSync } from 'node:fs'
+import { mkdtempSync, statSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
+import { createServer } from 'node:http'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { execFileSync } from 'node:child_process'
-import { kebab, listOperations, buildRequest, configPath, resolveApiKey } from './src/index.mjs'
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import {
+  kebab,
+  listOperations,
+  buildRequest,
+  configPath,
+  resolveApiKey,
+  compareVersions,
+  updateCheckPath,
+  upgradeMessage,
+  opToJson,
+  isSafeVersion,
+  updateCheckEnv,
+} from './src/index.mjs'
 
 const spec = {
   openapi: '3.0.3',
@@ -155,9 +169,10 @@ assert.deepEqual(JSON.parse(message.body), { id: 'msg_1', content: 'ciao' })
 assert.throws(() => buildRequest(ops.get('upload-file'), {}, 'x'), /request body media type is not supported/)
 
 // config path honours XDG_CONFIG_HOME, falls back to ~/.config
-assert.equal(configPath({ XDG_CONFIG_HOME: '/x' }), '/x/wevion/config.json')
-assert.equal(configPath({ HOME: '/home/u' }), '/home/u/.config/wevion/config.json')
-assert.equal(configPath({ APPDATA: 'C:\\Users\\u\\AppData\\Roaming' }, 'win32'), 'C:\\Users\\u\\AppData\\Roaming/Wevion/config.json')
+assert.equal(configPath({ XDG_CONFIG_HOME: '/x' }, 'linux'), '/x/wevion/config.json')
+assert.equal(configPath({ HOME: '/home/u' }, 'linux'), '/home/u/.config/wevion/config.json')
+const appData = 'C:\\Users\\u\\AppData\\Roaming'
+assert.equal(configPath({ APPDATA: appData }, 'win32'), join(appData, 'Wevion', 'config.json'))
 
 // api key precedence: env > config
 assert.equal(resolveApiKey({ WEVION_API_KEY: 'env' }, { apiKey: 'cfg' }), 'env')
@@ -170,14 +185,245 @@ assert.match(bundled.openapi, /^3\./)
 assert.ok(Object.keys(bundled.paths || {}).length > 0)
 const knownCommand = listOperations(bundled).keys().next().value
 assert.ok(knownCommand)
+const knownSimpleCommand = 'get-api-v1-ad-accounts'
+assert.ok(listOperations(bundled).has(knownSimpleCommand))
 
 const tmp = mkdtempSync(join(tmpdir(), 'wevion-cli-'))
-const symlink = join(tmp, 'wevion')
-symlinkSync(new URL('./src/index.mjs', import.meta.url), symlink)
-const help = execFileSync(process.execPath, [symlink, 'help', knownCommand, '--base-url=http://127.0.0.1:9'], {
-  encoding: 'utf8',
-  env: { ...process.env, WEVION_API_KEY: '' },
+const cli = fileURLToPath(new URL('./src/index.mjs', import.meta.url))
+const childBaseEnv = {
+  PATH: process.env.PATH || '',
+  Path: process.env.Path || '',
+  SystemRoot: process.env.SystemRoot || '',
+  WINDIR: process.env.WINDIR || '',
+  TEMP: process.env.TEMP || tmp,
+  TMP: process.env.TMP || tmp,
+  CI: '1',
+  NO_UPDATE_NOTIFIER: '1',
+  WEVION_API_KEY: '',
+  WEVION_TIMEOUT_MS: '1000',
+  WEVION_SPEC_TIMEOUT_MS: '500',
+  XDG_CONFIG_HOME: tmp,
+  HOME: tmp,
+  APPDATA: tmp,
+}
+
+function runCli(args, env = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [cli, ...args], {
+      env: { ...childBaseEnv, ...env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.setEncoding('utf8')
+    child.stderr.setEncoding('utf8')
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk
+    })
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk
+    })
+    child.on('error', (err) => {
+      resolve({ status: 1, stdout, stderr: `${stderr}${err.message}` })
+    })
+    child.on('close', (status) => {
+      resolve({ status, stdout, stderr })
+    })
+  })
+}
+
+const offlineHelp = await runCli(['help', knownCommand, '--base-url=http://127.0.0.1:9'])
+assert.equal(offlineHelp.status, 0)
+assert.match(offlineHelp.stdout, /Flags:/)
+const leadingBaseUrlList = await runCli(['--base-url=http://127.0.0.1:9', 'list'])
+assert.equal(leadingBaseUrlList.status, 0)
+assert.match(leadingBaseUrlList.stdout, /Wevion CLI/)
+const leadingBaseUrlHelpJson = await runCli(['--base-url', 'http://127.0.0.1:9', 'help', knownCommand, '--json'])
+assert.equal(leadingBaseUrlHelpJson.status, 0)
+assert.equal(JSON.parse(leadingBaseUrlHelpJson.stdout).command, knownCommand)
+
+const liveSpec = {
+  openapi: '3.0.3',
+  security: [{ apiKeyAuth: [] }],
+  paths: {
+    '/api/v1/sentinel': {
+      get: {
+        operationId: 'sentinelLiveSpec',
+        tags: ['sentinel'],
+        summary: 'sentinel-live-spec',
+        responses: { 200: { description: 'OK' } },
+      },
+    },
+    '/api/v1/no-content': {
+      get: {
+        operationId: 'noContentSuccess',
+        tags: ['sentinel'],
+        summary: 'no-content-success',
+        responses: { 204: { description: 'No content' } },
+      },
+    },
+    '/api/v1/error': {
+      get: {
+        operationId: 'errorWithSecret',
+        tags: ['sentinel'],
+        summary: 'error-with-secret',
+        parameters: [{ name: 'api_key', in: 'query', schema: { type: 'string' } }],
+        responses: { 500: { description: 'Error' } },
+      },
+    },
+  },
+}
+
+let mode = 'live'
+const hits = []
+const server = createServer((req, res) => {
+  hits.push({ method: req.method, url: req.url, headers: req.headers })
+  if (req.url === '/docs/json') {
+    if (mode === 'upgrade') {
+      res.writeHead(426, {
+        'content-type': 'application/json',
+        'x-wevion-min-cli-version': '9.0.0',
+      })
+      res.end(JSON.stringify({ message: 'please upgrade test' }))
+      return
+    }
+    if (mode === 'invalid') {
+      res.writeHead(200, { 'content-type': 'text/html' })
+      res.end('<html>not openapi</html>')
+      return
+    }
+    res.writeHead(200, { 'content-type': 'application/json' })
+    if (req.method === 'HEAD') {
+      res.end()
+      return
+    }
+    res.end(JSON.stringify(liveSpec))
+    return
+  }
+  if (req.url === '/api/v1/no-content') {
+    res.writeHead(204)
+    res.end()
+    return
+  }
+  if (req.url?.startsWith('/api/v1/error')) {
+    res.writeHead(500, { 'content-type': 'application/json' })
+    res.end(JSON.stringify({ error: 'boom' }))
+    return
+  }
+  res.writeHead(404, { 'content-type': 'application/json' })
+  res.end(JSON.stringify({ error: 'not found' }))
+})
+
+await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
+try {
+  const baseUrl = `http://127.0.0.1:${server.address().port}`
+  const liveList = await runCli(['list', '--json'], { WEVION_BASE_URL: baseUrl })
+  assert.equal(liveList.status, 0)
+  assert.equal(liveList.stderr, '')
+  assert.ok(JSON.parse(liveList.stdout).find((op) => op.command === 'sentinel-live-spec'))
+  assert.equal(hits[0].url, '/docs/json')
+  assert.equal(hits[0].method, 'GET')
+  assert.equal(hits[0].headers['x-wevion-cli-version'], '1.0.0')
+  if (process.platform !== 'win32') {
+    assert.equal(statSync(join(tmp, 'wevion', 'spec-cache.json')).mode & 0o777, 0o600)
+  }
+
+  const cacheHitList = await runCli(['list', '--json'], { WEVION_BASE_URL: baseUrl })
+  assert.equal(cacheHitList.status, 0)
+  assert.ok(JSON.parse(cacheHitList.stdout).find((op) => op.command === 'sentinel-live-spec'))
+  assert.ok(hits.find((hit) => hit.method === 'HEAD' && hit.url === '/docs/json'))
+
+  mode = 'invalid'
+  const invalidSpecFallback = await runCli(['list', '--json'], {
+    WEVION_BASE_URL: baseUrl,
+    WEVION_SPEC_TTL_MS: '0',
+  })
+  assert.equal(invalidSpecFallback.status, 0)
+  assert.ok(JSON.parse(invalidSpecFallback.stdout).find((op) => op.command === 'sentinel-live-spec'))
+  assert.match(invalidSpecFallback.stderr, /invalid OpenAPI spec/)
+  mode = 'live'
+
+  const helpJson = await runCli(['help', 'sentinel-live-spec', '--json'], { WEVION_BASE_URL: baseUrl })
+  assert.equal(helpJson.status, 0)
+  assert.equal(JSON.parse(helpJson.stdout).command, 'sentinel-live-spec')
+
+  const agentGuide = await runCli(['agent'], { WEVION_BASE_URL: baseUrl })
+  assert.equal(agentGuide.status, 0)
+  assert.match(agentGuide.stdout, /agent guide/)
+  assert.equal(hits.filter((hit) => hit.url === '/docs/json').length, 4)
+
+  const badListFlag = await runCli(['list', '--json', '--bad'], { WEVION_BASE_URL: baseUrl })
+  assert.equal(badListFlag.status, 2)
+  const badHelpFlag = await runCli(['help', 'sentinel-live-spec', '--json', '--bad'], { WEVION_BASE_URL: baseUrl })
+  assert.equal(badHelpFlag.status, 2)
+
+  const usageError = await runCli(['no-content-success', '--definitely-unknown'], {
+    WEVION_BASE_URL: baseUrl,
+    WEVION_API_KEY: 'test-key',
+  })
+  assert.equal(usageError.status, 2)
+
+  const emptySuccess = await runCli(['no-content-success'], {
+    WEVION_BASE_URL: baseUrl,
+    WEVION_API_KEY: 'test-key',
+  })
+  assert.equal(emptySuccess.status, 0)
+  assert.deepEqual(JSON.parse(emptySuccess.stdout), { ok: true, status: 204 })
+
+  const unsafeBaseUrl = await runCli([knownSimpleCommand, '--base-url', `http://user:pass@127.0.0.1:${server.address().port}`], {
+    WEVION_API_KEY: 'test-key',
+  })
+  assert.equal(unsafeBaseUrl.status, 2)
+  assert.match(unsafeBaseUrl.stderr, /must not include credentials/)
+
+  const redactedError = await runCli(['error-with-secret', '--api_key', 'secret-value'], {
+    WEVION_BASE_URL: baseUrl,
+    WEVION_API_KEY: 'test-key',
+  })
+  assert.equal(redactedError.status, 1)
+  assert.match(redactedError.stderr, /api_key=%5BREDACTED%5D/)
+  assert.doesNotMatch(redactedError.stderr, /secret-value/)
+
+  mode = 'upgrade'
+  const upgrade = await runCli(['--base-url', baseUrl, 'list'], { WEVION_SPEC_TTL_MS: '0' })
+  assert.equal(upgrade.status, 3)
+  assert.equal(upgrade.stdout, '')
+  assert.match(upgrade.stderr, /please upgrade test/)
+} finally {
+  await new Promise((resolve) => server.close(resolve))
+}
+
+// update notifier: version compare + cache path location
+assert.ok(compareVersions('1.0.10', '1.0.2') > 0) // numeric, not lexical
+assert.ok(compareVersions('1.0.2', '1.0.10') < 0)
+assert.equal(compareVersions('1.0.3', '1.0.3'), 0)
+assert.ok(compareVersions('1.1.0', '1.0.999') > 0)
+assert.ok(compareVersions('1.0.0-beta.1', '1.0.0') < 0)
+assert.ok(compareVersions('1.0.0', '1.0.0-beta.1') > 0)
+assert.ok(isSafeVersion('1.0.0-beta.1'))
+assert.equal(isSafeVersion('1.0.0\nbad'), false)
+assert.equal(updateCheckPath({ XDG_CONFIG_HOME: '/x' }), '/x/wevion/update-check.json')
+assert.deepEqual(updateCheckEnv({ HOME: '/h', WEVION_API_KEY: 'secret', HTTPS_PROXY: 'http://p' }), {
+  HOME: '/h',
+  HTTPS_PROXY: 'http://p',
 })
-assert.match(help, /Flags:/)
+
+// 426 upgrade message: prefer the server-provided message, else a default
+assert.equal(upgradeMessage('{"message":"upgrade now: npm i -g @wevion/cli@latest"}'), 'upgrade now: npm i -g @wevion/cli@latest')
+assert.match(upgradeMessage('not json'), /no longer supported/)
+assert.match(upgradeMessage('', '9.0.0'), /Minimum: 9\.0\.0/)
+
+// opToJson: machine-readable command view for agents (list --json / help --json)
+const getJson = opToJson(ops.get('get-ad-account-by-id'))
+assert.equal(getJson.command, 'get-ad-account-by-id')
+assert.equal(getJson.method, 'GET')
+assert.deepEqual(
+  getJson.params.find((p) => p.flag === '--id'),
+  { flag: '--id', in: 'path', required: true, type: 'string', array: false },
+)
+assert.equal(getJson.body, null)
+const postJson = opToJson(ops.get('create-campaign'))
+assert.ok(postJson.body.flags.find((f) => f.field === 'name' && f.required === true))
+assert.equal(postJson.body.raw, "--json '<json>'")
 
 console.log('ok')