@langchain/langgraph-cli 1.1.8 → 1.1.10

package/dist/cli/build.mjs

@@ -0,0 +1,52 @@
+import { getDockerCapabilities } from "../docker/compose.mjs";
+import { assembleLocalDeps, configToDocker, getBaseImage, } from "../docker/docker.mjs";
+import { getExecaOptions } from "../docker/shell.mjs";
+import { getConfig } from "../utils/config.mjs";
+import { builder } from "./utils/builder.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { $ } from "execa";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { logger } from "../utils/logging.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
+import { gracefulExit } from "exit-hook";
+const stream = (proc) => {
+    logger.info(`Running "${proc.spawnargs.join(" ")}"`);
+    return proc;
+};
+builder
+    .command("build")
+    .description("Build LangGraph API server Docker image.")
+    .requiredOption("-t, --tag <tag>", "Tag for the Docker image.")
+    .option("-c, --config <path>", "Path to configuration file", process.cwd())
+    .option("--no-pull", "Running the server with locally-built images. By default LangGraph will pull the latest images from the registry")
+    .argument("[args...]")
+    .passThroughOptions()
+    .allowUnknownOption()
+    .exitOverride((error) => gracefulExit(error.exitCode))
+    .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();
+    const projectDir = path.dirname(configPath);
+    const config = getConfig(await fs.readFile(configPath, "utf-8"));
+    const opts = await getExecaOptions({
+        cwd: projectDir,
+        stderr: "inherit",
+        stdout: "inherit",
+    });
+    const localDeps = await assembleLocalDeps(configPath, config);
+    const input = await configToDocker(configPath, config, localDeps, {
+        watch: false,
+        dockerCommand: "build",
+    });
+    let exec = $({ ...opts, input });
+    if (params.pull) {
+        await stream(exec `docker pull ${getBaseImage(config)}`);
+    }
+    exec = $({ ...opts, input });
+    await stream(exec `docker build -f - -t ${params.tag} ${projectDir} ${pass}`);
+});

package/dist/cli/cli.mjs

@@ -0,0 +1,13 @@
+#!/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";
+import "./new.mjs";
+import "./sysinfo.mjs";
+builder.exitOverride((error) => gracefulExit(error.exitCode));
+asyncExitHook(() => flushAnalytics(), { wait: 2000 });
+builder.parse();

package/dist/cli/cloudflare.mjs

@@ -0,0 +1,172 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { Readable, Transform, Writable } from "node:stream";
+import { ChildProcess, spawn } from "node:child_process";
+import { extract as tarExtract } from "tar";
+import * as nodeStream from "node:stream/web";
+import { fileURLToPath } from "node:url";
+import { logger } from "../utils/logging.mjs";
+import { BytesLineDecoder } from "./utils/stream.mjs";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLOUDFLARED_VERSION = "2025.2.1";
+const CLOUDFLARED_CACHE_DIR = path.join(__dirname, ".cloudflare", CLOUDFLARED_VERSION);
+const writeFile = async (path, stream) => {
+    if (stream == null)
+        throw new Error("Stream is null");
+    return await fs.writeFile(path, Readable.fromWeb(stream));
+};
+class CloudflareLoggerStream extends WritableStream {
+    constructor() {
+        const decoder = new TextDecoder();
+        super({
+            write(chunk) {
+                const text = decoder.decode(chunk);
+                const [_timestamp, level, ...rest] = text.split(" ");
+                const message = rest.join(" ");
+                if (level === "INF") {
+                    logger.debug(message);
+                }
+                else if (level === "ERR") {
+                    logger.error(message);
+                }
+                else {
+                    logger.info(message);
+                }
+            },
+        });
+    }
+    fromWeb() {
+        return Writable.fromWeb(this);
+    }
+}
+class CloudflareUrlStream extends TransformStream {
+    constructor() {
+        const decoder = new TextDecoder();
+        super({
+            transform(chunk, controller) {
+                const str = decoder.decode(chunk);
+                const urlMatch = str.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/)?.[0];
+                if (urlMatch)
+                    controller.enqueue(urlMatch);
+            },
+        });
+    }
+    fromWeb() {
+        // @ts-expect-error
+        return Transform.fromWeb(this, { objectMode: true });
+    }
+}
+export async function startCloudflareTunnel(port) {
+    const targetBinaryPath = await ensureCloudflared();
+    logger.info("Starting tunnel");
+    const child = spawn(targetBinaryPath, ["tunnel", "--url", `http://localhost:${port}`], { stdio: ["inherit", "pipe", "pipe"] });
+    child.stdout
+        .pipe(new BytesLineDecoder().fromWeb())
+        .pipe(new CloudflareLoggerStream().fromWeb());
+    child.stderr
+        .pipe(new BytesLineDecoder().fromWeb())
+        .pipe(new CloudflareLoggerStream().fromWeb());
+    const tunnelUrl = new Promise((resolve) => {
+        child.stderr
+            .pipe(new CloudflareUrlStream().fromWeb())
+            .once("data", (data) => {
+            logger.info(`Tunnel URL: "${data}"`);
+            resolve(data);
+        });
+    });
+    return { child, tunnelUrl };
+}
+function getFiles() {
+    const platform = getPlatform();
+    const arch = getArchitecture();
+    if (platform === "windows") {
+        if (arch !== "386" && arch !== "amd64") {
+            throw new Error(`Unsupported architecture: ${arch}`);
+        }
+        return { binary: `cloudflared-${platform}-${arch}.exe` };
+    }
+    if (platform === "darwin") {
+        if (arch !== "arm64" && arch !== "amd64") {
+            throw new Error(`Unsupported architecture: ${arch}`);
+        }
+        return {
+            archive: `cloudflared-${platform}-${arch}.tgz`,
+            binary: "cloudflared",
+        };
+    }
+    if (platform === "linux") {
+        if (arch !== "arm64" && arch !== "amd64" && arch !== "386") {
+            throw new Error(`Unsupported architecture: ${arch}`);
+        }
+        return { binary: `cloudflared-${platform}-${arch}` };
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}
+async function downloadCloudflared() {
+    await fs.mkdir(CLOUDFLARED_CACHE_DIR, { recursive: true });
+    logger.info("Requesting download of `cloudflared`");
+    const { binary, archive } = getFiles();
+    const downloadFile = archive ?? binary;
+    const tempDirPath = await fs.mkdtemp(path.join(os.tmpdir(), "cloudflared-"));
+    const tempFilePath = path.join(tempDirPath, downloadFile);
+    const url = `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/${downloadFile}`;
+    logger.debug("Downloading `${archive}`", { url, target: tempDirPath });
+    const response = await fetch(url);
+    if (!response.ok || !response.body) {
+        throw new Error(`Failed to download cloudflared: ${response.statusText}`);
+    }
+    await writeFile(tempFilePath, response.body);
+    if (archive != null) {
+        if (path.extname(archive) !== ".tgz") {
+            throw new Error(`Invalid archive type: "${path.extname(archive)}"`);
+        }
+        logger.debug("Extracting `cloudflared`");
+        await tarExtract({ file: tempFilePath, cwd: tempDirPath });
+    }
+    const sourceBinaryPath = path.resolve(tempDirPath, binary);
+    const targetBinaryPath = path.resolve(CLOUDFLARED_CACHE_DIR, binary);
+    logger.debug("Moving `cloudflared` to target directory", {
+        targetBinaryPath,
+    });
+    await fs.rename(sourceBinaryPath, targetBinaryPath);
+    await fs.chmod(targetBinaryPath, 0o755);
+}
+async function ensureCloudflared() {
+    const { binary } = getFiles();
+    const targetBinaryPath = path.resolve(CLOUDFLARED_CACHE_DIR, binary);
+    try {
+        await fs.access(targetBinaryPath);
+    }
+    catch {
+        await downloadCloudflared();
+    }
+    return targetBinaryPath;
+}
+function getArchitecture() {
+    const arch = os.arch();
+    switch (arch) {
+        case "x64":
+            return "amd64";
+        case "arm64":
+            return "arm64";
+        case "ia32":
+        case "x86":
+            return "386";
+        default:
+            throw new Error(`Unsupported architecture: ${arch}`);
+    }
+}
+function getPlatform() {
+    const platform = os.platform();
+    switch (platform) {
+        case "darwin":
+            return "darwin";
+        case "linux":
+            return "linux";
+        case "win32":
+            return "windows";
+        default:
+            throw new Error(`Unsupported platform: ${platform}`);
+    }
+}

package/dist/cli/dev.mjs

@@ -0,0 +1,143 @@
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { parse, populate } from "dotenv";
+import { watch } from "chokidar";
+import { z } from "zod/v3";
+import open from "open";
+import { startCloudflareTunnel } from "./cloudflare.mjs";
+import { createIpcServer } from "./utils/ipc/server.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { getConfig } from "../utils/config.mjs";
+import { builder } from "./utils/builder.mjs";
+import { logError, logger } from "../utils/logging.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
+import { gracefulExit } from "exit-hook";
+builder
+    .command("dev")
+    .description("Run LangGraph API server in development mode with hot reloading.")
+    .option("-p, --port <number>", "port to run the server on", "2024")
+    .option("-h, --host <string>", "host to bind to", "localhost")
+    .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())
+    .option("--tunnel", "use Cloudflare Tunnel to expose the server to the internet")
+    .allowExcessArguments()
+    .allowUnknownOption()
+    .exitOverride((error) => gracefulExit(error.exitCode))
+    .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",
+    tunnel: Boolean(command.opts().tunnel),
+})))
+    .action(async (options, { args }) => {
+    try {
+        const configPath = await getProjectPath(options.config);
+        const projectCwd = path.dirname(configPath);
+        const [pid, server] = await createIpcServer();
+        const watcher = watch([configPath], {
+            ignoreInitial: true,
+            cwd: projectCwd,
+        });
+        let hasOpenedFlag = false;
+        let child = undefined;
+        let tunnel = undefined;
+        let hostUrl = "https://smith.langchain.com";
+        let envNoBrowser = process.env.BROWSER === "none";
+        server.on("data", async (data) => {
+            const response = z.object({ queryParams: z.string() }).parse(data);
+            if (options.browser && !envNoBrowser && !hasOpenedFlag) {
+                hasOpenedFlag = true;
+                const queryParams = new URLSearchParams(response.queryParams);
+                const tunnelUrl = await tunnel?.tunnelUrl;
+                if (tunnelUrl)
+                    queryParams.set("baseUrl", tunnelUrl);
+                let queryParamsStr = queryParams.toString();
+                if (queryParamsStr)
+                    queryParamsStr = `?${queryParams.toString()}`;
+                open(`${hostUrl}/studio${queryParamsStr}`);
+            }
+        });
+        // check if .gitignore already contains .langgraph-api
+        const gitignorePath = path.resolve(projectCwd, ".gitignore");
+        const gitignoreContent = await fs
+            .readFile(gitignorePath, "utf-8")
+            .catch(() => "");
+        if (!gitignoreContent.includes(".langgraph_api")) {
+            logger.info("Updating .gitignore to prevent `.langgraph_api` from being committed.");
+            await fs.appendFile(gitignorePath, "\n# LangGraph API\n.langgraph_api\n");
+        }
+        const prepareContext = async () => {
+            const config = getConfig(await fs.readFile(configPath, "utf-8"));
+            const newWatch = [configPath];
+            const env = { ...process.env };
+            const configEnv = config?.env;
+            if (configEnv) {
+                if (typeof configEnv === "string") {
+                    const envPath = path.resolve(projectCwd, configEnv);
+                    newWatch.push(envPath);
+                    const envData = await fs.readFile(envPath, "utf-8");
+                    populate(env, parse(envData));
+                }
+                else if (Array.isArray(configEnv)) {
+                    throw new Error("Env storage is not supported by CLI.");
+                }
+                else if (typeof configEnv === "object") {
+                    if (!process.env)
+                        throw new Error("process.env is not defined");
+                    populate(env, configEnv);
+                }
+            }
+            const oldWatch = Object.entries(watcher.getWatched()).flatMap(([dir, files]) => files.map((file) => path.resolve(projectCwd, dir, file)));
+            const addedTarget = newWatch.filter((target) => !oldWatch.includes(target));
+            const removedTarget = oldWatch.filter((target) => !newWatch.includes(target));
+            watcher.unwatch(removedTarget).add(addedTarget);
+            try {
+                const { Client } = await import("langsmith");
+                const apiUrl = env?.["LANGSMITH_ENDPOINT"] ||
+                    env?.["LANGCHAIN_ENDPOINT"] ||
+                    undefined;
+                hostUrl = new Client({ apiUrl }).getHostUrl() || hostUrl;
+            }
+            catch {
+                // pass
+            }
+            return { config, env, hostUrl };
+        };
+        const launchServer = async () => {
+            const { config, env, hostUrl } = await prepareContext();
+            if (child != null)
+                child.kill();
+            if (tunnel != null)
+                tunnel.child.kill();
+            if (options.tunnel)
+                tunnel = await startCloudflareTunnel(options.port);
+            envNoBrowser = process.env.BROWSER === "none" || env.BROWSER === "none";
+            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, hostUrl }, { pid, projectCwd });
+            }
+            else {
+                const { spawnServer } = await import("@langchain/langgraph-api");
+                child = await spawnServer(options, { config, env, hostUrl }, { pid, projectCwd });
+            }
+        };
+        watcher.on("all", async (_name, path) => {
+            logger.warn(`Detected changes in ${path}, restarting server`);
+            launchServer();
+        });
+        // TODO: sometimes the server keeps sending stuff
+        // while gracefully exiting
+        launchServer();
+        process.on("exit", () => {
+            watcher.close();
+            server.close();
+            child?.kill();
+        });
+    }
+    catch (error) {
+        logError(error, { prefix: "Failed to launch server" });
+    }
+});

package/dist/cli/dev.python.mjs

@@ -0,0 +1,129 @@
+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 "../utils/logging.mjs";
+import { assembleLocalDeps } from "../docker/docker.mjs";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const UV_VERSION = "0.9.11";
+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);
+        // Just copy the file directly (it's a single executable, not a directory)
+        await fs.copyFile(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

@@ -0,0 +1,114 @@
+import { assembleLocalDeps, configToCompose, configToDocker, } from "../docker/docker.mjs";
+import { createCompose, getDockerCapabilities } from "../docker/compose.mjs";
+import { getConfig } from "../utils/config.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { builder } from "./utils/builder.mjs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import dedent from "dedent";
+import { logger } from "../utils/logging.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
+import { gracefulExit } from "exit-hook";
+const fileExists = async (path) => {
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+builder
+    .command("dockerfile")
+    .description("Generate a Dockerfile for the LangGraph API server, with Docker Compose options.")
+    .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())
+    .exitOverride((error) => gracefulExit(error.exitCode))
+    .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"));
+    const localDeps = await assembleLocalDeps(configPath, config);
+    const dockerfile = await configToDocker(configPath, config, localDeps);
+    if (savePath === "-") {
+        process.stdout.write(dockerfile);
+        process.stdout.write("\n");
+        return;
+    }
+    const targetPath = path.resolve(process.cwd(), savePath);
+    await fs.writeFile(targetPath, dockerfile);
+    logger.info(`✅ Created: ${path.basename(targetPath)}`);
+    if (options.addDockerCompose) {
+        const { apiDef } = await configToCompose(configPath, config, {
+            watch: false,
+        });
+        const capabilities = await getDockerCapabilities();
+        const compose = createCompose(capabilities, { apiDef });
+        const composePath = path.resolve(path.dirname(targetPath), "docker-compose.yml");
+        await fs.writeFile(composePath, compose);
+        logger.info("✅ Created: .docker-compose.yml");
+        const dockerignorePath = path.resolve(path.dirname(targetPath), ".dockerignore");
+        if (!fileExists(dockerignorePath)) {
+            await fs.writeFile(dockerignorePath, dedent `
+            # Ignore node_modules and other dependency directories
+            node_modules
+            bower_components
+            vendor
+  
+            # Ignore logs and temporary files
+            *.log
+            *.tmp
+            *.swp
+  
+            # Ignore .env files and other environment files
+            .env
+            .env.*
+            *.local
+  
+            # Ignore git-related files
+            .git
+            .gitignore
+  
+            # Ignore Docker-related files and configs
+            .dockerignore
+            docker-compose.yml
+  
+            # Ignore build and cache directories
+            dist
+            build
+            .cache
+            __pycache__
+  
+            # Ignore IDE and editor configurations
+            .vscode
+            .idea
+            *.sublime-project
+            *.sublime-workspace
+            .DS_Store  # macOS-specific
+  
+            # Ignore test and coverage files
+            coverage
+            *.coverage
+            *.test.js
+            *.spec.js
+            tests
+          `);
+            logger.info(`✅ Created: ${path.basename(dockerignorePath)}`);
+        }
+        const envPath = path.resolve(path.dirname(targetPath), ".env");
+        if (!fileExists(envPath)) {
+            await fs.writeFile(envPath, dedent `
+            # Uncomment the following line to add your LangSmith API key
+            # LANGSMITH_API_KEY=your-api-key
+            # Or if you have a LangSmith Deployment license key, then uncomment the following line:
+            # LANGGRAPH_CLOUD_LICENSE_KEY=your-license-key
+            # Add any other environment variables go below...
+          `);
+            logger.info(`✅ Created: ${path.basename(envPath)}`);
+        }
+    }
+});

package/dist/cli/new.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { builder } from "./utils/builder.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
+import { createNew } from "create-langgraph";
+import { gracefulExit } from "exit-hook";
+builder
+    .command("new")
+    .description("Create a new LangGraph project")
+    .argument("[path]", "Path to create the project")
+    .option("-t, --template <template>", "Template to use", "")
+    .hook("preAction", withAnalytics())
+    .exitOverride((error) => gracefulExit(error.exitCode))
+    .action((path, options) => createNew(path, options.template));