nolo-cli 0.1.30 → 0.1.31

package/spaceAttachCommands.ts

@@ -0,0 +1,135 @@
+import { ContentType } from "./app/types";
+import { resolveCliAgentKeyInput } from "./agentAliases";
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
+import { resolveAgentRecordFromHybridStore } from "./agentRecordHelpers";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import {
+  parseSpaceIdFromInput,
+  readSpaceRecordWithFallback,
+  writeSpaceRecord,
+} from "./spaceMutationHelpers";
+
+function usage() {
+  return [
+    "Usage:",
+    "  nolo space attach-agent --space <spaceId|spaceKey|spaceUrl> --agent <agentKey|alias|agentUrl>",
+    "",
+  ].join("\n");
+}
+
+export async function runSpaceAttachAgentCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+
+  if (args.includes("--help") || args.includes("-h")) {
+    output.write(`${usage()}\n`);
+    return 0;
+  }
+
+  const rawSpace = readOption(args, "--space");
+  const rawAgent = readOption(args, "--agent");
+  if (!rawSpace || !rawAgent) {
+    output.write(`${usage()}\n`);
+    return 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!authToken || !userId) {
+    output.write("[nolo] space attach-agent 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(args, env);
+  const serverCandidates = resolveServerCandidates(args, env, defaultServerUrl);
+
+  try {
+    const spaceId = parseSpaceIdFromInput(rawSpace);
+    const agentKey = resolveCliAgentKeyInput(rawAgent);
+    const spaceRecord = await readSpaceRecordWithFallback({
+      authToken,
+      db,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverCandidates,
+      spaceId,
+    });
+    const resolvedAgent = await resolveAgentRecordFromHybridStore({
+      agentInput: rawAgent,
+      cliArgs: args,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+    });
+    if (!resolvedAgent?.record || typeof resolvedAgent.record !== "object") {
+      throw new Error(`agent not found: ${agentKey}`);
+    }
+
+    const title =
+      typeof resolvedAgent.record.name === "string" && resolvedAgent.record.name.trim()
+        ? resolvedAgent.record.name.trim()
+        : agentKey;
+    const now = Date.now();
+    const nextSpaceRecord = {
+      ...spaceRecord,
+      updatedAt: now,
+      contents: {
+        ...(spaceRecord?.contents ?? {}),
+        [agentKey]: {
+          ...(spaceRecord?.contents?.[agentKey] ?? {}),
+          title,
+          type: ContentType.AGENT,
+          contentKey: agentKey,
+          updatedAt: now,
+          createdAt: spaceRecord?.contents?.[agentKey]?.createdAt ?? now,
+        },
+      },
+    };
+
+    await writeSpaceRecord({
+      authToken,
+      db,
+      fallbackFetchImpl,
+      fetchImpl,
+      record: nextSpaceRecord,
+      serverUrl: defaultServerUrl,
+      spaceId,
+      userId,
+    });
+
+    output.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          baseUrl: defaultServerUrl,
+          spaceId,
+          agentKey,
+          title,
+        },
+        null,
+        2
+      )}\n`
+    );
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] space attach-agent failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}

package/spaceInternalCommandEntries.ts

@@ -1,5 +1,6 @@
 import { createEnvCommand } from "./cliCommandFactories";
 import type { CommandEntry } from "./cliCommandTypes";
+import { runSpaceAttachAgentCommand } from "./spaceAttachCommands";
 import {
   runSpaceCategoryCommand,
   runSpaceContentCategoryCommand,
@@ -12,6 +13,7 @@ export function getSpaceInternalCommandEntries(): CommandEntry[] {
   return [
     createEnvCommand(["space", "list"], "List joined spaces", runSpaceListCommand),
     createEnvCommand(["space", "read"], "Read a space", runSpaceReadCommand),
+    createEnvCommand(["space", "attach-agent"], "Attach an existing agent to a space", runSpaceAttachAgentCommand),
     createEnvCommand(["space", "category"], "Create or update a space category", runSpaceCategoryCommand),
     createEnvCommand(["space", "content-category"], "Move content into a space category", runSpaceContentCategoryCommand),
     createEnvCommand(["space", "delete"], "Delete spaces by safe filters", runSpaceDeleteCommand),

package/ai/agent/runtimeServerBase.ts

@@ -1,37 +0,0 @@
-export const normalizeServerOrigin = (base: string): string | null => {
-  try {
-    return new URL(base).origin.replace(/\/+$/, "");
-  } catch {
-    return null;
-  }
-};
-
-export const extractAgentRuntimeServerBase = (agentRecord: any): string | null => {
-  const candidates = [
-    agentRecord?.delegation?.serverBase,
-    agentRecord?.runtime?.serverBase,
-    agentRecord?.runtimeServerBase,
-  ];
-
-  if (Array.isArray(agentRecord?.runtimes)) {
-    const runtimes = agentRecord.runtimes
-      .filter((runtime: any) => runtime && typeof runtime === "object")
-      .slice()
-      .sort((a: any, b: any) => {
-        const priorityA =
-          typeof a.priority === "number" ? a.priority : Number.MAX_SAFE_INTEGER;
-        const priorityB =
-          typeof b.priority === "number" ? b.priority : Number.MAX_SAFE_INTEGER;
-        return priorityA - priorityB;
-      });
-    candidates.push(...runtimes.map((runtime: any) => runtime.serverBase));
-  }
-
-  for (const candidate of candidates) {
-    if (typeof candidate === "string" && candidate.trim()) {
-      return candidate.trim();
-    }
-  }
-
-  return null;
-};

package/server/handlers/desktopAgentRuntimeHostFacts.ts

@@ -1,40 +0,0 @@
-import {
-  buildAgentRuntimeDecisionInput,
-  canUsePlatformChatProvider,
-  hasDirectOpenAiCompatibleProvider,
-  type AgentRuntimeCapabilityFacts,
-  type AgentRuntimeDecisionInput,
-} from "../../agent-runtime";
-
-export type DesktopAgentRuntimeEnv = Record<string, string | undefined>;
-
-function hasDesktopLevelDbPersistence(env: DesktopAgentRuntimeEnv) {
-  return Boolean(env.NOLO_SERVER_DB_PATH?.trim());
-}
-
-function hasDesktopProviderRequestEndpoint(env: DesktopAgentRuntimeEnv) {
-  return hasDirectOpenAiCompatibleProvider(env) || canUsePlatformChatProvider(env);
-}
-
-export function describeDesktopAgentRuntimeHostFacts(
-  env: DesktopAgentRuntimeEnv
-): AgentRuntimeCapabilityFacts {
-  const hasLevelDbPersistence = hasDesktopLevelDbPersistence(env);
-  const hasProviderRequestEndpoint = hasDesktopProviderRequestEndpoint(env);
-
-  return {
-    host: "desktop",
-    capabilities: [
-      ...(hasLevelDbPersistence ? ["leveldb-agent-config"] : []),
-      ...(hasProviderRequestEndpoint ? ["local-provider"] : []),
-      ...(hasLevelDbPersistence ? ["leveldb-persistence"] : []),
-    ],
-    serverFallbackAvailable: true,
-  };
-}
-
-export function buildDesktopAgentRuntimeDecisionInput(
-  env: DesktopAgentRuntimeEnv
-): AgentRuntimeDecisionInput {
-  return buildAgentRuntimeDecisionInput(describeDesktopAgentRuntimeHostFacts(env));
-}