nolo-cli 0.1.30 → 0.1.32

package/server/handlers/desktopFiles/operations.ts

@@ -1,202 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { mkdir, readdir } from "node:fs/promises";
-import path from "node:path";
-
-import type { AllowedRoot } from "./sandbox";
-import { resolveSandboxPath } from "./sandbox";
-import type {
-  DesktopFilesStore,
-  FileHistoryBatch,
-  FileOperation,
-  FileOperationPlan,
-  FileOperationResult,
-} from "./store";
-
-export type SandboxFileEntry = {
-  name: string;
-  relativePath: string;
-  kind: "file" | "directory";
-};
-
-export type UndoResult = {
-  ok: boolean;
-  errorCode?: string;
-};
-
-export async function listSandboxFiles(
-  root: AllowedRoot,
-  relativePath: string,
-): Promise<SandboxFileEntry[]> {
-  const resolved = resolveSandboxPath(root, relativePath);
-  const entries = await readdir(resolved.absolutePath, { withFileTypes: true });
-
-  return entries
-    .filter((entry) => entry.isDirectory() || entry.isFile())
-    .map((entry) => {
-      const entryRelativePath = normalizeRelativePath(path.join(resolved.relativePath, entry.name));
-      return {
-        name: entry.name,
-        relativePath: entryRelativePath,
-        kind: entry.isDirectory() ? "directory" : "file",
-      };
-    })
-    .sort((a, b) => {
-      if (a.kind !== b.kind) return a.kind === "directory" ? -1 : 1;
-      return a.name.localeCompare(b.name);
-    });
-}
-
-export async function readSandboxTextFile(
-  root: AllowedRoot,
-  relativePath: string,
-): Promise<string> {
-  const resolved = resolveSandboxPath(root, relativePath);
-  const stat = statSync(resolved.absolutePath);
-  if (!stat.isFile()) throw new Error("not_a_file");
-  return readFileSync(resolved.absolutePath, "utf8");
-}
-
-export async function executeApprovedPlan(
-  store: DesktopFilesStore,
-  planId: string,
-): Promise<FileHistoryBatch> {
-  const plan = await store.getPlan(planId);
-  if (!plan) throw new Error("plan_not_found");
-  if (!plan.approved) throw new Error("plan_not_approved");
-
-  const root = await store.getRoot(plan.rootId);
-  if (!root) throw new Error("root_not_found");
-
-  const operations: FileOperationResult[] = [];
-  for (const operation of plan.operations) {
-    operations.push(executeOperation(root, operation));
-  }
-
-  const batch: FileHistoryBatch = {
-    batchId: createId("batch"),
-    planId: plan.planId,
-    rootId: plan.rootId,
-    createdAt: new Date().toISOString(),
-    operations,
-    undoable: operations.some((operation) => operation.ok),
-  };
-
-  await store.appendHistory(batch);
-  return batch;
-}
-
-export async function undoHistoryBatch(
-  store: DesktopFilesStore,
-  batchId: string,
-): Promise<UndoResult> {
-  const history = await store.listHistory();
-  const batch = history.find((candidate) => candidate.batchId === batchId);
-  if (!batch) return { ok: false, errorCode: "batch_not_found" };
-
-  const root = await store.getRoot(batch.rootId);
-  if (!root) return { ok: false, errorCode: "root_not_found" };
-
-  for (const operation of [...batch.operations].reverse()) {
-    if (!operation.ok) continue;
-    if ((operation.kind === "move" || operation.kind === "rename") && operation.sourceRelativePath && operation.destinationRelativePath) {
-      const source = resolveSandboxPath(root, operation.destinationRelativePath);
-      const destination = resolveSandboxPath(root, operation.sourceRelativePath);
-      if (existsSync(source.absolutePath) && !existsSync(destination.absolutePath)) {
-        mkdirSync(path.dirname(destination.absolutePath), { recursive: true });
-        renameSync(source.absolutePath, destination.absolutePath);
-      }
-    }
-  }
-
-  return { ok: true };
-}
-
-function executeOperation(root: AllowedRoot, operation: FileOperation): FileOperationResult {
-  try {
-    switch (operation.kind) {
-      case "mkdir": {
-        const destination = resolveRequiredDestination(root, operation);
-        if (existsSync(destination.absolutePath) && operation.conflictPolicy === "skip") {
-          return okResult(operation);
-        }
-        mkdirSync(destination.absolutePath, { recursive: true });
-        return okResult(operation);
-      }
-      case "writeText": {
-        const destination = resolveRequiredDestination(root, operation);
-        if (existsSync(destination.absolutePath) && operation.conflictPolicy === "skip") {
-          return okResult(operation);
-        }
-        mkdirSync(path.dirname(destination.absolutePath), { recursive: true });
-        writeFileSync(destination.absolutePath, operation.content ?? "", "utf8");
-        return okResult(operation);
-      }
-      case "move":
-      case "rename": {
-        const source = resolveRequiredSource(root, operation);
-        const destination = resolveRequiredDestination(root, operation);
-        if (existsSync(destination.absolutePath) && operation.conflictPolicy === "skip") {
-          return okResult(operation);
-        }
-        mkdirSync(path.dirname(destination.absolutePath), { recursive: true });
-        renameSync(source.absolutePath, destination.absolutePath);
-        return okResult(operation);
-      }
-      case "deleteToTrash": {
-        const source = resolveRequiredSource(root, operation);
-        rmSync(source.absolutePath, { recursive: true, force: true });
-        return okResult(operation);
-      }
-      default:
-        return { ...operationResult(operation), ok: false, errorCode: "unsupported_operation" };
-    }
-  } catch (error) {
-    return {
-      ...operationResult(operation),
-      ok: false,
-      errorCode: error instanceof Error ? error.message : "operation_failed",
-    };
-  }
-}
-
-function resolveRequiredSource(root: AllowedRoot, operation: FileOperation) {
-  if (!operation.sourceRelativePath) throw new Error("missing_source");
-  return resolveSandboxPath(root, operation.sourceRelativePath);
-}
-
-function resolveRequiredDestination(root: AllowedRoot, operation: FileOperation) {
-  if (!operation.destinationRelativePath) throw new Error("missing_destination");
-  return resolveSandboxPath(root, operation.destinationRelativePath);
-}
-
-function okResult(operation: FileOperation): FileOperationResult {
-  return {
-    ...operationResult(operation),
-    ok: true,
-  };
-}
-
-function operationResult(operation: FileOperation): Omit<FileOperationResult, "ok"> {
-  return {
-    kind: operation.kind,
-    sourceRelativePath: operation.sourceRelativePath,
-    destinationRelativePath: operation.destinationRelativePath,
-  };
-}
-
-function normalizeRelativePath(relativePath: string): string {
-  const normalized = relativePath.replaceAll(path.sep, "/");
-  return normalized === "." ? "" : normalized;
-}
-
-function createId(prefix: string): string {
-  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}

package/server/handlers/desktopFiles/sandbox.ts

@@ -1,62 +0,0 @@
-import path from "node:path";
-
-export type AllowedRoot = {
-  id: string;
-  label: string;
-  path: string;
-};
-
-export type ResolvedSandboxPath = {
-  rootId: string;
-  rootPath: string;
-  relativePath: string;
-  absolutePath: string;
-};
-
-const normalizeRootPath = (value: string) => path.resolve(value);
-
-export function createAllowedRoot(input: AllowedRoot): AllowedRoot {
-  const id = input.id.trim();
-  const label = input.label.trim() || id;
-  const rootPath = normalizeRootPath(input.path);
-  if (!id) throw new Error("root_id_required");
-  if (!rootPath) throw new Error("root_path_required");
-  return { id, label, path: rootPath };
-}
-
-export function validateRelativePath(relativePath: string): string {
-  if (typeof relativePath !== "string" || !relativePath.trim()) {
-    throw new Error("relative_path_required");
-  }
-  if (path.isAbsolute(relativePath)) {
-    throw new Error("absolute_paths_not_allowed");
-  }
-  const normalized = path.normalize(relativePath.trim());
-  if (normalized === ".." || normalized.startsWith(`..${path.sep}`)) {
-    throw new Error("path_outside_authorized_root");
-  }
-  return normalized;
-}
-
-export function resolveSandboxPath(
-  root: AllowedRoot,
-  relativePath: string
-): ResolvedSandboxPath {
-  const normalizedRoot = normalizeRootPath(root.path);
-  const normalizedRelative = validateRelativePath(relativePath);
-  const absolutePath = path.resolve(normalizedRoot, normalizedRelative);
-  const relativeFromRoot = path.relative(normalizedRoot, absolutePath);
-  if (
-    relativeFromRoot === ".." ||
-    relativeFromRoot.startsWith(`..${path.sep}`) ||
-    path.isAbsolute(relativeFromRoot)
-  ) {
-    throw new Error("path_outside_authorized_root");
-  }
-  return {
-    rootId: root.id,
-    rootPath: normalizedRoot,
-    relativePath: normalizedRelative,
-    absolutePath,
-  };
-}

package/server/handlers/desktopFiles/store.ts

@@ -1,81 +0,0 @@
-import type { AllowedRoot } from "./sandbox";
-
-export type FileOperationKind = "mkdir" | "move" | "rename" | "writeText" | "deleteToTrash";
-
-export type FileOperation = {
-  kind: FileOperationKind;
-  sourceRelativePath?: string;
-  destinationRelativePath?: string;
-  content?: string;
-  reason: string;
-  conflictPolicy: "skip" | "overwrite" | "rename";
-};
-
-export type FileOperationPlan = {
-  planId: string;
-  rootId: string;
-  summary: string;
-  operations: FileOperation[];
-  riskLevel: "low" | "medium" | "high";
-  requiresConfirmation: true;
-  approved: boolean;
-};
-
-export type FileOperationResult = {
-  kind: FileOperationKind;
-  sourceRelativePath?: string;
-  destinationRelativePath?: string;
-  ok: boolean;
-  errorCode?: string;
-};
-
-export type FileHistoryBatch = {
-  batchId: string;
-  planId: string;
-  rootId: string;
-  createdAt: string;
-  operations: FileOperationResult[];
-  undoable: boolean;
-};
-
-export type DesktopFilesStore = ReturnType<typeof createDesktopFilesStore>;
-
-export function createDesktopFilesStore() {
-  const roots = new Map<string, AllowedRoot>();
-  const plans = new Map<string, FileOperationPlan>();
-  const history: FileHistoryBatch[] = [];
-
-  return {
-    async saveRoot(root: AllowedRoot) {
-      roots.set(root.id, root);
-      return root;
-    },
-    async listRoots() {
-      return [...roots.values()];
-    },
-    async getRoot(rootId: string) {
-      return roots.get(rootId) ?? null;
-    },
-    async savePlan(plan: FileOperationPlan) {
-      plans.set(plan.planId, plan);
-      return plan;
-    },
-    async getPlan(planId: string) {
-      return plans.get(planId) ?? null;
-    },
-    async approvePlan(planId: string) {
-      const plan = plans.get(planId);
-      if (!plan) throw new Error("plan_not_found");
-      plans.set(planId, { ...plan, approved: true });
-    },
-    async appendHistory(batch: FileHistoryBatch) {
-      history.unshift(batch);
-      return batch;
-    },
-    async listHistory() {
-      return [...history];
-    },
-  };
-}
-
-export const desktopFilesStore = createDesktopFilesStore();

package/server/handlers/desktopLlamaRuntimeHandler.ts

@@ -1,360 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-
-import { isPidRunning } from "../../../scripts/helpers/devProcessGuard";
-import {
-  parseLocalLlamaConfigFile,
-  probeLlamaHealth,
-  resolveLlamaLaunchConfig,
-  resolveLlamaSupervisorPaths,
-  startManagedLlamaServer,
-  stopManagedLlamaServer,
-  type LlamaLaunchConfig,
-  type StoredLlamaLaunchState,
-} from "../../../scripts/helpers/llamaServerSupervisor";
-import {
-  createLlamaRuntimeController,
-  type DesktopLlamaRuntimeSnapshot,
-} from "../../../scripts/runtime/llamaRuntimeController";
-import { startLlamaRuntime, waitForHealthy } from "../../../scripts/runtime/llamaRuntimeStartup";
-
-const JSON_HEADERS = {
-  "content-type": "application/json; charset=utf-8",
-};
-
-type DesktopLlamaRuntimeResponse = Omit<DesktopLlamaRuntimeSnapshot, "state"> & {
-  state: DesktopLlamaRuntimeSnapshot["state"] | "starting";
-  accepted?: boolean;
-};
-
-type DesktopLlamaRuntimeHandlerController = {
-  status: () => Promise<DesktopLlamaRuntimeSnapshot>;
-  stop: () => Promise<{ managedPid: number | null }>;
-  start: () => Promise<{
-    status: DesktopLlamaRuntimeSnapshot;
-    startupTask: Promise<void> | null;
-  }>;
-};
-
-type DesktopLlamaRuntimeHandlerDeps = {
-  isDesktopMode?: () => boolean;
-  controller?: DesktopLlamaRuntimeHandlerController;
-  logger?: Pick<Console, "error">;
-  repoRoot?: string;
-};
-
-const json = (data: unknown, status = 200) =>
-  new Response(JSON.stringify(data), {
-    status,
-    headers: JSON_HEADERS,
-  });
-
-const defaultIsDesktopMode = () => process.env.NOLO_DESKTOP === "1";
-
-const notDesktopResponse = () =>
-  json({ error: "Desktop llama runtime is only available inside Nolo Desktop." }, 404);
-
-function resolveLocalOpenAiBaseUrl(config: Pick<LlamaLaunchConfig, "host" | "port">) {
-  return `http://${config.host}:${config.port}/v1`;
-}
-
-export function configureDesktopLocalProviderEnv(config: Pick<LlamaLaunchConfig, "host" | "port">) {
-  process.env.NOLO_LOCAL_OPENAI_BASE_URL ||= resolveLocalOpenAiBaseUrl(config);
-  process.env.NOLO_LOCAL_LLM ||= "direct";
-}
-
-function formatError(error: unknown, fallback: string): string {
-  return error instanceof Error ? error.message : fallback;
-}
-
-function createDesktopLlamaRuntimeController(
-  repoRoot = process.cwd(),
-): DesktopLlamaRuntimeHandlerController {
-  const paths = resolveLlamaSupervisorPaths(repoRoot);
-
-  const ensureLogDir = async () => {
-    await mkdir(paths.logDir, { recursive: true });
-  };
-
-  const readStoredState = async (): Promise<StoredLlamaLaunchState | null> => {
-    try {
-      const raw = await Bun.file(paths.stateFile).text();
-      const parsed = JSON.parse(raw) as StoredLlamaLaunchState;
-      return parsed && typeof parsed === "object" ? parsed : null;
-    } catch {
-      return null;
-    }
-  };
-
-  const readLocalConfigFile = async (): Promise<Partial<LlamaLaunchConfig> | null> => {
-    try {
-      return parseLocalLlamaConfigFile(await Bun.file(paths.localConfigFile).text());
-    } catch (error) {
-      if (existsSync(paths.localConfigFile)) {
-        throw new Error(
-          `Failed to parse local llama config at ${paths.localConfigFile}: ${formatError(
-            error,
-            "Unknown parse error",
-          )}`,
-        );
-      }
-      return null;
-    }
-  };
-
-  const writeStoredState = async (config: LlamaLaunchConfig): Promise<void> => {
-    await ensureLogDir();
-    const payload: StoredLlamaLaunchState = {
-      launchConfig: config,
-      updatedAt: new Date().toISOString(),
-    };
-    await writeFile(paths.stateFile, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-  };
-
-  const readManagedPid = (): number | null => {
-    try {
-      const raw = readFileSync(paths.pidFile, "utf8").trim();
-      const pid = Number(raw);
-      return Number.isInteger(pid) && pid > 0 ? pid : null;
-    } catch {
-      return null;
-    }
-  };
-
-  const removeManagedPidFile = async (): Promise<void> => {
-    await rm(paths.pidFile, { force: true }).catch(() => undefined);
-  };
-
-  const readWatchPid = (): number | null => {
-    try {
-      const raw = readFileSync(paths.watchPidFile, "utf8").trim();
-      const pid = Number(raw);
-      return Number.isInteger(pid) && pid > 0 ? pid : null;
-    } catch {
-      return null;
-    }
-  };
-
-  const readLogTail = async (maxLines: number): Promise<string[]> => {
-    try {
-      const raw = await Bun.file(paths.logFile).text();
-      return raw
-        .split(/\r?\n/)
-        .map((line) => line.trimEnd())
-        .filter((line) => line.length > 0)
-        .slice(-maxLines);
-    } catch {
-      return [];
-    }
-  };
-
-  const resolveLaunchConfigOrThrow = async (): Promise<LlamaLaunchConfig> => {
-    const storedState = await readStoredState();
-    const localConfig = await readLocalConfigFile();
-    const config = resolveLlamaLaunchConfig({
-      storedConfig: {
-        ...(storedState?.launchConfig ?? {}),
-        ...(localConfig ?? {}),
-      },
-    });
-
-    if (!config) {
-      throw new Error(
-        `Missing llama launch config. Populate ${paths.localConfigFile} or configure the desktop runtime first.`,
-      );
-    }
-
-    configureDesktopLocalProviderEnv(config);
-    return config;
-  };
-
-  const probeHealth = (
-    config: Pick<LlamaLaunchConfig, "host" | "port" | "healthPath" | "modelsPath">,
-  ) => probeLlamaHealth(config);
-
-  const stopManagedServer = () =>
-    stopManagedLlamaServer({
-      readManagedPid,
-      isPidRunning,
-      removeManagedPidFile,
-    });
-
-  const startManagedServer = (config: LlamaLaunchConfig) =>
-    startManagedLlamaServer(config, {
-      ensureLogDir,
-      readManagedPid,
-      isPidRunning,
-      removeManagedPidFile,
-      writePidFile: (pid) => writeFile(paths.pidFile, `${pid}\n`, "utf8"),
-      logFilePath: paths.logFile,
-    });
-
-  const runtimeController = createLlamaRuntimeController({
-    readStoredState,
-    readLocalConfigFile,
-    readManagedPid,
-    readWatchPid,
-    isPidRunning,
-    stopPid: stopManagedServer,
-    probeHealth,
-    readLogTail: () => readLogTail(40),
-  });
-
-  return {
-    status: () => runtimeController.status(),
-    stop: () => runtimeController.stop(),
-    start: () =>
-      startLlamaRuntime({
-        resolveLaunchConfigOrThrow,
-        writeStoredState,
-        probeHealth,
-        readManagedPid,
-        isPidRunning,
-        stopManagedServer,
-        startManagedServer,
-        readStatus: () => runtimeController.status(),
-        waitForHealthy: (config) =>
-          waitForHealthy(config, {
-            probeHealth,
-            readManagedPid,
-            isPidRunning,
-            sleep: Bun.sleep,
-            logFilePath: paths.logFile,
-          }),
-      }),
-  };
-}
-
-function buildResponseSnapshot(
-  snapshot: DesktopLlamaRuntimeSnapshot,
-  activeStartTask: Promise<void> | null,
-  lastStartError: string | null,
-): DesktopLlamaRuntimeResponse {
-  if (snapshot.state !== "running" && activeStartTask) {
-    const { error: _error, ...startingSnapshot } = snapshot;
-    return {
-      ...startingSnapshot,
-      state: "starting",
-    };
-  }
-
-  if (snapshot.state !== "running" && lastStartError) {
-    return {
-      ...snapshot,
-      state: "error",
-      error: lastStartError,
-    };
-  }
-
-  return snapshot;
-}
-
-export function createDesktopLlamaRuntimeHandlers(
-  deps: DesktopLlamaRuntimeHandlerDeps = {},
-) {
-  const isDesktopMode = deps.isDesktopMode ?? defaultIsDesktopMode;
-  const runtimeController =
-    deps.controller ?? createDesktopLlamaRuntimeController(deps.repoRoot);
-  const logger = deps.logger ?? console;
-
-  let activeStartTask: Promise<void> | null = null;
-  let activeStartToken = 0;
-  let lastStartError: string | null = null;
-
-  const clearStartState = () => {
-    activeStartToken += 1;
-    activeStartTask = null;
-    lastStartError = null;
-  };
-
-  const readSnapshot = async () =>
-    buildResponseSnapshot(await runtimeController.status(), activeStartTask, lastStartError);
-
-  const trackStartTask = (task: Promise<void>) => {
-    const taskToken = ++activeStartToken;
-    lastStartError = null;
-    activeStartTask = task
-      .catch((error) => {
-        if (activeStartToken === taskToken) {
-          lastStartError = formatError(error, "Failed to start llama runtime");
-        }
-        logger.error("[desktop-provider-runtime] start failed", error);
-      })
-      .finally(() => {
-        if (activeStartToken === taskToken) {
-          activeStartTask = null;
-        }
-      });
-  };
-
-  const handleGet = async () => {
-    if (!isDesktopMode()) {
-      return notDesktopResponse();
-    }
-
-    try {
-      return json(await readSnapshot());
-    } catch (error) {
-      return json(
-        {
-          error: formatError(error, "Failed to read llama runtime state"),
-        },
-        500,
-      );
-    }
-  };
-
-  const handlePost = async (req: Request) => {
-    if (!isDesktopMode()) {
-      return notDesktopResponse();
-    }
-
-    const body = await req.json().catch(() => ({} as { action?: string }));
-
-    try {
-      if (body.action === "start") {
-        if (activeStartTask) {
-          return json({ ...(await readSnapshot()), accepted: true }, 202);
-        }
-
-        const result = await runtimeController.start();
-        if (result.startupTask) {
-          trackStartTask(result.startupTask);
-          return json(
-            {
-              ...buildResponseSnapshot(result.status, activeStartTask, lastStartError),
-              accepted: true,
-            },
-            202,
-          );
-        }
-
-        return json(buildResponseSnapshot(result.status, activeStartTask, lastStartError));
-      }
-
-      if (body.action === "stop") {
-        clearStartState();
-        return json(await runtimeController.stop());
-      }
-    } catch (error) {
-      return json(
-        {
-          error: formatError(error, "Failed to update llama runtime state"),
-        },
-        500,
-      );
-    }
-
-    return json({ error: "Unsupported action" }, 400);
-  };
-
-  return {
-    handleGet,
-    handlePost,
-  };
-}
-
-const defaultHandlers = createDesktopLlamaRuntimeHandlers();
-
-export const handleDesktopLlamaRuntimeGet = defaultHandlers.handleGet;
-export const handleDesktopLlamaRuntimePost = defaultHandlers.handlePost;