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

package/dist/cli/build.mjs

@@ -8,6 +8,7 @@ import { $ } from "execa";
 import * as path from "node:path";
 import * as fs from "node:fs/promises";
 import { logger } from "../logging.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
 const stream = (proc) => {
     logger.info(`Running "${proc.spawnargs.join(" ")}"`);
     return proc;
@@ -20,6 +21,10 @@ builder
     .option("--no-pull", "Running the server with locally-built images. By default LangGraph will pull the latest images from the registry")
     .argument("[args...]")
     .passThroughOptions()
+    .hook("preAction", withAnalytics((command) => ({
+    config: command.opts().config !== process.cwd(),
+    pull: command.opts().pull,
+})))
     .action(async (pass, params) => {
     const configPath = await getProjectPath(params.config);
     await getDockerCapabilities();

package/dist/cli/cli.mjs

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
 import { builder } from "./utils/builder.mjs";
+import { flushAnalytics } from "./utils/analytics.mjs";
+import { asyncExitHook, gracefulExit } from "exit-hook";
 import "./dev.mjs";
 import "./docker.mjs";
 import "./build.mjs";
 import "./up.mjs";
+builder.exitOverride((error) => gracefulExit(error.exitCode));
+asyncExitHook(() => flushAnalytics(), { wait: 2000 });
 builder.parse();

package/dist/cli/dev.mjs

@@ -1,18 +1,15 @@
 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";
+import { withAnalytics } from "./utils/analytics.mjs";
 builder
     .command("dev")
     .description("Run LangGraph API server in development mode with hot reloading.")
@@ -21,7 +18,15 @@ 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()
+    .hook("preAction", withAnalytics((command) => ({
+    config: command.opts().config !== process.cwd(),
+    port: command.opts().port !== "2024",
+    host: command.opts().host !== "localhost",
+    n_jobs_per_worker: command.opts().nJobsPerWorker !== "10",
+})))
+    .action(async (options, { args }) => {
     try {
         const configPath = await getProjectPath(options.config);
         const projectCwd = path.dirname(configPath);
@@ -32,32 +37,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 +63,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 +71,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 +80,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/docker.mjs

@@ -7,6 +7,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import dedent from "dedent";
 import { logger } from "../logging.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
 const fileExists = async (path) => {
     try {
         await fs.access(path);
@@ -22,6 +23,10 @@ builder
     .argument("<save-path>", "Path to save the Dockerfile")
     .option("--add-docker-compose", "Add additional files for running the LangGraph API server with docker-compose. These files include a docker-compose.yml, .env file, and a .dockerignore file.")
     .option("-c, --config <path>", "Path to configuration file", process.cwd())
+    .hook("preAction", withAnalytics((command) => ({
+    config: command.opts().config !== process.cwd(),
+    add_docker_compose: !!command.opts().addDockerCompose,
+})))
     .action(async (savePath, options) => {
     const configPath = await getProjectPath(options.config);
     const config = getConfig(await fs.readFile(configPath, "utf-8"));

package/dist/cli/up.mjs

@@ -10,6 +10,7 @@ import { getExecaOptions } from "../docker/shell.mjs";
 import { $ } from "execa";
 import { createHash } from "node:crypto";
 import dedent from "dedent";
+import { withAnalytics } from "./utils/analytics.mjs";
 const sha256 = (input) => createHash("sha256").update(input).digest("hex");
 const getProjectName = (configPath) => {
     const cwd = path.dirname(configPath).toLocaleLowerCase();
@@ -34,12 +35,22 @@ 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)
     .option("--wait", "Wait for services to start before returning. Implies --detach", false)
     .option("--postgres-uri <uri>", "Postgres URI to use for the database. Defaults to launching a local database")
+    .hook("preAction", withAnalytics((command) => ({
+    config: command.opts().config !== process.cwd(),
+    port: command.opts().port !== "8123",
+    postgres_uri: !!command.opts().postgresUri,
+    docker_compose: !!command.opts().dockerCompose,
+    recreate: command.opts().recreate,
+    pull: command.opts().pull,
+    watch: command.opts().watch,
+    wait: command.opts().wait,
+})))
     .action(async (params) => {
     logger.info("Starting LangGraph API server...");
     logger.warn(dedent `

package/dist/cli/utils/analytics.mjs

@@ -0,0 +1,39 @@
+import os from "node:os";
+import { version } from "./version.mjs";
+const SUPABASE_PUBLIC_API_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imt6cmxwcG9qaW5wY3l5YWlweG5iIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTkyNTc1NzksImV4cCI6MjAzNDgzMzU3OX0.kkVOlLz3BxemA5nP-vat3K4qRtrDuO4SwZSR_htcX9c";
+const SUPABASE_URL = "https://kzrlppojinpcyyaipxnb.supabase.co";
+async function logData(data) {
+    try {
+        await fetch(`${SUPABASE_URL}/rest/v1/js_logs`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                apikey: SUPABASE_PUBLIC_API_KEY,
+                "User-Agent": "Mozilla/5.0",
+            },
+            body: JSON.stringify(data),
+        });
+    }
+    catch (error) {
+        // pass
+    }
+}
+let analyticsPromise = Promise.resolve();
+export function withAnalytics(fn) {
+    if (process.env.LANGGRAPH_CLI_NO_ANALYTICS === "1") {
+        return () => void 0;
+    }
+    return function (actionCommand) {
+        analyticsPromise = analyticsPromise.then(() => logData({
+            os: os.platform(),
+            os_version: os.release(),
+            node_version: process.version,
+            cli_version: version,
+            cli_command: actionCommand.name(),
+            params: fn?.(actionCommand) ?? {},
+        }).catch(() => { }));
+    };
+}
+export async function flushAnalytics() {
+    await analyticsPromise;
+}

package/dist/cli/utils/builder.mjs

@@ -1,16 +1,7 @@
 import { Command } from "@commander-js/extra-typings";
-import * as fs from "node:fs/promises";
-import * as url from "node:url";
+import { version } from "./version.mjs";
 export const builder = new Command()
     .name("langgraph")
     .description("LangGraph.js CLI")
+    .version(version)
     .enablePositionalOptions();
-try {
-    const packageJson = url.fileURLToPath(new URL("../../../package.json", import.meta.url));
-    const { version } = JSON.parse(await fs.readFile(packageJson, "utf-8"));
-    builder.version(version);
-}
-catch (error) {
-    console.error(error);
-    // pass
-}

package/dist/cli/utils/version.mjs

@@ -0,0 +1,13 @@
+import * as fs from "node:fs/promises";
+import * as url from "node:url";
+async function getVersion() {
+    try {
+        const packageJson = url.fileURLToPath(new URL("../../../package.json", import.meta.url));
+        const { version } = JSON.parse(await fs.readFile(packageJson, "utf-8"));
+        return version + "+js";
+    }
+    catch {
+        return "0.0.0-unknown";
+    }
+}
+export const version = await getVersion();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-cli",
-  "version": "0.0.0-preview.5",
+  "version": "0.0.0-preview.7",
   "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",