v1.26.0

changelog.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 2026-05-09 - 1.26.0 - feat(dcrouter)
+add managed local dcrouter mode with status controls and gateway integration
+
+- Adds a ManagedDcRouterManager to provision and control a local dcrouter container with default gateway settings.
+- Updates gateway sync logic to support managed, external, and disabled dcrouter modes, including managed local route targets.
+- Exposes managed dcrouter status, start, stop, and restart operations through OpsServer typed requests.
+- Extends settings APIs and the settings UI to configure managed dcrouter ports, image, data directory, and mode selection.
+- Adjusts Onebox startup to prepare managed dcrouter settings, shift proxy ports when managed mode is active, and initialize the local gateway before route sync.
+
 ## 2026-05-09 - 1.25.0 - feat(external-gateway)
 add gateway client domain and DNS record support for dcrouter integration
 

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/onebox",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "exports": "./mod.ts",
   "tasks": {
     "test": "deno test --allow-all test/",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/onebox",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "Self-hosted container platform with automatic SSL and DNS - a mini Heroku for single servers",
   "main": "mod.ts",
   "type": "module",

test/external_gateway_test.ts

@@ -164,6 +164,49 @@ Deno.test('ExternalGatewayManager syncs service routes to dcrouter gatewayClient
   assertEquals(syncRequest.requestData.enabled, true);
 });
 
+Deno.test('ExternalGatewayManager uses managed dcrouter local target in managed mode', async () => {
+  const oneboxRef = makeOneboxRef();
+  (oneboxRef as any).managedDcRouter = {
+    getMode: () => 'managed',
+    getGatewayUrl: () => 'http://127.0.0.1:3300',
+    getAdminToken: async () => 'dcr-managed-token',
+    ensureGatewayClientId: () => 'onebox-managed',
+    getRouteTarget: () => ({ host: 'onebox-smartproxy', port: 80 }),
+  };
+
+  const service: IService = {
+    id: 1,
+    name: 'hello',
+    image: 'nginx:latest',
+    envVars: {},
+    port: 3000,
+    domain: 'hello.example.com',
+    status: 'running',
+    createdAt: 1,
+    updatedAt: 1,
+  };
+
+  let syncRequest: Record<string, unknown> | null = null;
+  const manager = new ExternalGatewayManager(oneboxRef as any);
+  (manager as any).fireDcRouterRequest = async (method: string, requestData: Record<string, unknown>, config: any) => {
+    if (method === 'exportCertificate') {
+      return { success: false };
+    }
+    assertEquals(config.url, 'http://127.0.0.1:3300');
+    assertEquals(config.apiToken, 'dcr-managed-token');
+    syncRequest = requestData;
+    return { success: true, action: 'created', routeId: 'route-1' };
+  };
+
+  await manager.syncServiceRoute(service);
+
+  assert(syncRequest);
+  const route = (syncRequest as Record<string, unknown>).route as any;
+  const ownership = (syncRequest as Record<string, unknown>).ownership as any;
+  assertEquals(ownership.gatewayClientId, 'onebox-managed');
+  assertEquals(route.action.targets, [{ host: 'onebox-smartproxy', port: 80 }]);
+});
+
 Deno.test('ExternalGatewayManager deletes service routes through dcrouter gatewayClient API', async () => {
   const oneboxRef = makeOneboxRef();
   const manager = new ExternalGatewayManager(oneboxRef as any);

test/managed_dcrouter_test.ts

@@ -0,0 +1,54 @@
+import { assert, assertEquals } from '@std/assert';
+
+import { ManagedDcRouterManager } from '../ts/classes/managed-dcrouter.ts';
+
+class FakeDatabase {
+  public settings = new Map<string, string>();
+  public secretSettings = new Map<string, string>();
+
+  getSetting(key: string): string | null {
+    return this.settings.get(key) ?? null;
+  }
+
+  setSetting(key: string, value: string): void {
+    this.settings.set(key, value);
+  }
+
+  async getSecretSetting(key: string): Promise<string | null> {
+    return this.secretSettings.get(key) ?? null;
+  }
+
+  async setSecretSetting(key: string, value: string): Promise<void> {
+    this.secretSettings.set(key, value);
+  }
+}
+
+Deno.test('ManagedDcRouterManager persists default managed gateway settings', async () => {
+  const database = new FakeDatabase();
+  const manager = new ManagedDcRouterManager({ database } as any);
+
+  assertEquals(manager.getMode(), 'managed');
+
+  await manager.prepareGatewaySettings();
+
+  assertEquals(database.getSetting('dcrouterMode'), 'managed');
+  assertEquals(manager.getMode(), 'managed');
+  assertEquals(database.getSetting('dcrouterGatewayUrl'), 'http://127.0.0.1:3300');
+  assertEquals(database.getSetting('dcrouterTargetHost'), 'onebox-smartproxy');
+  assertEquals(database.getSetting('dcrouterTargetPort'), '80');
+  assert(database.getSetting('dcrouterGatewayClientId')?.startsWith('onebox-'));
+  assert((await database.getSecretSetting('dcrouterManagedAdminApiToken'))?.startsWith('dcr_'));
+});
+
+Deno.test('ManagedDcRouterManager keeps existing external gateway default external', async () => {
+  const database = new FakeDatabase();
+  database.setSetting('dcrouterGatewayUrl', 'https://edge.example.com');
+  const manager = new ManagedDcRouterManager({ database } as any);
+
+  assertEquals(manager.getMode(), 'external');
+
+  await manager.prepareGatewaySettings();
+
+  assertEquals(database.getSetting('dcrouterMode'), null);
+  assertEquals(database.getSetting('dcrouterTargetHost'), null);
+});

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/onebox',
-  version: '1.25.0',
+  version: '1.26.0',
   description: 'Self-hosted container platform with automatic SSL and DNS - a mini Heroku for single servers'
 }

ts/classes/external-gateway.ts

@@ -3,6 +3,7 @@ import { logger } from '../logging.ts';
 import { getErrorMessage } from '../utils/error.ts';
 import { OneboxDatabase } from './database.ts';
 import type { IDomain, IService } from '../types.ts';
+import type { TDcRouterMode } from './managed-dcrouter.ts';
 
 type TWorkHosterType = 'onebox';
 
@@ -124,6 +125,9 @@ export class ExternalGatewayManager {
   }
 
   public async isConfigured(): Promise<boolean> {
+    if (this.getMode() === 'disabled') {
+      return false;
+    }
     const config = await this.getConfig({ requireTarget: false });
     return Boolean(config);
   }
@@ -336,13 +340,24 @@ export class ExternalGatewayManager {
   }
 
   private async getConfig(options: { requireTarget?: boolean } = {}): Promise<IExternalGatewayConfig | null> {
-    const url = this.normalizeUrl(this.database.getSetting('dcrouterGatewayUrl') || '');
-    const apiToken = await this.database.getSecretSetting('dcrouterGatewayApiToken');
+    const mode = this.getMode();
+    if (mode === 'disabled') {
+      return null;
+    }
+
+    const url = mode === 'managed'
+      ? this.oneboxRef.managedDcRouter.getGatewayUrl()
+      : this.normalizeUrl(this.database.getSetting('dcrouterGatewayUrl') || '');
+    const apiToken = mode === 'managed'
+      ? await this.oneboxRef.managedDcRouter.getAdminToken()
+      : await this.database.getSecretSetting('dcrouterGatewayApiToken');
     if (!url || !apiToken) {
       return null;
     }
 
-    const gatewayClientId = this.ensureGatewayClientId();
+    const gatewayClientId = mode === 'managed'
+      ? this.oneboxRef.managedDcRouter.ensureGatewayClientId()
+      : this.ensureGatewayClientId();
     const config: IExternalGatewayConfig = {
       url,
       apiToken,
@@ -351,6 +366,11 @@ export class ExternalGatewayManager {
     };
 
     if (options.requireTarget !== false) {
+      if (mode === 'managed') {
+        const target = this.oneboxRef.managedDcRouter.getRouteTarget();
+        config.targetHost = target.host;
+        config.targetPort = target.port;
+      } else {
         config.targetHost = this.database.getSetting('dcrouterTargetHost')
           || this.database.getSetting('serverIP')
           || undefined;
@@ -360,6 +380,7 @@ export class ExternalGatewayManager {
             || '80',
         );
         config.targetPort = targetPort;
+      }
 
       if (!config.targetHost) {
         throw new Error('dcrouterTargetHost or serverIP must be configured for external gateway route sync');
@@ -369,6 +390,10 @@ export class ExternalGatewayManager {
     return config;
   }
 
+  private getMode(): TDcRouterMode {
+    return this.oneboxRef.managedDcRouter?.getMode?.() || 'external';
+  }
+
   private async requireConfig(options: { requireTarget?: boolean } = {}): Promise<IExternalGatewayConfig> {
     const config = await this.getConfig(options);
     if (!config) {

ts/classes/managed-dcrouter.ts

@@ -0,0 +1,332 @@
+import * as plugins from '../plugins.ts';
+import { logger } from '../logging.ts';
+import { getErrorMessage } from '../utils/error.ts';
+import { OneboxDatabase } from './database.ts';
+
+export type TDcRouterMode = 'managed' | 'external' | 'disabled';
+
+export interface IManagedDcRouterStatus {
+  mode: TDcRouterMode;
+  configured: boolean;
+  running: boolean;
+  healthy: boolean;
+  containerId?: string;
+  image: string;
+  gatewayUrl: string;
+  opsPort: number;
+  httpPort: number;
+  httpsPort: number;
+  message?: string;
+}
+
+const containerName = 'onebox-dcrouter';
+const defaultImage = 'code.foss.global/serve.zone/dcrouter:latest';
+const defaultDataDir = './.nogit/dcrouter-data';
+const defaultOpsPort = 3300;
+const defaultHttpPort = 80;
+const defaultHttpsPort = 443;
+const internalBaseDir = '/data';
+
+export class ManagedDcRouterManager {
+  private database: OneboxDatabase;
+  private dockerClient: InstanceType<typeof plugins.docker.Docker> | null = null;
+
+  constructor(private oneboxRef: any) {
+    this.database = oneboxRef.database;
+  }
+
+  public getMode(): TDcRouterMode {
+    const storedMode = this.database.getSetting('dcrouterMode');
+    if (storedMode === 'managed' || storedMode === 'external' || storedMode === 'disabled') {
+      return storedMode;
+    }
+
+    const hasExternalGateway = Boolean(this.database.getSetting('dcrouterGatewayUrl'));
+    return hasExternalGateway ? 'external' : 'managed';
+  }
+
+  public getImage(): string {
+    return this.database.getSetting('dcrouterManagedImage') || defaultImage;
+  }
+
+  public getOpsPort(): number {
+    return this.parsePort(this.database.getSetting('dcrouterManagedOpsPort'), defaultOpsPort);
+  }
+
+  public getHttpPort(): number {
+    return this.parsePort(this.database.getSetting('dcrouterManagedHttpPort'), defaultHttpPort);
+  }
+
+  public getHttpsPort(): number {
+    return this.parsePort(this.database.getSetting('dcrouterManagedHttpsPort'), defaultHttpsPort);
+  }
+
+  public getDataDir(): string {
+    return this.database.getSetting('dcrouterManagedDataDir') || defaultDataDir;
+  }
+
+  public getGatewayUrl(): string {
+    return `http://127.0.0.1:${this.getOpsPort()}`;
+  }
+
+  public getRouteTarget(): { host: string; port: number } {
+    return {
+      host: 'onebox-smartproxy',
+      port: 80,
+    };
+  }
+
+  public ensureGatewayClientId(): string {
+    let gatewayClientId = this.database.getSetting('dcrouterGatewayClientId')
+      || this.database.getSetting('dcrouterWorkHosterId');
+    if (!gatewayClientId) {
+      gatewayClientId = `onebox-${crypto.randomUUID()}`;
+      this.database.setSetting('dcrouterGatewayClientId', gatewayClientId);
+    }
+    return gatewayClientId;
+  }
+
+  public async getAdminToken(): Promise<string> {
+    const existingToken = await this.database.getSecretSetting('dcrouterManagedAdminApiToken');
+    if (existingToken) {
+      return existingToken;
+    }
+
+    const token = `dcr_${crypto.randomUUID().replaceAll('-', '')}${crypto.randomUUID().replaceAll('-', '')}`;
+    await this.database.setSecretSetting('dcrouterManagedAdminApiToken', token);
+    return token;
+  }
+
+  public async prepareGatewaySettings(): Promise<void> {
+    if (this.getMode() !== 'managed') {
+      return;
+    }
+
+    const target = this.getRouteTarget();
+    this.database.setSetting('dcrouterMode', 'managed');
+    this.database.setSetting('dcrouterGatewayUrl', this.getGatewayUrl());
+    this.database.setSetting('dcrouterTargetHost', target.host);
+    this.database.setSetting('dcrouterTargetPort', String(target.port));
+    this.ensureGatewayClientId();
+    await this.getAdminToken();
+  }
+
+  public async init(): Promise<void> {
+    if (this.getMode() === 'managed') {
+      await this.start();
+      return;
+    }
+
+    await this.stop();
+  }
+
+  public async start(options: { recreate?: boolean } = {}): Promise<IManagedDcRouterStatus> {
+    if (this.getMode() !== 'managed') {
+      throw new Error('Managed dcrouter mode is not enabled');
+    }
+
+    await this.prepareGatewaySettings();
+    await this.ensureDockerClient();
+
+    if (options.recreate) {
+      await this.removeExistingContainer();
+    }
+
+    const existingContainer = await this.getExistingContainer();
+    if (existingContainer) {
+      if (this.isContainerRunning(existingContainer)) {
+        await this.waitForReady().catch((error) => {
+          logger.warn(`Managed dcrouter readiness check failed: ${getErrorMessage(error)}`);
+        });
+        return await this.getStatus();
+      }
+
+      await this.startContainer(existingContainer.Id);
+      await this.waitForReady();
+      return await this.getStatus();
+    }
+
+    await this.createContainer();
+    await this.waitForReady();
+    return await this.getStatus();
+  }
+
+  public async stop(): Promise<IManagedDcRouterStatus> {
+    await this.ensureDockerClient();
+    const existingContainer = await this.getExistingContainer();
+    if (existingContainer && this.isContainerRunning(existingContainer)) {
+      await this.stopContainer(existingContainer.Id);
+    }
+    return await this.getStatus();
+  }
+
+  public async restart(): Promise<IManagedDcRouterStatus> {
+    return await this.start({ recreate: true });
+  }
+
+  public async getStatus(): Promise<IManagedDcRouterStatus> {
+    const baseStatus: IManagedDcRouterStatus = {
+      mode: this.getMode(),
+      configured: this.getMode() === 'managed',
+      running: false,
+      healthy: false,
+      image: this.getImage(),
+      gatewayUrl: this.getGatewayUrl(),
+      opsPort: this.getOpsPort(),
+      httpPort: this.getHttpPort(),
+      httpsPort: this.getHttpsPort(),
+    };
+
+    try {
+      await this.ensureDockerClient();
+      const existingContainer = await this.getExistingContainer();
+      if (!existingContainer) {
+        return baseStatus;
+      }
+
+      const running = this.isContainerRunning(existingContainer);
+      return {
+        ...baseStatus,
+        running,
+        healthy: running ? await this.checkHealthy() : false,
+        containerId: existingContainer.Id,
+      };
+    } catch (error) {
+      return {
+        ...baseStatus,
+        message: getErrorMessage(error),
+      };
+    }
+  }
+
+  private async ensureDockerClient(): Promise<void> {
+    if (!this.dockerClient) {
+      this.dockerClient = new plugins.docker.Docker({
+        socketPath: 'unix:///var/run/docker.sock',
+      });
+      await this.dockerClient.start();
+    }
+  }
+
+  private parsePort(value: string | null, fallback: number): number {
+    if (!value) return fallback;
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      return fallback;
+    }
+    return port;
+  }
+
+  private async getAbsoluteDataDir(): Promise<string> {
+    const dataDir = plugins.path.resolve(this.getDataDir());
+    await Deno.mkdir(dataDir, { recursive: true });
+    return dataDir;
+  }
+
+  private async createContainer(): Promise<void> {
+    const image = this.getImage();
+    const token = await this.getAdminToken();
+    const dataDir = await this.getAbsoluteDataDir();
+
+    await this.oneboxRef.docker.pullImage(image);
+
+    const response = await this.dockerClient!.request('POST', `/containers/create?name=${containerName}`, {
+      Image: image,
+      Env: [
+        `DCROUTER_BASE_DIR=${internalBaseDir}`,
+        `DCROUTER_ADMIN_API_TOKEN=${token}`,
+        'DCROUTER_ADMIN_API_TOKEN_NAME=Onebox Managed Admin Token',
+      ],
+      Labels: {
+        'managed-by': 'onebox',
+        'onebox-type': 'dcrouter',
+      },
+      ExposedPorts: {
+        '80/tcp': {},
+        '443/tcp': {},
+        '3000/tcp': {},
+      },
+      HostConfig: {
+        NetworkMode: 'onebox-network',
+        RestartPolicy: {
+          Name: 'unless-stopped',
+        },
+        Binds: [`${dataDir}:${internalBaseDir}`],
+        PortBindings: {
+          '80/tcp': [{ HostIp: '0.0.0.0', HostPort: String(this.getHttpPort()) }],
+          '443/tcp': [{ HostIp: '0.0.0.0', HostPort: String(this.getHttpsPort()) }],
+          '3000/tcp': [{ HostIp: '127.0.0.1', HostPort: String(this.getOpsPort()) }],
+        },
+      },
+    });
+
+    if (response.statusCode >= 300) {
+      throw new Error(`Failed to create managed dcrouter container: HTTP ${response.statusCode} - ${JSON.stringify(response.body)}`);
+    }
+
+    await this.startContainer(response.body.Id);
+    logger.success(`Managed dcrouter container started: ${response.body.Id}`);
+  }
+
+  private async getExistingContainer(): Promise<any | null> {
+    const filters = encodeURIComponent(JSON.stringify({ name: [containerName] }));
+    const response = await this.dockerClient!.request('GET', `/containers/json?all=true&filters=${filters}`, {});
+    if (response.statusCode >= 300 || !Array.isArray(response.body)) {
+      return null;
+    }
+
+    return response.body.find((container: any) => {
+      return container.Names?.some((name: string) => name === `/${containerName}` || name === containerName);
+    }) ?? null;
+  }
+
+  private isContainerRunning(container: any): boolean {
+    return container.State === 'running' || Boolean(container.Status?.toLowerCase().startsWith('up '));
+  }
+
+  private async startContainer(containerId: string): Promise<void> {
+    const response = await this.dockerClient!.request('POST', `/containers/${containerId}/start`, {});
+    if (response.statusCode >= 300 && response.statusCode !== 304) {
+      throw new Error(`Failed to start managed dcrouter container: HTTP ${response.statusCode}`);
+    }
+  }
+
+  private async stopContainer(containerId: string): Promise<void> {
+    const response = await this.dockerClient!.request('POST', `/containers/${containerId}/stop`, {});
+    if (response.statusCode >= 300 && response.statusCode !== 304) {
+      throw new Error(`Failed to stop managed dcrouter container: HTTP ${response.statusCode}`);
+    }
+  }
+
+  private async removeExistingContainer(): Promise<void> {
+    const existingContainer = await this.getExistingContainer();
+    if (!existingContainer) {
+      return;
+    }
+
+    const response = await this.dockerClient!.request('DELETE', `/containers/${existingContainer.Id}?force=true`, {});
+    if (response.statusCode >= 300) {
+      throw new Error(`Failed to remove managed dcrouter container: HTTP ${response.statusCode}`);
+    }
+  }
+
+  private async checkHealthy(): Promise<boolean> {
+    try {
+      const response = await fetch(this.getGatewayUrl());
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  private async waitForReady(maxAttempts = 30, intervalMs = 1000): Promise<void> {
+    for (let i = 0; i < maxAttempts; i++) {
+      if (await this.checkHealthy()) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+
+    throw new Error('Managed dcrouter did not become ready in time');
+  }
+}

ts/classes/onebox.ts

@@ -25,6 +25,7 @@ import { ProxyLogReceiver } from './proxy-log-receiver.ts';
 import { BackupManager } from './backup-manager.ts';
 import { BackupScheduler } from './backup-scheduler.ts';
 import { ExternalGatewayManager } from './external-gateway.ts';
+import { ManagedDcRouterManager } from './managed-dcrouter.ts';
 import { OpsServer } from '../opsserver/index.ts';
 
 export class Onebox {
@@ -45,6 +46,7 @@ export class Onebox {
   public proxyLogReceiver: ProxyLogReceiver;
   public backupManager: BackupManager;
   public backupScheduler: BackupScheduler;
+  public managedDcRouter: ManagedDcRouterManager;
   public externalGateway: ExternalGatewayManager;
   public opsServer: OpsServer;
 
@@ -88,7 +90,8 @@ export class Onebox {
     // Initialize Backup scheduler
     this.backupScheduler = new BackupScheduler(this);
 
-    // Initialize optional dcrouter edge gateway integration
+    // Initialize optional dcrouter gateway integration
+    this.managedDcRouter = new ManagedDcRouterManager(this);
     this.externalGateway = new ExternalGatewayManager(this);
 
     // Initialize OpsServer (TypedRequest-based server)
@@ -111,6 +114,20 @@ export class Onebox {
       // Initialize Docker
       await this.docker.init();
 
+      try {
+        await this.managedDcRouter.prepareGatewaySettings();
+      } catch (error) {
+        logger.warn(`Managed dcrouter settings preparation failed: ${getErrorMessage(error)}`);
+      }
+
+      if (this.managedDcRouter.getMode() !== 'managed') {
+        try {
+          await this.managedDcRouter.stop();
+        } catch (error) {
+          logger.warn(`Failed to stop inactive managed dcrouter: ${getErrorMessage(error)}`);
+        }
+      }
+
       // Start proxy log receiver before reverse proxy startup.
       try {
         await this.proxyLogReceiver.start();
@@ -128,8 +145,9 @@ export class Onebox {
       // Start HTTP reverse proxy (non-critical - don't fail init if ports are busy)
       // Use 8080/8443 in dev mode to avoid permission issues
       const isDev = Deno.env.get('ONEBOX_DEV') === 'true' || Deno.args.includes('--ephemeral');
-      const httpPort = isDev ? 8080 : 80;
-      const httpsPort = isDev ? 8443 : 443;
+      const isManagedDcRouter = this.managedDcRouter.getMode() === 'managed';
+      const httpPort = isDev || isManagedDcRouter ? 8080 : 80;
+      const httpsPort = isDev || isManagedDcRouter ? 8443 : 443;
 
       try {
         await this.reverseProxy.startHttp(httpPort);
@@ -165,6 +183,14 @@ export class Onebox {
         logger.warn('Cloudflare domain sync initialization failed - domain sync will be limited');
       }
 
+      // Initialize managed local dcrouter before syncing delegated routes.
+      try {
+        await this.managedDcRouter.init();
+      } catch (error) {
+        logger.warn('Managed dcrouter initialization failed - local gateway sync will be disabled');
+        logger.warn(`Error: ${getErrorMessage(error)}`);
+      }
+
       // Initialize external dcrouter gateway (non-critical)
       try {
         await this.externalGateway.init();

ts/database/secret-settings.ts

@@ -7,6 +7,7 @@ const secretSettingAliases = {
   backupPassword: ['backup_encryption_password'],
   cloudflareToken: ['cloudflareAPIKey'],
   dcrouterGatewayApiToken: ['externalGatewayApiToken'],
+  dcrouterManagedAdminApiToken: [],
 } as const;
 
 type TCanonicalSecretSettingKey = keyof typeof secretSettingAliases;

ts/opsserver/classes.opsserver.ts

@@ -23,6 +23,7 @@ export class OpsServer {
   public backupsHandler!: handlers.BackupsHandler;
   public schedulesHandler!: handlers.SchedulesHandler;
   public settingsHandler!: handlers.SettingsHandler;
+  public managedDcRouterHandler!: handlers.ManagedDcRouterHandler;
   public logsHandler!: handlers.LogsHandler;
   public workspaceHandler!: handlers.WorkspaceHandler;
   public appStoreHandler!: handlers.AppStoreHandler;
@@ -66,6 +67,7 @@ export class OpsServer {
     this.backupsHandler = new handlers.BackupsHandler(this);
     this.schedulesHandler = new handlers.SchedulesHandler(this);
     this.settingsHandler = new handlers.SettingsHandler(this);
+    this.managedDcRouterHandler = new handlers.ManagedDcRouterHandler(this);
     this.logsHandler = new handlers.LogsHandler(this);
     this.workspaceHandler = new handlers.WorkspaceHandler(this);
     this.appStoreHandler = new handlers.AppStoreHandler(this);

ts/opsserver/handlers/index.ts

@@ -10,6 +10,7 @@ export * from './network.handler.ts';
 export * from './backups.handler.ts';
 export * from './schedules.handler.ts';
 export * from './settings.handler.ts';
+export * from './managed-dcrouter.handler.ts';
 export * from './logs.handler.ts';
 export * from './workspace.handler.ts';
 export * from './appstore.handler.ts';

ts/opsserver/handlers/managed-dcrouter.handler.ts

@@ -0,0 +1,59 @@
+import * as plugins from '../../plugins.ts';
+import type { OpsServer } from '../classes.opsserver.ts';
+import * as interfaces from '../../../ts_interfaces/index.ts';
+import { requireAdminIdentity } from '../helpers/guards.ts';
+
+export class ManagedDcRouterHandler {
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(private opsServerRef: OpsServer) {
+    this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+    this.registerHandlers();
+  }
+
+  private registerHandlers(): void {
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetManagedDcRouterStatus>(
+        'getManagedDcRouterStatus',
+        async (dataArg) => {
+          await requireAdminIdentity(this.opsServerRef.adminHandler, dataArg);
+          const status = await this.opsServerRef.oneboxRef.managedDcRouter.getStatus();
+          return { status };
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_StartManagedDcRouter>(
+        'startManagedDcRouter',
+        async (dataArg) => {
+          await requireAdminIdentity(this.opsServerRef.adminHandler, dataArg);
+          const status = await this.opsServerRef.oneboxRef.managedDcRouter.start();
+          return { status };
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_StopManagedDcRouter>(
+        'stopManagedDcRouter',
+        async (dataArg) => {
+          await requireAdminIdentity(this.opsServerRef.adminHandler, dataArg);
+          const status = await this.opsServerRef.oneboxRef.managedDcRouter.stop();
+          return { status };
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_RestartManagedDcRouter>(
+        'restartManagedDcRouter',
+        async (dataArg) => {
+          await requireAdminIdentity(this.opsServerRef.adminHandler, dataArg);
+          const status = await this.opsServerRef.oneboxRef.managedDcRouter.restart();
+          return { status };
+        },
+      ),
+    );
+  }
+}

ts/opsserver/handlers/settings.handler.ts

@@ -18,10 +18,17 @@ export class SettingsHandler {
     const cloudflareToken = await db.getSecretSetting('cloudflareToken');
     const dcrouterGatewayApiToken = await db.getSecretSetting('dcrouterGatewayApiToken');
     const settingsMap = db.getAllSettings();
+    const managedDcRouter = this.opsServerRef.oneboxRef.managedDcRouter;
 
     return {
       cloudflareToken: cloudflareToken || '',
       cloudflareZoneId: settingsMap['cloudflareZoneId'] || '',
+      dcrouterMode: managedDcRouter.getMode(),
+      dcrouterManagedImage: managedDcRouter.getImage(),
+      dcrouterManagedOpsPort: managedDcRouter.getOpsPort(),
+      dcrouterManagedHttpPort: managedDcRouter.getHttpPort(),
+      dcrouterManagedHttpsPort: managedDcRouter.getHttpsPort(),
+      dcrouterManagedDataDir: managedDcRouter.getDataDir(),
       dcrouterGatewayUrl: settingsMap['dcrouterGatewayUrl'] || '',
       dcrouterGatewayApiToken: dcrouterGatewayApiToken || '',
       dcrouterGatewayClientId: settingsMap['dcrouterGatewayClientId'] || settingsMap['dcrouterWorkHosterId'] || '',
@@ -69,8 +76,8 @@ export class SettingsHandler {
           }
 
           if (this.hasExternalGatewaySetting(updates)) {
-            this.refreshExternalGateway().catch((error) => {
-              logger.warn(`External gateway settings refresh failed: ${getErrorMessage(error)}`);
+            this.refreshDcRouterGateway().catch((error) => {
+              logger.warn(`dcrouter gateway settings refresh failed: ${getErrorMessage(error)}`);
             });
           }
 
@@ -105,6 +112,12 @@ export class SettingsHandler {
 
   private hasExternalGatewaySetting(settings: Partial<interfaces.data.ISettings>): boolean {
     return [
+      'dcrouterMode',
+      'dcrouterManagedImage',
+      'dcrouterManagedOpsPort',
+      'dcrouterManagedHttpPort',
+      'dcrouterManagedHttpsPort',
+      'dcrouterManagedDataDir',
       'dcrouterGatewayUrl',
       'dcrouterGatewayApiToken',
       'dcrouterGatewayClientId',
@@ -114,8 +127,14 @@ export class SettingsHandler {
     ].some((key) => Object.prototype.hasOwnProperty.call(settings, key));
   }
 
-  private async refreshExternalGateway(): Promise<void> {
+  private async refreshDcRouterGateway(): Promise<void> {
     const onebox = this.opsServerRef.oneboxRef;
+    if (onebox.managedDcRouter.getMode() === 'managed') {
+      await onebox.managedDcRouter.restart();
+    } else {
+      await onebox.managedDcRouter.stop();
+    }
+
     await onebox.externalGateway.syncDomains();
 
     const services = onebox.database.getAllServices().filter((service) => service.domain);

ts/types.ts

@@ -259,6 +259,12 @@ export interface IAppSettings {
   serverIP?: string;
   cloudflareToken?: string;
   cloudflareZoneId?: string;
+  dcrouterMode?: 'managed' | 'external' | 'disabled';
+  dcrouterManagedImage?: string;
+  dcrouterManagedOpsPort?: number;
+  dcrouterManagedHttpPort?: number;
+  dcrouterManagedHttpsPort?: number;
+  dcrouterManagedDataDir?: string;
   dcrouterGatewayUrl?: string;
   dcrouterGatewayApiToken?: string;
   dcrouterGatewayClientId?: string;

ts_interfaces/data/settings.ts

@@ -2,9 +2,31 @@
  * Settings data shapes for Onebox
  */
 
+export type TDcRouterMode = 'managed' | 'external' | 'disabled';
+
+export interface IManagedDcRouterStatus {
+  mode: TDcRouterMode;
+  configured: boolean;
+  running: boolean;
+  healthy: boolean;
+  containerId?: string;
+  image: string;
+  gatewayUrl: string;
+  opsPort: number;
+  httpPort: number;
+  httpsPort: number;
+  message?: string;
+}
+
 export interface ISettings {
   cloudflareToken: string;
   cloudflareZoneId: string;
+  dcrouterMode: TDcRouterMode;
+  dcrouterManagedImage: string;
+  dcrouterManagedOpsPort: number;
+  dcrouterManagedHttpPort: number;
+  dcrouterManagedHttpsPort: number;
+  dcrouterManagedDataDir: string;
   dcrouterGatewayUrl: string;
   dcrouterGatewayApiToken: string;
   dcrouterGatewayClientId: string;

ts_interfaces/requests/settings.ts

@@ -54,3 +54,55 @@ export interface IReq_GetBackupPasswordStatus extends plugins.typedrequestInterf
     status: data.IBackupPasswordStatus;
   };
 }
+
+export interface IReq_GetManagedDcRouterStatus extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetManagedDcRouterStatus
+> {
+  method: 'getManagedDcRouterStatus';
+  request: {
+    identity: data.IIdentity;
+  };
+  response: {
+    status: data.IManagedDcRouterStatus;
+  };
+}
+
+export interface IReq_StartManagedDcRouter extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_StartManagedDcRouter
+> {
+  method: 'startManagedDcRouter';
+  request: {
+    identity: data.IIdentity;
+  };
+  response: {
+    status: data.IManagedDcRouterStatus;
+  };
+}
+
+export interface IReq_StopManagedDcRouter extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_StopManagedDcRouter
+> {
+  method: 'stopManagedDcRouter';
+  request: {
+    identity: data.IIdentity;
+  };
+  response: {
+    status: data.IManagedDcRouterStatus;
+  };
+}
+
+export interface IReq_RestartManagedDcRouter extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_RestartManagedDcRouter
+> {
+  method: 'restartManagedDcRouter';
+  request: {
+    identity: data.IIdentity;
+  };
+  response: {
+    status: data.IManagedDcRouterStatus;
+  };
+}

ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/onebox',
-  version: '1.25.0',
+  version: '1.26.0',
   description: 'Self-hosted container platform with automatic SSL and DNS - a mini Heroku for single servers'
 }

ts_web/appstate.ts

@@ -54,6 +54,7 @@ export interface IBackupsState {
 export interface ISettingsState {
   settings: interfaces.data.ISettings | null;
   backupPasswordConfigured: boolean;
+  managedDcRouterStatus: interfaces.data.IManagedDcRouterStatus | null;
 }
 
 export interface IAppStoreState {
@@ -142,6 +143,7 @@ export const settingsStatePart = await appState.getStatePart<ISettingsState>(
   {
     settings: null,
     backupPasswordConfigured: false,
+    managedDcRouterStatus: null,
   },
   'soft',
 );
@@ -898,17 +900,21 @@ export const triggerScheduleAction = backupsStatePart.createAction<{ scheduleId:
 export const fetchSettingsAction = settingsStatePart.createAction(async (statePartArg) => {
   const context = getActionContext();
   try {
-    const [settingsResp, passwordResp] = await Promise.all([
+    const [settingsResp, passwordResp, managedDcRouterResp] = await Promise.all([
       new plugins.domtools.plugins.typedrequest.TypedRequest<
         interfaces.requests.IReq_GetSettings
       >('/typedrequest', 'getSettings').fire({ identity: context.identity! }),
       new plugins.domtools.plugins.typedrequest.TypedRequest<
         interfaces.requests.IReq_GetBackupPasswordStatus
       >('/typedrequest', 'getBackupPasswordStatus').fire({ identity: context.identity! }),
+      new plugins.domtools.plugins.typedrequest.TypedRequest<
+        interfaces.requests.IReq_GetManagedDcRouterStatus
+      >('/typedrequest', 'getManagedDcRouterStatus').fire({ identity: context.identity! }),
     ]);
     return {
       settings: settingsResp.settings,
       backupPasswordConfigured: passwordResp.status.isConfigured,
+      managedDcRouterStatus: managedDcRouterResp.status,
     };
   } catch (err) {
     console.error('Failed to fetch settings:', err);
@@ -935,6 +941,58 @@ export const updateSettingsAction = settingsStatePart.createAction<{
   }
 });
 
+export const fetchManagedDcRouterStatusAction = settingsStatePart.createAction(async (statePartArg) => {
+  const context = getActionContext();
+  try {
+    const response = await new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_GetManagedDcRouterStatus
+    >('/typedrequest', 'getManagedDcRouterStatus').fire({ identity: context.identity! });
+    return { ...statePartArg.getState(), managedDcRouterStatus: response.status };
+  } catch (err) {
+    console.error('Failed to fetch managed dcrouter status:', err);
+    return statePartArg.getState();
+  }
+});
+
+export const startManagedDcRouterAction = settingsStatePart.createAction(async (statePartArg) => {
+  const context = getActionContext();
+  try {
+    const response = await new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_StartManagedDcRouter
+    >('/typedrequest', 'startManagedDcRouter').fire({ identity: context.identity! });
+    return { ...statePartArg.getState(), managedDcRouterStatus: response.status };
+  } catch (err) {
+    console.error('Failed to start managed dcrouter:', err);
+    return statePartArg.getState();
+  }
+});
+
+export const stopManagedDcRouterAction = settingsStatePart.createAction(async (statePartArg) => {
+  const context = getActionContext();
+  try {
+    const response = await new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_StopManagedDcRouter
+    >('/typedrequest', 'stopManagedDcRouter').fire({ identity: context.identity! });
+    return { ...statePartArg.getState(), managedDcRouterStatus: response.status };
+  } catch (err) {
+    console.error('Failed to stop managed dcrouter:', err);
+    return statePartArg.getState();
+  }
+});
+
+export const restartManagedDcRouterAction = settingsStatePart.createAction(async (statePartArg) => {
+  const context = getActionContext();
+  try {
+    const response = await new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_RestartManagedDcRouter
+    >('/typedrequest', 'restartManagedDcRouter').fire({ identity: context.identity! });
+    return { ...statePartArg.getState(), managedDcRouterStatus: response.status };
+  } catch (err) {
+    console.error('Failed to restart managed dcrouter:', err);
+    return statePartArg.getState();
+  }
+});
+
 export const setBackupPasswordAction = settingsStatePart.createAction<{ password: string }>(
   async (statePartArg, dataArg) => {
     const context = getActionContext();

ts_web/elements/ob-view-settings.ts

@@ -17,6 +17,7 @@ export class ObViewSettings extends DeesElement {
   accessor settingsState: appstate.ISettingsState = {
     settings: null,
     backupPasswordConfigured: false,
+    managedDcRouterStatus: null,
   };
 
   @state()
@@ -81,6 +82,64 @@ export class ObViewSettings extends DeesElement {
         gap: 16px;
       }
 
+      .gateway-mode-row,
+      .gateway-status-row {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        gap: 12px;
+        padding: 16px 20px;
+        border-bottom: 1px solid ${cssManager.bdTheme('#f4f4f5', '#27272a')};
+      }
+
+      .gateway-mode-row {
+        justify-content: flex-start;
+      }
+
+      .gateway-mode-button {
+        border: 1px solid ${cssManager.bdTheme('#d4d4d8', '#3f3f46')};
+        border-radius: 999px;
+        background: ${cssManager.bdTheme('#ffffff', '#18181b')};
+        color: ${cssManager.bdTheme('#3f3f46', '#d4d4d8')};
+        padding: 8px 12px;
+        font: inherit;
+        cursor: pointer;
+      }
+
+      .gateway-mode-button.active {
+        border-color: ${cssManager.bdTheme('#2563eb', '#60a5fa')};
+        background: ${cssManager.bdTheme('#eff6ff', '#172554')};
+        color: ${cssManager.bdTheme('#1d4ed8', '#bfdbfe')};
+      }
+
+      .gateway-status-label {
+        font-size: 12px;
+        font-weight: 600;
+        text-transform: uppercase;
+        color: ${cssManager.bdTheme('#71717a', '#a1a1aa')};
+      }
+
+      .gateway-status-value {
+        margin-top: 4px;
+        font-size: 14px;
+        color: ${cssManager.bdTheme('#18181b', '#fafafa')};
+      }
+
+      .gateway-status-error,
+      .gateway-disabled {
+        color: ${cssManager.bdTheme('#b91c1c', '#fca5a5')};
+        font-size: 13px;
+      }
+
+      .gateway-disabled {
+        grid-column: 1 / -1;
+      }
+
+      .gateway-actions {
+        display: flex;
+        gap: 8px;
+      }
+
       .gateway-field.full {
         grid-column: 1 / -1;
       }
@@ -99,6 +158,11 @@ export class ObViewSettings extends DeesElement {
         .gateway-content {
           grid-template-columns: 1fr;
         }
+
+        .gateway-status-row {
+          align-items: flex-start;
+          flex-direction: column;
+        }
       }
     `,
   ];
@@ -117,6 +181,12 @@ export class ObViewSettings extends DeesElement {
           darkMode: true,
           cloudflareToken: '',
           cloudflareZoneId: '',
+          dcrouterMode: 'managed',
+          dcrouterManagedImage: 'code.foss.global/serve.zone/dcrouter:latest',
+          dcrouterManagedOpsPort: 3300,
+          dcrouterManagedHttpPort: 80,
+          dcrouterManagedHttpsPort: 443,
+          dcrouterManagedDataDir: './.nogit/dcrouter-data',
           dcrouterGatewayClientId: '',
           dcrouterWorkHosterId: '',
           autoRenewCerts: false,
@@ -150,22 +220,40 @@ export class ObViewSettings extends DeesElement {
 
   private renderExternalGatewaySettings(): TemplateResult {
     const settings = this.settingsState.settings;
+    const mode = settings?.dcrouterMode || 'managed';
     return html`
       <section class="gateway-card">
         <div class="gateway-header">
-          <div class="gateway-title">Delegate Routing</div>
-          <div class="gateway-subtitle">Delegate public app routing, DNS, and certificates to a dcrouter edge authority.</div>
+          <div class="gateway-title">dcrouter Gateway</div>
+          <div class="gateway-subtitle">Run a local managed dcrouter or delegate routing, DNS, and certificates to an external dcrouter.</div>
         </div>
+        <div class="gateway-mode-row">
+          ${this.renderModeButton('managed', 'Managed Local', mode)}
+          ${this.renderModeButton('external', 'External dcrouter', mode)}
+          ${this.renderModeButton('disabled', 'Disabled', mode)}
+        </div>
+        ${mode === 'managed' ? this.renderManagedGatewayStatus() : null}
         <div class="gateway-content">
+          ${mode === 'managed' ? html`
+            ${this.renderGatewayInput('dcrouterManagedImage', 'dcrouter Image', settings?.dcrouterManagedImage || 'code.foss.global/serve.zone/dcrouter:latest', 'OCI image used for the managed local gateway.')}
+            ${this.renderGatewayInput('dcrouterManagedDataDir', 'Data Directory', settings?.dcrouterManagedDataDir || './.nogit/dcrouter-data', 'Host directory mounted into the dcrouter container.')}
+            ${this.renderGatewayInput('dcrouterManagedOpsPort', 'Local Ops Port', String(settings?.dcrouterManagedOpsPort || 3300), 'Bound to 127.0.0.1 for Onebox to call dcrouter APIs.')}
+            ${this.renderGatewayInput('dcrouterManagedHttpPort', 'Public HTTP Port', String(settings?.dcrouterManagedHttpPort || 80), 'Host port owned by dcrouter for HTTP ingress.')}
+            ${this.renderGatewayInput('dcrouterManagedHttpsPort', 'Public HTTPS Port', String(settings?.dcrouterManagedHttpsPort || 443), 'Host port owned by dcrouter for HTTPS ingress.')}
+            ${this.renderGatewayInput('dcrouterGatewayClientId', 'Gateway Client ID', settings?.dcrouterGatewayClientId || settings?.dcrouterWorkHosterId || '', 'Leave empty to let Onebox create a stable ID.')}
+          ` : mode === 'external' ? html`
             ${this.renderGatewayInput('dcrouterGatewayUrl', 'Gateway URL', settings?.dcrouterGatewayUrl || '', 'Base URL of the dcrouter OpsServer.')}
             ${this.renderGatewayInput('dcrouterGatewayApiToken', 'API Token', settings?.dcrouterGatewayApiToken || '', 'Requires gateway-client access in dcrouter.', true)}
             ${this.renderGatewayInput('dcrouterGatewayClientId', 'Gateway Client ID', settings?.dcrouterGatewayClientId || settings?.dcrouterWorkHosterId || '', 'Leave empty to let Onebox create a stable ID.')}
             ${this.renderGatewayInput('dcrouterTargetHost', 'Target Host', settings?.dcrouterTargetHost || '', 'Defaults to the configured server IP when empty.')}
             ${this.renderGatewayInput('dcrouterTargetPort', 'Target Port', String(settings?.dcrouterTargetPort || 80), 'Internal HTTP port dcrouter forwards to.')}
+          ` : html`
+            <div class="gateway-disabled">dcrouter route delegation is disabled. Onebox will keep using its local SmartProxy directly.</div>
+          `}
         </div>
         <div class="gateway-footer">
           <dees-button
-            .text=${'Save Gateway Settings'}
+            .text=${'Save dcrouter Settings'}
             .type=${'default'}
             .icon=${'lucide:Save'}
             @click=${() => this.saveExternalGatewaySettings()}
@@ -175,6 +263,38 @@ export class ObViewSettings extends DeesElement {
     `;
   }
 
+  private renderModeButton(
+    mode: 'managed' | 'external' | 'disabled',
+    label: string,
+    activeMode: string,
+  ): TemplateResult {
+    return html`
+      <button
+        class="gateway-mode-button ${activeMode === mode ? 'active' : ''}"
+        @click=${() => this.updateGatewayDraft('dcrouterMode', mode)}
+      >${label}</button>
+    `;
+  }
+
+  private renderManagedGatewayStatus(): TemplateResult {
+    const status = this.settingsState.managedDcRouterStatus;
+    const stateText = status?.running ? (status.healthy ? 'Running' : 'Starting') : 'Stopped';
+    return html`
+      <div class="gateway-status-row">
+        <div>
+          <div class="gateway-status-label">Managed dcrouter</div>
+          <div class="gateway-status-value">${stateText}${status?.gatewayUrl ? ` at ${status.gatewayUrl}` : ''}</div>
+          ${status?.message ? html`<div class="gateway-status-error">${status.message}</div>` : null}
+        </div>
+        <div class="gateway-actions">
+          <dees-button .text=${'Start'} .type=${'default'} @click=${() => appstate.settingsStatePart.dispatchAction(appstate.startManagedDcRouterAction, null)}></dees-button>
+          <dees-button .text=${'Restart'} .type=${'default'} @click=${() => appstate.settingsStatePart.dispatchAction(appstate.restartManagedDcRouterAction, null)}></dees-button>
+          <dees-button .text=${'Stop'} .type=${'default'} @click=${() => appstate.settingsStatePart.dispatchAction(appstate.stopManagedDcRouterAction, null)}></dees-button>
+        </div>
+      </div>
+    `;
+  }
+
   private renderGatewayInput(
     key: keyof NonNullable<appstate.ISettingsState['settings']>,
     label: string,
@@ -201,7 +321,13 @@ export class ObViewSettings extends DeesElement {
     value: string,
   ): void {
     const currentSettings = this.settingsState.settings || {} as NonNullable<appstate.ISettingsState['settings']>;
-    const nextValue = key === 'dcrouterTargetPort' ? Number(value) || 0 : value;
+    const numberKeys = new Set([
+      'dcrouterTargetPort',
+      'dcrouterManagedOpsPort',
+      'dcrouterManagedHttpPort',
+      'dcrouterManagedHttpsPort',
+    ]);
+    const nextValue = numberKeys.has(key as string) ? Number(value) || 0 : value;
     this.settingsState = {
       ...this.settingsState,
       settings: {
@@ -217,6 +343,12 @@ export class ObViewSettings extends DeesElement {
 
     await appstate.settingsStatePart.dispatchAction(appstate.updateSettingsAction, {
       settings: {
+        dcrouterMode: settings.dcrouterMode || 'managed',
+        dcrouterManagedImage: settings.dcrouterManagedImage || 'code.foss.global/serve.zone/dcrouter:latest',
+        dcrouterManagedOpsPort: Number(settings.dcrouterManagedOpsPort) || 3300,
+        dcrouterManagedHttpPort: Number(settings.dcrouterManagedHttpPort) || 80,
+        dcrouterManagedHttpsPort: Number(settings.dcrouterManagedHttpsPort) || 443,
+        dcrouterManagedDataDir: settings.dcrouterManagedDataDir || './.nogit/dcrouter-data',
         dcrouterGatewayUrl: settings.dcrouterGatewayUrl || '',
         dcrouterGatewayApiToken: settings.dcrouterGatewayApiToken || '',
         dcrouterGatewayClientId: settings.dcrouterGatewayClientId || settings.dcrouterWorkHosterId || '',
@@ -224,5 +356,6 @@ export class ObViewSettings extends DeesElement {
         dcrouterTargetPort: Number(settings.dcrouterTargetPort) || 80,
       },
     });
+    await appstate.settingsStatePart.dispatchAction(appstate.fetchManagedDcRouterStatusAction, null);
   }
 }