nolo-cli 0.1.26 → 0.1.29

package/agentDialogsCommands.ts

@@ -0,0 +1,226 @@
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
+import { queryUserRecords, readDbRecord, resolveAgentRecordFromHybridStore } from "./agentRecordHelpers";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import { readFromServerCandidates, readThroughList } from "./hybridReadHelpers";
+
+function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function hasFlag(args: string[], flag: string) {
+  return args.includes(flag);
+}
+
+function usage() {
+  return [
+    "Usage:",
+    "  nolo agent dialogs --agent <agentId|agentKey|agentUrl> [--limit 100] [--tag <tag>] [--json]",
+    "",
+  ].join("\n");
+}
+
+function normalizeText(value: unknown, max = 120): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed.length > max ? `${trimmed.slice(0, max - 3)}...` : trimmed;
+}
+
+function matchesAgent(dialog: any, agentKey: string): boolean {
+  if (dialog?.primaryAgentKey === agentKey) return true;
+  return Array.isArray(dialog?.cybots) && dialog.cybots.includes(agentKey);
+}
+
+function formatTask(dialog: any): string {
+  return (
+    normalizeText(dialog?.taskLabel, 64) ??
+    normalizeText(dialog?.runtimeCheckpoint?.lastUserInput, 64) ??
+    normalizeText(dialog?.title, 64) ??
+    "(untitled)"
+  );
+}
+
+function summarizeDialog(dialog: any) {
+  return {
+    id: dialog?.id ?? null,
+    updatedAt: dialog?.updatedAt ?? null,
+    status: dialog?.status ?? null,
+    taskLabel: dialog?.taskLabel ?? null,
+    title: dialog?.title ?? null,
+    durationMs: dialog?.durationMs ?? null,
+    toolCallCount: dialog?.toolCallCount ?? null,
+    tags: Array.isArray(dialog?.tags) ? dialog.tags : [],
+    lastUserInput: dialog?.runtimeCheckpoint?.lastUserInput ?? null,
+    lastAssistantText: dialog?.runtimeCheckpoint?.lastAssistantText ?? null,
+    lastToolNames: dialog?.runtimeCheckpoint?.lastToolNames ?? [],
+    llmWaitMs: dialog?.runtimeCheckpoint?.latencyProfile?.llmWaitMs ?? null,
+  };
+}
+
+async function listLocalDialogs(args: {
+  db: Awaited<ReturnType<typeof getReadableCliDb>>;
+  userId: string;
+}) {
+  const dialogs: any[] = [];
+  const prefix = `dialog-${args.userId}-`;
+  for await (const [key, value] of args.db.iterator()) {
+    if (typeof key !== "string" || !key.startsWith(prefix) || !value || typeof value !== "object") {
+      continue;
+    }
+    dialogs.push({
+      ...(value as Record<string, unknown>),
+      dbKey: typeof (value as any).dbKey === "string" ? (value as any).dbKey : key,
+    });
+  }
+  return dialogs;
+}
+
+export async function runAgentDialogsCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const agentInput = readOption(args, "--agent");
+  if (!agentInput || hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    output.write(`${usage()}\n`);
+    return agentInput ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    output.write("[nolo] agent dialogs requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const currentUserId = parseUserIdFromAuthToken(authToken);
+  if (!currentUserId) {
+    output.write("[nolo] agent dialogs could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const limit = Math.max(1, Number(readOption(args, "--limit") ?? "100"));
+  const filterTag = readOption(args, "--tag")?.trim();
+  const jsonMode = hasFlag(args, "--json");
+
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const serverUrl = resolveServerUrl(env);
+  const serverCandidates = resolveServerCandidates(env, serverUrl);
+
+  try {
+    const resolvedAgent = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+    });
+    if (!resolvedAgent) {
+      throw new Error(`agent not found: ${agentInput}`);
+    }
+
+    const agentKey = resolvedAgent.agentKey;
+    const agent = resolvedAgent.record;
+    const ownerUserId =
+      (typeof agent?.userId === "string" && agent.userId.trim()) ||
+      currentUserId;
+
+    let resolvedBaseUrl = serverUrl;
+    const loadRemoteDialogs = async () => {
+      const remote = await readFromServerCandidates({
+        serverCandidates,
+        readRemote: (candidateUrl) =>
+          queryUserRecords({
+            authToken,
+            fallbackFetchImpl,
+            fetchImpl,
+            serverUrl: candidateUrl,
+            userId: ownerUserId,
+            type: "dialog",
+            limit: Math.max(limit * 3, 200),
+          }),
+      });
+      resolvedBaseUrl = remote.serverUrl;
+      return remote.value;
+    };
+
+    const readResult = await readThroughList({
+      readLocal: () => listLocalDialogs({ db, userId: ownerUserId }),
+      readRemote: loadRemoteDialogs,
+      isEmpty: (items) => items.filter((dialog: any) => matchesAgent(dialog, agentKey)).length === 0,
+    });
+    const dialogs = readResult.items;
+    const source = readResult.source;
+
+    const filtered = dialogs
+      .filter((dialog: any) => matchesAgent(dialog, agentKey))
+      .filter((dialog: any) => !filterTag || (Array.isArray(dialog?.tags) && dialog.tags.includes(filterTag)))
+      .sort((a: any, b: any) => {
+        const ta = a?.updatedAt == null ? 0 : new Date(a.updatedAt).getTime();
+        const tb = b?.updatedAt == null ? 0 : new Date(b.updatedAt).getTime();
+        return tb - ta;
+      })
+      .slice(0, limit);
+
+    const grouped = filtered.reduce<Record<string, number>>((acc, dialog: any) => {
+      const key = formatTask(dialog);
+      acc[key] = (acc[key] ?? 0) + 1;
+      return acc;
+    }, {});
+
+    const payload = {
+      source,
+      baseUrl: resolvedBaseUrl,
+      agent: {
+        key: agentKey,
+        id: agent?.id ?? null,
+        name: agent?.name ?? null,
+        model: agent?.model ?? null,
+        enableThinking: agent?.enableThinking ?? null,
+        updatedAt: agent?.updatedAt ?? null,
+      },
+      totalDialogs: filtered.length,
+      grouped,
+      dialogs: filtered.map(summarizeDialog),
+    };
+
+    if (jsonMode) {
+      output.write(`${JSON.stringify(payload, null, 2)}\n`);
+      return 0;
+    }
+
+    output.write(`agent=${payload.agent.key}\n`);
+    output.write(
+      `name=${payload.agent.name ?? "-"} model=${payload.agent.model ?? "-"} thinking=${String(payload.agent.enableThinking)}\n`
+    );
+    output.write(`dialogs=${payload.totalDialogs}\n\n`);
+    output.write("groups:\n");
+    for (const [task, count] of Object.entries(grouped)) {
+      output.write(`- ${count} x ${task}\n`);
+    }
+    output.write("\nrecent dialogs:\n");
+    for (const dialog of payload.dialogs) {
+      output.write(
+        `- ${dialog.id} | ${dialog.updatedAt ?? "-"} | ${dialog.durationMs ?? "-"}ms | tools=${dialog.toolCallCount ?? 0} | ${
+          normalizeText(dialog.taskLabel, 48) ?? normalizeText(dialog.title, 48) ?? "-"
+        }\n`
+      );
+    }
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent dialogs failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}

package/agentDoctorCommands.ts

@@ -0,0 +1,203 @@
+import { createUserKey } from "./database/keys";
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
+import { listLocalCachedAgents, listRemoteAgents } from "./agentListHelpers";
+import { queryUserRecords, readDbRecord } from "./agentRecordHelpers";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import { readRecordWithCandidates } from "./hybridReadHelpers";
+
+const TEST_AGENT_PATTERNS = [
+  /^Benchmark\b/i,
+  /\bE2E\b/i,
+  /\btest(er|ing)?\b/i,
+  /\bsmoke\b/i,
+] as const;
+
+function usage() {
+  return [
+    "Audit the current account's publisher identity and agent visibility state.",
+    "",
+    "Usage:",
+    "  nolo agent doctor",
+    "  nolo agent doctor --json",
+    "",
+  ].join("\n");
+}
+
+function looksLikeTestAgent(name: string) {
+  return TEST_AGENT_PATTERNS.some((pattern) => pattern.test(name));
+}
+
+export async function runAgentDoctorCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const wantJson = args.includes("--json");
+
+  if (args.includes("--help") || args.includes("-h")) {
+    output.write(`${usage()}\n`);
+    return 0;
+  }
+
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    output.write("[nolo] agent doctor requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent doctor 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;
+  const defaultServerUrl = resolveServerUrl(env);
+  const serverCandidates = resolveServerCandidates(env, defaultServerUrl);
+
+  try {
+    const [profile, settings, agents] = await Promise.all([
+      readRecordWithCandidates<Record<string, any> | null>({
+        db,
+        dbKey: createUserKey.profile(userId),
+        serverCandidates,
+        readRemote: async (serverUrl, dbKey) =>
+          readDbRecord({
+            authToken,
+            dbKey,
+            fallbackFetchImpl,
+            fetchImpl,
+            serverUrl,
+          }),
+      }).catch(() => null),
+      readRecordWithCandidates<Record<string, any> | null>({
+        db,
+        dbKey: createUserKey.settings(userId),
+        serverCandidates,
+        readRemote: async (serverUrl, dbKey) =>
+          readDbRecord({
+            authToken,
+            dbKey,
+            fallbackFetchImpl,
+            fetchImpl,
+            serverUrl,
+          }),
+      }).catch(() => null),
+      (async () => {
+        try {
+          return await listLocalCachedAgents({ db, userId });
+        } catch {
+          return await listRemoteAgents({
+            authToken,
+            fallbackFetchImpl,
+            fetchImpl,
+            includeLegacy: true,
+            serverUrl: defaultServerUrl,
+            userId,
+            queryUserRecords,
+            readDbRecord,
+          });
+        }
+      })(),
+    ]);
+
+    const mismatchedAgents = agents.filter(
+      (agent) => agent.isPublicFlag !== agent.publicRecordExists
+    );
+    const testishPublicAgents = agents.filter(
+      (agent) => agent.publicRecordExists && looksLikeTestAgent(agent.name)
+    );
+
+    const report = {
+      userId,
+      baseUrl: defaultServerUrl,
+      profile: {
+        nickname: profile?.nickname ?? null,
+        bio: profile?.bio ?? profile?.signature ?? null,
+        website: profile?.website ?? null,
+      },
+      settings: {
+        displayName: settings?.displayName ?? null,
+        bio: settings?.bio ?? null,
+      },
+      counts: {
+        totalAgents: agents.length,
+        publicAgents: agents.filter((agent) => agent.publicRecordExists).length,
+        visibilityMismatches: mismatchedAgents.length,
+        testishPublicAgents: testishPublicAgents.length,
+      },
+      mismatchedAgents: mismatchedAgents.map((agent) => ({
+        id: agent.id,
+        name: agent.name,
+        isPublicFlag: agent.isPublicFlag,
+        publicRecordExists: agent.publicRecordExists,
+      })),
+      testishPublicAgents: testishPublicAgents.map((agent) => ({
+        id: agent.id,
+        name: agent.name,
+        model: agent.model,
+      })),
+      publicAgents: agents
+        .filter((agent) => agent.publicRecordExists)
+        .map((agent) => ({
+          id: agent.id,
+          name: agent.name,
+          model: agent.model,
+        })),
+    };
+
+    if (wantJson) {
+      output.write(`${JSON.stringify(report, null, 2)}\n`);
+      return 0;
+    }
+
+    output.write(`userId: ${report.userId}\n`);
+    output.write(`nickname: ${report.profile.nickname ?? "-"}\n`);
+    output.write(`bio: ${report.profile.bio ?? "-"}\n`);
+    output.write(`website: ${report.profile.website ?? "-"}\n`);
+    output.write(`settings.displayName: ${report.settings.displayName ?? "-"}\n`);
+    output.write(`total agents: ${report.counts.totalAgents}\n`);
+    output.write(`public agents: ${report.counts.publicAgents}\n`);
+    output.write(`visibility mismatches: ${report.counts.visibilityMismatches}\n`);
+    output.write(`test-like public agents: ${report.counts.testishPublicAgents}\n`);
+
+    if (report.mismatchedAgents.length > 0) {
+      output.write("\n[mismatched]\n");
+      for (const agent of report.mismatchedAgents) {
+        output.write(
+          `${agent.id} ${agent.name} flag=${agent.isPublicFlag} publicRecord=${agent.publicRecordExists}\n`
+        );
+      }
+    }
+
+    if (report.testishPublicAgents.length > 0) {
+      output.write("\n[test-like public]\n");
+      for (const agent of report.testishPublicAgents) {
+        output.write(`${agent.id} ${agent.name} (${agent.model})\n`);
+      }
+    }
+
+    if (report.publicAgents.length > 0) {
+      output.write("\n[public agents]\n");
+      for (const agent of report.publicAgents) {
+        output.write(`${agent.id} ${agent.name} (${agent.model})\n`);
+      }
+    }
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent doctor failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}

package/agentInternalCommandEntries.ts

@@ -1,4 +1,9 @@
 import { runAgentListCommand } from "./agentListCommands";
+import { runAgentCreateCustomCommand } from "./agentCreateCustomCommands";
+import { runAgentDialogsCommand } from "./agentDialogsCommands";
+import { runAgentDoctorCommand } from "./agentDoctorCommands";
+import { runAgentUnpublishCommand } from "./agentUnpublishCommands";
+import { runAgentSuperviseCommand } from "./agentSuperviseCommands";
 import {
   runAgentBindCurrentCommand,
   runAgentRuntimeDoctorCommand,
@@ -11,20 +16,24 @@ import {
 } from "./agentRecordCommands";
 import { runAgentRunCommand } from "./agentRunCommand";
 import {
+  createArgsCommand,
   createEnvCommand,
   createEnvScriptDirCommand,
 } from "./cliCommandFactories";
 import type { CommandEntry } from "./cliCommandTypes";
-import { runSetupOfflineMarxistsAgentCommand } from "./offlineMarxistsAgentCommand";
 
 export function getAgentInternalCommandEntries(): CommandEntry[] {
   return [
     createEnvScriptDirCommand(["chat"], "Chat with an agent", runAgentRunCommand),
+    createEnvCommand(["agent", "create-custom"], "Create a custom coding agent", runAgentCreateCustomCommand),
     createEnvCommand(["agent", "list"], "List owned agents", runAgentListCommand),
+    createEnvCommand(["agent", "dialogs"], "Inspect recent dialogs for an agent", runAgentDialogsCommand),
+    createEnvCommand(["agent", "doctor"], "Audit agent workspace health", runAgentDoctorCommand),
+    createEnvCommand(["agent", "unpublish"], "Remove an agent's public record", runAgentUnpublishCommand),
     createEnvCommand(["agent", "pull"], "Cache an agent for local runs", runAgentPullCommand),
     createEnvCommand(["agent", "read"], "Read a single agent", runAgentReadCommand),
     createEnvScriptDirCommand(["agent", "run"], "Run an agent", runAgentRunCommand),
-    createEnvCommand(["agent", "setup-offline-marxists"], "Create or update the Marxists.org offline book agent", runSetupOfflineMarxistsAgentCommand),
+    createArgsCommand(["agent", "supervise"], "Run an agent in autonomous cycles", runAgentSuperviseCommand),
     createEnvCommand(["agent", "update"], "Update agent fields", runAgentUpdateCommand),
     createEnvCommand(["agent", "bind-current"], "Bind an agent to this machine", runAgentBindCurrentCommand),
     createEnvCommand(["agent", "smoke-current"], "Smoke test a bound agent through this machine", runAgentSmokeCurrentCommand),

package/agentListCommands.ts

@@ -12,8 +12,10 @@ import {
 import {
   parseUserIdFromAuthToken,
   resolveAuthToken,
+  resolveServerCandidates,
   resolveServerUrl,
 } from "./cliEnvHelpers";
+import { readFromServerCandidates, readThroughList } from "./hybridReadHelpers";
 
 export async function runAgentListCommand(
   args: string[],
@@ -38,27 +40,34 @@ export async function runAgentListCommand(
   const db = deps.db ?? await getReadableCliDb(output);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const serverUrl = resolveServerUrl(env);
+  const serverCandidates = resolveServerCandidates(env, serverUrl);
 
   try {
-    let agents: ListedAgent[];
-    let source: "local-cache" | "remote-cache";
-    try {
-      agents = await listLocalCachedAgents({ db, userId });
-      source = "local-cache";
-    } catch {
-      const serverUrl = resolveServerUrl(env);
-      agents = await listRemoteAgents({
-        authToken,
-        fallbackFetchImpl,
-        fetchImpl,
-        includeLegacy,
-        serverUrl,
-        userId,
-        queryUserRecords,
-        readDbRecord,
+    const loadRemoteAgents = async () => {
+      const remote = await readFromServerCandidates({
+        serverCandidates,
+        readRemote: (candidateUrl) =>
+          listRemoteAgents({
+            authToken,
+            fallbackFetchImpl,
+            fetchImpl,
+            includeLegacy,
+            serverUrl: candidateUrl,
+            userId,
+            queryUserRecords,
+            readDbRecord,
+          }),
       });
-      source = "remote-cache";
-    }
+      return remote.value;
+    };
+
+    const result = await readThroughList({
+      readLocal: () => listLocalCachedAgents({ db, userId }),
+      readRemote: loadRemoteAgents,
+    });
+    let agents = result.items;
+    const source = result.source;
 
     if (!includeLegacy) {
       agents = agents.filter((agent) => !agent.privateKey.startsWith("cybot-"));