@afffun/codexbot 1.0.72 → 1.0.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afffun/codexbot",
-  "version": "1.0.72",
+  "version": "1.0.74",
   "description": "Thin npm bootstrap CLI for installing and operating Codexbot nodes",
   "type": "module",
   "author": "john88188 <john88188@outlook.com>",

package/src/activation_service.mjs

@@ -0,0 +1,262 @@
+import fsSyncDefault from 'node:fs';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import readline from 'node:readline/promises';
+
+import { buildInstallLicenseClaimUrl, getDefaultDistributionConfig } from './config_service.mjs';
+import { resolveInstalledControlLayout } from './installed_layout_service.mjs';
+
+function trim(value, fallback = '') {
+  const text = String(value ?? '').trim();
+  return text || String(fallback ?? '').trim();
+}
+
+function createPrompter({ stdin, stdout } = {}) {
+  const input = stdin || process.stdin;
+  const output = stdout || process.stdout;
+  if (!input?.isTTY || !output?.isTTY) {
+    return {
+      interactive: false,
+      ask: async () => '',
+      close: async () => {},
+    };
+  }
+  const rl = readline.createInterface({ input, output });
+  return {
+    interactive: true,
+    ask: async (prompt) => trim(await rl.question(prompt)),
+    close: async () => {
+      rl.close();
+    },
+  };
+}
+
+function runChildCapture(spawnFn, command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      ...options,
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (chunk) => {
+      stdout += Buffer.from(chunk).toString('utf8');
+    });
+    child.stderr?.on('data', (chunk) => {
+      stderr += Buffer.from(chunk).toString('utf8');
+    });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`${command} exited via signal ${signal}`));
+        return;
+      }
+      resolve({ code: Number(code || 0), stdout, stderr });
+    });
+  });
+}
+
+function runChildInherit(spawnFn, command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(command, args, {
+      stdio: 'inherit',
+      ...options,
+    });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`${command} exited via signal ${signal}`));
+        return;
+      }
+      resolve(Number(code || 0));
+    });
+  });
+}
+
+function resolveControlLayout({ fsSync, pathModule, processImpl, options }) {
+  return resolveInstalledControlLayout({
+    fsSync,
+    pathModule,
+    env: processImpl.env,
+    profile: options.layoutProfile,
+    appDir: options.appDir,
+    controlEnvFile: options.controlEnvFile,
+    controlUser: options.controlUser,
+    codexHomeDir: options.codexHomeDir,
+  });
+}
+
+async function readJsonResponse(response) {
+  const text = await response.text();
+  try {
+    return text ? JSON.parse(text) : {};
+  } catch {
+    return {};
+  }
+}
+
+function buildClaimFailureMessage(error, claimUrl) {
+  const lines = [trim(error?.message, 'license claim failed')];
+  lines.push('');
+  lines.push('The node remains installed but activation is still pending.');
+  lines.push(`Retry with: codexbot activate --license-key '<your-license-key>' --license-claim-url '${claimUrl}'`);
+  lines.push('Or complete activation manually after obtaining an activation package.');
+  return lines.join('\n');
+}
+
+export function createNpmDistributionActivationService(deps = {}) {
+  const fsPromises = deps.fsPromises || fs;
+  const fsSync = deps.fsSync || fsSyncDefault;
+  const osModule = deps.osModule || os;
+  const pathModule = deps.pathModule || path;
+  const spawnFn = deps.spawnFn || spawn;
+  const processImpl = deps.processImpl || process;
+  const fetchFn = deps.fetchFn || fetch;
+  const logger = deps.logger || console;
+  const promptFactory = deps.promptFactory || createPrompter;
+
+  async function resolveLicenseKey(options = {}) {
+    const explicit = trim(options.licenseKey);
+    if (explicit) return explicit;
+    const prompter = promptFactory({
+      stdin: processImpl.stdin,
+      stdout: processImpl.stdout,
+    });
+    try {
+      if (Boolean(options.nonInteractive) || !prompter.interactive) {
+        throw new Error('license key is required');
+      }
+      const entered = trim(await prompter.ask('License key: '));
+      if (!entered) throw new Error('license key is required');
+      return entered;
+    } finally {
+      await prompter.close().catch(() => {});
+    }
+  }
+
+  async function readInstalledNodeIdentity(layout, options = {}) {
+    const scriptPath = pathModule.join(layout.appDir, 'scripts', 'codexbot_node_identity.sh');
+    const isRoot = typeof processImpl.getuid === 'function' ? processImpl.getuid() === 0 : false;
+    const command = isRoot ? 'bash' : 'sudo';
+    const commandArgs = isRoot
+      ? [scriptPath, '--control-env-file', layout.controlEnvFile]
+      : ['bash', scriptPath, '--control-env-file', layout.controlEnvFile];
+    const result = await runChildCapture(spawnFn, command, commandArgs);
+    if (result.code !== 0) {
+      throw new Error(trim(result.stderr || result.stdout, 'failed to read node identity'));
+    }
+    let payload = {};
+    try {
+      payload = JSON.parse(result.stdout);
+    } catch {
+      throw new Error('node identity output is not valid JSON');
+    }
+    return payload;
+  }
+
+  async function fetchActivationPackage({ claimUrl, licenseKey, identity }) {
+    const response = await fetchFn(claimUrl, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'user-agent': 'codexbot-npm-cli/1.0',
+      },
+      body: JSON.stringify({
+        licenseKey,
+        fingerprint: trim(identity?.machineFingerprint),
+        node: {
+          id: trim(identity?.nodeId),
+          ...(identity?.payload && typeof identity.payload === 'object' && !Array.isArray(identity.payload) ? identity.payload : {}),
+        },
+      }),
+    });
+    const payload = await readJsonResponse(response);
+    if (!response.ok) {
+      const err = new Error(trim(payload?.error?.message || payload?.message, `license claim http ${response.status}`));
+      err.code = trim(payload?.error?.code || payload?.code, `HTTP_${response.status}`);
+      err.statusCode = response.status;
+      err.payload = payload;
+      throw err;
+    }
+    return payload;
+  }
+
+  async function writeActivationPackage(tempDir, activation = {}) {
+    const licenseFile = pathModule.join(tempDir, 'license.json');
+    const licensePublicKeyFile = pathModule.join(tempDir, 'license-public.pem');
+    const licenseServerPublicKeyFile = pathModule.join(tempDir, 'license-server-public.pem');
+    await fsPromises.writeFile(licenseFile, `${JSON.stringify(activation.license || {}, null, 2)}\n`, 'utf8');
+    await fsPromises.writeFile(licensePublicKeyFile, `${trim(activation.licensePublicKey)}\n`, 'utf8');
+    await fsPromises.writeFile(licenseServerPublicKeyFile, `${trim(activation.licenseServerPublicKey)}\n`, 'utf8');
+    return {
+      licenseFile,
+      licensePublicKeyFile,
+      licenseServerPublicKeyFile,
+    };
+  }
+
+  async function runLocalActivationScript(layout, files) {
+    const scriptPath = pathModule.join(layout.appDir, 'scripts', 'codexbot_activate.sh');
+    const isRoot = typeof processImpl.getuid === 'function' ? processImpl.getuid() === 0 : false;
+    const baseArgs = [
+      scriptPath,
+      '--control-env-file', layout.controlEnvFile,
+      '--license-file', files.licenseFile,
+      '--license-public-key-file', files.licensePublicKeyFile,
+      '--license-server-public-key-file', files.licenseServerPublicKeyFile,
+      '--start',
+    ];
+    const command = isRoot ? 'bash' : 'sudo';
+    const commandArgs = isRoot ? baseArgs : ['bash', ...baseArgs];
+    return runChildInherit(spawnFn, command, commandArgs);
+  }
+
+  async function claimAndActivate(options = {}) {
+    const defaults = getDefaultDistributionConfig(processImpl.env);
+    const licenseKey = await resolveLicenseKey(options);
+    const claimUrl = buildInstallLicenseClaimUrl({
+      installBaseUrl: options.installBaseUrl || defaults.installBaseUrl,
+      claimUrl: options.licenseClaimUrl || defaults.licenseClaimUrl,
+      allowHttp: Boolean(options.allowHttp),
+    });
+    const layout = resolveControlLayout({
+      fsSync,
+      pathModule,
+      processImpl,
+      options,
+    });
+    const tempDir = await fsPromises.mkdtemp(pathModule.join(osModule.tmpdir(), 'codexbot-activation-'));
+    try {
+      logger.log('==> Read node identity');
+      const identity = await readInstalledNodeIdentity(layout, options);
+      logger.log(`==> Claim activation package from ${claimUrl}`);
+      const claim = await fetchActivationPackage({ claimUrl, licenseKey, identity });
+      const activation = claim?.activation || {};
+      if (!activation.license || !trim(activation.licensePublicKey) || !trim(activation.licenseServerPublicKey)) {
+        throw new Error('claim response is missing activation package files');
+      }
+      const files = await writeActivationPackage(tempDir, activation);
+      logger.log('==> Activate installed node');
+      const exitCode = await runLocalActivationScript(layout, files);
+      if (exitCode !== 0) {
+        throw new Error(`activation script exited with code ${exitCode}`);
+      }
+      return {
+        ok: true,
+        claim,
+      };
+    } catch (error) {
+      const wrapped = new Error(buildClaimFailureMessage(error, claimUrl));
+      wrapped.cause = error;
+      throw wrapped;
+    } finally {
+      await fsPromises.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+  }
+
+  return {
+    claimAndActivate,
+  };
+}

package/src/args_service.mjs

@@ -30,6 +30,8 @@ function parseBootstrapOptions(argv = []) {
     wecomTencentDocsApiKey: '',
     openAiApiKey: '',
     deferLicenseActivation: false,
+    licenseKey: '',
+    licenseClaimUrl: '',
     licenseFile: '',
     licensePublicKeyFile: '',
     licenseServerPublicKeyFile: '',
@@ -130,6 +132,16 @@ function parseBootstrapOptions(argv = []) {
       options.deferLicenseActivation = true;
       continue;
     }
+    if (token === '--license-key') {
+      options.licenseKey = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--license-claim-url') {
+      options.licenseClaimUrl = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
     if (token === '--license-file') {
       options.licenseFile = readOptionValue(argv, i, token);
       i += 1;
@@ -171,7 +183,7 @@ function parseBootstrapOptions(argv = []) {
   return options;
 }
 
-function parseAuthOptions(argv = []) {
+function parseLayoutOptions(argv = []) {
   const options = {
     layoutProfile: '',
     appDir: '',
@@ -212,6 +224,71 @@ function parseAuthOptions(argv = []) {
   return options;
 }
 
+function parseActivationOptions(argv = []) {
+  const options = {
+    ...parseLayoutOptions([]),
+    installBaseUrl: '',
+    licenseClaimUrl: '',
+    allowHttp: false,
+    nonInteractive: false,
+    licenseKey: '',
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = trim(argv[i]);
+    if (!token) continue;
+    if (token === '--license-key') {
+      options.licenseKey = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--install-base-url') {
+      options.installBaseUrl = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--license-claim-url') {
+      options.licenseClaimUrl = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--allow-http') {
+      options.allowHttp = true;
+      continue;
+    }
+    if (token === '--non-interactive' || token === '--no-prompt') {
+      options.nonInteractive = true;
+      continue;
+    }
+    if (token === '--layout-profile') {
+      options.layoutProfile = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--app-dir') {
+      options.appDir = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--control-env-file') {
+      options.controlEnvFile = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--control-user') {
+      options.controlUser = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--codex-home-dir') {
+      options.codexHomeDir = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    throw new Error(`unknown activate arg: ${token}`);
+  }
+  return options;
+}
+
 export function parseCliArgs(argv = []) {
   const args = Array.isArray(argv) ? argv.map((item) => String(item || '')) : [];
   const command = trim(args[0]).toLowerCase();
@@ -222,7 +299,7 @@ export function parseCliArgs(argv = []) {
     return { action: 'version' };
   }
   if (command === 'doctor') {
-    return { action: 'doctor', options: parseAuthOptions(args.slice(1)) };
+    return { action: 'doctor', options: parseLayoutOptions(args.slice(1)) };
   }
   if (command === 'install') {
     return { action: 'install', options: parseBootstrapOptions(args.slice(1)) };
@@ -230,12 +307,15 @@ export function parseCliArgs(argv = []) {
   if (command === 'upgrade') {
     return { action: 'upgrade', options: parseBootstrapOptions(args.slice(1)) };
   }
+  if (command === 'activate') {
+    return { action: 'activate', options: parseActivationOptions(args.slice(1)) };
+  }
   if (command === 'auth') {
     const sub = trim(args[1]).toLowerCase() || 'status';
     if (!['status', 'login', 'login-link', 'logout'].includes(sub)) {
       throw new Error(`unknown auth subcommand: ${sub}`);
     }
-    return { action: 'auth', mode: sub, options: parseAuthOptions(args.slice(2)) };
+    return { action: 'auth', mode: sub, options: parseLayoutOptions(args.slice(2)) };
   }
   throw new Error(`unknown command: ${command}`);
 }

package/src/config_service.mjs

@@ -33,9 +33,20 @@ export function getDefaultDistributionConfig(env = process.env) {
     updateBaseUrl: normalizeBaseUrl(env.CODEXBOT_UPDATE_BASE_URL, DEFAULT_UPDATE_BASE_URL),
     channel: normalizeChannel(env.CODEXBOT_INSTALL_CHANNEL, DEFAULT_CHANNEL),
     authToken: trim(env.CODEXBOT_UPDATE_TOKEN || env.CODEX_REMOTE_UPDATE_AUTH_TOKEN, ''),
+    licenseClaimUrl: trim(env.CODEXBOT_LICENSE_CLAIM_URL, ''),
   };
 }
 
+export function buildInstallLicenseClaimUrl({
+  installBaseUrl = DEFAULT_INSTALL_BASE_URL,
+  claimUrl = '',
+  allowHttp = false,
+} = {}) {
+  const resolvedInstallBaseUrl = normalizeBaseUrl(installBaseUrl, DEFAULT_INSTALL_BASE_URL);
+  const resolvedClaimUrl = trim(claimUrl) || `${resolvedInstallBaseUrl}/v1/install/license/claim`;
+  return assertHttps(resolvedClaimUrl, { allowHttp, label: 'license claim url' });
+}
+
 export function buildPublicInstallUrls({
   installBaseUrl = DEFAULT_INSTALL_BASE_URL,
   updateBaseUrl = DEFAULT_UPDATE_BASE_URL,

package/src/entrypoint.mjs

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parseCliArgs } from './args_service.mjs';
+import { createNpmDistributionActivationService } from './activation_service.mjs';
 import { createNpmDistributionInstallService } from './install_service.mjs';
 import { createNpmDistributionAuthService } from './auth_service.mjs';
 
@@ -16,6 +17,7 @@ function renderUsage() {
     'Usage:',
     '  codexbot install [bootstrap options] [install-remote flags...]',
     '  codexbot upgrade [bootstrap options] [install-remote flags...]',
+    '  codexbot activate [activation options]',
     '  codexbot auth status|login|login-link|logout [layout overrides]',
     '  codexbot doctor [layout overrides]',
     '  codexbot version',
@@ -32,6 +34,8 @@ function renderUsage() {
     '  --wecom-secret <secret>',
     '  --wecom-tencent-docs-api-key <apiKey>',
     '  --openai-api-key <key>',
+    '  --license-key <key>',
+    '  install will auto-claim and activate when a license key is provided.',
     '  --license-file </path/to/license.json>',
     '  --license-public-key-file </path/to/license-public.pem>',
     '  --license-server-public-key-file </path/to/license-server-public.pem>',
@@ -45,6 +49,13 @@ function renderUsage() {
     '  --token <protected update server token>',
     '  --allow-http',
     '',
+    'Activation options:',
+    '  --license-key <key>',
+    '  --install-base-url <https://codexbotinstall.example.com>',
+    '  --license-claim-url <https://codexbotinstall.example.com/v1/install/license/claim>',
+    '  --non-interactive',
+    '  --allow-http',
+    '',
     'Layout overrides:',
     '  --layout-profile <split|legacy>',
     '  --app-dir <path>',
@@ -57,6 +68,7 @@ function renderUsage() {
 export async function runCodexbotCli(argv = [], deps = {}) {
   const logger = deps.logger || console;
   const installService = deps.installService || createNpmDistributionInstallService({ logger });
+  const activationService = deps.activationService || createNpmDistributionActivationService({ logger });
   const authService = deps.authService || createNpmDistributionAuthService({ logger });
   const cli = parseCliArgs(argv);
   if (cli.action === 'help') {
@@ -86,6 +98,10 @@ export async function runCodexbotCli(argv = [], deps = {}) {
   if (cli.action === 'upgrade') {
     return installService.runUpgradeCommand(cli.options || {});
   }
+  if (cli.action === 'activate') {
+    await activationService.claimAndActivate(cli.options || {});
+    return 0;
+  }
   if (cli.action === 'auth') {
     return authService.runAuthCommand(cli.mode, cli.options || {});
   }

package/src/install_seed_service.mjs

@@ -283,6 +283,7 @@ export function createNpmDistributionInstallSeedService(deps = {}) {
         seedLicenseFile: '',
         seedLicensePublicKeyFile: '',
         seedLicenseServerPublicKeyFile: '',
+        licenseKey: trim(options.licenseKey),
         deferLicenseActivation: Boolean(options.deferLicenseActivation),
         summary: {
           connector: 'skip',
@@ -294,6 +295,9 @@ export function createNpmDistributionInstallSeedService(deps = {}) {
       };
 
       if (explicitSeedFiles) {
+        if (result.licenseKey) {
+          throw new Error('license key cannot be combined with explicit license seed files');
+        }
         result.seedLicenseFile = trim(options.licenseFile);
         result.seedLicensePublicKeyFile = trim(options.licensePublicKeyFile);
         result.seedLicenseServerPublicKeyFile = trim(options.licenseServerPublicKeyFile);
@@ -373,22 +377,24 @@ export function createNpmDistributionInstallSeedService(deps = {}) {
         result.summary.connectorSeeded = true;
       }
 
+      let licenseKey = result.licenseKey;
       let licenseFile = trim(options.licenseFile);
       let licensePublicKeyFile = trim(options.licensePublicKeyFile);
       let licenseServerPublicKeyFile = trim(options.licenseServerPublicKeyFile);
-      if (!result.deferLicenseActivation && !licenseFile && !licensePublicKeyFile && !licenseServerPublicKeyFile && !nonInteractive) {
-        const provideLicense = normalizeYesNo(await prompter.ask('Provide license materials now? [y/N]: '), false);
-        if (provideLicense) {
-          licenseFile = await prompter.ask('Path to license.json: ');
-          licensePublicKeyFile = await prompter.ask('Path to license-public.pem: ');
-          licenseServerPublicKeyFile = await prompter.ask('Path to license-server-public.pem: ');
-        } else {
-          result.deferLicenseActivation = true;
-        }
-      } else if (!licenseFile && !licensePublicKeyFile && !licenseServerPublicKeyFile) {
+      if (licenseKey && (licenseFile || licensePublicKeyFile || licenseServerPublicKeyFile)) {
+        throw new Error('license key cannot be combined with direct license file inputs');
+      }
+      if (!licenseKey && !licenseFile && !licensePublicKeyFile && !licenseServerPublicKeyFile && !nonInteractive) {
+        licenseKey = trim(await prompter.ask('License key (optional, blank to skip and activate later): '));
+      }
+      if (!licenseKey && !licenseFile && !licensePublicKeyFile && !licenseServerPublicKeyFile) {
         result.deferLicenseActivation = true;
       }
 
+      if (licenseKey) {
+        result.licenseKey = licenseKey;
+        result.deferLicenseActivation = true;
+      }
       const licenseProvided = Boolean(licenseFile || licensePublicKeyFile || licenseServerPublicKeyFile);
       if (licenseProvided) {
         result.seedLicenseFile = await ensureReadableFile(fsPromises, licenseFile, 'license file');

package/src/install_service.mjs

@@ -7,6 +7,7 @@ import {
   buildRemoteInstallUrls,
   getDefaultDistributionConfig,
 } from './config_service.mjs';
+import { createNpmDistributionActivationService } from './activation_service.mjs';
 import { createNpmDistributionInstallSeedService } from './install_seed_service.mjs';
 
 function trim(value, fallback = '') {
@@ -116,6 +117,14 @@ export function createNpmDistributionInstallService(deps = {}) {
     processImpl,
     logger,
   });
+  const activationService = deps.activationService || createNpmDistributionActivationService({
+    fsPromises,
+    pathModule,
+    spawnFn,
+    processImpl,
+    fetchFn,
+    logger,
+  });
 
   async function runRemoteInstall({
     mode,
@@ -151,6 +160,7 @@ export function createNpmDistributionInstallService(deps = {}) {
       effectiveOptions.licenseFile = trim(installSeed.seedLicenseFile, effectiveOptions.licenseFile);
       effectiveOptions.licensePublicKeyFile = trim(installSeed.seedLicensePublicKeyFile, effectiveOptions.licensePublicKeyFile);
       effectiveOptions.licenseServerPublicKeyFile = trim(installSeed.seedLicenseServerPublicKeyFile, effectiveOptions.licenseServerPublicKeyFile);
+      effectiveOptions.licenseKey = trim(installSeed.licenseKey, effectiveOptions.licenseKey);
       effectiveOptions.deferLicenseActivation = Boolean(installSeed.deferLicenseActivation || effectiveOptions.deferLicenseActivation);
     }
     const authToken = trim(effectiveOptions.token, defaults.authToken);
@@ -211,7 +221,17 @@ export function createNpmDistributionInstallService(deps = {}) {
       const isRoot = typeof processImpl.getuid === 'function' ? processImpl.getuid() === 0 : false;
       const command = isRoot ? 'bash' : 'sudo';
       const commandArgs = isRoot ? args : ['bash', ...args];
-      return await runChild(spawnFn, command, commandArgs);
+      const exitCode = await runChild(spawnFn, command, commandArgs);
+      if (distributionMode === 'install' && exitCode === 0 && trim(effectiveOptions.licenseKey)) {
+        await activationService.claimAndActivate({
+          licenseKey: effectiveOptions.licenseKey,
+          installBaseUrl: urls.installBaseUrl,
+          licenseClaimUrl: effectiveOptions.licenseClaimUrl,
+          allowHttp: Boolean(effectiveOptions.allowHttp),
+          nonInteractive: true,
+        });
+      }
+      return exitCode;
     } finally {
       if (installSeed?.cleanup) {
         await installSeed.cleanup().catch(() => {});