nolo-cli 0.1.23 → 0.1.29

package/chat/web/sidebar/useChatSidebarFilteredData.ts

@@ -0,0 +1,141 @@
+import { useMemo } from "react";
+
+import { UNCATEGORIZED_ID } from "../../../create/space/constants";
+import {
+  matchesSidebarVisibleTypes,
+  type SidebarVisibleType,
+} from "../../../create/space/sidebarVisibleTypes";
+import type { SpaceContent } from "../../../app/types";
+
+import type { ChatSidebarCategoryItem, ChatSidebarGroupedData } from "./types";
+
+interface UseChatSidebarFilteredDataParams {
+  groupedData: ChatSidebarGroupedData;
+  sortedCategories: ChatSidebarCategoryItem[];
+  visibleTypes: SidebarVisibleType[];
+  isShowingAllTypes: boolean;
+  displayCount: number;
+  isFullyLoaded: boolean;
+  searchQuery: string;
+}
+
+export function buildFilteredSidebarGroupedData({
+  groupedData,
+  sortedCategories,
+  visibleTypes,
+  isShowingAllTypes,
+  displayCount,
+  isFullyLoaded,
+  searchQuery,
+}: UseChatSidebarFilteredDataParams): ChatSidebarGroupedData {
+  let uncategorizedItems = groupedData.uncategorized;
+  let categorizedItemsMap = groupedData.categorized;
+
+  if (!isShowingAllTypes || searchQuery) {
+    const filterFn = (item: SpaceContent) => {
+      if (!matchesSidebarVisibleTypes(item, visibleTypes)) return false;
+
+      if (!searchQuery) return true;
+      const query = searchQuery.toLowerCase();
+      return (
+        (item.title || "").toLowerCase().includes(query) ||
+        ((item as any).name || "").toLowerCase().includes(query) ||
+        ((item as any).description || "").toLowerCase().includes(query)
+      );
+    };
+
+    uncategorizedItems = uncategorizedItems.filter(filterFn);
+    categorizedItemsMap = Object.fromEntries(
+      Object.entries(categorizedItemsMap).map(([categoryId, items]) => [
+        categoryId,
+        items.filter(filterFn),
+      ])
+    );
+  }
+
+  if (isFullyLoaded) {
+    return {
+      uncategorized: uncategorizedItems,
+      categorized: categorizedItemsMap,
+    };
+  }
+
+  let remainingCount = displayCount;
+  const slicedUncategorized = uncategorizedItems.slice(0, remainingCount);
+  remainingCount = Math.max(0, remainingCount - uncategorizedItems.length);
+
+  const slicedCategorized: Record<string, SpaceContent[]> = {};
+  for (const category of sortedCategories) {
+    const items = categorizedItemsMap[category.id] || [];
+    if (remainingCount > 0) {
+      slicedCategorized[category.id] = items.slice(0, remainingCount);
+      remainingCount = Math.max(0, remainingCount - items.length);
+    } else {
+      slicedCategorized[category.id] = [];
+    }
+  }
+
+  return {
+    uncategorized: slicedUncategorized,
+    categorized: slicedCategorized,
+  };
+}
+
+export const useChatSidebarFilteredData = ({
+  groupedData,
+  sortedCategories,
+  visibleTypes,
+  isShowingAllTypes,
+  displayCount,
+  isFullyLoaded,
+  searchQuery,
+}: UseChatSidebarFilteredDataParams) => {
+  const filteredGroupedData = useMemo(() => buildFilteredSidebarGroupedData({
+    groupedData,
+    sortedCategories,
+    visibleTypes,
+    isShowingAllTypes,
+    displayCount,
+    isFullyLoaded,
+    searchQuery,
+  }), [
+    displayCount,
+    groupedData.categorized,
+    groupedData.uncategorized,
+    isFullyLoaded,
+    isShowingAllTypes,
+    searchQuery,
+    sortedCategories,
+    visibleTypes,
+  ]);
+
+  const allVisibleCategoryIds = useMemo(() => {
+    const ids: string[] = [];
+    if (filteredGroupedData.uncategorized.length > 0) {
+      ids.push(UNCATEGORIZED_ID);
+    }
+    sortedCategories.forEach((category) => {
+      if ((filteredGroupedData.categorized[category.id]?.length || 0) > 0) {
+        ids.push(category.id);
+      }
+    });
+    return ids;
+  }, [filteredGroupedData, sortedCategories]);
+
+  const isEmpty = useMemo(() => {
+    const allContentCount =
+      filteredGroupedData.uncategorized.length +
+      Object.values(filteredGroupedData.categorized).reduce(
+        (count, items) => count + items.length,
+        0
+      );
+
+    return allContentCount === 0 && (isShowingAllTypes ? sortedCategories.length === 0 : true);
+  }, [filteredGroupedData, isShowingAllTypes, sortedCategories.length]);
+
+  return {
+    filteredGroupedData,
+    allVisibleCategoryIds,
+    isEmpty,
+  };
+};

package/chat/web/sidebar/useSidebarDragAndDrop.ts

@@ -0,0 +1,56 @@
+import { useCallback } from "react";
+
+import type { AppDispatch } from "../../../app/store";
+import {
+  reorderCategories,
+  updateContentCategory,
+} from "../../../create/space/spaceSlice";
+
+import type { ChatSidebarCategoryItem } from "./types";
+
+export const useCategoryDragAndDrop = (
+  sortedCategories: ChatSidebarCategoryItem[],
+  spaceId: string | undefined,
+  dispatch: AppDispatch
+) =>
+  useCallback(
+    (activeId: string, overId: string) => {
+      if (!spaceId || activeId === overId) return;
+
+      const oldIndex = sortedCategories.findIndex((category) => category.id === activeId);
+      const newIndex = sortedCategories.findIndex((category) => category.id === overId);
+
+      if (oldIndex === -1 || newIndex === -1) return;
+
+      const reordered = [...sortedCategories];
+      const [movedItem] = reordered.splice(oldIndex, 1);
+      reordered.splice(newIndex, 0, movedItem);
+
+      (dispatch as any)(
+        reorderCategories({
+          spaceId,
+          sortedCategoryIds: reordered.map((category) => category.id),
+        })
+      );
+    },
+    [dispatch, sortedCategories, spaceId]
+  );
+
+export const useItemDragAndDrop = (
+  spaceId: string | undefined,
+  dispatch: AppDispatch
+) =>
+  useCallback(
+    (itemId: string, sourceContainer: string, targetContainer: string) => {
+      if (!spaceId || sourceContainer === targetContainer) return;
+
+      (dispatch as any)(
+        updateContentCategory({
+          spaceId,
+          contentKey: itemId,
+          categoryId: targetContainer,
+        })
+      );
+    },
+    [dispatch, spaceId]
+  );

package/cliCommandAdapters.ts

@@ -0,0 +1,28 @@
+import type { CliCommandHandler, CliRuntimeContext } from "./cliCommandTypes";
+
+export function withCliEnv<TDeps extends { env: NodeJS.ProcessEnv }>(
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CliCommandHandler {
+  return (args: string[], ctx: CliRuntimeContext) =>
+    command(args, { env: ctx.env } as TDeps);
+}
+
+export function withCliEnvAndScriptDir<TDeps extends { env: NodeJS.ProcessEnv; scriptDir: string }>(
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CliCommandHandler {
+  return (args: string[], ctx: CliRuntimeContext) =>
+    command(args, {
+      env: ctx.env,
+      scriptDir: ctx.scriptDir,
+    } as TDeps);
+}
+
+export function withCliEntrypointEnv<TDeps extends { env: NodeJS.ProcessEnv; cliEntrypointPath: string }>(
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CliCommandHandler {
+  return (args: string[], ctx: CliRuntimeContext) =>
+    command(args, {
+      env: ctx.env,
+      cliEntrypointPath: ctx.entrypointPath,
+    } as TDeps);
+}

package/cliCommandDispatch.ts

@@ -0,0 +1,66 @@
+import { fileURLToPath } from "node:url";
+import type { CliPackageInfo, CliRuntimeContext, CommandEntry } from "./cliCommandTypes";
+
+export async function runResolvedCommand(
+  command: CommandEntry,
+  originalArgs: string[],
+  ctx: CliRuntimeContext,
+  deps: {
+    runScript: (script: string, forwardedArgs: string[], env: NodeJS.ProcessEnv) => Promise<number>;
+  }
+) {
+  if (command.kind === "internal") {
+    if (!command.handler) {
+      throw new Error(`Internal command ${command.path.join(" ")} is missing a handler.`);
+    }
+    return command.handler(originalArgs.slice(command.path.length), ctx);
+  }
+
+  if (!command.script) {
+    throw new Error(`Script command ${command.path.join(" ")} is missing a script.`);
+  }
+
+  const forwardedArgs = [...(command.fixedArgs ?? []), ...originalArgs.slice(command.path.length)];
+  return deps.runScript(command.script, forwardedArgs, ctx.env);
+}
+
+function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
+  const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
+  const apiKey = readOption(args, "--api-key") || readOption(args, "--token");
+  return {
+    ...runtimeEnv,
+    ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
+    ...(apiKey ? { AUTH_TOKEN: apiKey } : {}),
+  };
+}
+
+export function looksLikeDaemonShortcut(args: string[]) {
+  return args.includes("--server-url") || args.includes("--api-key");
+}
+
+export function createCliRuntimeContext(args: {
+  env: NodeJS.ProcessEnv;
+  scriptDir: string;
+  entrypointPath?: string;
+  packageInfo: CliPackageInfo;
+}): CliRuntimeContext {
+  return {
+    env: args.env,
+    scriptDir: args.scriptDir,
+    entrypointPath: args.entrypointPath ?? fileURLToPath(import.meta.url),
+    packageInfo: args.packageInfo,
+  };
+}
+
+export function withDaemonShortcutArgs(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
+  if (!looksLikeDaemonShortcut(args)) return { commandArgs: args, envOverride: null as NodeJS.ProcessEnv | null };
+  return {
+    commandArgs: ["daemon", ...args],
+    envOverride: buildDaemonEnv(args, runtimeEnv),
+  };
+}

package/cliCommandFactories.ts

@@ -0,0 +1,66 @@
+import {
+  withCliEntrypointEnv,
+  withCliEnv,
+  withCliEnvAndScriptDir,
+} from "./cliCommandAdapters";
+import { withDaemonShortcutArgs } from "./cliCommandDispatch";
+import {
+  createInternalCommand,
+  type CliRuntimeContext,
+  type CliCommandHandler,
+  type CommandEntry,
+} from "./cliCommandTypes";
+
+export function createEnvCommand<TDeps extends { env: NodeJS.ProcessEnv }>(
+  path: string[],
+  description: string,
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, withCliEnv(command) as CliCommandHandler);
+}
+
+export function createEnvScriptDirCommand<TDeps extends { env: NodeJS.ProcessEnv; scriptDir: string }>(
+  path: string[],
+  description: string,
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, withCliEnvAndScriptDir(command) as CliCommandHandler);
+}
+
+export function createEntrypointEnvCommand<TDeps extends { env: NodeJS.ProcessEnv; cliEntrypointPath: string }>(
+  path: string[],
+  description: string,
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, withCliEntrypointEnv(command) as CliCommandHandler);
+}
+
+export function createArgsCommand(
+  path: string[],
+  description: string,
+  command: (args: string[]) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, (args) => command(args));
+}
+
+export function createContextCommand(
+  path: string[],
+  description: string,
+  command: (args: string[], ctx: CliRuntimeContext) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, command as CliCommandHandler);
+}
+
+export function createDaemonShortcutCommand<TDeps extends { env: NodeJS.ProcessEnv; cliEntrypointPath: string }>(
+  path: string[],
+  description: string,
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, (args, ctx) => {
+    const normalized = withDaemonShortcutArgs(args, ctx.env);
+    return command(["--ws"], {
+      env: normalized.envOverride ?? ctx.env,
+      cliEntrypointPath: ctx.entrypointPath,
+    } as TDeps);
+  });
+}

package/cliCommandTypes.ts

@@ -0,0 +1,49 @@
+import type { readPackageInfo } from "./updateCommands";
+
+export type CliPackageInfo = ReturnType<typeof readPackageInfo>;
+
+export type CliRuntimeContext = {
+  env: NodeJS.ProcessEnv;
+  scriptDir: string;
+  entrypointPath: string;
+  packageInfo: CliPackageInfo;
+};
+
+export type CliCommandHandler = (args: string[], ctx: CliRuntimeContext) => Promise<number>;
+
+export type CommandEntry = {
+  path: string[];
+  description: string;
+  kind: "internal" | "script";
+  script?: string;
+  fixedArgs?: string[];
+  handler?: CliCommandHandler;
+};
+
+export function createScriptCommand(
+  path: string[],
+  script: string,
+  description: string,
+  fixedArgs?: string[]
+): CommandEntry {
+  return {
+    path,
+    kind: "script",
+    script,
+    description,
+    ...(fixedArgs ? { fixedArgs } : {}),
+  };
+}
+
+export function createInternalCommand(
+  path: string[],
+  description: string,
+  handler: CliCommandHandler
+): CommandEntry {
+  return {
+    path,
+    kind: "internal",
+    description,
+    handler,
+  };
+}

package/cliEnvHelpers.ts

@@ -0,0 +1,130 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import { NOLO_CLUSTER_SERVERS } from "./database/config";
+
+export type EnvLike = Record<string, string | undefined>;
+
+function trimTrailingSlashes(value: string) {
+  return value.trim().replace(/\/+$/, "");
+}
+
+function firstDefinedEnvValue(env: EnvLike, keys: string[]) {
+  for (const key of keys) {
+    const value = env[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return "";
+}
+
+export function hasFlag(args: string[], flag: string) {
+  return args.includes(flag);
+}
+
+export function readCliOptionValue(args: string[], flag: string): string {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === flag) {
+      const next = args[i + 1];
+      if (typeof next === "string" && !next.startsWith("-")) return next;
+      return "";
+    }
+    if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);
+  }
+  return "";
+}
+
+export function resolveServerUrlFromEnv(env: EnvLike) {
+  return trimTrailingSlashes(
+    firstDefinedEnvValue(env, ["NOLO_SERVER_URL", "NOLO_SERVER", "BASE_URL"]) ||
+      DEFAULT_NOLO_SERVER_URL,
+  );
+}
+
+export function resolveServerUrlFromArgs(args: string[], env: EnvLike) {
+  return trimTrailingSlashes(
+    readCliOptionValue(args, "--server-url") ||
+      readCliOptionValue(args, "--server") ||
+      readCliOptionValue(args, "--base-url") ||
+      firstDefinedEnvValue(env, ["NOLO_SERVER_URL", "NOLO_SERVER", "BASE_URL"]) ||
+      DEFAULT_NOLO_SERVER_URL,
+  );
+}
+
+export function resolveServerUrl(env: EnvLike) {
+  return resolveServerUrlFromEnv(env);
+}
+
+export function resolveServerCandidates(env: EnvLike, preferred?: string | null) {
+  const values = [
+    preferred?.trim(),
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+  ];
+  return [...new Set(
+    values
+      .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+      .map((value) => value.replace(/\/+$/, ""))
+  )];
+}
+
+export function resolveAuthToken(env: EnvLike) {
+  return resolveAuthTokenFromEnv(env);
+}
+
+export function resolveAuthTokenFromEnv(env: EnvLike, extraEnvKeys: string[] = []) {
+  return (
+    firstDefinedEnvValue(env, [...extraEnvKeys, "BENCHMARK_AUTH_TOKEN", "AUTH_TOKEN", "AUTH"]) ||
+    ""
+  );
+}
+
+export function resolveAuthTokenFromArgs(
+  args: string[],
+  env: EnvLike,
+  extraEnvKeys: string[] = [],
+) {
+  return (
+    readCliOptionValue(args, "--api-key") ||
+    readCliOptionValue(args, "--token") ||
+    firstDefinedEnvValue(env, [
+      ...extraEnvKeys,
+      "BENCHMARK_AUTH_TOKEN",
+      "NOLO_TASK_RUN_TOKEN",
+      "NOLO_MACHINE_API_KEY",
+      "AUTH_TOKEN",
+      "AUTH",
+    ]) ||
+    ""
+  );
+}
+
+export function decodeJwtPayload(token: string): Record<string, unknown> | null {
+  const trimmed = token.trim();
+  if (!trimmed) return null;
+  const parts = trimmed.split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  for (const payload of payloadCandidates) {
+    try {
+      return JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+export function parseUserIdFromAuthToken(token: string) {
+  const parsed = decodeJwtPayload(token);
+  return typeof parsed?.userId === "string" ? parsed.userId : "";
+}
+
+export function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+export function readOptionValue(args: string[], flag: string) {
+  return readCliOptionValue(args, flag);
+}

package/cliIoTypes.ts

@@ -0,0 +1,3 @@
+export type OutputLike = {
+  write(chunk: string): unknown;
+};