@olane/os 0.8.16 → 0.8.17

package/dist/src/worlds/world-manager.tool.js

@@ -0,0 +1,270 @@
+import { oLaneTool } from '@olane/o-lane';
+import { oAddress, DEFAULT_INSTANCE_PATH } from '@olane/o-core';
+import { WorldInstanceTool } from './world-instance.tool.js';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { watch } from 'node:fs';
+/**
+ * WorldManagerTool — dedicated oLaneTool node at o://world-manager.
+ * Child of the root leader. Manages the lifecycle of all world instance nodes.
+ *
+ * On startup: reads persisted world configs and starts a WorldInstanceTool child for each.
+ */
+export class WorldManagerTool extends oLaneTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://world-manager'),
+            description: 'Manages world instances (branded networks)',
+            methods: {
+                create_world: {
+                    name: 'create_world',
+                    description: 'Create a new world (branded network)',
+                    parameters: [
+                        { name: 'name', type: 'string', required: true, description: 'World name' },
+                        { name: 'description', type: 'string', required: false, description: 'World description' },
+                        { name: 'icon', type: 'string', required: false, description: 'World icon' },
+                        { name: 'supportedTypes', type: 'array', required: false, description: 'Supported address types' },
+                        { name: 'createdBy', type: 'string', required: false, description: 'Copass ID of creator' },
+                    ],
+                    dependencies: [],
+                },
+                remove_world: {
+                    name: 'remove_world',
+                    description: 'Remove a world',
+                    parameters: [
+                        { name: 'id', type: 'string', required: true, description: 'World ID' },
+                    ],
+                    dependencies: [],
+                },
+                list_worlds: {
+                    name: 'list_worlds',
+                    description: 'List all worlds',
+                    parameters: [],
+                    dependencies: [],
+                },
+                join_world: {
+                    name: 'join_world',
+                    description: 'Join a world by Copass ID',
+                    parameters: [
+                        { name: 'id', type: 'string', required: true, description: 'World ID' },
+                        { name: 'copassId', type: 'string', required: true, description: 'Copass ID' },
+                    ],
+                    dependencies: [],
+                },
+            },
+        });
+        this.worlds = new Map();
+        this.fsWatcher = null;
+        this.syncDebounce = null;
+        this.storagePath =
+            config.storagePath ??
+                path.join(DEFAULT_INSTANCE_PATH, '..', 'storage', config.systemName || 'default', 'worlds');
+    }
+    async start() {
+        await super.start();
+        await fs.ensureDir(this.storagePath);
+        await this.restoreWorlds();
+        this.startWatching();
+    }
+    async stop() {
+        this.stopWatching();
+        await super.stop();
+    }
+    /**
+     * Watch the worlds directory for file changes.
+     * When the CLI writes a new address to a world JSON,
+     * the running instance picks it up and syncs to memory.
+     */
+    startWatching() {
+        try {
+            this.fsWatcher = watch(this.storagePath, (event, filename) => {
+                if (!filename?.endsWith('.json'))
+                    return;
+                // Debounce — multiple events fire for a single write
+                if (this.syncDebounce)
+                    clearTimeout(this.syncDebounce);
+                this.syncDebounce = setTimeout(() => {
+                    this.syncFromDisk(filename).catch((err) => this.logger.warn(`Failed to sync world file ${filename}:`, err));
+                }, 500);
+            });
+            this.fsWatcher.unref(); // Don't prevent process exit
+            this.logger.debug('Watching worlds directory for changes');
+        }
+        catch (err) {
+            this.logger.warn('Could not watch worlds directory:', err);
+        }
+    }
+    stopWatching() {
+        if (this.syncDebounce)
+            clearTimeout(this.syncDebounce);
+        if (this.fsWatcher) {
+            this.fsWatcher.close();
+            this.fsWatcher = null;
+        }
+    }
+    /**
+     * Sync a world from its JSON file on disk into the running instance.
+     * Handles both new worlds and updated addresses on existing worlds.
+     */
+    async syncFromDisk(filename) {
+        const filePath = path.join(this.storagePath, filename);
+        if (!(await fs.pathExists(filePath)))
+            return;
+        try {
+            const data = await fs.readJson(filePath);
+            const worldConfig = data.config;
+            if (!worldConfig?.id)
+                return;
+            const existing = this.worlds.get(worldConfig.id);
+            if (existing) {
+                // Sync addresses: add any new ones from disk into the running instance
+                const diskAddresses = data.addresses || [];
+                const currentAddresses = existing.getAddresses();
+                for (const addr of diskAddresses) {
+                    const alreadyLoaded = currentAddresses.some((a) => a.address === addr.address);
+                    if (!alreadyLoaded) {
+                        await existing._tool_register_address({
+                            params: { address: addr.address, type: addr.type, metadata: addr.metadata },
+                        });
+                        this.logger.debug(`Synced new address '${addr.address}' to world '${worldConfig.name}'`);
+                    }
+                }
+            }
+            else {
+                // New world — start it
+                const instance = await this.startWorldInstance(worldConfig);
+                this.worlds.set(worldConfig.id, instance);
+                this.logger.debug(`Synced new world from disk: ${worldConfig.name}`);
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Failed to parse world file ${filename}:`, err);
+        }
+    }
+    // ── Tool methods ───────────────────────────────────────────
+    async _tool_create_world(request) {
+        const { name, description, icon, supportedTypes, createdBy } = request.params;
+        const id = `world-${name.toLowerCase().replace(/[^a-z0-9-]/g, '-')}`;
+        if (this.worlds.has(id)) {
+            return { success: false, error: `World '${name}' already exists` };
+        }
+        const worldConfig = {
+            id,
+            name,
+            description,
+            icon,
+            supportedTypes: supportedTypes || ['filepath'],
+            members: createdBy ? [createdBy] : [],
+            createdAt: new Date().toISOString(),
+            createdBy,
+        };
+        const instance = await this.startWorldInstance(worldConfig);
+        this.worlds.set(id, instance);
+        await this.persistWorldConfig(worldConfig);
+        return { success: true, world: worldConfig };
+    }
+    async _tool_remove_world(request) {
+        const { id } = request.params;
+        const instance = this.worlds.get(id);
+        if (!instance) {
+            return { success: false, error: `World '${id}' not found` };
+        }
+        await instance.stop();
+        this.worlds.delete(id);
+        const worldFile = path.join(this.storagePath, `${id}.json`);
+        if (await fs.pathExists(worldFile)) {
+            await fs.remove(worldFile);
+        }
+        return { success: true };
+    }
+    async _tool_list_worlds(_request) {
+        const worlds = Array.from(this.worlds.values()).map((w) => w.world);
+        return { success: true, worlds };
+    }
+    async _tool_join_world(request) {
+        const { id, copassId } = request.params;
+        const instance = this.worlds.get(id);
+        if (!instance) {
+            return { success: false, error: `World '${id}' not found` };
+        }
+        if (!instance.world.members.includes(copassId)) {
+            instance.world.members.push(copassId);
+            await this.persistWorldConfig(instance.world);
+        }
+        return { success: true };
+    }
+    // ── Public accessors ───────────────────────────────────────
+    listWorlds() {
+        return Array.from(this.worlds.values()).map((w) => w.world);
+    }
+    getWorldInstance(id) {
+        return this.worlds.get(id);
+    }
+    /**
+     * Create a world (public convenience, delegates to _tool_create_world).
+     */
+    async createWorld(params) {
+        return this._tool_create_world({ params });
+    }
+    /**
+     * Join a world (public convenience, delegates to _tool_join_world).
+     */
+    async joinWorld(id, copassId) {
+        return this._tool_join_world({ params: { id, copassId } });
+    }
+    // ── Internal ───────────────────────────────────────────────
+    async startWorldInstance(worldConfig) {
+        const slug = worldConfig.name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+        const worldAddress = new oAddress(`o://world-manager/${slug}`);
+        const persistFile = path.join(this.storagePath, `${worldConfig.id}.json`);
+        const instance = new WorldInstanceTool({
+            address: worldAddress,
+            leader: this.address,
+            parent: this.address,
+            _allowNestedAddress: true,
+        }, worldConfig, persistFile);
+        this.addChildNode(instance);
+        await instance.start();
+        return instance;
+    }
+    async restoreWorlds() {
+        try {
+            const files = await fs.readdir(this.storagePath);
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                try {
+                    const data = await fs.readJson(path.join(this.storagePath, file));
+                    const worldConfig = data.config || data;
+                    if (worldConfig.id && worldConfig.name) {
+                        const instance = await this.startWorldInstance(worldConfig);
+                        this.worlds.set(worldConfig.id, instance);
+                        this.logger.debug(`Restored world: ${worldConfig.name}`);
+                    }
+                }
+                catch (err) {
+                    this.logger.error(`Failed to restore world from ${file}:`, err);
+                }
+            }
+        }
+        catch {
+            // No worlds to restore
+        }
+    }
+    async persistWorldConfig(config) {
+        await fs.ensureDir(this.storagePath);
+        const existing = path.join(this.storagePath, `${config.id}.json`);
+        let addresses = [];
+        try {
+            if (await fs.pathExists(existing)) {
+                const data = await fs.readJson(existing);
+                addresses = data.addresses || [];
+            }
+        }
+        catch {
+            // ignore
+        }
+        await fs.writeJson(existing, { config, addresses }, { spaces: 2 });
+    }
+}

package/dist/src/worlds/world.types.d.ts

@@ -0,0 +1,23 @@
+export type WorldSupportedType = 'filepath';
+export interface WorldConfig {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    networkId?: string;
+    supportedTypes: WorldSupportedType[];
+    members: string[];
+    createdAt: string;
+    createdBy?: string;
+}
+export interface WorldAddressEntry {
+    address: string;
+    type: WorldSupportedType;
+    registeredAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface WorldData {
+    config: WorldConfig;
+    addresses: WorldAddressEntry[];
+}
+//# sourceMappingURL=world.types.d.ts.map

package/dist/src/worlds/world.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.types.d.ts","sourceRoot":"","sources":["../../../src/worlds/world.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC;AAE5C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,kBAAkB,EAAE,CAAC;IACrC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,kBAAkB,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,iBAAiB,EAAE,CAAC;CAChC"}

package/dist/src/worlds/world.types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/os",
-  "version": "0.8.16",
+  "version": "0.8.17",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -58,23 +58,24 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@olane/o-client-limited": "0.8.16",
-    "@olane/o-config": "0.8.16",
-    "@olane/o-core": "0.8.16",
-    "@olane/o-intelligence": "0.8.16",
-    "@olane/o-lane": "0.8.16",
-    "@olane/o-leader": "0.8.16",
-    "@olane/o-login": "0.8.16",
-    "@olane/o-protocol": "0.8.16",
-    "@olane/o-storage": "0.8.16",
-    "@olane/o-tool": "0.8.16",
-    "@olane/o-tool-registry": "0.8.16",
-    "@olane/o-tools-common": "0.8.16",
+    "@libp2p/circuit-relay-v2": "^4.1.3",
+    "@olane/o-client-limited": "0.8.17",
+    "@olane/o-config": "0.8.17",
+    "@olane/o-core": "0.8.17",
+    "@olane/o-intelligence": "0.8.17",
+    "@olane/o-lane": "0.8.17",
+    "@olane/o-leader": "0.8.17",
+    "@olane/o-login": "0.8.17",
+    "@olane/o-protocol": "0.8.17",
+    "@olane/o-storage": "0.8.17",
+    "@olane/o-tool": "0.8.17",
+    "@olane/o-tool-registry": "0.8.17",
+    "@olane/o-tools-common": "0.8.17",
     "chalk": "^5.6.2",
     "debug": "^4.4.3",
     "dotenv": "^17.3.1",
     "fs-extra": "^11.3.3",
     "touch": "^3.1.1"
   },
-  "gitHead": "8e724c4efc57e8d771394815b036322085deff33"
+  "gitHead": "848be12a374d32f799026feecf15ada6bcf753ff"
 }