@dyyz1993/codenomad 0.15.0 → 0.15.2

package/dist/auth/session-manager.js

@@ -1,7 +1,10 @@
 import crypto from "crypto";
+const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+const CLEANUP_INTERVAL_MS = 30 * 60 * 1000;
 export class SessionManager {
     constructor() {
         this.sessions = new Map();
+        this.cleanupTimer = setInterval(() => this.cleanupExpired(), CLEANUP_INTERVAL_MS);
     }
     createSession(username) {
         const id = crypto.randomBytes(32).toString("base64url");
@@ -14,4 +17,29 @@ export class SessionManager {
             return undefined;
         return this.sessions.get(id);
     }
+    validateSession(sessionId) {
+        const info = this.sessions.get(sessionId);
+        if (!info)
+            return null;
+        if (Date.now() - info.createdAt > SESSION_TTL_MS) {
+            this.sessions.delete(sessionId);
+            return null;
+        }
+        return info;
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        for (const [id, info] of this.sessions) {
+            if (now - info.createdAt > SESSION_TTL_MS) {
+                this.sessions.delete(id);
+            }
+        }
+    }
+    shutdown() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+        this.sessions.clear();
+    }
 }

package/dist/filesystem/__tests__/search-cache.test.js

@@ -5,10 +5,10 @@ describe("workspace search cache", () => {
     beforeEach(() => {
         clearWorkspaceSearchCache();
     });
-    it("expires cached candidates after the TTL", () => {
+    it("expires cached candidates after the TTL", async () => {
         const workspacePath = "/tmp/workspace";
         const startTime = 1000;
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], startTime);
+        await refreshWorkspaceCandidates(workspacePath, async () => [createEntry("file-a")], startTime);
         const beforeExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS - 1);
         assert.ok(beforeExpiry);
         assert.equal(beforeExpiry.length, 1);
@@ -16,13 +16,13 @@ describe("workspace search cache", () => {
         const afterExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS + 1);
         assert.equal(afterExpiry, undefined);
     });
-    it("replaces cached entries when manually refreshed", () => {
+    it("replaces cached entries when manually refreshed", async () => {
         const workspacePath = "/tmp/workspace";
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5000);
+        await refreshWorkspaceCandidates(workspacePath, async () => [createEntry("file-a")], 5000);
         const initial = getWorkspaceCandidates(workspacePath, 5001);
         assert.ok(initial);
         assert.equal(initial[0].name, "file-a");
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6000);
+        await refreshWorkspaceCandidates(workspacePath, async () => [createEntry("file-b")], 6000);
         const refreshed = getWorkspaceCandidates(workspacePath, 6001);
         assert.ok(refreshed);
         assert.equal(refreshed[0].name, "file-b");

package/dist/filesystem/search-cache.js

@@ -13,9 +13,9 @@ export function getWorkspaceCandidates(rootDir, now = Date.now()) {
     }
     return cloneEntries(cached.candidates);
 }
-export function refreshWorkspaceCandidates(rootDir, builder, now = Date.now()) {
+export async function refreshWorkspaceCandidates(rootDir, builder, now = Date.now()) {
     const key = normalizeKey(rootDir);
-    const freshCandidates = builder();
+    const freshCandidates = await builder();
     if (!freshCandidates || freshCandidates.length === 0) {
         workspaceCandidateCache.delete(key);
         return [];

package/dist/filesystem/search.js

@@ -1,4 +1,4 @@
-import fs from "fs";
+import { readdir, stat } from "node:fs/promises";
 import path from "path";
 import fuzzysort from "fuzzysort";
 import { clearWorkspaceSearchCache, getWorkspaceCandidates, refreshWorkspaceCandidates } from "./search-cache";
@@ -6,7 +6,7 @@ const DEFAULT_LIMIT = 100;
 const MAX_LIMIT = 200;
 const MAX_CANDIDATES = 8000;
 const IGNORED_DIRECTORIES = new Set([".git", ".hg", ".svn", "node_modules", "dist", "build", ".next", ".nuxt", ".turbo", ".cache", "coverage"].map((name) => name.toLowerCase()));
-export function searchWorkspaceFiles(rootDir, query, options = {}) {
+export async function searchWorkspaceFiles(rootDir, query, options = {}) {
     const trimmedQuery = query.trim();
     if (!trimmedQuery) {
         throw new Error("Search query is required");
@@ -21,7 +21,7 @@ export function searchWorkspaceFiles(rootDir, query, options = {}) {
             entries = getWorkspaceCandidates(normalizedRoot);
         }
         if (!entries) {
-            entries = refreshWorkspaceCandidates(normalizedRoot, () => collectCandidates(normalizedRoot));
+            entries = await refreshWorkspaceCandidates(normalizedRoot, () => collectCandidates(normalizedRoot));
         }
     }
     catch (error) {
@@ -45,7 +45,7 @@ export function searchWorkspaceFiles(rootDir, query, options = {}) {
     }
     return matches.map((match) => match.obj.entry);
 }
-function collectCandidates(rootDir) {
+async function collectCandidates(rootDir) {
     const queue = [""];
     const entries = [];
     while (queue.length > 0 && entries.length < MAX_CANDIDATES) {
@@ -53,7 +53,7 @@ function collectCandidates(rootDir) {
         const absoluteDir = relativeDir ? path.join(rootDir, relativeDir) : rootDir;
         let dirents;
         try {
-            dirents = fs.readdirSync(absoluteDir, { withFileTypes: true });
+            dirents = await readdir(absoluteDir, { withFileTypes: true });
         }
         catch {
             continue;
@@ -68,7 +68,7 @@ function collectCandidates(rootDir) {
             }
             let stats;
             try {
-                stats = fs.statSync(absolutePath);
+                stats = await stat(absolutePath);
             }
             catch {
                 continue;

package/dist/index.js

@@ -48,6 +48,7 @@ function parseCliOptions(argv) {
         .addOption(new Option("--http <enabled>", "Enable HTTP listener (true|false)").env("CLI_HTTP").default("false"))
         .addOption(new Option("--https-port <number>", "HTTPS port (0 for auto)").env("CLI_HTTPS_PORT").default(DEFAULT_HTTPS_PORT).argParser(parsePort))
         .addOption(new Option("--http-port <number>", "HTTP port (0 for auto)").env("CLI_HTTP_PORT").default(DEFAULT_HTTP_PORT).argParser(parsePort))
+        .addOption(new Option("--port <number>", "Shorthand for --http-port").argParser(parsePort))
         .addOption(new Option("--tls-key <path>", "TLS private key (PEM)").env("CLI_TLS_KEY"))
         .addOption(new Option("--tls-cert <path>", "TLS certificate (PEM)").env("CLI_TLS_CERT"))
         .addOption(new Option("--tls-ca <path>", "TLS CA chain (PEM)").env("CLI_TLS_CA"))
@@ -94,12 +95,18 @@ function parseCliOptions(argv) {
     if (upgrade === undefined && !httpsEnabled && !httpEnabled) {
         throw new InvalidArgumentError("At least one listener must be enabled (--https or --http)");
     }
+    const resolvedHttpPort = parsed.port ?? parsed.httpPort;
+    const portExplicit = parsed.port !== undefined;
+    const httpsPortExplicit = parsed.httpsPort !== DEFAULT_HTTPS_PORT;
+    const resolvedHttpsPort = portExplicit && !httpsPortExplicit && resolvedHttpPort !== DEFAULT_HTTP_PORT
+        ? resolvedHttpPort + 1
+        : parsed.httpsPort;
     return {
         host: normalizedHost,
         https: httpsEnabled,
         http: httpEnabled,
-        httpsPort: parsed.httpsPort,
-        httpPort: parsed.httpPort,
+        httpsPort: resolvedHttpsPort,
+        httpPort: resolvedHttpPort,
         tlsKeyPath: parsed.tlsKey,
         tlsCertPath: parsed.tlsCert,
         tlsCaPath: parsed.tlsCa,
@@ -225,7 +232,7 @@ async function main() {
     });
     const instanceStore = new InstanceStore(configLocation.instancesDir);
     const speechService = new SpeechService(settings, logger.child({ component: "speech" }));
-    const sidecarManager = new SideCarManager({
+    const sidecarManager = await SideCarManager.create({
         settings,
         eventBus,
         logger: logger.child({ component: "sidecars" }),
@@ -247,6 +254,7 @@ async function main() {
         overrideUiDir: uiDirOverride,
         uiDevServerUrl: options.uiDevServer,
         manifestUrl: options.uiManifestUrl,
+        configDir,
         logger: logger.child({ component: "ui" }),
     });
     serverMeta.serverVersion = packageJson.version;
@@ -288,8 +296,9 @@ async function main() {
         channel: pluginChannel,
         logger: logger.child({ component: "voice-mode" }),
     });
-    const httpsPortExplicit = programHasArg(process.argv.slice(2), "--https-port") || Boolean(process.env.CLI_HTTPS_PORT);
-    const httpPortExplicit = programHasArg(process.argv.slice(2), "--http-port") || Boolean(process.env.CLI_HTTP_PORT);
+    const portArgPassed = programHasArg(process.argv.slice(2), "--port");
+    const httpsPortExplicit = programHasArg(process.argv.slice(2), "--https-port") || Boolean(process.env.CLI_HTTPS_PORT) || portArgPassed;
+    const httpPortExplicit = programHasArg(process.argv.slice(2), "--http-port") || programHasArg(process.argv.slice(2), "--port") || Boolean(process.env.CLI_HTTP_PORT);
     const httpsBindPort = httpsPortExplicit ? options.httpsPort : 0;
     const httpBindPort = httpPortExplicit ? options.httpPort : 0;
     // Listener binding rules:

package/dist/server/routes/auth-pages/login.html

@@ -101,28 +101,39 @@
           showError("Username and password are required.")
           return
         }
-        try {
-          const res = await fetch("/api/auth/login", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ username, password }),
-            credentials: "include",
-          })
-          if (!res.ok) {
-            let message = ""
-            try {
-              const json = await res.json()
-              message = json && json.error ? String(json.error) : ""
-            } catch {
-              message = ""
+
+        const MAX_RETRIES = 3
+        const RETRY_DELAY_MS = 2000
+
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+          try {
+            const res = await fetch("/api/auth/login", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ username, password }),
+              credentials: "include",
+            })
+            if (!res.ok) {
+              let message = ""
+              try {
+                const json = await res.json()
+                message = json && json.error ? String(json.error) : ""
+              } catch {
+                message = ""
+              }
+              showError(message || `Login failed (${res.status})`)
+              return
             }
-            showError(message || `Login failed (${res.status})`)
+            window.location.replace("/")
             return
+          } catch (e) {
+            if (attempt < MAX_RETRIES) {
+              showError(`Connection failed, retrying (${attempt}/${MAX_RETRIES})...`)
+              await new Promise((r) => setTimeout(r, RETRY_DELAY_MS))
+            } else {
+              showError("Service connection failed. The port may have changed. Please refresh the page and try again.")
+            }
           }
-          // Replace history entry so Back doesn't return to /login.
-          window.location.replace("/")
-        } catch (e) {
-          showError(e && e.message ? e.message : String(e))
         }
       }
 

package/dist/server/routes/events.js

@@ -3,6 +3,7 @@ let nextClientId = 0;
 const ConnectionQuerySchema = z.object({
     clientId: z.string().trim().min(1),
     connectionId: z.string().trim().min(1),
+    workspaceId: z.string().trim().optional(),
 });
 const PongBodySchema = ConnectionQuerySchema.extend({
     pingTs: z.number().optional(),
@@ -20,7 +21,32 @@ export function registerEventRoutes(app, deps) {
         reply.raw.setHeader("Connection", "keep-alive");
         reply.raw.flushHeaders?.();
         reply.hijack();
+        const filterWorkspaceId = connection.workspaceId;
+        const getEventWorkspaceId = (event) => {
+            switch (event.type) {
+                case "workspace.created":
+                case "workspace.started":
+                case "workspace.error":
+                    return event.workspace?.id;
+                case "workspace.stopped":
+                    return event.workspaceId;
+                case "workspace.log":
+                    return event.entry.workspaceId;
+                case "instance.event":
+                case "instance.eventStatus":
+                case "instance.dataChanged":
+                    return event.instanceId;
+                default:
+                    return undefined;
+            }
+        };
         const send = (event) => {
+            if (filterWorkspaceId) {
+                const eventWsId = getEventWorkspaceId(event);
+                if (eventWsId && eventWsId !== filterWorkspaceId) {
+                    return;
+                }
+            }
             deps.logger.debug({ clientId, type: event.type }, "SSE event dispatched");
             if (deps.logger.isLevelEnabled("trace")) {
                 deps.logger.trace({ clientId, event }, "SSE event payload");

package/dist/server/routes/settings.js

@@ -10,10 +10,10 @@ function validateBinaryPath(binaryPath) {
 }
 export function registerSettingsRoutes(app, deps) {
     // Full-document access
-    app.get("/api/storage/config", async () => sanitizeConfigDoc(deps.settings.getDoc("config")));
+    app.get("/api/storage/config", async () => sanitizeConfigDoc(await deps.settings.getDoc("config")));
     app.patch("/api/storage/config", async (request, reply) => {
         try {
-            return sanitizeConfigDoc(deps.settings.mergePatchDoc("config", request.body ?? {}));
+            return sanitizeConfigDoc(await deps.settings.mergePatchDoc("config", request.body ?? {}));
         }
         catch (error) {
             reply.code(400);
@@ -21,11 +21,11 @@ export function registerSettingsRoutes(app, deps) {
         }
     });
     app.get("/api/storage/config/:owner", async (request) => {
-        return sanitizeConfigOwner(request.params.owner, deps.settings.getOwner("config", request.params.owner));
+        return sanitizeConfigOwner(request.params.owner, await deps.settings.getOwner("config", request.params.owner));
     });
     app.patch("/api/storage/config/:owner", async (request, reply) => {
         try {
-            return sanitizeConfigOwner(request.params.owner, deps.settings.mergePatchOwner("config", request.params.owner, request.body ?? {}));
+            return sanitizeConfigOwner(request.params.owner, await deps.settings.mergePatchOwner("config", request.params.owner, request.body ?? {}));
         }
         catch (error) {
             reply.code(400);
@@ -35,7 +35,7 @@ export function registerSettingsRoutes(app, deps) {
     app.get("/api/storage/state", async () => deps.settings.getDoc("state"));
     app.patch("/api/storage/state", async (request, reply) => {
         try {
-            return deps.settings.mergePatchDoc("state", request.body ?? {});
+            return await deps.settings.mergePatchDoc("state", request.body ?? {});
         }
         catch (error) {
             reply.code(400);
@@ -47,7 +47,7 @@ export function registerSettingsRoutes(app, deps) {
     });
     app.patch("/api/storage/state/:owner", async (request, reply) => {
         try {
-            return deps.settings.mergePatchOwner("state", request.params.owner, request.body ?? {});
+            return await deps.settings.mergePatchOwner("state", request.params.owner, request.body ?? {});
         }
         catch (error) {
             reply.code(400);

package/dist/server/routes/speech.js

@@ -23,7 +23,7 @@ function getSpeechErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
 export function registerSpeechRoutes(app, deps) {
-    app.get("/api/speech/capabilities", async () => deps.speechService.getCapabilities());
+    app.get("/api/speech/capabilities", async () => await deps.speechService.getCapabilities());
     app.post("/api/speech/transcribe", async (request, reply) => {
         try {
             const body = TranscribeBodySchema.parse(request.body ?? {});

package/dist/server/routes/workspaces.js

@@ -77,7 +77,7 @@ export function registerWorkspaceRoutes(app, deps) {
     app.get("/api/workspaces/:id/files/search", async (request, reply) => {
         try {
             const query = WorkspaceFileSearchQuerySchema.parse(request.query ?? {});
-            return deps.workspaceManager.searchFiles(request.params.id, query.q, {
+            return await deps.workspaceManager.searchFiles(request.params.id, query.q, {
                 limit: query.limit,
                 type: query.type,
                 refresh: query.refresh,

package/dist/settings/binaries.js

@@ -3,15 +3,15 @@ function prettyLabel(p) {
     const last = parts[parts.length - 1] || p;
     return last || p;
 }
-function readUiBinaries(settings) {
-    const ui = settings.getOwner("state", "ui");
+async function readUiBinaries(settings) {
+    const ui = await settings.getOwner("state", "ui");
     const list = ui?.opencodeBinaries;
     if (!Array.isArray(list))
         return [];
     return list.filter((item) => item && typeof item === "object" && typeof item.path === "string");
 }
-function readDefaultBinaryPath(settings) {
-    const server = settings.getOwner("config", "server");
+async function readDefaultBinaryPath(settings) {
+    const server = await settings.getOwner("config", "server");
     const value = server?.opencodeBinary;
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
@@ -19,12 +19,12 @@ export class BinaryResolver {
     constructor(settings) {
         this.settings = settings;
     }
-    list() {
+    async list() {
         return readUiBinaries(this.settings);
     }
-    resolveDefault() {
-        const binaries = this.list();
-        const configuredDefault = readDefaultBinaryPath(this.settings);
+    async resolveDefault() {
+        const binaries = await this.list();
+        const configuredDefault = await readDefaultBinaryPath(this.settings);
         const fallback = binaries[0]?.path;
         const path = configuredDefault ?? fallback ?? "opencode";
         const entry = binaries.find((b) => b.path === path);

package/dist/settings/service.js

@@ -51,46 +51,46 @@ export class SettingsService {
         this.configStore = new YamlDocStore(location.configYamlPath, logger.child({ component: "settings-config" }));
         this.stateStore = new YamlDocStore(location.stateYamlPath, logger.child({ component: "settings-state" }));
     }
-    getDoc(kind) {
+    async getDoc(kind) {
         if (kind !== "config") {
             return this.stateStore.get();
         }
-        const current = this.configStore.get();
+        const current = await this.configStore.get();
         const normalized = normalizeConfigDoc(current);
         if (!isDeepEqual(current, normalized)) {
-            this.configStore.replace(normalized);
+            await this.configStore.replace(normalized);
         }
         return normalized;
     }
-    mergePatchDoc(kind, patch) {
+    async mergePatchDoc(kind, patch) {
         const updated = kind === "config"
-            ? this.configStore.replace(normalizeConfigDoc(this.configStore.mergePatch(patch)))
-            : this.stateStore.mergePatch(patch);
-        this.publish(kind, "*");
+            ? await this.configStore.replace(normalizeConfigDoc(await this.configStore.mergePatch(patch)))
+            : await this.stateStore.mergePatch(patch);
+        await this.publish(kind, "*");
         return updated;
     }
-    getOwner(kind, owner) {
+    async getOwner(kind, owner) {
         if (kind !== "config") {
             return this.stateStore.getOwner(owner);
         }
         return owner === "server"
-            ? normalizeServerConfigOwner(this.getDoc("config").server)
-            : this.getDoc("config")[owner];
+            ? normalizeServerConfigOwner((await this.getDoc("config")).server)
+            : (await this.getDoc("config"))[owner];
     }
-    mergePatchOwner(kind, owner, patch) {
+    async mergePatchOwner(kind, owner, patch) {
         const updated = kind === "config"
             ? owner === "server"
-                ? this.configStore.replaceOwner(owner, normalizeServerConfigOwner(this.configStore.mergePatchOwner(owner, patch)))
-                : this.configStore.mergePatchOwner(owner, patch)
-            : this.stateStore.mergePatchOwner(owner, patch);
-        this.publish(kind, owner, updated);
+                ? await this.configStore.replaceOwner(owner, normalizeServerConfigOwner(await this.configStore.mergePatchOwner(owner, patch)))
+                : await this.configStore.mergePatchOwner(owner, patch)
+            : await this.stateStore.mergePatchOwner(owner, patch);
+        await this.publish(kind, owner, updated);
         return updated;
     }
-    publish(kind, owner, value) {
+    async publish(kind, owner, value) {
         if (!this.eventBus)
             return;
         const type = kind === "config" ? "storage.configChanged" : "storage.stateChanged";
-        const nextValue = value ?? this.getOwner(kind, owner);
+        const nextValue = value ?? await this.getOwner(kind, owner);
         const payload = {
             type,
             owner,

package/dist/settings/yaml-doc-store.js

@@ -1,4 +1,5 @@
-import fs from "fs";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
 import path from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { applyMergePatch, isPlainObject } from "./merge-patch";
@@ -20,17 +21,20 @@ export class YamlDocStore {
         this.cache = {};
         this.loaded = false;
     }
-    load() {
+    async load() {
         if (this.loaded) {
             return this.cache;
         }
         try {
-            if (!fs.existsSync(this.filePath)) {
+            try {
+                await access(this.filePath, constants.F_OK);
+            }
+            catch {
                 this.cache = {};
                 this.loaded = true;
                 return this.cache;
             }
-            const content = fs.readFileSync(this.filePath, "utf-8");
+            const content = await readFile(this.filePath, "utf-8");
             const parsed = parseYaml(content);
             this.cache = normalizeDoc(parsed);
             this.loaded = true;
@@ -43,51 +47,51 @@ export class YamlDocStore {
             return this.cache;
         }
     }
-    get() {
+    async get() {
         return this.load();
     }
-    replace(next) {
+    async replace(next) {
         const normalized = normalizeDoc(next);
         this.cache = normalized;
         this.loaded = true;
-        this.persist();
+        await this.persist();
         return this.cache;
     }
-    mergePatch(patch) {
+    async mergePatch(patch) {
         if (!isPlainObject(patch)) {
             throw new Error("Patch must be a JSON object");
         }
-        const current = this.get();
+        const current = await this.get();
         const next = applyMergePatch(current, patch);
         return this.replace(next);
     }
-    getOwner(owner) {
-        const doc = this.get();
+    async getOwner(owner) {
+        const doc = await this.get();
         const value = doc?.[owner];
         return normalizeDoc(value);
     }
-    replaceOwner(owner, value) {
-        const doc = this.get();
+    async replaceOwner(owner, value) {
+        const doc = await this.get();
         const nextDoc = { ...doc, [owner]: normalizeDoc(value) };
-        this.replace(nextDoc);
+        await this.replace(nextDoc);
         return nextDoc[owner];
     }
-    mergePatchOwner(owner, patch) {
+    async mergePatchOwner(owner, patch) {
         if (!isPlainObject(patch)) {
             throw new Error("Patch must be a JSON object");
         }
-        const doc = this.get();
+        const doc = await this.get();
         const currentOwner = normalizeDoc(doc?.[owner]);
         const nextOwner = normalizeDoc(applyMergePatch(currentOwner, patch));
         const nextDoc = { ...doc, [owner]: nextOwner };
-        this.replace(nextDoc);
+        await this.replace(nextDoc);
         return nextOwner;
     }
-    persist() {
+    async persist() {
         try {
-            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            await mkdir(path.dirname(this.filePath), { recursive: true });
             const yaml = stringifyYaml(this.cache);
-            fs.writeFileSync(this.filePath, ensureTrailingNewline(yaml), "utf-8");
+            await writeFile(this.filePath, ensureTrailingNewline(yaml), "utf-8");
         }
         catch (error) {
             this.logger.warn({ err: error, filePath: this.filePath }, "Failed to persist YAML doc");

package/dist/sidecars/manager.js

@@ -4,17 +4,21 @@ export class SideCarManager {
         this.options = options;
         this.configs = new Map();
         this.runtime = new Map();
-        for (const record of this.loadConfiguredSideCars()) {
-            this.configs.set(record.id, record);
-            this.runtime.set(record.id, { status: "stopped" });
+    }
+    static async create(options) {
+        const instance = new SideCarManager(options);
+        for (const record of await instance.loadConfiguredSideCars()) {
+            instance.configs.set(record.id, record);
+            instance.runtime.set(record.id, { status: "stopped" });
         }
         queueMicrotask(() => {
-            for (const record of this.configs.values()) {
-                void this.refreshPortSideCar(record.id).catch((error) => {
-                    this.options.logger.warn({ sidecarId: record.id, err: error }, "Failed to probe sidecar port");
+            for (const record of instance.configs.values()) {
+                void instance.refreshPortSideCar(record.id).catch((error) => {
+                    instance.options.logger.warn({ sidecarId: record.id, err: error }, "Failed to probe sidecar port");
                 });
             }
         });
+        return instance;
     }
     async list() {
         await this.refreshPortStatuses();
@@ -45,7 +49,7 @@ export class SideCarManager {
         };
         this.configs.set(record.id, record);
         this.runtime.set(record.id, { status: "stopped" });
-        this.persistConfigs();
+        await this.persistConfigs();
         await this.refreshPortSideCar(record.id);
         return this.toSideCar(record);
     }
@@ -56,7 +60,7 @@ export class SideCarManager {
         record.insecure = typeof input.insecure === "boolean" ? input.insecure : record.insecure;
         record.prefixMode = typeof input.prefixMode === "string" ? input.prefixMode : record.prefixMode;
         record.updatedAt = new Date().toISOString();
-        this.persistConfigs();
+        await this.persistConfigs();
         await this.refreshPortSideCar(id);
         return this.toSideCar(record);
     }
@@ -66,7 +70,7 @@ export class SideCarManager {
             return false;
         this.configs.delete(id);
         this.runtime.delete(id);
-        this.persistConfigs();
+        await this.persistConfigs();
         this.options.eventBus.publish({ type: "sidecar.removed", sidecarId: id });
         return true;
     }
@@ -140,12 +144,12 @@ export class SideCarManager {
         }
         return record;
     }
-    persistConfigs() {
+    async persistConfigs() {
         const sidecars = Array.from(this.configs.values()).map((record) => ({ ...record }));
-        this.options.settings.mergePatchOwner("config", "server", { sidecars });
+        await this.options.settings.mergePatchOwner("config", "server", { sidecars });
     }
-    loadConfiguredSideCars() {
-        const serverConfig = this.options.settings.getOwner("config", "server");
+    async loadConfiguredSideCars() {
+        const serverConfig = await this.options.settings.getOwner("config", "server");
         const list = Array.isArray(serverConfig?.sidecars) ? serverConfig.sidecars : [];
         const records = [];
         for (const item of list) {