nolo-cli 0.1.29 → 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/spaceCategoryCommands.ts

@@ -49,7 +49,7 @@ export async function runSpaceCategoryCommand(
     return 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   const userId = parseUserIdFromAuthToken(authToken);
   if (!authToken || !userId) {
     output.write("[nolo] space category requires an auth token with userId. Run `nolo login`.\n");
@@ -66,8 +66,8 @@ export async function runSpaceCategoryCommand(
   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);
+  const defaultServerUrl = resolveServerUrl(args, env);
+  const serverCandidates = resolveServerCandidates(args, env, defaultServerUrl);
 
   try {
     const spaceId = parseSpaceIdFromInput(rawSpace);
@@ -163,7 +163,7 @@ export async function runSpaceContentCategoryCommand(
     return 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   const userId = parseUserIdFromAuthToken(authToken);
   if (!authToken || !userId) {
     output.write("[nolo] space content-category requires an auth token with userId. Run `nolo login`.\n");
@@ -189,8 +189,8 @@ export async function runSpaceContentCategoryCommand(
   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);
+  const defaultServerUrl = resolveServerUrl(args, env);
+  const serverCandidates = resolveServerCandidates(args, env, defaultServerUrl);
 
   try {
     const spaceId = parseSpaceIdFromInput(rawSpace);

package/spaceCommands.ts

@@ -181,7 +181,7 @@ export async function runSpaceListCommand(
   const output = deps.output ?? process.stdout;
   const filters = parseSpaceListArgs(args);
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] space list requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -196,8 +196,8 @@ export async function runSpaceListCommand(
   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);
+  const defaultServerUrl = resolveServerUrl(args, env);
+  const serverCandidates = resolveServerCandidates(args, env, defaultServerUrl);
 
   try {
     let spaces: ListedSpace[];

package/spaceDeleteCommands.ts

@@ -195,7 +195,7 @@ export async function runSpaceDeleteCommand(
     return 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   const userId = parseUserIdFromAuthToken(authToken);
   if (!authToken || !userId) {
     output.write("[nolo] space delete requires an auth token with userId. Run `nolo login`.\n");
@@ -207,7 +207,7 @@ export async function runSpaceDeleteCommand(
   const db = deps.db ?? await getReadableCliDb(output);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const serverUrl = resolveServerUrl(env);
+  const serverUrl = resolveServerUrl(args, env);
 
   try {
     const memberships = await fetchMemberships({

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/spaceReadCommands.ts

@@ -79,7 +79,7 @@ export async function runSpaceReadCommand(
   const output = deps.output ?? process.stdout;
   const { raw, brief, contentKeyFilter, includeRecord } = parseSpaceReadArgs(args);
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   if (!authToken) {
     output.write("[nolo] space read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -94,8 +94,8 @@ export async function runSpaceReadCommand(
   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);
+  const defaultServerUrl = resolveServerUrl(args, env);
+  const serverCandidates = resolveServerCandidates(args, env, defaultServerUrl);
 
   try {
     const spaceId = parseSpaceIdFromInput(raw);

package/tableMetaCommands.ts

@@ -158,7 +158,7 @@ export async function runTableMetaCommand(
     return 1;
   }
 
-  const authToken = resolveAuthToken(env);
+  const authToken = resolveAuthToken(args, env);
   const userId = parseUserIdFromAuthToken(authToken);
   if (!authToken || !userId) {
     output.write("[nolo] table meta requires an auth token with userId. Run `nolo login`.\n");
@@ -168,7 +168,7 @@ export async function runTableMetaCommand(
   const name = rawName.trim();
   const description = readOption(args, "--description")?.trim() || undefined;
   const tags = parseTags(readOption(args, "--tags"));
-  const serverUrl = resolveServerUrl(env);
+  const serverUrl = resolveServerUrl(args, env);
   const db = deps.db ?? await getReadableCliDb(output);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;

package/taskRunCommand.ts

@@ -13,6 +13,15 @@ type TaskRunCommandDeps = {
   fetchImpl?: typeof fetch;
 };
 
+const DEFAULT_TASK_RUN_TIMEOUT_MS = 10 * 60 * 1000;
+
+function resolveTaskRunTimeoutMs(env: EnvLike) {
+  const raw = env.NOLO_TASK_RUN_TIMEOUT_MS;
+  if (!raw) return DEFAULT_TASK_RUN_TIMEOUT_MS;
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_TASK_RUN_TIMEOUT_MS;
+}
+
 export async function runTaskRunCommand(args: string[], deps: TaskRunCommandDeps = {}) {
   const env = loadTaskRunEnv(deps.env ?? process.env, { includeDefaultEnvFiles: deps.env === undefined });
   const output = deps.output ?? process.stdout;
@@ -38,6 +47,7 @@ export async function runTaskRunCommand(args: string[], deps: TaskRunCommandDeps
   }
 
   const serverUrl = resolveServerUrl(args, env);
+  const timeoutMs = resolveTaskRunTimeoutMs(env);
   let response: Response;
   try {
     response = await fetchImpl(`${serverUrl}/api/task-run`, {
@@ -47,6 +57,7 @@ export async function runTaskRunCommand(args: string[], deps: TaskRunCommandDeps
         "Content-Type": "application/json",
       },
       body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs),
     });
   } catch (error) {
     output.write(`[nolo] task-run failed: ${error instanceof Error ? error.message : String(error)}\n`);

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));
-}