nolo-cli 0.1.32 → 0.1.33

package/database/server/authorityStoreTypes.ts

@@ -1,31 +0,0 @@
-export type AuthorityBatchOperation =
-  | { type: "put"; key: string; value: unknown }
-  | { type: "del"; key: string };
-
-export type AuthorityIteratorOptions = {
-  gte?: string;
-  lte?: string;
-  lt?: string;
-  reverse?: boolean;
-};
-
-export interface AuthorityBatchWriter {
-  put(key: string, value: unknown): void;
-  del(key: string): void;
-  write(): Promise<void>;
-}
-
-export interface AuthorityStore {
-  readonly location?: string;
-  readonly status?: string;
-  open(): Promise<void>;
-  close(): Promise<void>;
-  get<T = any>(key: string): Promise<T>;
-  put(key: string, value: unknown): Promise<void>;
-  del(key: string): Promise<void>;
-  batchWrite(ops: AuthorityBatchOperation[]): Promise<void>;
-  createBatch(): AuthorityBatchWriter;
-  iterator(
-    options?: AuthorityIteratorOptions
-  ): AsyncIterableIterator<[string, unknown]>;
-}

package/database/server/legacyServerDb.ts

@@ -1,58 +0,0 @@
-import type {
-  AuthorityBatchOperation,
-  AuthorityBatchWriter,
-  AuthorityIteratorOptions,
-  AuthorityStore,
-} from "./authorityStoreTypes";
-
-export type LegacyServerDb = {
-  readonly location?: string;
-  readonly status?: string;
-  open(): Promise<void>;
-  close(): Promise<void>;
-  get<T = any>(key: string): Promise<T>;
-  put(key: string, value: unknown): Promise<void>;
-  del(key: string): Promise<void>;
-  batch(ops: AuthorityBatchOperation[]): Promise<void>;
-  batch(): AuthorityBatchWriter;
-  iterator(
-    options?: AuthorityIteratorOptions
-  ): AsyncIterableIterator<[string, unknown]>;
-};
-
-export function createLegacyServerDb(store: AuthorityStore): LegacyServerDb {
-  const batch = (ops?: AuthorityBatchOperation[]) => {
-    if (Array.isArray(ops)) {
-      return store.batchWrite(ops);
-    }
-    return store.createBatch();
-  };
-
-  return {
-    get location() {
-      return store.location;
-    },
-    get status() {
-      return store.status;
-    },
-    async open() {
-      await store.open();
-    },
-    async close() {
-      await store.close();
-    },
-    async get<T = any>(key: string) {
-      return store.get<T>(key);
-    },
-    async put(key: string, value: unknown) {
-      await store.put(key, value);
-    },
-    async del(key: string) {
-      await store.del(key);
-    },
-    batch: batch as LegacyServerDb["batch"],
-    iterator(options: AuthorityIteratorOptions = {}) {
-      return store.iterator(options);
-    },
-  };
-}

package/database/server/levelAuthorityStore.ts

@@ -1,75 +0,0 @@
-import type {
-  AuthorityBatchOperation,
-  AuthorityBatchWriter,
-  AuthorityIteratorOptions,
-  AuthorityStore,
-} from "./authorityStoreTypes";
-
-type LevelBatchWriterLike = {
-  put(key: string, value: unknown): unknown;
-  del(key: string): unknown;
-  write(): Promise<void>;
-};
-
-type LevelLike = {
-  readonly location?: string;
-  readonly status?: string;
-  open?(): Promise<void>;
-  close?(): Promise<void>;
-  get<T = any>(key: string): Promise<T>;
-  put(key: string, value: unknown): Promise<void>;
-  del(key: string): Promise<void>;
-  batch(ops: AuthorityBatchOperation[]): Promise<void>;
-  batch(): LevelBatchWriterLike;
-  iterator(
-    options?: AuthorityIteratorOptions
-  ): AsyncIterableIterator<[string, unknown]>;
-};
-
-export function createLevelAuthorityStore(levelDb: LevelLike): AuthorityStore {
-  const createBatch = (): AuthorityBatchWriter => {
-    const batch = levelDb.batch();
-    return {
-      put(key: string, value: unknown) {
-        batch.put(key, value);
-      },
-      del(key: string) {
-        batch.del(key);
-      },
-      async write() {
-        await batch.write();
-      },
-    };
-  };
-
-  return {
-    get location() {
-      return levelDb.location;
-    },
-    get status() {
-      return levelDb.status;
-    },
-    async open() {
-      await levelDb.open?.();
-    },
-    async close() {
-      await levelDb.close?.();
-    },
-    async get<T = any>(key: string) {
-      return levelDb.get<T>(key);
-    },
-    async put(key: string, value: unknown) {
-      await levelDb.put(key, value);
-    },
-    async del(key: string) {
-      await levelDb.del(key);
-    },
-    async batchWrite(ops: AuthorityBatchOperation[]) {
-      await levelDb.batch(ops);
-    },
-    createBatch,
-    iterator(options: AuthorityIteratorOptions = {}) {
-      return levelDb.iterator(options);
-    },
-  };
-}

package/database/server/memoryAuthorityStore.ts

@@ -1,133 +0,0 @@
-import type {
-  AuthorityBatchOperation,
-  AuthorityBatchWriter,
-  AuthorityIteratorOptions,
-  AuthorityStore,
-} from "./authorityStoreTypes";
-
-type MemoryEntry = {
-  key: string;
-  value: unknown;
-};
-
-const createNotFoundError = () => {
-  const error = new Error("NotFound") as Error & { notFound: true };
-  error.notFound = true;
-  return error;
-};
-
-class MemoryAuthorityBacking {
-  readonly location: string;
-  status: "closed" | "open" = "closed";
-  private readonly data = new Map<string, unknown>();
-
-  constructor(location: string) {
-    this.location = location;
-  }
-
-  async open() {
-    this.status = "open";
-  }
-
-  async close() {
-    this.status = "closed";
-  }
-
-  async get<T = any>(key: string): Promise<T> {
-    if (!this.data.has(key)) {
-      throw createNotFoundError();
-    }
-    return this.data.get(key) as T;
-  }
-
-  async put(key: string, value: unknown) {
-    this.data.set(key, value);
-  }
-
-  async del(key: string) {
-    this.data.delete(key);
-  }
-
-  async batchWrite(ops: AuthorityBatchOperation[]) {
-    for (const op of ops) {
-      if (op.type === "put") {
-        this.data.set(op.key, op.value);
-      } else {
-        this.data.delete(op.key);
-      }
-    }
-  }
-
-  createBatch(): AuthorityBatchWriter {
-    const buffered: AuthorityBatchOperation[] = [];
-    return {
-      put(key: string, value: unknown) {
-        buffered.push({ type: "put", key, value });
-      },
-      del(key: string) {
-        buffered.push({ type: "del", key });
-      },
-      write: async () => {
-        await this.batchWrite(buffered);
-      },
-    };
-  }
-
-  async *iterator(
-    options: AuthorityIteratorOptions = {}
-  ): AsyncIterableIterator<[string, unknown]> {
-    const entries: MemoryEntry[] = Array.from(this.data.entries())
-      .sort(([left], [right]) => left.localeCompare(right))
-      .map(([key, value]) => ({ key, value }));
-
-    if (options.reverse) {
-      entries.reverse();
-    }
-
-    for (const entry of entries) {
-      if (options.gte && entry.key < options.gte) continue;
-      if (options.lte && entry.key > options.lte) continue;
-      if (options.lt && entry.key >= options.lt) continue;
-      yield [entry.key, entry.value];
-    }
-  }
-}
-
-export function createMemoryAuthorityStore(
-  location = ":memory:"
-): AuthorityStore {
-  const backing = new MemoryAuthorityBacking(location);
-
-  return {
-    get location() {
-      return backing.location;
-    },
-    get status() {
-      return backing.status;
-    },
-    async open() {
-      await backing.open();
-    },
-    async close() {
-      await backing.close();
-    },
-    async get<T = any>(key: string) {
-      return backing.get<T>(key);
-    },
-    async put(key: string, value: unknown) {
-      await backing.put(key, value);
-    },
-    async del(key: string) {
-      await backing.del(key);
-    },
-    async batchWrite(ops: AuthorityBatchOperation[]) {
-      await backing.batchWrite(ops);
-    },
-    createBatch() {
-      return backing.createBatch();
-    },
-    iterator(options: AuthorityIteratorOptions = {}) {
-      return backing.iterator(options);
-    },
-  };
-}

package/database/server/serverStoreFactory.ts

@@ -1,124 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Level } from "level";
-
-import type { AuthorityStore } from "./authorityStoreTypes";
-import { createLegacyServerDb, type LegacyServerDb } from "./legacyServerDb";
-import { createLevelAuthorityStore } from "./levelAuthorityStore";
-import { createMemoryAuthorityStore } from "./memoryAuthorityStore";
-
-// Keep the storage seam local-first. Cross-process sharing stays in the
-// existing core/proxy runtime layer; this factory is only for embedded drivers.
-export type ServerStoreDriver = "level" | "memory";
-
-export type ServerStoreFactoryEnv = {
-  NOLO_SERVER_AUTHORITY_DRIVER?: string | undefined;
-};
-
-export const safeJsonEncoding = {
-  name: "safe-json",
-  format: "utf8" as const,
-  encode: (data: any) => JSON.stringify(data),
-  decode: (data: string) => {
-    try {
-      return JSON.parse(data);
-    } catch {
-      console.warn("[LevelDB] Corrupted value:", data?.substring?.(0, 60));
-      return null;
-    }
-  },
-};
-
-export type ServerStoreRuntime = {
-  authorityStore: AuthorityStore;
-  serverDb: LegacyServerDb;
-};
-
-export type ServerStoreFactoryOptions = {
-  driver?: ServerStoreDriver;
-  env?: ServerStoreFactoryEnv;
-  globalScope?: Record<string, unknown>;
-};
-
-export function ensureServerDbDirectory(dbPath: string) {
-  const dir = path.dirname(dbPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-export function createLevelBackedAuthorityStore(dbPath: string): AuthorityStore {
-  const levelDb = new Level<string, any>(dbPath, {
-    valueEncoding: safeJsonEncoding,
-  });
-  return createLevelAuthorityStore(levelDb);
-}
-
-export function resolveServerStoreDriver(
-  env: ServerStoreFactoryEnv = process.env
-): ServerStoreDriver {
-  const rawDriver = env.NOLO_SERVER_AUTHORITY_DRIVER?.trim().toLowerCase();
-  if (!rawDriver) return "level";
-  if (rawDriver === "level") return "level";
-  if (rawDriver === "memory") return "memory";
-  throw new Error(`Unsupported server authority store driver: ${rawDriver}`);
-}
-
-export function createAuthorityStoreForDriver(
-  driver: ServerStoreDriver,
-  dbPath: string,
-  env: ServerStoreFactoryEnv = process.env
-): AuthorityStore {
-  switch (driver) {
-    case "level":
-      return createLevelBackedAuthorityStore(dbPath);
-    case "memory":
-      // Test/dev-only driver that exercises the seam without changing the
-      // production single-writer runtime model.
-      return createMemoryAuthorityStore(dbPath);
-  }
-}
-
-export function getOrCreateServerStoreRuntime(
-  dbPath: string,
-  options: ServerStoreFactoryOptions = {}
-): ServerStoreRuntime {
-  const globalScope =
-    options.globalScope ?? (globalThis as Record<string, unknown>);
-  const driver = options.driver ?? resolveServerStoreDriver(options.env);
-  const cachedDriver = globalScope.__serverAuthorityStoreDriver;
-
-  ensureServerDbDirectory(dbPath);
-
-  if (
-    globalScope.__serverAuthorityStore &&
-    typeof cachedDriver === "string" &&
-    cachedDriver !== driver
-  ) {
-    throw new Error(
-      `Server authority store already initialized with driver ${cachedDriver}, cannot reuse it for ${driver}`
-    );
-  }
-
-  if (!globalScope.__serverAuthorityStore) {
-    globalScope.__serverAuthorityStore = createAuthorityStoreForDriver(
-      driver,
-      dbPath,
-      options.env
-    );
-    globalScope.__serverAuthorityStoreDriver = driver;
-  } else if (!cachedDriver) {
-    globalScope.__serverAuthorityStoreDriver = driver;
-  }
-
-  const authorityStore = globalScope.__serverAuthorityStore as AuthorityStore;
-
-  if (!globalScope.__serverDb) {
-    globalScope.__serverDb = createLegacyServerDb(authorityStore);
-  }
-
-  return {
-    authorityStore,
-    serverDb: globalScope.__serverDb as LegacyServerDb,
-  };
-}

package/database/tombstones.ts

@@ -1,52 +0,0 @@
-export const getRecordTimestamp = (record: any): number => {
-  if (!record || typeof record !== "object") return 0;
-
-  const candidates = [
-    record.updatedAt,
-    record.updated_at,
-    record.createdAt,
-    record.created,
-    record?.meta?.createdAt,
-  ];
-
-  for (const candidate of candidates) {
-    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) {
-      return candidate;
-    }
-    if (typeof candidate === "string" && candidate.trim()) {
-      const timestamp = Date.parse(candidate);
-      if (Number.isFinite(timestamp) && timestamp > 0) {
-        return timestamp;
-      }
-    }
-  }
-
-  return 0;
-};
-
-export const isTombstoneRecord = (record: any): boolean => {
-  if (!record || typeof record !== "object") return false;
-  const deletedAt = record.deletedAt;
-  if (typeof deletedAt === "string") return deletedAt.trim().length > 0;
-  return Boolean(deletedAt);
-};
-
-export const shouldReplaceWithNextRecord = (
-  nextRecord: any,
-  currentRecord: any
-): boolean => {
-  const nextTs = getRecordTimestamp(nextRecord);
-  const currentTs = getRecordTimestamp(currentRecord);
-
-  if (nextTs !== currentTs) return nextTs > currentTs;
-  return isTombstoneRecord(nextRecord) && !isTombstoneRecord(currentRecord);
-};
-
-export const buildTombstoneRecord = <T extends Record<string, any>>(
-  record: T,
-  nowIso: string
-): T & { deletedAt: string; updatedAt: string } => ({
-  ...record,
-  deletedAt: nowIso,
-  updatedAt: nowIso,
-});

package/database/utils/ulid.ts

@@ -1 +0,0 @@
-export { ulid } from "ulid";

package/dialogDataAccess.ts

@@ -1,186 +0,0 @@
-import { fetchMessages } from "./chat/messages/fetchMessages";
-import { getReadableCliDb } from "./agentCommandSupport";
-import type { DialogHttpAttempt, DialogReadSource } from "./dialogReadHelpers";
-
-export function isLocalBaseUrl(baseUrl: string) {
-  try {
-    const hostname = new URL(baseUrl).hostname;
-    return hostname === "localhost" || hostname === "127.0.0.1";
-  } catch {
-    return false;
-  }
-}
-
-async function fetchJsonWithFallback(
-  url: string,
-  init: RequestInit,
-  fetchImpl: typeof fetch,
-  fallbackFetchImpl?: typeof fetch
-) {
-  try {
-    return await fetchImpl(url, init);
-  } catch (error) {
-    if (!fallbackFetchImpl) throw error;
-    return fallbackFetchImpl(url, init);
-  }
-}
-
-async function readDialogOverHttp(args: {
-  authToken: string;
-  base: string;
-  dialogId: string;
-  dialogKey: string;
-  fetchImpl: typeof fetch;
-  fallbackFetchImpl?: typeof fetch;
-  limit: number;
-}) {
-  const authHeaders = {
-    ...(args.authToken ? { Authorization: `Bearer ${args.authToken}` } : {}),
-    "Content-Type": "application/json",
-  };
-
-  const readViaBridge = async () => {
-    const bridgeRes = await fetchJsonWithFallback(
-      `${args.base}/api/dialog-read`,
-      {
-        method: "POST",
-        headers: authHeaders,
-        body: JSON.stringify({
-          dialogKey: args.dialogKey,
-          dialogId: args.dialogId,
-          limit: args.limit,
-        }),
-      },
-      args.fetchImpl,
-      args.fallbackFetchImpl
-    );
-    if (!bridgeRes.ok) {
-      throw Object.assign(new Error(`dialog read bridge failed: HTTP ${bridgeRes.status}`), {
-        status: bridgeRes.status,
-        base: args.base,
-        stage: "bridge",
-      });
-    }
-    const payload = await bridgeRes.json();
-    if (!payload?.ok) {
-      throw Object.assign(
-        new Error(`dialog read bridge failed: ${payload?.error ?? "unknown error"}`),
-        {
-          status: 500,
-          base: args.base,
-          stage: "bridge",
-        }
-      );
-    }
-    return {
-      meta: payload.meta,
-      msgs: payload.msgs,
-      source: "http" as DialogReadSource,
-    };
-  };
-
-  const metaRes = await fetchJsonWithFallback(
-    `${args.base}/api/v1/db/read/${encodeURIComponent(args.dialogKey)}`,
-    {
-      headers: args.authToken ? { Authorization: `Bearer ${args.authToken}` } : {},
-    },
-    args.fetchImpl,
-    args.fallbackFetchImpl
-  );
-
-  if (!metaRes.ok) {
-    if (metaRes.status === 401 || metaRes.status === 403) {
-      return readViaBridge();
-    }
-    throw Object.assign(new Error(`read dialog meta failed: HTTP ${metaRes.status}`), {
-      status: metaRes.status,
-      base: args.base,
-      stage: "meta",
-    });
-  }
-
-  const metaPayload = await metaRes.json().catch(() => ({}));
-  const meta = metaPayload?.data ?? metaPayload;
-
-  const msgsRes = await fetchJsonWithFallback(
-    `${args.base}/rpc/getConvMsgs`,
-    {
-      method: "POST",
-      headers: authHeaders,
-      body: JSON.stringify({ dialogId: args.dialogId, limit: args.limit }),
-    },
-    args.fetchImpl,
-    args.fallbackFetchImpl
-  );
-
-  if (!msgsRes.ok) {
-    if (msgsRes.status === 401 || msgsRes.status === 403) {
-      return readViaBridge();
-    }
-    throw Object.assign(new Error(`read dialog messages failed: HTTP ${msgsRes.status}`), {
-      status: msgsRes.status,
-      base: args.base,
-      stage: "messages",
-    });
-  }
-
-  const msgs = await msgsRes.json();
-  return {
-    meta,
-    msgs,
-    source: "http" as DialogReadSource,
-  };
-}
-
-export async function tryHttpDialogCandidates(args: {
-  authToken: string;
-  bases: string[];
-  dialogId: string;
-  dialogKey: string;
-  fetchImpl: typeof fetch;
-  fallbackFetchImpl?: typeof fetch;
-  limit: number;
-}) {
-  const attempts: DialogHttpAttempt[] = [];
-  for (const base of args.bases) {
-    try {
-      const result = await readDialogOverHttp({
-        authToken: args.authToken,
-        base,
-        dialogId: args.dialogId,
-        dialogKey: args.dialogKey,
-        fetchImpl: args.fetchImpl,
-        fallbackFetchImpl: args.fallbackFetchImpl,
-        limit: args.limit,
-      });
-      attempts.push({ base, ok: true });
-      return { ...result, resolvedBase: base, attempts };
-    } catch (error) {
-      const status =
-        typeof error === "object" && error !== null && "status" in error
-          ? Number((error as any).status)
-          : undefined;
-      const message = error instanceof Error ? error.message : String(error);
-      attempts.push({ base, ok: false, status, message });
-    }
-  }
-  throw Object.assign(new Error("All HTTP dialog reads failed"), { attempts });
-}
-
-export async function readDialogFromLocalDb(args: {
-  db: Awaited<ReturnType<typeof getReadableCliDb>>;
-  dialogId: string;
-  dialogKey: string;
-  limit: number;
-}) {
-  const meta = await args.db.get(args.dialogKey);
-  const msgs = await fetchMessages(args.db, args.dialogId, {
-    limit: args.limit,
-    throwOnError: true,
-  });
-  return {
-    meta,
-    msgs,
-    source: "local-db-fallback" as DialogReadSource,
-  };
-}

package/dialogInternalCommandEntries.ts

@@ -1,11 +0,0 @@
-import { createEnvCommand } from "./cliCommandFactories";
-import type { CommandEntry } from "./cliCommandTypes";
-import { runDialogReadCommand } from "./dialogReadCommands";
-import { runDialogStatusCommand } from "./dialogStatusCommands";
-
-export function getDialogInternalCommandEntries(): CommandEntry[] {
-  return [
-    createEnvCommand(["dialog", "read"], "Read a dialog", runDialogReadCommand),
-    createEnvCommand(["dialog", "status"], "Read compact dialog status", runDialogStatusCommand),
-  ];
-}