nolo-cli 0.1.26 → 0.1.29

package/server/handlers/desktopAgentRuntimeAdapter.ts

@@ -0,0 +1,307 @@
+import type {
+  AgentRuntimeAgentConfig,
+  AgentRuntimeChatMessage,
+  AgentRuntimeHostAdapter,
+  AgentRuntimeProvider,
+  AgentRuntimeSaveTurnInput,
+  AgentRuntimeToolCallInput,
+  AgentRuntimeToolResult,
+} from "../../agent-runtime";
+import {
+  buildAgentRuntimeDialogWritePlan,
+  buildAgentRuntimeAgentLookupKeys,
+  buildOpenAiCompatibleChatCompletionRequest,
+  buildPlatformChatCompletionRequest,
+  dialogMessageRecordToAgentRuntimeMessage,
+  parseOpenAiCompatibleChatCompletionResponse,
+  parsePlatformChatCompletionResponse,
+  resolveAgentRuntimeConfigFromRecord,
+  resolveOpenAiCompatibleProviderConfig,
+  resolvePlatformChatProviderConfig,
+  shouldFetchAgentRuntimeRecordRemotely,
+  shouldUsePlatformChatProvider,
+} from "../../agent-runtime";
+import {
+  describeDesktopAgentRuntimeHostFacts,
+  type DesktopAgentRuntimeEnv,
+} from "./desktopAgentRuntimeHostFacts";
+import { normalizeBuiltinPlatformAgentModelConfig } from "./agentRun/builtinAgents";
+
+export type DesktopAgentRuntimeActions = {
+  loadAgentConfig(agentRef: string): Promise<AgentRuntimeAgentConfig | null>;
+  loadDialogHistory(dialogId: string): Promise<AgentRuntimeChatMessage[]>;
+  saveTurn(input: AgentRuntimeSaveTurnInput): Promise<{ dialogId: string }>;
+  resolveProvider(agentConfig: AgentRuntimeAgentConfig): Promise<AgentRuntimeProvider>;
+  executeTool(call: AgentRuntimeToolCallInput): Promise<AgentRuntimeToolResult>;
+};
+
+export type DesktopAgentRuntimeRecordStore = {
+  read(dbKey: string, options?: { remote?: boolean }): Promise<unknown>;
+  batch?(ops: Array<{ type: "put"; key: string; value: Record<string, unknown> }>): Promise<unknown>;
+  iterator?(options: { gte: string; lte?: string; lt?: string; reverse?: boolean; limit?: number }): AsyncIterable<[string, unknown]>;
+};
+
+export function resolveDesktopAgentRuntimeUserId(env: DesktopAgentRuntimeEnv) {
+  return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
+}
+
+export async function loadDesktopAgentRuntimeAgentConfigFromRecordStore(args: {
+  store: DesktopAgentRuntimeRecordStore;
+  agentRef: string;
+  userId: string;
+}): Promise<AgentRuntimeAgentConfig | null> {
+  for (const key of buildAgentRuntimeAgentLookupKeys(args)) {
+    const record = await args.store.read(key, {
+      remote: shouldFetchAgentRuntimeRecordRemotely(key),
+    });
+    if (!record || typeof record !== "object") continue;
+    return resolveAgentRuntimeConfigFromRecord(
+      key,
+      normalizeBuiltinPlatformAgentModelConfig({
+        ...(record as Record<string, unknown>),
+        dbKey: (record as Record<string, unknown>).dbKey ?? key,
+      }) as Record<string, unknown>,
+    );
+  }
+  return null;
+}
+
+export async function loadDesktopAgentRuntimeDialogHistoryFromRecordStore(args: {
+  store: Pick<DesktopAgentRuntimeRecordStore, "iterator">;
+  dialogId: string;
+}): Promise<AgentRuntimeChatMessage[]> {
+  if (!args.store.iterator) return [];
+  const messages: AgentRuntimeChatMessage[] = [];
+  const prefix = `dialog-${args.dialogId}-msg-`;
+  for await (const [, value] of args.store.iterator({ gte: prefix, lte: `${prefix}\uffff` })) {
+    const message = dialogMessageRecordToAgentRuntimeMessage(value as Record<string, unknown>);
+    if (message) messages.push(message);
+  }
+  return messages;
+}
+
+export function createDesktopAgentRuntimeRecordStoreReadActions(args: {
+  env: DesktopAgentRuntimeEnv;
+  store: DesktopAgentRuntimeRecordStore;
+}): Pick<DesktopAgentRuntimeActions, "loadAgentConfig" | "loadDialogHistory"> {
+  const userId = resolveDesktopAgentRuntimeUserId(args.env);
+  return {
+    loadAgentConfig: (agentRef) => loadDesktopAgentRuntimeAgentConfigFromRecordStore({
+      store: args.store,
+      agentRef,
+      userId,
+    }),
+    loadDialogHistory: (dialogId) => loadDesktopAgentRuntimeDialogHistoryFromRecordStore({
+      store: args.store,
+      dialogId,
+    }),
+  };
+}
+
+export async function saveDesktopAgentRuntimeTurnToRecordStore(args: {
+  store: Pick<DesktopAgentRuntimeRecordStore, "read" | "batch">;
+  input: AgentRuntimeSaveTurnInput;
+  userId: string;
+  now: () => number;
+  createId: () => string;
+  workspaceRoot?: string;
+}) {
+  let existingDialog: Record<string, unknown> | null = null;
+  if (args.input.continueDialogId) {
+    const dialogKey = `dialog-${args.userId}-${args.input.continueDialogId}`;
+    const record = await args.store.read(dialogKey, { remote: false });
+    existingDialog = record && typeof record === "object" ? record as Record<string, unknown> : null;
+  }
+
+  const plan = buildAgentRuntimeDialogWritePlan({
+    input: args.input,
+    userId: args.userId,
+    now: args.now(),
+    createId: args.createId,
+    existingDialog,
+    runtimeHost: "desktop",
+    runtimeMetadata: {
+      ...(args.workspaceRoot ? { worktreePath: args.workspaceRoot } : {}),
+    },
+  });
+  if (!args.store.batch) {
+    throw new Error("Desktop agent runtime record store cannot save turns without batch support.");
+  }
+  await args.store.batch(plan.ops);
+  return { dialogId: plan.dialogId };
+}
+
+export function createDesktopAgentRuntimeRecordStoreActions(args: {
+  env: DesktopAgentRuntimeEnv;
+  store: DesktopAgentRuntimeRecordStore;
+  now: () => number;
+  createId: () => string;
+  workspaceRoot?: string;
+  getWorkspaceRoot?: () => string | undefined;
+  resolveProvider: DesktopAgentRuntimeActions["resolveProvider"];
+  executeTool: DesktopAgentRuntimeActions["executeTool"];
+}): DesktopAgentRuntimeActions {
+  const userId = resolveDesktopAgentRuntimeUserId(args.env);
+  return {
+    ...createDesktopAgentRuntimeRecordStoreReadActions({
+      env: args.env,
+      store: args.store,
+    }),
+    saveTurn: (input) => saveDesktopAgentRuntimeTurnToRecordStore({
+      store: args.store,
+      input,
+      userId,
+      now: args.now,
+      createId: args.createId,
+      workspaceRoot: args.getWorkspaceRoot?.() ?? args.workspaceRoot,
+    }),
+    resolveProvider: args.resolveProvider,
+    executeTool: args.executeTool,
+  };
+}
+
+export function resolveDesktopOpenAiCompatibleProvider(args: {
+  env: DesktopAgentRuntimeEnv;
+  agentConfig: AgentRuntimeAgentConfig;
+  fetchImpl?: typeof fetch;
+  tools?: Record<string, unknown>[];
+}): AgentRuntimeProvider {
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const providerConfig = resolveOpenAiCompatibleProviderConfig({
+    agentConfig: args.agentConfig,
+    env: args.env,
+  });
+  return {
+    model: providerConfig.model,
+    complete: async (messages) => {
+      const request = buildOpenAiCompatibleChatCompletionRequest({
+        providerConfig,
+        messages,
+        tools: args.tools,
+      });
+      const response = await fetchImpl(request.url, request.init);
+      const data = await response.json().catch(() => ({}));
+      if (!response.ok) {
+        throw new Error(`desktop provider failed: HTTP ${response.status} ${JSON.stringify(data)}`);
+      }
+      return parseOpenAiCompatibleChatCompletionResponse({
+        providerConfig,
+        data,
+        trace: messages,
+      });
+    },
+  };
+}
+
+export function resolveDesktopPlatformChatProvider(args: {
+  env: DesktopAgentRuntimeEnv;
+  agentConfig: AgentRuntimeAgentConfig;
+  fetchImpl?: typeof fetch;
+  tools?: Record<string, unknown>[];
+}): AgentRuntimeProvider {
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const providerConfig = resolvePlatformChatProviderConfig({
+    agentConfig: args.agentConfig,
+    env: args.env,
+  });
+  return {
+    model: providerConfig.model,
+    complete: async (messages) => {
+      const request = buildPlatformChatCompletionRequest({
+        providerConfig,
+        messages,
+        tools: args.tools,
+      });
+      const response = await fetchImpl(request.url, request.init);
+      const data = await response.json().catch(() => ({}));
+      if (!response.ok) {
+        throw new Error(`desktop platform provider failed: HTTP ${response.status} ${JSON.stringify(data)}`);
+      }
+      return parsePlatformChatCompletionResponse({
+        providerConfig,
+        data,
+        trace: messages,
+      });
+    },
+  };
+}
+
+export function resolveDesktopConfiguredProvider(args: {
+  env: DesktopAgentRuntimeEnv;
+  agentConfig: AgentRuntimeAgentConfig;
+  fetchImpl?: typeof fetch;
+  tools?: Record<string, unknown>[];
+}): AgentRuntimeProvider {
+  if (shouldUsePlatformChatProvider(args.env, args.agentConfig)) {
+    return resolveDesktopPlatformChatProvider(args);
+  }
+  return resolveDesktopOpenAiCompatibleProvider(args);
+}
+
+export async function loadDesktopAgentRuntimeAgentConfig(args: {
+  actions: Pick<DesktopAgentRuntimeActions, "loadAgentConfig">;
+  agentRef: string;
+}) {
+  return args.actions.loadAgentConfig(args.agentRef);
+}
+
+export async function loadDesktopAgentRuntimeDialogHistory(args: {
+  actions: Pick<DesktopAgentRuntimeActions, "loadDialogHistory">;
+  dialogId: string;
+}) {
+  return args.actions.loadDialogHistory(args.dialogId);
+}
+
+export async function saveDesktopAgentRuntimeTurn(args: {
+  actions: Pick<DesktopAgentRuntimeActions, "saveTurn">;
+  input: AgentRuntimeSaveTurnInput;
+}) {
+  return args.actions.saveTurn(args.input);
+}
+
+export async function resolveDesktopAgentRuntimeProvider(args: {
+  actions: Pick<DesktopAgentRuntimeActions, "resolveProvider">;
+  agentConfig: AgentRuntimeAgentConfig;
+}) {
+  return args.actions.resolveProvider(args.agentConfig);
+}
+
+export async function executeDesktopAgentRuntimeToolCall(args: {
+  actions: Pick<DesktopAgentRuntimeActions, "executeTool">;
+  call: AgentRuntimeToolCallInput;
+}) {
+  return args.actions.executeTool(args.call);
+}
+
+export function createDesktopAgentRuntimeAdapter(args: {
+  env: DesktopAgentRuntimeEnv;
+  actions: DesktopAgentRuntimeActions;
+  capabilities?: string[];
+}): AgentRuntimeHostAdapter {
+  const facts = describeDesktopAgentRuntimeHostFacts(args.env);
+
+  return {
+    host: "desktop",
+    capabilities: [...new Set([...facts.capabilities, ...(args.capabilities ?? [])])],
+    loadAgentConfig: (agentRef) => loadDesktopAgentRuntimeAgentConfig({
+      actions: args.actions,
+      agentRef,
+    }),
+    loadDialogHistory: (dialogId) => loadDesktopAgentRuntimeDialogHistory({
+      actions: args.actions,
+      dialogId,
+    }),
+    saveTurn: (input) => saveDesktopAgentRuntimeTurn({
+      actions: args.actions,
+      input,
+    }),
+    resolveProvider: (agentConfig) => resolveDesktopAgentRuntimeProvider({
+      actions: args.actions,
+      agentConfig,
+    }),
+    executeTool: (call) => executeDesktopAgentRuntimeToolCall({
+      actions: args.actions,
+      call,
+    }),
+  };
+}

package/server/handlers/desktopAgentRuntimeHostFacts.ts

@@ -0,0 +1,40 @@
+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));
+}

package/server/handlers/desktopAgentRuntimeStatusHandler.ts

@@ -0,0 +1,54 @@
+import {
+  resolveAgentRuntimeDecision,
+  type AgentRuntimeDecision,
+} from "../../agent-runtime";
+import {
+  buildDesktopAgentRuntimeDecisionInput,
+  describeDesktopAgentRuntimeHostFacts,
+  type DesktopAgentRuntimeEnv,
+} from "./desktopAgentRuntimeHostFacts";
+
+export type DesktopAgentRuntimeStatus = {
+  ok: true;
+  host: "desktop";
+  capabilities: string[];
+  decision: AgentRuntimeDecision;
+  missingLocalCapabilities: string[];
+};
+
+const JSON_HEADERS = {
+  "Content-Type": "application/json; charset=utf-8",
+};
+
+export function buildDesktopAgentRuntimeStatus(args: {
+  env?: DesktopAgentRuntimeEnv;
+} = {}): DesktopAgentRuntimeStatus {
+  const env = args.env ?? process.env;
+  const facts = describeDesktopAgentRuntimeHostFacts(env);
+  const decision = resolveAgentRuntimeDecision(buildDesktopAgentRuntimeDecisionInput(env));
+  return {
+    ok: true,
+    host: "desktop",
+    capabilities: facts.capabilities,
+    decision,
+    missingLocalCapabilities: decision.missingLocalCapabilities,
+  };
+}
+
+export async function handleDesktopAgentRuntimeStatusGet(
+  _req: Request,
+  deps: { env?: DesktopAgentRuntimeEnv } = {}
+) {
+  const env = deps.env ?? process.env;
+  if (env.NOLO_DESKTOP !== "1") {
+    return new Response(JSON.stringify({ error: "Desktop runtime only" }), {
+      status: 404,
+      headers: JSON_HEADERS,
+    });
+  }
+
+  return new Response(JSON.stringify(buildDesktopAgentRuntimeStatus({ env })), {
+    status: 200,
+    headers: JSON_HEADERS,
+  });
+}

package/server/handlers/desktopAgentRuntimeTurnHandler.ts

@@ -0,0 +1,165 @@
+import type { AgentRuntimeMessageContent } from "../../agent-runtime";
+import { parseToken } from "../../auth/token";
+import { WEB_AUTH_TOKEN_COOKIE } from "../../auth/tokenCookie";
+import {
+  createDesktopAgentRuntimeHybridRecordStoreFromDb,
+  runDesktopAgentRuntimeTurn,
+  type DesktopTextOnlyAgentRuntimeTurnInput,
+} from "./desktopAgentRuntimeTurnService";
+import type { DesktopAgentRuntimeRecordStore } from "./desktopAgentRuntimeAdapter";
+import type { DesktopAgentRuntimeEnv } from "./desktopAgentRuntimeHostFacts";
+
+type DesktopAgentRuntimeTurnBody = {
+  agentRef: string;
+  input: AgentRuntimeMessageContent;
+  continueDialogId?: string;
+  maxToolRounds?: number;
+  cwd?: string;
+};
+
+type DesktopAgentRuntimeTurnHandlerDeps = {
+  env?: DesktopAgentRuntimeEnv;
+  store?: DesktopAgentRuntimeRecordStore;
+  fetchImpl?: typeof fetch;
+  runTurn?: (input: DesktopTextOnlyAgentRuntimeTurnInput) => Promise<unknown>;
+};
+
+const JSON_HEADERS = {
+  "Content-Type": "application/json; charset=utf-8",
+};
+
+function jsonDesktopAgentRuntimeTurnResponse(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: JSON_HEADERS,
+  });
+}
+
+async function readDesktopAgentRuntimeTurnJson(req: Request) {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+}
+
+function normalizeDesktopAgentRuntimeTurnError(error: unknown) {
+  return error instanceof Error
+    ? error.message
+    : "Failed to run desktop agent runtime turn";
+}
+
+function extractDesktopRequestAuthToken(req: Request) {
+  const authHeaderToken = req.headers.get("authorization")?.split(" ")[1]?.trim();
+  if (authHeaderToken) return authHeaderToken;
+
+  const cookieHeader = req.headers.get("cookie") ?? req.headers.get("Cookie") ?? "";
+  const cookieToken = cookieHeader
+    .split(";")
+    .map((part) => part.trim())
+    .find((part) => part.startsWith(`${WEB_AUTH_TOKEN_COOKIE}=`))
+    ?.slice(`${WEB_AUTH_TOKEN_COOKIE}=`.length);
+  return cookieToken ? decodeURIComponent(cookieToken) : "";
+}
+
+function resolveDesktopTurnRequestEnv(req: Request, env: DesktopAgentRuntimeEnv): DesktopAgentRuntimeEnv {
+  const authToken = extractDesktopRequestAuthToken(req);
+  if (!authToken) return env;
+
+  const parsed = parseToken(authToken);
+  const parsedUserId = typeof parsed?.userId === "string" && parsed.userId.trim()
+    ? parsed.userId.trim()
+    : undefined;
+  return {
+    ...env,
+    AUTH_TOKEN: env.AUTH_TOKEN || authToken,
+    AUTH: env.AUTH || authToken,
+    ...(parsedUserId && !env.NOLO_USER_ID ? { NOLO_USER_ID: parsedUserId } : {}),
+  };
+}
+
+function isAgentRuntimeMessageContent(value: unknown): value is AgentRuntimeMessageContent {
+  return typeof value === "string" || Array.isArray(value);
+}
+
+function parseDesktopAgentRuntimeTurnBody(body: unknown): DesktopAgentRuntimeTurnBody | null {
+  if (!body || typeof body !== "object") return null;
+  const record = body as Record<string, unknown>;
+  if (typeof record.agentRef !== "string" || !record.agentRef.trim()) return null;
+  if (!isAgentRuntimeMessageContent(record.input)) return null;
+  return {
+    agentRef: record.agentRef.trim(),
+    input: record.input,
+    ...(typeof record.continueDialogId === "string" && record.continueDialogId.trim()
+      ? { continueDialogId: record.continueDialogId.trim() }
+      : {}),
+    ...(typeof record.maxToolRounds === "number" && Number.isFinite(record.maxToolRounds)
+      ? { maxToolRounds: Math.max(0, Math.floor(record.maxToolRounds)) }
+      : {}),
+    ...(typeof record.cwd === "string" && record.cwd.trim()
+      ? { cwd: record.cwd.trim() }
+      : {}),
+  };
+}
+
+async function resolveDesktopAgentRuntimeTurnStore(
+  args: {
+    injectedStore?: DesktopAgentRuntimeRecordStore;
+    env: DesktopAgentRuntimeEnv;
+    fetchImpl?: typeof fetch;
+  }
+) {
+  if (args.injectedStore) return args.injectedStore;
+  const dbModule = await import("../../database/server/db");
+  await dbModule.ensureServerDbOpen();
+  return createDesktopAgentRuntimeHybridRecordStoreFromDb({
+    db: dbModule.default,
+    env: args.env,
+    fetchImpl: args.fetchImpl,
+  });
+}
+
+export async function handleDesktopAgentRuntimeTurnPost(
+  req: Request,
+  deps: DesktopAgentRuntimeTurnHandlerDeps = {}
+) {
+  const baseEnv = deps.env ?? process.env;
+  const env = resolveDesktopTurnRequestEnv(req, baseEnv);
+  if (env.NOLO_DESKTOP !== "1") {
+    return jsonDesktopAgentRuntimeTurnResponse({ error: "Desktop runtime only" }, 404);
+  }
+
+  const body = parseDesktopAgentRuntimeTurnBody(await readDesktopAgentRuntimeTurnJson(req));
+  if (!body) {
+    return jsonDesktopAgentRuntimeTurnResponse({ error: "agentRef and input are required" }, 400);
+  }
+
+  const store = await resolveDesktopAgentRuntimeTurnStore({
+    injectedStore: deps.store,
+    env,
+    fetchImpl: deps.fetchImpl,
+  });
+  const runTurn = deps.runTurn ?? runDesktopAgentRuntimeTurn;
+  try {
+    const result = await runTurn({
+      env,
+      store,
+      agentRef: body.agentRef,
+      input: body.input,
+      continueDialogId: body.continueDialogId,
+      maxToolRounds: body.maxToolRounds,
+      cwd: body.cwd,
+      fetchImpl: deps.fetchImpl,
+    });
+
+    return jsonDesktopAgentRuntimeTurnResponse({
+      ok: true,
+      result,
+    });
+  } catch (error) {
+    return jsonDesktopAgentRuntimeTurnResponse(
+      { error: normalizeDesktopAgentRuntimeTurnError(error) },
+      500
+    );
+  }
+}