@openchamber/web 1.4.7 → 1.4.9

package/server/index.js

@@ -39,6 +39,9 @@ const FILE_SEARCH_EXCLUDED_DIRS = new Set([
   'logs'
 ]);
 
+// Lock to prevent race conditions in persistSettings
+let persistSettingsLock = Promise.resolve();
+
 const normalizeDirectoryPath = (value) => {
   if (typeof value !== 'string') {
     return value;
@@ -608,6 +611,10 @@ const sanitizeSettingsUpdate = (payload) => {
   if (typeof candidate.autoCreateWorktree === 'boolean') {
     result.autoCreateWorktree = candidate.autoCreateWorktree;
   }
+  if (typeof candidate.commitMessageModel === 'string') {
+    const trimmed = candidate.commitMessageModel.trim();
+    result.commitMessageModel = trimmed.length > 0 ? trimmed : undefined;
+  }
 
   const skillCatalogs = sanitizeSkillCatalogs(candidate.skillCatalogs);
   if (skillCatalogs) {
@@ -696,30 +703,39 @@ const formatSettingsResponse = (settings) => {
 };
 
 const validateProjectEntries = async (projects) => {
+  console.log(`[validateProjectEntries] Starting validation for ${projects.length} projects`);
+
   if (!Array.isArray(projects)) {
+    console.warn(`[validateProjectEntries] Input is not an array, returning empty`);
     return [];
   }
 
   const results = [];
   for (const project of projects) {
     if (!project || typeof project.path !== 'string' || project.path.length === 0) {
+      console.error(`[validateProjectEntries] Invalid project entry: missing or empty path`, project);
       continue;
     }
     try {
       const stats = await fsPromises.stat(project.path);
       if (!stats.isDirectory()) {
+        console.error(`[validateProjectEntries] Project path is not a directory: ${project.path}`);
         continue;
       }
       results.push(project);
     } catch (error) {
       const err = error;
+      console.error(`[validateProjectEntries] Failed to validate project "${project.path}": ${err.code || err.message || err}`);
       if (err && typeof err === 'object' && err.code === 'ENOENT') {
+        console.log(`[validateProjectEntries] Removing project with ENOENT: ${project.path}`);
         continue;
       }
-      continue;
+      console.log(`[validateProjectEntries] Keeping project despite non-ENOENT error: ${project.path}`);
+      results.push(project);
     }
   }
 
+  console.log(`[validateProjectEntries] Validation complete: ${results.length}/${projects.length} projects valid`);
   return results;
 };
 
@@ -794,27 +810,39 @@ const readSettingsFromDiskMigrated = async () => {
 };
 
 const persistSettings = async (changes) => {
-  const current = await readSettingsFromDisk();
-  const sanitized = sanitizeSettingsUpdate(changes);
-  let next = mergePersistedSettings(current, sanitized);
-
-  if (Array.isArray(next.projects)) {
-    const validated = await validateProjectEntries(next.projects);
-    next = { ...next, projects: validated };
-  }
-
-  if (Array.isArray(next.projects) && next.projects.length > 0) {
-    const activeId = typeof next.activeProjectId === 'string' ? next.activeProjectId : '';
-    const active = next.projects.find((project) => project.id === activeId) || null;
-    if (!active) {
-      next = { ...next, activeProjectId: next.projects[0].id };
-    }
-  } else if (next.activeProjectId) {
-    next = { ...next, activeProjectId: undefined };
-  }
-
-  await writeSettingsToDisk(next);
-  return formatSettingsResponse(next);
+  // Serialize concurrent calls using lock
+  persistSettingsLock = persistSettingsLock.then(async () => {
+    console.log(`[persistSettings] Called with changes:`, JSON.stringify(changes, null, 2));
+    const current = await readSettingsFromDisk();
+    console.log(`[persistSettings] Current projects count:`, Array.isArray(current.projects) ? current.projects.length : 'N/A');
+    const sanitized = sanitizeSettingsUpdate(changes);
+    let next = mergePersistedSettings(current, sanitized);
+
+    if (Array.isArray(next.projects)) {
+      console.log(`[persistSettings] Validating ${next.projects.length} projects...`);
+      const validated = await validateProjectEntries(next.projects);
+      console.log(`[persistSettings] After validation: ${validated.length} projects remain`);
+      next = { ...next, projects: validated };
+    }
+
+    if (Array.isArray(next.projects) && next.projects.length > 0) {
+      const activeId = typeof next.activeProjectId === 'string' ? next.activeProjectId : '';
+      const active = next.projects.find((project) => project.id === activeId) || null;
+      if (!active) {
+        console.log(`[persistSettings] Active project ID ${activeId} not found, switching to ${next.projects[0].id}`);
+        next = { ...next, activeProjectId: next.projects[0].id };
+      }
+    } else if (next.activeProjectId) {
+      console.log(`[persistSettings] No projects found, clearing activeProjectId ${next.activeProjectId}`);
+      next = { ...next, activeProjectId: undefined };
+    }
+
+    await writeSettingsToDisk(next);
+    console.log(`[persistSettings] Successfully saved ${next.projects?.length || 0} projects to disk`);
+    return formatSettingsResponse(next);
+  });
+  
+  return persistSettingsLock;
 };
 
 // HMR-persistent state via globalThis
@@ -945,6 +973,22 @@ function setOpenCodePort(port) {
   lastOpenCodeError = null;
 }
 
+async function waitForOpenCodePort(timeoutMs = 15000) {
+  if (openCodePort !== null) {
+    return openCodePort;
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    if (openCodePort !== null) {
+      return openCodePort;
+    }
+  }
+
+  throw new Error('Timed out waiting for OpenCode port');
+}
+
 function getLoginShellPath() {
   if (process.platform === 'win32') {
     return null;
@@ -1807,6 +1851,7 @@ function setupProxy(app) {
     },
     onProxyReq: (proxyReq, req, res) => {
       console.log(`Proxying ${req.method} ${req.path} to OpenCode`);
+
       if (req.headers.accept && req.headers.accept.includes('text/event-stream')) {
         console.log(`[SSE] Setting up SSE proxy for ${req.method} ${req.path}`);
         proxyReq.setHeader('Accept', 'text/event-stream');
@@ -1842,11 +1887,11 @@ function startHealthMonitoring() {
   }
 
   healthCheckInterval = setInterval(async () => {
-    if (!openCodeProcess || isShuttingDown) return;
+    if (!openCodeProcess || isShuttingDown || isRestartingOpenCode) return;
 
     try {
-
-      if (openCodeProcess.exitCode !== null) {
+      const healthy = await isOpenCodeProcessHealthy();
+      if (!healthy) {
         console.log('OpenCode process not running, restarting...');
         await restartOpenCode();
       }
@@ -1870,28 +1915,29 @@ async function gracefulShutdown(options = {}) {
 
   if (openCodeProcess) {
     console.log('Stopping OpenCode process...');
-    openCodeProcess.kill('SIGTERM');
-
-    await new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        openCodeProcess.kill('SIGKILL');
-        resolve();
-      }, SHUTDOWN_TIMEOUT);
-
-      openCodeProcess.on('exit', () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-    });
+    try {
+      openCodeProcess.close();
+    } catch (error) {
+      console.warn('Error closing OpenCode process:', error);
+    }
+    openCodeProcess = null;
   }
 
   if (server) {
-    await new Promise((resolve) => {
-      server.close(() => {
-        console.log('HTTP server closed');
-        resolve();
-      });
-    });
+    await Promise.race([
+      new Promise((resolve) => {
+        server.close(() => {
+          console.log('HTTP server closed');
+          resolve();
+        });
+      }),
+      new Promise((resolve) => {
+        setTimeout(() => {
+          console.warn('Server close timeout reached, forcing shutdown');
+          resolve();
+        }, SHUTDOWN_TIMEOUT);
+      })
+    ]);
   }
 
   if (uiAuthController) {
@@ -1931,7 +1977,7 @@ async function main(options = {}) {
       status: 'ok',
       timestamp: new Date().toISOString(),
       openCodePort: openCodePort,
-      openCodeRunning: Boolean(openCodeProcess && openCodeProcess.exitCode === null),
+      openCodeRunning: Boolean(openCodePort && isOpenCodeReady && !isRestartingOpenCode),
       openCodeApiPrefix,
       openCodeApiPrefixDetected,
       isOpenCodeReady,
@@ -1952,16 +1998,16 @@ async function main(options = {}) {
       req.path.startsWith('/api/opencode')
     ) {
 
-      express.json()(req, res, next);
+      express.json({ limit: '50mb' })(req, res, next);
     } else if (req.path.startsWith('/api')) {
 
       next();
     } else {
 
-      express.json()(req, res, next);
+      express.json({ limit: '50mb' })(req, res, next);
     }
   });
-  app.use(express.urlencoded({ extended: true }));
+  app.use(express.urlencoded({ extended: true, limit: '50mb' }));
 
   app.use((req, res, next) => {
     console.log(`${new Date().toISOString()} - ${req.method} ${req.path}`);
@@ -2385,11 +2431,15 @@ async function main(options = {}) {
   });
 
   app.put('/api/config/settings', async (req, res) => {
+    console.log(`[API:PUT /api/config/settings] Received request`);
+    console.log(`[API:PUT /api/config/settings] Request body:`, JSON.stringify(req.body, null, 2));
     try {
       const updated = await persistSettings(req.body ?? {});
+      console.log(`[API:PUT /api/config/settings] Success, returning ${updated.projects?.length || 0} projects`);
       res.json(updated);
     } catch (error) {
-      console.error('Failed to save settings:', error);
+      console.error(`[API:PUT /api/config/settings] Failed to save settings:`, error);
+      console.error(`[API:PUT /api/config/settings] Error stack:`, error.stack);
       res.status(500).json({ error: error instanceof Error ? error.message : 'Failed to save settings' });
     }
   });
@@ -3256,6 +3306,17 @@ async function main(options = {}) {
     }
   });
 
+  app.get('/api/git/discover-credentials', async (req, res) => {
+    try {
+      const { discoverGitCredentials } = await import('./lib/git-credentials.js');
+      const credentials = discoverGitCredentials();
+      res.json(credentials);
+    } catch (error) {
+      console.error('Failed to discover git credentials:', error);
+      res.status(500).json({ error: 'Failed to discover git credentials' });
+    }
+  });
+
   app.get('/api/git/check', async (req, res) => {
     const { isGitRepository } = await getGitLibraries();
     try {
@@ -3272,6 +3333,23 @@ async function main(options = {}) {
     }
   });
 
+  app.get('/api/git/remote-url', async (req, res) => {
+    const { getRemoteUrl } = await getGitLibraries();
+    try {
+      const directory = req.query.directory;
+      if (!directory) {
+        return res.status(400).json({ error: 'directory parameter is required' });
+      }
+      const remote = req.query.remote || 'origin';
+
+      const url = await getRemoteUrl(directory, remote);
+      res.json({ url });
+    } catch (error) {
+      console.error('Failed to get remote url:', error);
+      res.status(500).json({ error: 'Failed to get remote url' });
+    }
+  });
+
   app.get('/api/git/current-identity', async (req, res) => {
     const { getCurrentIdentity } = await getGitLibraries();
     try {
@@ -3456,6 +3534,15 @@ async function main(options = {}) {
         .join('\n\n');
 
       const prompt = `You are drafting git commit notes for this codebase. Respond in JSON of the shape {"subject": string, "highlights": string[]} (ONLY the JSON in response, no markdown wrappers or anything except JSON) with these rules:\n- subject follows our convention: type[optional-scope]: summary (examples: "feat: add diff virtualization", "fix(chat): restore enter key handling")\n- allowed types: feat, fix, chore, style, refactor, perf, docs, test, build, ci (choose the best match or fallback to chore)\n- summary must be imperative, concise, <= 70 characters, no trailing punctuation\n- scope is optional; include only when obvious from filenames/folders; do not invent scopes\n- focus on the most impactful user-facing change; if multiple capabilities ship together, align the subject with the dominant theme and use highlights to cover the other major outcomes\n- highlights array should contain 2-3 plain sentences (<= 90 chars each) that describe distinct features or UI changes users will notice (e.g. "Add per-file revert action in Changes list"). Avoid subjective benefit statements, marketing tone, repeating the subject, or referencing helper function names. Highlight additions such as new controls/buttons, new actions (e.g. revert), or stored state changes explicitly. Skip highlights if fewer than two meaningful points exist.\n- text must be plain (no markdown bullets); each highlight should start with an uppercase verb\n\nDiff summary:\n${diffSummaries}`;
+ 
+      const settings = await readSettingsFromDiskMigrated();
+      const rawModel = typeof settings.commitMessageModel === 'string' ? settings.commitMessageModel.trim() : '';
+      const model = (() => {
+        if (!rawModel) return 'big-pickle';
+        const parts = rawModel.split('/').filter(Boolean);
+        const candidate = parts.length > 1 ? parts[parts.length - 1] : parts[0];
+        return candidate || 'big-pickle';
+      })();
 
       const completionTimeout = createTimeoutSignal(LONG_REQUEST_TIMEOUT_MS);
       let response;
@@ -3464,7 +3551,7 @@ async function main(options = {}) {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({
-            model: 'big-pickle',
+            model,
             messages: [{ role: 'user', content: prompt }],
             max_tokens: 3000,
             stream: false,
@@ -4781,9 +4868,12 @@ async function main(options = {}) {
   });
 
   if (attachSignals && !signalsAttached) {
-    process.on('SIGTERM', gracefulShutdown);
-    process.on('SIGINT', gracefulShutdown);
-    process.on('SIGQUIT', gracefulShutdown);
+    const handleSignal = async () => {
+      await gracefulShutdown();
+    };
+    process.on('SIGTERM', handleSignal);
+    process.on('SIGINT', handleSignal);
+    process.on('SIGQUIT', handleSignal);
     signalsAttached = true;
     syncToHmrState();
   }

package/server/lib/git-credentials.js

@@ -0,0 +1,74 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const GIT_CREDENTIALS_PATH = path.join(os.homedir(), '.git-credentials');
+
+export function discoverGitCredentials() {
+  const credentials = [];
+
+  if (!fs.existsSync(GIT_CREDENTIALS_PATH)) {
+    return credentials;
+  }
+
+  try {
+    const content = fs.readFileSync(GIT_CREDENTIALS_PATH, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+
+    for (const line of lines) {
+      try {
+        const url = new URL(line.trim());
+        const hostname = url.hostname;
+        const pathname = url.pathname && url.pathname !== '/' ? url.pathname : '';
+        const host = hostname + pathname;
+        const username = url.username || '';
+
+        if (host && username) {
+          const exists = credentials.some(c => c.host === host && c.username === username);
+          if (!exists) {
+            credentials.push({ host, username });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to read .git-credentials:', error);
+  }
+
+  return credentials;
+}
+
+export function getCredentialForHost(host) {
+  if (!fs.existsSync(GIT_CREDENTIALS_PATH)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(GIT_CREDENTIALS_PATH, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+
+    for (const line of lines) {
+      try {
+        const url = new URL(line.trim());
+        const hostname = url.hostname;
+        const pathname = url.pathname && url.pathname !== '/' ? url.pathname : '';
+        const credHost = hostname + pathname;
+
+        if (credHost === host) {
+          return {
+            username: url.username || '',
+            token: url.password || ''
+          };
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to read .git-credentials for host lookup:', error);
+  }
+
+  return null;
+}

package/server/lib/git-identity-storage.js

@@ -66,7 +66,9 @@ export function createProfile(profileData) {
     name: profileData.name || profileData.userName,
     userName: profileData.userName,
     userEmail: profileData.userEmail,
+    authType: profileData.authType || 'ssh',
     sshKey: profileData.sshKey || null,
+    host: profileData.host || null,
     color: profileData.color || 'keyword',
     icon: profileData.icon || 'branch'
   };

package/server/lib/git-service.js

@@ -117,6 +117,17 @@ export async function getGlobalIdentity() {
   }
 }
 
+export async function getRemoteUrl(directory, remoteName = 'origin') {
+  const git = simpleGit(normalizeDirectoryPath(directory));
+
+  try {
+    const url = await git.remote(['get-url', remoteName]);
+    return url?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
 export async function getCurrentIdentity(directory) {
   const git = simpleGit(normalizeDirectoryPath(directory));
 
@@ -157,13 +168,24 @@ export async function setLocalIdentity(directory, profile) {
     await git.addConfig('user.name', profile.userName, false, 'local');
     await git.addConfig('user.email', profile.userEmail, false, 'local');
 
-    if (profile.sshKey) {
+    const authType = profile.authType || 'ssh';
+
+    if (authType === 'ssh' && profile.sshKey) {
       await git.addConfig(
         'core.sshCommand',
         `ssh -i ${profile.sshKey}`,
         false,
         'local'
       );
+      await git.raw(['config', '--local', '--unset', 'credential.helper']).catch(() => {});
+    } else if (authType === 'token' && profile.host) {
+      await git.addConfig(
+        'credential.helper',
+        'store',
+        false,
+        'local'
+      );
+      await git.raw(['config', '--local', '--unset', 'core.sshCommand']).catch(() => {});
     }
 
     return true;