nolo-cli 0.1.22 → 0.1.26

package/runtimeDoctorCommands.ts

@@ -0,0 +1,118 @@
+import { resolveAgentRuntimeDecision } from "./agent-runtime/runtimeDecision";
+import {
+  type AgentCommandDeps,
+  type LocalRuntimeProbeResult,
+} from "./agentCommandSupport";
+import {
+  resolveAuthToken,
+  resolveServerUrl,
+  type EnvLike,
+} from "./cliEnvHelpers";
+
+function detectLocalAgentConfig(env: EnvLike) {
+  return Boolean(readLocalAgentKey(env) || env.NOLO_AGENT_CACHE_READY);
+}
+
+function readLocalAgentKey(env: EnvLike) {
+  return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
+}
+
+function detectLocalProvider(env: EnvLike) {
+  return Boolean(
+    env.OPENAI_API_KEY ||
+    env.ANTHROPIC_API_KEY ||
+    env.GOOGLE_API_KEY ||
+    env.NOLO_LOCAL_OPENAI_BASE_URL ||
+    env.OLLAMA_BASE_URL
+  );
+}
+
+function detectProviderLabel(env: EnvLike) {
+  if (env.NOLO_LOCAL_OPENAI_BASE_URL) return `openai-compatible endpoint ${env.NOLO_LOCAL_OPENAI_BASE_URL}`;
+  if (env.OLLAMA_BASE_URL) return `ollama-compatible endpoint ${env.OLLAMA_BASE_URL}`;
+  if (env.OPENAI_API_KEY) return "openai via env OPENAI_API_KEY";
+  if (env.ANTHROPIC_API_KEY) return "anthropic via env ANTHROPIC_API_KEY";
+  if (env.GOOGLE_API_KEY) return "google via env GOOGLE_API_KEY";
+  return "missing";
+}
+
+async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbeResult> {
+  const { resolveCliLocalRuntimeDbPath } = await import("./localRuntimeDb");
+  const dbPath = resolveCliLocalRuntimeDbPath({ env });
+  const agentKey = readLocalAgentKey(env);
+  try {
+    const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb");
+    const db = await getDefaultCliLocalRuntimeDb();
+    if (!agentKey) {
+      return { ok: true, dbPath, agentFound: false };
+    }
+    try {
+      await db.get(agentKey);
+      return { ok: true, dbPath, agentFound: true, agentKey };
+    } catch {
+      return { ok: true, dbPath, agentFound: false, agentKey };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      dbPath,
+      agentFound: false,
+      ...(agentKey ? { agentKey } : {}),
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function runDoctorRuntimeCommand(
+  _args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const authToken = resolveAuthToken(env);
+  const serverUrl = resolveServerUrl(env);
+  const localProbe = await (deps.localRuntimeProbe ?? defaultLocalRuntimeProbe)(env);
+  const hasLocalAgentConfig = detectLocalAgentConfig(env) && localProbe.ok && localProbe.agentFound;
+  const hasLocalProvider = detectLocalProvider(env);
+  const missingLocalCapabilities = [
+    ...(localProbe.ok ? [] : ["leveldb"]),
+    ...(hasLocalAgentConfig ? [] : ["agent-config"]),
+    ...(hasLocalProvider ? [] : ["provider"]),
+  ];
+  const decision = resolveAgentRuntimeDecision({
+    requestedMode: "auto",
+    syncRequested: false,
+    host: "cli",
+    hasLocalAgentConfig,
+    hasLocalProvider,
+    hasLocalPersistence: true,
+    missingLocalCapabilities,
+    requiresServer: false,
+    serverFallbackAvailable: Boolean(authToken || env.NOLO_SERVER || env.BASE_URL),
+  });
+
+  output.write(`Runtime: ${decision.mode}\n`);
+  output.write(`Reason: ${decision.reason}\n`);
+  output.write(`LevelDB: ${localProbe.ok ? "ok" : "failed"}\n`);
+  output.write(`DB path: ${localProbe.dbPath}\n`);
+  if (!localProbe.ok && localProbe.error) {
+    output.write(`DB error: ${localProbe.error}\n`);
+  }
+  if (localProbe.agentKey) {
+    output.write(`Agent config: ${localProbe.agentFound ? "found" : "missing"} (${localProbe.agentKey})\n`);
+  } else {
+    output.write("Agent config: missing (no local agent key)\n");
+  }
+  output.write(`Provider: ${hasLocalProvider ? "available" : "missing"} (${detectProviderLabel(env)})\n`);
+  output.write("Persistence: LevelDB local store\n");
+  output.write(`Sync: ${authToken ? "available" : "unavailable"}${authToken ? "" : " (not authenticated)"}\n`);
+  output.write(`Server fallback: ${decision.runnable && decision.mode === "server" ? serverUrl : authToken || env.NOLO_SERVER || env.BASE_URL ? serverUrl : "unavailable"}\n`);
+  if (decision.missingLocalCapabilities.length > 0) {
+    output.write("Missing local capabilities:\n");
+    for (const capability of decision.missingLocalCapabilities) {
+      output.write(`- ${capability}\n`);
+    }
+  }
+
+  return decision.runnable ? 0 : 1;
+}

package/scriptCommandEntries.ts

@@ -0,0 +1,71 @@
+import { createScriptCommand, type CommandEntry } from "./cliCommandTypes";
+
+function getDocScriptCommands(): CommandEntry[] {
+  return [
+    createScriptCommand(["doc", "create"], "createDoc.ts", "Create a normal doc"),
+    createScriptCommand(["doc", "read"], "readDoc.ts", "Read a normal doc"),
+    createScriptCommand(["doc", "update"], "updateDoc.ts", "Update a normal doc"),
+    createScriptCommand(["doc", "delete"], "deleteDoc.ts", "Delete a normal doc"),
+    createScriptCommand(["skill-doc", "create"], "createSkillDoc.ts", "Create a skill doc"),
+    createScriptCommand(["skill-doc", "read"], "readSkillDoc.ts", "Read a skill doc"),
+    createScriptCommand(["skill-doc", "update"], "updateSkillDoc.ts", "Update a skill doc"),
+    createScriptCommand(["skill-doc", "delete"], "deleteSkillDoc.ts", "Delete a skill doc"),
+    createScriptCommand(["skill", "create-doc"], "createSkillDoc.ts", "Create a skill-backed doc"),
+  ];
+}
+
+function getSpaceScriptCommands(): CommandEntry[] {
+  return [
+    createScriptCommand(["dialog", "read"], "readDialog.ts", "Read a dialog"),
+    createScriptCommand(["dialog", "status"], "dialogStatus.ts", "Read compact dialog status"),
+    createScriptCommand(["space", "list"], "listSpaces.ts", "List joined spaces"),
+    createScriptCommand(["space", "read"], "readSpace.ts", "Read a space"),
+    createScriptCommand(["space", "delete"], "deleteSpaces.ts", "Delete spaces by safe filters"),
+    createScriptCommand(["space", "category"], "upsertSpaceCategory.ts", "Create or update a space category"),
+    createScriptCommand(["space", "content-category"], "setSpaceContentCategory.ts", "Move content into a space category"),
+  ];
+}
+
+function getTableScriptCommands(): CommandEntry[] {
+  return [
+    createScriptCommand(["table", "add-column"], "tableData.ts", "Add one table column", ["--action", "add-column"]),
+    createScriptCommand(["table", "add-row"], "tableData.ts", "Add one table row", ["--action", "add-row"]),
+    createScriptCommand(["table", "add-rows"], "tableData.ts", "Add table rows", ["--action", "add-rows"]),
+    createScriptCommand(["table", "update-row"], "tableData.ts", "Update one table row", ["--action", "update-row"]),
+    createScriptCommand(["table", "update-rows"], "tableData.ts", "Update table rows", ["--action", "update-rows"]),
+    createScriptCommand(["table", "delete-row"], "tableData.ts", "Delete one table row", ["--action", "delete-row"]),
+    createScriptCommand(["table", "delete-rows"], "tableData.ts", "Delete table rows", ["--action", "delete-rows"]),
+    createScriptCommand(["table", "data"], "tableData.ts", "Low-level table row script bridge"),
+    createScriptCommand(["table", "meta"], "upsertTableMeta.ts", "Create or update table metadata"),
+  ];
+}
+
+function getAgentScriptCommands(): CommandEntry[] {
+  return [
+    createScriptCommand(["agent", "unpublish"], "unpublishAgent.ts", "Remove an agent's public record"),
+    createScriptCommand(["agent", "dialogs"], "queryAgentDialogs.ts", "Inspect recent dialogs for an agent"),
+    createScriptCommand(["agent", "doctor"], "doctorAgentWorkspace.ts", "Audit agent workspace health"),
+    createScriptCommand(["agent", "create-custom"], "createCustomCodingAgent.ts", "Create a custom coding agent"),
+    createScriptCommand(["agent", "create-space"], "createSpaceAgents.ts", "Create or attach shared-space agents"),
+    createScriptCommand(["agent", "setup-demo"], "setupDemoAgent.ts", "Bootstrap demo publisher agents"),
+    createScriptCommand(["agent", "supervise"], "runAutonomousAgent.ts", "Run an agent in autonomous cycles"),
+  ];
+}
+
+function getRuntimeScriptCommands(): CommandEntry[] {
+  return [
+    createScriptCommand(["llama"], "llamaServerSupervisor.ts", "Manage the llama.cpp runtime"),
+    createScriptCommand(["model-runtime"], "localModelRuntimeSupervisor.ts", "Manage local model runtime processes"),
+    createScriptCommand(["dev"], "devControl.ts", "Manage the local dev environment"),
+  ];
+}
+
+export function getScriptCommandEntries(): CommandEntry[] {
+  return [
+    ...getDocScriptCommands(),
+    ...getSpaceScriptCommands(),
+    ...getTableScriptCommands(),
+    ...getAgentScriptCommands(),
+    ...getRuntimeScriptCommands(),
+  ];
+}

package/systemInternalCommandEntries.ts

@@ -0,0 +1,71 @@
+import { runLoginCommand, runLogoutCommand, runWhoamiCommand } from "./authCommands";
+import {
+  createEntrypointEnvCommand,
+  createEnvCommand,
+} from "./cliCommandFactories";
+import { createInternalCommand, type CommandEntry } from "./cliCommandTypes";
+import { withDaemonShortcutArgs } from "./cliCommandDispatch";
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import {
+  runMachineConnectCommand,
+  runMachineStatusCommand,
+} from "./machineCommands";
+import { runDoctorRuntimeCommand } from "./runtimeDoctorCommands";
+import {
+  buildCliDoctorText,
+  buildCliVersionText,
+  runSelfUpdate,
+} from "./updateCommands";
+
+export function getSystemInternalCommandEntries(renderHelpText: () => string): CommandEntry[] {
+  return [
+    createEnvCommand(["doctor", "runtime"], "Diagnose local-first agent runtime selection", runDoctorRuntimeCommand),
+    createInternalCommand(["login"], "Log in to Nolo", (args) => Promise.resolve(runLoginCommand(args))),
+    createInternalCommand(["logout"], "Log out of Nolo", async () => runLogoutCommand()),
+    createInternalCommand(["whoami"], "Show the current login state", async () => runWhoamiCommand()),
+    createEntrypointEnvCommand(["connect"], "Send machine heartbeats or hold a connector websocket", runMachineConnectCommand),
+    createInternalCommand(["daemon"], "Run the connector daemon shortcut", (args, ctx) => {
+      const normalized = withDaemonShortcutArgs(args, ctx.env);
+      return runMachineConnectCommand(["--ws"], {
+        env: normalized.envOverride ?? ctx.env,
+        cliEntrypointPath: ctx.entrypointPath,
+      });
+    }),
+    createInternalCommand(["machine", "status"], "List machines registered to the current profile", (args, ctx) =>
+      runMachineStatusCommand(args, { env: ctx.env })
+    ),
+    createInternalCommand(["doctor"], "Show CLI doctor information", async (_args, ctx) => {
+      console.log(
+        buildCliDoctorText({
+          packageName: ctx.packageInfo.name,
+          version: ctx.packageInfo.version,
+          entrypoint: ctx.entrypointPath,
+          serverUrl: ctx.env.NOLO_SERVER || ctx.env.BASE_URL || DEFAULT_NOLO_SERVER_URL,
+          profileName: ctx.env.NOLO_PROFILE || "local",
+        })
+      );
+      return 0;
+    }),
+    createInternalCommand(["update"], "Update the CLI", async () => runSelfUpdate()),
+    createInternalCommand(["version"], "Show CLI version", async (_args, ctx) => {
+      console.log(buildCliVersionText(ctx.packageInfo));
+      return 0;
+    }),
+    createInternalCommand(["--version"], "Show CLI version", async (_args, ctx) => {
+      console.log(buildCliVersionText(ctx.packageInfo));
+      return 0;
+    }),
+    createInternalCommand(["-v"], "Show CLI version", async (_args, ctx) => {
+      console.log(buildCliVersionText(ctx.packageInfo));
+      return 0;
+    }),
+    createInternalCommand(["--help"], "Show help", async () => {
+      console.log(renderHelpText());
+      return 0;
+    }),
+    createInternalCommand(["-h"], "Show help", async () => {
+      console.log(renderHelpText());
+      return 0;
+    }),
+  ];
+}

package/tableCommands.ts

@@ -1,4 +1,5 @@
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import { includeTableActivityColumns } from "./render/table/activityColumns";
 
 type EnvLike = Record<string, string | undefined>;
 type OutputLike = { write(chunk: string): unknown };
@@ -34,10 +35,24 @@ function parseJsonOption<T>(args: string[], flag: string): T | undefined {
   }
 }
 
+function parseJsonOptionAlias<T>(args: string[], primaryFlag: string, aliasFlag: string): T | undefined {
+  const primary = readOption(args, primaryFlag);
+  const alias = readOption(args, aliasFlag);
+  const raw = primary || alias;
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw) as T;
+  } catch (error) {
+    const usedFlag = primary ? primaryFlag : aliasFlag;
+    throw new Error(`${usedFlag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
 function parseOutputMode(raw: string): OutputMode {
   if (!raw) return "full";
+  if (raw === "json") return "raw";
   if (raw === "full" || raw === "raw" || raw === "items" || raw === "jsonl") return raw;
-  throw new Error(`--output must be one of full, raw, items, jsonl; got ${raw}`);
+  throw new Error(`--output must be one of full, raw, items, json, jsonl; got ${raw}`);
 }
 
 function parseTableArg(raw: string): { tenantId?: string; tableId?: string } {
@@ -94,10 +109,26 @@ function formatOutput(input: { envelope: any; rawData: any; mode: OutputMode }):
   return Array.isArray(items) ? items.map((item) => JSON.stringify(item)).join("\n") : JSON.stringify(items);
 }
 
+function mergeQueryShortcutFilters(args: string[], filters: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
+  const row = readOption(args, "--row") || readOption(args, "--row-id");
+  const rowDbKey = readOption(args, "--row-dbkey");
+  const shortcutFilters: Record<string, unknown> = {};
+  if (row) {
+    if (row.startsWith("row-")) shortcutFilters.dbKey = row;
+    else shortcutFilters.rowId = row;
+  }
+  if (rowDbKey) shortcutFilters.dbKey = rowDbKey;
+  if (Object.keys(shortcutFilters).length === 0) return filters;
+  return {
+    ...(filters ?? {}),
+    ...shortcutFilters,
+  };
+}
+
 function usage(): string {
   return [
     "Usage:",
-    "  nolo table query --table <tableId|metaKey> [--tenant-id <userId>] [--filters <json>] [--columns <json-array>] [--no-base-fields] [--output full|raw|items|jsonl]",
+    "  nolo table query --table <tableId|metaKey> [--tenant-id <userId>] [--filters <json>|--filter <json>] [--row <rowId|rowDbKey>] [--columns <json-array>] [--include-activity] [--no-base-fields] [--output full|raw|items|json|jsonl]",
     "",
   ].join("\n");
 }
@@ -117,7 +148,10 @@ export async function runTableQueryCommand(args: string[], deps: TableCommandDep
   try {
     outputMode = parseOutputMode(readOption(args, "--output"));
     columns = parseJsonOption<string[]>(args, "--columns");
-    filters = parseJsonOption<Record<string, unknown>>(args, "--filters");
+    filters = mergeQueryShortcutFilters(
+      args,
+      parseJsonOptionAlias<Record<string, unknown>>(args, "--filters", "--filter")
+    );
   } catch (error) {
     output.write(`[nolo] table query failed: ${error instanceof Error ? error.message : String(error)}\n`);
     return 1;
@@ -127,6 +161,7 @@ export async function runTableQueryCommand(args: string[], deps: TableCommandDep
   const authToken = resolveAuthToken(args, env);
   const tenantId = readOption(args, "--tenant-id") || tableArg.tenantId || env.USER_ID || parseJwtTenantId(authToken);
   const tableId = tableArg.tableId;
+  const hasSingleRowShortcut = Boolean(readOption(args, "--row") || readOption(args, "--row-id") || readOption(args, "--row-dbkey"));
   if (!tenantId || !tableId) {
     output.write(usage());
     return 1;
@@ -149,9 +184,11 @@ export async function runTableQueryCommand(args: string[], deps: TableCommandDep
         tenantId,
         tableId,
         filters: filters ?? {},
-        columns,
+        columns: hasFlag(args, "--include-activity")
+          ? includeTableActivityColumns(columns)
+          : columns,
         includeBaseFields: !hasFlag(args, "--no-base-fields"),
-        limit: Number(readOption(args, "--limit") || 20),
+        limit: Number(readOption(args, "--limit") || (hasSingleRowShortcut ? 1 : 20)),
         offset: Number(readOption(args, "--offset") || 0),
         sortBy: readOption(args, "--sort-by") || "updatedAt",
         sortOrder: readOption(args, "--sort-order") === "asc" ? "asc" : "desc",

package/workflowInternalCommandEntries.ts

@@ -0,0 +1,11 @@
+import { createEnvCommand } from "./cliCommandFactories";
+import type { CommandEntry } from "./cliCommandTypes";
+import { runTableQueryCommand } from "./tableCommands";
+import { runTaskRunCommand } from "./taskRunCommand";
+
+export function getWorkflowInternalCommandEntries(): CommandEntry[] {
+  return [
+    createEnvCommand(["table", "query"], "Query table rows", runTableQueryCommand),
+    createEnvCommand(["task-run"], "Update durable task-run state through the runner bridge", runTaskRunCommand),
+  ];
+}