nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.21

package/localDialogRead-2VRI24F4.js

@@ -0,0 +1,26 @@
+import "./chunk-4VNS5WPM.js";
+
+// packages/agent-runtime/localDialogRead.ts
+async function readDialogFromLocalDb(args) {
+  const [{ fetchMessages }] = await Promise.all([
+    import("./fetchMessages-KTNM7QAR.js")
+  ]);
+  let serverDb;
+  if (args.db) {
+    serverDb = args.db;
+  } else {
+    const dbModule = await import("./db-HCJ5PRB5.js");
+    serverDb = dbModule.default;
+    await dbModule.ensureServerDbOpen();
+  }
+  return {
+    meta: await serverDb.get(args.dialogKey),
+    msgs: await fetchMessages(serverDb, args.dialogId, {
+      limit: args.limit,
+      throwOnError: true
+    })
+  };
+}
+export {
+  readDialogFromLocalDb
+};

package/localFirstLog-DHNOY2NA.js

@@ -0,0 +1,19 @@
+import "./chunk-4VNS5WPM.js";
+
+// packages/app/localFirst/localFirstLog.ts
+var PREFIX = "[localFirst]";
+function localFirstLog(event, data) {
+  const safeEvent = event.trim() || "unknown";
+  if (data && Object.keys(data).length > 0) {
+    try {
+      console.info(PREFIX, safeEvent, JSON.stringify(data));
+    } catch {
+      console.info(PREFIX, safeEvent, data);
+    }
+    return;
+  }
+  console.info(PREFIX, safeEvent);
+}
+export {
+  localFirstLog
+};

package/localRuntimeAuthority-TEGCOWX4.js

@@ -0,0 +1,471 @@
+import {
+  createCliAuthorityBrokerClient,
+  createCliAuthorityBrokerSocketInvoker,
+  isCliAuthorityBrokerUnavailableError,
+  resolveCliAuthorityBrokerEndpoint,
+  resolveCliAuthorityBrokerHealthPath,
+  resolveCliAuthorityBrokerMetadataPath
+} from "./chunk-U4TRT5V4.js";
+import {
+  createLegacyServerDb,
+  createLevelAuthorityStore,
+  isLevelLockError
+} from "./chunk-CF2WZF4N.js";
+import "./chunk-6WD3OOJS.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  resolveNoloHome
+} from "./chunk-LM6IYQ3F.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/cli/localRuntimeAuthority.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// packages/database-engine/cliAuthorityBrokerServer.ts
+import fs from "node:fs";
+import path from "node:path";
+import { createServer } from "node:net";
+var brokerRegistry = /* @__PURE__ */ new Map();
+var DEFAULT_ITERATOR_LIMIT = 200;
+function resolveBrokerListenTarget(endpoint) {
+  if (endpoint.startsWith("unix://")) {
+    return { kind: "unix", path: endpoint.slice("unix://".length) };
+  }
+  if (endpoint.startsWith("tcp://")) {
+    const url = new URL(endpoint);
+    return {
+      kind: "tcp",
+      host: url.hostname,
+      port: Number(url.port)
+    };
+  }
+  throw new Error(`Unsupported CLI authority broker endpoint: ${endpoint}`);
+}
+function buildListeningEndpoint(server, target) {
+  if (target.kind === "unix") {
+    return `unix://${target.path}`;
+  }
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    return `tcp://${target.host}:${target.port}`;
+  }
+  const info = address;
+  return `tcp://${target.host}:${info.port}`;
+}
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+function writeJsonFile(filePath, data) {
+  if (!filePath) return;
+  ensureParentDir(filePath);
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+}
+function removeFileIfPresent(filePath) {
+  if (!filePath) return;
+  try {
+    fs.rmSync(filePath, { force: true });
+  } catch {
+  }
+}
+async function buildIteratorPage(store, request) {
+  const rows = [];
+  for await (const entry of store.iterator(request.options ?? {})) {
+    rows.push(entry);
+  }
+  const startIndex = request.cursor ? rows.findIndex(([key]) => key === request.cursor) + 1 : 0;
+  const limit = request.limit ?? DEFAULT_ITERATOR_LIMIT;
+  const entries = rows.slice(startIndex, startIndex + limit);
+  const lastEntry = entries.at(-1) ?? null;
+  return {
+    entries,
+    nextCursor: lastEntry ? lastEntry[0] : null,
+    done: startIndex + entries.length >= rows.length
+  };
+}
+function createErrorResponse(error) {
+  if (typeof error === "object" && error !== null && typeof error.code === "string" && typeof error.message === "string") {
+    return {
+      ok: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        retryable: error.retryable === true
+      }
+    };
+  }
+  return {
+    ok: false,
+    error: {
+      code: "BROKER_INTERNAL_ERROR",
+      message: toErrorMessage(error)
+    }
+  };
+}
+async function dispatchCliAuthorityBrokerRequest(store, request) {
+  try {
+    switch (request.type) {
+      case "status":
+        return { ok: true, result: { type: "status" } };
+      case "open":
+        await store.open();
+        return { ok: true, result: { type: "open" } };
+      case "close":
+        await store.close();
+        return { ok: true, result: { type: "close" } };
+      case "get":
+        return { ok: true, result: { type: "get", value: await store.get(request.key) } };
+      case "put":
+        await store.put(request.key, request.value);
+        return { ok: true, result: { type: "put" } };
+      case "del":
+        await store.del(request.key);
+        return { ok: true, result: { type: "del" } };
+      case "batchWrite":
+        await store.batchWrite(request.ops);
+        return { ok: true, result: { type: "batchWrite" } };
+      case "iterator":
+        return {
+          ok: true,
+          result: {
+            type: "iterator",
+            page: await buildIteratorPage(store, request)
+          }
+        };
+    }
+  } catch (error) {
+    return createErrorResponse(error);
+  }
+}
+async function createBrokerHandle(options) {
+  const target = resolveBrokerListenTarget(options.endpoint);
+  if (target.kind === "unix") {
+    ensureParentDir(target.path);
+    removeFileIfPresent(target.path);
+  }
+  const store = await options.createStore();
+  await store.open();
+  const server = createServer((socket) => {
+    bindSocketRequestHandler({ socket, store });
+  });
+  if ((options.transportMode ?? "socket") === "socket") {
+    try {
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        if (target.kind === "unix") {
+          server.listen(target.path, () => {
+            server.off("error", reject);
+            resolve();
+          });
+          return;
+        }
+        server.listen(target.port, target.host, () => {
+          server.off("error", reject);
+          resolve();
+        });
+      });
+      server.unref();
+    } catch (error) {
+      await store.close().catch(() => {
+      });
+      throw error;
+    }
+  }
+  const now = options.now ?? Date.now;
+  const listeningEndpoint = (options.transportMode ?? "socket") === "socket" ? buildListeningEndpoint(server, target) : options.endpoint;
+  writeJsonFile(options.metadataPath, {
+    pid: process.pid,
+    endpoint: listeningEndpoint,
+    location: store.location ?? listeningEndpoint,
+    startedAt: new Date(now()).toISOString()
+  });
+  writeJsonFile(options.healthPath, {
+    ok: true,
+    pid: process.pid,
+    endpoint: listeningEndpoint,
+    checkedAt: new Date(now()).toISOString()
+  });
+  let closed = false;
+  return {
+    endpoint: options.endpoint,
+    listeningEndpoint,
+    authorityStore: store,
+    request(request) {
+      return dispatchCliAuthorityBrokerRequest(store, request);
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      brokerRegistry.delete(options.endpoint);
+      if ((options.transportMode ?? "socket") === "socket") {
+        await new Promise((resolve, reject) => {
+          server.close((error) => error ? reject(error) : resolve());
+        });
+      }
+      await store.close();
+      if (target.kind === "unix") {
+        removeFileIfPresent(target.path);
+      }
+      removeFileIfPresent(options.metadataPath);
+      removeFileIfPresent(options.healthPath);
+    }
+  };
+}
+function bindSocketRequestHandler(args) {
+  let buffer = "";
+  args.socket.setEncoding("utf8");
+  args.socket.on("data", async (chunk) => {
+    buffer += chunk;
+    if (!buffer.includes("\n")) return;
+    const [rawRequest] = buffer.split("\n");
+    buffer = "";
+    let response;
+    try {
+      response = await dispatchCliAuthorityBrokerRequest(
+        args.store,
+        JSON.parse(rawRequest)
+      );
+    } catch (error) {
+      response = createErrorResponse(error);
+    }
+    args.socket.end(`${JSON.stringify(response)}
+`);
+  });
+}
+function getOrCreateCliAuthorityBrokerServer(options) {
+  const existing = brokerRegistry.get(options.endpoint);
+  if (existing) return existing;
+  const pending = createBrokerHandle(options).catch((error) => {
+    brokerRegistry.delete(options.endpoint);
+    throw error;
+  });
+  brokerRegistry.set(options.endpoint, pending);
+  return pending;
+}
+
+// packages/cli/localRuntimeAuthority.ts
+function ensureDbParentDir(dbPath) {
+  fs2.mkdirSync(path2.dirname(dbPath), { recursive: true });
+}
+function isCliAuthorityLockError(error) {
+  if (isLevelLockError(error)) return true;
+  const message = toErrorMessage(error);
+  return /Database failed to open|EADDRINUSE|Failed to listen/i.test(message);
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveCliLocalRuntimeDbPath(options = {}) {
+  return path2.join(
+    resolveNoloHome({
+      env: options.env,
+      homeDir: options.homeDir
+    }),
+    "data",
+    "leveldb"
+  );
+}
+var defaultCliAuthorityBrokerConnectDeps = {
+  createClient: (options) => createCliAuthorityBrokerClient(options),
+  startBroker: (options) => getOrCreateCliAuthorityBrokerServer(options),
+  sleep
+};
+async function connectCliAuthorityBroker(args) {
+  const deps = {
+    ...defaultCliAuthorityBrokerConnectDeps,
+    ...args.deps
+  };
+  async function connectClient() {
+    const client2 = deps.createClient({
+      endpoint: args.endpoint,
+      invoke: createCliAuthorityBrokerSocketInvoker({ endpoint: args.endpoint })
+    });
+    async function attachToExistingBroker(attempts) {
+      for (let attempt = 0; attempt < attempts; attempt += 1) {
+        await deps.sleep(100);
+        try {
+          await client2.open();
+          return true;
+        } catch (error) {
+          if (!isCliAuthorityBrokerUnavailableError(error)) throw error;
+        }
+      }
+      return false;
+    }
+    try {
+      await deps.startBroker({
+        endpoint: args.endpoint,
+        metadataPath: args.metadataPath,
+        healthPath: args.healthPath,
+        createStore: () => createLevelAuthorityStore(args.dbPath)
+      });
+      await client2.open();
+      return client2;
+    } catch (error) {
+      if (!isCliAuthorityLockError(error)) throw error;
+      if (await attachToExistingBroker(5)) {
+        return client2;
+      }
+      let lastError = error;
+      for (let attempt = 0; attempt < 5; attempt += 1) {
+        await deps.sleep(100);
+        try {
+          await deps.startBroker({
+            endpoint: args.endpoint,
+            metadataPath: args.metadataPath,
+            healthPath: args.healthPath,
+            createStore: () => createLevelAuthorityStore(args.dbPath)
+          });
+          await client2.open();
+          return client2;
+        } catch (retryError) {
+          lastError = retryError;
+          if (isCliAuthorityLockError(retryError)) {
+            if (await attachToExistingBroker(2)) {
+              return client2;
+            }
+            continue;
+          }
+          if (isCliAuthorityBrokerUnavailableError(retryError)) {
+            continue;
+          }
+          throw retryError;
+        }
+      }
+      throw new Error(`CLI authority broker could not attach or take ownership for ${args.endpoint}`, {
+        cause: lastError
+      });
+    }
+  }
+  let client = await connectClient();
+  let reconnecting = null;
+  async function reconnect() {
+    reconnecting ??= connectClient();
+    try {
+      client = await reconnecting;
+      return client;
+    } finally {
+      reconnecting = null;
+    }
+  }
+  async function runWithSelfHealing(operation) {
+    try {
+      return await operation(client);
+    } catch (error) {
+      if (!isCliAuthorityBrokerUnavailableError(error)) throw error;
+      const recoveredClient = await reconnect();
+      return operation(recoveredClient);
+    }
+  }
+  return {
+    get location() {
+      return client.location;
+    },
+    get status() {
+      return client.status;
+    },
+    open: () => runWithSelfHealing((activeClient) => activeClient.open()),
+    close: () => runWithSelfHealing((activeClient) => activeClient.close()),
+    get: (key) => runWithSelfHealing((activeClient) => activeClient.get(key)),
+    put: (key, value) => runWithSelfHealing((activeClient) => activeClient.put(key, value)),
+    del: (key) => runWithSelfHealing((activeClient) => activeClient.del(key)),
+    batchWrite: (ops) => runWithSelfHealing((activeClient) => activeClient.batchWrite(ops)),
+    createBatch() {
+      const ops = [];
+      return {
+        put(key, value) {
+          ops.push({ type: "put", key, value });
+        },
+        del(key) {
+          ops.push({ type: "del", key });
+        },
+        write: () => runWithSelfHealing((activeClient) => activeClient.batchWrite(ops))
+      };
+    },
+    iterator(options = {}) {
+      return async function* iterate() {
+        let activeOptions = options;
+        let lastYieldedKey;
+        let skipResumeKey = false;
+        let recovered = false;
+        while (true) {
+          try {
+            for await (const entry of client.iterator(activeOptions)) {
+              if (skipResumeKey && entry[0] === lastYieldedKey) {
+                skipResumeKey = false;
+                continue;
+              }
+              skipResumeKey = false;
+              lastYieldedKey = entry[0];
+              yield entry;
+            }
+            return;
+          } catch (error) {
+            if (recovered || !isCliAuthorityBrokerUnavailableError(error)) {
+              throw error;
+            }
+            recovered = true;
+            await reconnect();
+            if (lastYieldedKey === void 0) {
+              activeOptions = options;
+              continue;
+            }
+            if (options.reverse) {
+              activeOptions = {
+                ...options,
+                lt: lastYieldedKey
+              };
+              continue;
+            }
+            activeOptions = {
+              ...options,
+              gte: lastYieldedKey
+            };
+            skipResumeKey = true;
+          }
+        }
+      }();
+    }
+  };
+}
+async function getDefaultCliLocalRuntimeAuthority(options = {}) {
+  const env = options.env ?? process.env;
+  const dbPath = resolveCliLocalRuntimeDbPath({
+    env,
+    homeDir: options.homeDir
+  });
+  ensureDbParentDir(dbPath);
+  const endpoint = resolveCliAuthorityBrokerEndpoint({
+    transport: "tcp",
+    env,
+    homeDir: options.homeDir
+  });
+  const metadataPath = resolveCliAuthorityBrokerMetadataPath({
+    transport: "tcp",
+    env,
+    homeDir: options.homeDir
+  });
+  const healthPath = resolveCliAuthorityBrokerHealthPath({
+    transport: "tcp",
+    env,
+    homeDir: options.homeDir
+  });
+  return connectCliAuthorityBroker({
+    endpoint,
+    metadataPath,
+    healthPath,
+    dbPath
+  });
+}
+async function getDefaultCliLocalRuntimeDb(options = {}) {
+  const authorityStore = await getDefaultCliLocalRuntimeAuthority(options);
+  return createLegacyServerDb(authorityStore);
+}
+export {
+  connectCliAuthorityBroker,
+  getDefaultCliLocalRuntimeAuthority,
+  getDefaultCliLocalRuntimeDb
+};

package/localRuntimeDb-LGDF6FQP.js

@@ -0,0 +1,12 @@
+import {
+  buildCliLocalRuntimeDbEnv,
+  getDefaultCliLocalRuntimeDb,
+  resolveCliLocalRuntimeDbPath
+} from "./chunk-H33743XH.js";
+import "./chunk-LM6IYQ3F.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  buildCliLocalRuntimeDbEnv,
+  getDefaultCliLocalRuntimeDb,
+  resolveCliLocalRuntimeDbPath
+};