npm - @openchamber/web - Versions diffs - 1.2.6 → 1.2.8 - Mend

@openchamber/web 1.2.6 → 1.2.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/README.md +10 -1
package/bin/cli.js +274 -4
package/dist/assets/{ToolOutputDialog-C4z4D1To.js → ToolOutputDialog-BYb4g1c7.js} +2 -2
package/dist/assets/{index-Ch3--lhG.js → index--hIzFLog.js} +2 -2
package/dist/assets/index-BSN-fGG5.css +1 -0
package/dist/assets/main-DI52tBPC.js +118 -0
package/dist/assets/{vendor-.pnpm-B7ko08Tb.js → vendor-.pnpm-Buk6Khtx.js} +305 -305
package/dist/index.html +3 -3
package/package.json +1 -1
package/server/index.js +106 -0
package/server/lib/package-manager.js +255 -0
package/dist/assets/index-DR5HBLaO.css +0 -1
package/dist/assets/main-DwC7ZQj_.js +0 -118

package/dist/index.html CHANGED Viewed

@@ -157,10 +157,10 @@
         pointer-events: none;
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-Ch3--lhG.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/vendor-.pnpm-B7ko08Tb.js">
+    <script type="module" crossorigin src="/assets/index--hIzFLog.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/vendor-.pnpm-Buk6Khtx.js">
     <link rel="stylesheet" crossorigin href="/assets/vendor--B3aGWKBE.css">
-    <link rel="stylesheet" crossorigin href="/assets/index-DR5HBLaO.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BSN-fGG5.css">
   </head>
   <body class="h-full bg-background text-foreground">
     <div id="root" class="h-full">

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@openchamber/web",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "private": false,
   "type": "module",
   "main": "./server/index.js",

package/server/index.js CHANGED Viewed

@@ -1605,6 +1605,112 @@ async function main(options = {}) {
   app.use('/api', (req, res, next) => uiAuthController.requireAuth(req, res, next));
+  app.get('/api/openchamber/update-check', async (_req, res) => {
+    try {
+      const { checkForUpdates } = await import('./lib/package-manager.js');
+      const updateInfo = await checkForUpdates();
+      res.json(updateInfo);
+    } catch (error) {
+      console.error('Failed to check for updates:', error);
+      res.status(500).json({
+        available: false,
+        error: error instanceof Error ? error.message : 'Failed to check for updates',
+      });
+    }
+  });
+  app.post('/api/openchamber/update-install', async (_req, res) => {
+    try {
+      const { spawn: spawnChild } = await import('child_process');
+      const {
+        checkForUpdates,
+        getUpdateCommand,
+        detectPackageManager,
+      } = await import('./lib/package-manager.js');
+      // Verify update is available
+      const updateInfo = await checkForUpdates();
+      if (!updateInfo.available) {
+        return res.status(400).json({ error: 'No update available' });
+      }
+      const pm = detectPackageManager();
+      const updateCmd = getUpdateCommand(pm);
+      // Get current server port for restart
+      const currentPort = server.address()?.port || 3000;
+      // Try to read stored instance options for restart
+      const tmpDir = os.tmpdir();
+      const instanceFilePath = path.join(tmpDir, `openchamber-${currentPort}.json`);
+      let storedOptions = { port: currentPort, daemon: true };
+      try {
+        const content = fs.readFileSync(instanceFilePath, 'utf8');
+        storedOptions = JSON.parse(content);
+      } catch {
+        // Use defaults
+      }
+      // Build restart command with stored options
+      let restartCmd = `openchamber serve --port ${storedOptions.port} --daemon`;
+      if (storedOptions.uiPassword) {
+        // Escape password for shell
+        const escapedPw = storedOptions.uiPassword.replace(/'/g, "'\\''");
+        restartCmd += ` --ui-password '${escapedPw}'`;
+      }
+      // Respond immediately - update will happen after response
+      res.json({
+        success: true,
+        message: 'Update starting, server will restart shortly',
+        version: updateInfo.version,
+        packageManager: pm,
+      });
+      // Give time for response to be sent
+      setTimeout(() => {
+        console.log(`\nInstalling update using ${pm}...`);
+        console.log(`Running: ${updateCmd}`);
+        // Create a script that will:
+        // 1. Wait for current process to exit
+        // 2. Run the update
+        // 3. Restart the server with original options
+        const script = `
+          sleep 2
+          ${updateCmd}
+          if [ $? -eq 0 ]; then
+            echo "Update successful, restarting OpenChamber..."
+            ${restartCmd}
+          else
+            echo "Update failed"
+            exit 1
+          fi
+        `;
+        // Spawn detached shell to run update after we exit
+        const child = spawnChild('sh', ['-c', script], {
+          detached: true,
+          stdio: 'ignore',
+          env: process.env,
+        });
+        child.unref();
+        console.log('Update process spawned, shutting down server...');
+        // Give child process time to start, then exit
+        setTimeout(() => {
+          process.exit(0);
+        }, 500);
+      }, 500);
+    } catch (error) {
+      console.error('Failed to install update:', error);
+      res.status(500).json({
+        error: error instanceof Error ? error.message : 'Failed to install update',
+      });
+    }
+  });
   app.get('/api/openchamber/models-metadata', async (req, res) => {
     const now = Date.now();

package/server/lib/package-manager.js ADDED Viewed

@@ -0,0 +1,255 @@
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_NAME = '@openchamber/web';
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}`;
+const CHANGELOG_URL = 'https://raw.githubusercontent.com/btriapitsyn/openchamber/main/CHANGELOG.md';
+/**
+ * Detect which package manager was used to install this package.
+ * Strategy:
+ * 1. Check npm_config_user_agent (set during npm/pnpm/yarn/bun install)
+ * 2. Check npm_execpath for PM binary path
+ * 3. Analyze package location path for PM-specific patterns
+ * 4. Fall back to npm
+ */
+export function detectPackageManager() {
+  // Strategy 1: Check user agent (most reliable during install)
+  const userAgent = process.env.npm_config_user_agent || '';
+  if (userAgent.startsWith('pnpm')) return 'pnpm';
+  if (userAgent.startsWith('yarn')) return 'yarn';
+  if (userAgent.startsWith('bun')) return 'bun';
+  if (userAgent.startsWith('npm')) return 'npm';
+  // Strategy 2: Check execpath
+  const execPath = process.env.npm_execpath || '';
+  if (execPath.includes('pnpm')) return 'pnpm';
+  if (execPath.includes('yarn')) return 'yarn';
+  if (execPath.includes('bun')) return 'bun';
+  // Strategy 3: Analyze package location for PM-specific patterns
+  try {
+    const pkgPath = path.resolve(__dirname, '..', '..');
+    if (pkgPath.includes('.pnpm')) return 'pnpm';
+    if (pkgPath.includes('/.yarn/') || pkgPath.includes('\\.yarn\\')) return 'yarn';
+    if (pkgPath.includes('/.bun/') || pkgPath.includes('\\.bun\\')) return 'bun';
+  } catch {
+    // Ignore path resolution errors
+  }
+  // Strategy 4: Check which PM binaries are available and preferred
+  const pmChecks = [
+    { name: 'pnpm', check: () => isCommandAvailable('pnpm') },
+    { name: 'yarn', check: () => isCommandAvailable('yarn') },
+    { name: 'bun', check: () => isCommandAvailable('bun') },
+  ];
+  for (const { name, check } of pmChecks) {
+    if (check()) {
+      // Verify this PM actually has the package installed globally
+      if (isPackageInstalledWith(name)) {
+        return name;
+      }
+    }
+  }
+  return 'npm';
+}
+function isCommandAvailable(command) {
+  try {
+    const result = spawnSync(command, ['--version'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 5000,
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function isPackageInstalledWith(pm) {
+  try {
+    let args;
+    switch (pm) {
+      case 'pnpm':
+        args = ['list', '-g', '--depth=0', PACKAGE_NAME];
+        break;
+      case 'yarn':
+        args = ['global', 'list', '--depth=0'];
+        break;
+      case 'bun':
+        args = ['pm', 'ls', '-g'];
+        break;
+      default:
+        args = ['list', '-g', '--depth=0', PACKAGE_NAME];
+    }
+    const result = spawnSync(pm, args, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 10000,
+    });
+    if (result.status !== 0) return false;
+    return result.stdout.includes(PACKAGE_NAME) || result.stdout.includes('openchamber');
+  } catch {
+    return false;
+  }
+}
+/**
+ * Get the update command for the detected package manager
+ */
+export function getUpdateCommand(pm = detectPackageManager()) {
+  switch (pm) {
+    case 'pnpm':
+      return `pnpm add -g ${PACKAGE_NAME}@latest`;
+    case 'yarn':
+      return `yarn global add ${PACKAGE_NAME}@latest`;
+    case 'bun':
+      return `bun add -g ${PACKAGE_NAME}@latest`;
+    default:
+      return `npm install -g ${PACKAGE_NAME}@latest`;
+  }
+}
+/**
+ * Get current installed version from package.json
+ */
+export function getCurrentVersion() {
+  try {
+    const pkgPath = path.resolve(__dirname, '..', '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+/**
+ * Fetch latest version from npm registry
+ */
+export async function getLatestVersion() {
+  try {
+    const response = await fetch(NPM_REGISTRY_URL, {
+      headers: { Accept: 'application/json' },
+      signal: AbortSignal.timeout(10000),
+    });
+    if (!response.ok) {
+      throw new Error(`Registry responded with ${response.status}`);
+    }
+    const data = await response.json();
+    return data['dist-tags']?.latest || null;
+  } catch (error) {
+    console.warn('Failed to fetch latest version from npm:', error.message);
+    return null;
+  }
+}
+/**
+ * Parse semver version to numeric for comparison
+ */
+function parseVersion(version) {
+  const parts = version.replace(/^v/, '').split('.').map(Number);
+  return (parts[0] || 0) * 10000 + (parts[1] || 0) * 100 + (parts[2] || 0);
+}
+/**
+ * Fetch changelog notes between versions
+ */
+export async function fetchChangelogNotes(fromVersion, toVersion) {
+  try {
+    const response = await fetch(CHANGELOG_URL, {
+      signal: AbortSignal.timeout(10000),
+    });
+    if (!response.ok) return undefined;
+    const changelog = await response.text();
+    const sections = changelog.split(/^## /m).slice(1);
+    const fromNum = parseVersion(fromVersion);
+    const toNum = parseVersion(toVersion);
+    const relevantSections = sections.filter((section) => {
+      const match = section.match(/^\[(\d+\.\d+\.\d+)\]/);
+      if (!match) return false;
+      const ver = parseVersion(match[1]);
+      return ver > fromNum && ver <= toNum;
+    });
+    if (relevantSections.length === 0) return undefined;
+    return relevantSections
+      .map((s) => '## ' + s.trim())
+      .join('\n\n');
+  } catch {
+    return undefined;
+  }
+}
+/**
+ * Check for updates and return update info
+ */
+export async function checkForUpdates() {
+  const currentVersion = getCurrentVersion();
+  const latestVersion = await getLatestVersion();
+  if (!latestVersion || currentVersion === 'unknown') {
+    return {
+      available: false,
+      currentVersion,
+      error: 'Unable to determine versions',
+    };
+  }
+  const currentNum = parseVersion(currentVersion);
+  const latestNum = parseVersion(latestVersion);
+  const available = latestNum > currentNum;
+  const pm = detectPackageManager();
+  let changelog;
+  if (available) {
+    changelog = await fetchChangelogNotes(currentVersion, latestVersion);
+  }
+  return {
+    available,
+    version: latestVersion,
+    currentVersion,
+    body: changelog,
+    packageManager: pm,
+    // Show our CLI command, not raw package manager command
+    updateCommand: 'openchamber update',
+  };
+}
+/**
+ * Execute the update (used by CLI)
+ */
+export function executeUpdate(pm = detectPackageManager()) {
+  const command = getUpdateCommand(pm);
+  console.log(`Updating ${PACKAGE_NAME} using ${pm}...`);
+  console.log(`Running: ${command}`);
+  const [cmd, ...args] = command.split(' ');
+  const result = spawnSync(cmd, args, {
+    stdio: 'inherit',
+    shell: true,
+  });
+  return {
+    success: result.status === 0,
+    exitCode: result.status,
+  };
+}