@openchamber/web 1.11.5 → 1.11.7

package/server/lib/opencode/openchamber-routes.js

@@ -1,7 +1,6 @@
 export const registerOpenChamberRoutes = (app, dependencies) => {
   const {
     fs,
-    os,
     path,
     process,
     server,
@@ -104,14 +103,15 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
       }
 
       const currentPort = server.address()?.port || 3000;
-      const tmpDir = os.tmpdir();
-      const instanceFilePath = path.join(tmpDir, `openchamber-${currentPort}.json`);
+      const instanceFilePath = path.join(openchamberDataDir, 'run', `openchamber-${currentPort}.json`);
       let storedOptions = { port: currentPort, daemon: true };
       try {
         const content = await fs.promises.readFile(instanceFilePath, 'utf8');
         storedOptions = JSON.parse(content);
       } catch {
       }
+      const launchMode = storedOptions.launchMode === 'foreground' ? 'foreground' : 'daemon';
+      const isForegroundService = launchMode === 'foreground';
 
       const isWindows = process.platform === 'win32';
       const quotePosix = (value) => `'${String(value).replace(/'/g, "'\\''")}'`;
@@ -152,7 +152,7 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
           restartCmdFallback += ` --ui-password '${escapedPw}'`;
         }
       }
-      const restartCmd = `(${restartCmdPrimary}) || (${restartCmdFallback})`;
+      const restartCmd = isForegroundService ? '' : `(${restartCmdPrimary}) || (${restartCmdFallback})`;
       const updateLogPath = path.join(openchamberDataDir, 'update-install.log');
       const logPreamble = [
         '',
@@ -165,8 +165,9 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
         `packagePath=${pmDetails.packagePath || 'unknown'}`,
         `globalNodeModulesRoot=${pmDetails.globalNodeModulesRoot || 'unknown'}`,
         `mode=${isContainer ? 'container' : 'restart'}`,
+        `launchMode=${launchMode}`,
         `updateCommand=${updateCmd}`,
-        `restartCommand=${restartCmd}`,
+        `restartCommand=${restartCmd || 'service-manager'}`,
         `logPath=${updateLogPath}`,
       ].join('\n');
 
@@ -176,6 +177,7 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
         version: updateInfo.version,
         packageManager: pm,
         autoRestart: true,
+        restartManager: isForegroundService ? 'service' : 'cli',
       });
 
         setTimeout(() => {
@@ -192,7 +194,7 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
             ${updateCmd}
             if %ERRORLEVEL% EQU 0 (
               echo Update successful, restarting OpenChamber...
-              ${restartCmd}
+              ${restartCmd || 'echo Service manager will restart OpenChamber.'}
             ) else (
               echo Update failed
               exit /b 1
@@ -204,7 +206,7 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
             ${updateCmd}
             if [ $? -eq 0 ]; then
               echo "Update successful, restarting OpenChamber..."
-              ${restartCmd}
+              ${restartCmd || 'echo "Service manager will restart OpenChamber."'}
             else
               echo "Update failed"
               exit 1

package/server/lib/opencode/plugin-routes.js

@@ -0,0 +1,373 @@
+import fs from 'fs';
+import os from 'os';
+
+import { getNpmInfo as defaultGetNpmInfo } from './npm-registry.js';
+import { isExactSemver as defaultIsExactSemver, isPathSpec as defaultIsPathSpec, parseNpmSpec as defaultParseNpmSpec, parsePathSpec as defaultParsePathSpec } from './plugin-spec.js';
+
+const ENTRY_EXISTS_CODES = new Set(['ENTRY_EXISTS', 'EEXIST']);
+const FILE_EXISTS_CODES = new Set(['FILE_EXISTS', 'EEXIST']);
+const NOT_FOUND_CODES = new Set(['NOT_FOUND', 'ENOENT']);
+const BAD_REQUEST_CODES = new Set(['INVALID_FILENAME', 'INVALID_SCOPE', 'INVALID_SPEC', 'EINVAL']);
+
+export const registerPluginRoutes = (app, dependencies) => {
+  const {
+    resolveOptionalProjectDirectory,
+    refreshOpenCodeAfterConfigChange,
+    clientReloadDelayMs,
+    listPluginEntries,
+    getPluginEntry,
+    createPluginEntry,
+    updatePluginEntry,
+    deletePluginEntry,
+    listPluginDirFiles,
+    readPluginDirFile,
+    writePluginDirFile,
+    deletePluginDirFile,
+    encodePluginId,
+    decodePluginId,
+    getNpmInfo = defaultGetNpmInfo,
+    parseNpmSpec = defaultParseNpmSpec,
+    parsePathSpec = defaultParsePathSpec,
+    isExactSemver = defaultIsExactSemver,
+    isPathSpec = defaultIsPathSpec,
+  } = dependencies;
+
+  const parsedKindForSpec = (spec) => (isPathSpec(spec) ? 'path' : 'npm');
+
+  const resolveDirectory = async (req, res) => {
+    const { directory, error } = await resolveOptionalProjectDirectory(req);
+    if (error) {
+      res.status(400).json({ error });
+      return null;
+    }
+    return directory || null;
+  };
+
+  const successPayload = (message) => ({
+    success: true,
+    requiresReload: true,
+    message,
+    reloadDelayMs: clientReloadDelayMs,
+    reloadFailed: false,
+    warning: undefined,
+  });
+
+  const completePluginMutation = async (res, operation, _noun, applyChange) => {
+    applyChange();
+
+    const pastTense = operation.replace(/ion$/, 'ed').replace(/update$/, 'updated');
+
+    try {
+      await refreshOpenCodeAfterConfigChange(`plugin ${operation}`);
+      return res.json(successPayload(`Plugin ${pastTense}. Reloading interface…`));
+    } catch (error) {
+      console.error(`[API:plugin ${operation}] Reload failed after config write:`, error);
+      return res.json({
+        success: true,
+        requiresReload: false,
+        message: `Plugin ${pastTense}, but OpenCode reload failed.`,
+        reloadDelayMs: clientReloadDelayMs,
+        reloadFailed: true,
+        warning: error.message || 'OpenCode reload failed after plugin config changed',
+      });
+    }
+  };
+
+  const validateEntryId = (id) => {
+    const decoded = decodePluginId(id);
+    if (decoded.prefix !== 'config') {
+      const error = new Error('Plugin entry not found');
+      error.code = 'NOT_FOUND';
+      throw error;
+    }
+  };
+
+  const validateFileId = (id) => {
+    const decoded = decodePluginId(id);
+    if (decoded.prefix !== 'file') {
+      const error = new Error('Plugin file not found');
+      error.code = 'NOT_FOUND';
+      throw error;
+    }
+  };
+
+  const handlePluginError = (res, error, fallbackMessage, context, existsKind = null) => {
+    const code = error?.code;
+    if ((existsKind === 'entry' && ENTRY_EXISTS_CODES.has(code)) || (existsKind === 'file' && FILE_EXISTS_CODES.has(code))) {
+      return res.status(409).json({ error: error.message });
+    }
+    if (NOT_FOUND_CODES.has(code)) {
+      return res.status(404).json({ error: error.message });
+    }
+    if (BAD_REQUEST_CODES.has(code)) {
+      return res.status(400).json({ error: error.message });
+    }
+
+    console.error(context, error);
+    return res.status(500).json({ error: fallbackMessage });
+  };
+
+  app.get('/api/config/plugins', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+
+      res.json({
+        entries: listPluginEntries(directory),
+        files: listPluginDirFiles(directory),
+      });
+    } catch (error) {
+      console.error('[API:GET /api/config/plugins] Failed:', error);
+      res.status(500).json({ error: 'Failed to list plugins' });
+    }
+  });
+
+  app.get('/api/config/plugins/registry', async (req, res) => {
+    try {
+      const { directory, error: directoryError } = await resolveOptionalProjectDirectory(req);
+      if (directoryError) {
+        return res.status(400).json({ error: directoryError });
+      }
+      const rawSpecs = (req.query.specs || '').toString();
+      const specs = rawSpecs
+        ? rawSpecs.split(',').map((spec) => {
+          try {
+            return decodeURIComponent(spec);
+          } catch {
+            return spec;
+          }
+        }).filter((spec) => spec.length > 0)
+        : [];
+      const uniqueSpecs = Array.from(new Set(specs));
+      if (uniqueSpecs.length > 100) {
+        return res.status(400).json({ error: 'too many specs' });
+      }
+
+      const refresh = req.query.refresh === 'true';
+      const npmJobs = new Map();
+      const malformedSpecs = new Set();
+
+      for (const spec of uniqueSpecs) {
+        if (parsedKindForSpec(spec) !== 'npm') continue;
+
+        const parsed = parseNpmSpec(spec);
+        if (parsed.malformed) {
+          malformedSpecs.add(spec);
+          continue;
+        }
+
+        const job = npmJobs.get(parsed.name) || { specs: [], parsedBySpec: new Map() };
+        job.specs.push(spec);
+        job.parsedBySpec.set(spec, parsed);
+        npmJobs.set(parsed.name, job);
+      }
+
+      const npmInfoByName = new Map();
+      await Promise.all(Array.from(npmJobs.keys()).map(async (name) => {
+        npmInfoByName.set(name, await getNpmInfo(name, { forceRefresh: refresh }));
+      }));
+
+      const results = [];
+      for (const spec of uniqueSpecs) {
+        if (malformedSpecs.has(spec)) {
+          results.push({ kind: 'npm-malformed', spec, error: 'Spec syntax is malformed' });
+          continue;
+        }
+
+        if (parsedKindForSpec(spec) === 'path') {
+          const { absolutePath } = parsePathSpec(spec, { homedir: os.homedir(), cwd: directory || os.homedir() });
+          try {
+            fs.statSync(absolutePath);
+          } catch {
+            results.push({ kind: 'path-missing', spec, absolutePath });
+            continue;
+          }
+
+          try {
+            fs.accessSync(absolutePath, fs.constants.R_OK);
+            results.push({ kind: 'path-ok', spec, absolutePath });
+          } catch {
+            results.push({ kind: 'path-unreadable', spec, absolutePath });
+          }
+          continue;
+        }
+
+        const parsed = parseNpmSpec(spec);
+        const info = npmInfoByName.get(parsed.name);
+        if (!info.ok) {
+          if (info.status === 404) {
+            results.push({ kind: 'npm-missing-package', spec, name: parsed.name, error: info.error });
+            continue;
+          }
+
+          results.push({ kind: 'npm-network', spec, error: info.status === 'network' ? info.error : `Registry returned ${info.status}` });
+          continue;
+        }
+
+        const currentVersion = parsed.version;
+        if (currentVersion !== null && isExactSemver(currentVersion) && !info.versions.includes(currentVersion)) {
+          results.push({
+            kind: 'npm-missing-version',
+            spec,
+            name: parsed.name,
+            currentVersion,
+            latestVersion: info.latest,
+            versions: info.versions,
+          });
+          continue;
+        }
+
+        results.push({
+          kind: 'npm-ok',
+          spec,
+          name: parsed.name,
+          currentVersion,
+          latestVersion: info.latest,
+          versions: info.versions,
+          hasUpdate: currentVersion !== null && isExactSemver(currentVersion) && currentVersion !== info.latest,
+        });
+      }
+
+      return res.json({ results });
+    } catch (error) {
+      console.error('[API:GET /api/config/plugins/registry]', error);
+      return res.status(500).json({ error: 'Failed to query npm registry' });
+    }
+  });
+
+  app.get('/api/config/plugins/entry/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateEntryId(req.params.id);
+
+      const entry = getPluginEntry(req.params.id, directory);
+      if (!entry) {
+        return res.status(404).json({ error: 'Plugin entry not found' });
+      }
+      return res.json(entry);
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to get plugin entry', '[API:GET /api/config/plugins/entry/:id] Failed:');
+    }
+  });
+
+  app.post('/api/config/plugins/entry', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+
+      await completePluginMutation(res, 'entry creation', 'entry', () => {
+        createPluginEntry({
+          spec: req.body?.spec,
+          options: req.body?.options,
+          scope: req.body?.scope,
+        }, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to create plugin entry', '[API:POST /api/config/plugins/entry] Failed:', 'entry');
+    }
+  });
+
+  app.patch('/api/config/plugins/entry/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateEntryId(req.params.id);
+
+      await completePluginMutation(res, 'entry update', 'entry', () => {
+        updatePluginEntry(req.params.id, {
+          spec: req.body?.spec,
+          options: req.body?.options,
+        }, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to update plugin entry', '[API:PATCH /api/config/plugins/entry/:id] Failed:', 'entry');
+    }
+  });
+
+  app.delete('/api/config/plugins/entry/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateEntryId(req.params.id);
+
+      await completePluginMutation(res, 'entry deletion', 'entry', () => {
+        deletePluginEntry(req.params.id, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to delete plugin entry', '[API:DELETE /api/config/plugins/entry/:id] Failed:', 'entry');
+    }
+  });
+
+  app.get('/api/config/plugins/file/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateFileId(req.params.id);
+
+      const file = readPluginDirFile(req.params.id, directory);
+      if (!file) {
+        return res.status(404).json({ error: 'Plugin file not found' });
+      }
+      return res.json(file);
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to read plugin file', '[API:GET /api/config/plugins/file/:id] Failed:');
+    }
+  });
+
+  app.post('/api/config/plugins/file', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      const id = encodePluginId('file', `${req.body?.scope || 'user'}:${req.body?.fileName || ''}`);
+
+      await completePluginMutation(res, 'file creation', 'file', () => {
+        validateFileId(id);
+        writePluginDirFile({
+          fileName: req.body?.fileName,
+          content: req.body?.content,
+          scope: req.body?.scope,
+        }, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to create plugin file', '[API:POST /api/config/plugins/file] Failed:', 'file');
+    }
+  });
+
+  app.put('/api/config/plugins/file/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateFileId(req.params.id);
+
+      const existing = readPluginDirFile(req.params.id, directory);
+      if (!existing) {
+        return res.status(404).json({ error: 'Plugin file not found' });
+      }
+
+      await completePluginMutation(res, 'file update', 'file', () => {
+        writePluginDirFile({
+          fileName: existing.fileName,
+          content: req.body?.content,
+          scope: existing.scope,
+        }, directory, { overwrite: true });
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to update plugin file', '[API:PUT /api/config/plugins/file/:id] Failed:', 'file');
+    }
+  });
+
+  app.delete('/api/config/plugins/file/:id', async (req, res) => {
+    try {
+      const directory = await resolveDirectory(req, res);
+      if (directory === null && res.headersSent) return;
+      validateFileId(req.params.id);
+
+      await completePluginMutation(res, 'file deletion', 'file', () => {
+        deletePluginDirFile(req.params.id, directory);
+      });
+    } catch (error) {
+      return handlePluginError(res, error, 'Failed to delete plugin file', '[API:DELETE /api/config/plugins/file/:id] Failed:', 'file');
+    }
+  });
+};