nolo-cli 0.1.26 → 0.1.29

package/machineWsSession.ts

@@ -0,0 +1,148 @@
+import type { HeartbeatLoopOptions } from "./connector-experimental/heartbeatLoop";
+import type { MachineHeartbeat } from "./connector-experimental/protocol";
+
+type EnvLike = Record<string, string | undefined>;
+type OutputLike = { write(chunk: string): unknown };
+
+export type ConnectorWebSocketOptions = {
+  headers: Record<string, string>;
+  onMessage: (message: string) => void | Promise<void>;
+  sentMessages: string[];
+};
+
+const CONNECTOR_WS_KEEPALIVE_MS = 25_000;
+
+function buildConnectorKeepaliveMessage() {
+  return JSON.stringify({ type: "connector.keepalive", sentAt: Date.now() });
+}
+
+function resolveHeartbeatIntervalMs(env: EnvLike) {
+  const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");
+  return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
+}
+
+export async function defaultConnectWebSocket(
+  url: string,
+  options: ConnectorWebSocketOptions,
+) {
+  const WebSocketCtor = globalThis.WebSocket;
+  if (!WebSocketCtor) {
+    throw new Error("WebSocket is not available in this runtime");
+  }
+  await new Promise<void>((resolve, reject) => {
+    const ws = new WebSocketCtor(url, {
+      headers: options.headers,
+    } as any);
+    let opened = false;
+    let keepalive: ReturnType<typeof setInterval> | null = null;
+    const clearKeepalive = () => {
+      if (keepalive) {
+        clearInterval(keepalive);
+        keepalive = null;
+      }
+    };
+    ws.addEventListener(
+      "open",
+      () => {
+        opened = true;
+        keepalive = setInterval(() => {
+          try {
+            ws.send(buildConnectorKeepaliveMessage());
+          } catch {
+            clearKeepalive();
+          }
+        }, CONNECTOR_WS_KEEPALIVE_MS);
+      },
+      { once: true },
+    );
+    ws.addEventListener("error", () => {
+      clearKeepalive();
+      reject(new Error("connector websocket failed"));
+    });
+    ws.addEventListener(
+      "close",
+      () => {
+        clearKeepalive();
+        if (opened) resolve();
+        else reject(new Error("connector websocket closed before opening"));
+      },
+      { once: true },
+    );
+    ws.addEventListener("message", (event) => {
+      const startIndex = options.sentMessages.length;
+      Promise.resolve(options.onMessage(String(event.data)))
+        .then(() => {
+          for (const message of options.sentMessages.slice(startIndex)) {
+            ws.send(message);
+          }
+        })
+        .catch(() => undefined);
+    });
+  });
+}
+
+export async function runMachineWsSession(options: {
+  env: EnvLike;
+  output: OutputLike;
+  machine: MachineHeartbeat;
+  serverUrl: string;
+  authToken: string;
+  sendHeartbeat: () => Promise<void>;
+  runHeartbeatLoop: (options: HeartbeatLoopOptions) => Promise<void>;
+  resolveConnectorWebSocketTarget: (args: {
+    serverUrl: string;
+    machineId: string;
+    headers: Record<string, string>;
+  }) => Promise<string>;
+  connectWebSocket: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
+  onMessage: (message: string, send: (message: string) => void) => void | Promise<void>;
+}) {
+  const sentMessages: string[] = [];
+  const heartbeatAbort = new AbortController();
+  let heartbeatLoopPromise: Promise<void> | null = null;
+  let websocketPromise: Promise<void> | null = null;
+  try {
+    await options.sendHeartbeat();
+    options.output.write(
+      `Connector websocket connected: ${options.machine.name} (${options.machine.machineId})\n`
+    );
+    heartbeatLoopPromise = options.runHeartbeatLoop({
+      intervalMs: resolveHeartbeatIntervalMs(options.env),
+      sendHeartbeat: options.sendHeartbeat,
+      signal: heartbeatAbort.signal,
+    });
+    const heartbeatMonitorPromise = heartbeatLoopPromise.then(() => {
+      if (!heartbeatAbort.signal.aborted) {
+        throw new Error("connector heartbeat loop ended unexpectedly");
+      }
+    });
+    const wsTarget = await options.resolveConnectorWebSocketTarget({
+      serverUrl: options.serverUrl,
+      machineId: options.machine.machineId,
+      headers: { Authorization: `Bearer ${options.authToken}` },
+    });
+    websocketPromise = options.connectWebSocket(wsTarget, {
+      headers: { Authorization: `Bearer ${options.authToken}` },
+      sentMessages,
+      onMessage: (message) =>
+        options.onMessage(message, (response) => {
+          sentMessages.push(response);
+        }),
+    });
+    await Promise.race([websocketPromise, heartbeatMonitorPromise]);
+    heartbeatAbort.abort();
+    await Promise.allSettled([websocketPromise, heartbeatLoopPromise]);
+    return 0;
+  } catch (error) {
+    heartbeatAbort.abort();
+    await Promise.allSettled(
+      [websocketPromise, heartbeatLoopPromise].filter(Boolean) as Promise<void>[],
+    );
+    options.output.write(
+      `[nolo] Connector websocket failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.26",
+  "version": "0.1.29",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -12,33 +12,87 @@
     "agentRuntimeLocal.ts",
     "agentAliases.ts",
     "agentCommandSupport.ts",
+    "agentCreateCustomCommands.ts",
+    "agentDialogsCommands.ts",
+    "agentDoctorCommands.ts",
     "agentListCommands.ts",
     "localRuntimeDb.ts",
     "agentRuntimeCommands.ts",
     "agentListHelpers.ts",
     "agentMachineCommands.ts",
     "agentPullCommand.ts",
+    "agentRunLocalWorkspace.ts",
+    "agentRunParsing.ts",
     "agentRecordCommands.ts",
     "agentRecordHelpers.ts",
     "agentRunCommand.ts",
+    "agentSuperviseCommands.ts",
+    "agentUnpublishCommands.ts",
     "authCommands.ts",
+    "build.ts",
+    "buildPublish.ts",
+    "buildPublishArtifactAssembly.ts",
+    "buildPublishImportAnalysis.ts",
     "cliCommandAdapters.ts",
     "cliCommandFactories.ts",
     "cliCommandDispatch.ts",
     "cliCommandTypes.ts",
     "cliEnvHelpers.ts",
+    "cliIoTypes.ts",
+    "hybridReadHelpers.ts",
     "commandRegistry.ts",
     "connectorRunArtifact.ts",
     "connectorWebSocketTarget.ts",
+    "customCodingAgentFlow.ts",
+    "customCodingAgentRecord.ts",
     "defaultServer.ts",
     "agentInternalCommandEntries.ts",
+    "dialogInternalCommandEntries.ts",
+    "dialogDataAccess.ts",
+    "dialogReadCommands.ts",
+    "dialogReadHelpers.ts",
+    "dialogStatusCommands.ts",
+    "docInternalCommandEntries.ts",
     "internalCommandEntries.ts",
+    "machineCommandPrompts.ts",
+    "machineCommandResolution.ts",
     "machineCommands.ts",
-    "offlineMarxistsAgentCommand.ts",
+    "machineDaemonCommands.ts",
+    "machineHeartbeatCommands.ts",
+    "machineStatusCommands.ts",
+    "machineWatchCommands.ts",
+    "machineWsPromptMaterialization.ts",
+    "machineWsRunDispatch.ts",
+    "machineWsSession.ts",
+    "pageCreateCommands.ts",
+    "pageDeleteCommands.ts",
+    "pageReadCommands.ts",
+    "pageUpdateCommands.ts",
+    "pageWriteHelpers.ts",
+    "publishPackage.ts",
+    "runtimeInternalCommandEntries.ts",
     "runtimeDoctorCommands.ts",
+    "runtimePassthroughCommands.ts",
     "scriptCommandEntries.ts",
+    "scriptPassthroughHelpers.ts",
+    "secretScanHelpers.ts",
+    "spaceCategoryCommands.ts",
+    "spaceCommands.ts",
+    "spaceDeleteCommands.ts",
+    "spaceInternalCommandEntries.ts",
+    "spaceMutationHelpers.ts",
+    "spaceReadCommands.ts",
     "systemInternalCommandEntries.ts",
+    "tableDataOutput.ts",
+    "tableQueryParsing.ts",
+    "tableQueryRequest.ts",
+    "tableDataSafety.ts",
+    "tableMetaCommands.ts",
+    "tableMutationCommands.ts",
     "taskRunCommand.ts",
+    "taskRunPromptShared.ts",
+    "taskRunActions.ts",
+    "taskRunParsing.ts",
     "workflowInternalCommandEntries.ts",
     "runtimeModeArgs.ts",
     "tableCommands.ts",
@@ -49,10 +103,19 @@
     "ai/**/*.ts",
     "connector-experimental/**/*.ts",
     "agent-runtime/**/*.ts",
+    "connector-experimental/**/*.ts",
+    "app/**/*.ts",
+    "create/**/*.ts",
     "database/**/*.ts",
     "ai/**/*.ts",
-    "connector-experimental/**/*.ts",
-    "render/**/*.ts"
+    "chat/**/*.ts",
+    "render/**/*.ts",
+    "core/**/*.ts",
+    "auth/**/*.ts",
+    "life/**/*.ts",
+    "share/**/*.ts",
+    "server/**/*.ts",
+    "integrations/**/*.ts"
   ],
   "publishConfig": {
     "access": "public"
@@ -64,9 +127,50 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "unist-util-visit": "^5.0.0",
     "date-fns-tz": "^2.0.0",
     "level": "^10.0.0",
     "js-yaml": "^4.1.0",
-    "ulid": "^2.3.0"
+    "@types/crypto-js": "^4.1.2",
+    "crypto-js": "^4.1.1",
+    "tweetnacl": "^1.0.3",
+    "@reduxjs/toolkit": "^2.5.0",
+    "react-redux": "^9.2.0",
+    "react-hot-toast": "^2.4.1",
+    "react": "^19.2.1",
+    "browser-image-compression": "^2.0.2",
+    "react-i18next": "^14.1.2",
+    "i18next": "^23.11.5",
+    "ulid": "^2.3.0",
+    "pino": "^9.9.0",
+    "slate": "^0.112.0",
+    "mdast-util-from-markdown": "^2.0.2",
+    "mdast-util-gfm": "^3.0.0",
+    "micromark-extension-gfm": "^3.0.0",
+    "slate-history": "^0.113.1",
+    "slate-react": "^0.112.1",
+    "pdfjs-dist": "^5.2.133",
+    "rambda": "^8.6.0",
+    "react-native-blob-util": "^0.24.7",
+    "@react-native-community/netinfo": "^11.5.0",
+    "react-native-sse": "^1.2.1",
+    "@lobehub/icons": "^5.0.1",
+    "pizzip": "^3.2.0",
+    "docxtemplater": "^3.67.5",
+    "iztro": "^2.5.8",
+    "zod": "^3.25.20",
+    "react-hook-form": "^7.51.5",
+    "@hookform/resolvers": "^3.3.2",
+    "react-router-dom": "^6.23.1",
+    "croner": "^8.0.1",
+    "xlsx": "^0.18.5",
+    "mermaid": "^11.6.0",
+    "js-base64": "^3.7.7",
+    "react-native-keychain": "^9.2.2",
+    "async-mutex": "^0.5.0",
+    "diff": "^8.0.2",
+    "react-dom": "^19.2.1",
+    "@waffo/pancake-ts": "^0.5.2",
+    "playwright": "^1.59.1"
   }
 }

package/pageCreateCommands.ts

@@ -0,0 +1,219 @@
+import type { SkillDocConfig } from "./ai/skills/skillDocProtocol";
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
+import { readDbRecord } from "./agentRecordHelpers";
+import { parseUserIdFromAuthToken, resolveAuthToken, resolveServerUrl } from "./cliEnvHelpers";
+import {
+  buildDocSpaceRecord,
+  buildPageKey,
+  buildPageRecord,
+  buildSkillDocId,
+  buildSkillPageRecord,
+  buildSkillSummaryFromRecord,
+  createPageId,
+  parseJsonOption,
+  readBodyOption,
+  readOption,
+  writeRemoteRecordsThenCache,
+} from "./pageWriteHelpers";
+import { findPotentialSecrets, formatSecretFindings } from "./secretScanHelpers";
+
+function usage(command: "doc" | "skill-doc") {
+  return [
+    "Usage:",
+    `  nolo ${command} create --title <title> [options]`,
+    "",
+  ].join("\n");
+}
+
+async function readSpaceRecord(args: {
+  authToken: string;
+  db: Awaited<ReturnType<typeof getReadableCliDb>>;
+  fetchImpl: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
+  serverUrl: string;
+  spaceKey: string;
+}) {
+  try {
+    return await args.db.get(args.spaceKey);
+  } catch {
+    return readDbRecord({
+      authToken: args.authToken,
+      dbKey: args.spaceKey,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+      serverUrl: args.serverUrl,
+    });
+  }
+}
+
+async function runBasePageCreateCommand(
+  args: string[],
+  deps: AgentCommandDeps,
+  mode: "doc" | "skill-doc"
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (args.includes("--help") || args.includes("-h")) {
+    output.write(`${usage(mode)}\n`);
+    return 0;
+  }
+
+  const title = readOption(args, "--title")?.trim();
+  const description = readOption(args, "--description")?.trim();
+  const spaceId = readOption(args, "--space")?.trim() ?? null;
+  if (!title || !spaceId || (mode === "skill-doc" && !description)) {
+    output.write(`${usage(mode)}\n`);
+    return 1;
+  }
+
+  const authToken = resolveAuthToken(env);
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!authToken || !userId) {
+    output.write(`[nolo] ${mode} create requires an auth token with userId. Run \`nolo login\`.\n`);
+    return 1;
+  }
+
+  const body = readBodyOption(args, "");
+  const secretFindings = findPotentialSecrets(body);
+  if (secretFindings.length > 0 && !args.includes("--allow-secrets")) {
+    output.write(
+      `[nolo] refusing to create ${mode} because the body looks like it contains secrets.\n${formatSecretFindings(secretFindings)}\n`
+    );
+    return 1;
+  }
+
+  const serverUrl = resolveServerUrl(env);
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const explicitId = readOption(args, "--id")?.trim();
+  const pageId = explicitId || (mode === "skill-doc" ? buildSkillDocId(title) : createPageId());
+  const dbKey = buildPageKey(userId, pageId);
+  const spaceKey = `space-${spaceId}`;
+  const shouldDryRun = args.includes("--dry-run");
+  const shouldOutputJson = args.includes("--json");
+
+  const pageRecord =
+    mode === "skill-doc"
+      ? buildSkillPageRecord({
+          body,
+          dbKey,
+          existing: null,
+          skillConfig: {
+            version: "0.1",
+            kind: "skill",
+            id: pageId,
+            name: title,
+            description: description!,
+            ...(readOption(args, "--tools") !== undefined
+              ? { toolNames: parseJsonOption<string[]>(readOption(args, "--tools"), []) }
+              : {}),
+            ...(readOption(args, "--required-skills") !== undefined
+              ? { requiredSkills: parseJsonOption<string[]>(readOption(args, "--required-skills"), []) }
+              : {}),
+            ...(readOption(args, "--recommended-skills") !== undefined
+              ? { recommendedSkills: parseJsonOption<string[]>(readOption(args, "--recommended-skills"), []) }
+              : {}),
+            ...(readOption(args, "--preferred-agents") !== undefined
+              ? { preferredAgents: parseJsonOption<string[]>(readOption(args, "--preferred-agents"), []) }
+              : {}),
+            ...(readOption(args, "--trigger-mode") !== undefined
+              ? { triggerMode: readOption(args, "--trigger-mode") as SkillDocConfig["triggerMode"] }
+              : {}),
+            ...(readOption(args, "--budget-tier") !== undefined
+              ? { budgetTier: readOption(args, "--budget-tier") as SkillDocConfig["budgetTier"] }
+              : {}),
+            ...(readOption(args, "--prompt-patch") !== undefined
+              ? { promptPatch: readOption(args, "--prompt-patch") || undefined }
+              : {}),
+          },
+          skillId: pageId,
+          spaceId,
+          title,
+        })
+      : buildPageRecord({
+          content: body,
+          dbKey,
+          meta: description ? { description } : undefined,
+          pageId,
+          spaceId,
+          title,
+        });
+
+  const summary = {
+    dryRun: shouldDryRun,
+    kind: mode === "skill-doc" ? "skill" : "page",
+    title,
+    dbKey,
+    id: pageId,
+    spaceId,
+    baseUrl: serverUrl,
+    secretFindingCount: secretFindings.length,
+    secretFindings,
+  };
+
+  if (shouldDryRun) {
+    output.write(`${JSON.stringify(summary, null, 2)}\n`);
+    return 0;
+  }
+
+  try {
+    const existingSpaceRecord = await readSpaceRecord({
+      authToken,
+      db,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverUrl,
+      spaceKey,
+    });
+    const spaceRecord = buildDocSpaceRecord({
+      contentKey: dbKey,
+      existingSpaceRecord,
+      skillSummary: mode === "skill-doc" ? buildSkillSummaryFromRecord(pageRecord) : undefined,
+      spaceId,
+      title,
+    });
+
+    await writeRemoteRecordsThenCache({
+      authToken,
+      db,
+      fallbackFetchImpl,
+      fetchImpl,
+      records: [
+        { dbKey, record: pageRecord, serverUrl },
+        { dbKey: spaceKey, record: spaceRecord, serverUrl },
+      ],
+      userId,
+    });
+
+    output.write(
+      `${JSON.stringify(
+        shouldOutputJson ? summary : { ...summary, ok: true },
+        null,
+        2
+      )}\n`
+    );
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] ${mode} create failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}
+
+export async function runDocCreateCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  return runBasePageCreateCommand(args, deps, "doc");
+}
+
+export async function runSkillDocCreateCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  return runBasePageCreateCommand(args, deps, "skill-doc");
+}

package/pageDeleteCommands.ts

@@ -0,0 +1,167 @@
+import { parseSkillDocProtocol, resolvePageSkillMetadata } from "./ai/skills/skillDocProtocol";
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
+import { deleteDbRecord, readDbRecord, writeDbRecord } from "./agentRecordHelpers";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import { readRecordWithCandidates } from "./hybridReadHelpers";
+import { buildDetachedDocSpaceRecord, readOption } from "./pageWriteHelpers";
+
+function usage(command: "doc" | "skill-doc") {
+  return [
+    "Usage:",
+    `  nolo ${command} delete --key <pageKey>`,
+    "",
+  ].join("\n");
+}
+
+async function readRecord(args: {
+  authToken: string;
+  db: Awaited<ReturnType<typeof getReadableCliDb>>;
+  dbKey: string;
+  fetchImpl: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
+  serverCandidates: string[];
+}) {
+  return readRecordWithCandidates<Record<string, any>>({
+    db: args.db,
+    dbKey: args.dbKey,
+    serverCandidates: args.serverCandidates,
+    readRemote: async (serverUrl, dbKey) =>
+      readDbRecord({
+        authToken: args.authToken,
+        dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl,
+      }),
+  });
+}
+
+export async function runBasePageDeleteCommand(
+  args: string[],
+  deps: AgentCommandDeps,
+  mode: "doc" | "skill-doc"
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const dbKey = readOption(args, "--key");
+  if (!dbKey || dbKey === "-h" || dbKey === "--help") {
+    output.write(`${usage(mode)}\n`);
+    return dbKey ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(env);
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!authToken || !userId) {
+    output.write(`[nolo] ${mode} delete requires an auth token with userId. Run \`nolo login\`.\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 existing = await readRecord({
+      authToken,
+      db,
+      dbKey,
+      fetchImpl,
+      fallbackFetchImpl,
+      serverCandidates,
+    });
+
+    if (mode === "doc" && existing?.meta?.kind === "skill") {
+      throw new Error(`target page is a skill doc; use \`nolo skill-doc delete --key ${dbKey}\``);
+    }
+    if (mode === "skill-doc") {
+      const parsed = parseSkillDocProtocol(
+        typeof existing?.content === "string" ? existing.content : "",
+        existing?.meta,
+        existing?.tools
+      );
+      const metadata = resolvePageSkillMetadata({
+        ...existing,
+        content: parsed.content,
+      });
+      if (!metadata?.skillConfig) {
+        throw new Error(`target page is not a skill doc: ${dbKey}`);
+      }
+    }
+
+    const spaceId =
+      typeof existing?.spaceId === "string" && existing.spaceId.trim()
+        ? existing.spaceId
+        : null;
+    const spaceKey = spaceId ? `space-${spaceId}` : null;
+    let pendingSpaceRecord: Record<string, any> | null = null;
+
+    if (spaceId && spaceKey) {
+      const existingSpaceRecord = await readRecord({
+        authToken,
+        db,
+        dbKey: spaceKey,
+        fetchImpl,
+        fallbackFetchImpl,
+        serverCandidates,
+      });
+      const spaceRecord = buildDetachedDocSpaceRecord({
+        contentKey: dbKey,
+        existingSpaceRecord,
+        spaceId,
+      });
+      pendingSpaceRecord = spaceRecord;
+      await writeDbRecord({
+        authToken,
+        dbKey: spaceKey,
+        fallbackFetchImpl,
+        fetchImpl,
+        record: spaceRecord,
+        serverUrl: defaultServerUrl,
+        userId,
+      });
+    }
+
+    const deleteStatus = await deleteDbRecord({
+      authToken,
+      dbKey,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverUrl: defaultServerUrl,
+      userId,
+    });
+    if (spaceKey && pendingSpaceRecord) {
+      await db.put(spaceKey, pendingSpaceRecord);
+    }
+    await db.batch([{ type: "del", key: dbKey }]);
+    output.write(`${JSON.stringify({ ok: true, dbKey, status: deleteStatus, spaceKey }, null, 2)}\n`);
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] ${mode} delete failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}
+
+export async function runDocDeleteCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  return runBasePageDeleteCommand(args, deps, "doc");
+}
+
+export async function runSkillDocDeleteCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  return runBasePageDeleteCommand(args, deps, "skill-doc");
+}