nolo-cli 0.1.45 → 0.1.47

package/cli/runtimeDoctorCommands.ts

@@ -1,174 +0,0 @@
-import { resolveAgentRuntimeDecision } from "../agent-runtime/runtimeDecision";
-import {
-  resolveCliAuthorityBrokerEndpoint,
-  resolveCliAuthorityBrokerHealthPath,
-  resolveCliAuthorityBrokerMetadataPath,
-  resolveCliAuthorityStoreDriver,
-} from "../database/server/cliAuthorityStoreDriver";
-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 authorityDriver = resolveCliAuthorityStoreDriver({ env });
-  const authorityEndpoint = resolveCliAuthorityBrokerEndpoint({ transport: "tcp", env });
-  const authorityMetadataPath = resolveCliAuthorityBrokerMetadataPath({ transport: "tcp", env });
-  const authorityHealthPath = resolveCliAuthorityBrokerHealthPath({ transport: "tcp", env });
-  const agentKey = readLocalAgentKey(env);
-  try {
-    const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb");
-    const db = await getDefaultCliLocalRuntimeDb({ env });
-    if (!agentKey) {
-      return {
-        ok: true,
-        dbPath,
-        authorityDriver,
-        authorityEndpoint,
-        authorityMetadataPath,
-        authorityHealthPath,
-        agentFound: false,
-      };
-    }
-    try {
-      const record = await db.get(agentKey);
-      return {
-        ok: true,
-        dbPath,
-        authorityDriver,
-        authorityEndpoint,
-        authorityMetadataPath,
-        authorityHealthPath,
-        agentFound: record != null,
-        agentKey,
-      };
-    } catch {
-      return {
-        ok: true,
-        dbPath,
-        authorityDriver,
-        authorityEndpoint,
-        authorityMetadataPath,
-        authorityHealthPath,
-        agentFound: false,
-        agentKey,
-      };
-    }
-  } catch (error) {
-    return {
-      ok: false,
-      dbPath,
-      authorityDriver,
-      authorityEndpoint,
-      authorityMetadataPath,
-      authorityHealthPath,
-      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(args, env);
-  const serverUrl = resolveServerUrl(args, 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 ||
-      args.includes("--server") ||
-      args.includes("--server-url") ||
-      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`);
-  output.write(`Authority driver: ${localProbe.authorityDriver ?? "unknown"}\n`);
-  if (localProbe.authorityEndpoint) {
-    output.write(`Authority endpoint: ${localProbe.authorityEndpoint}\n`);
-  }
-  if (localProbe.authorityMetadataPath) {
-    output.write(`Authority metadata: ${localProbe.authorityMetadataPath}\n`);
-  }
-  if (localProbe.authorityHealthPath) {
-    output.write(`Authority health: ${localProbe.authorityHealthPath}\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/cli/runtimeModeArgs.ts

@@ -1,33 +0,0 @@
-import type { AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
-
-type TuiLaunchMode = {
-  shouldStartTui: boolean;
-  envPatch: Record<string, string>;
-};
-
-function runtimeModeFromFlag(flag: string): AgentRuntimeRequestedMode | "" {
-  if (flag === "--local") return "local";
-  if (flag === "--server") return "server";
-  if (flag === "--auto") return "auto";
-  return "";
-}
-
-export function resolveTuiLaunchMode(args: string[]): TuiLaunchMode {
-  const command = args[0];
-  if (command !== "chat" && command !== "tui") {
-    return { shouldStartTui: false, envPatch: {} };
-  }
-  if (args.length === 1) {
-    return { shouldStartTui: true, envPatch: {} };
-  }
-  if (args.length === 2) {
-    const mode = runtimeModeFromFlag(args[1] ?? "");
-    if (mode) {
-      return {
-        shouldStartTui: true,
-        envPatch: { NOLO_RUNTIME_MODE: mode },
-      };
-    }
-  }
-  return { shouldStartTui: false, envPatch: {} };
-}

package/cli/scriptCommandEntries.ts

@@ -1,66 +0,0 @@
-import { createScriptCommand, type CommandEntry } from "./cliCommandTypes";
-
-function getDocScriptCommands(): CommandEntry[] {
-  return [
-    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", "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"),
-  ];
-}
-
-function getSpaceScriptCommands(): CommandEntry[] {
-  return [
-    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/cli/secretScan.ts

@@ -1,31 +0,0 @@
-export type SecretFinding = {
-  label: string;
-  line: number;
-  preview: string;
-};
-
-const SECRET_PATTERNS: Array<{ label: string; pattern: RegExp }> = [
-  { label: "password", pattern: /\bpassword\s*[:=]\s*["']?[^"',\s#]{8,}/i },
-  { label: "psk", pattern: /\bpsk\s*[:=]\s*["']?[^"',\s#]{8,}/i },
-  { label: "api key", pattern: /\b(api[_-]?key|apikey)\s*[:=]\s*["']?[^"',\s#]{12,}/i },
-  { label: "token", pattern: /\b(token|secret)\s*[:=]\s*["']?[^"',\s#]{12,}/i },
-  { label: "private key", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-];
-
-export function findPotentialSecrets(text: string): SecretFinding[] {
-  return text
-    .split(/\r?\n/)
-    .flatMap((line, index) =>
-      SECRET_PATTERNS.filter(({ pattern }) => pattern.test(line)).map(({ label }) => ({
-        label,
-        line: index + 1,
-        preview: line.length > 120 ? `${line.slice(0, 117)}...` : line,
-      }))
-    );
-}
-
-export function formatSecretFindings(findings: SecretFinding[]) {
-  return findings
-    .map((finding) => `  line ${finding.line} (${finding.label}): ${finding.preview}`)
-    .join("\n");
-}

package/cli/systemInternalCommandEntries.ts

@@ -1,65 +0,0 @@
-import { runLoginCommand, runLogoutCommand, runWhoamiCommand } from "./authCommands";
-import {
-  createArgsCommand,
-  createContextCommand,
-  createDaemonShortcutCommand,
-  createEntrypointEnvCommand,
-  createEnvCommand,
-} from "./cliCommandFactories";
-import type { CommandEntry } from "./cliCommandTypes";
-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),
-    createArgsCommand(["login"], "Log in to Nolo", (args) => Promise.resolve(runLoginCommand(args))),
-    createArgsCommand(["logout"], "Log out of Nolo", async () => runLogoutCommand()),
-    createArgsCommand(["whoami"], "Show the current login state", async () => runWhoamiCommand()),
-    createEntrypointEnvCommand(["connect"], "Send machine heartbeats or hold a connector websocket", runMachineConnectCommand),
-    createDaemonShortcutCommand(["daemon"], "Run the connector daemon shortcut", runMachineConnectCommand),
-    createEnvCommand(["machine", "status"], "List machines registered to the current profile", runMachineStatusCommand),
-    createContextCommand(["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;
-    }),
-    createArgsCommand(["update"], "Update the CLI", async () => runSelfUpdate()),
-    createContextCommand(["version"], "Show CLI version", async (_args, ctx) => {
-      console.log(buildCliVersionText(ctx.packageInfo));
-      return 0;
-    }),
-    createContextCommand(["--version"], "Show CLI version", async (_args, ctx) => {
-      console.log(buildCliVersionText(ctx.packageInfo));
-      return 0;
-    }),
-    createContextCommand(["-v"], "Show CLI version", async (_args, ctx) => {
-      console.log(buildCliVersionText(ctx.packageInfo));
-      return 0;
-    }),
-    createArgsCommand(["--help"], "Show help", async () => {
-      console.log(renderHelpText());
-      return 0;
-    }),
-    createArgsCommand(["-h"], "Show help", async () => {
-      console.log(renderHelpText());
-      return 0;
-    }),
-  ];
-}