om-memory-system 5.6.1 → 5.8.0

package/dist/services/space-routes.js

@@ -1,4 +1,7 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
 import { basename } from "node:path";
+import { promisify } from "node:util";
 import * as config from "../config.js";
 import { HostAppearanceError, createAppearance } from "./host-appearance.js";
 import { log } from "./logger.js";
@@ -10,6 +13,7 @@ import { DEFAULT_SPACE_ID, SpaceError, findSpace, listSpaces, isValidSpaceId, re
 import { archiveStoredSpace, createStoredSpace, renameStoredSpace, spaceFiles, switchStoredSpace, unarchiveStoredSpace, } from "./spaces/registry-store.js";
 import { listBackups, restoreBackup } from "./spaces/restore.js";
 import { ommsHomeDir } from "./spaces/storage-resolution.js";
+import { isLoopbackAddress } from "./web-api-auth.js";
 const ok = (data) => ({ status: 200, body: { success: true, data } });
 const fail = (status, code, error) => ({
     status,
@@ -18,10 +22,8 @@ const fail = (status, code, error) => ({
 export const STATUS_BY_CODE = {
     "invalid-name": 400,
     "invalid-id": 400,
-    reserved: 400,
     unknown: 404,
     "name-taken": 409,
-    "id-taken": 409,
     protected: 409,
     active: 409,
     archived: 409,
@@ -53,21 +55,25 @@ function appearanceOf(files) {
     return createAppearance(files.appearanceRoot, isValidSpaceId, "Unknown space");
 }
 function describeSpaces(files, registry, globalFolder, looks) {
-    return listSpaces(registry).map((space) => ({
-        look: looks[space.id] ?? { kind: "default" },
-        id: space.id,
-        name: space.name,
-        createdAt: space.createdAt || null,
-        archived: space.archived,
-        archivedAt: space.archivedAt ?? null,
-        active: space.id === registry.activeSpaceId,
-        sizeBytes: folderSize(resolveSpaceFolder(space.id, {
+    return listSpaces(registry).map((space) => {
+        const folder = resolveSpaceFolder(space.id, {
             globalStoragePath: globalFolder,
             spacesRoot: files.spacesRoot,
-        })),
-        disabled: disabledReasons(space, registry.activeSpaceId),
-        links: spaceLinks(registry, space.id),
-    }));
+        });
+        return {
+            look: looks[space.id] ?? { kind: "default" },
+            id: space.id,
+            name: space.name,
+            createdAt: space.createdAt || null,
+            archived: space.archived,
+            archivedAt: space.archivedAt ?? null,
+            active: space.id === registry.activeSpaceId,
+            folder,
+            sizeBytes: folderSize(folder),
+            disabled: disabledReasons(space, registry.activeSpaceId),
+            links: spaceLinks(registry, space.id),
+        };
+    });
 }
 function describeBackup(path, summary) {
     return {
@@ -98,12 +104,12 @@ async function snapshot(files, cwd) {
 function nameOf(body) {
     return typeof body.name === "string" ? body.name : "";
 }
-export async function routeSpaces(path, method, readBody, cwd) {
+export async function routeSpaces(path, method, readBody, cwd, options = {}) {
     if (path !== "/api/spaces" && !path.startsWith("/api/spaces/"))
         return undefined;
     const files = spaceFiles(ommsHomeDir());
     try {
-        return await dispatch(path, method, readBody, cwd, files);
+        return await dispatch(path, method, readBody, cwd, files, options);
     }
     catch (error) {
         if (error instanceof SpaceError) {
@@ -115,7 +121,7 @@ export async function routeSpaces(path, method, readBody, cwd) {
         return fail(500, "error", error instanceof Error ? error.message : "Spaces request failed");
     }
 }
-async function dispatch(path, method, readBody, cwd, files) {
+async function dispatch(path, method, readBody, cwd, files, options) {
     if (path === "/api/spaces" && method === "GET")
         return ok(await snapshot(files, cwd));
     if (path === "/api/spaces" && method === "POST") {
@@ -147,7 +153,7 @@ async function dispatch(path, method, readBody, cwd, files) {
         }
         return ok({ look: (await appearance.read([space.id]))[space.id] });
     }
-    const match = /^\/api\/spaces\/([^/]+)(?:\/(switch|rename|archive|unarchive|backup))?$/.exec(path);
+    const match = /^\/api\/spaces\/([^/]+)(?:\/(switch|rename|archive|unarchive|backup|open-folder))?$/.exec(path);
     if (!match)
         return undefined;
     const id = decodeURIComponent(match[1]);
@@ -160,7 +166,11 @@ async function dispatch(path, method, readBody, cwd, files) {
         else if (action === "unarchive")
             await unarchiveStoredSpace(files, id);
         else if (action === "rename")
-            await renameStoredSpace(files, id, nameOf(await readBody()));
+            await renameStoredSpace(files, id, nameOf(await readBody()), {
+                defaultFolder: globalFolder(),
+            });
+        else if (action === "open-folder")
+            return await openFolder(files, id, options);
         else
             return ok(await backUp(files, id));
         config.refreshConfigIfChanged(cwd);
@@ -173,6 +183,39 @@ async function dispatch(path, method, readBody, cwd, files) {
 function globalFolder() {
     return config.CONFIG.skillStoragePath ?? config.CONFIG.storagePath;
 }
+/** The file manager command of this platform. The folder is its only argument. */
+const openerCommand = process.platform === "win32" ? "explorer" : process.platform === "darwin" ? "open" : "xdg-open";
+const execFileAsync = promisify(execFile);
+/** The real opener. execFile runs no shell, so a path can never be reinterpreted as a command. */
+async function startFileManager(command, args) {
+    // The opener hands off to the file manager and exits, so this await reports a missing
+    // opener without waiting on the file manager itself.
+    await execFileAsync(command, args);
+}
+/**
+ * Opens the space folder in the platform file manager. Refused unless the caller is this
+ * machine, and the folder always comes from the registry, never from the request.
+ */
+async function openFolder(files, id, options) {
+    if (!isLoopbackAddress(options.remoteAddress)) {
+        return fail(403, "forbidden", "Only the local machine can open a space folder. Use the web app on this computer.");
+    }
+    const space = requireSpace(files, id);
+    const folder = resolveSpaceFolder(space.id, {
+        globalStoragePath: globalFolder(),
+        spacesRoot: files.spacesRoot,
+    });
+    if (!existsSync(folder)) {
+        return fail(409, "missing-folder", `The space folder is missing: ${folder}. Restore the space from a backup, then try again.`);
+    }
+    try {
+        await (options.startOpener ?? startFileManager)(openerCommand, [folder]);
+    }
+    catch (error) {
+        return fail(500, "opener", `Could not open the folder: ${folder}. ${error instanceof Error ? error.message : "The file manager did not start."}`);
+    }
+    return ok({ folder });
+}
 async function backUp(files, id) {
     const space = requireSpace(files, id);
     const { backupPath, manifest } = await backupSpace({

package/dist/services/spaces/backup.js

@@ -58,6 +58,9 @@ function isStoreFile(relPath) {
     const parts = relPath.split("/");
     if (parts.some((part) => SKIPPED_FOLDERS.includes(part)))
         return false;
+    // The root space.json label is live-instance state; a restored space gets a fresh one.
+    if (parts.length === 1 && parts[0] === "space.json")
+        return false;
     return !SKIPPED_SUFFIXES.some((suffix) => relPath.endsWith(suffix));
 }
 function uniqueBackupFolder(backupsRoot, id, now) {

package/dist/services/spaces/operations.js

@@ -222,12 +222,14 @@ export async function executeSpaceOperation(args, context) {
         }[action];
         const registry = await change(context.files, name);
         const active = activeOf(registry);
+        // The caller may have passed the id, so the message names the display name.
+        const displayName = findSpace(registry, name).name;
         return {
             success: true,
             activeSpace: active,
             message: action === "use"
                 ? `Active space is now "${active.name}". It applies from the next turn.`
-                : `Space "${name}" is now ${action === "archive" ? "archived" : "not archived"}.`,
+                : `Space "${displayName}" is now ${action === "archive" ? "archived" : "not archived"}.`,
         };
     }
     catch (error) {

package/dist/services/spaces/registry-store.d.ts

@@ -1,4 +1,4 @@
-import { type SpaceEntry, type SpaceRegistry } from "./registry.js";
+import { type CreateSpaceOptions, type SpaceEntry, type SpaceRegistry } from "./registry.js";
 export interface SpaceFiles {
     /** `<omms folder>/spaces.json` */
     registryPath: string;
@@ -24,12 +24,14 @@ export declare function updateRegistry<T>(files: SpaceFiles, change: (registry:
     registry: SpaceRegistry;
     result: T;
 }>;
-export declare function createStoredSpace(files: SpaceFiles, name: string): Promise<SpaceEntry>;
+export declare function createStoredSpace(files: SpaceFiles, name: string, options?: CreateSpaceOptions): Promise<SpaceEntry>;
 export declare const archiveStoredSpace: (files: SpaceFiles, idOrName: string) => Promise<SpaceRegistry>;
 export declare const unarchiveStoredSpace: (files: SpaceFiles, idOrName: string) => Promise<SpaceRegistry>;
 export declare const switchStoredSpace: (files: SpaceFiles, idOrName: string) => Promise<SpaceRegistry>;
 export declare const removeStoredSpace: (files: SpaceFiles, idOrName: string) => Promise<SpaceRegistry>;
-export declare function renameStoredSpace(files: SpaceFiles, idOrName: string, name: string): Promise<SpaceRegistry>;
+export declare function renameStoredSpace(files: SpaceFiles, idOrName: string, name: string, options?: {
+    defaultFolder?: string;
+}): Promise<SpaceRegistry>;
 /** Adds a link between two stored spaces under the lock (design D5). */
 export declare function linkStoredSpace(files: SpaceFiles, idOrName: string, targetIdOrName: string): Promise<SpaceRegistry>;
 /** Removes a link between two stored spaces under the lock (design D5). */

package/dist/services/spaces/registry-store.js

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { dirname, join } from "node:path";
-import { SpaceError, archiveSpace, createSpace, linkSpace, readRegistryFile, removeSpace, renameSpace, switchSpace, unarchiveSpace, unlinkSpace, } from "./registry.js";
+import { SpaceError, archiveSpace, createSpace, findSpace, linkSpace, listSpaces, readRegistryFile, removeSpace, renameSpace, switchSpace, unarchiveSpace, unlinkSpace, DEFAULT_SPACE_ID, } from "./registry.js";
+import { writeSpaceLabel } from "./space-label.js";
 /**
  * The one write path for `spaces.json` (design D5). The web server, the CLI and the
  * `memory` tool all change the registry through `updateRegistry`. Readers never lock.
@@ -109,13 +110,25 @@ export async function updateRegistry(files, change) {
         }
     }
 }
-export async function createStoredSpace(files, name) {
+export async function createStoredSpace(files, name, options = {}) {
     const { result } = await updateRegistry(files, (registry) => {
-        const created = createSpace(registry, name, new Date().toISOString());
+        // A leftover folder must not be adopted by a new space, so its name counts as a taken id.
+        const folderIds = existsSync(files.spacesRoot) ? readdirSync(files.spacesRoot) : [];
+        const created = createSpace(registry, name, new Date().toISOString(), {
+            ...options,
+            avoidIds: [...(options.avoidIds ?? []), ...folderIds],
+        });
         // The folder comes first, so the registry never names a space that has no folder.
         mkdirSync(join(files.spacesRoot, created.space.id), { recursive: true });
         return { registry: created.registry, result: created.space };
     });
+    // The label only names the folder; a failed write must not fail the create.
+    try {
+        writeSpaceLabel(join(files.spacesRoot, result.id), result);
+    }
+    catch {
+        // Start-up backfills the label later.
+    }
     return result;
 }
 const simple = (apply) => async (files, idOrName) => (await updateRegistry(files, (registry) => ({
@@ -126,11 +139,27 @@ export const archiveStoredSpace = simple(archiveSpace);
 export const unarchiveStoredSpace = simple(unarchiveSpace);
 export const switchStoredSpace = simple(switchSpace);
 export const removeStoredSpace = simple(removeSpace);
-export async function renameStoredSpace(files, idOrName, name) {
-    return (await updateRegistry(files, (registry) => ({
-        registry: renameSpace(registry, idOrName, name),
-        result: 0,
-    }))).registry;
+export async function renameStoredSpace(files, idOrName, name, options = {}) {
+    const { registry, result: renamed } = await updateRegistry(files, (current) => {
+        // Found by id: the new name may equal another space's id, which findSpace would pick.
+        const id = findSpace(current, idOrName)?.id;
+        const next = renameSpace(current, idOrName, name);
+        return { registry: next, result: listSpaces(next).find((space) => space.id === id) };
+    });
+    if (renamed) {
+        // Default lives in the global storage folder, which only the caller knows.
+        const folder = renamed.id === DEFAULT_SPACE_ID ? options.defaultFolder : join(files.spacesRoot, renamed.id);
+        if (folder) {
+            // The label only names the folder; a failed write must not fail the rename.
+            try {
+                writeSpaceLabel(folder, renamed);
+            }
+            catch {
+                // Start-up backfills the label later.
+            }
+        }
+    }
+    return registry;
 }
 /** Adds a link between two stored spaces under the lock (design D5). */
 export async function linkStoredSpace(files, idOrName, targetIdOrName) {

package/dist/services/spaces/registry.d.ts

@@ -28,7 +28,7 @@ export interface SpaceRegistry {
     /** User-created spaces only. Default is added by `listSpaces`. */
     spaces: SpaceEntry[];
 }
-export type SpaceErrorCode = "invalid-name" | "name-taken" | "id-taken" | "reserved" | "protected" | "active" | "archived" | "not-archived" | "unknown" | "invalid-id" | "unreadable" | "lock-timeout";
+export type SpaceErrorCode = "invalid-name" | "name-taken" | "protected" | "active" | "archived" | "not-archived" | "unknown" | "invalid-id" | "unreadable" | "lock-timeout";
 /** A refused space operation. The message is safe to show to the user. */
 export declare class SpaceError extends Error {
     readonly code: SpaceErrorCode;
@@ -43,14 +43,20 @@ export interface SpacePaths {
 export declare function emptyRegistry(): SpaceRegistry;
 /** Every space in display order: Default first, then user spaces in creation order. */
 export declare function listSpaces(registry: SpaceRegistry): SpaceEntry[];
-/** Lowercase letters, digits and single hyphens, at most 40 characters. Empty when the name has none. */
-export declare function spaceIdFromName(name: string): string;
 /** True for a space id that is safe to use in a path: lowercase letters, digits and single hyphens. */
 export declare function isValidSpaceId(id: string): boolean;
 /** Finds a space by id, or by display name without regard to case. */
 export declare function findSpace(registry: SpaceRegistry, idOrName: string): SpaceEntry | undefined;
-/** Adds a space. Returns the new registry and the new entry. The active space does not change. */
-export declare function createSpace(registry: SpaceRegistry, name: string, now: string): {
+/** Draws a random space id: `space-` plus 10 lowercase letters and digits (ADR for random ids). */
+export declare function drawRandomSpaceId(): string;
+export interface CreateSpaceOptions {
+    /** Draws a candidate id. Tests inject a fixed source. */
+    drawId?: () => string;
+    /** Ids to refuse beyond the registry, such as folders already on disk. */
+    avoidIds?: readonly string[];
+}
+/** Adds a space with a random id. Returns the new registry and the new entry. The active space does not change. */
+export declare function createSpace(registry: SpaceRegistry, name: string, now: string, options?: CreateSpaceOptions): {
     registry: SpaceRegistry;
     space: SpaceEntry;
 };

package/dist/services/spaces/registry.js

@@ -1,3 +1,4 @@
+import { randomInt } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 /**
@@ -36,14 +37,6 @@ function defaultEntry(registry) {
 export function listSpaces(registry) {
     return [defaultEntry(registry), ...registry.spaces];
 }
-/** Lowercase letters, digits and single hyphens, at most 40 characters. Empty when the name has none. */
-export function spaceIdFromName(name) {
-    const id = name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-    return id.slice(0, MAX_SPACE_ID_LENGTH).replace(/-+$/, "");
-}
 const ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 /** True for a space id that is safe to use in a path: lowercase letters, digits and single hyphens. */
 export function isValidSpaceId(id) {
@@ -67,10 +60,10 @@ function requireSpace(registry, idOrName) {
     return space;
 }
 function validTargets(registry) {
-    const names = listSpaces(registry)
+    const targets = listSpaces(registry)
         .filter((space) => !space.archived)
-        .map((space) => space.id);
-    return `Spaces that can become active: ${names.join(", ")}.`;
+        .map((space) => `${space.name} (${space.id})`);
+    return `Spaces that can become active: ${targets.join(", ")}.`;
 }
 function checkedName(name) {
     const trimmed = name.trim();
@@ -79,23 +72,38 @@ function checkedName(name) {
     }
     return trimmed;
 }
-/** Adds a space. Returns the new registry and the new entry. The active space does not change. */
-export function createSpace(registry, name, now) {
+const RANDOM_ID_SUFFIX_LENGTH = 10;
+const ID_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+/** The most draws before createSpace gives up, so a broken source cannot loop forever. */
+const MAX_ID_DRAWS = 100;
+/** Draws a random space id: `space-` plus 10 lowercase letters and digits (ADR for random ids). */
+export function drawRandomSpaceId() {
+    let suffix = "";
+    for (let i = 0; i < RANDOM_ID_SUFFIX_LENGTH; i++) {
+        suffix += ID_ALPHABET[randomInt(ID_ALPHABET.length)];
+    }
+    return `space-${suffix}`;
+}
+/** Adds a space with a random id. Returns the new registry and the new entry. The active space does not change. */
+export function createSpace(registry, name, now, options = {}) {
     const display = checkedName(name);
     const existing = findByName(registry, display);
     if (existing) {
         throw new SpaceError("name-taken", `A space named "${existing.name}" already exists.`);
     }
-    const id = spaceIdFromName(display);
-    if (id === "") {
-        throw new SpaceError("invalid-name", "A space name needs at least one letter or digit.");
-    }
-    if (id === DEFAULT_SPACE_ID) {
-        throw new SpaceError("reserved", `The id "${DEFAULT_SPACE_ID}" belongs to the Default space.`);
-    }
-    const clash = registry.spaces.find((space) => space.id === id);
-    if (clash) {
-        throw new SpaceError("id-taken", `The name "${display}" gives the same folder id as "${clash.name}". Choose another name.`);
+    const drawId = options.drawId ?? drawRandomSpaceId;
+    const avoid = options.avoidIds ?? [];
+    let id = "";
+    for (let draws = 0;; draws++) {
+        if (draws >= MAX_ID_DRAWS) {
+            throw new SpaceError("invalid-id", "Could not draw an unused space id. Try again.");
+        }
+        id = drawId();
+        const taken = id === DEFAULT_SPACE_ID ||
+            avoid.includes(id) ||
+            registry.spaces.some((space) => space.id === id);
+        if (isValidSpaceId(id) && !taken)
+            break;
     }
     const space = { id, name: display, createdAt: now, archived: false };
     return { registry: { ...registry, spaces: [...registry.spaces, space] }, space };

package/dist/services/spaces/restore.js

@@ -72,7 +72,7 @@ async function createWithFreeName(files, name, now) {
             return await createStoredSpace(files, restoredName(name, now, attempt));
         }
         catch (error) {
-            const taken = error instanceof SpaceError && ["name-taken", "id-taken"].includes(error.code);
+            const taken = error instanceof SpaceError && error.code === "name-taken";
             if (!taken || attempt >= 50)
                 throw error;
         }

package/dist/services/spaces/space-label.d.ts

@@ -0,0 +1,16 @@
+import { type SpaceEntry, type SpaceRegistry } from "./registry.js";
+/** Writes the label of one space folder atomically: temp file in the folder, then rename. */
+export declare function writeSpaceLabel(folder: string, space: SpaceEntry): void;
+/**
+ * Adds or repairs the label of every existing space folder. A folder that does
+ * not exist is skipped: the pass never creates a folder and touches no other
+ * file. One failing folder does not stop the rest.
+ */
+export declare function backfillSpaceLabels(registry: SpaceRegistry, files: {
+    spacesRoot: string;
+}, globalStoragePath: string): void;
+/**
+ * Reads the registry from the OMMS folder and runs the backfill pass over it.
+ * Best effort: callers wrap it so a failure never reaches start-up.
+ */
+export declare function backfillSpaceLabelsFromDisk(ommsDir: string, globalStoragePath: string): void;

package/dist/services/spaces/space-label.js

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { listSpaces, readRegistryFile, resolveSpaceFolder, } from "./registry.js";
+/**
+ * The `space.json` label inside every space folder (space-folder-ids design). It
+ * names a folder found on disk. OMMS writes it but never reads it to decide
+ * anything: the registry stays the only source for ids, names and folders.
+ */
+const LABEL_FILE = "space.json";
+/** Writes the label of one space folder atomically: temp file in the folder, then rename. */
+export function writeSpaceLabel(folder, space) {
+    const target = join(folder, LABEL_FILE);
+    const temporary = `${target}.${process.pid}.tmp`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(spaceLabelOf(space), null, 2)}\n`);
+        renameSync(temporary, target);
+    }
+    catch (error) {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+        throw error;
+    }
+}
+function spaceLabelOf(space) {
+    // The Default space has no creation time in the registry, so its label keeps the empty string.
+    return { id: space.id, name: space.name, createdAt: space.createdAt };
+}
+/** The name in the folder label, or undefined when the file is missing or broken. */
+function labelName(folder) {
+    try {
+        const raw = JSON.parse(readFileSync(join(folder, LABEL_FILE), "utf-8"));
+        return typeof raw?.name === "string" ? raw.name : undefined;
+    }
+    catch {
+        // A missing or broken label is rewritten, never trusted.
+        return undefined;
+    }
+}
+/**
+ * Adds or repairs the label of every existing space folder. A folder that does
+ * not exist is skipped: the pass never creates a folder and touches no other
+ * file. One failing folder does not stop the rest.
+ */
+export function backfillSpaceLabels(registry, files, globalStoragePath) {
+    for (const space of listSpaces(registry)) {
+        try {
+            const folder = resolveSpaceFolder(space.id, {
+                globalStoragePath,
+                spacesRoot: files.spacesRoot,
+            });
+            if (!existsSync(folder))
+                continue;
+            if (labelName(folder) === space.name)
+                continue;
+            writeSpaceLabel(folder, space);
+        }
+        catch {
+            // The label is metadata; the registry entry is what counts.
+        }
+    }
+}
+/**
+ * Reads the registry from the OMMS folder and runs the backfill pass over it.
+ * Best effort: callers wrap it so a failure never reaches start-up.
+ */
+export function backfillSpaceLabelsFromDisk(ommsDir, globalStoragePath) {
+    const { registry } = readRegistryFile(join(ommsDir, "spaces.json"));
+    backfillSpaceLabels(registry, { spacesRoot: join(ommsDir, "spaces") }, globalStoragePath);
+}

package/dist/services/web-route-modules.d.ts

@@ -10,4 +10,6 @@ export type RouteModuleResult = RouteResult & {
  * ceiling. Each returns undefined for paths it does not own. The request body
  * is read once, and only by a route that needs it.
  */
-export declare function routeModules(path: string, method: string, url: URL, req: Request, ctx: SkillRouteContext): Promise<RouteModuleResult | undefined>;
+export declare function routeModules(path: string, method: string, url: URL, req: Request, ctx: SkillRouteContext & {
+    remoteAddress?: string;
+}): Promise<RouteModuleResult | undefined>;

package/dist/services/web-route-modules.js

@@ -26,7 +26,9 @@ export async function routeModules(path, method, url, req, ctx) {
     const transfers = await routeSpaceTransfers(path, method, req, ctx.cwd);
     if (transfers !== undefined)
         return transfers;
-    const spaces = await routeSpaces(path, method, readBody, ctx.cwd);
+    const spaces = await routeSpaces(path, method, readBody, ctx.cwd, {
+        remoteAddress: ctx.remoteAddress,
+    });
     if (spaces !== undefined)
         return spaces;
     return routeChat(path, method, readBody, config);

package/dist/services/web-server.js

@@ -1375,6 +1375,7 @@ export class WebServer {
             }
             const routed = await routeModules(path, method, url, req, {
                 cwd: this.config.directory ?? process.cwd(),
+                remoteAddress,
                 startRecordPast: async (cwd) => (await import("../importer/web-import-api.js")).startRecordPast(this.importJobs, cwd),
             });
             if (routed)

package/dist/v2/plugin.js

@@ -1,8 +1,64 @@
+import { fileURLToPath } from "node:url";
 import { OmmsPlugin } from "../index.js";
 import { loadOpencodeProvider } from "../adapters/opencode/opencode-provider-loader.js";
 import { registerV2Adapter } from "./adapter.js";
 import { createV2MemoryBridge } from "./memory-bridge.js";
 import { createLegacyClient } from "./legacy-client.js";
+/**
+ * Remove old OMMS copies from the OpenCode cache. It runs in the background and
+ * is not awaited, so a slow or failing clean-up never delays or breaks setup.
+ * `OMMS_DISABLE_UPDATE_CHECK` does not stop it: removing old copies saves disk
+ * space and installs nothing. It keeps the copy that `~/.omms/runtime.json` names.
+ */
+function startCacheCleanup() {
+    void (async () => {
+        const modulePath = fileURLToPath(import.meta.url);
+        const [{ installedFromNpm }, { pruneOldCacheCopies }, { readRuntimeRecord }, { ommsDir }, { packageVersion }, { log },] = await Promise.all([
+            import("../services/host-self-update.js"),
+            import("../services/host-copies.js"),
+            import("../services/runtime-record.js"),
+            import("../services/runtime-handoff.js"),
+            import("../services/package-version.js"),
+            import("../services/logger.js"),
+        ]);
+        if (!installedFromNpm(modulePath))
+            return;
+        const recorded = readRuntimeRecord(ommsDir());
+        await pruneOldCacheCopies({
+            modulePath,
+            runningVersion: packageVersion(),
+            keepRoots: recorded ? [recorded.root] : [],
+            now: Date.now(),
+            log: (message, data) => log(message, data),
+        });
+    })().catch(() => { });
+}
+let serviceUpdateStarted = false;
+/**
+ * Check npm for a newer OMMS from the background service too, so OpenCode
+ * without a TUI (OpenChamber, `opencode serve`) also updates. Once per
+ * process: setup can run for each project. Not awaited; a failure is ignored.
+ */
+function startServiceSelfUpdate() {
+    if (serviceUpdateStarted)
+        return;
+    serviceUpdateStarted = true;
+    void (async () => {
+        const modulePath = fileURLToPath(import.meta.url);
+        const [{ opencodeSelfUpdateDeps, startOpencodeServiceSelfUpdate }, { startHostSelfUpdate }, { packageVersion }, { log },] = await Promise.all([
+            import("../adapters/opencode/self-update.js"),
+            import("../services/host-self-update.js"),
+            import("../services/package-version.js"),
+            import("../services/logger.js"),
+        ]);
+        const deps = opencodeSelfUpdateDeps({
+            modulePath,
+            currentVersion: packageVersion(),
+            log: (message, data) => log(message, data),
+        });
+        startOpencodeServiceSelfUpdate({ run: () => startHostSelfUpdate(deps) });
+    })().catch(() => { });
+}
 const OmmsPluginV2 = {
     id: "omms",
     async setup(ctx) {
@@ -18,7 +74,10 @@ const OmmsPluginV2 = {
         // context. Route internal structured-output calls through the adapter.
         const { setV2Client } = await loadOpencodeProvider();
         setV2Client(legacyClient);
-        return registerV2Adapter(ctx, legacy, createV2MemoryBridge(ctx.location.directory));
+        const adapter = await registerV2Adapter(ctx, legacy, createV2MemoryBridge(ctx.location.directory));
+        startCacheCleanup();
+        startServiceSelfUpdate();
+        return adapter;
     },
 };
 export default OmmsPluginV2;