@afffun/codexbot 1.0.96 → 1.0.98

package/package.json

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

package/src/auth_service.mjs

@@ -42,25 +42,46 @@ function mapAuthModeToCodexArgs(mode) {
 function buildProjectionScript(layout) {
   const controlDir = trim(layout.codexHomeDir);
   const agentHomeDir = trim(layout.agentHomeDir);
+  const agentUser = trim(layout.agentUser);
+  const agentGroup = trim(layout.agentGroup);
   if (!controlDir || !agentHomeDir) return '';
   const agentDir = path.join(agentHomeDir, '.codex');
   const lines = [
     'set -euo pipefail',
     `control_dir=${JSON.stringify(controlDir)}`,
+    `agent_home_dir=${JSON.stringify(agentHomeDir)}`,
     `agent_dir=${JSON.stringify(agentDir)}`,
-    'if [[ -d "$agent_dir" ]]; then',
-    '  :',
-    'else',
+    `agent_user=${JSON.stringify(agentUser)}`,
+    `agent_group=${JSON.stringify(agentGroup)}`,
+    'parent_gid="$(stat -c \'%g\' "$agent_home_dir" 2>/dev/null || true)"',
+    'if [[ ! -d "$agent_dir" ]]; then',
     '  mkdir -p "$agent_dir"',
     'fi',
+    'if [[ "$(id -u)" == "0" && -n "$agent_user" && -n "$agent_group" ]]; then',
+    '  chown "$agent_user:$agent_group" "$agent_dir" 2>/dev/null || true',
+    'elif [[ -n "$agent_group" ]]; then',
+    '  chgrp "$agent_group" "$agent_dir" 2>/dev/null || true',
+    'elif [[ -n "$parent_gid" ]]; then',
+    '  chgrp "$parent_gid" "$agent_dir" 2>/dev/null || true',
+    'fi',
+    'chmod 2770 "$agent_dir" 2>/dev/null || chmod 0770 "$agent_dir" 2>/dev/null || true',
   ];
   for (const entry of PROJECTED_FILES) {
     lines.push(`src="$control_dir/${entry.name}"`);
     lines.push(`dst="$agent_dir/${entry.name}"`);
     lines.push('if [[ -f "$src" ]]; then');
     lines.push('  rm -f "$dst"');
-    lines.push('  cp "$src" "$dst"');
-    lines.push(`  chmod ${entry.mode} "$dst"`);
+    lines.push('  if [[ "$(id -u)" == "0" && -n "$agent_user" && -n "$agent_group" ]]; then');
+    lines.push(`    install -D -m ${entry.mode} -o "$agent_user" -g "$agent_group" "$src" "$dst"`);
+    lines.push('  else');
+    lines.push('    cp "$src" "$dst"');
+    lines.push('    if [[ -n "$agent_group" ]]; then');
+    lines.push('      chgrp "$agent_group" "$dst" 2>/dev/null || true');
+    lines.push('    elif [[ -n "$parent_gid" ]]; then');
+    lines.push('      chgrp "$parent_gid" "$dst" 2>/dev/null || true');
+    lines.push('    fi');
+    lines.push(`    chmod ${entry.mode} "$dst"`);
+    lines.push('  fi');
     lines.push('fi');
   }
   return lines.join('\n');
@@ -116,7 +137,15 @@ export function createNpmDistributionAuthService(deps = {}) {
       const projectionScript = buildProjectionScript(layout);
       if (projectionScript) {
         const projectionArgs = ['-u', layout.controlUser, 'env', `CODEX_HOME=${layout.codexHomeDir}`, `PATH=${pathModule.dirname(layout.codexBinPath)}:${processImpl.env.PATH || ''}`, 'bash', '-lc', projectionScript];
-        if (isRoot || !(currentUser && currentUser === layout.controlUser)) {
+        if (isRoot) {
+          await runChild(spawnFn, 'bash', ['-lc', projectionScript], {
+            env: {
+              ...processImpl.env,
+              CODEX_HOME: layout.codexHomeDir,
+              PATH: `${pathModule.dirname(layout.codexBinPath)}:${processImpl.env.PATH || ''}`,
+            },
+          });
+        } else if (!(currentUser && currentUser === layout.controlUser)) {
           await runChild(spawnFn, 'sudo', projectionArgs);
         } else {
           await runChild(spawnFn, 'bash', ['-lc', projectionScript], {

package/src/entrypoint.mjs

@@ -68,7 +68,11 @@ function renderUsage() {
 
 export async function runCodexbotCli(argv = [], deps = {}) {
   const logger = deps.logger || console;
-  const installService = deps.installService || createNpmDistributionInstallService({ logger });
+  const packageVersion = readPackageVersion();
+  const installService = deps.installService || createNpmDistributionInstallService({
+    logger,
+    cliVersion: packageVersion,
+  });
   const activationService = deps.activationService || createNpmDistributionActivationService({ logger });
   const authService = deps.authService || createNpmDistributionAuthService({ logger });
   const cli = parseCliArgs(argv);
@@ -77,7 +81,6 @@ export async function runCodexbotCli(argv = [], deps = {}) {
     return 0;
   }
   if (cli.action === 'version') {
-    const packageVersion = readPackageVersion();
     let installedVersion = '';
     try {
       installedVersion = authService.resolveInstalledVersion({});

package/src/install_service.mjs

@@ -9,6 +9,7 @@ import {
 } from './config_service.mjs';
 import { createNpmDistributionActivationService } from './activation_service.mjs';
 import { createNpmDistributionInstallSeedService } from './install_seed_service.mjs';
+import { compareVersionLike } from './version_compare_service.mjs';
 
 function trim(value, fallback = '') {
   const text = String(value ?? '').trim();
@@ -102,6 +103,55 @@ function runChild(spawnFn, command, args, options = {}) {
   });
 }
 
+async function readJsonResponse(response) {
+  const text = await response.text();
+  try {
+    return text ? JSON.parse(text) : {};
+  } catch {
+    return {};
+  }
+}
+
+function buildMinimumCliVersionMessage({
+  currentCliVersion,
+  minimumCliVersion,
+  manifestVersion,
+  channel,
+} = {}) {
+  const lines = [
+    `This Codexbot CLI is too old for the current public ${channel || 'stable'} install chain.`,
+    `- current CLI: ${trim(currentCliVersion, '(unknown)')}`,
+    `- minimum supported CLI: ${trim(minimumCliVersion, '(unknown)')}`,
+  ];
+  if (trim(manifestVersion)) {
+    lines.push(`- current public runtime: ${manifestVersion}`);
+  }
+  lines.push('');
+  lines.push('Update the npm CLI first, then retry:');
+  lines.push(`- npm install -g @afffun/codexbot@latest`);
+  lines.push(`- codexbot install`);
+  return lines.join('\n');
+}
+
+function assertMinimumCliVersion({
+  cliVersion = '',
+  manifest = null,
+  channel = '',
+} = {}) {
+  const minCliVersion = trim(manifest?.publicInstall?.minimumCliVersion || manifest?.minimumCliVersion);
+  const currentCliVersion = trim(cliVersion);
+  if (!minCliVersion || !currentCliVersion) return;
+  if (compareVersionLike(currentCliVersion, minCliVersion) >= 0) return;
+  const err = new Error(buildMinimumCliVersionMessage({
+    currentCliVersion,
+    minimumCliVersion: minCliVersion,
+    manifestVersion: trim(manifest?.version),
+    channel,
+  }));
+  err.code = 'CLI_VERSION_UNSUPPORTED';
+  throw err;
+}
+
 export function createNpmDistributionInstallService(deps = {}) {
   const fetchFn = deps.fetchFn || fetch;
   const fsPromises = deps.fsPromises || fs;
@@ -110,6 +160,7 @@ export function createNpmDistributionInstallService(deps = {}) {
   const spawnFn = deps.spawnFn || spawn;
   const processImpl = deps.processImpl || process;
   const logger = deps.logger || console;
+  const cliVersion = trim(deps.cliVersion);
   const installSeedService = deps.installSeedService || createNpmDistributionInstallSeedService({
     fsPromises,
     osModule,
@@ -195,6 +246,23 @@ export function createNpmDistributionInstallService(deps = {}) {
         });
         await writeResponseToFile(keyResponse, tempKeyPath, fsPromises);
       }
+      if (distributionMode === 'install') {
+        logger.log('==> Fetch manifest');
+        const manifestResponse = await ensureOkResponse(await fetchFn(urls.manifestUrl, { headers }), {
+          label: 'manifest',
+          installBaseUrl: urls.installBaseUrl,
+          channel: urls.channel,
+          updateBaseUrl: urls.updateBaseUrl,
+          authTokenPresent: Boolean(authToken),
+          distributionMode,
+        });
+        const manifestPayload = await readJsonResponse(manifestResponse);
+        assertMinimumCliVersion({
+          cliVersion,
+          manifest: manifestPayload,
+          channel: urls.channel,
+        });
+      }
 
       const remoteMode = distributionMode === 'install' ? 'auto' : trim(mode, 'auto');
       const args = [

package/src/installed_layout_service.mjs

@@ -7,6 +7,9 @@ const SPLIT_DEFAULTS = Object.freeze({
   appDir: '/usr/local/lib/codexbot',
   controlEnvFile: '/etc/codexbot/control.env',
   controlUser: 'codexbotd',
+  controlGroup: 'codexbotd',
+  agentUser: 'codexagent',
+  agentGroup: 'codexagent',
   codexHomeDir: '/var/lib/codexbot/control/home/.codex',
   agentHomeDir: '/var/lib/codexbot/agent/home',
 });
@@ -16,6 +19,9 @@ const LEGACY_DEFAULTS = Object.freeze({
   appDir: '/home/codexbot/codexbot-telegram',
   controlEnvFile: '/home/codexbot/codexbot-telegram/.env',
   controlUser: 'codexbot',
+  controlGroup: 'codexbot',
+  agentUser: 'codexbot',
+  agentGroup: 'codexbot',
   codexHomeDir: '/home/codexbot/codexbot-home/.codex',
   agentHomeDir: '',
 });
@@ -67,6 +73,9 @@ export function resolveInstalledControlLayout({
   const fileEnv = readEnvFile(fsSync, envFile);
   const resolvedAppDir = pathModule.resolve(trim(appDir || fileEnv.CODEXBOT_APP_DIR || fileEnv.CODEXBOT_SYSTEM_ROOT, defaults.appDir));
   const resolvedControlUser = trim(controlUser || fileEnv.CODEXBOT_CONTROL_USER, defaults.controlUser);
+  const resolvedControlGroup = trim(fileEnv.CODEXBOT_CONTROL_GROUP, defaults.controlGroup);
+  const resolvedAgentUser = trim(fileEnv.CODEXBOT_AGENT_USER, defaults.agentUser);
+  const resolvedAgentGroup = trim(fileEnv.CODEXBOT_AGENT_GROUP, defaults.agentGroup);
   const resolvedCodexHomeDir = pathModule.resolve(trim(
     codexHomeDir
       || fileEnv.CODEXBOT_CONTROL_CODEX_HOME_DIR
@@ -83,6 +92,9 @@ export function resolveInstalledControlLayout({
     appDir: resolvedAppDir,
     controlEnvFile: envFile,
     controlUser: resolvedControlUser,
+    controlGroup: resolvedControlGroup,
+    agentUser: resolvedAgentUser,
+    agentGroup: resolvedAgentGroup,
     codexHomeDir: resolvedCodexHomeDir,
     agentHomeDir: resolvedAgentHomeDir,
     codexBinPath,

package/src/version_compare_service.mjs

@@ -0,0 +1,31 @@
+function trimText(value) {
+  return String(value || '').trim();
+}
+
+function tokenizeVersionLike(value) {
+  return trimText(value)
+    .split(/[.\-+_]/g)
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((item) => (/^\d+$/.test(item) ? Number.parseInt(item, 10) : item.toLowerCase()));
+}
+
+export function compareVersionLike(a, b) {
+  const left = tokenizeVersionLike(a);
+  const right = tokenizeVersionLike(b);
+  const limit = Math.max(left.length, right.length);
+  for (let index = 0; index < limit; index += 1) {
+    const lv = left[index] ?? 0;
+    const rv = right[index] ?? 0;
+    if (typeof lv === 'number' && typeof rv === 'number') {
+      if (lv < rv) return -1;
+      if (lv > rv) return 1;
+      continue;
+    }
+    const ls = String(lv);
+    const rs = String(rv);
+    if (ls < rs) return -1;
+    if (ls > rs) return 1;
+  }
+  return 0;
+}