@dobby.ai/dobby 0.1.0

package/plugins/provider-pi/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@dobby.ai/provider-pi",
+  "version": "0.1.2",
+  "private": false,
+  "type": "module",
+  "description": "Built-in pi provider extension package",
+  "main": "./index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@mariozechner/pi-agent-core": "^0.53.0",
+    "@mariozechner/pi-ai": "^0.53.0",
+    "@mariozechner/pi-coding-agent": "^0.53.0",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "@dobby.ai/plugin-sdk": "^0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@dobby.ai/plugin-sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@dobby.ai/plugin-sdk": "file:../plugin-sdk",
+    "@types/node": "^22.10.5",
+    "typescript": "^5.9.2"
+  },
+  "files": [
+    "index.js",
+    "dist/",
+    "dobby.manifest.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/plugins/provider-pi/src/contribution.ts

@@ -0,0 +1,476 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { AgentMessage, ThinkingLevel } from "@mariozechner/pi-agent-core";
+import {
+  AuthStorage,
+  type CreateAgentSessionOptions,
+  type ToolDefinition,
+  createAgentSession,
+  createBashTool,
+  createEditTool,
+  createFindTool,
+  createGrepTool,
+  createLsTool,
+  createReadTool,
+  createWriteTool,
+  ModelRegistry,
+  SessionManager,
+  type AgentSession,
+  type BashOperations,
+  type EditOperations,
+  type ReadOperations,
+  type WriteOperations,
+} from "@mariozechner/pi-coding-agent";
+import type { Api, ImageContent, Model } from "@mariozechner/pi-ai";
+import { z } from "zod";
+import type {
+  GatewayAgentEvent,
+  GatewayAgentRuntime,
+  ProviderContributionModule,
+  ProviderInstance,
+  ProviderInstanceCreateOptions,
+  ProviderSessionArchiveOptions,
+  ProviderRuntimeCreateOptions,
+} from "@dobby.ai/plugin-sdk";
+
+const BOXLITE_CONTEXT_CONVERSATION_KEY_ENV = "__IM_AGENT_BOXLITE_CONVERSATION_KEY";
+const BOXLITE_CONTEXT_PROJECT_ROOT_ENV = "__IM_AGENT_BOXLITE_PROJECT_ROOT";
+
+type RuntimeTool = NonNullable<CreateAgentSessionOptions["tools"]>[number];
+
+interface PiProviderConfig {
+  provider: string;
+  model: string;
+  thinkingLevel: ThinkingLevel;
+  agentDir?: string;
+  authFile?: string;
+  modelsFile?: string;
+}
+
+interface BuiltTools {
+  activeTools: RuntimeTool[];
+  customTools: ToolDefinition[];
+}
+
+const piProviderConfigSchema = z.object({
+  provider: z.string().min(1),
+  model: z.string().min(1),
+  thinkingLevel: z.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).default("off"),
+  agentDir: z.string().optional(),
+  authFile: z.string().optional(),
+  modelsFile: z.string().default("./models.custom.json"),
+});
+
+const IMAGE_MIME_TYPES: Record<string, string> = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+};
+
+function assertWithinRoot(absolutePath: string, rootDir: string): void {
+  const normalizedRoot = resolve(rootDir);
+  const normalizedPath = resolve(absolutePath);
+  const rootPrefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
+
+  if (normalizedPath !== normalizedRoot && !normalizedPath.startsWith(rootPrefix)) {
+    throw new Error(`Path '${normalizedPath}' is outside allowed project root '${normalizedRoot}'`);
+  }
+}
+
+function safeSegment(value: string): string {
+  return value.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+function extractAssistantText(message: AgentMessage): string {
+  if (message.role !== "assistant") return "";
+  const blocks = message.content.filter((block): block is { type: "text"; text: string } => block.type === "text");
+  return blocks.map((block) => block.text).join("\n");
+}
+
+function extractToolResultText(result: unknown): string {
+  if (!result || typeof result !== "object") return "(no output)";
+  const content = (result as { content?: unknown }).content;
+  if (!Array.isArray(content)) return "(no output)";
+
+  const textBlocks = content.filter(
+    (block): block is { type: "text"; text: string } =>
+      typeof block === "object" &&
+      block !== null &&
+      "type" in block &&
+      (block as { type: string }).type === "text" &&
+      "text" in block,
+  );
+
+  const text = textBlocks.map((block) => block.text).join("\n").trim();
+  return text.length > 0 ? text : "(no output)";
+}
+
+function normalizeMaybePath(configBaseDir: string, value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return undefined;
+  if (trimmed === "~") return resolve(process.env.HOME ?? "", ".");
+  if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+    return resolve(process.env.HOME ?? "", trimmed.slice(2));
+  }
+  return resolve(configBaseDir, trimmed);
+}
+
+function formatArchiveStamp(timestampMs: number): string {
+  return new Date(timestampMs).toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}
+
+async function archiveSessionPath(
+  sessionsDir: string,
+  sourcePath: string,
+  archivedAtMs: number,
+): Promise<string | undefined> {
+  const relativePath = relative(sessionsDir, sourcePath);
+  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+    throw new Error(`Session path '${sourcePath}' is outside sessions dir '${sessionsDir}'`);
+  }
+
+  const archiveRoot = join(sessionsDir, "_archived", `${formatArchiveStamp(archivedAtMs)}-${randomUUID().slice(0, 8)}`);
+  const archivePath = join(archiveRoot, relativePath);
+  await mkdir(dirname(archivePath), { recursive: true });
+
+  try {
+    await rename(sourcePath, archivePath);
+    return archivePath;
+  } catch (error) {
+    const asErr = error as NodeJS.ErrnoException;
+    if (asErr.code === "ENOENT") {
+      return undefined;
+    }
+    throw error;
+  }
+}
+
+class PiGatewayRuntime implements GatewayAgentRuntime {
+  constructor(private readonly session: AgentSession) {}
+
+  async prompt(text: string, options?: { images?: ImageContent[] }): Promise<void> {
+    if (options?.images && options.images.length > 0) {
+      await this.session.prompt(text, { images: options.images });
+      return;
+    }
+    await this.session.prompt(text);
+  }
+
+  subscribe(listener: (event: GatewayAgentEvent) => void): () => void {
+    return this.session.subscribe((event) => {
+      if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+        listener({ type: "message_delta", delta: event.assistantMessageEvent.delta });
+        return;
+      }
+
+      if (event.type === "message_end" && event.message.role === "assistant") {
+        const finalText = extractAssistantText(event.message);
+        if (finalText.trim().length > 0) {
+          listener({ type: "message_complete", text: finalText });
+        }
+        return;
+      }
+
+      if (event.type === "tool_execution_start") {
+        listener({ type: "tool_start", toolName: event.toolName });
+        return;
+      }
+
+      if (event.type === "tool_execution_end") {
+        listener({
+          type: "tool_end",
+          toolName: event.toolName,
+          isError: event.isError,
+          output: extractToolResultText(event.result),
+        });
+        return;
+      }
+
+      if (event.type === "auto_compaction_start") {
+        listener({ type: "status", message: `Compacting context (${event.reason})...` });
+        return;
+      }
+
+      if (event.type === "auto_retry_start") {
+        listener({ type: "status", message: `Retrying (${event.attempt}/${event.maxAttempts})...` });
+      }
+    });
+  }
+
+  async abort(): Promise<void> {
+    await this.session.abort();
+  }
+
+  dispose(): void {
+    this.session.dispose();
+  }
+}
+
+class PiProviderInstanceImpl implements ProviderInstance {
+  private readonly authStorage: AuthStorage;
+  private readonly modelRegistry: ModelRegistry;
+  private readonly model: Model<Api>;
+
+  constructor(
+    readonly id: string,
+    private readonly providerConfig: PiProviderConfig,
+    private readonly dataConfig: ProviderInstanceCreateOptions["data"],
+    private readonly logger: ProviderInstanceCreateOptions["host"]["logger"],
+  ) {
+    this.authStorage = AuthStorage.create(providerConfig.authFile);
+    this.modelRegistry = new ModelRegistry(this.authStorage, providerConfig.modelsFile);
+
+    const model = this.modelRegistry.find(providerConfig.provider, providerConfig.model);
+    if (!model) {
+      throw new Error(`Configured model '${providerConfig.provider}/${providerConfig.model}' not found`);
+    }
+    this.model = model;
+  }
+
+  async createRuntime(options: ProviderRuntimeCreateOptions): Promise<GatewayAgentRuntime> {
+    const sessionFile = options.sessionPolicy === "ephemeral"
+      ? this.getEphemeralSessionFilePath(options.conversationKey)
+      : this.getSessionFilePath(options.inbound);
+    const sessionDir = dirname(sessionFile);
+
+    await mkdir(this.dataConfig.sessionsDir, { recursive: true });
+    await mkdir(this.dataConfig.logsDir, { recursive: true });
+    await mkdir(this.dataConfig.stateDir, { recursive: true });
+    await mkdir(this.dataConfig.attachmentsDir, { recursive: true });
+    await mkdir(sessionDir, { recursive: true });
+
+    const builtTools = this.buildTools(
+      options.conversationKey,
+      options.route.profile.projectRoot,
+      options.route.profile.tools,
+      options,
+    );
+
+    const sessionOptions = {
+      cwd: options.route.profile.projectRoot,
+      authStorage: this.authStorage,
+      modelRegistry: this.modelRegistry,
+      sessionManager: SessionManager.open(sessionFile, sessionDir),
+      model: this.model,
+      thinkingLevel: this.providerConfig.thinkingLevel,
+      tools: builtTools.activeTools,
+      customTools: builtTools.customTools,
+      ...(this.providerConfig.agentDir ? { agentDir: this.providerConfig.agentDir } : {}),
+    };
+
+    const { session } = await createAgentSession(sessionOptions);
+
+    this.logger.info(
+      {
+        providerInstance: this.id,
+        activeTools: builtTools.activeTools.map((tool) => tool.name),
+      },
+      "Provider runtime initialized",
+    );
+
+    if (options.route.profile.systemPromptFile) {
+      try {
+        const prompt = await readFile(options.route.profile.systemPromptFile, "utf-8");
+        session.agent.setSystemPrompt(prompt);
+      } catch (error) {
+        this.logger.warn(
+          { err: error, routeId: options.route.routeId, file: options.route.profile.systemPromptFile },
+          "Failed to load route system prompt; continuing with default",
+        );
+      }
+    }
+
+    return new PiGatewayRuntime(session);
+  }
+
+  async archiveSession(options: ProviderSessionArchiveOptions): Promise<{ archived: boolean; archivePath?: string }> {
+    const sessionFile = options.sessionPolicy === "ephemeral"
+      ? this.getEphemeralSessionFilePath(options.conversationKey)
+      : this.getSessionFilePath(options.inbound);
+    const archivePath = await archiveSessionPath(
+      this.dataConfig.sessionsDir,
+      sessionFile,
+      options.archivedAtMs ?? Date.now(),
+    );
+    return archivePath ? { archived: true, archivePath } : { archived: false };
+  }
+
+  private buildTools(
+    conversationKey: string,
+    projectRoot: string,
+    profile: "full" | "readonly",
+    options: ProviderRuntimeCreateOptions,
+  ): BuiltTools {
+    const readOps: ReadOperations = {
+      access: async (absolutePath) => {
+        assertWithinRoot(absolutePath, projectRoot);
+      },
+      readFile: async (absolutePath) => {
+        assertWithinRoot(absolutePath, projectRoot);
+        return readFile(absolutePath);
+      },
+      detectImageMimeType: async (absolutePath) => {
+        const ext = extname(absolutePath).toLowerCase();
+        return IMAGE_MIME_TYPES[ext] ?? null;
+      },
+    };
+
+    const writeOps: WriteOperations = {
+      mkdir: async (dir) => {
+        assertWithinRoot(dir, projectRoot);
+        await mkdir(dir, { recursive: true });
+      },
+      writeFile: async (absolutePath, content) => {
+        assertWithinRoot(absolutePath, projectRoot);
+        await writeFile(absolutePath, content, "utf-8");
+      },
+    };
+
+    const editOps: EditOperations = {
+      access: async (absolutePath) => {
+        assertWithinRoot(absolutePath, projectRoot);
+      },
+      readFile: async (absolutePath) => {
+        assertWithinRoot(absolutePath, projectRoot);
+        return readFile(absolutePath);
+      },
+      writeFile: async (absolutePath, content) => {
+        assertWithinRoot(absolutePath, projectRoot);
+        await writeFile(absolutePath, content, "utf-8");
+      },
+    };
+
+    const bashOps: BashOperations = {
+      exec: async (command, cwd, execOptionsFromTool) => {
+        const env: NodeJS.ProcessEnv = {
+          ...(execOptionsFromTool.env ?? {}),
+          [BOXLITE_CONTEXT_CONVERSATION_KEY_ENV]: conversationKey,
+          [BOXLITE_CONTEXT_PROJECT_ROOT_ENV]: projectRoot,
+        };
+
+        const execOptions = {
+          ...(execOptionsFromTool.signal ? { signal: execOptionsFromTool.signal } : {}),
+          ...(execOptionsFromTool.timeout !== undefined ? { timeoutSeconds: execOptionsFromTool.timeout } : {}),
+          env,
+        };
+
+        this.logger.info(
+          {
+            providerInstance: this.id,
+            sandboxExecutorType: options.executor.constructor?.name ?? "unknown",
+            cwd,
+            timeoutSeconds: execOptions.timeoutSeconds,
+          },
+          "Dispatching bash command to sandbox executor",
+        );
+
+        const result = await options.executor.exec(command, cwd, execOptions);
+        const combined = `${result.stdout}${result.stderr}`;
+        if (combined.length > 0) {
+          execOptionsFromTool.onData(Buffer.from(combined, "utf-8"));
+        }
+
+        this.logger.info(
+          {
+            providerInstance: this.id,
+            sandboxExecutorType: options.executor.constructor?.name ?? "unknown",
+            code: result.code,
+            killed: result.killed,
+            stdoutBytes: Buffer.byteLength(result.stdout, "utf-8"),
+            stderrBytes: Buffer.byteLength(result.stderr, "utf-8"),
+          },
+          "Sandbox executor completed bash command",
+        );
+
+        return { exitCode: result.killed ? null : result.code };
+      },
+    };
+
+    const readTool = createReadTool(projectRoot, { operations: readOps }) as RuntimeTool;
+    const bashTool = createBashTool(projectRoot, { operations: bashOps }) as RuntimeTool;
+    const editTool = createEditTool(projectRoot, { operations: editOps }) as RuntimeTool;
+    const writeTool = createWriteTool(projectRoot, { operations: writeOps }) as RuntimeTool;
+    const grepTool = createGrepTool(projectRoot) as RuntimeTool;
+    const findTool = createFindTool(projectRoot) as RuntimeTool;
+    const lsTool = createLsTool(projectRoot) as RuntimeTool;
+
+    if (profile === "readonly") {
+      const activeTools = [readTool, grepTool, findTool, lsTool];
+      return {
+        activeTools,
+        customTools: activeTools.map((tool) => this.toCustomToolDefinition(tool)),
+      };
+    }
+
+    const activeTools = [readTool, bashTool, editTool, writeTool];
+    return {
+      activeTools,
+      customTools: activeTools.map((tool) => this.toCustomToolDefinition(tool)),
+    };
+  }
+
+  private toCustomToolDefinition(tool: RuntimeTool): ToolDefinition {
+    return {
+      name: tool.name,
+      label: tool.label,
+      description: tool.description,
+      parameters: tool.parameters,
+      execute: (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate),
+    };
+  }
+
+  private getSessionFilePath(inbound: ProviderRuntimeCreateOptions["inbound"]): string {
+    const guildSegment = safeSegment(inbound.guildId ?? "dm");
+    const connectorSegment = safeSegment(inbound.connectorId);
+    const sourceSegment = safeSegment(inbound.source.id);
+    const threadSegment = safeSegment(inbound.threadId ?? "root");
+    const chatSegment = safeSegment(inbound.chatId);
+
+    return join(
+      this.dataConfig.sessionsDir,
+      connectorSegment,
+      inbound.platform,
+      safeSegment(inbound.accountId),
+      guildSegment,
+      sourceSegment,
+      threadSegment,
+      `${chatSegment}.jsonl`,
+    );
+  }
+
+  private getEphemeralSessionFilePath(conversationKey: string): string {
+    return join(
+      this.dataConfig.sessionsDir,
+      "_cron-ephemeral",
+      `${safeSegment(conversationKey)}.jsonl`,
+    );
+  }
+}
+
+export const providerPiContribution: ProviderContributionModule = {
+  kind: "provider",
+  configSchema: z.toJSONSchema(piProviderConfigSchema),
+  createInstance(options) {
+    const parsed = piProviderConfigSchema.parse(options.config);
+    const agentDir = normalizeMaybePath(options.host.configBaseDir, parsed.agentDir);
+    const authFile = normalizeMaybePath(options.host.configBaseDir, parsed.authFile);
+    const modelsFile = normalizeMaybePath(options.host.configBaseDir, parsed.modelsFile);
+
+    const normalizedConfig: PiProviderConfig = {
+      provider: parsed.provider,
+      model: parsed.model,
+      thinkingLevel: parsed.thinkingLevel,
+      ...(agentDir ? { agentDir } : {}),
+      ...(authFile ? { authFile } : {}),
+      ...(modelsFile ? { modelsFile } : {}),
+    };
+
+    return new PiProviderInstanceImpl(options.instanceId, normalizedConfig, options.data, options.host.logger);
+  },
+};
+
+export default providerPiContribution;

package/plugins/provider-pi/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/plugins/sandbox-core/boxlite.js

@@ -0,0 +1 @@
+export { sandboxBoxliteContribution as contribution, sandboxBoxliteContribution as default } from "./dist/boxlite-contribution.js";

package/plugins/sandbox-core/dobby.manifest.json

@@ -0,0 +1,17 @@
+{
+  "apiVersion": "1.0",
+  "name": "@dobby.ai/sandbox-core",
+  "version": "0.1.0",
+  "contributions": [
+    {
+      "id": "sandbox.docker",
+      "kind": "sandbox",
+      "entry": "./dist/docker-contribution.js"
+    },
+    {
+      "id": "sandbox.boxlite",
+      "kind": "sandbox",
+      "entry": "./dist/boxlite-contribution.js"
+    }
+  ]
+}

package/plugins/sandbox-core/docker.js

@@ -0,0 +1 @@
+export { sandboxDockerContribution as contribution, sandboxDockerContribution as default } from "./dist/docker-contribution.js";

package/plugins/sandbox-core/package-lock.json

@@ -0,0 +1,136 @@
+{
+  "name": "@dobby.ai/sandbox-core",
+  "version": "0.1.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@dobby.ai/sandbox-core",
+      "version": "0.1.1",
+      "dependencies": {
+        "@boxlite-ai/boxlite": "^0.2.11",
+        "zod": "^4.3.6"
+      },
+      "devDependencies": {
+        "@dobby.ai/plugin-sdk": "file:../plugin-sdk",
+        "@types/node": "^22.10.5",
+        "typescript": "^5.9.2"
+      },
+      "peerDependencies": {
+        "@dobby.ai/plugin-sdk": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "@dobby.ai/plugin-sdk": {
+          "optional": true
+        }
+      }
+    },
+    "../plugin-sdk": {
+      "name": "@dobby.ai/plugin-sdk",
+      "version": "0.1.2",
+      "dev": true
+    },
+    "node_modules/@boxlite-ai/boxlite": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmmirror.com/@boxlite-ai/boxlite/-/boxlite-0.2.11.tgz",
+      "integrity": "sha512-IJ+jyYdsc1hmZknDtqGpRyMAMxoQfF1VFDVuPhiO59fBmoDEI5u69DzoMtyax4gzL3Q46tjYkVBvJhNtSDaxBw==",
+      "license": "Apache-2.0",
+      "workspaces": [
+        "npm/*"
+      ],
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "@boxlite-ai/boxlite-darwin-arm64": "0.2.11",
+        "@boxlite-ai/boxlite-darwin-x64": "0.2.11",
+        "@boxlite-ai/boxlite-linux-arm64-gnu": "0.2.11",
+        "@boxlite-ai/boxlite-linux-x64-gnu": "0.2.11"
+      },
+      "peerDependencies": {
+        "playwright-core": ">=1.58.0"
+      },
+      "peerDependenciesMeta": {
+        "playwright-core": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@boxlite-ai/boxlite-darwin-arm64": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmmirror.com/@boxlite-ai/boxlite-darwin-arm64/-/boxlite-darwin-arm64-0.2.11.tgz",
+      "integrity": "sha512-JjNf6S/+XqooWvFX2Zn9XjmeML/e6Errk0jzG77v8YV0k2nNmt8P1nMANb2kMPbsQn93ap9v74VnYesYdKRoNg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@boxlite-ai/boxlite-linux-x64-gnu": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmmirror.com/@boxlite-ai/boxlite-linux-x64-gnu/-/boxlite-linux-x64-gnu-0.2.11.tgz",
+      "integrity": "sha512-H3a8FMc6X4KVsmlQKs2xTIlSh4KhiI52MnXV16OwcC6OWQBBadR1N6GCCKojfwpqn6yIsZc2dxoyy25YTYYf9g==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@dobby.ai/plugin-sdk": {
+      "resolved": "../plugin-sdk",
+      "link": true
+    },
+    "node_modules/@types/node": {
+      "version": "22.19.11",
+      "resolved": "https://registry.npmmirror.com/@types/node/-/node-22.19.11.tgz",
+      "integrity": "sha512-BH7YwL6rA93ReqeQS1c4bsPpcfOmJasG+Fkr6Y59q83f9M1WcBRHR2vM+P9eOisYRcN3ujQoiZY8uk5W+1WL8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmmirror.com/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/zod": {
+      "version": "4.3.6",
+      "resolved": "https://registry.npmmirror.com/zod/-/zod-4.3.6.tgz",
+      "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}