nolo-cli 0.1.32 → 0.1.33

package/cli/agentPullCommand.ts

@@ -1,20 +1,14 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { getDefaultCliLocalRuntimeDb } from "./localRuntimeDb";
 import type { CliLocalRuntimeDb } from "./client/localRuntimeAdapter";
-import type { OutputLike } from "./cliIoTypes";
-import {
-  buildCurrentUserPlatformAgentCandidateKeys,
-  resolveCliAgentKeyInput,
-} from "./agentAliases";
-import { resolveAgentRecordFromHybridStore } from "./agentRecordHelpers";
-import {
-  parseUserIdFromAuthToken,
-  readCliOptionValue,
-  resolveAuthToken,
-  resolveServerUrl,
-} from "./cliEnvHelpers";
+import { resolveCliAgentKeyInput } from "./agentAliases";
 
 type EnvLike = Record<string, string | undefined>;
 
+type OutputLike = {
+  write(chunk: string): unknown;
+};
+
 type AgentPullCommandDeps = {
   env?: EnvLike;
   output?: OutputLike;
@@ -27,7 +21,8 @@ export type ParsedAgentPullArgs = {
 };
 
 function readFlagValue(args: string[], flag: string) {
-  return readCliOptionValue(args, flag) || undefined;
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
 }
 
 function positionalArgs(args: string[]) {
@@ -49,6 +44,14 @@ export function parseAgentPullArgs(args: string[]): ParsedAgentPullArgs | null {
   return { agentKey: resolveCliAgentKeyInput(agentKey) };
 }
 
+function resolveServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+}
+
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
+
 function extractToolNames(record: any) {
   if (Array.isArray(record?.toolNames)) return record.toolNames.filter((tool: unknown) => typeof tool === "string");
   if (!Array.isArray(record?.tools)) return [];
@@ -110,58 +113,35 @@ export async function runAgentPullCommand(args: string[], deps: AgentPullCommand
     return 1;
   }
 
-  const serverUrl = resolveServerUrl(args, env);
-  const authToken = resolveAuthToken(args, env);
-  const currentUserId = parseUserIdFromAuthToken(authToken);
+  const serverUrl = resolveServerUrl(env);
+  const authToken = resolveAuthToken(env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const db = deps.db ?? await getDefaultCliLocalRuntimeDb();
-  const agentInput = readFlagValue(args, "--agent") ?? positionalArgs(args)[0] ?? parsed.agentKey;
-  let agentKey = parsed.agentKey;
-  let resolvedRecord: any;
-
-  const candidateKeys = buildCurrentUserPlatformAgentCandidateKeys(agentInput, currentUserId);
-  if (candidateKeys.length > 0 && candidateKeys[0] !== parsed.agentKey) {
-    const resolved = await resolveAgentRecordFromHybridStore({
-      agentInput,
-      cliArgs: args,
-      env,
-      db,
+
+  let record: any;
+  try {
+    record = await readRemoteAgent({
+      agentKey: parsed.agentKey,
+      serverUrl,
+      authToken,
       fetchImpl,
     });
-    if (resolved?.agentKey) {
-      agentKey = resolved.agentKey;
-      if (resolved.source === "remote-cache") {
-        resolvedRecord = resolved.record;
-      }
-    }
-  }
-
-  let record: any = resolvedRecord;
-  if (!record) {
-    try {
-      record = await readRemoteAgent({
-        agentKey,
-        serverUrl,
-        authToken,
-        fetchImpl,
-      });
-    } catch (error) {
-      output.write(
-        `[nolo] Failed to pull ${agentKey} from ${serverUrl}: ${
-          error instanceof Error ? error.message : String(error)
-        }\n`
-      );
-      return 1;
-    }
+  } catch (error) {
+    output.write(
+      `[nolo] Failed to pull ${parsed.agentKey} from ${serverUrl}: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
   }
 
   if (!record || typeof record !== "object") {
-    output.write(`[nolo] Server returned an empty agent record for ${agentKey}.\n`);
+    output.write(`[nolo] Server returned an empty agent record for ${parsed.agentKey}.\n`);
     return 1;
   }
 
-  const localRecord = normalizeAgentRecord(agentKey, record);
-  await db.put(agentKey, localRecord);
-  output.write(`[nolo] cached ${agentKey} in local LevelDB\n`);
+  const localRecord = normalizeAgentRecord(parsed.agentKey, record);
+  await db.put(parsed.agentKey, localRecord);
+  output.write(`[nolo] cached ${parsed.agentKey} in local LevelDB\n`);
   return 0;
 }

package/cli/agentRecordCommands.ts

@@ -17,11 +17,11 @@ export async function runAgentReadCommand(
   const output = deps.output ?? process.stdout;
   const agentInput = args[0]?.trim();
   if (!agentInput || agentInput === "--help" || agentInput === "-h") {
-    output.write("Usage: nolo agent read <agent> [--server <url>]\n");
+    output.write("Usage: nolo agent read <agent>\n");
     return agentInput ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -35,7 +35,6 @@ export async function runAgentReadCommand(
   try {
     const result = await resolveAgentRecordFromHybridStore({
       agentInput,
-      cliArgs: args,
       env,
       db,
       fetchImpl,
@@ -80,7 +79,7 @@ export async function runAgentUpdateCommand(
     return args[0] ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent update requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -98,7 +97,6 @@ export async function runAgentUpdateCommand(
 
   try {
     const built = await buildUpdatedAgentRecord({
-      cliArgs: args,
       parsed,
       env,
       db,

package/cli/agentRecordHelpers.ts

@@ -1,14 +1,8 @@
 import { readFileSync } from "node:fs";
-import {
-  buildPrivateAgentKey,
-  buildCurrentUserPlatformAgentCandidateKeys,
-  resolveCliAgentKeyInput,
-  resolvePlatformAgentAliasSpec,
-} from "./agentAliases";
+import { resolveCliAgentKeyInput } from "./agentAliases";
 import type { CliKvDb } from "./client/hybridRecordStore";
 import { buildLocalAgentLookupKeys, shouldReadAgentKeyRemotely } from "./client/localAgentRecords";
 import {
-  hasExplicitServerOverride,
   parseUserIdFromAuthToken,
   readOption,
   resolveAuthToken,
@@ -16,7 +10,6 @@ import {
   resolveServerUrl,
   type EnvLike,
 } from "./cliEnvHelpers";
-import { parseSpaceIdFromInput, readSpaceRecordWithFallback } from "./spaceMutationHelpers";
 
 const PROVIDER_COPY_FIELDS = [
   "apiSource",
@@ -155,13 +148,10 @@ export async function queryUserRecords(args: {
   fetchImpl: typeof fetch;
   serverUrl: string;
   userId: string;
-  type: "agent" | "cybot" | "dialog";
-  limit?: number;
+  type: "agent" | "cybot";
 }) {
   const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}${
-      typeof args.limit === "number" && Number.isFinite(args.limit) ? `?limit=${args.limit}` : ""
-    }`,
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}`,
     {
       method: "POST",
       headers: {
@@ -191,26 +181,6 @@ export async function writeAgentRecord(args: {
   serverUrl: string;
   userId: string;
   record: Record<string, any>;
-}) {
-  return writeDbRecord({
-    authToken: args.authToken,
-    dbKey: args.agentKey,
-    fallbackFetchImpl: args.fallbackFetchImpl,
-    fetchImpl: args.fetchImpl,
-    record: args.record,
-    serverUrl: args.serverUrl,
-    userId: args.userId,
-  });
-}
-
-export async function writeDbRecord(args: {
-  authToken: string;
-  dbKey: string;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  serverUrl: string;
-  userId: string;
-  record: Record<string, any>;
 }) {
   const res = await fetchWithTransportFallback(`${args.serverUrl}/api/v1/db/write/`, {
     method: "POST",
@@ -219,11 +189,11 @@ export async function writeDbRecord(args: {
       "Content-Type": "application/json",
     },
     body: JSON.stringify({
-      customKey: args.dbKey,
+      customKey: args.agentKey,
       userId: args.userId,
       data: {
         ...args.record,
-        dbKey: args.dbKey,
+        dbKey: args.agentKey,
       },
     }),
   }, args);
@@ -233,145 +203,36 @@ export async function writeDbRecord(args: {
   }
 }
 
-export async function deleteDbRecord(args: {
-  authToken: string;
-  dbKey: string;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  serverUrl: string;
-  userId: string;
-}) {
-  const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/delete/${encodeURIComponent(args.dbKey)}?userId=${encodeURIComponent(args.userId)}`,
-    {
-      method: "DELETE",
-      headers: {
-        Authorization: `Bearer ${args.authToken}`,
-      },
-    },
-    args
-  );
-  const text = await res.text();
-  let data: any = {};
-  if (text) {
-    try {
-      data = JSON.parse(text);
-    } catch {
-      data = {};
-    }
-  }
-  if (res.status === 404) return "missing" as const;
-  if (!res.ok && res.status !== 204) {
-    throw new Error(`delete failed: HTTP ${res.status} ${JSON.stringify(data)}`);
-  }
-  return "deleted" as const;
-}
-
 export async function resolveAgentRecordFromHybridStore(args: {
   agentInput: string;
-  cliArgs?: string[];
   env: EnvLike;
   db: CliKvDb;
   fetchImpl: typeof fetch;
   fallbackFetchImpl?: typeof fetch;
 }) {
   const agentKey = resolveCliAgentKeyInput(args.agentInput);
-  const authToken = resolveAuthToken(args.cliArgs ?? [], args.env);
-  const currentUserId = parseUserIdFromAuthToken(authToken);
-  const cliArgs = args.cliArgs ?? [];
-  const defaultServerUrl = resolveServerUrl(cliArgs, args.env);
-  const serverCandidates = resolveServerCandidates(cliArgs, args.env, defaultServerUrl);
-  const preferRemote = hasExplicitServerOverride(cliArgs);
-  const aliasSpec = resolvePlatformAgentAliasSpec(args.agentInput);
-  const rawSpaceInput = readOption(cliArgs, "--space");
-  const preferredLookupKeys = buildCurrentUserPlatformAgentCandidateKeys(
-    args.agentInput,
-    currentUserId
-  );
-  const collectSpaceAttachedCandidateKeys = (spaceRecord: any) => {
-    const contents = spaceRecord?.contents;
-    if (!contents || typeof contents !== "object") return [];
-
-    const currentUserPrivateKey =
-      currentUserId ? buildPrivateAgentKey(currentUserId, aliasSpec!.agentId) : null;
-    const canonicalMatches: string[] = [];
-    const otherMatches: string[] = [];
-    const currentUserMatches: string[] = [];
+  const authToken = resolveAuthToken(args.env);
+  const defaultServerUrl = resolveServerUrl(args.env);
 
-    for (const [entryKey, value] of Object.entries(contents)) {
-      if (!value || typeof value !== "object") continue;
-      const contentKey =
-        typeof (value as any).contentKey === "string" && (value as any).contentKey.trim()
-          ? (value as any).contentKey.trim()
-          : entryKey.trim();
-      if (!contentKey || !contentKey.endsWith(`-${aliasSpec!.agentId}`)) continue;
-      if (contentKey === aliasSpec!.canonicalKey) {
-        canonicalMatches.push(contentKey);
-        continue;
-      }
-      if (currentUserPrivateKey && contentKey === currentUserPrivateKey) {
-        currentUserMatches.push(contentKey);
-        continue;
-      }
-      otherMatches.push(contentKey);
-    }
-
-    return Array.from(
-      new Set([
-        ...canonicalMatches.sort(),
-        ...otherMatches.sort(),
-        ...currentUserMatches.sort(),
-      ])
-    );
-  };
-  const resolveSpaceAttachedCandidateKeys = async () => {
-    if (!aliasSpec || !rawSpaceInput || !authToken) return [];
+  for (const key of buildLocalAgentLookupKeys({
+    agentRef: agentKey,
+    userId: parseUserIdFromAuthToken(authToken) || "local",
+  })) {
     try {
-      const spaceId = parseSpaceIdFromInput(rawSpaceInput);
-      let localSpaceRecord: any = null;
-      try {
-        localSpaceRecord = await args.db.get(`space-${spaceId}`);
-      } catch {
-        localSpaceRecord = null;
-      }
-
-      const localMatches = collectSpaceAttachedCandidateKeys(localSpaceRecord);
-      if (localMatches.length > 0) return localMatches;
-
-      const spaceRecord = await readSpaceRecordWithFallback({
-        authToken,
-        db: {
-          ...args.db,
-          get: async () => {
-            throw new Error("force remote refresh for shared space alias resolution");
-          },
-        },
-        fallbackFetchImpl: args.fallbackFetchImpl,
-        fetchImpl: args.fetchImpl,
-        serverCandidates,
-        spaceId,
-      });
-      if (spaceRecord && typeof args.db.put === "function") {
-        await args.db.put(`space-${spaceId}`, spaceRecord);
+      const record = await args.db.get(key);
+      if (record && typeof record === "object") {
+        return {
+          agentKey: key,
+          record,
+          source: record?.serverOrigin ? "remote-cache" : "local-cache",
+        } as const;
       }
-      return collectSpaceAttachedCandidateKeys(spaceRecord);
     } catch {
-      return [];
+      // local miss
     }
-  };
-  const spaceAttachedLookupKeys = await resolveSpaceAttachedCandidateKeys();
-  const lookupKeys =
-    spaceAttachedLookupKeys.length > 0
-      ? Array.from(new Set([...spaceAttachedLookupKeys, ...preferredLookupKeys]))
-      : preferredLookupKeys.length > 0
-        ? preferredLookupKeys
-      : buildLocalAgentLookupKeys({
-          agentRef: agentKey,
-          userId: currentUserId || "local",
-        });
 
-  const readRemoteRecord = async (key: string) => {
-    for (const serverUrl of serverCandidates) {
+    if (!shouldReadAgentKeyRemotely(key)) continue;
+    for (const serverUrl of resolveServerCandidates(args.env, defaultServerUrl)) {
       try {
         const remoteRecord = await readAgentRecord({
           agentKey: key,
@@ -391,31 +252,6 @@ export async function resolveAgentRecordFromHybridStore(args: {
         // try next
       }
     }
-    return null;
-  };
-
-  for (const key of lookupKeys) {
-    if (preferRemote && shouldReadAgentKeyRemotely(key)) {
-      const remoteFirst = await readRemoteRecord(key);
-      if (remoteFirst) return remoteFirst;
-    }
-
-    try {
-      const record = await args.db.get(key);
-      if (record && typeof record === "object") {
-        return {
-          agentKey: key,
-          record,
-          source: record?.serverOrigin ? "remote-cache" : "local-cache",
-        } as const;
-      }
-    } catch {
-      // local miss
-    }
-
-    if (!shouldReadAgentKeyRemotely(key)) continue;
-    const remoteFallback = await readRemoteRecord(key);
-    if (remoteFallback) return remoteFallback;
   }
 
   return null;
@@ -487,7 +323,6 @@ export function parseAgentUpdateArgs(args: string[]) {
 }
 
 export async function buildUpdatedAgentRecord(args: {
-  cliArgs?: string[];
   parsed: NonNullable<ReturnType<typeof parseAgentUpdateArgs>>;
   env: EnvLike;
   db: CliKvDb;
@@ -497,14 +332,13 @@ export async function buildUpdatedAgentRecord(args: {
 }) {
   const cached = await resolveAgentRecordFromHybridStore({
     agentInput: args.parsed.agentInput,
-    cliArgs: args.cliArgs,
     env: args.env,
     db: args.db,
     fetchImpl: args.fetchImpl,
     fallbackFetchImpl: args.fallbackFetchImpl,
   });
   const agentKey = cached?.agentKey ?? resolveCliAgentKeyInput(args.parsed.agentInput);
-  const serverUrl = cached?.record?.serverOrigin ?? resolveServerUrl(args.cliArgs ?? [], args.env);
+  const serverUrl = cached?.record?.serverOrigin ?? resolveServerUrl(args.env);
   const currentRecord = await readAgentRecord({
     agentKey,
     authToken: args.authToken,
@@ -516,7 +350,6 @@ export async function buildUpdatedAgentRecord(args: {
   if (args.parsed.copyProviderFrom) {
     const providerSource = await resolveAgentRecordFromHybridStore({
       agentInput: args.parsed.copyProviderFrom,
-      cliArgs: args.cliArgs,
       env: args.env,
       db: args.db,
       fetchImpl: args.fetchImpl,