nolo-cli 0.1.23 → 0.1.26

package/offlineMarxistsAgentCommand.ts

@@ -0,0 +1,314 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+
+type EnvLike = Record<string, string | undefined>;
+
+type OutputLike = {
+  write(chunk: string): unknown;
+};
+
+type SetupOfflineMarxistsAgentDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  fetchImpl?: typeof fetch;
+  now?: () => number;
+};
+
+type ParsedArgs = {
+  serverUrl: string;
+  authToken: string;
+  userId: string;
+  sourceAgentKey: string;
+  targetAgentId: string;
+  targetAgentKey: string;
+  spaceId: string;
+  name: string;
+  publicAgent: boolean;
+  json: boolean;
+};
+
+const DEFAULT_USER_ID = "b2e06f801f";
+const DEFAULT_SPACE_ID = "01KKY77TT0DA9NY7TNW3R7255N";
+const DEFAULT_SOURCE_AGENT_ID = "01MIMO25MONTH00000001PGT4X";
+const DEFAULT_TARGET_AGENT_ID = "01OFFMARXBOOK000000010AHL1";
+const DEFAULT_AGENT_NAME = "离线马克思主义文库书籍转换助手";
+const TOOL_NAME = "convertMarxistsBookToOfflineHtml";
+const AGENT_TOOLS = [TOOL_NAME];
+
+function readFlagValue(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function parseUserIdFromToken(token: string) {
+  const payload = token.split(".")[0];
+  if (!payload) return "";
+  try {
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+    const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+    return typeof parsed?.userId === "string" ? parsed.userId : "";
+  } catch {
+    return "";
+  }
+}
+
+function normalizeBaseUrl(value: string) {
+  return value.trim().replace(/\/+$/, "");
+}
+
+function parseArgs(args: string[], env: EnvLike): ParsedArgs | null {
+  if (args.includes("--help") || args.includes("-h")) return null;
+  const serverUrl = normalizeBaseUrl(
+    readFlagValue(args, "--server") ??
+      readFlagValue(args, "--server-url") ??
+      env.NOLO_SERVER ??
+      env.BASE_URL ??
+      DEFAULT_NOLO_SERVER_URL
+  );
+  const authToken = readFlagValue(args, "--token") ?? env.AUTH_TOKEN ?? env.NOLO_AUTH_TOKEN ?? "";
+  const userId =
+    readFlagValue(args, "--user-id") ??
+    env.NOLO_USER_ID ??
+    parseUserIdFromToken(authToken) ??
+    DEFAULT_USER_ID;
+  const sourceAgentKey =
+    readFlagValue(args, "--source-agent") ??
+    env.NOLO_MIMO_SOURCE_AGENT_KEY ??
+    `agent-${userId}-${DEFAULT_SOURCE_AGENT_ID}`;
+  const targetAgentId =
+    readFlagValue(args, "--target-agent-id") ??
+    env.NOLO_OFFLINE_MARXISTS_AGENT_ID ??
+    DEFAULT_TARGET_AGENT_ID;
+  const targetAgentKey =
+    readFlagValue(args, "--target-agent") ??
+    env.NOLO_OFFLINE_MARXISTS_AGENT_KEY ??
+    `agent-${userId}-${targetAgentId}`;
+  const spaceId =
+    readFlagValue(args, "--space") ??
+    env.NOLO_OFFLINE_MARXISTS_SPACE_ID ??
+    DEFAULT_SPACE_ID;
+
+  if (!authToken.trim()) return null;
+  return {
+    serverUrl,
+    authToken,
+    userId,
+    sourceAgentKey,
+    targetAgentId,
+    targetAgentKey,
+    spaceId,
+    name: readFlagValue(args, "--name") ?? DEFAULT_AGENT_NAME,
+    publicAgent: args.includes("--public"),
+    json: args.includes("--json"),
+  };
+}
+
+async function readDbRecord(args: {
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  authToken: string;
+  dbKey: string;
+}) {
+  const res = await args.fetchImpl(
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    { headers: { Authorization: `Bearer ${args.authToken}` } }
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`read ${args.dbKey} failed (${res.status}): ${JSON.stringify(data)}`);
+  }
+  return (data as any)?.data ?? data;
+}
+
+async function writeDbRecord(args: {
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  authToken: string;
+  userId: string;
+  dbKey: string;
+  data: Record<string, any>;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/v1/db/write/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${args.authToken}`,
+    },
+    body: JSON.stringify({
+      customKey: args.dbKey,
+      userId: args.userId,
+      data: { ...args.data, dbKey: args.dbKey },
+    }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`write ${args.dbKey} failed (${res.status}): ${JSON.stringify(data)}`);
+  }
+}
+
+function buildTargetAgent(args: {
+  parsed: ParsedArgs;
+  source: Record<string, any>;
+  now: number;
+}) {
+  const { parsed, source, now } = args;
+  if (!source.apiKey) {
+    throw new Error(`source agent ${parsed.sourceAgentKey} has no apiKey`);
+  }
+  if (!source.customProviderUrl) {
+    throw new Error(`source agent ${parsed.sourceAgentKey} has no customProviderUrl`);
+  }
+  return {
+    id: parsed.targetAgentId,
+    type: "agent",
+    name: parsed.name,
+    description:
+      "把 Marxists.org 中文旧式书籍页面转换为可离线打开的单文件 HTML，保留原 CSS、表格排版和背景纹理。",
+    prompt:
+      "你是离线书籍转换助手。用户给出 Marxists.org 中文书籍页面或要求保存离线书籍时，只能调用 convertMarxistsBookToOfflineHtml，不要使用普通网页抓取流程。最终回答必须逐字给出 rawData.fileUrl、rawData.pageCount、rawData.hasNetworkUrls、rawData.byteLength。",
+    isPublic: parsed.publicAgent,
+    model: source.model ?? "mimo-v2.5-pro",
+    provider: source.provider ?? "custom",
+    apiSource: source.apiSource ?? "custom",
+    apiKey: source.apiKey,
+    customProviderUrl: source.customProviderUrl,
+    apiKeyHeader: source.apiKeyHeader ?? "api-key",
+    tools: AGENT_TOOLS,
+    temperature: source.temperature ?? 0.2,
+    maxTokens: source.maxTokens ?? 4096,
+    category: "document-tools",
+    tags: ["offline-book", "marxists", "mimo"],
+    userId: parsed.userId,
+    createdAt: source.createdAt ?? now,
+    updatedAt: now,
+  };
+}
+
+async function attachAgentToSpace(args: {
+  fetchImpl: typeof fetch;
+  parsed: ParsedArgs;
+  contentKey: string;
+  title: string;
+  now: number;
+}) {
+  const spaceKey = `space-${args.parsed.spaceId}`;
+  const space = await readDbRecord({
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.parsed.serverUrl,
+    authToken: args.parsed.authToken,
+    dbKey: spaceKey,
+  });
+  await writeDbRecord({
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.parsed.serverUrl,
+    authToken: args.parsed.authToken,
+    userId: args.parsed.userId,
+    dbKey: spaceKey,
+    data: {
+      ...space,
+      contents: {
+        ...(space.contents ?? {}),
+        [args.contentKey]: {
+          ...(space.contents?.[args.contentKey] ?? {}),
+          title: args.title,
+          type: "agent",
+          contentKey: args.contentKey,
+          createdAt: space.contents?.[args.contentKey]?.createdAt ?? args.now,
+          updatedAt: args.now,
+        },
+      },
+      updatedAt: args.now,
+    },
+  });
+}
+
+function writeUsage(output: OutputLike) {
+  output.write(
+    "Usage: nolo agent setup-offline-marxists [--server https://nolo.chat] [--source-agent <key>] [--space <spaceId>] [--target-agent-id <id>] [--json]\n" +
+      "Requires AUTH_TOKEN from `nolo login` or --token.\n"
+  );
+}
+
+export async function runSetupOfflineMarxistsAgentCommand(
+  args: string[],
+  deps: SetupOfflineMarxistsAgentDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const parsed = parseArgs(args, env);
+  if (!parsed) {
+    writeUsage(output);
+    return 1;
+  }
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const now = deps.now?.() ?? Date.now();
+
+  try {
+    const source = await readDbRecord({
+      fetchImpl,
+      serverUrl: parsed.serverUrl,
+      authToken: parsed.authToken,
+      dbKey: parsed.sourceAgentKey,
+    });
+    const target = buildTargetAgent({ parsed, source, now });
+    await writeDbRecord({
+      fetchImpl,
+      serverUrl: parsed.serverUrl,
+      authToken: parsed.authToken,
+      userId: parsed.userId,
+      dbKey: parsed.targetAgentKey,
+      data: target,
+    });
+    const publicKey = `agent-pub-${parsed.targetAgentId}`;
+    if (parsed.publicAgent) {
+      await writeDbRecord({
+        fetchImpl,
+        serverUrl: parsed.serverUrl,
+        authToken: parsed.authToken,
+        userId: parsed.userId,
+        dbKey: publicKey,
+        data: target,
+      });
+    }
+    await attachAgentToSpace({
+      fetchImpl,
+      parsed,
+      contentKey: parsed.publicAgent ? publicKey : parsed.targetAgentKey,
+      title: parsed.name,
+      now,
+    });
+
+    const result = {
+      serverUrl: parsed.serverUrl,
+      sourceAgentKey: parsed.sourceAgentKey,
+      agentKey: parsed.targetAgentKey,
+      agentUrl: `${parsed.serverUrl}/${parsed.targetAgentKey}`,
+      publicKey: parsed.publicAgent ? publicKey : null,
+      spaceId: parsed.spaceId,
+      model: target.model,
+      provider: target.provider,
+      customProviderUrl: target.customProviderUrl,
+      tools: target.tools,
+    };
+    if (parsed.json) {
+      output.write(`${JSON.stringify(result, null, 2)}\n`);
+    } else {
+      output.write(
+        [
+          `created/updated: ${result.agentKey}`,
+          `url: ${result.agentUrl}`,
+          `space: ${result.spaceId}`,
+          `model: ${result.model}`,
+          `tools: ${result.tools.join(", ")}`,
+          "",
+        ].join("\n")
+      );
+    }
+    return 0;
+  } catch (error) {
+    output.write(
+      `setup-offline-marxists failed: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+    return 1;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.23",
+  "version": "0.1.26",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -11,17 +11,35 @@
     "index.ts",
     "agentRuntimeLocal.ts",
     "agentAliases.ts",
+    "agentCommandSupport.ts",
+    "agentListCommands.ts",
     "localRuntimeDb.ts",
     "agentRuntimeCommands.ts",
+    "agentListHelpers.ts",
+    "agentMachineCommands.ts",
     "agentPullCommand.ts",
+    "agentRecordCommands.ts",
+    "agentRecordHelpers.ts",
     "agentRunCommand.ts",
     "authCommands.ts",
+    "cliCommandAdapters.ts",
+    "cliCommandFactories.ts",
+    "cliCommandDispatch.ts",
+    "cliCommandTypes.ts",
+    "cliEnvHelpers.ts",
     "commandRegistry.ts",
     "connectorRunArtifact.ts",
     "connectorWebSocketTarget.ts",
     "defaultServer.ts",
+    "agentInternalCommandEntries.ts",
+    "internalCommandEntries.ts",
     "machineCommands.ts",
+    "offlineMarxistsAgentCommand.ts",
+    "runtimeDoctorCommands.ts",
+    "scriptCommandEntries.ts",
+    "systemInternalCommandEntries.ts",
     "taskRunCommand.ts",
+    "workflowInternalCommandEntries.ts",
     "runtimeModeArgs.ts",
     "tableCommands.ts",
     "updateCommands.ts",
@@ -32,8 +50,8 @@
     "connector-experimental/**/*.ts",
     "agent-runtime/**/*.ts",
     "database/**/*.ts",
-    "connector-experimental/**/*.ts",
     "ai/**/*.ts",
+    "connector-experimental/**/*.ts",
     "render/**/*.ts"
   ],
   "publishConfig": {

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/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),
+  ];
+}