@langchain/langgraph-cli 1.1.8 → 1.1.10

package/dist/cli/sysinfo.mjs

@@ -0,0 +1,63 @@
+import { builder } from "./utils/builder.mjs";
+import { detect } from "package-manager-detector";
+import { $ } from "execa";
+builder
+    .command("sysinfo")
+    .description("Print system information")
+    .action(async () => {
+    const manager = await detect();
+    if (!manager)
+        throw new Error("No package manager detected");
+    console.log("Node version:", process.version);
+    console.log("Operating system:", process.platform, process.arch);
+    console.log("Package manager:", manager.name);
+    console.log("Package manager version:", manager.version ?? "N/A");
+    console.log("-".repeat(20));
+    const output = await (async () => {
+        switch (manager.name) {
+            case "npm":
+                return await $ `npm ls --depth=4`;
+            case "yarn":
+                if (manager.version === "berry") {
+                    return await $ `yarn info`;
+                }
+                return await $ `yarn list --depth=4`;
+            case "pnpm":
+                return await $ `pnpm ls --depth=4`;
+            case "bun":
+                return await $ `bun pm ls`;
+            default:
+                return await $ `npm ls`;
+        }
+    })();
+    const gatherMatch = (str, regex) => {
+        return [...new Set([...str.matchAll(regex)].map((match) => match[0]))];
+    };
+    const packages = gatherMatch(output.stdout, /(@langchain\/[^\s@]+|langsmith|langchain|zod|zod-to-json-schema)/g);
+    async function getPackageInfo(packageName) {
+        switch (manager?.name) {
+            case "npm":
+                return (await $ `npm explain ${packageName}`).stdout;
+            case "yarn":
+                return (await $ `yarn why ${packageName}`).stdout;
+            case "pnpm":
+                return (await $ `pnpm why ${packageName}`).stdout;
+            case "bun":
+                return (await $ `bun why ${packageName}`).stdout;
+            default:
+                return null;
+        }
+    }
+    function escapeRegExp(text) {
+        return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    }
+    for (const pkg of packages) {
+        const info = await getPackageInfo(pkg);
+        if (!info)
+            continue;
+        const targetRegex = new RegExp(escapeRegExp(pkg) + "[@\\s][^\\s]*", "g");
+        console.log(pkg, "->", gatherMatch(info, targetRegex)
+            .map((i) => i.slice(pkg.length).trim())
+            .join(", "));
+    }
+});

package/dist/cli/up.mjs

@@ -0,0 +1,139 @@
+import { builder } from "./utils/builder.mjs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getConfig } from "../utils/config.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { logger } from "../utils/logging.mjs";
+import { createCompose, getDockerCapabilities } from "../docker/compose.mjs";
+import { configToCompose, getBaseImage } from "../docker/docker.mjs";
+import { getExecaOptions } from "../docker/shell.mjs";
+import { $ } from "execa";
+import { createHash } from "node:crypto";
+import dedent from "dedent";
+import { withAnalytics } from "./utils/analytics.mjs";
+import { gracefulExit } from "exit-hook";
+const sha256 = (input) => createHash("sha256").update(input).digest("hex");
+const getProjectName = (configPath) => {
+    const cwd = path.dirname(configPath).toLocaleLowerCase();
+    return `${path.basename(cwd)}-${sha256(cwd)}`;
+};
+const stream = (proc) => {
+    logger.debug(`Running "${proc.spawnargs.join(" ")}"`);
+    return proc;
+};
+const waitForHealthcheck = async (port) => {
+    const now = Date.now();
+    while (Date.now() - now < 10_000) {
+        const ok = await fetch(`http://localhost:${port}/ok`).then((res) => res.ok, () => false);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (ok)
+            return true;
+    }
+    throw new Error("Healthcheck timed out");
+};
+builder
+    .command("up")
+    .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", "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")
+    .exitOverride((error) => gracefulExit(error.exitCode))
+    .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 `
+        For local dev, requires env var LANGSMITH_API_KEY with access to LangSmith Deployment.
+        For production use, requires a license key in env var LANGGRAPH_CLOUD_LICENSE_KEY.
+      `);
+    const configPath = await getProjectPath(params.config);
+    const config = getConfig(await fs.readFile(configPath, "utf-8"));
+    const cwd = path.dirname(configPath);
+    const capabilities = await getDockerCapabilities();
+    const fullRestartFiles = [configPath];
+    if (typeof config.env === "string") {
+        fullRestartFiles.push(path.resolve(cwd, config.env));
+    }
+    const { apiDef } = await configToCompose(configPath, config, {
+        watch: capabilities.watchAvailable,
+    });
+    const name = getProjectName(configPath);
+    const execOpts = await getExecaOptions({
+        cwd,
+        stdout: "inherit",
+        stderr: "inherit",
+    });
+    const exec = $(execOpts);
+    if (!config._INTERNAL_docker_tag && params.pull) {
+        // pull the image
+        logger.info(`Pulling image ${getBaseImage(config)}...`);
+        await stream(exec `docker pull ${getBaseImage(config)}`);
+    }
+    // remove dangling images
+    logger.info(`Pruning dangling images...`);
+    await stream(exec `docker image prune -f --filter ${`label=com.docker.compose.project=${name}`}`);
+    // remove stale containers
+    logger.info(`Pruning stale containers...`);
+    await stream(exec `docker container prune -f --filter ${`label=com.docker.compose.project=${name}`}`);
+    const input = createCompose(capabilities, {
+        port: +params.port,
+        postgresUri: params.postgresUri,
+        apiDef,
+    });
+    const args = ["--remove-orphans"];
+    if (params.recreate) {
+        args.push("--force-recreate", "--renew-anon-volumes");
+        try {
+            await stream(exec `docker volume rm langgraph-data`);
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    if (params.watch) {
+        if (capabilities.watchAvailable) {
+            args.push("--watch");
+        }
+        else {
+            logger.warn("Watch mode is not available. Please upgrade your Docker Engine.");
+        }
+    }
+    else if (params.wait) {
+        args.push("--wait");
+    }
+    else {
+        args.push("--abort-on-container-exit");
+    }
+    logger.info(`Launching docker-compose...`);
+    const cmd = capabilities.composeType === "plugin"
+        ? ["docker", "compose"]
+        : ["docker-compose"];
+    cmd.push("--project-directory", cwd, "--project-name", name);
+    const userCompose = params.dockerCompose || config.docker_compose_file;
+    if (userCompose)
+        cmd.push("-f", userCompose);
+    cmd.push("-f", "-");
+    const up = stream($({ ...execOpts, input }) `${cmd} up ${args}`);
+    waitForHealthcheck(+params.port).then(() => {
+        logger.info(`
+          Ready!
+          - API: http://localhost:${params.port}
+          - Docs: http://localhost:${params.port}/docs
+          - LangGraph Studio: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:${params.port}
+        `);
+    }, () => void 0);
+    await up.catch(() => void 0);
+});

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, options) {
+    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: options?.name ?? actionCommand.name(),
+            params: fn?.(actionCommand) ?? {},
+        }).catch(() => { }));
+    };
+}
+export async function flushAnalytics() {
+    await analyticsPromise;
+}

package/dist/cli/utils/builder.mjs

@@ -0,0 +1,7 @@
+import { Command } from "@commander-js/extra-typings";
+import { version } from "./version.mjs";
+export const builder = new Command()
+    .name("langgraphjs")
+    .description("LangGraph.js CLI")
+    .version(version)
+    .enablePositionalOptions();

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

@@ -0,0 +1,93 @@
+// MIT License
+//
+// Copyright (c) Hiroki Osame <hiroki.osame@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// 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,29 @@
+// MIT License
+//
+// Copyright (c) Hiroki Osame <hiroki.osame@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// 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,40 @@
+// MIT License
+//
+// Copyright (c) Hiroki Osame <hiroki.osame@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// 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/cli/utils/stream.mjs

@@ -0,0 +1,90 @@
+import { Transform } from "node:stream";
+const CR = "\r".charCodeAt(0);
+const LF = "\n".charCodeAt(0);
+const TRAILING_NEWLINE = [CR, LF];
+function joinArrays(data) {
+    const totalLength = data.reduce((acc, curr) => acc + curr.length, 0);
+    let merged = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const c of data) {
+        merged.set(c, offset);
+        offset += c.length;
+    }
+    return merged;
+}
+export class BytesLineDecoder extends TransformStream {
+    constructor() {
+        let buffer = [];
+        let trailingCr = false;
+        super({
+            start() {
+                buffer = [];
+                trailingCr = false;
+            },
+            transform(chunk, controller) {
+                // See https://docs.python.org/3/glossary.html#term-universal-newlines
+                let text = chunk;
+                // Handle trailing CR from previous chunk
+                if (trailingCr) {
+                    text = joinArrays([[CR], text]);
+                    trailingCr = false;
+                }
+                // Check for trailing CR in current chunk
+                if (text.length > 0 && text.at(-1) === CR) {
+                    trailingCr = true;
+                    text = text.subarray(0, -1);
+                }
+                if (!text.length)
+                    return;
+                const trailingNewline = TRAILING_NEWLINE.includes(text.at(-1));
+                const lastIdx = text.length - 1;
+                const { lines } = text.reduce((acc, cur, idx) => {
+                    if (acc.from > idx)
+                        return acc;
+                    if (cur === CR || cur === LF) {
+                        acc.lines.push(text.subarray(acc.from, idx));
+                        if (cur === CR && text[idx + 1] === LF) {
+                            acc.from = idx + 2;
+                        }
+                        else {
+                            acc.from = idx + 1;
+                        }
+                    }
+                    if (idx === lastIdx && acc.from <= lastIdx) {
+                        acc.lines.push(text.subarray(acc.from));
+                    }
+                    return acc;
+                }, { lines: [], from: 0 });
+                if (lines.length === 1 && !trailingNewline) {
+                    buffer.push(lines[0]);
+                    return;
+                }
+                if (buffer.length) {
+                    // Include existing buffer in first line
+                    buffer.push(lines[0]);
+                    lines[0] = joinArrays(buffer);
+                    buffer = [];
+                }
+                if (!trailingNewline) {
+                    // If the last segment is not newline terminated,
+                    // buffer it for the next chunk
+                    if (lines.length)
+                        buffer = [lines.pop()];
+                }
+                // Enqueue complete lines
+                for (const line of lines) {
+                    controller.enqueue(line);
+                }
+            },
+            flush(controller) {
+                if (buffer.length) {
+                    controller.enqueue(joinArrays(buffer));
+                }
+            },
+        });
+    }
+    fromWeb() {
+        // @ts-expect-error invalid types for response.body
+        return Transform.fromWeb(this);
+    }
+}

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();