nolo-cli 0.1.33 → 0.1.35

package/cli/agentPullCommand.ts

@@ -1,7 +1,7 @@
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { getDefaultCliLocalRuntimeDb } from "./localRuntimeDb";
 import type { CliLocalRuntimeDb } from "./client/localRuntimeAdapter";
 import { resolveCliAgentKeyInput } from "./agentAliases";
+import { resolveAuthToken, resolveServerUrl } from "./cliEnvHelpers";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -44,14 +44,6 @@ 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 [];
@@ -113,8 +105,11 @@ export async function runAgentPullCommand(args: string[], deps: AgentPullCommand
     return 1;
   }
 
-  const serverUrl = resolveServerUrl(env);
-  const authToken = resolveAuthToken(env);
+  const serverUrl = resolveServerUrl(args, env);
+  const authToken =
+    readFlagValue(args, "--token") ||
+    readFlagValue(args, "--machine-key") ||
+    resolveAuthToken(env, ["BENCHMARK_AUTH_TOKEN"]);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const db = deps.db ?? await getDefaultCliLocalRuntimeDb();
 

package/cli/agentRecordCommands.ts

@@ -2,6 +2,7 @@ import { resolveCliAgentKeyInput } from "./agentAliases";
 import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
 import {
   buildUpdatedAgentRecord,
+  buildCreatedAgentRecord,
   normalizeAgentRecordForOutput,
   parseAgentUpdateArgs,
   resolveAgentRecordFromHybridStore,
@@ -21,7 +22,7 @@ export async function runAgentReadCommand(
     return agentInput ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] agent read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -35,6 +36,7 @@ export async function runAgentReadCommand(
   try {
     const result = await resolveAgentRecordFromHybridStore({
       agentInput,
+      cliArgs: args,
       env,
       db,
       fetchImpl,
@@ -79,7 +81,7 @@ export async function runAgentUpdateCommand(
     return args[0] ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] agent update requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -97,6 +99,7 @@ export async function runAgentUpdateCommand(
 
   try {
     const built = await buildUpdatedAgentRecord({
+      cliArgs: args,
       parsed,
       env,
       db,
@@ -139,3 +142,85 @@ export async function runAgentUpdateCommand(
     return 1;
   }
 }
+
+export async function runAgentCreateCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  let parsed;
+  try {
+    parsed = parseAgentUpdateArgs(args);
+  } catch (error) {
+    output.write(`[nolo] agent create failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+  if (!parsed) {
+    output.write(
+      "Usage: nolo agent create <agent> [--model <id>] [--cli-provider <provider>] [--api-source <source>] [--prompt <text> | --prompt-file <path> | --prompt-doc <pageKey>] [--tools <json>] [--copy-provider-from <agent>] [--name <name>] [--custom-provider-url <url>] [--provider-api-key <key>] [--field key=value]\n"
+    );
+    return args[0] ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent create requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent create could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+
+  try {
+    const built = await buildCreatedAgentRecord({
+      cliArgs: args,
+      parsed,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+      authToken,
+    });
+
+    await writeAgentRecord({
+      agentKey: built.agentKey,
+      authToken,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverUrl: built.serverUrl,
+      userId,
+      record: built.nextRecord,
+    });
+    await db.put(built.agentKey, {
+      ...built.nextRecord,
+      dbKey: built.agentKey,
+      key: built.nextRecord?.key || built.agentKey,
+      serverOrigin: built.serverUrl,
+    });
+
+    output.write(JSON.stringify({
+      ok: true,
+      agentKey: built.agentKey,
+      baseUrl: built.serverUrl,
+      updates: built.updates,
+      record: built.nextRecord,
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent create failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}

package/cli/agentRecordHelpers.ts

@@ -125,10 +125,12 @@ export async function readDbRecord(args: {
   authToken: string;
   fallbackFetchImpl?: typeof fetch;
   fetchImpl: typeof fetch;
+  includeDeleted?: boolean;
   serverUrl: string;
 }) {
+  const query = args.includeDeleted ? "?includeDeleted=true" : "";
   const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}${query}`,
     {
       method: "GET",
       headers: { Authorization: `Bearer ${args.authToken}` },
@@ -146,19 +148,29 @@ export async function queryUserRecords(args: {
   authToken: string;
   fallbackFetchImpl?: typeof fetch;
   fetchImpl: typeof fetch;
+  limit?: number;
   serverUrl: string;
+  summary?: boolean;
+  includeDeleted?: boolean;
   userId: string;
-  type: "agent" | "cybot";
-}) {
+  type: string | string[];
+}): Promise<any[]> {
+  const query = typeof args.limit === "number" && args.limit > 0
+    ? `?limit=${Math.floor(args.limit)}`
+    : "";
   const res = await fetchWithTransportFallback(
-    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}`,
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}${query}`,
     {
       method: "POST",
       headers: {
         Authorization: `Bearer ${args.authToken}`,
         "Content-Type": "application/json",
       },
-      body: JSON.stringify({ type: args.type }),
+      body: JSON.stringify({
+        type: args.type,
+        ...(args.includeDeleted ? { includeDeleted: true } : {}),
+        ...(args.summary ? { summary: true } : {}),
+      }),
     },
     args
   );
@@ -173,6 +185,34 @@ export async function queryUserRecords(args: {
       : [];
 }
 
+export async function deleteDbRecord(args: {
+  dbKey: string;
+  deleteOptions?: { type?: "single" | "table" | "messages" };
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const type = args.deleteOptions?.type;
+  const query =
+    type && type !== "single"
+      ? `?type=${encodeURIComponent(type)}`
+      : "";
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/delete/${encodeURIComponent(args.dbKey)}${query}`,
+    {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${args.authToken}` },
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`delete failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data;
+}
+
 export async function writeAgentRecord(args: {
   agentKey: string;
   authToken: string;
@@ -205,14 +245,19 @@ export async function writeAgentRecord(args: {
 
 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.env);
-  const defaultServerUrl = resolveServerUrl(args.env);
+  const authToken = args.cliArgs
+    ? resolveAuthToken(args.cliArgs, args.env)
+    : resolveAuthToken(args.env);
+  const defaultServerUrl = args.cliArgs
+    ? resolveServerUrl(args.cliArgs, args.env)
+    : resolveServerUrl(args.env);
 
   for (const key of buildLocalAgentLookupKeys({
     agentRef: agentKey,
@@ -232,7 +277,11 @@ export async function resolveAgentRecordFromHybridStore(args: {
     }
 
     if (!shouldReadAgentKeyRemotely(key)) continue;
-    for (const serverUrl of resolveServerCandidates(args.env, defaultServerUrl)) {
+    for (const serverUrl of (
+      args.cliArgs
+        ? resolveServerCandidates(args.cliArgs, args.env, defaultServerUrl)
+        : resolveServerCandidates(args.env, defaultServerUrl)
+    )) {
       try {
         const remoteRecord = await readAgentRecord({
           agentKey: key,
@@ -290,6 +339,8 @@ export function parseAgentUpdateArgs(args: string[]) {
   const tools = readOption(args, "--tools");
   const copyProviderFrom = readOption(args, "--copy-provider-from");
   const name = readOption(args, "--name");
+  const customProviderUrl = readOption(args, "--custom-provider-url");
+  const apiKey = readOption(args, "--api-key");
 
   const promptSources = [prompt, promptFile, promptDoc].filter(Boolean);
   if (promptSources.length > 1) {
@@ -304,6 +355,8 @@ export function parseAgentUpdateArgs(args: string[]) {
   if (promptFile) updates.prompt = readFileSync(promptFile, "utf8");
   if (tools) updates.tools = parseJsonishValue(tools);
   if (name) updates.name = name;
+  if (customProviderUrl) updates.customProviderUrl = customProviderUrl;
+  if (apiKey) updates.apiKey = apiKey;
 
   for (const entry of readRepeatedOption(args, "--field")) {
     const index = entry.indexOf("=");
@@ -322,7 +375,73 @@ export function parseAgentUpdateArgs(args: string[]) {
   return { agentInput, updates, promptDoc, copyProviderFrom };
 }
 
+export async function buildCreatedAgentRecord(args: {
+  cliArgs?: string[];
+  parsed: NonNullable<ReturnType<typeof parseAgentUpdateArgs>>;
+  env: EnvLike;
+  db: CliKvDb;
+  fetchImpl: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
+  authToken: string;
+}) {
+  const agentKey = resolveCliAgentKeyInput(args.parsed.agentInput);
+  const serverUrl = args.cliArgs ? resolveServerUrl(args.cliArgs, args.env) : resolveServerUrl(args.env);
+
+  if (args.parsed.copyProviderFrom) {
+    const providerSource = await resolveAgentRecordFromHybridStore({
+      agentInput: args.parsed.copyProviderFrom,
+      cliArgs: args.cliArgs,
+      env: args.env,
+      db: args.db,
+      fetchImpl: args.fetchImpl,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+    });
+    if (!providerSource) {
+      throw new Error(`provider source agent not found: ${args.parsed.copyProviderFrom}`);
+    }
+    for (const field of PROVIDER_COPY_FIELDS) {
+      if (field in providerSource.record) {
+        args.parsed.updates[field] = providerSource.record[field];
+      }
+    }
+  }
+
+  if (args.parsed.promptDoc) {
+    const promptDoc = await readDbRecord({
+      dbKey: args.parsed.promptDoc,
+      authToken: args.authToken,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+      serverUrl,
+    });
+    const promptBody = typeof promptDoc?.content === "string" ? promptDoc.content : "";
+    if (!promptBody.trim()) {
+      throw new Error(`prompt doc is empty or unreadable: ${args.parsed.promptDoc}`);
+    }
+    args.parsed.updates.prompt = promptBody;
+  }
+
+  const userId = parseUserIdFromAuthToken(args.authToken);
+
+  const nextRecord = {
+    ...args.parsed.updates,
+    dbKey: agentKey,
+    key: agentKey,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    userId,
+  };
+
+  return {
+    agentKey,
+    serverUrl,
+    nextRecord,
+    updates: args.parsed.updates,
+  };
+}
+
 export async function buildUpdatedAgentRecord(args: {
+  cliArgs?: string[];
   parsed: NonNullable<ReturnType<typeof parseAgentUpdateArgs>>;
   env: EnvLike;
   db: CliKvDb;
@@ -332,13 +451,16 @@ 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.env);
+  const serverUrl = cached?.record?.serverOrigin ?? (
+    args.cliArgs ? resolveServerUrl(args.cliArgs, args.env) : resolveServerUrl(args.env)
+  );
   const currentRecord = await readAgentRecord({
     agentKey,
     authToken: args.authToken,
@@ -350,6 +472,7 @@ 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,

package/cli/agentRuntimeLocal.ts

@@ -19,6 +19,9 @@ export {
   resolvePlatformChatProviderConfig,
   resolveLocalToolPolicy,
   resolveOpenAiCompatibleProviderConfig,
+  resolveRequestedRuntimeToolNames,
+  evaluateShellCommandPolicy,
+  isDestructiveShellCommand,
   shouldUsePlatformChatProvider,
   shouldCacheHybridRemoteRecord,
   shouldFetchAgentRuntimeRecordRemotely,

package/cli/cliCommandDispatch.ts

@@ -31,7 +31,7 @@ function readOption(args: string[], flag: string) {
 
 function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
   const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
-  const apiKey = readOption(args, "--api-key") || readOption(args, "--token");
+  const apiKey = readOption(args, "--machine-key") || readOption(args, "--token");
   return {
     ...runtimeEnv,
     ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
@@ -40,7 +40,7 @@ function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
 }
 
 export function looksLikeDaemonShortcut(args: string[]) {
-  return args.includes("--server-url") || args.includes("--api-key");
+  return args.includes("--server-url") || args.includes("--machine-key");
 }
 
 export function createCliRuntimeContext(args: {

package/cli/cliEnvHelpers.ts

@@ -3,19 +3,17 @@ import { NOLO_CLUSTER_SERVERS } from "../database/config";
 
 export type EnvLike = Record<string, string | undefined>;
 
-export function resolveServerUrl(env: EnvLike) {
+export function resolveServerUrlFromEnv(env: EnvLike) {
   return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
-export function resolveServerCandidates(env: EnvLike, preferred?: string | null) {
-  const values = [
-    preferred?.trim(),
-    env.NOLO_SERVER,
-    env.BASE_URL,
-    env.NOLO_SERVER_URL,
-    DEFAULT_NOLO_SERVER_URL,
-    ...NOLO_CLUSTER_SERVERS,
-  ];
+type ResolverInput = string[] | EnvLike;
+
+function isCliArgs(value: ResolverInput): value is string[] {
+  return Array.isArray(value);
+}
+
+function buildServerCandidates(values: Array<string | null | undefined>) {
   return [...new Set(
     values
       .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
@@ -23,8 +21,78 @@ export function resolveServerCandidates(env: EnvLike, preferred?: string | null)
   )];
 }
 
-export function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || "";
+export function resolveServerUrl(env: EnvLike): string;
+export function resolveServerUrl(args: string[], env: EnvLike): string;
+export function resolveServerUrl(input: ResolverInput, env?: EnvLike) {
+  if (isCliArgs(input)) {
+    const explicit =
+      readOption(input, "--server-url") ||
+      readOption(input, "--server");
+    return explicit?.replace(/\/+$/, "") || resolveServerUrlFromEnv(env ?? {});
+  }
+  return resolveServerUrlFromEnv(input);
+}
+
+export function resolveServerCandidates(env: EnvLike, preferred?: string | null): string[];
+export function resolveServerCandidates(
+  args: string[],
+  env: EnvLike,
+  preferred?: string | null,
+): string[];
+export function resolveServerCandidates(
+  input: ResolverInput,
+  envOrPreferred?: EnvLike | string | null,
+  preferred?: string | null,
+) {
+  if (isCliArgs(input)) {
+    const env = (envOrPreferred ?? {}) as EnvLike;
+    const explicitServer = resolveServerUrl(input, env);
+    return buildServerCandidates([
+      explicitServer,
+      preferred?.trim(),
+      env.NOLO_SERVER,
+      env.BASE_URL,
+      env.NOLO_SERVER_URL,
+      DEFAULT_NOLO_SERVER_URL,
+      ...NOLO_CLUSTER_SERVERS,
+    ]);
+  }
+
+  const env = input;
+  return buildServerCandidates([
+    typeof envOrPreferred === "string" ? envOrPreferred.trim() : undefined,
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+  ]);
+}
+
+export function resolveAuthTokenFromEnv(env: EnvLike, extraEnvKeys: string[] = []) {
+  for (const key of ["AUTH_TOKEN", "AUTH", ...extraEnvKeys]) {
+    const value = env[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return "";
+}
+
+export function resolveAuthToken(env: EnvLike, extraEnvKeys?: string[]): string;
+export function resolveAuthToken(args: string[], env: EnvLike, extraEnvKeys?: string[]): string;
+export function resolveAuthToken(
+  input: ResolverInput,
+  envOrExtraEnvKeys?: EnvLike | string[],
+  extraEnvKeys: string[] = [],
+) {
+  if (isCliArgs(input)) {
+    const env = (envOrExtraEnvKeys ?? {}) as EnvLike;
+    return (
+      readOption(input, "--token") ||
+      readOption(input, "--machine-key") ||
+      resolveAuthTokenFromEnv(env, extraEnvKeys)
+    );
+  }
+  return resolveAuthTokenFromEnv(input, (envOrExtraEnvKeys as string[] | undefined) ?? []);
 }
 
 export function parseUserIdFromAuthToken(token: string) {

package/cli/cliSpaceHelpers.ts

@@ -0,0 +1,39 @@
+export function normalizeSpaceIdInput(rawInput: string) {
+  const raw = rawInput.trim();
+  if (!raw) return "";
+
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const url = new URL(raw);
+    const match = url.pathname.match(/^\/space\/([^/?#]+)/);
+    if (match?.[1]) return decodeURIComponent(match[1]);
+  }
+
+  return raw.startsWith("space-") ? raw.slice("space-".length) : raw;
+}
+
+export function buildSpaceLookup(rawInput: string) {
+  const spaceId = normalizeSpaceIdInput(rawInput);
+  return {
+    spaceId,
+    spaceKey: spaceId.startsWith("space-") ? spaceId : `space-${spaceId}`,
+  };
+}
+
+export function getSpaceContentKeys(spaceRecord: any): Set<string> {
+  const keys = new Set<string>();
+  const contents = spaceRecord?.contents;
+  if (!contents || typeof contents !== "object") return keys;
+
+  for (const [entryKey, value] of Object.entries(contents)) {
+    if (typeof entryKey === "string" && entryKey.trim()) {
+      keys.add(entryKey.trim());
+    }
+    if (value && typeof value === "object") {
+      const contentKey = (value as any).contentKey;
+      if (typeof contentKey === "string" && contentKey.trim()) {
+        keys.add(contentKey.trim());
+      }
+    }
+  }
+  return keys;
+}

package/cli/client/agentRun.ts

@@ -778,6 +778,7 @@ async function runLocalAgentTurnForCli(
       background: options.background,
       noStream: options.noStream,
       maxToolRounds: options.maxToolRounds,
+      ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
       ...(traceLocalTools || collectToolEvidence
         ? {
             onToolEvent: (event) => {