nolo-cli 0.1.26 → 0.1.30

package/server/handlers/desktopFiles/operations.ts

@@ -0,0 +1,202 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,360 @@
+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;