@larkup/cli 0.2.24 → 0.2.26

package/dist/{chunk-L34L3RDQ.js → chunk-JZ3UCEGF.js}

@@ -3,12 +3,12 @@ import { promises as fs2 } from "fs";
 import path2 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 
-// ../../packages/core/src/workspace.ts
-import { promises as fs } from "fs";
-import path from "path";
-import { randomUUID } from "crypto";
+// ../../packages/core/src/project-store.ts
 import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+import { promises as fs } from "fs";
 import net from "net";
+import path from "path";
 
 // ../../packages/core/src/types.ts
 var DEFAULT_CONFIG = {
@@ -47,223 +47,178 @@ var DEFAULT_CONFIG = {
   useScraperProxy: false,
   webCrawlerProvider: "local",
   firecrawlApiKey: "",
+  defaultSandboxProvider: "local",
+  sandboxProviderConfigs: {},
   toolConfigs: {},
+  skills: [],
   updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
 };
 
-// ../../packages/core/src/workspace.ts
-var ROOT = path.join(process.cwd(), ".larkup");
-var SERVERS_DIR = path.join(ROOT, "servers");
-var WORKSPACE_PATH = path.join(ROOT, "workspace.json");
+// ../../packages/core/src/project-store.ts
+var LARKUP_ROOT = path.join(process.cwd(), ".larkup");
+var PROJECTS_DIR = path.join(LARKUP_ROOT, "projects");
 var BASE_PORT = 8080;
-var EMPTY = { username: null, activeServerId: null, servers: [], mode: null };
-var als = new AsyncLocalStorage();
-function runWithServer(serverId, fn) {
-  return als.run({ serverId }, fn);
-}
+var EMPTY_WORKSPACE = { activeProjectId: null, projects: [] };
+var projectScope = new AsyncLocalStorage();
 var writeChain = Promise.resolve();
-function serialize(fn) {
-  const run = writeChain.then(fn, fn);
-  writeChain = run.catch(() => {
-  });
+function serialize(operation) {
+  const run = writeChain.then(operation, operation);
+  writeChain = run.catch(() => void 0);
   return run;
 }
-async function serializeWorkspace(fn) {
-  await getWorkspace();
-  return serialize(async () => fn(await readRaw() ?? EMPTY));
-}
-function serverDir(id) {
-  return path.join(SERVERS_DIR, id);
-}
-function relServerPath(id, sub) {
-  return `./.larkup/servers/${id}/${sub}`;
-}
-async function exists(p) {
-  try {
-    await fs.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function moveIfExists(from, to) {
-  if (!await exists(from)) return;
-  await fs.mkdir(path.dirname(to), { recursive: true });
+async function readWorkspaceFile() {
   try {
-    await fs.rename(from, to);
-  } catch {
-    await fs.cp(from, to, { recursive: true });
-    await fs.rm(from, { recursive: true, force: true });
-  }
-}
-async function readRaw() {
-  try {
-    const raw = await fs.readFile(WORKSPACE_PATH, "utf8");
-    return { ...EMPTY, ...JSON.parse(raw) };
-  } catch {
-    return null;
-  }
-}
-async function writeRaw(ws) {
-  await fs.mkdir(ROOT, { recursive: true });
-  await fs.writeFile(WORKSPACE_PATH, JSON.stringify(ws, null, 2), "utf8");
-  return ws;
-}
-async function getWorkspace() {
-  const existing = await readRaw();
-  if (existing) return existing;
-  return serialize(migrateOrInit);
-}
-async function migrateOrInit() {
-  const again = await readRaw();
-  if (again) return again;
-  const hasLegacy = await exists(path.join(ROOT, "config.json"));
-  if (!hasLegacy) {
-    return writeRaw(EMPTY);
-  }
-  const id = randomUUID();
-  const dir = serverDir(id);
-  await fs.mkdir(dir, { recursive: true });
-  for (const f of [
-    "config.json",
-    "documents.json",
-    "jobs.json",
-    "index-run.json",
-    "server-local.json"
-  ]) {
-    await moveIfExists(path.join(ROOT, f), path.join(dir, f));
-  }
-  await moveIfExists(path.join(ROOT, "lancedb"), path.join(dir, "lancedb"));
-  await moveIfExists(path.join(ROOT, "generated-server"), path.join(dir, "generated-server"));
-  let name = "Default server";
-  try {
-    const cfgPath = path.join(dir, "config.json");
-    const cfg = JSON.parse(await fs.readFile(cfgPath, "utf8"));
-    if (cfg.projectName) name = cfg.projectName;
-    if (cfg.vectorStore === "lancedb" && (cfg.storeConfig?.mode ?? "local") === "local") {
-      cfg.storeConfig = {
-        ...cfg.storeConfig,
-        dbPath: relServerPath(id, "lancedb")
-      };
-    }
-    await fs.writeFile(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+    const entries = await fs.readdir(PROJECTS_DIR, { withFileTypes: true });
+    const projects = await Promise.all(
+      entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+        try {
+          return JSON.parse(
+            await fs.readFile(path.join(PROJECTS_DIR, entry.name, "project.json"), "utf8")
+          );
+        } catch {
+          return null;
+        }
+      })
+    );
+    const resolvedProjects = projects.filter((project) => project !== null);
+    const activeProjectId = resolvedProjects.find((project) => project.active)?.id ?? null;
+    return {
+      activeProjectId,
+      projects: resolvedProjects
+    };
   } catch {
+    return EMPTY_WORKSPACE;
   }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const meta = {
-    id,
-    name,
-    port: BASE_PORT,
-    createdAt: now,
-    updatedAt: now
-  };
-  return writeRaw({ username: null, activeServerId: id, servers: [meta], mode: null });
 }
-async function getActiveServer() {
-  const ws = await getWorkspace();
-  const override = als.getStore()?.serverId;
-  const id = override ?? ws.activeServerId;
-  if (!id) return null;
-  return ws.servers.find((s) => s.id === id) ?? null;
-}
-async function getDataDir() {
-  const server = await getActiveServer();
-  if (!server) return null;
-  const dir = serverDir(server.id);
-  await fs.mkdir(dir, { recursive: true });
-  return dir;
-}
-async function requireDataDir() {
-  const dir = await getDataDir();
-  if (dir) return dir;
-  const scopedServerId = als.getStore()?.serverId;
-  if (scopedServerId) {
-    throw new Error(`Server "${scopedServerId}" no longer exists.`);
-  }
-  const { server } = await createServer("my-larkup");
-  return serverDir(server.id);
+async function writeWorkspaceFile(workspace) {
+  await fs.mkdir(PROJECTS_DIR, { recursive: true });
+  await Promise.all(
+    workspace.projects.map(async (project) => {
+      const persisted = { ...project, active: project.id === workspace.activeProjectId };
+      await fs.mkdir(projectDir(project.id), { recursive: true });
+      await fs.writeFile(
+        path.join(projectDir(project.id), "project.json"),
+        JSON.stringify(persisted, null, 2),
+        "utf8"
+      );
+    })
+  );
+  return workspace;
 }
 async function isPortFree(port) {
   return new Promise((resolve) => {
     const server = net.createServer();
     server.once("error", () => resolve(false));
-    server.once("listening", () => {
-      server.close(() => resolve(true));
-    });
+    server.once("listening", () => server.close(() => resolve(true)));
     server.listen(port, "127.0.0.1");
   });
 }
-async function nextPort(ws) {
-  const ports = ws.servers.map((s) => s.port);
-  let candidate = Math.max(BASE_PORT - 1, ...ports) + 1;
-  while (!await isPortFree(candidate)) {
-    candidate++;
-  }
-  return candidate;
+async function nextPort(workspace) {
+  let port = Math.max(BASE_PORT - 1, ...workspace.projects.map((project) => project.port)) + 1;
+  while (!await isPortFree(port)) port += 1;
+  return port;
+}
+function slugify(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "my-larkup";
 }
-function defaultConfigFor(id, name, prevConfig = {}) {
+function initialConfig(project) {
   return {
     ...DEFAULT_CONFIG,
-    projectName: name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "my-larkup",
-    storeConfig: { mode: "local", dbPath: relServerPath(id, "lancedb") },
-    embeddingApiKey: prevConfig.embeddingApiKey ?? DEFAULT_CONFIG.embeddingApiKey,
-    customEmbeddings: prevConfig.customEmbeddings ?? DEFAULT_CONFIG.customEmbeddings,
-    chatApiKey: prevConfig.chatApiKey ?? DEFAULT_CONFIG.chatApiKey,
-    customChatModels: prevConfig.customChatModels ?? DEFAULT_CONFIG.customChatModels,
-    visionApiKey: prevConfig.visionApiKey ?? DEFAULT_CONFIG.visionApiKey,
-    customVisionModels: prevConfig.customVisionModels ?? DEFAULT_CONFIG.customVisionModels,
-    serperApiKey: prevConfig.serperApiKey ?? DEFAULT_CONFIG.serperApiKey,
-    scraperProxyServer: prevConfig.scraperProxyServer ?? DEFAULT_CONFIG.scraperProxyServer,
-    scraperProxyUsername: prevConfig.scraperProxyUsername ?? DEFAULT_CONFIG.scraperProxyUsername,
-    scraperProxyPassword: prevConfig.scraperProxyPassword ?? DEFAULT_CONFIG.scraperProxyPassword,
-    useScraperProxy: prevConfig.useScraperProxy ?? DEFAULT_CONFIG.useScraperProxy,
-    webCrawlerProvider: prevConfig.webCrawlerProvider ?? DEFAULT_CONFIG.webCrawlerProvider,
-    firecrawlApiKey: prevConfig.firecrawlApiKey ?? DEFAULT_CONFIG.firecrawlApiKey,
+    projectName: slugify(project.name),
+    storeConfig: {
+      ...DEFAULT_CONFIG.storeConfig,
+      mode: "local",
+      dbPath: `./.larkup/projects/${project.id}/index`
+    },
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function createServer(name) {
-  return serializeWorkspace(async (ws) => {
-    const id = randomUUID();
+function runWithProject(projectId, operation) {
+  return projectScope.run({ projectId }, operation);
+}
+function projectDir(projectId) {
+  return path.join(PROJECTS_DIR, projectId);
+}
+async function getProjectWorkspace() {
+  return readWorkspaceFile();
+}
+async function getActiveProject() {
+  const workspace = await getProjectWorkspace();
+  const projectId = projectScope.getStore()?.projectId ?? workspace.activeProjectId;
+  return workspace.projects.find((project) => project.id === projectId) ?? null;
+}
+async function getProjectDataDir() {
+  const project = await getActiveProject();
+  if (!project) return null;
+  const dir = projectDir(project.id);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function requireProjectDataDir() {
+  const dir = await getProjectDataDir();
+  if (dir) return dir;
+  if (projectScope.getStore()?.projectId) {
+    throw new Error(`Project "${projectScope.getStore()?.projectId}" does not exist.`);
+  }
+  const { project } = await createProject("My project");
+  return projectDir(project.id);
+}
+function createProject(name) {
+  return serialize(async () => {
+    const workspace = await readWorkspaceFile();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const meta = {
-      id,
-      name: name.trim() || "Untitled server",
-      port: await nextPort(ws),
+    const project = {
+      id: randomUUID(),
+      name: name.trim() || "Untitled project",
+      port: await nextPort(workspace),
       createdAt: now,
       updatedAt: now
     };
-    const dir = serverDir(id);
-    await fs.mkdir(dir, { recursive: true });
-    let prevConfig = {};
-    if (ws.activeServerId) {
-      try {
-        const raw = await fs.readFile(
-          path.join(serverDir(ws.activeServerId), "config.json"),
-          "utf8"
-        );
-        prevConfig = JSON.parse(raw);
-      } catch {
-      }
-    }
-    await fs.writeFile(
-      path.join(dir, "config.json"),
-      JSON.stringify(defaultConfigFor(id, meta.name, prevConfig), null, 2),
-      "utf8"
-    );
+    const dir = projectDir(project.id);
+    await fs.mkdir(path.join(dir, "releases"), { recursive: true });
+    await Promise.all([
+      fs.writeFile(path.join(dir, "project.json"), JSON.stringify({ ...project, active: true }, null, 2), "utf8"),
+      fs.writeFile(
+        path.join(dir, "config.json"),
+        JSON.stringify(initialConfig(project), null, 2),
+        "utf8"
+      ),
+      fs.writeFile(path.join(dir, "groups.json"), JSON.stringify([{
+        id: "default",
+        name: "Default",
+        description: "Sources added without a specific group.",
+        icon: "\u{1F4DA}",
+        assistantEnabled: true,
+        createdAt: now,
+        updatedAt: now
+      }], null, 2), "utf8"),
+      fs.writeFile(path.join(dir, "documents.json"), "[]\n", "utf8"),
+      fs.writeFile(path.join(dir, "deployments.json"), "[]\n", "utf8"),
+      fs.writeFile(path.join(dir, "automations.json"), "[]\n", "utf8"),
+      fs.writeFile(path.join(dir, "jobs.json"), "[]\n", "utf8"),
+      fs.writeFile(path.join(dir, "runtime.json"), "{}\n", "utf8")
+    ]);
     const next = {
-      ...ws,
-      servers: [...ws.servers, meta],
-      activeServerId: id
+      activeProjectId: project.id,
+      projects: [...workspace.projects.map((item) => ({ ...item, active: false })), project]
     };
-    await writeRaw(next);
-    return { workspace: next, server: meta };
+    await writeWorkspaceFile(next);
+    return { workspace: next, project };
   });
 }
-function setActiveServer(id) {
-  return serializeWorkspace(async (ws) => {
-    if (!ws.servers.some((s) => s.id === id)) return ws;
-    return writeRaw({ ...ws, activeServerId: id });
+function setActiveProject(projectId) {
+  return serialize(async () => {
+    const workspace = await readWorkspaceFile();
+    if (!workspace.projects.some((project) => project.id === projectId)) return workspace;
+    return writeWorkspaceFile({ ...workspace, activeProjectId: projectId });
+  });
+}
+async function resetLocalProjects(confirmedPath) {
+  if (confirmedPath !== PROJECTS_DIR) {
+    throw new Error(`Confirmation must exactly match ${PROJECTS_DIR}.`);
+  }
+  await serialize(async () => {
+    await fs.rm(PROJECTS_DIR, { recursive: true, force: true });
   });
 }
 
@@ -6924,7 +6879,7 @@ function serialize2(fn) {
   return run;
 }
 async function analyticsPath(create) {
-  const dir = create ? await requireDataDir() : await getDataDir();
+  const dir = create ? await requireProjectDataDir() : await getProjectDataDir();
   if (!dir) return null;
   return path2.join(dir, "analytics.json");
 }
@@ -6961,11 +6916,15 @@ function estimateCost(modelId, promptTokens, completionTokens) {
   const outputPrice = parseFloat(model.pricing.output || "0");
   return promptTokens * inputPrice + completionTokens * outputPrice;
 }
-async function getAnalyticsSummary(days) {
+async function getAnalyticsSummary(days, runtime = "all") {
   const events = await readUsageEvents();
   const now = /* @__PURE__ */ new Date();
   const cutoff = days > 0 ? new Date(now.getTime() - days * 24 * 60 * 60 * 1e3) : /* @__PURE__ */ new Date(0);
-  const filtered = events.filter((e) => new Date(e.timestamp) >= cutoff);
+  const filtered = events.filter((e) => {
+    if (new Date(e.timestamp) < cutoff || runtime === "all") return new Date(e.timestamp) >= cutoff;
+    const inferredRuntime = e.runtime ?? (/(localhost|127\.0\.0\.1|\[::1\])/.test(e.endpoint ?? "") ? "local" : "remote");
+    return inferredRuntime === runtime;
+  });
   const summary = {
     totalChatTokens: 0,
     totalEmbeddingTokens: 0,
@@ -7051,13 +7010,14 @@ async function getAnalyticsSummary(days) {
 
 export {
   DEFAULT_CONFIG,
-  runWithServer,
-  getWorkspace,
-  getActiveServer,
-  getDataDir,
-  requireDataDir,
-  createServer,
-  setActiveServer,
+  runWithProject,
+  getProjectWorkspace,
+  getActiveProject,
+  getProjectDataDir,
+  requireProjectDataDir,
+  createProject,
+  setActiveProject,
+  resetLocalProjects,
   ALL_MODELS,
   readUsageEvents,
   trackUsageEvent,