@kodelyth/codex 2026.5.40 → 2026.5.42

package/src/conversation-turn-input.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from "vitest";
+import { buildCodexConversationTurnInput } from "./conversation-turn-input.js";
+
+describe("codex conversation turn input", () => {
+  it("forwards inbound image attachments to Codex app-server", () => {
+    expect(
+      buildCodexConversationTurnInput({
+        prompt: "what is this?",
+        event: {
+          content: "what is this?",
+          channel: "telegram",
+          isGroup: false,
+          metadata: {
+            mediaPaths: ["/tmp/photo.png", "/tmp/readme.txt"],
+            mediaUrls: ["https://example.test/photo.png"],
+            mediaTypes: ["image/png", "text/plain"],
+          },
+        },
+      }),
+    ).toEqual([
+      { type: "text", text: "what is this?", text_elements: [] },
+      { type: "localImage", path: "/tmp/photo.png" },
+    ]);
+  });
+
+  it("uses remote image urls when no local path is available", () => {
+    expect(
+      buildCodexConversationTurnInput({
+        prompt: "look",
+        event: {
+          content: "look",
+          channel: "webchat",
+          isGroup: false,
+          metadata: {
+            mediaUrl: "https://example.test/photo.webp?sig=1",
+          },
+        },
+      }),
+    ).toEqual([
+      { type: "text", text: "look", text_elements: [] },
+      { type: "image", url: "https://example.test/photo.webp?sig=1" },
+    ]);
+  });
+
+  it("keeps protocol-relative image urls remote", () => {
+    expect(
+      buildCodexConversationTurnInput({
+        prompt: "look",
+        event: {
+          content: "look",
+          channel: "webchat",
+          isGroup: false,
+          metadata: {
+            mediaUrl: "//cdn.example.test/photo.webp",
+          },
+        },
+      }),
+    ).toEqual([
+      { type: "text", text: "look", text_elements: [] },
+      { type: "image", url: "//cdn.example.test/photo.webp" },
+    ]);
+  });
+
+  it("decodes local file URLs for Codex local image input", () => {
+    expect(
+      buildCodexConversationTurnInput({
+        prompt: "look",
+        event: {
+          content: "look",
+          channel: "webchat",
+          isGroup: false,
+          metadata: {
+            mediaPath: "file:///tmp/Klaw%20QA/photo.png",
+            mediaType: "image/png",
+          },
+        },
+      }),
+    ).toEqual([
+      { type: "text", text: "look", text_elements: [] },
+      { type: "localImage", path: "/tmp/Klaw QA/photo.png" },
+    ]);
+  });
+
+  it("drops malformed local file URLs instead of throwing", () => {
+    expect(
+      buildCodexConversationTurnInput({
+        prompt: "look",
+        event: {
+          content: "look",
+          channel: "webchat",
+          isGroup: false,
+          metadata: {
+            mediaPath: "file:///tmp/%zz/photo.png",
+            mediaType: "image/png",
+          },
+        },
+      }),
+    ).toEqual([{ type: "text", text: "look", text_elements: [] }]);
+  });
+
+  it("treats local media URLs as Codex local image input", () => {
+    expect(
+      buildCodexConversationTurnInput({
+        prompt: "look",
+        event: {
+          content: "look",
+          channel: "webchat",
+          isGroup: false,
+          metadata: {
+            mediaUrls: ["/tmp/staged-photo.png", "file:///tmp/Klaw%20QA/second.jpg"],
+            mediaTypes: ["image/png", "image/jpeg"],
+          },
+        },
+      }),
+    ).toEqual([
+      { type: "text", text: "look", text_elements: [] },
+      { type: "localImage", path: "/tmp/staged-photo.png" },
+      { type: "localImage", path: "/tmp/Klaw QA/second.jpg" },
+    ]);
+  });
+
+  it("treats Windows media paths as Codex local image input", () => {
+    expect(
+      buildCodexConversationTurnInput({
+        prompt: "look",
+        event: {
+          content: "look",
+          channel: "webchat",
+          isGroup: false,
+          metadata: {
+            mediaUrl: "C:\\Klaw QA\\photo.png",
+            mediaType: "image/png",
+          },
+        },
+      }),
+    ).toEqual([
+      { type: "text", text: "look", text_elements: [] },
+      { type: "localImage", path: "C:\\Klaw QA\\photo.png" },
+    ]);
+  });
+});

package/src/conversation-turn-input.ts

@@ -0,0 +1,106 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { PluginHookInboundClaimEvent } from "klaw/plugin-sdk/plugin-entry";
+import type { CodexUserInput } from "./app-server/protocol.js";
+
+type InboundMedia = {
+  path?: string;
+  url?: string;
+  mimeType?: string;
+};
+
+const IMAGE_EXTENSIONS = new Set([".avif", ".gif", ".jpeg", ".jpg", ".png", ".webp"]);
+
+export function buildCodexConversationTurnInput(params: {
+  prompt: string;
+  event: PluginHookInboundClaimEvent;
+}): CodexUserInput[] {
+  return [
+    { type: "text", text: params.prompt, text_elements: [] },
+    ...extractInboundMedia(params.event)
+      .map(toCodexImageInput)
+      .filter((item): item is CodexUserInput => item !== undefined),
+  ];
+}
+
+function extractInboundMedia(event: PluginHookInboundClaimEvent): InboundMedia[] {
+  const metadata = event.metadata ?? {};
+  // Klaw channels expose either local staged files or remote URLs. Keep
+  // them separate so Codex can receive the cheaper localImage input when a file
+  // is already present, while still supporting remote-only transports.
+  const paths = readStringArray(metadata.mediaPaths).concat(readStringArray(metadata.mediaPath));
+  const urls = readStringArray(metadata.mediaUrls).concat(readStringArray(metadata.mediaUrl));
+  const mimeTypes = readStringArray(metadata.mediaTypes).concat(
+    readStringArray(metadata.mediaType),
+  );
+  const count = Math.max(paths.length, urls.length, mimeTypes.length);
+  const media: InboundMedia[] = [];
+  for (let index = 0; index < count; index += 1) {
+    media.push({
+      path: paths[index],
+      url: urls[index],
+      mimeType: mimeTypes[index] ?? mimeTypes[0],
+    });
+  }
+  return media;
+}
+
+function toCodexImageInput(media: InboundMedia): CodexUserInput | undefined {
+  if (!isImageMedia(media)) {
+    return undefined;
+  }
+  const localPath = media.path ?? readLocalMediaPath(media.url);
+  if (localPath) {
+    const normalized = normalizeFileUrl(localPath);
+    return normalized ? { type: "localImage", path: normalized } : undefined;
+  }
+  return media.url ? { type: "image", url: media.url } : undefined;
+}
+
+function isImageMedia(media: InboundMedia): boolean {
+  if (media.mimeType?.toLowerCase().startsWith("image/")) {
+    return true;
+  }
+  const candidate = media.path ?? media.url;
+  if (!candidate) {
+    return false;
+  }
+  return IMAGE_EXTENSIONS.has(path.extname(candidate.split(/[?#]/, 1)[0] ?? "").toLowerCase());
+}
+
+function normalizeFileUrl(value: string): string | undefined {
+  if (!value.startsWith("file://")) {
+    return value;
+  }
+  try {
+    return fileURLToPath(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function readLocalMediaPath(value: string | undefined): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  if (value.startsWith("file://")) {
+    return value;
+  }
+  if (value.startsWith("//")) {
+    return undefined;
+  }
+  if (path.isAbsolute(value) || path.win32.isAbsolute(value)) {
+    return value;
+  }
+  return /^[a-z][a-z0-9+.-]*:/i.test(value) ? undefined : value;
+}
+
+function readStringArray(value: unknown): string[] {
+  if (typeof value === "string" && value.trim()) {
+    return [value.trim()];
+  }
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => (typeof entry === "string" ? entry.trim() : "")).filter(Boolean);
+}

package/src/manifest.test.ts

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+import { describe, expect, it } from "vitest";
+import { MANAGED_CODEX_APP_SERVER_PACKAGE_VERSION } from "./app-server/version.js";
+
+type CodexPackageManifest = {
+  dependencies?: Record<string, string>;
+};
+
+describe("codex package manifest", () => {
+  it("keeps runtime dependencies in the package manifest", () => {
+    const packageJson = JSON.parse(
+      fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+    ) as CodexPackageManifest;
+
+    expect(packageJson.dependencies).toHaveProperty("@earendil-works/pi-coding-agent");
+    expect(packageJson.dependencies?.["@openai/codex"]).toBe(
+      MANAGED_CODEX_APP_SERVER_PACKAGE_VERSION,
+    );
+  });
+});