@langchain/langgraph-cli 0.0.0-preview.5 → 0.0.0-preview.6

package/dist/cli/dev.mjs

@@ -1,18 +1,14 @@
 import * as path from "node:path";
 import * as fs from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
+import { parse, populate } from "dotenv";
+import { watch } from "chokidar";
+import { z } from "zod";
 import open from "open";
-import * as dotenv from "dotenv";
-import { logger } from "../logging.mjs";
-import { getConfig } from "../utils/config.mjs";
 import { createIpcServer } from "./utils/ipc/server.mjs";
-import { z } from "zod";
-import { watch } from "chokidar";
-import { builder } from "./utils/builder.mjs";
 import { getProjectPath } from "./utils/project.mjs";
-const tsxTarget = new URL("../../cli.mjs", import.meta.resolve("tsx/esm/api"));
-const entrypointTarget = new URL(import.meta.resolve("./dev.entrypoint.mjs"));
+import { getConfig } from "../utils/config.mjs";
+import { builder } from "./utils/builder.mjs";
+import { logger } from "../logging.mjs";
 builder
     .command("dev")
     .description("Run LangGraph API server in development mode with hot reloading.")
@@ -21,7 +17,9 @@ builder
     .option("--no-browser", "disable auto-opening the browser")
     .option("-n, --n-jobs-per-worker <number>", "number of workers to run", "10")
     .option("-c, --config <path>", "path to configuration file", process.cwd())
-    .action(async (options) => {
+    .allowExcessArguments()
+    .allowUnknownOption()
+    .action(async (options, { args }) => {
     try {
         const configPath = await getProjectPath(options.config);
         const projectCwd = path.dirname(configPath);
@@ -32,32 +30,11 @@ builder
         });
         let hasOpenedFlag = false;
         let child = undefined;
-        const localUrl = `http://${options.host}:${options.port}`;
-        const studioUrl = `https://smith.langchain.com/studio?baseUrl=${localUrl}`;
-        console.log(`
-         Welcome to
-
-╦  ┌─┐┌┐┌┌─┐╔═╗┬─┐┌─┐┌─┐┬ ┬
-║  ├─┤││││ ┬║ ╦├┬┘├─┤├─┘├─┤
-╩═╝┴ ┴┘└┘└─┘╚═╝┴└─┴ ┴┴  ┴ ┴.js
-
-- 🚀 API: \x1b[36m${localUrl}\x1b[0m
-- 🎨 Studio UI: \x1b[36m${studioUrl}\x1b[0m
-
-This in-memory server is designed for development and testing.
-For production use, please use LangGraph Cloud.
-
-`);
         server.on("data", (data) => {
-            const { host, organizationId } = z
-                .object({ host: z.string(), organizationId: z.string().nullish() })
-                .parse(data);
-            logger.info(`Server running at ${host}`);
+            const response = z.object({ queryParams: z.string() }).parse(data);
             if (options.browser && !hasOpenedFlag) {
                 hasOpenedFlag = true;
-                open(organizationId
-                    ? `${studioUrl}&organizationId=${organizationId}`
-                    : studioUrl);
+                open(`https://smith.langchain.com/studio${response.queryParams}`);
             }
         });
         // check if .gitignore already contains .langgraph-api
@@ -79,7 +56,7 @@ For production use, please use LangGraph Cloud.
                     const envPath = path.resolve(projectCwd, configEnv);
                     newWatch.push(envPath);
                     const envData = await fs.readFile(envPath, "utf-8");
-                    dotenv.populate(env, dotenv.parse(envData));
+                    populate(env, parse(envData));
                 }
                 else if (Array.isArray(configEnv)) {
                     throw new Error("Env storage is not supported by CLI.");
@@ -87,7 +64,7 @@ For production use, please use LangGraph Cloud.
                 else if (typeof configEnv === "object") {
                     if (!process.env)
                         throw new Error("process.env is not defined");
-                    dotenv.populate(env, configEnv);
+                    populate(env, configEnv);
                 }
             }
             const oldWatch = Object.entries(watcher.getWatched()).flatMap(([dir, files]) => files.map((file) => path.resolve(projectCwd, dir, file)));
@@ -96,31 +73,27 @@ For production use, please use LangGraph Cloud.
             watcher.unwatch(removedTarget).add(addedTarget);
             return { config, env };
         };
-        const launchTsx = async () => {
+        const launchServer = async () => {
             const { config, env } = await prepareContext();
             if (child != null)
                 child.kill();
-            child = spawn(process.execPath, [
-                fileURLToPath(tsxTarget),
-                "watch",
-                "--clear-screen=false",
-                fileURLToPath(entrypointTarget),
-                pid.toString(),
-                JSON.stringify({
-                    port: Number.parseInt(options.port, 10),
-                    nWorkers: Number.parseInt(options.nJobsPerWorker, 10),
-                    host: options.host,
-                    graphs: config.graphs,
-                    cwd: projectCwd,
-                }),
-            ], { stdio: ["inherit", "inherit", "inherit", "ipc"], env });
+            if ("python_version" in config) {
+                logger.warn("Launching Python server from @langchain/langgraph-cli is experimental. Please use the `langgraph-cli` package from PyPi instead.");
+                const { spawnPythonServer } = await import("./dev.python.mjs");
+                child = await spawnPythonServer({ ...options, rest: args }, { configPath, config, env }, { pid, projectCwd });
+            }
+            else {
+                const { spawnNodeServer } = await import("./dev.node.mjs");
+                child = await spawnNodeServer({ ...options, rest: args }, { configPath, config, env }, { pid, projectCwd });
+            }
         };
         watcher.on("all", async (_name, path) => {
             logger.warn(`Detected changes in ${path}, restarting server`);
-            launchTsx();
+            launchServer();
         });
-        // TODO: handle errors
-        launchTsx();
+        // TODO: sometimes the server keeps sending stuff
+        // while gracefully exiting
+        launchServer();
         process.on("exit", () => {
             watcher.close();
             server.close();

package/dist/cli/{dev.entrypoint.mjs → dev.node.entrypoint.mjs}

@@ -16,8 +16,9 @@ const isTracingEnabled = () => {
         process.env?.LANGCHAIN_TRACING;
     return value === "true";
 };
+const options = StartServerSchema.parse(JSON.parse(payload));
 const [{ host, cleanup }, organizationId] = await Promise.all([
-    startServer(StartServerSchema.parse(JSON.parse(payload))),
+    startServer(options),
     (async () => {
         if (isTracingEnabled()) {
             try {
@@ -31,5 +32,9 @@ const [{ host, cleanup }, organizationId] = await Promise.all([
         return null;
     })(),
 ]);
+logger.info(`Server running at ${host}`);
+let queryParams = `?baseUrl=http://${options.host}:${options.port}`;
+if (organizationId)
+    queryParams += `&organizationId=${organizationId}`;
 asyncExitHook(cleanup, { wait: 1000 });
-sendToParent?.({ host, organizationId });
+sendToParent?.({ queryParams });

package/dist/cli/dev.node.mjs

@@ -0,0 +1,35 @@
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import {} from "../utils/config.mjs";
+export async function spawnNodeServer(args, context, options) {
+    const localUrl = `http://${args.host}:${args.port}`;
+    const studioUrl = `https://smith.langchain.com/studio?baseUrl=${localUrl}`;
+    console.log(`
+          Welcome to
+
+╦  ┌─┐┌┐┌┌─┐╔═╗┬─┐┌─┐┌─┐┬ ┬
+║  ├─┤││││ ┬║ ╦├┬┘├─┤├─┘├─┤
+╩═╝┴ ┴┘└┘└─┘╚═╝┴└─┴ ┴┴  ┴ ┴.js
+
+- 🚀 API: \x1b[36m${localUrl}\x1b[0m
+- 🎨 Studio UI: \x1b[36m${studioUrl}\x1b[0m
+
+This in-memory server is designed for development and testing.
+For production use, please use LangGraph Cloud.
+
+`);
+    return spawn(process.execPath, [
+        fileURLToPath(new URL("../../cli.mjs", import.meta.resolve("tsx/esm/api"))),
+        "watch",
+        "--clear-screen=false",
+        fileURLToPath(new URL(import.meta.resolve("./dev.node.entrypoint.mjs"))),
+        options.pid.toString(),
+        JSON.stringify({
+            port: Number.parseInt(args.port, 10),
+            nWorkers: Number.parseInt(args.nJobsPerWorker, 10),
+            host: args.host,
+            graphs: context.config.graphs,
+            cwd: options.projectCwd,
+        }),
+    ], { stdio: ["inherit", "inherit", "inherit", "ipc"], env: context.env });
+}

package/dist/cli/dev.python.mjs

@@ -0,0 +1,128 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { Readable } from "node:stream";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { extract as tarExtract } from "tar";
+import zipExtract from "extract-zip";
+import { logger } from "../logging.mjs";
+import { assembleLocalDeps } from "../docker/docker.mjs";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const UV_VERSION = "0.5.20";
+const UV_BINARY_CACHE = path.join(__dirname, ".uv", UV_VERSION);
+function getPlatformInfo() {
+    const platform = os.platform();
+    const arch = os.arch();
+    let binaryName = "uv";
+    let extension = "";
+    if (platform === "win32") {
+        extension = ".exe";
+    }
+    return {
+        platform,
+        arch,
+        extension,
+        binaryName: binaryName + extension,
+    };
+}
+function getDownloadUrl(info) {
+    let platformStr;
+    switch (info.platform) {
+        case "darwin":
+            platformStr = "apple-darwin";
+            break;
+        case "win32":
+            platformStr = "pc-windows-msvc";
+            break;
+        case "linux":
+            platformStr = "unknown-linux-gnu";
+            break;
+        default:
+            throw new Error(`Unsupported platform: ${info.platform}`);
+    }
+    let archStr;
+    switch (info.arch) {
+        case "x64":
+            archStr = "x86_64";
+            break;
+        case "arm64":
+            archStr = "aarch64";
+            break;
+        default:
+            throw new Error(`Unsupported architecture: ${info.arch}`);
+    }
+    const fileName = `uv-${archStr}-${platformStr}${info.platform === "win32" ? ".zip" : ".tar.gz"}`;
+    return `https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${fileName}`;
+}
+async function downloadAndExtract(url, destPath, info) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Failed to download uv: ${response.statusText}`);
+    if (!response.body)
+        throw new Error("No response body");
+    const tempDirPath = await fs.mkdtemp(path.join(os.tmpdir(), "uv-"));
+    const tempFilePath = path.join(tempDirPath, path.basename(url));
+    try {
+        // @ts-expect-error invalid types for response.body
+        await fs.writeFile(tempFilePath, Readable.fromWeb(response.body));
+        let sourceBinaryPath = tempDirPath;
+        if (url.endsWith(".zip")) {
+            await zipExtract(tempFilePath, { dir: tempDirPath });
+        }
+        else {
+            await tarExtract({ file: tempFilePath, cwd: tempDirPath });
+            sourceBinaryPath = path.resolve(sourceBinaryPath, path.basename(tempFilePath).slice(0, ".tar.gz".length * -1));
+        }
+        sourceBinaryPath = path.resolve(sourceBinaryPath, info.binaryName);
+        // Move binary to cache directory
+        const targetBinaryPath = path.join(destPath, info.binaryName);
+        await fs.rename(sourceBinaryPath, targetBinaryPath);
+        await fs.chmod(targetBinaryPath, 0o755);
+        return targetBinaryPath;
+    }
+    finally {
+        await fs.rm(tempDirPath, { recursive: true, force: true });
+    }
+}
+export async function getUvBinary() {
+    await fs.mkdir(UV_BINARY_CACHE, { recursive: true });
+    const info = getPlatformInfo();
+    const cachedBinaryPath = path.join(UV_BINARY_CACHE, info.binaryName);
+    try {
+        await fs.access(cachedBinaryPath);
+        return cachedBinaryPath;
+    }
+    catch {
+        // Binary not found in cache, download it
+        logger.info(`Downloading uv ${UV_VERSION} for ${info.platform}...`);
+        const url = getDownloadUrl(info);
+        return await downloadAndExtract(url, UV_BINARY_CACHE, info);
+    }
+}
+export async function spawnPythonServer(args, context, options) {
+    const deps = await assembleLocalDeps(context.configPath, context.config);
+    const requirements = deps.rebuildFiles.filter((i) => i.endsWith(".txt"));
+    return spawn(await getUvBinary(), [
+        "run",
+        "--with",
+        "langgraph-cli[inmem]",
+        ...requirements?.flatMap((i) => ["--with-requirements", i]),
+        "langgraph",
+        "dev",
+        "--port",
+        args.port,
+        "--host",
+        args.host,
+        "--n-jobs-per-worker",
+        args.nJobsPerWorker,
+        "--config",
+        context.configPath,
+        ...(args.browser ? [] : ["--no-browser"]),
+        ...args.rest,
+    ], {
+        stdio: ["inherit", "inherit", "inherit"],
+        env: context.env,
+        cwd: options.projectCwd,
+    });
+}

package/dist/cli/up.mjs

@@ -34,7 +34,7 @@ builder
     .description("Launch LangGraph API server.")
     .option("-c, --config <path>", "Path to configuration file", process.cwd())
     .option("-d, --docker-compose <path>", "Advanced: Path to docker-compose.yml file with additional services to launch")
-    .option("-p, --port <port>", "Port to run the server on", "8000")
+    .option("-p, --port <port>", "Port to run the server on", "8123")
     .option("--recreate", "Force recreate containers and volumes", false)
     .option("--no-pull", "Running the server with locally-built images. By default LangGraph will pull the latest images from the registry")
     .option("--watch", "Restart on file changes", false)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-cli",
-  "version": "0.0.0-preview.5",
+  "version": "0.0.0-preview.6",
   "type": "module",
   "engines": {
     "node": ">=18"
@@ -35,10 +35,12 @@
     "dotenv": "^16.4.7",
     "execa": "^9.5.2",
     "exit-hook": "^4.0.0",
+    "extract-zip": "^2.0.1",
     "hono": "^4.5.4",
     "langsmith": "^0.2.15",
     "open": "^10.1.0",
     "superjson": "^2.2.2",
+    "tar": "^7.4.3",
     "tsx": "^4.19.2",
     "uuid": "^10.0.0",
     "winston": "^3.17.0",