@langchain/langgraph-cli 0.0.0-preview.4

package/dist/cli/cli.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { builder } from "./utils/builder.mjs";
+import "./dev.mjs";
+import "./dockerfile.mjs";
+import "./build.mjs";
+// import "./up.mjs";
+builder.parse();

package/dist/cli/dev.entrypoint.mjs

@@ -0,0 +1,35 @@
+import "../preload.mjs";
+import { asyncExitHook } from "exit-hook";
+import * as process from "node:process";
+import { startServer, StartServerSchema } from "../server.mjs";
+import { connectToServer } from "./utils/ipc/client.mjs";
+import { Client as LangSmithClient } from "langsmith";
+import { logger } from "../logging.mjs";
+logger.info(`Starting server...`);
+const [ppid, payload] = process.argv.slice(-2);
+const sendToParent = await connectToServer(+ppid);
+// TODO: re-export langsmith/isTracingEnabled
+const isTracingEnabled = () => {
+    const value = process.env?.LANGSMITH_TRACING_V2 ||
+        process.env?.LANGCHAIN_TRACING_V2 ||
+        process.env?.LANGSMITH_TRACING ||
+        process.env?.LANGCHAIN_TRACING;
+    return value === "true";
+};
+const [{ host, cleanup }, organizationId] = await Promise.all([
+    startServer(StartServerSchema.parse(JSON.parse(payload))),
+    (async () => {
+        if (isTracingEnabled()) {
+            try {
+                // @ts-expect-error Private method
+                return new LangSmithClient()._getTenantId();
+            }
+            catch (error) {
+                logger.warn("Failed to get organization ID", { error });
+            }
+        }
+        return null;
+    })(),
+]);
+asyncExitHook(cleanup, { wait: 1000 });
+sendToParent?.({ host, organizationId });

package/dist/cli/dev.mjs

@@ -0,0 +1,133 @@
+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 open from "open";
+import * as dotenv from "dotenv";
+import { logger } from "../logging.mjs";
+import { ConfigSchema } 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"));
+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())
+    .action(async (options) => {
+    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;
+        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}`);
+            if (options.browser && !hasOpenedFlag) {
+                hasOpenedFlag = true;
+                open(organizationId
+                    ? `${studioUrl}&organizationId=${organizationId}`
+                    : studioUrl);
+            }
+        });
+        // 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 = ConfigSchema.parse(JSON.parse(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");
+                    dotenv.populate(env, dotenv.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");
+                    dotenv.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);
+            return { config, env };
+        };
+        const launchTsx = 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 });
+        };
+        watcher.on("all", async (_name, path) => {
+            logger.warn(`Detected changes in ${path}, restarting server`);
+            launchTsx();
+        });
+        // TODO: handle errors
+        launchTsx();
+        process.on("exit", () => {
+            watcher.close();
+            server.close();
+            child?.kill();
+        });
+    }
+    catch (error) {
+        logger.error(error);
+    }
+});

package/dist/cli/dockerfile.mjs

@@ -0,0 +1,35 @@
+import { assembleLocalDeps, configToCompose, configToDocker, } from "../docker/dockerfile.mjs";
+import { createCompose, getDockerCapabilities } from "../docker/compose.mjs";
+import { ConfigSchema } 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";
+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())
+    .action(async (savePath, options) => {
+    const configPath = await getProjectPath(options.config);
+    const config = ConfigSchema.parse(JSON.parse(await fs.readFile(configPath, "utf-8")));
+    const localDeps = await assembleLocalDeps(configPath, config);
+    const dockerfile = await configToDocker(configPath, config, localDeps);
+    if (savePath === "-") {
+        console.log(dockerfile);
+        return;
+    }
+    const targetPath = path.resolve(process.cwd(), savePath, "Dockerfile");
+    await fs.writeFile(targetPath, dockerfile);
+    if (options.addDockerCompose) {
+        const { apiDef } = await configToCompose(configPath, config, {
+            watch: false,
+        });
+        const capabilities = await getDockerCapabilities();
+        const compose = createCompose(capabilities, { apiDef });
+        const composePath = path.resolve(process.cwd(), savePath, "docker-compose.yml");
+        await fs.writeFile(composePath, compose);
+        // TODO: add .dockerignore and .env files
+    }
+});

package/dist/cli/utils/builder.mjs

@@ -0,0 +1,16 @@
+import { Command } from "@commander-js/extra-typings";
+import * as fs from "node:fs/promises";
+import * as url from "node:url";
+export const builder = new Command()
+    .name("langgraph")
+    .description("LangGraph.js CLI")
+    .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/ipc/client.mjs

@@ -0,0 +1,25 @@
+// https://github.com/privatenumber/tsx/tree/28a3e7d2b8fd72b683aab8a98dd1fcee4624e4cb
+import net from "node:net";
+import { getPipePath } from "./utils/get-pipe-path.mjs";
+export const connectToServer = (processId = process.ppid) => new Promise((resolve) => {
+    const pipePath = getPipePath(processId);
+    const socket = net.createConnection(pipePath, () => {
+        const sendToParent = (data) => {
+            const messageBuffer = Buffer.from(JSON.stringify(data));
+            const lengthBuffer = Buffer.alloc(4);
+            lengthBuffer.writeInt32BE(messageBuffer.length, 0);
+            socket.write(Buffer.concat([lengthBuffer, messageBuffer]));
+        };
+        resolve(sendToParent);
+    });
+    /**
+     * Ignore error when:
+     * - Called as a loader and there is no server
+     * - Nested process when using --test and the ppid is incorrect
+     */
+    socket.on("error", () => {
+        resolve(undefined);
+    });
+    // Prevent Node from waiting for this socket to close before exiting
+    socket.unref();
+});

package/dist/cli/utils/ipc/server.mjs

@@ -0,0 +1,71 @@
+// https://github.com/privatenumber/tsx/tree/28a3e7d2b8fd72b683aab8a98dd1fcee4624e4cb
+import net from "node:net";
+import fs from "node:fs";
+import { tmpdir } from "./utils/temporary-directory.mjs";
+import { getPipePath } from "./utils/get-pipe-path.mjs";
+const bufferData = (onMessage) => {
+    let buffer = Buffer.alloc(0);
+    return (data) => {
+        buffer = Buffer.concat([buffer, data]);
+        while (buffer.length > 4) {
+            const messageLength = buffer.readInt32BE(0);
+            if (buffer.length >= 4 + messageLength) {
+                const message = buffer.slice(4, 4 + messageLength);
+                onMessage(message);
+                buffer = buffer.slice(4 + messageLength);
+            }
+            else {
+                break;
+            }
+        }
+    };
+};
+export const createIpcServer = async () => {
+    const server = net.createServer((socket) => {
+        socket.on("data", bufferData((message) => {
+            const data = JSON.parse(message.toString());
+            server.emit("data", data);
+        }));
+    });
+    const pipePath = getPipePath(process.pid);
+    await fs.promises.mkdir(tmpdir, { recursive: true });
+    /**
+     * Fix #457 (https://github.com/privatenumber/tsx/issues/457)
+     *
+     * Avoid the error "EADDRINUSE: address already in use"
+     *
+     * If the pipe file already exists, it means that the previous process has been closed abnormally.
+     *
+     * We can safely delete the pipe file, the previous process must has been closed,
+     * as pid is unique at the same.
+     */
+    await fs.promises.rm(pipePath, { force: true });
+    await new Promise((resolve, reject) => {
+        server.listen(pipePath, resolve);
+        server.on("error", reject);
+    });
+    // Prevent Node from waiting for this socket to close before exiting
+    server.unref();
+    process.on("exit", () => {
+        server.close();
+        /**
+         * Only clean on Unix
+         *
+         * https://nodejs.org/api/net.html#ipc-support:
+         * On Windows, the local domain is implemented using a named pipe.
+         * The path must refer to an entry in \\?\pipe\ or \\.\pipe\.
+         * Any characters are permitted, but the latter may do some processing
+         * of pipe names, such as resolving .. sequences. Despite how it might
+         * look, the pipe namespace is flat. Pipes will not persist. They are
+         * removed when the last reference to them is closed. Unlike Unix domain
+         * sockets, Windows will close and remove the pipe when the owning process exits.
+         */
+        if (process.platform !== "win32") {
+            try {
+                fs.rmSync(pipePath);
+            }
+            catch { }
+        }
+    });
+    return [process.pid, server];
+};

package/dist/cli/utils/ipc/utils/get-pipe-path.mjs

@@ -0,0 +1,7 @@
+// https://github.com/privatenumber/tsx/tree/28a3e7d2b8fd72b683aab8a98dd1fcee4624e4cb
+import path from "node:path";
+import { tmpdir } from "./temporary-directory.mjs";
+export const getPipePath = (processId) => {
+    const pipePath = path.join(tmpdir, `${processId}.pipe`);
+    return process.platform === "win32" ? `\\\\?\\pipe\\${pipePath}` : pipePath;
+};

package/dist/cli/utils/ipc/utils/temporary-directory.mjs

@@ -0,0 +1,18 @@
+// https://github.com/privatenumber/tsx/tree/28a3e7d2b8fd72b683aab8a98dd1fcee4624e4cb
+import path from "node:path";
+import os from "node:os";
+/**
+ * Cache directory is based on the user's identifier
+ * to avoid permission issues when accessed by a different user
+ */
+const { geteuid } = process;
+const userId = geteuid
+    ? // For Linux users with virtual users on CI (e.g. Docker)
+        geteuid()
+    : // Use username on Windows because it doesn't have id
+        os.userInfo().username;
+/**
+ * This ensures that the cache directory is unique per user
+ * and has the appropriate permissions
+ */
+export const tmpdir = path.join(os.tmpdir(), `tsx-${userId}`);

package/dist/cli/utils/project.mjs

@@ -0,0 +1,18 @@
+import * as url from "node:url";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+export async function getProjectPath(key) {
+    const configPathOrFile = key.startsWith("file://")
+        ? url.fileURLToPath(key)
+        : path.resolve(process.cwd(), key);
+    let configPath = undefined;
+    if ((await fs.stat(configPathOrFile)).isDirectory()) {
+        configPath = path.join(configPathOrFile, "langgraph.json");
+    }
+    else if (path.basename(configPathOrFile) === "langgraph.json") {
+        configPath = configPathOrFile;
+    }
+    if (!configPath)
+        throw new Error("Invalid path");
+    return configPath;
+}

package/dist/docker/compose.mjs

@@ -0,0 +1,185 @@
+import { $ } from "execa";
+import * as yaml from "yaml";
+import { z } from "zod";
+import { getExecaOptions } from "./shell.mjs";
+export const DEFAULT_POSTGRES_URI = "postgres://postgres:postgres@langgraph-postgres:5432/postgres?sslmode=disable";
+const REDIS = {
+    image: "redis:6",
+    healthcheck: {
+        test: "redis-cli ping",
+        start_period: "10s",
+        timeout: "1s",
+        retries: 5,
+    },
+};
+const DB = {
+    image: "pgvector/pgvector:pg16",
+    // TODO: make exposing postgres optional
+    // ports: ['5433:5432'],
+    expose: ["5432"],
+    command: ["postgres", "-c", "shared_preload_libraries=vector"],
+    environment: {
+        POSTGRES_DB: "postgres",
+        POSTGRES_USER: "postgres",
+        POSTGRES_PASSWORD: "postgres",
+    },
+    volumes: ["langgraph-data:/var/lib/postgresql/data"],
+    healthcheck: {
+        test: "pg_isready -U postgres",
+        start_period: "10s",
+        timeout: "1s",
+        retries: 5,
+    },
+};
+function parseVersion(input) {
+    const parts = input.trim().split(".", 3);
+    const majorStr = parts[0] ?? "0";
+    const minorStr = parts[1] ?? "0";
+    const patchStr = parts[2] ?? "0";
+    const major = Number.parseInt(majorStr.startsWith("v") ? majorStr.slice(1) : majorStr);
+    const minor = Number.parseInt(minorStr);
+    const patch = Number.parseInt(patchStr.split("-").at(0) ?? "0");
+    return { major, minor, patch };
+}
+function compareVersion(a, b) {
+    if (a.major !== b.major) {
+        return Math.sign(a.major - b.major);
+    }
+    if (a.minor !== b.minor) {
+        return Math.sign(a.minor - b.minor);
+    }
+    return Math.sign(a.patch - b.patch);
+}
+export async function getDockerCapabilities() {
+    let rawInfo = null;
+    try {
+        const { stdout } = await $(await getExecaOptions()) `docker info -f json`;
+        rawInfo = JSON.parse(stdout);
+    }
+    catch (error) {
+        throw new Error("Docker not installed or not running: " + error);
+    }
+    const info = z
+        .object({
+        ServerVersion: z.string(),
+        ClientInfo: z.object({
+            Plugins: z.array(z.object({
+                Name: z.string(),
+                Version: z.string().optional(),
+            })),
+        }),
+    })
+        .safeParse(rawInfo);
+    if (!info.success || !info.data.ServerVersion) {
+        throw new Error("Docker not running");
+    }
+    const composePlugin = info.data.ClientInfo.Plugins.find((i) => i.Name === "compose" && i.Version != null);
+    const buildxPlugin = info.data.ClientInfo.Plugins.find((i) => i.Name === "buildx" && i.Version != null);
+    let composeRes;
+    if (composePlugin != null) {
+        composeRes = {
+            composeType: "plugin",
+            versionCompose: parseVersion(composePlugin.Version),
+        };
+    }
+    else {
+        try {
+            const standalone = await $(await getExecaOptions()) `docker-compose --version --short`;
+            composeRes = {
+                composeType: "standalone",
+                versionCompose: parseVersion(standalone.stdout),
+            };
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error("Docker Compose not installed");
+        }
+    }
+    const versionDocker = parseVersion(info.data.ServerVersion);
+    if (compareVersion(versionDocker, parseVersion("23.0.5")) < 0) {
+        throw new Error("Please upgrade Docker to at least 23.0.5");
+    }
+    return {
+        ...composeRes,
+        healthcheckStartInterval: compareVersion(versionDocker, parseVersion("25.0.0")) >= 0,
+        watchAvailable: compareVersion(composeRes.versionCompose, parseVersion("2.25.0")) >= 0,
+        buildAvailable: buildxPlugin != null,
+        versionDocker,
+    };
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function createCompose(capabilities, options) {
+    let includeDb = false;
+    let postgresUri = options.postgresUri;
+    if (!options.postgresUri) {
+        includeDb = true;
+        postgresUri = DEFAULT_POSTGRES_URI;
+    }
+    else {
+        includeDb = false;
+    }
+    const compose = {
+        services: {},
+    };
+    compose.services["langgraph-redis"] = { ...REDIS };
+    if (includeDb) {
+        compose.volumes = {
+            "langgraph-data": { driver: "local" },
+        };
+        compose.services["langgraph-postgres"] = { ...DB };
+        if (capabilities.healthcheckStartInterval) {
+            compose.services["langgraph-postgres"].healthcheck.interval = "60s";
+            compose.services["langgraph-postgres"].healthcheck.start_interval = "1s";
+        }
+        else {
+            compose.services["langgraph-postgres"].healthcheck.interval = "5s";
+        }
+    }
+    compose.services["langgraph-api"] = {
+        ports: [options.port ? `${options.port}:8000` : "8000"],
+        environment: {
+            REDIS_URI: "redis://langgraph-redis:6379",
+            POSTGRES_URI: postgresUri,
+        },
+        depends_on: {
+            "langgraph-redis": { condition: "service_healthy" },
+        },
+    };
+    if (includeDb) {
+        compose.services["langgraph-api"].depends_on["langgraph-postgres"] = {
+            condition: "service_healthy",
+        };
+    }
+    if (capabilities.healthcheckStartInterval) {
+        compose.services["langgraph-api"].healthcheck = {
+            test: "python /api/healthcheck.py",
+            interval: "60s",
+            start_interval: "1s",
+            start_period: "10s",
+        };
+        compose.services["langgraph-redis"].healthcheck.interval = "60s";
+        compose.services["langgraph-redis"].healthcheck.start_interval = "1s";
+    }
+    else {
+        compose.services["langgraph-redis"].healthcheck.interval = "5s";
+    }
+    // merge in with rest of the payload
+    if (options.apiDef) {
+        for (const key in options.apiDef) {
+            const prevValue = compose.services["langgraph-api"][key];
+            const newValue = options.apiDef[key];
+            if (isPlainObject(prevValue) && isPlainObject(newValue)) {
+                compose.services["langgraph-api"][key] = {
+                    ...prevValue,
+                    ...newValue,
+                };
+            }
+            else {
+                compose.services["langgraph-api"][key] = newValue;
+            }
+        }
+    }
+    return yaml.stringify(compose, { blockQuote: "literal" });
+}