@vantran-se/openchamber-web 2.0.6 → 2.0.8

package/bin/lib/DOCUMENTATION.md

@@ -127,6 +127,7 @@ These modules hold reusable, non-presentational logic for commands.
 
 - `cli-startup.js`
   - Native startup service detection, install/uninstall/status helpers, and platform-specific startup command execution.
+  - Installed startup services remain owned by their platform service manager. `startup start|stop|restart` controls that manager directly. Top-level lifecycle commands route the service's configured port through the same manager, and `update` restarts it after package installation instead of starting a duplicate daemon.
 
 - `cli-tunnel-profiles.js`
   - Tunnel profile normalization, token resolution/redaction, profile storage, migration, file-permission warnings, and managed-remote pair persistence.

package/bin/lib/cli-args.js

@@ -674,6 +674,9 @@ SUBCOMMANDS:
   status      Show startup integration status
   enable      Install and start native user startup integration
   disable     Stop and remove native user startup integration
+  start       Start the installed startup service
+  stop        Stop the installed startup service
+  restart     Restart the installed startup service
 
 OPTIONS:
   -p, --port              Web server port used by startup service

package/bin/lib/cli-lifecycle.js

@@ -234,6 +234,7 @@ async function discoverRunningInstances(options = {}) {
         mtime,
         startedAt,
         launchMode,
+        startupService: storedOptions?.startupService === true,
         runtime: liveInfo.runtime,
         source: 'registry+probe',
         host: typeof confirmedHost === 'string' && confirmedHost.length > 0

package/bin/lib/cli-process.js

@@ -60,6 +60,7 @@ function writeInstanceOptions(instanceFilePath, options, onNotice) {
       uiPassword: typeof options.uiPassword === 'string' ? options.uiPassword : undefined,
       hasUiPassword: typeof options.uiPassword === 'string',
       apiOnly: options.apiOnly === true,
+      startupService: process.env.OPENCHAMBER_STARTUP_SERVICE === '1',
       startedAt: Number.isFinite(options.startedAt) ? options.startedAt : Date.now(),
     };
     fs.writeFileSync(instanceFilePath, JSON.stringify(toStore, null, 2), { mode: 0o600 });

package/bin/lib/cli-startup.js

@@ -91,6 +91,7 @@ function collectStartupEnv(options = {}) {
       env.OPENCODE_BINARY = opencodeBinary.trim();
     }
   }
+  env.OPENCHAMBER_STARTUP_SERVICE = '1';
   const uiPassword = hasUiPasswordConfigured(options.uiPassword) ? options.uiPassword : undefined;
   if (uiPassword) {
     env.OPENCHAMBER_UI_PASSWORD = uiPassword;
@@ -329,6 +330,17 @@ function getUserLingerEnabled(user) {
   return parseLingerState(result.stdout);
 }
 
+function startupServicePort(servicePath) {
+  try {
+    const content = fs.readFileSync(servicePath, 'utf8');
+    const match = content.match(/(?:--port(?:&quot;|"|')?\s+(?:&quot;|"|')?|<string>--port<\/string>\s*<string>)(\d+)/);
+    const port = Number.parseInt(match?.[1] || '', 10);
+    return Number.isInteger(port) && port > 0 ? port : DEFAULT_PORT;
+  } catch {
+    return DEFAULT_PORT;
+  }
+}
+
 function getStartupStatus() {
   const paths = getStartupServicePaths();
   if (!paths.servicePath) {
@@ -336,7 +348,14 @@ function getStartupStatus() {
   }
   if (paths.platform === 'windows') {
     const result = runStartupCommand('schtasks.exe', ['/Query', '/TN', STARTUP_SERVICE_ID], { allowFailure: true });
-    return { supported: true, platform: paths.platform, enabled: result.status === 0, active: null, servicePath: paths.servicePath };
+    return {
+      supported: true,
+      platform: paths.platform,
+      enabled: result.status === 0,
+      active: null,
+      servicePath: paths.servicePath,
+      port: startupServicePort(getWindowsStartupWrapperPath()),
+    };
   }
   if (paths.platform === 'linux') {
     const enabledResult = runStartupCommand('systemctl', ['--user', 'is-enabled', 'openchamber.service'], { allowFailure: true });
@@ -350,6 +369,7 @@ function getStartupStatus() {
       active: activeState === 'active',
       activeState,
       servicePath: paths.servicePath,
+      port: startupServicePort(paths.servicePath),
       lingerEnabled: getUserLingerEnabled(lingerUser),
       lingerUser: lingerUser || null,
     };
@@ -360,6 +380,7 @@ function getStartupStatus() {
     enabled: fs.existsSync(paths.servicePath),
     active: null,
     servicePath: paths.servicePath,
+    port: startupServicePort(paths.servicePath),
   };
 }
 
@@ -430,10 +451,41 @@ function disableStartupService() {
   return getStartupStatus();
 }
 
+function controlStartupService(action) {
+  const status = getStartupStatus();
+  if (!status.supported || !status.enabled) {
+    throw new TunnelCliError('OpenChamber startup service is not installed.', EXIT_CODE.USAGE_ERROR);
+  }
+  if (!['start', 'stop', 'restart'].includes(action)) {
+    throw new TunnelCliError(`Unsupported startup service action: ${action}`, EXIT_CODE.USAGE_ERROR);
+  }
+  if (status.platform === 'linux') {
+    runStartupCommand('systemctl', ['--user', action, 'openchamber.service']);
+  } else if (status.platform === 'macos') {
+    const domain = `gui/${process.getuid()}`;
+    const target = `${domain}/${STARTUP_SERVICE_ID}`;
+    if (action === 'stop') {
+      runStartupCommand('/bin/launchctl', ['bootout', target], { allowFailure: true });
+    } else {
+      runStartupCommand('/bin/launchctl', ['bootout', target], { allowFailure: true });
+      runStartupCommand('/bin/launchctl', ['bootstrap', domain, status.servicePath]);
+      runStartupCommand('/bin/launchctl', ['kickstart', '-k', target]);
+    }
+  } else if (status.platform === 'windows') {
+    if (action !== 'start') runStartupCommand('schtasks.exe', ['/End', '/TN', STARTUP_SERVICE_ID], { allowFailure: true });
+    if (action !== 'stop') runStartupCommand('schtasks.exe', ['/Run', '/TN', STARTUP_SERVICE_ID]);
+  }
+  return getStartupStatus();
+}
+
+const restartStartupService = () => controlStartupService('restart');
 
 export {
   getStartupStatus,
+  startupServicePort,
   enableStartupService,
   disableStartupService,
+  controlStartupService,
+  restartStartupService,
   buildWindowsStartupTaskCommand,
 };

package/bin/lib/cli-startup.test.js

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { describe, expect, it } from 'vitest';
+
+import { startupServicePort } from './cli-startup.js';
+
+function withServiceFile(content, run) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-startup-test-'));
+  const servicePath = path.join(dir, 'service');
+  fs.writeFileSync(servicePath, content);
+  try {
+    return run(servicePath);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+describe('startup service metadata', () => {
+  it('reads the configured port from a systemd unit', () => {
+    withServiceFile('ExecStart="/node" "/openchamber" "serve" "--foreground" "--port" "3069"\n', (servicePath) => {
+      expect(startupServicePort(servicePath)).toBe(3069);
+    });
+  });
+
+  it('reads the configured port from a launchd plist', () => {
+    withServiceFile('<string>--port</string>\n<string>3070</string>\n', (servicePath) => {
+      expect(startupServicePort(servicePath)).toBe(3070);
+    });
+  });
+
+  it('reads the configured port from the Windows startup wrapper', () => {
+    withServiceFile("& 'openchamber' 'serve' '--foreground' '--port' '3071'\n", (servicePath) => {
+      expect(startupServicePort(servicePath)).toBe(3071);
+    });
+  });
+});

package/bin/lib/commands-lifecycle.js

@@ -1,6 +1,7 @@
 import { EXIT_CODE, TunnelCliError } from './cli-errors.js';
 import { requestServerShutdown } from './cli-http.js';
 import { isPortAvailable } from './cli-ports.js';
+import { controlStartupService, getStartupStatus } from './cli-startup.js';
 import {
   discoverLifecycleInstances,
   discoverUnconfirmedRegistryInstanceOnPort,
@@ -24,6 +25,7 @@ import {
 } from '../cli-output.js';
 
 async function stopCommand(options) {
+    const startupStatus = getStartupStatus();
     const showOutput = shouldRenderHumanOutput(options);
     const suppressQuietOutput = options?.suppressQuietOutput === true;
     const jsonResults = [];
@@ -75,6 +77,17 @@ async function stopCommand(options) {
       }
 
       const explicitInstance = runningInstances[0];
+      if (startupStatus.enabled && startupStatus.port === explicitInstance.port && explicitInstance.startupService === true) {
+        controlStartupService('stop');
+        jsonResults.push({ port: explicitInstance.port, stopped: true, manager: startupStatus.platform });
+        if (isJsonMode(options)) printJson({ stoppedCount: 1, results: jsonResults });
+        else if (showOutput) {
+          logStatus('success', `stopped startup service on port ${explicitInstance.port}`);
+          finish('stop complete');
+        }
+        printQuietStopResults();
+        return;
+      }
       if (explicitInstance.runtime === 'desktop') {
         jsonResults.push({ port: options.port, runtime: 'desktop', stopped: false, reason: 'desktop-managed' });
         if (isJsonMode(options)) {
@@ -210,6 +223,11 @@ async function stopCommand(options) {
     }
 
     for (const instance of runningInstances) {
+      if (startupStatus.enabled && startupStatus.port === instance.port && instance.startupService === true) {
+        controlStartupService('stop');
+        jsonResults.push({ port: instance.port, stopped: true, manager: startupStatus.platform });
+        continue;
+      }
       const stopSpin = showOutput ? createSpinner(options) : null;
       if (showOutput && !stopSpin) {
         logStatus('info', `stopping port ${instance.port} (PID: ${instance.pid})`);
@@ -287,7 +305,13 @@ async function restartCommand(options, serveCommand) {
       return;
     }
 
+    const startupStatus = getStartupStatus();
     for (const instance of runningInstances) {
+      if (startupStatus.enabled && startupStatus.port === instance.port && instance.startupService === true) {
+        controlStartupService('restart');
+        restarted.push({ fromPort: instance.port, toPort: instance.port, manager: startupStatus.platform });
+        continue;
+      }
       if (instance.runtime === 'desktop') {
         const message = `Port ${instance.port} is managed by OpenChamber Desktop and cannot be restarted with this command.`;
         if (isJsonMode(options)) {
@@ -316,6 +340,11 @@ async function restartCommand(options, serveCommand) {
       const isForeground = launchMode === 'foreground';
 
       const restartPort = options.explicitPort ? options.port : instance.port;
+      if (isForeground) {
+        restarted.push({ fromPort: instance.port, toPort: restartPort, launchMode, ok: false, reason: 'manual-foreground' });
+        if (showOutput) logStatus('warning', `foreground OpenChamber on port ${instance.port} requires its owning terminal or process manager to restart it`);
+        continue;
+      }
 
       const restartSpin = showOutput ? createSpinner(options) : null;
       if (showOutput && !restartSpin) {
@@ -331,19 +360,6 @@ async function restartCommand(options, serveCommand) {
           suppressQuietOutput: true,
         });
 
-        // Foreground instances are managed by a process manager (systemd,
-        // Docker, etc.) that will restart them automatically after stop.
-        // Do not call serve() here — just record the stop as a successful
-        // restart and let the process manager handle the actual restart.
-        if (isForeground) {
-          restarted.push({ fromPort: instance.port, toPort: restartPort, launchMode, ok: true });
-          restartSpin?.stop(`Stopped foreground instance on port ${instance.port} (process manager will restart)`);
-          if (showOutput && !restartSpin) {
-            logStatus('success', `port ${instance.port} stopped`, 'process manager will restart');
-          }
-          continue;
-        }
-
         await new Promise((resolve) => setTimeout(resolve, 500));
 
         const restartedPort = await runServe({

package/bin/lib/commands-startup.js

@@ -1,5 +1,5 @@
 import { EXIT_CODE, TunnelCliError } from './cli-errors.js';
-import { getStartupStatus, enableStartupService, disableStartupService } from './cli-startup.js';
+import { getStartupStatus, enableStartupService, disableStartupService, controlStartupService } from './cli-startup.js';
 import {
   intro as clackIntro,
   outro as clackOutro,
@@ -13,8 +13,9 @@ async function startupCommand(options, action = 'status', dependencies = {}) {
   const getStatus = dependencies.getStartupStatus || getStartupStatus;
   const enableService = dependencies.enableStartupService || enableStartupService;
   const disableService = dependencies.disableStartupService || disableStartupService;
+  const controlService = dependencies.controlStartupService || controlStartupService;
   const normalized = typeof action === 'string' ? action.trim().toLowerCase() : 'status';
-  if (!['status', 'enable', 'disable'].includes(normalized)) {
+  if (!['status', 'enable', 'disable', 'start', 'stop', 'restart'].includes(normalized)) {
     throw new TunnelCliError(
       `Unknown startup subcommand '${action}'. Use 'openchamber startup --help'.`,
       EXIT_CODE.USAGE_ERROR
@@ -26,6 +27,8 @@ async function startupCommand(options, action = 'status', dependencies = {}) {
     status = enableService(options);
   } else if (normalized === 'disable') {
     status = disableService();
+  } else if (normalized === 'start' || normalized === 'stop' || normalized === 'restart') {
+    status = controlService(normalized);
   } else {
     status = getStatus();
   }

package/bin/lib/commands-startup.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { startupCommand } from './commands-startup.js';
+
+const quiet = { quiet: true };
+
+describe('startup command service controls', () => {
+  for (const action of ['start', 'stop', 'restart']) {
+    it(`${action}s the installed startup service without changing installation`, async () => {
+      const controlStartupService = vi.fn(() => ({ supported: true, enabled: true, active: action !== 'stop', platform: 'linux' }));
+      await startupCommand(quiet, action, { controlStartupService });
+      expect(controlStartupService).toHaveBeenCalledWith(action);
+    });
+  }
+});

package/bin/lib/commands-update.js

@@ -1,5 +1,6 @@
 import { requestServerShutdown } from './cli-http.js';
-import { discoverRunningInstances } from './cli-lifecycle.js';
+import { discoverRunningInstances as discoverRunningInstancesDefault } from './cli-lifecycle.js';
+import { getStartupStatus as getStartupStatusDefault, restartStartupService as restartStartupServiceDefault } from './cli-startup.js';
 import {
   readInstanceOptions,
   removePidFile,
@@ -16,7 +17,27 @@ import {
   logStatus,
 } from '../cli-output.js';
 
-function createUpdateCommand({ importFromFilePath, packageManagerPath, serveCommand }) {
+export function partitionUpdateInstances(instances, readOptions = readInstanceOptions, startupStatus = null) {
+  const managed = [];
+  const startup = [];
+  const foreground = [];
+  for (const instance of instances) {
+    const options = readOptions(instance.instanceFilePath) || {};
+    if (options.launchMode !== 'foreground') managed.push(instance);
+    else if (startupStatus?.enabled && startupStatus.port === instance.port && instance.startupService === true) startup.push(instance);
+    else foreground.push(instance);
+  }
+  return { managed, startup, foreground };
+}
+
+function createUpdateCommand({
+  importFromFilePath,
+  packageManagerPath,
+  serveCommand,
+  discoverRunningInstances = discoverRunningInstancesDefault,
+  getStartupStatus = getStartupStatusDefault,
+  restartStartupService = restartStartupServiceDefault,
+}) {
   return async function updateCommand(options = {}) {
     const showOutput = shouldRenderHumanOutput(options);
     const updateSpin = createSpinner(options);
@@ -29,6 +50,12 @@ function createUpdateCommand({ importFromFilePath, packageManagerPath, serveComm
     } = await importFromFilePath(packageManagerPath);
 
     const runningInstances = await discoverRunningInstances();
+    const startupStatus = getStartupStatus();
+    const { managed: managedInstances, startup: startupInstances } = partitionUpdateInstances(
+      runningInstances,
+      readInstanceOptions,
+      startupStatus,
+    );
     const currentVersion = getCurrentVersion();
 
     if (showOutput) {
@@ -75,9 +102,9 @@ function createUpdateCommand({ importFromFilePath, packageManagerPath, serveComm
     }
     updateSpin?.message(`Updating to ${updateInfo.version || 'latest'}...`);
 
-    if (runningInstances.length > 0) {
-      updateSpin?.message(`Stopping ${runningInstances.length} running instance(s)...`);
-      for (const instance of runningInstances) {
+    if (managedInstances.length > 0) {
+      updateSpin?.message(`Stopping ${managedInstances.length} running instance(s)...`);
+      for (const instance of managedInstances) {
         try {
           const requested = await requestServerShutdown(instance.port, instance.host);
           await stopInstanceProcess(instance.pid, {
@@ -101,9 +128,14 @@ function createUpdateCommand({ importFromFilePath, packageManagerPath, serveComm
       throw new Error(`Update failed with exit code ${result.exitCode}`);
     }
 
-    if (runningInstances.length > 0) {
-      updateSpin?.message(`Restarting ${runningInstances.length} instance(s)...`);
-      for (const instance of runningInstances) {
+    if (startupInstances.length > 0) {
+      updateSpin?.message('Restarting startup service...');
+      restartStartupService();
+    }
+
+    if (managedInstances.length > 0) {
+      updateSpin?.message(`Restarting ${managedInstances.length} instance(s)...`);
+      for (const instance of managedInstances) {
         const storedOptions = readInstanceOptions(instance.instanceFilePath) || { port: instance.port };
         await serveCommand({
           port: storedOptions.port || instance.port,

package/bin/lib/commands-update.test.js

@@ -3,7 +3,7 @@ import os from 'os';
 import path from 'path';
 import { describe, expect, it, vi } from 'vitest';
 
-import { createUpdateCommand } from './commands-update.js';
+import { createUpdateCommand, partitionUpdateInstances } from './commands-update.js';
 
 async function withTempOpenChamberDataDir(fn) {
   const previous = process.env.OPENCHAMBER_DATA_DIR;
@@ -12,16 +12,63 @@ async function withTempOpenChamberDataDir(fn) {
   try {
     return await fn(dir);
   } finally {
-    if (typeof previous === 'string') {
-      process.env.OPENCHAMBER_DATA_DIR = previous;
-    } else {
-      delete process.env.OPENCHAMBER_DATA_DIR;
-    }
+    if (previous === undefined) delete process.env.OPENCHAMBER_DATA_DIR;
+    else process.env.OPENCHAMBER_DATA_DIR = previous;
     fs.rmSync(dir, { recursive: true, force: true });
   }
 }
 
 describe('update command', () => {
+  it('separates CLI daemons from the installed startup service', () => {
+    const daemon = { port: 3000, instanceFilePath: '/daemon.json' };
+    const startup = { port: 3069, instanceFilePath: '/startup.json', startupService: true };
+    const manualForeground = { port: 3070, instanceFilePath: '/manual.json' };
+    const readOptions = vi.fn((filePath) => ({
+      launchMode: filePath === daemon.instanceFilePath ? 'daemon' : 'foreground',
+    }));
+
+    expect(partitionUpdateInstances(
+      [daemon, startup, manualForeground],
+      readOptions,
+      { enabled: true, active: true, port: 3069 },
+    )).toEqual({
+      managed: [daemon],
+      startup: [startup],
+      foreground: [manualForeground],
+    });
+  });
+
+  it('restarts the installed startup service after updating', async () => {
+    await withTempOpenChamberDataDir(async (dir) => {
+      const originalWrite = process.stdout.write;
+      process.stdout.write = vi.fn(() => true);
+      const instanceFilePath = path.join(dir, 'run', 'openchamber-3069.json');
+      fs.mkdirSync(path.dirname(instanceFilePath), { recursive: true });
+      fs.writeFileSync(instanceFilePath, JSON.stringify({ port: 3069, launchMode: 'foreground' }));
+      const restartStartupService = vi.fn();
+      const updateCommand = createUpdateCommand({
+        packageManagerPath: '/fake/package-manager.js',
+        serveCommand: vi.fn(),
+        discoverRunningInstances: vi.fn(async () => [{ port: 3069, instanceFilePath, startupService: true }]),
+        getStartupStatus: vi.fn(() => ({ supported: true, enabled: true, active: true, port: 3069 })),
+        restartStartupService,
+        importFromFilePath: vi.fn(async () => ({
+          checkForUpdates: vi.fn(async () => ({ available: true, version: '9.9.9' })),
+          detectPackageManager: vi.fn(() => 'npm'),
+          executeUpdate: vi.fn(() => ({ success: true, exitCode: 0 })),
+          getCurrentVersion: vi.fn(() => '1.0.0'),
+        })),
+      });
+
+      try {
+        await updateCommand({ json: true });
+        expect(restartStartupService).toHaveBeenCalledTimes(1);
+      } finally {
+        process.stdout.write = originalWrite;
+      }
+    });
+  });
+
   it('uses the package-manager helpers on the update-available path', async () => {
     await withTempOpenChamberDataDir(async () => {
       const originalWrite = process.stdout.write;

package/dist/assets/{CodeMirrorCommentWidgets-BlzB2e0C.js → CodeMirrorCommentWidgets--j227ElB.js}

@@ -1 +1 @@
-import{j as a}from"./vendor-react-BUCujlKS.js";import{I as l,a as I}from"./useInlineCommentController-Bb9Gjz1Q.js";function E(g){const{drafts:x,editingDraftId:d,commentText:o,onTextChange:r,selection:n,isDragging:u,fileLabel:s,newWidgetId:f,mapDraftToRange:p,onSave:m,onCancel:c,onEdit:C,onDelete:h}=g,t=[];for(const e of x){const i=p(e);if(e.id===d){t.push({afterLine:i.end,id:`edit-${e.id}`,content:a.jsx(l,{initialText:o,onTextChange:r,fileLabel:s,lineRange:i,isEditing:!0,onSave:m,onCancel:c},`edit-${e.id}`)});continue}t.push({afterLine:i.end,id:`card-${e.id}`,content:a.jsx(I,{draft:e,onEdit:()=>C(e),onDelete:()=>h(e)},`card-${e.id}`)})}if(n&&!d&&!u){const e={...n,start:Math.min(n.start,n.end),end:Math.max(n.start,n.end)};t.push({afterLine:e.end,id:f,content:a.jsx(l,{initialText:o,onTextChange:r,fileLabel:s,lineRange:e,isEditing:!1,onSave:m,onCancel:c},f)})}return t}export{E as b};
+import{j as a}from"./vendor-react-BUCujlKS.js";import{I as l,a as I}from"./useInlineCommentController-dDUqIMI2.js";function E(g){const{drafts:x,editingDraftId:d,commentText:o,onTextChange:r,selection:n,isDragging:u,fileLabel:s,newWidgetId:f,mapDraftToRange:p,onSave:m,onCancel:c,onEdit:C,onDelete:h}=g,t=[];for(const e of x){const i=p(e);if(e.id===d){t.push({afterLine:i.end,id:`edit-${e.id}`,content:a.jsx(l,{initialText:o,onTextChange:r,fileLabel:s,lineRange:i,isEditing:!0,onSave:m,onCancel:c},`edit-${e.id}`)});continue}t.push({afterLine:i.end,id:`card-${e.id}`,content:a.jsx(I,{draft:e,onEdit:()=>C(e),onDelete:()=>h(e)},`card-${e.id}`)})}if(n&&!d&&!u){const e={...n,start:Math.min(n.start,n.end),end:Math.max(n.start,n.end)};t.push({afterLine:e.end,id:f,content:a.jsx(l,{initialText:o,onTextChange:r,fileLabel:s,lineRange:e,isEditing:!1,onSave:m,onCancel:c},f)})}return t}export{E as b};