npm - @openchamber/web - Versions diffs - 1.3.9 → 1.4.0 - Mend

@openchamber/web 1.3.9 → 1.4.0

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 (14) hide show

package/README.md +1 -0
package/bin/cli.js +56 -15
package/dist/assets/{ToolOutputDialog-BrFH3eLi.js → ToolOutputDialog-68nQ6kiw.js} +3 -3
package/dist/assets/index-BK6z1XIy.css +1 -0
package/dist/assets/{index-CqiXpckC.js → index-DbT28rmj.js} +2 -2
package/dist/assets/main-DPWbnEr6.js +122 -0
package/dist/assets/{vendor-.bun-B0k_58z8.js → vendor-.bun-BhxSBVb2.js} +213 -213
package/dist/index.html +3 -3
package/package.json +2 -2
package/server/index.js +51 -11
package/server/lib/cloudflare-tunnel.js +196 -0
package/server/lib/git-service.js +120 -13
package/dist/assets/index-Coco_yFR.css +0 -1
package/dist/assets/main-DpLFDKL6.js +0 -119

package/dist/index.html CHANGED Viewed

@@ -160,10 +160,10 @@
         pointer-events: none;
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-CqiXpckC.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/vendor-.bun-B0k_58z8.js">
+    <script type="module" crossorigin src="/assets/index-DbT28rmj.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/vendor-.bun-BhxSBVb2.js">
     <link rel="stylesheet" crossorigin href="/assets/vendor--swUGvSZA.css">
-    <link rel="stylesheet" crossorigin href="/assets/index-Coco_yFR.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BK6z1XIy.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.3.9",
+  "version": "1.4.0",
   "private": false,
   "type": "module",
   "main": "./server/index.js",
@@ -19,7 +19,7 @@
     "build:watch": "vite build --watch",
     "type-check": "tsc --noEmit",
     "lint": "eslint \"./src/**/*.{ts,tsx}\" --config ../../eslint.config.js",
-    "start": "node server/index.js"
+    "start": "node bin/cli.js serve"
   },
   "dependencies": {
     "@fontsource/ibm-plex-mono": "^5.2.7",

package/server/index.js CHANGED Viewed

@@ -7,6 +7,7 @@ import http from 'http';
 import { fileURLToPath } from 'url';
 import os from 'os';
 import { createUiAuth } from './lib/ui-auth.js';
+import { startCloudflareTunnel, printTunnelWarning, checkCloudflaredAvailable } from './lib/cloudflare-tunnel.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -578,6 +579,7 @@ let isOpenCodeReady = false;
 let openCodeNotReadySince = 0;
 let exitOnShutdown = true;
 let uiAuthController = null;
+let cloudflareTunnelController = null;
 // Sync helper - call after modifying any HMR state variable
 const syncToHmrState = () => {
@@ -713,21 +715,18 @@ function resolveBinaryFromPath(binaryName, searchPath) {
 }
 function getOpencodeSpawnConfig() {
-  const envPath = buildAugmentedPath();
-  const resolvedEnv = { ...process.env, PATH: envPath };
   if (OPENCODE_BINARY_ENV) {
-    const explicit = resolveBinaryFromPath(OPENCODE_BINARY_ENV, envPath);
+    const explicit = resolveBinaryFromPath(OPENCODE_BINARY_ENV, process.env.PATH);
     if (explicit) {
       console.log(`Using OpenCode binary from OPENCODE_BINARY: ${explicit}`);
-      return { command: explicit, env: resolvedEnv };
+      return { command: explicit, env: undefined };
     }
     console.warn(
       `OPENCODE_BINARY path "${OPENCODE_BINARY_ENV}" not found. Falling back to search.`
     );
   }
-  return { command: 'opencode', env: resolvedEnv };
+  return { command: 'opencode', env: undefined };
 }
 const ENV_CONFIGURED_OPENCODE_PORT = (() => {
@@ -1151,7 +1150,8 @@ function parseArgs(argv = process.argv.slice(2)) {
     process.env.OPENCHAMBER_UI_PASSWORD ||
     process.env.OPENCODE_UI_PASSWORD ||
     null;
-  const options = { port: DEFAULT_PORT, uiPassword: envPassword };
+  const envCfTunnel = process.env.OPENCHAMBER_TRY_CF_TUNNEL === 'true';
+  const options = { port: DEFAULT_PORT, uiPassword: envPassword, tryCfTunnel: envCfTunnel };
   const consumeValue = (currentIndex, inlineValue) => {
     if (typeof inlineValue === 'string') {
@@ -1188,6 +1188,11 @@ function parseArgs(argv = process.argv.slice(2)) {
       options.uiPassword = typeof value === 'string' ? value : '';
       continue;
     }
+    if (optionName === 'try-cf-tunnel') {
+      options.tryCfTunnel = true;
+      continue;
+    }
   }
   return options;
@@ -1835,6 +1840,12 @@ async function gracefulShutdown(options = {}) {
     uiAuthController = null;
   }
+  if (cloudflareTunnelController) {
+    console.log('Stopping Cloudflare tunnel...');
+    cloudflareTunnelController.stop();
+    cloudflareTunnelController = null;
+  }
   console.log('Graceful shutdown complete');
   if (exitProcess) {
     process.exit(0);
@@ -1843,7 +1854,9 @@ async function gracefulShutdown(options = {}) {
 async function main(options = {}) {
   const port = Number.isFinite(options.port) && options.port >= 0 ? Math.trunc(options.port) : DEFAULT_PORT;
+  const tryCfTunnel = options.tryCfTunnel === true;
   const attachSignals = options.attachSignals !== false;
+  const onTunnelReady = typeof options.onTunnelReady === 'function' ? options.onTunnelReady : null;
   if (typeof options.exitOnShutdown === 'boolean') {
     exitOnShutdown = options.exitOnShutdown;
   }
@@ -3387,12 +3400,12 @@ async function main(options = {}) {
         return res.status(400).json({ error: 'directory parameter is required' });
       }
-      const { path, branch, createBranch } = req.body;
+      const { path, branch, createBranch, startPoint } = req.body;
       if (!path || !branch) {
         return res.status(400).json({ error: 'path and branch are required' });
       }
-      const result = await addWorktree(directory, path, branch, { createBranch });
+      const result = await addWorktree(directory, path, branch, { createBranch, startPoint });
       res.json(result);
     } catch (error) {
       console.error('Failed to add worktree:', error);
@@ -3599,7 +3612,9 @@ async function main(options = {}) {
           const isSymbolicLink = dirent.isSymbolicLink();
           if (!isDirectory && isSymbolicLink) {
-            try {
+  try {
               const linkStats = await fsPromises.stat(entryPath);
               isDirectory = linkStats.isDirectory();
             } catch {
@@ -4026,6 +4041,7 @@ async function main(options = {}) {
     res.json({ success: true, killedCount });
   });
   try {
     // Check if we can reuse an existing OpenCode process from a previous HMR cycle
     syncFromHmrState();
@@ -4086,13 +4102,35 @@ async function main(options = {}) {
       reject(error);
     };
     server.once('error', onError);
-    server.listen(port, () => {
+    server.listen(port, async () => {
       server.off('error', onError);
       const addressInfo = server.address();
       activePort = typeof addressInfo === 'object' && addressInfo ? addressInfo.port : port;
       console.log(`OpenChamber server running on port ${activePort}`);
       console.log(`Health check: http://localhost:${activePort}/health`);
       console.log(`Web interface: http://localhost:${activePort}`);
+      if (tryCfTunnel) {
+        console.log('\nInitializing Cloudflare Quick Tunnel...');
+        const cfCheck = await checkCloudflaredAvailable();
+        if (cfCheck.available) {
+          try {
+            const originUrl = `http://localhost:${activePort}`;
+            cloudflareTunnelController = await startCloudflareTunnel({ originUrl, port: activePort });
+            printTunnelWarning();
+            if (onTunnelReady) {
+              const tunnelUrl = cloudflareTunnelController.getPublicUrl();
+              if (tunnelUrl) {
+                onTunnelReady(tunnelUrl);
+              }
+            }
+          } catch (error) {
+            console.error(`Failed to start Cloudflare tunnel: ${error.message}`);
+            console.log('Continuing without tunnel...');
+          }
+        }
+      }
       resolve();
     });
   });
@@ -4119,6 +4157,7 @@ async function main(options = {}) {
     httpServer: server,
     getPort: () => activePort,
     getOpenCodePort: () => openCodePort,
+    getTunnelUrl: () => cloudflareTunnelController?.getPublicUrl() ?? null,
     isReady: () => isOpenCodeReady,
     restartOpenCode: () => restartOpenCode(),
     stop: (shutdownOptions = {}) =>
@@ -4133,6 +4172,7 @@ if (isCliExecution) {
   exitOnShutdown = true;
   main({
     port: cliOptions.port,
+    tryCfTunnel: cliOptions.tryCfTunnel,
     attachSignals: true,
     exitOnShutdown: true,
     uiPassword: cliOptions.uiPassword

package/server/lib/cloudflare-tunnel.js ADDED Viewed

@@ -0,0 +1,196 @@
+import { spawn, spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TRY_CF_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+async function searchPathFor(command) {
+  const pathValue = process.env.PATH || '';
+  const segments = pathValue.split(path.delimiter).filter(Boolean);
+  const WINDOWS_EXTENSIONS = process.platform === 'win32'
+    ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+        .split(';')
+        .map((ext) => ext.trim().toLowerCase())
+        .filter(Boolean)
+        .map((ext) => (ext.startsWith('.') ? ext : `.${ext}`))
+    : [''];
+  for (const dir of segments) {
+    for (const ext of WINDOWS_EXTENSIONS) {
+      const fileName = process.platform === 'win32' ? `${command}${ext}` : command;
+      const candidate = path.join(dir, fileName);
+      try {
+        const stats = fs.statSync(candidate);
+        if (stats.isFile()) {
+          if (process.platform !== 'win32') {
+            try {
+              fs.accessSync(candidate, fs.constants.X_OK);
+            } catch {
+              continue;
+            }
+          }
+          return candidate;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+export async function checkCloudflaredAvailable() {
+  const cfPath = await searchPathFor('cloudflared');
+  if (cfPath) {
+    try {
+      const result = spawnSync(cfPath, ['--version'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+      if (result.status === 0) {
+        return { available: true, path: cfPath, version: result.stdout.trim() };
+      }
+    } catch {
+      // Ignore
+    }
+  }
+  return { available: false, path: null, version: null };
+}
+export function printCloudflareTunnelInstallHelp() {
+  const platform = process.platform;
+  let installCmd = '';
+  if (platform === 'darwin') {
+    installCmd = 'brew install cloudflared';
+  } else if (platform === 'win32') {
+    installCmd = 'winget install --id Cloudflare.cloudflared';
+  } else {
+    installCmd = 'Download from https://github.com/cloudflare/cloudflared/releases';
+  }
+  console.log(`
+╔══════════════════════════════════════════════════════════════════╗
+║  Cloudflare tunnel requires 'cloudflared' to be installed        ║
+╚══════════════════════════════════════════════════════════════════╝
+Install instructions for your platform:
+  macOS:    brew install cloudflared
+  Windows:  winget install --id Cloudflare.cloudflared
+  Linux:    Download from https://github.com/cloudflare/cloudflared/releases
+Or visit: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflared/downloads/
+`);
+}
+export async function startCloudflareTunnel({ originUrl, port }) {
+  const cfCheck = await checkCloudflaredAvailable();
+  if (!cfCheck.available) {
+    printCloudflareTunnelInstallHelp();
+    throw new Error('cloudflared is not installed');
+  }
+  console.log(`Using cloudflared: ${cfCheck.path} (${cfCheck.version})`);
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-cf-'));
+  const child = spawn('cloudflared', ['tunnel', '--url', originUrl], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      HOME: tempDir,
+      CF_TELEMETRY_DISABLE: '1',
+    },
+    killSignal: 'SIGINT',
+  });
+  let publicUrl = null;
+  let tunnelReady = false;
+  const onData = (chunk, isStderr) => {
+    const text = chunk.toString('utf8');
+    if (!tunnelReady) {
+      const match = text.match(TRY_CF_URL_REGEX);
+      if (match) {
+        publicUrl = match[0];
+        tunnelReady = true;
+      }
+    }
+    process.stderr.write(isStderr ? text : '');
+  };
+  child.stdout.on('data', (chunk) => onData(chunk, false));
+  child.stderr.on('data', (chunk) => onData(chunk, true));
+  child.on('error', (error) => {
+    console.error(`Cloudflared error: ${error.message}`);
+    cleanupTempDir();
+  });
+  const cleanupTempDir = () => {
+    try {
+      if (fs.existsSync(tempDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+  };
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      if (!publicUrl) {
+        reject(new Error('Tunnel URL not received within 30 seconds'));
+      }
+    }, 30000);
+    const checkReady = setInterval(() => {
+      if (publicUrl) {
+        clearTimeout(timeout);
+        clearInterval(checkReady);
+        resolve(null);
+      }
+    }, 100);
+    child.on('exit', (code) => {
+      clearTimeout(timeout);
+      clearInterval(checkReady);
+      cleanupTempDir();
+      if (code !== null && code !== 0) {
+        reject(new Error(`Cloudflared exited with code ${code}`));
+      }
+    });
+  });
+  return {
+    stop: () => {
+      try {
+        child.kill('SIGINT');
+      } catch {
+        // Ignore
+      }
+    },
+    process: child,
+    getPublicUrl: () => publicUrl,
+  };
+}
+export function printTunnelWarning() {
+  console.log(`
+⚠️  Cloudflare Quick Tunnel Limitations:
+   • Maximum 200 concurrent requests
+   • Server-Sent Events (SSE) are NOT supported
+   • URLs are temporary and will expire when the tunnel stops
+   • Password protection is required for tunnel access
+   For production use, set up a named Cloudflare Tunnel:
+   https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/
+`);
+}

package/server/lib/git-service.js CHANGED Viewed

@@ -271,15 +271,62 @@ export async function getStatus(directory) {
       };
     }
+    const selectBaseRefForUnpublished = async () => {
+      const candidates = [];
+      const originHead = await git
+        .raw(['symbolic-ref', '-q', 'refs/remotes/origin/HEAD'])
+        .then((value) => String(value || '').trim())
+        .catch(() => '');
+      if (originHead) {
+        // "refs/remotes/origin/main" -> "origin/main"
+        candidates.push(originHead.replace(/^refs\/remotes\//, ''));
+      }
+      candidates.push('origin/main', 'origin/master', 'main', 'master');
+      for (const ref of candidates) {
+        const exists = await git
+          .raw(['rev-parse', '--verify', ref])
+          .then((value) => String(value || '').trim())
+          .catch(() => '');
+        if (exists) return ref;
+      }
+      return null;
+    };
+    let tracking = status.tracking || null;
+    let ahead = status.ahead;
+    let behind = status.behind;
+    // When no upstream is configured (common for new worktree branches), Git doesn't report ahead/behind.
+    // We still want to show the number of unpublished commits to the user.
+    if (!tracking && status.current) {
+      const baseRef = await selectBaseRefForUnpublished();
+      if (baseRef) {
+        const countRaw = await git
+          .raw(['rev-list', '--count', `${baseRef}..HEAD`])
+          .then((value) => String(value || '').trim())
+          .catch(() => '');
+        const count = parseInt(countRaw, 10);
+        if (Number.isFinite(count)) {
+          ahead = count;
+          behind = 0;
+        }
+      }
+    }
     return {
       current: status.current,
-      tracking: status.tracking,
-      ahead: status.ahead,
-      behind: status.behind,
-      files: status.files.map(f => ({
+      tracking,
+      ahead,
+      behind,
+      files: status.files.map((f) => ({
         path: f.path,
         index: f.index,
-        working_dir: f.working_dir
+        working_dir: f.working_dir,
       })),
       isClean: status.isClean(),
       diffStats,
@@ -512,22 +559,79 @@ export async function pull(directory, options = {}) {
 export async function push(directory, options = {}) {
   const git = simpleGit(normalizeDirectoryPath(directory));
-  try {
-    const result = await git.push(
-      options.remote || 'origin',
-      options.branch,
-      options.options || {}
+  const buildUpstreamOptions = (raw) => {
+    if (Array.isArray(raw)) {
+      return raw.includes('--set-upstream') ? raw : [...raw, '--set-upstream'];
+    }
+    if (raw && typeof raw === 'object') {
+      return { ...raw, '--set-upstream': null };
+    }
+    return ['--set-upstream'];
+  };
+  const looksLikeMissingUpstream = (error) => {
+    const message = String(error?.message || error?.stderr || '').toLowerCase();
+    return (
+      message.includes('has no upstream') ||
+      message.includes('no upstream') ||
+      message.includes('set-upstream') ||
+      message.includes('set upstream') ||
+      (message.includes('upstream') && message.includes('push') && message.includes('-u'))
     );
+  };
+  const normalizePushResult = (result) => {
     return {
       success: true,
       pushed: result.pushed,
       repo: result.repo,
-      ref: result.ref
+      ref: result.ref,
     };
+  };
+  const remote = options.remote || 'origin';
+  // If caller didn't specify a branch, this is the common "Push"/"Commit & Push" path.
+  // When there's no upstream yet (typical for freshly-created worktree branches), publish it on first push.
+  if (!options.branch) {
+    try {
+      const status = await git.status();
+      if (status.current && !status.tracking) {
+        const result = await git.push(remote, status.current, buildUpstreamOptions(options.options));
+        return normalizePushResult(result);
+      }
+    } catch (error) {
+      // If we can't read status, fall back to the regular push path below.
+      console.warn('Failed to read git status before push:', error);
+    }
+  }
+  try {
+    const result = await git.push(remote, options.branch, options.options || {});
+    return normalizePushResult(result);
   } catch (error) {
-    console.error('Failed to push:', error);
-    throw error;
+    // Last-resort fallback: retry with upstream if the error suggests it's missing.
+    if (!looksLikeMissingUpstream(error)) {
+      console.error('Failed to push:', error);
+      throw error;
+    }
+    try {
+      const status = await git.status();
+      const branch = options.branch || status.current;
+      if (!branch) {
+        console.error('Failed to push: missing branch name for upstream setup:', error);
+        throw error;
+      }
+      const result = await git.push(remote, branch, buildUpstreamOptions(options.options));
+      return normalizePushResult(result);
+    } catch (fallbackError) {
+      console.error('Failed to push (including upstream fallback):', fallbackError);
+      throw fallbackError;
+    }
   }
 }
@@ -726,6 +830,7 @@ export async function addWorktree(directory, worktreePath, branch, options = {})
   try {
     const args = ['worktree', 'add'];
+    const startPoint = typeof options.startPoint === 'string' ? options.startPoint.trim() : '';
     if (options.createBranch) {
       args.push('-b', branch);
@@ -735,6 +840,8 @@ export async function addWorktree(directory, worktreePath, branch, options = {})
     if (!options.createBranch) {
       args.push(branch);
+    } else if (startPoint) {
+      args.push(startPoint);
     }
     await git.raw(args);