@langchain/langgraph-cli 1.1.8 → 1.1.10

package/dist/utils/config.mjs

@@ -0,0 +1,104 @@
+import { z } from "zod/v3";
+import { extname } from "node:path";
+const GraphPathSchema = z.string().refine((i) => i.includes(":"), {
+    message: "Import string must be in format '<file>:<export>'",
+});
+const BaseConfigSchema = z.object({
+    docker_compose_file: z.string().optional(),
+    dockerfile_lines: z.array(z.string()).default([]),
+    graphs: z.record(z.union([
+        GraphPathSchema,
+        z.object({
+            path: GraphPathSchema,
+            description: z.string().optional(),
+        }),
+    ])),
+    ui: z.record(z.string()).optional(),
+    ui_config: z.object({ shared: z.array(z.string()).optional() }).optional(),
+    _INTERNAL_docker_tag: z.string().optional(),
+    env: z
+        .union([z.array(z.string()), z.record(z.string()), z.string()])
+        .default({}),
+    store: z
+        .object({
+        index: z
+            .object({
+            dims: z.number().optional(),
+            embed: z.string().optional(),
+            fields: z.array(z.string()).optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    auth: z
+        .object({
+        path: z.string().optional(),
+        disable_studio_auth: z.boolean().default(false),
+    })
+        .optional(),
+    http: z
+        .object({
+        app: z.string().optional(),
+        disable_assistants: z.boolean().default(false),
+        disable_threads: z.boolean().default(false),
+        disable_runs: z.boolean().default(false),
+        disable_store: z.boolean().default(false),
+        disable_meta: z.boolean().default(false),
+        cors: z
+            .object({
+            allow_origins: z.array(z.string()).optional(),
+            allow_methods: z.array(z.string()).optional(),
+            allow_headers: z.array(z.string()).optional(),
+            allow_credentials: z.boolean().optional(),
+            allow_origin_regex: z.string().optional(),
+            expose_headers: z.array(z.string()).optional(),
+            max_age: z.number().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+});
+const DEFAULT_PYTHON_VERSION = "3.11";
+const DEFAULT_NODE_VERSION = "20";
+const PYTHON_EXTENSIONS = [".py", ".pyx", ".pyd", ".pyi"];
+const PythonVersionSchema = z.union([z.literal("3.11"), z.literal("3.12")]);
+const NodeVersionSchema = z.union([z.literal("20"), z.literal("22")]);
+const PythonConfigSchema = BaseConfigSchema.merge(z.object({
+    pip_config_file: z.string().optional(),
+    dependencies: z
+        .array(z.string())
+        .nonempty("You need to specify at least one dependency"),
+})).merge(z.object({
+    python_version: PythonVersionSchema.default(DEFAULT_PYTHON_VERSION),
+    node_version: NodeVersionSchema.optional(),
+}));
+const NodeConfigSchema = BaseConfigSchema.merge(z.object({ node_version: NodeVersionSchema.default(DEFAULT_NODE_VERSION) }));
+const ConfigSchema = z.union([NodeConfigSchema, PythonConfigSchema]);
+// TODO: implement this in Python CLI
+export const getConfig = (config) => {
+    let input = typeof config === "string" ? JSON.parse(config) : config;
+    const { graphs } = BaseConfigSchema.parse(input);
+    const isPython = Object.values(graphs).map((graphDef) => {
+        const importStr = typeof graphDef === "string" ? graphDef : graphDef.path;
+        return PYTHON_EXTENSIONS.includes(extname(importStr.split(":")[0]));
+    });
+    const somePython = isPython.some((i) => i);
+    const someNode = !isPython.every((i) => i);
+    const node_version = someNode
+        ? input.node_version || DEFAULT_NODE_VERSION
+        : undefined;
+    const python_version = somePython
+        ? input.python_version || (someNode ? "3.12" : DEFAULT_PYTHON_VERSION)
+        : undefined;
+    if (node_version && python_version && python_version !== "3.12") {
+        throw new Error("Only Python 3.12 is supported with Node.js");
+    }
+    input = { ...input, node_version, python_version };
+    if (!input.node_version)
+        delete input.node_version;
+    if (!input.python_version)
+        delete input.python_version;
+    if (python_version)
+        return PythonConfigSchema.parse(input);
+    return NodeConfigSchema.parse(input);
+};

package/dist/utils/logging.mjs

@@ -0,0 +1,96 @@
+import { createLogger, format, transports } from "winston";
+import { consoleFormat } from "winston-console-format";
+import { parse as stacktraceParser } from "stacktrace-parser";
+import { readFileSync } from "fs";
+import { codeFrameColumns } from "@babel/code-frame";
+import path from "node:path";
+const LOG_JSON = process.env.LOG_JSON === "true";
+const LOG_LEVEL = process.env.LOG_LEVEL || "debug";
+export const logger = createLogger({
+    level: LOG_LEVEL,
+    format: format.combine(format.errors({ stack: true }), format.timestamp(), format.json(), ...(!LOG_JSON
+        ? [
+            format.colorize({ all: true }),
+            format.padLevels(),
+            consoleFormat({
+                showMeta: true,
+                metaStrip: ["timestamp"],
+                inspectOptions: {
+                    depth: Infinity,
+                    colors: true,
+                    maxArrayLength: Infinity,
+                    breakLength: 120,
+                    compact: Infinity,
+                },
+            }),
+        ]
+        : [
+            format.printf((info) => {
+                const { timestamp, level, message, ...rest } = info;
+                let event;
+                if (typeof message === "string") {
+                    event = message;
+                }
+                else {
+                    event = JSON.stringify(message);
+                }
+                if (rest.stack) {
+                    rest.message = event;
+                    event = rest.stack;
+                }
+                return JSON.stringify({ timestamp, level, event, ...rest });
+            }),
+        ])),
+    transports: [new transports.Console()],
+});
+const formatStack = (stack) => {
+    if (!stack)
+        return stack;
+    const [firstFile] = stacktraceParser(stack).filter((item) => !item.file?.split(path.sep).includes("node_modules") &&
+        !item.file?.startsWith("node:"));
+    if (firstFile?.file && firstFile?.lineNumber) {
+        try {
+            const filePath = firstFile.file;
+            const line = firstFile.lineNumber;
+            const column = firstFile.column ?? 0;
+            const messageLines = stack.split("\n");
+            const spliceIndex = messageLines.findIndex((i) => i.includes(filePath));
+            const padding = " ".repeat(Math.max(0, messageLines[spliceIndex].indexOf("at")));
+            const highlightCode = process.stdout.isTTY;
+            let codeFrame = codeFrameColumns(readFileSync(filePath, "utf-8"), { start: { line, column } }, { highlightCode });
+            codeFrame = codeFrame
+                .split("\n")
+                .map((i) => padding + i + "\x1b[0m")
+                .join("\n");
+            if (highlightCode) {
+                codeFrame = "\x1b[36m" + codeFrame + "\x1b[31m";
+            }
+            // insert codeframe after the line but dont lose the stack
+            return [
+                ...messageLines.slice(0, spliceIndex + 1),
+                codeFrame,
+                ...messageLines.slice(spliceIndex + 1),
+            ].join("\n");
+        }
+        catch {
+            // pass
+        }
+    }
+    return stack;
+};
+export const logError = (error, options) => {
+    let message;
+    let context = options?.context;
+    if (error instanceof Error) {
+        message = formatStack(error.stack) || error.message;
+    }
+    else {
+        message = String(error);
+        context = { ...context, error };
+    }
+    if (options?.prefix != null)
+        message = `${options.prefix}:\n${message}`;
+    logger.error(message, ...(context != null ? [context] : []));
+};
+process.on("uncaughtException", (error) => logError(error));
+process.on("unhandledRejection", (error) => logError(error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-cli",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -19,25 +19,11 @@
     "url": "git+ssh://git@github.com/langchain-ai/langgraphjs.git",
     "directory": "libs/langgraph-cli"
   },
-  "scripts": {
-    "clean": "rm -rf dist/ .turbo/",
-    "build": "yarn turbo:command build:internal --filter=@langchain/langgraph-cli",
-    "build:internal": "yarn clean && node scripts/build.mjs",
-    "prepublish": "yarn build",
-    "typecheck": "tsc --noEmit",
-    "cli": "tsx src/cli/cli.mts",
-    "cli:watch": "tsx watch src/cli/cli.mts",
-    "test": "vitest run",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
-  },
   "dependencies": {
     "@babel/code-frame": "^7.26.2",
     "@commander-js/extra-typings": "^13.0.0",
-    "@langchain/langgraph-api": "workspace:*",
     "chokidar": "^4.0.3",
     "commander": "^13.0.0",
-    "create-langgraph": "workspace:*",
     "dedent": "^1.5.3",
     "dotenv": "^16.4.7",
     "execa": "^9.5.2",
@@ -51,7 +37,9 @@
     "winston": "^3.17.0",
     "winston-console-format": "^1.0.8",
     "yaml": "^2.7.0",
-    "zod": "^3.25.76 || ^4"
+    "zod": "^3.25.76 || ^4",
+    "@langchain/langgraph-api": "1.1.10",
+    "create-langgraph": "1.1.5"
   },
   "devDependencies": {
     "@types/babel__code-frame": "^7.0.6",
@@ -60,5 +48,17 @@
     "tsx": "^4.19.3",
     "typescript": "^4.9.5 || ^5.4.5",
     "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "clean": "rm -rf dist/ .turbo/",
+    "build": "pnpm turbo build:internal --filter=@langchain/langgraph-cli",
+    "build:internal": "pnpm clean && node scripts/build.mjs",
+    "prepublish": "pnpm build",
+    "typecheck": "tsc --noEmit",
+    "cli": "tsx src/cli/cli.mts",
+    "cli:watch": "tsx watch src/cli/cli.mts",
+    "test": "vitest run",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
   }
-}
+}