@olane/os 0.8.16 → 0.8.18

package/dist/src/o-olane-os/o-os.js

@@ -1,6 +1,8 @@
 import { OlaneOSSystemStatus } from './enum/o-os.status-enum.js';
 import touch from 'touch';
 import { readFile } from 'fs/promises';
+import { mkdir } from 'fs/promises';
+import * as path from 'path';
 import { oLeaderNode } from '@olane/o-leader';
 import { oAddress, oObject } from '@olane/o-core';
 import { NodeType } from '@olane/o-core';
@@ -10,6 +12,11 @@ import { ConfigManager } from '../utils/config.js';
 import { oLaneTool } from '@olane/o-lane';
 import { oLaneStorage } from '@olane/o-storage';
 import { oNodeAddress } from '@olane/o-node';
+import { WorldManagerTool } from '../worlds/world-manager.tool.js';
+import { AddressBook } from '../address-book/address-book.js';
+import { MemoryHarness } from '../memory/memory-harness.js';
+import { CopassVectorStoreTool } from '../vector-store/copass-vector-store.tool.js';
+import { FilesystemTool } from '../tools/filesystem.tool.js';
 export class OlaneOS extends oObject {
     constructor(config) {
         super();
@@ -17,6 +24,10 @@ export class OlaneOS extends oObject {
         this.nodes = []; // clones of node for scale
         this.rootLeader = null; // the root leader node
         this.roundRobinIndex = 0;
+        this.worldManager = null;
+        this.addressBook = null;
+        this.memory = null;
+        this.filesystemTool = null;
         this.config = config;
     }
     entryNode() {
@@ -50,14 +61,17 @@ export class OlaneOS extends oObject {
         // Then we'll migrate to using o://os-config for persistence
         if (this.config.configFilePath) {
             try {
+                // Ensure parent directory exists before touch
+                await mkdir(path.dirname(this.config.configFilePath), { recursive: true });
                 await touch(this.config.configFilePath);
                 this.logger.debug('Config file path: ' + this.config.configFilePath);
                 // let's load the config
                 const config = await readFile(this.config.configFilePath, 'utf8');
                 this.logger.debug('Config file contents: ' + config);
-                if (config?.length === 0) {
-                    // no contents, let's create a new config
-                    throw new Error('No config file found, cannot start OS instance');
+                if (!config || config.trim().length === 0) {
+                    // Empty file (fresh OS) — use the in-memory config as-is
+                    this.logger.debug('Empty config file, using constructor config');
+                    return;
                 }
                 const json = JSON.parse(config);
                 this.logger.debug('Config file parsed: ' + json);
@@ -246,6 +260,104 @@ export class OlaneOS extends oObject {
             // Don't throw - allow OS to continue even if replay fails
         }
     }
+    /**
+     * Initialize world manager, address book, and memory harness
+     * after the leader and nodes are started.
+     */
+    async initOSServices() {
+        const instanceName = (await this.getOSInstanceName()) ||
+            this.config.network?.name ||
+            'default';
+        // Address book
+        this.addressBook = new AddressBook(instanceName);
+        await this.addressBook.load();
+        // OS service nodes (children of root leader)
+        if (this.rootLeader) {
+            // Memory harness — shells out to `olane ingest/copass` CLI
+            this.memory = new MemoryHarness();
+            this.logger.debug('Memory harness initialized');
+            // Vector store — routes to Copass backend so index_network
+            // and any o://vector-store calls go through the memory harness
+            const vectorStore = new CopassVectorStoreTool({
+                address: new oAddress('o://vector-store'),
+                leader: this.rootLeader.address,
+                parent: this.rootLeader.address,
+                _allowNestedAddress: true,
+            });
+            this.rootLeader.addChildNode(vectorStore);
+            await vectorStore.start();
+            this.logger.debug('Copass vector store started');
+            // Filesystem tool — single instance for the entire OS
+            this.filesystemTool = new FilesystemTool({
+                address: new oAddress('o://fs'),
+                leader: this.rootLeader.address,
+                parent: this.rootLeader.address,
+                _allowNestedAddress: true,
+            });
+            this.rootLeader.addChildNode(this.filesystemTool);
+            await this.filesystemTool.start();
+            this.logger.debug('Filesystem tool started');
+            // World manager
+            this.worldManager = new WorldManagerTool({
+                leader: this.rootLeader.address,
+                parent: this.rootLeader.address,
+                systemName: instanceName,
+                _allowNestedAddress: true,
+            });
+            this.rootLeader.addChildNode(this.worldManager);
+            await this.worldManager.start();
+            this.logger.debug('World manager started');
+        }
+    }
+    /**
+     * Only index if `indexCompletedAt` is not set in the instance config.
+     * Records the timestamp after successful indexing.
+     */
+    async indexOnceInBackground() {
+        const osName = await this.getOSInstanceName();
+        if (osName) {
+            const existing = await ConfigManager.getOSConfig(osName);
+            if (existing?.indexCompletedAt) {
+                this.logger.debug('Network already indexed, skipping');
+                return;
+            }
+        }
+        await this.indexNetworkParallel();
+        // Record completion
+        if (osName) {
+            const config = await ConfigManager.getOSConfig(osName);
+            if (config) {
+                await ConfigManager.saveOSConfig({
+                    ...config,
+                    indexCompletedAt: new Date().toISOString(),
+                });
+            }
+        }
+    }
+    /**
+     * Index all nodes in the network in parallel.
+     * Each node indexes itself + its children concurrently,
+     * rather than the default sequential tree walk.
+     */
+    async indexNetworkParallel() {
+        const allNodes = [
+            ...this.leaders,
+            ...this.nodes,
+        ];
+        this.logger.debug(`Indexing ${allNodes.length} node(s) in parallel...`);
+        await Promise.allSettled(allNodes.map(async (node) => {
+            try {
+                await node.use(node.address, {
+                    method: 'index_network',
+                    params: {},
+                });
+            }
+            catch (err) {
+                this.logger.warn(`Failed to index ${node.address.toString()}: ${err}`);
+            }
+        }));
+        this.logger.debug('Parallel network indexing complete');
+    }
     async use(oAddress, params) {
         const entryNode = this.entryNode();
         if (!entryNode) {
@@ -265,6 +377,9 @@ export class OlaneOS extends oObject {
         this.logger.debug('Leaders started...');
         await this.startNodes(NodeType.NODE);
         this.logger.debug('Nodes started...');
+        // Initialize world manager, address book, and memory harness
+        await this.initOSServices();
+        this.logger.debug('OS services initialized...');
         // Load config from o://os-config storage backend (after tools are initialized)
         // This merges any saved lanes from persistent storage
         await this.loadConfigFromStorage();
@@ -273,14 +388,11 @@ export class OlaneOS extends oObject {
         await this.runSavedPlans();
         this.logger.debug('Saved plans run...');
         this.logger.debug('OS instance started...');
-        // index the OS instance
+        this.status = OlaneOSSystemStatus.RUNNING;
+        // Index the network once (first boot only), in the background.
         if (!this.config.noIndexNetwork) {
-            await this.use(oAddress.leader(), {
-                method: 'index_network',
-                params: {},
-            });
+            this.indexOnceInBackground().catch((err) => this.logger.error('Background network indexing failed:', err));
         }
-        this.status = OlaneOSSystemStatus.RUNNING;
         return {
             peerId: this.rootLeader?.peerId.toString() || '',
             transports: this.rootLeader?.transports || [],

package/dist/src/tools/filesystem.tool.d.ts

@@ -0,0 +1,24 @@
+import { oNodeConfig } from '@olane/o-node';
+import { oLaneTool } from '@olane/o-lane';
+import { oRequest } from '@olane/o-core';
+import type { ToolResult } from '@olane/o-tool';
+/**
+ * FilesystemTool — an oLaneTool that provides scoped filesystem access.
+ * A single instance exists per OS at o://fs, shared across all worlds.
+ *
+ * The tool maintains a list of allowed directory paths (addresses).
+ * All file operations are restricted to these directories.
+ */
+export declare class FilesystemTool extends oLaneTool {
+    private allowedPaths;
+    constructor(config: oNodeConfig, allowedPaths?: string[]);
+    getAllowedPaths(): string[];
+    _tool_add_path(request: oRequest): Promise<ToolResult>;
+    _tool_remove_path(request: oRequest): Promise<ToolResult>;
+    _tool_list_paths(_request: oRequest): Promise<ToolResult>;
+    _tool_read_file(request: oRequest): Promise<ToolResult>;
+    _tool_list_files(request: oRequest): Promise<ToolResult>;
+    _tool_stat_path(request: oRequest): Promise<ToolResult>;
+    private isWithinAllowedPath;
+}
+//# sourceMappingURL=filesystem.tool.d.ts.map

package/dist/src/tools/filesystem.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/filesystem.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAIhD;;;;;;GAMG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C,OAAO,CAAC,YAAY,CAAgB;gBAExB,MAAM,EAAE,WAAW,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE;IAyDxD,eAAe,IAAI,MAAM,EAAE;IAMrB,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAqBtD,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAQzD,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAMzD,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAgBvD,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAwBxD,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAyB7D,OAAO,CAAC,mBAAmB;CAK5B"}

package/dist/src/tools/filesystem.tool.js

@@ -0,0 +1,163 @@
+import { oLaneTool } from '@olane/o-lane';
+import { readFile, readdir, stat, access } from 'fs/promises';
+import * as path from 'path';
+/**
+ * FilesystemTool — an oLaneTool that provides scoped filesystem access.
+ * A single instance exists per OS at o://fs, shared across all worlds.
+ *
+ * The tool maintains a list of allowed directory paths (addresses).
+ * All file operations are restricted to these directories.
+ */
+export class FilesystemTool extends oLaneTool {
+    constructor(config, allowedPaths) {
+        super({
+            ...config,
+            description: 'Scoped filesystem access for a world',
+            methods: {
+                add_path: {
+                    name: 'add_path',
+                    description: 'Add a directory path to the allowed list',
+                    parameters: [
+                        { name: 'path', type: 'string', required: true, description: 'Absolute directory path' },
+                    ],
+                    dependencies: [],
+                },
+                remove_path: {
+                    name: 'remove_path',
+                    description: 'Remove a directory path from the allowed list',
+                    parameters: [
+                        { name: 'path', type: 'string', required: true, description: 'Path to remove' },
+                    ],
+                    dependencies: [],
+                },
+                list_paths: {
+                    name: 'list_paths',
+                    description: 'List all allowed directory paths',
+                    parameters: [],
+                    dependencies: [],
+                },
+                read_file: {
+                    name: 'read_file',
+                    description: 'Read a file within an allowed path',
+                    parameters: [
+                        { name: 'path', type: 'string', required: true, description: 'File path to read' },
+                    ],
+                    dependencies: [],
+                },
+                list_files: {
+                    name: 'list_files',
+                    description: 'List files in a directory within an allowed path',
+                    parameters: [
+                        { name: 'path', type: 'string', required: true, description: 'Directory path' },
+                        { name: 'recursive', type: 'boolean', required: false, description: 'List recursively' },
+                    ],
+                    dependencies: [],
+                },
+                stat_path: {
+                    name: 'stat_path',
+                    description: 'Get file/directory info within an allowed path',
+                    parameters: [
+                        { name: 'path', type: 'string', required: true, description: 'Path to stat' },
+                    ],
+                    dependencies: [],
+                },
+            },
+        });
+        this.allowedPaths = [];
+        this.allowedPaths = allowedPaths || [];
+    }
+    getAllowedPaths() {
+        return [...this.allowedPaths];
+    }
+    // ── Path management ────────────────────────────────────────
+    async _tool_add_path(request) {
+        const { path: dirPath } = request.params;
+        const resolved = path.resolve(dirPath);
+        try {
+            await access(resolved);
+            const stats = await stat(resolved);
+            if (!stats.isDirectory()) {
+                return { success: false, error: `'${resolved}' is not a directory` };
+            }
+        }
+        catch {
+            return { success: false, error: `'${resolved}' does not exist or is not accessible` };
+        }
+        if (!this.allowedPaths.includes(resolved)) {
+            this.allowedPaths.push(resolved);
+        }
+        return { success: true, path: resolved };
+    }
+    async _tool_remove_path(request) {
+        const { path: dirPath } = request.params;
+        const resolved = path.resolve(dirPath);
+        const before = this.allowedPaths.length;
+        this.allowedPaths = this.allowedPaths.filter((p) => p !== resolved);
+        return { success: true, removed: this.allowedPaths.length < before };
+    }
+    async _tool_list_paths(_request) {
+        return { success: true, paths: [...this.allowedPaths] };
+    }
+    // ── File operations (scoped to allowed paths) ──────────────
+    async _tool_read_file(request) {
+        const { path: filePath } = request.params;
+        const resolved = path.resolve(filePath);
+        if (!this.isWithinAllowedPath(resolved)) {
+            return { success: false, error: `'${resolved}' is outside allowed paths` };
+        }
+        try {
+            const content = await readFile(resolved, 'utf8');
+            return { success: true, content, path: resolved };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to read: ${err}` };
+        }
+    }
+    async _tool_list_files(request) {
+        const { path: dirPath, recursive } = request.params;
+        const resolved = path.resolve(dirPath);
+        if (!this.isWithinAllowedPath(resolved)) {
+            return { success: false, error: `'${resolved}' is outside allowed paths` };
+        }
+        try {
+            const entries = await readdir(resolved, {
+                withFileTypes: true,
+                recursive: !!recursive,
+            });
+            const files = entries.map((e) => ({
+                name: e.name,
+                isDirectory: e.isDirectory(),
+                path: path.join(e.parentPath || resolved, e.name),
+            }));
+            return { success: true, files };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to list: ${err}` };
+        }
+    }
+    async _tool_stat_path(request) {
+        const { path: targetPath } = request.params;
+        const resolved = path.resolve(targetPath);
+        if (!this.isWithinAllowedPath(resolved)) {
+            return { success: false, error: `'${resolved}' is outside allowed paths` };
+        }
+        try {
+            const stats = await stat(resolved);
+            return {
+                success: true,
+                path: resolved,
+                isFile: stats.isFile(),
+                isDirectory: stats.isDirectory(),
+                size: stats.size,
+                modified: stats.mtime.toISOString(),
+            };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to stat: ${err}` };
+        }
+    }
+    // ── Helpers ────────────────────────────────────────────────
+    isWithinAllowedPath(filePath) {
+        return this.allowedPaths.some((allowed) => filePath === allowed || filePath.startsWith(allowed + path.sep));
+    }
+}

package/dist/src/utils/config.d.ts

@@ -14,6 +14,12 @@ export interface OlaneOSInstanceConfig {
     transports?: string[];
     oNetworkConfig?: OlaneOSConfig;
     remoteLeaderAddress?: oNodeAddress;
+    /** Copass ID linked to this OS instance. */
+    copassId?: string;
+    /** World ID if this instance represents a world. */
+    worldId?: string;
+    /** Timestamp of first completed network index. */
+    indexCompletedAt?: string;
 }
 export interface CLIConfig {
     instancesPath: string;
@@ -29,7 +35,7 @@ export declare class ConfigManager {
     static getConfig(): Promise<CLIConfig>;
     static saveConfig(config: Partial<CLIConfig>): Promise<void>;
     static writeConfig(config: Partial<CLIConfig>): Promise<void>;
-    static getOSConfigFromPath(path: string): Promise<OlaneOSInstanceConfig | null>;
+    static getOSConfigFromPath(p: string): Promise<OlaneOSInstanceConfig | null>;
     static getOSConfig(name: string): Promise<OlaneOSInstanceConfig | null>;
     static updateOSConfig(config: OlaneOSInstanceConfig): Promise<OlaneOSInstanceConfig | null>;
     static saveOSConfig(config: OlaneOSInstanceConfig): Promise<void>;

package/dist/src/utils/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/utils/config.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,mBAAmB,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B,mBAAmB,CAAC,EAAE,YAAY,CAAC;CACpC;AAED,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC5C;AAED,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAE9C,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;IAChD,OAAO,CAAC,MAAM,CAAC,aAAa,CAAyB;IACrD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;WAEnC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASxC,MAAM,CAAC,gBAAgB,IAAI,SAAS;WAOvB,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC;WAM/B,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAOrD,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAItD,mBAAmB,CAC9B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAO3B,WAAW,CACtB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAY3B,cAAc,CACzB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAQ3B,YAAY,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;WAS1D,eAAe,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;WAuBnD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAM3D"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/utils/config.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,mBAAmB,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B,mBAAmB,CAAC,EAAE,YAAY,CAAC;IACnC,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC5C;AAED,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAoB9C,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;IAChD,OAAO,CAAC,MAAM,CAAC,aAAa,CAAyB;IACrD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;WAEnC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASxC,MAAM,CAAC,gBAAgB,IAAI,SAAS;WAOvB,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC;WAM/B,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAOrD,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAItD,mBAAmB,CAC9B,CAAC,EAAE,MAAM,GACR,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAW3B,WAAW,CACtB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAY3B,cAAc,CACzB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAQ3B,YAAY,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;WAQ1D,eAAe,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;WAsBnD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAM3D"}

package/dist/src/utils/config.js

@@ -1,12 +1,28 @@
-import * as fs from 'fs-extra';
+import { readFile, writeFile, mkdir, readdir, rm, access } from 'fs/promises';
 import * as path from 'path';
 import { DEFAULT_CONFIG_PATH, DEFAULT_INSTANCE_PATH, DEFAULT_CONFIG_FILE, } from '@olane/o-core';
 export const CONFIG_FILE_NAME = 'config.json';
+async function pathExists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(p) {
+    const data = await readFile(p, 'utf8');
+    return JSON.parse(data);
+}
+async function writeJson(p, data, opts) {
+    await writeFile(p, JSON.stringify(data, null, opts?.spaces), 'utf8');
+}
 export class ConfigManager {
     static async initialize() {
-        await fs.ensureDir(ConfigManager.configPath);
-        await fs.ensureDir(ConfigManager.instancesPath);
-        if (!(await fs.pathExists(ConfigManager.configFile))) {
+        await mkdir(ConfigManager.configPath, { recursive: true });
+        await mkdir(ConfigManager.instancesPath, { recursive: true });
+        if (!(await pathExists(ConfigManager.configFile))) {
             await this.writeConfig(this.getDefaultConfig());
         }
     }
@@ -18,7 +34,7 @@ export class ConfigManager {
     }
     static async getConfig() {
         await this.initialize();
-        const config = await fs.readJson(ConfigManager.configFile);
+        const config = await readJson(ConfigManager.configFile);
         return { ...this.getDefaultConfig(), ...config };
     }
     static async saveConfig(config) {
@@ -28,18 +44,25 @@ export class ConfigManager {
         await this.writeConfig(newConfig);
     }
     static async writeConfig(config) {
-        await fs.writeJson(ConfigManager.configFile, config, { spaces: 2 });
+        await writeJson(ConfigManager.configFile, config, { spaces: 2 });
     }
-    static async getOSConfigFromPath(path) {
-        if (await fs.pathExists(path)) {
-            return await fs.readJson(path);
+    static async getOSConfigFromPath(p) {
+        try {
+            if (!(await pathExists(p)))
+                return null;
+            const raw = await readFile(p, 'utf8');
+            if (!raw || !raw.trim())
+                return null;
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
         }
-        return null;
     }
     static async getOSConfig(name) {
         const configPath = path.join(ConfigManager.instancesPath, name, CONFIG_FILE_NAME);
-        if (await fs.pathExists(configPath)) {
-            return await fs.readJson(configPath);
+        if (await pathExists(configPath)) {
+            return await readJson(configPath);
         }
         return null;
     }
@@ -51,10 +74,9 @@ export class ConfigManager {
         return c;
     }
     static async saveOSConfig(config) {
-        // Use direct filesystem operations for OS config persistence
         const osPath = path.join(ConfigManager.instancesPath, config.name);
-        await fs.ensureDir(osPath);
-        await fs.writeJson(path.join(osPath, CONFIG_FILE_NAME), config, {
+        await mkdir(osPath, { recursive: true });
+        await writeJson(path.join(osPath, CONFIG_FILE_NAME), config, {
             spaces: 2,
         });
     }
@@ -62,7 +84,7 @@ export class ConfigManager {
         try {
             await this.initialize();
             const osInstances = [];
-            const osInstanceNames = await fs.readdir(ConfigManager.instancesPath);
+            const osInstanceNames = await readdir(ConfigManager.instancesPath);
             for (const osInstanceName of osInstanceNames) {
                 const config = await this.getOSConfig(osInstanceName);
                 if (config) {
@@ -72,7 +94,6 @@ export class ConfigManager {
             return osInstances;
         }
         catch (error) {
-            // if the default path for config does not exist, return an empty array
             if (error instanceof Error && error.message.includes('ENOENT')) {
                 return [];
             }
@@ -81,8 +102,8 @@ export class ConfigManager {
     }
     static async deleteOSInstance(name) {
         const osInstancePath = path.join(ConfigManager.instancesPath, name);
-        if (await fs.pathExists(osInstancePath)) {
-            await fs.remove(osInstancePath);
+        if (await pathExists(osInstancePath)) {
+            await rm(osInstancePath, { recursive: true });
         }
     }
 }

package/dist/src/vector-store/copass-vector-store.tool.d.ts

@@ -0,0 +1,29 @@
+import { oRequest } from '@olane/o-core';
+import { oLaneTool } from '@olane/o-lane';
+import { oNodeConfig } from '@olane/o-node';
+import type { ToolResult } from '@olane/o-tool';
+/**
+ * Vector store implementation backed by the Copass backend via the CLI.
+ *
+ * Sits at o://vector-store so that `index_network` and any tool that
+ * calls `use(oAddress('o://vector-store'), ...)` routes through here.
+ *
+ * - add_documents  → `olane ingest text` for each document (parallelized)
+ * - search_similar → `olane copass context` (fast path search)
+ * - delete/update  → no-ops (Copass is append-only)
+ */
+export declare class CopassVectorStoreTool extends oLaneTool {
+    constructor(config: oNodeConfig);
+    /**
+     * Ingest documents into the Copass backend via `olane ingest text`.
+     * Runs up to INGEST_CONCURRENCY CLI calls in parallel.
+     */
+    _tool_add_documents(request: oRequest): Promise<ToolResult>;
+    /**
+     * Search via `olane copass context` (fast path).
+     */
+    _tool_search_similar(request: oRequest): Promise<ToolResult>;
+    _tool_delete_documents(_request: oRequest): Promise<ToolResult>;
+    _tool_update_documents(_request: oRequest): Promise<ToolResult>;
+}
+//# sourceMappingURL=copass-vector-store.tool.d.ts.map

package/dist/src/vector-store/copass-vector-store.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copass-vector-store.tool.d.ts","sourceRoot":"","sources":["../../../src/vector-store/copass-vector-store.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAKhD;;;;;;;;;GASG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;gBACtC,MAAM,EAAE,WAAW;IA2C/B;;;OAGG;IACG,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAsCjE;;OAEG;IACG,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAsB5D,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAI/D,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CAGtE"}