@mobileaidev/ai-app-bridge 0.2.15 → 0.3.0-rc.2

package/bin/command-router.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const { isolatedCommandDefinitions } = require('./command-registry');
+const { commandFailure } = require('./command-errors');
+
+function createCommandRouter({ loadScript, loadIntent, loadEvidence, dispatchCommon } = {}) {
+  if (typeof dispatchCommon !== 'function') {
+    throw new TypeError('dispatchCommon is required');
+  }
+  const loads = { script: 0, intent: 0, evidence: 0 };
+  return {
+    isolatedCommandDefinitions,
+    loads,
+    async route(command, args = {}, dependencies) {
+      if (command === 'script') {
+        return invokeIsolated('script', loadScript, args, loads);
+      }
+      if (command === 'intent') {
+        return invokeIsolated('intent', loadIntent, args, loads);
+      }
+      if (command === 'install-apk') {
+        return invokeIsolated('intent', loadIntent, { install: args, recordingDir: args.recordingDir }, loads);
+      }
+      if (command === 'permission-dialog') {
+        return invokeIsolated('intent', loadIntent, { permissionDialog: args, recordingDir: args.recordingDir }, loads);
+      }
+      if (command === 'evidence') {
+        return invokeIsolated('evidence', loadEvidence, args, loads);
+      }
+      return dispatchCommon(command, args, dependencies);
+    },
+  };
+}
+
+async function invokeIsolated(name, loader, args, loads) {
+  if (typeof loader !== 'function') {
+    return isolatedError(name, 'not_implemented');
+  }
+  loads[name] += 1;
+  let entry;
+  try {
+    entry = loader();
+  } catch (error) {
+    return isolatedError(name, 'isolated_module_unavailable', error.message || String(error));
+  }
+  if (!entry || typeof entry.handle !== 'function') {
+    return isolatedError(name, 'isolated_module_unavailable', 'entry handle is missing');
+  }
+  let handlePromise;
+  try {
+    handlePromise = Promise.resolve(entry.handle(args));
+  } catch (error) {
+    return { value: isolatedHandleError(name, error) };
+  }
+  // Stateful runtimes own cancellation and draining. An outer timer must not
+  // report a timeout while their work continues without supervision.
+  const result = await handlePromise.catch(error => isolatedHandleError(name, error));
+  return { value: result };
+}
+
+function isolatedHandleError(name, error) {
+  if (error?.code === 'sfs_busy') return { ok: false, error: 'fact_store_writer_busy', command: name, detail: error.message };
+  return commandFailure(error, name);
+}
+
+function isolatedError(command, error, detail) {
+  return {
+    value: {
+        ok: false,
+        error,
+        command,
+        ...(detail ? { detail } : {}),
+    },
+  };
+}
+
+module.exports = {
+  createCommandRouter,
+  isolatedCommandDefinitions,
+};

package/bin/connection-cache.js

@@ -0,0 +1,119 @@
+'use strict';
+
+class ConnectionCache {
+  constructor({ ttlMs = 15_000, maxEntries = 256, now = Date.now } = {}) {
+    if (!Number.isFinite(ttlMs) || ttlMs < 0) {
+      throw new TypeError('ttlMs must be a non-negative number');
+    }
+    if (typeof now !== 'function') {
+      throw new TypeError('now must be a function');
+    }
+    if (!Number.isInteger(maxEntries) || maxEntries < 1) {
+      throw new TypeError('maxEntries must be a positive integer');
+    }
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+    this.now = now;
+    this.entries = new Map();
+    this.inflight = new Map();
+    this.generations = new Map();
+    this.nextGeneration = 0;
+  }
+
+  async getOrCreate(key, create, { force = false } = {}) {
+    if (typeof key !== 'string' || key.length === 0) {
+      throw new TypeError('key is required');
+    }
+    if (typeof create !== 'function') {
+      throw new TypeError('create must be a function');
+    }
+
+    this.pruneEntries();
+    if (!force) {
+      const cached = this.entries.get(key);
+      if (cached && cached.expiresAtMs >= this.now()) {
+        this.entries.delete(key);
+        this.entries.set(key, cached);
+        return cached.value;
+      }
+      if (cached) this.entries.delete(key);
+      if (this.inflight.has(key)) return this.inflight.get(key);
+    } else {
+      this.entries.delete(key);
+    }
+
+    const generation = ++this.nextGeneration;
+    this.generations.set(key, generation);
+    const pending = Promise.resolve()
+      .then(create)
+      .then((value) => {
+        if (this.generations.get(key) === generation) {
+          this.entries.set(key, {
+            value,
+            expiresAtMs: this.now() + this.ttlMs,
+          });
+          this.pruneEntries();
+        }
+        return value;
+      })
+      .finally(() => {
+        if (this.inflight.get(key) === pending) {
+          this.inflight.delete(key);
+        }
+        if (
+          this.generations.get(key) === generation
+          && !this.inflight.has(key)
+          && !this.entries.has(key)
+        ) {
+          this.generations.delete(key);
+        }
+      });
+    this.inflight.set(key, pending);
+    return pending;
+  }
+
+  has(key) {
+    this.pruneEntries();
+    const cached = this.entries.get(key);
+    if (!cached) return false;
+    if (cached.expiresAtMs < this.now()) {
+      this.entries.delete(key);
+      if (!this.inflight.has(key)) this.generations.delete(key);
+      return false;
+    }
+    return true;
+  }
+
+  pruneEntries() {
+    const now = this.now();
+    for (const [key, entry] of this.entries) {
+      if (entry.expiresAtMs < now) {
+        this.entries.delete(key);
+        if (!this.inflight.has(key)) this.generations.delete(key);
+      }
+    }
+    while (this.entries.size > this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      this.entries.delete(oldestKey);
+      if (!this.inflight.has(oldestKey)) this.generations.delete(oldestKey);
+    }
+  }
+
+  invalidate(key) {
+    this.generations.set(key, ++this.nextGeneration);
+    this.inflight.delete(key);
+    const deleted = this.entries.delete(key);
+    this.generations.delete(key);
+    return deleted;
+  }
+
+  clear() {
+    this.entries.clear();
+    this.inflight.clear();
+    this.generations.clear();
+  }
+}
+
+module.exports = {
+  ConnectionCache,
+};