strata-storage 2.6.1 → 2.7.1

package/ios/Plugin/StrataStoragePlugin.swift

@@ -24,30 +24,44 @@ public class StrataStoragePlugin: CAPPlugin {
     private static let defaultDatabase = "strata_storage"
     private static let defaultTable = "storage"
 
-    /// Sanitizes a database name into a safe `.db` filename. Strips everything
-    /// outside `[A-Za-z0-9_]` (which also blocks path separators / traversal),
-    /// then appends `.db`. Empty input falls back to the default. The filename
-    /// CANNOT be a bound parameter, so it must be sanitized before use.
-    private func sqliteFileName(from database: String?) -> String {
-        let raw = database ?? StrataStoragePlugin.defaultDatabase
-        let cleaned = String(raw.unicodeScalars.filter { CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_").contains($0) })
-        let safe = cleaned.isEmpty ? StrataStoragePlugin.defaultDatabase : cleaned
-        return "\(safe).db"
+    /// Allowed characters for a SQLite identifier body (the first character must
+    /// additionally not be a digit).
+    private static let sqliteIdentifierChars =
+        CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_")
+
+    /// Validates a `database`/`table` identifier against `^[A-Za-z_][A-Za-z0-9_]*$`.
+    /// These two cannot be bound as parameters (they are interpolated into SQL /
+    /// the `.db` filename), so they are the single injection surface; every
+    /// other value is bound. Non-conforming identifiers are REJECTED rather than
+    /// silently stripped — the TS adapter applies the same allow-list and rejects
+    /// first, so this is defense-in-depth (and also blocks path traversal).
+    private func isValidSqliteIdentifier(_ s: String) -> Bool {
+        guard let first = s.unicodeScalars.first else { return false }
+        if CharacterSet(charactersIn: "0123456789").contains(first) { return false }
+        return s.unicodeScalars.allSatisfy { StrataStoragePlugin.sqliteIdentifierChars.contains($0) }
     }
 
-    /// Sanitizes a table name to a safe SQL identifier matching `^[A-Za-z0-9_]+$`.
-    /// Disallowed characters are removed; empty input falls back to the default.
-    /// The table name is interpolated into SQL (it cannot be bound), so this is
-    /// the single point that guarantees injection-safety for the identifier.
-    private func sqliteTableName(from table: String?) -> String {
-        let raw = table ?? StrataStoragePlugin.defaultTable
-        let cleaned = String(raw.unicodeScalars.filter { CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_").contains($0) })
-        return cleaned.isEmpty ? StrataStoragePlugin.defaultTable : cleaned
+    /// Returns the validated table identifier for the call, or nil after
+    /// rejecting `call` with a clear error.
+    private func validatedTable(_ call: CAPPluginCall) -> String? {
+        let table = call.getString("table") ?? StrataStoragePlugin.defaultTable
+        guard isValidSqliteIdentifier(table) else {
+            call.reject("Invalid SQLite table name: \(table)")
+            return nil
+        }
+        return table
     }
 
-    /// Returns the cached SQLite store for the call's `database` option.
-    private func sqliteStore(for call: CAPPluginCall) -> SQLiteStorage {
-        return SQLiteStorageManager.shared.store(forFile: sqliteFileName(from: call.getString("database")))
+    /// Returns the cached SQLite store for the call's validated `database`, or
+    /// nil after rejecting `call`. The filename cannot be a bound parameter, so
+    /// the name is validated before `.db` is appended.
+    private func validatedSqliteStore(for call: CAPPluginCall) -> SQLiteStorage? {
+        let database = call.getString("database") ?? StrataStoragePlugin.defaultDatabase
+        guard isValidSqliteIdentifier(database) else {
+            call.reject("Invalid SQLite database name: \(database)")
+            return nil
+        }
+        return SQLiteStorageManager.shared.store(forFile: "\(database).db")
     }
 
     /**
@@ -56,8 +70,21 @@ public class StrataStoragePlugin: CAPPlugin {
      */
     @objc func isAvailable(_ call: CAPPluginCall) {
         let storage = call.getString("storage") ?? "preferences"
+        let available: Bool
+        switch storage {
+        case "sqlite":
+            let database = call.getString("database") ?? StrataStoragePlugin.defaultDatabase
+            available = isValidSqliteIdentifier(database)
+                && SQLiteStorageManager.shared.store(forFile: "\(database).db").isOpen
+        case "filesystem":
+            available = filesystemStorage.isAvailable()
+        case "preferences", "secure":
+            available = true
+        default:
+            available = false
+        }
         call.resolve([
-            "available": supportedStorageTypes.contains(storage)
+            "available": available
         ])
     }
 
@@ -81,7 +108,8 @@ public class StrataStoragePlugin: CAPPlugin {
             case "secure":
                 value = try keychainStorage.get(key: key)
             case "sqlite":
-                value = sqliteStore(for: call).get(table: sqliteTableName(from: call.getString("table")), key: key)
+                guard let store = validatedSqliteStore(for: call), let table = validatedTable(call) else { return }
+                value = store.get(table: table, key: key)
             case "filesystem":
                 value = filesystemStorage.get(key: key)
             case "preferences":
@@ -117,6 +145,7 @@ public class StrataStoragePlugin: CAPPlugin {
                 let value = call.getValue("value") ?? NSNull()
                 _ = try keychainStorage.set(key: key, value: value)
             case "sqlite":
+                guard let store = validatedSqliteStore(for: call), let table = validatedTable(call) else { return }
                 // getObject returns JSObject ([String: JSValue]); upcast each
                 // value to Any (the canonical Capacitor pattern) so the bridged
                 // Foundation values are JSONSerialization-compatible.
@@ -124,8 +153,8 @@ public class StrataStoragePlugin: CAPPlugin {
                     call.reject("SQLite value must be a StorageValue object")
                     return
                 }
-                let ok = try sqliteStore(for: call).set(
-                    table: sqliteTableName(from: call.getString("table")),
+                let ok = try store.set(
+                    table: table,
                     key: key,
                     wrapper: jsObject as [String: Any]
                 )
@@ -172,7 +201,8 @@ public class StrataStoragePlugin: CAPPlugin {
             case "secure":
                 _ = try keychainStorage.remove(key: key)
             case "sqlite":
-                _ = sqliteStore(for: call).remove(table: sqliteTableName(from: call.getString("table")), key: key)
+                guard let store = validatedSqliteStore(for: call), let table = validatedTable(call) else { return }
+                _ = store.remove(table: table, key: key)
             case "filesystem":
                 _ = filesystemStorage.remove(key: key)
             case "preferences":
@@ -202,7 +232,8 @@ public class StrataStoragePlugin: CAPPlugin {
             case "secure":
                 _ = try keychainStorage.clear(prefix: prefix)
             case "sqlite":
-                _ = sqliteStore(for: call).clear(table: sqliteTableName(from: call.getString("table")), prefix: prefix)
+                guard let store = validatedSqliteStore(for: call), let table = validatedTable(call) else { return }
+                _ = store.clear(table: table, prefix: prefix)
             case "filesystem":
                 _ = filesystemStorage.clear(prefix: prefix)
             case "preferences":
@@ -231,7 +262,8 @@ public class StrataStoragePlugin: CAPPlugin {
             case "secure":
                 keys = try keychainStorage.keys(pattern: pattern)
             case "sqlite":
-                keys = sqliteStore(for: call).keys(table: sqliteTableName(from: call.getString("table")), pattern: pattern)
+                guard let store = validatedSqliteStore(for: call), let table = validatedTable(call) else { return }
+                keys = store.keys(table: table, pattern: pattern)
             case "filesystem":
                 keys = filesystemStorage.keys(pattern: pattern)
             case "preferences":
@@ -266,7 +298,8 @@ public class StrataStoragePlugin: CAPPlugin {
                 let info = try keychainStorage.size()
                 segments = ["total": info.total, "count": info.count, "keys": 0, "values": info.total, "metadata": 0]
             case "sqlite":
-                segments = try sqliteStore(for: call).size(table: sqliteTableName(from: call.getString("table")))
+                guard let store = validatedSqliteStore(for: call), let table = validatedTable(call) else { return }
+                segments = try store.size(table: table)
             case "filesystem":
                 segments = filesystemStorage.size()
             case "preferences":
@@ -295,8 +328,10 @@ public class StrataStoragePlugin: CAPPlugin {
 
     /**
      * Query SQLite-backed storage.
-     * Matches the optional `query` method in the JS contract:
-     * resolves `{ results: [{ key }] }` (JS re-fetches each value via get).
+     * Matches the optional `query` method in the JS contract: resolves
+     * `{ results: [{ key, value }] }` where `value` is the full StorageValue
+     * wrapper for each non-expired row, so the JS adapter applies the condition
+     * in one round-trip without re-fetching each key.
      */
     @objc func query(_ call: CAPPluginCall) {
         let storage = call.getString("storage") ?? "sqlite"
@@ -306,16 +341,34 @@ public class StrataStoragePlugin: CAPPlugin {
             return
         }
 
+        guard let store = validatedSqliteStore(for: call), let table = validatedTable(call) else { return }
         let condition = call.getObject("condition") ?? [:]
-        let results = sqliteStore(for: call).query(
-            table: sqliteTableName(from: call.getString("table")),
-            condition: condition
-        )
+        let results = store.query(table: table, condition: condition)
         call.resolve([
             "results": results
         ])
     }
 
+    /**
+     * Delete every expired row for a SQLite store and resolve `{ removed }`.
+     * The JS adapter calls this on its TTL cleanup tick, since `keys`/`query`
+     * now exclude expired rows in SQL (no lazy per-key deletion on read).
+     */
+    @objc func cleanupExpired(_ call: CAPPluginCall) {
+        let storage = call.getString("storage") ?? "sqlite"
+
+        guard storage == "sqlite" else {
+            call.reject("cleanupExpired is only supported for the 'sqlite' storage type")
+            return
+        }
+
+        guard let store = validatedSqliteStore(for: call), let table = validatedTable(call) else { return }
+        let removed = store.cleanupExpired(table: table)
+        call.resolve([
+            "removed": removed
+        ])
+    }
+
     /**
      * iOS-specific: read a UserDefaults value.
      * Resolves `{ value: unknown }`.

package/ios/Plugin/UserDefaultsStorage.swift

@@ -3,7 +3,13 @@ import Foundation
 @objc public class UserDefaultsStorage: NSObject {
     private let suiteName: String?
     private var userDefaults: UserDefaults
-    
+    /// All Strata keys are stored under this reserved prefix so that `keys()`,
+    /// `size()`, and `clear()` only ever touch Strata-owned entries — never the
+    /// rest of the app's `UserDefaults`. In particular `clear()` removes only
+    /// prefixed keys and NEVER calls `removePersistentDomain`, which would wipe
+    /// unrelated app/SDK settings in the shared domain.
+    private let keyPrefix = "strata_storage::"
+
     @objc public init(suiteName: String? = nil) {
         self.suiteName = suiteName
         if let suiteName = suiteName, let customDefaults = UserDefaults(suiteName: suiteName) {
@@ -13,75 +19,70 @@ import Foundation
         }
         super.init()
     }
-    
+
+    private func physicalKey(_ key: String) -> String {
+        return keyPrefix + key
+    }
+
+    /// The physical keys in this domain that are owned by Strata.
+    private func ownedPhysicalKeys() -> [String] {
+        return userDefaults.dictionaryRepresentation().keys.filter { $0.hasPrefix(keyPrefix) }
+    }
+
     @objc public func set(key: String, value: Any) -> Bool {
-        userDefaults.set(value, forKey: key)
+        userDefaults.set(value, forKey: physicalKey(key))
         return userDefaults.synchronize()
     }
-    
+
     @objc public func get(key: String) -> Any? {
-        return userDefaults.object(forKey: key)
+        return userDefaults.object(forKey: physicalKey(key))
     }
-    
+
     @objc public func remove(key: String) -> Bool {
-        userDefaults.removeObject(forKey: key)
+        userDefaults.removeObject(forKey: physicalKey(key))
         return userDefaults.synchronize()
     }
-    
+
     @objc public func clear(prefix: String? = nil) -> Bool {
-        if let prefix = prefix {
-            // Clear only keys with the given prefix
-            let keysToRemove = keys(pattern: prefix)
-            for key in keysToRemove {
-                userDefaults.removeObject(forKey: key)
-            }
-        } else {
-            // Clear all keys
-            if let suiteName = suiteName {
-                UserDefaults(suiteName: suiteName)?.removePersistentDomain(forName: suiteName)
-            } else {
-                guard let domain = Bundle.main.bundleIdentifier else {
-                    // Fallback: manually clear all keys
-                    let keys = Array(userDefaults.dictionaryRepresentation().keys)
-                    for key in keys {
-                        userDefaults.removeObject(forKey: key)
-                    }
-                    return userDefaults.synchronize()
-                }
-                userDefaults.removePersistentDomain(forName: domain)
-            }
+        // Only ever remove Strata-owned keys (optionally narrowed by `prefix`);
+        // never wipe the whole UserDefaults domain.
+        let targetPrefix = keyPrefix + (prefix ?? "")
+        for physical in userDefaults.dictionaryRepresentation().keys where physical.hasPrefix(targetPrefix) {
+            userDefaults.removeObject(forKey: physical)
         }
         return userDefaults.synchronize()
     }
-    
+
     @objc public func keys(pattern: String? = nil) -> [String] {
-        let allKeys = Array(userDefaults.dictionaryRepresentation().keys)
-        
+        // Present logical (un-prefixed) keys to callers.
+        let logical = ownedPhysicalKeys().map { String($0.dropFirst(keyPrefix.count)) }
+
         guard let pattern = pattern else {
-            return allKeys
+            return logical
         }
-        
-        // Filter keys by pattern (simple prefix matching)
-        return allKeys.filter { key in
+
+        return logical.filter { key in
             key.hasPrefix(pattern) || key.contains(pattern)
         }
     }
-    
+
     @objc public func has(key: String) -> Bool {
-        return userDefaults.object(forKey: key) != nil
+        return userDefaults.object(forKey: physicalKey(key)) != nil
     }
-    
+
     @objc public func size() -> (total: Int, count: Int) {
         let all = userDefaults.dictionaryRepresentation()
         var totalSize = 0
-        let count = all.count
-        
-        for (key, value) in all {
-            // Estimate size (key + value in bytes)
-            totalSize += key.data(using: .utf8)?.count ?? 0
+        var count = 0
+
+        for (physical, value) in all where physical.hasPrefix(keyPrefix) {
+            count += 1
+            let logical = String(physical.dropFirst(keyPrefix.count))
+            // Estimate size (logical key + value in bytes)
+            totalSize += logical.data(using: .utf8)?.count ?? 0
             totalSize += "\(value)".data(using: .utf8)?.count ?? 0
         }
-        
+
         return (total: totalSize, count: count)
     }
-}
+}

package/package.json

@@ -1,8 +1,10 @@
 {
   "name": "strata-storage",
-  "version": "2.6.1",
+  "version": "2.7.1",
   "description": "Zero-dependency universal storage plugin providing a unified API for all storage operations across web, Android, and iOS platforms",
   "type": "module",
+  "packageManager": "yarn@4.17.0",
+  "sideEffects": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -38,15 +40,16 @@
     "./angular": {
       "types": "./dist/integrations/angular/index.d.ts",
       "default": "./dist/integrations/angular/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
     "build": "node scripts/build.js",
     "clean": "rm -rf dist/",
-    "lint": "eslint 'src/**/*.{ts,tsx}' --fix",
+    "lint": "eslint 'src/**/*.{ts,tsx}'",
+    "lint:fix": "eslint 'src/**/*.{ts,tsx}' --fix",
     "typecheck": "tsc --noEmit",
-    "test": "vitest",
-    "test:coverage": "vitest --coverage",
+    "prepack": "yarn build && yarn lint && yarn typecheck",
     "prepublishOnly": "yarn build && yarn lint && yarn typecheck",
     "postinstall": "node scripts/postinstall.js || true"
   },
@@ -75,13 +78,14 @@
     "url": "https://github.com/aoneahsan/strata-storage.git"
   },
   "bugs": {
-    "url": "https://github.com/aoneahsan/strata-storage/issues"
+    "url": "https://stratastorage.aoneahsan.com/contact"
   },
-  "homepage": "https://github.com/aoneahsan/strata-storage#readme",
+  "homepage": "https://stratastorage.aoneahsan.com",
   "peerDependencies": {
     "@angular/core": ">=21.0.6",
     "@angular/forms": ">=21.0.6",
     "@capacitor/core": ">=8.0.0",
+    "firebase": ">=10.0.0",
     "react": ">=19.2.3",
     "vue": ">=3.5.26"
   },
@@ -95,6 +99,9 @@
     "@capacitor/core": {
       "optional": true
     },
+    "firebase": {
+      "optional": true
+    },
     "react": {
       "optional": true
     },
@@ -103,27 +110,24 @@
     }
   },
   "devDependencies": {
-    "@angular/common": "^21.2.15",
-    "@angular/core": "^21.2.15",
-    "@angular/forms": "^21.2.15",
-    "@capacitor/core": "^8.3.4",
-    "@types/node": "^25.9.1",
-    "@types/react": "^19.2.15",
-    "@typescript-eslint/eslint-plugin": "^8.60.0",
-    "@typescript-eslint/parser": "^8.60.0",
-    "@vitest/coverage-v8": "^4.1.7",
-    "eslint": "^10.4.0",
+    "@angular/common": "^22.0.0",
+    "@angular/core": "^22.0.0",
+    "@angular/forms": "^22.0.0",
+    "@capacitor/core": "^8.4.0",
+    "@types/node": "^25.9.2",
+    "@types/react": "^19.2.17",
+    "@typescript-eslint/eslint-plugin": "^8.60.1",
+    "@typescript-eslint/parser": "^8.60.1",
+    "eslint": "^10.4.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.6",
-    "jsdom": "^29.1.1",
     "prettier": "^3.8.3",
-    "react": "^19.2.6",
+    "react": "^19.2.7",
     "rxjs": "^7.8.2",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.60.0",
-    "vitest": "^4.1.7",
+    "typescript-eslint": "^8.60.1",
     "vue": "^3.5.35",
-    "zone.js": "~0.16.0"
+    "zone.js": "~0.16.2"
   },
   "engines": {
     "node": ">=24.13.0"
@@ -136,6 +140,5 @@
       "src": "android",
       "androidModule": "strata-storage"
     }
-  },
-  "packageManager": "yarn@4.14.1"
+  }
 }

package/scripts/build.js

@@ -43,7 +43,7 @@ const fixPathAliases = (dir) => {
     
     if (stat.isDirectory()) {
       fixPathAliases(filePath);
-    } else if (file.endsWith('.js')) {
+    } else if (file.endsWith('.js') || file.endsWith('.d.ts')) {
       let content = fs.readFileSync(filePath, 'utf8');
       
       // Calculate depth from dist root
@@ -61,6 +61,10 @@ const fixPathAliases = (dir) => {
         .replace(/from\s+["']@\/types\//g, `from "${pathToRoot}types/`)
         .replace(/from\s+["']@\/utils["']/g, `from "${pathToRoot}utils/index.js"`)
         .replace(/from\s+["']@\/plugin["']/g, `from "${pathToRoot}plugin/index.js"`)
+        .replace(/from\s+["']@\/types["']/g, `from "${pathToRoot}types/index.js"`)
+        .replace(/from\s+["']@\/index["']/g, `from "${pathToRoot}index.js"`)
+        .replace(/from\s+["']@\/config["']/g, `from "${pathToRoot}config/index.js"`)
+        .replace(/from\s+["']@\/integrations["']/g, `from "${pathToRoot}integrations/index.js"`)
         .replace(/import\(["']@\/core\//g, `import("${pathToRoot}core/`)
         .replace(/import\(["']@\/adapters\//g, `import("${pathToRoot}adapters/`)
         .replace(/import\(["']@\/features\//g, `import("${pathToRoot}features/`)
@@ -68,27 +72,48 @@ const fixPathAliases = (dir) => {
         .replace(/import\(["']@\/plugin\//g, `import("${pathToRoot}plugin/`)
         .replace(/import\(["']@\/types\//g, `import("${pathToRoot}types/`)
         .replace(/import\(["']@\/utils["']\)/g, `import("${pathToRoot}utils/index.js")`)
-        .replace(/import\(["']@\/plugin["']\)/g, `import("${pathToRoot}plugin/index.js")`);
+        .replace(/import\(["']@\/plugin["']\)/g, `import("${pathToRoot}plugin/index.js")`)
+        .replace(/import\(["']@\/types["']\)/g, `import("${pathToRoot}types/index.js")`)
+        .replace(/import\(["']@\/index["']\)/g, `import("${pathToRoot}index.js")`)
+        .replace(/import\(["']@\/config["']\)/g, `import("${pathToRoot}config/index.js")`)
+        .replace(/import\(["']@\/integrations["']\)/g, `import("${pathToRoot}integrations/index.js")`);
       
       // Also fix any remaining short imports that should point to index.js
       content = content
         .replace(/from\s+["']\.\/utils["']/g, `from "./utils/index.js"`)
         .replace(/from\s+["']\.\/plugin["']/g, `from "./plugin/index.js"`);
       
-      // Add .js extension to relative imports
+      // Add the correct extension to extensionless relative imports.
+      // Directory-aware: a barrel import like './types' must resolve to
+      // './types/index.js', a file import like './core/Strata' to
+      // './core/Strata.js'. tsc has already emitted every .js by now, so we
+      // resolve against the real dist files instead of blindly appending '.js'
+      // (the previous naive appender produced a dead './types.js' that broke
+      // type resolution for every TS consumer).
+      const fileDir = path.dirname(filePath);
+      const resolveRel = (importPath) => {
+        if (importPath.endsWith('.js') || importPath.endsWith('.json')) {
+          return importPath;
+        }
+        const abs = path.resolve(fileDir, importPath);
+        if (fs.existsSync(`${abs}.js`)) {
+          return `${importPath}.js`;
+        }
+        if (fs.existsSync(path.join(abs, 'index.js'))) {
+          return `${importPath.replace(/\/+$/, '')}/index.js`;
+        }
+        // Fall back to the legacy behavior if nothing matched on disk.
+        return `${importPath}.js`;
+      };
       content = content
-        .replace(/from\s+["'](\.[^"']+)["']/g, (match, path) => {
-          if (!path.endsWith('.js') && !path.endsWith('.json')) {
-            return `from "${path}.js"`;
-          }
-          return match;
-        })
-        .replace(/import\(["'](\.[^"']+)["']\)/g, (match, path) => {
-          if (!path.endsWith('.js') && !path.endsWith('.json')) {
-            return `import("${path}.js")`;
-          }
-          return match;
-        });
+        .replace(
+          /from\s+["'](\.[^"']+)["']/g,
+          (_match, p) => `from "${resolveRel(p)}"`,
+        )
+        .replace(
+          /import\(["'](\.[^"']+)["']\)/g,
+          (_match, p) => `import("${resolveRel(p)}")`,
+        );
       
       fs.writeFileSync(filePath, content);
     }
@@ -97,17 +122,6 @@ const fixPathAliases = (dir) => {
 
 fixPathAliases(distDir);
 
-// Copy native directories if they exist
-console.log('📱 Copying native code...');
-const nativeDirs = ['android', 'ios'];
-nativeDirs.forEach(dir => {
-  const srcPath = path.join(rootDir, dir);
-  const destPath = path.join(distDir, dir);
-  if (fs.existsSync(srcPath)) {
-    fs.cpSync(srcPath, destPath, { recursive: true });
-  }
-});
-
 // Copy other files
 console.log('📄 Copying additional files...');
 const filesToCopy = ['README.md', 'LICENSE'];
@@ -153,11 +167,16 @@ const distPackageJson = {
     './angular': {
       types: './integrations/angular/index.d.ts',
       default: './integrations/angular/index.js'
-    }
+    },
+    './package.json': './package.json'
   },
   author: packageJson.author,
   license: packageJson.license,
   repository: packageJson.repository,
+  // Carry metadata-only fields through so the dist manifest never drifts from
+  // the root manifest (bugs/homepage were previously dropped).
+  bugs: packageJson.bugs,
+  homepage: packageJson.homepage,
   keywords: packageJson.keywords,
   peerDependencies: packageJson.peerDependencies,
   peerDependenciesMeta: packageJson.peerDependenciesMeta,

package/scripts/cli.js

@@ -39,7 +39,7 @@ Examples:
   npx strata-storage configure
   npx strata-storage init
 
-Documentation: https://github.com/aoneahsan/strata-storage
+Documentation: https://stratastorage-docs.aoneahsan.com (AI agents: /ai)
 `);
   process.exit(0);
 }

package/scripts/configure.js

@@ -9,6 +9,7 @@ import fs from 'fs';
 import path from 'path';
 import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
+import readline from 'node:readline';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -110,7 +111,6 @@ function detectProject() {
 
 // Get configuration through prompts
 async function getConfiguration(projectInfo) {
-  const readline = require('readline');
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
@@ -433,7 +433,7 @@ function showCompletion(config) {
   }
   
   console.log('\nSee strata.example.* for a complete example.');
-  console.log('\nDocumentation: https://github.com/aoneahsan/strata-storage');
+  console.log('\nDocumentation: https://stratastorage-docs.aoneahsan.com');
 }
 
 // Run configuration

package/scripts/postinstall.js

@@ -40,5 +40,6 @@ console.log('   • Optional Capacitor integration');
 console.log('   • Built-in encryption & compression');
 console.log('   • Cross-tab synchronization\n');
 
-console.log('📖 Documentation: https://github.com/aoneahsan/strata-storage');
-console.log('⭐ Star us on GitHub: https://github.com/aoneahsan/strata-storage\n');
+console.log('📖 Documentation: https://stratastorage-docs.aoneahsan.com');
+console.log('🤖 For AI agents:  https://stratastorage-docs.aoneahsan.com/ai');
+console.log('🌐 Website:        https://stratastorage.aoneahsan.com\n');