@baique/pi-web-sky 0.1.35 → 0.1.37

package/lib/models-config-store.test.mjs

@@ -0,0 +1,200 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  normalizeModelsConfigCosts,
+  readModelsConfig,
+  writeModelsConfig,
+} = await jiti.import("./models-config-store.ts");
+const { invalidateModelsCache, loadModelsWithCache } = await jiti.import("./models-cache.ts");
+const { buildSessionContext, getSessionEntries } = await jiti.import("./session-reader.ts");
+
+function createTempRoot(t) {
+  const root = mkdtempSync(join(tmpdir(), "pi-web-models-config-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  return root;
+}
+
+function modelsData(id) {
+  return {
+    models: { [`provider:${id}`]: id },
+    modelList: [{ id, name: id, provider: "provider" }],
+    defaultModel: null,
+    thinkingLevels: {},
+    thinkingLevelMaps: {},
+    thinkingLevelPins: {},
+  };
+}
+
+test("saving models.json atomically invalidates the model-list cache", async (t) => {
+  const root = createTempRoot(t);
+  const modelsPath = join(root, "agent", "models.json");
+  const config = {
+    providers: {
+      acme: {
+        baseUrl: "https://models.example.test/v1",
+        api: "openai-completions",
+        models: [{ id: "acme-2" }],
+      },
+    },
+  };
+  let loads = 0;
+
+  invalidateModelsCache();
+  await loadModelsWithCache(root, async () => modelsData(`load-${++loads}`));
+  writeModelsConfig(config, modelsPath);
+  const reloaded = await loadModelsWithCache(root, async () => modelsData(`load-${++loads}`));
+
+  assert.equal(loads, 2);
+  assert.equal(reloaded.modelList[0].id, "load-2");
+  assert.deepEqual(readModelsConfig(modelsPath), config);
+  assert.deepEqual(readdirSync(join(root, "agent")), ["models.json"]);
+  if (process.platform !== "win32") {
+    assert.equal(statSync(modelsPath).mode & 0o777, 0o600);
+  }
+});
+
+test("models.json writes fill partial cost groups with zero and remove empty groups", (t) => {
+  const root = createTempRoot(t);
+  const modelsPath = join(root, "agent", "models.json");
+  const config = {
+    providers: {
+      acme: {
+        models: [
+          { id: "empty-cost", cost: {} },
+          { id: "partial-cost", cost: { input: 1, output: 2, cacheRead: 0.1 } },
+          { id: "complete-cost", cost: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 1.1 } },
+        ],
+        modelOverrides: {
+          inherited: { cost: { input: 3 } },
+        },
+      },
+    },
+  };
+
+  const normalized = normalizeModelsConfigCosts(config);
+  assert.deepEqual(normalized.providers.acme.models, [
+    { id: "empty-cost" },
+    { id: "partial-cost", cost: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 0 } },
+    { id: "complete-cost", cost: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 1.1 } },
+  ]);
+  assert.deepEqual(normalized.providers.acme.modelOverrides, {
+    inherited: { cost: { input: 3 } },
+  });
+  assert.deepEqual(config.providers.acme.models[0], { id: "empty-cost", cost: {} });
+
+  writeModelsConfig(config, modelsPath);
+  assert.deepEqual(readModelsConfig(modelsPath), normalized);
+});
+
+test("saving models.json drops blank model rows without hiding other schema errors", (t) => {
+  const root = createTempRoot(t);
+  const modelsPath = join(root, "agent", "models.json");
+
+  writeModelsConfig({
+    providers: {
+      acme: {
+        baseUrl: "https://models.example.test/v1",
+        api: "openai-completions",
+        models: [
+          { id: "working-model", cost: { input: 1 } },
+          { id: "" },
+          { id: "  " },
+          { id: 42 },
+          { name: "Missing identifier" },
+          null,
+        ],
+      },
+    },
+  }, modelsPath);
+
+  assert.deepEqual(readModelsConfig(modelsPath), {
+    providers: {
+      acme: {
+        baseUrl: "https://models.example.test/v1",
+        api: "openai-completions",
+        models: [
+          { id: "working-model", cost: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 } },
+          { id: 42 },
+          { name: "Missing identifier" },
+          null,
+        ],
+      },
+    },
+  });
+});
+
+test("an existing session opens after its historical model is removed from config", (t) => {
+  const root = createTempRoot(t);
+  const sessionPath = join(root, "session.jsonl");
+  const modelsPath = join(root, "models.json");
+  const records = [
+    {
+      type: "session",
+      version: 3,
+      id: "existing-session",
+      timestamp: "2026-01-01T00:00:00.000Z",
+      cwd: root,
+    },
+    {
+      type: "model_change",
+      id: "model-old",
+      parentId: null,
+      provider: "retired-provider",
+      modelId: "retired-model",
+      timestamp: "2026-01-01T00:00:01.000Z",
+    },
+    {
+      type: "message",
+      id: "user-1",
+      parentId: "model-old",
+      timestamp: "2026-01-01T00:00:02.000Z",
+      message: { role: "user", content: "keep this conversation" },
+    },
+    {
+      type: "message",
+      id: "assistant-1",
+      parentId: "user-1",
+      timestamp: "2026-01-01T00:00:03.000Z",
+      message: {
+        role: "assistant",
+        provider: "retired-provider",
+        model: "retired-model",
+        content: [{ type: "text", text: "still readable" }],
+      },
+    },
+  ];
+  writeFileSync(sessionPath, `${records.map((record) => JSON.stringify(record)).join("\n")}\n`);
+
+  writeModelsConfig({
+    providers: {
+      "retired-provider": {
+        baseUrl: "https://retired.example.test/v1",
+        api: "openai-completions",
+        models: [{ id: "retired-model" }],
+      },
+    },
+  }, modelsPath);
+  const beforeChange = buildSessionContext(getSessionEntries(sessionPath));
+  assert.equal(beforeChange.messages[1].content[0].text, "still readable");
+
+  writeModelsConfig({
+    providers: {
+      replacement: {
+        baseUrl: "https://replacement.example.test/v1",
+        api: "openai-completions",
+        models: [{ id: "replacement-model" }],
+      },
+    },
+  }, modelsPath);
+
+  const afterChange = buildSessionContext(getSessionEntries(sessionPath));
+  assert.deepEqual(afterChange.entryIds, ["user-1", "assistant-1"]);
+  assert.equal(afterChange.messages[0].content, "keep this conversation");
+  assert.equal(afterChange.messages[1].content[0].text, "still readable");
+});

package/lib/models-config-store.ts

@@ -0,0 +1,84 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { writePrivateFileAtomicSync } from "./atomic-file";
+import { invalidateModelsCache } from "./models-cache";
+
+const MODEL_COST_KEYS = ["input", "output", "cacheRead", "cacheWrite"] as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeModelCost(value: unknown): Record<string, unknown> | undefined {
+  if (!isRecord(value)) return undefined;
+  const providedKeys = MODEL_COST_KEYS.filter((key) => value[key] !== undefined);
+  if (providedKeys.length === 0) return undefined;
+  if (providedKeys.some((key) => (
+    typeof value[key] !== "number" || !Number.isFinite(value[key])
+  ))) return undefined;
+
+  return Object.fromEntries([
+    ...Object.entries(value),
+    ...MODEL_COST_KEYS.map((key) => [key, value[key] ?? 0]),
+  ]);
+}
+
+/** Complete partial cost groups with zero; omit a cost group only when it is empty. */
+export function normalizeModelsConfigCosts(
+  data: Record<string, unknown>,
+): Record<string, unknown> {
+  const normalized = structuredClone(data);
+  if (!isRecord(normalized.providers)) return normalized;
+
+  for (const provider of Object.values(normalized.providers)) {
+    if (!isRecord(provider) || !Array.isArray(provider.models)) continue;
+    for (const model of provider.models) {
+      if (!isRecord(model) || !("cost" in model)) continue;
+      const cost = normalizeModelCost(model.cost);
+      if (cost) model.cost = cost;
+      else delete model.cost;
+    }
+  }
+  return normalized;
+}
+
+function sanitizeModelsConfig(data: Record<string, unknown>): Record<string, unknown> {
+  if (!isRecord(data.providers)) return data;
+
+  const providers = Object.fromEntries(Object.entries(data.providers).map(([providerId, provider]) => {
+    if (!isRecord(provider) || !Array.isArray(provider.models)) return [providerId, provider];
+    const models = provider.models.filter((model) => (
+      !isRecord(model) || typeof model.id !== "string" || model.id.trim().length > 0
+    ));
+    return [providerId, { ...provider, models }];
+  }));
+
+  return { ...data, providers };
+}
+
+export function getModelsConfigPath(): string {
+  return join(getAgentDir(), "models.json");
+}
+
+export function readModelsConfig(
+  modelsPath = getModelsConfigPath(),
+): Record<string, unknown> {
+  if (!existsSync(modelsPath)) return { providers: {} };
+  try {
+    return JSON.parse(readFileSync(modelsPath, "utf8")) as Record<string, unknown>;
+  } catch {
+    return { providers: {} };
+  }
+}
+
+export function writeModelsConfig(
+  data: Record<string, unknown>,
+  modelsPath = getModelsConfigPath(),
+): void {
+  const dir = dirname(modelsPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const normalized = normalizeModelsConfigCosts(sanitizeModelsConfig(data));
+  writePrivateFileAtomicSync(modelsPath, JSON.stringify(normalized, null, 2));
+  invalidateModelsCache();
+}

package/lib/next-config-esm.test.mjs

@@ -0,0 +1,14 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+
+const configUrl = new URL("../next.config.ts", import.meta.url);
+const source = await readFile(configUrl, "utf8");
+
+test("resolves config paths without CommonJS globals", async () => {
+  assert.doesNotMatch(source, /\b__dirname\b/);
+  assert.match(source, /dirname\(fileURLToPath\(import\.meta\.url\)\)/);
+
+  const config = await import(`${configUrl.href}?esm-test`);
+  assert.equal(typeof config.default.env.NEXT_PUBLIC_APP_VERSION, "string");
+});

package/lib/next-config.test.mjs

@@ -0,0 +1,13 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { createJiti } from "jiti";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+test("scopes Next.js output file tracing to the pi-web package", async () => {
+  const config = await createJiti(import.meta.url).import("../next.config.ts", { default: true });
+
+  assert.equal(config.outputFileTracingRoot, projectRoot);
+});

package/lib/node-version.test.mjs

@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import test from "node:test";
+
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+const {
+  MIN_NODE_VERSION,
+  getUnsupportedNodeVersionMessage,
+  isNodeVersionSupported,
+} = require("../bin/node-version.js");
+
+test("accepts the minimum supported Node.js version and newer versions", () => {
+  for (const version of ["22.19.0", "v22.19.0", "22.19.1", "23.0.0"]) {
+    assert.equal(isNodeVersionSupported(version), true, version);
+  }
+});
+
+test("rejects older and invalid Node.js versions", () => {
+  for (const version of ["20.19.5", "22.18.99", "invalid"]) {
+    assert.equal(isNodeVersionSupported(version), false, version);
+  }
+});
+
+test("keeps the package engine aligned with the startup check", () => {
+  assert.equal(packageJson.engines.node, `>=${MIN_NODE_VERSION}`);
+});
+
+test("reports both the required and current Node.js versions", () => {
+  const message = getUnsupportedNodeVersionMessage("20.19.5");
+  assert.match(message, /requires Node\.js 22\.19\.0 or newer/);
+  assert.match(message, /Current Node\.js version: 20\.19\.5/);
+});

package/lib/normalize.test.mjs

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  normalizeStreamingToolCalls,
+  normalizeToolCalls,
+} = await jiti.import("./normalize.ts");
+
+function assistant(block) {
+  return {
+    role: "assistant",
+    provider: "anthropic",
+    model: "claude-test",
+    content: [block],
+  };
+}
+
+test("keeps SDK scratch input only for an in-flight snapshot", () => {
+  const message = assistant({
+    type: "toolCall",
+    id: "call-1",
+    name: "write",
+    arguments: { path: "/tmp/file" },
+    partialJson: '{"path":"/tmp/file","content":"hel',
+  });
+
+  assert.deepEqual(normalizeStreamingToolCalls(message).content[0], {
+    type: "toolCall",
+    toolCallId: "call-1",
+    toolName: "write",
+    input: { path: "/tmp/file" },
+    rawInput: '{"path":"/tmp/file","content":"hel',
+  });
+  assert.deepEqual(normalizeToolCalls(message).content[0], {
+    type: "toolCall",
+    toolCallId: "call-1",
+    toolName: "write",
+    input: { path: "/tmp/file" },
+  });
+});
+
+test("removes a client raw buffer when normalizing a completed message", () => {
+  const message = assistant({
+    type: "toolCall",
+    toolCallId: "call-2",
+    toolName: "write",
+    input: { path: "/tmp/file", content: "complete" },
+    rawInput: "temporary",
+  });
+
+  assert.equal(Object.hasOwn(normalizeToolCalls(message).content[0], "rawInput"), false);
+});

package/lib/normalize.ts

@@ -0,0 +1,63 @@
+import type { AgentMessage, AssistantMessage, ToolCallContent } from "./types";
+
+function isObject(val: unknown): val is Record<string, unknown> {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+
+function streamingRawInput(block: Record<string, unknown>): string | undefined {
+  if (typeof block.rawInput === "string") return block.rawInput;
+  if (typeof block.partialJson === "string") return block.partialJson;
+  if (typeof block.partialArgs === "string") return block.partialArgs;
+
+  const customInput = isObject(block.customInput) ? block.customInput : null;
+  const property = customInput && typeof customInput.property === "string"
+    ? customInput.property
+    : null;
+  const args = isObject(block.arguments) ? block.arguments : null;
+  return property && args && typeof args[property] === "string"
+    ? args[property]
+    : undefined;
+}
+
+function normalizeToolCallBlock(
+  block: unknown,
+  options: { includeStreamingRawInput?: boolean } = {},
+): ToolCallContent | null {
+  if (!isObject(block) || block.type !== "toolCall") return null;
+  const normalized: ToolCallContent = {
+    type: "toolCall",
+    toolCallId: typeof block.toolCallId === "string" ? block.toolCallId : (typeof block.id === "string" ? block.id : ""),
+    toolName: typeof block.toolName === "string" ? block.toolName : (typeof block.name === "string" ? block.name : ""),
+    input: typeof block.input === "object" && block.input !== null && !Array.isArray(block.input)
+      ? block.input as Record<string, unknown>
+      : (typeof block.arguments === "object" && block.arguments !== null && !Array.isArray(block.arguments)
+        ? block.arguments as Record<string, unknown>
+        : {}),
+  };
+  const rawInput = options.includeStreamingRawInput ? streamingRawInput(block) : undefined;
+  return rawInput === undefined ? normalized : { ...normalized, rawInput };
+}
+
+function normalizeAssistantToolCalls(
+  msg: AgentMessage,
+  options: { includeStreamingRawInput?: boolean } = {},
+): AgentMessage {
+  // Non-assistant roles (user, toolResult, bashExecution, custom) are returned
+  // unchanged — only assistant messages go through tool-call field normalization.
+  if (msg.role !== "assistant") return msg;
+  const content = (msg as AssistantMessage).content;
+  if (!Array.isArray(content)) return msg;
+  const normalized = content.map((block) => {
+    const result = normalizeToolCallBlock(block, options);
+    return result ?? block;
+  });
+  return { ...msg, content: normalized } as AgentMessage;
+}
+
+export function normalizeToolCalls(msg: AgentMessage): AgentMessage {
+  return normalizeAssistantToolCalls(msg);
+}
+
+export function normalizeStreamingToolCalls(msg: AgentMessage): AgentMessage {
+  return normalizeAssistantToolCalls(msg, { includeStreamingRawInput: true });
+}

package/lib/npx.ts

@@ -0,0 +1,62 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { execPath } from "process";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Locate `npx-cli.js` shipped with the running Node.js installation.
+ *
+ * On Windows the `npx` on PATH is actually `npx.cmd`, which Node.js (since
+ * 20.12 due to CVE-2024-27980) refuses to spawn from `execFile`/`spawn`
+ * without `shell: true`. Going through a shell reintroduces quoting bugs for
+ * user-supplied args. Instead we find the real `npx-cli.js` and invoke it
+ * directly via the current `node` binary, which works identically on every
+ * platform and needs no shell.
+ */
+function findNpxCli(): string | null {
+  const nodeDir = dirname(execPath);
+  const candidates = [
+    // Windows MSI installer layout: node.exe and node_modules share a dir
+    join(nodeDir, "node_modules", "npm", "bin", "npx-cli.js"),
+    // Unix layout: .../bin/node + .../lib/node_modules/npm/bin/npx-cli.js
+    join(nodeDir, "..", "lib", "node_modules", "npm", "bin", "npx-cli.js"),
+  ];
+  for (const p of candidates) {
+    try {
+      if (existsSync(p)) return p;
+    } catch {
+      // ignore
+    }
+  }
+  return null;
+}
+
+export interface RunNpxOptions {
+  timeout?: number;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface RunNpxResult {
+  stdout: string;
+  stderr: string;
+}
+
+/**
+ * Cross-platform wrapper for invoking `npx <args>` without ever using a
+ * shell, so user-controlled arguments are never interpreted as shell syntax.
+ */
+export async function runNpx(args: string[], opts: RunNpxOptions = {}): Promise<RunNpxResult> {
+  const npxCli = findNpxCli();
+  const { command, commandArgs } = npxCli
+    ? { command: execPath, commandArgs: [npxCli, ...args] }
+    : { command: "npx", commandArgs: args };
+  return execFileAsync(command, commandArgs, {
+    timeout: opts.timeout,
+    cwd: opts.cwd,
+    env: opts.env,
+  });
+}

package/lib/panel-layout.test.mjs

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  clampPanelWidth,
+  getDefaultRightPanelWidth,
+  getRightPanelMaxWidth,
+  getSidebarMaxWidth,
+} = await jiti.import("./panel-layout.ts");
+
+test("clamps panel widths to finite bounds", () => {
+  assert.equal(clampPanelWidth(420.4, 180, 480), 420);
+  assert.equal(clampPanelWidth(120, 180, 480), 180);
+  assert.equal(clampPanelWidth(600, 180, 480), 480);
+  assert.equal(clampPanelWidth(Number.NaN, 180, 480), 180);
+  assert.equal(clampPanelWidth(200, 300, 250), 300);
+});
+
+test("keeps the responsive right panel default within useful limits", () => {
+  assert.equal(getDefaultRightPanelWidth(700), 360);
+  assert.equal(getDefaultRightPanelWidth(1366), 574);
+  assert.equal(getDefaultRightPanelWidth(1920), 640);
+});
+
+test("reserves chat space while split panels are visible", () => {
+  assert.equal(getSidebarMaxWidth({
+    viewportWidth: 700,
+    rightPanelOpen: true,
+    rightPanelWidth: 560,
+  }), 380);
+  assert.equal(getSidebarMaxWidth({
+    viewportWidth: 1366,
+    rightPanelOpen: true,
+    rightPanelWidth: 686,
+  }), 260);
+  assert.equal(getRightPanelMaxWidth({
+    viewportWidth: 1024,
+    sidebarOpen: true,
+    sidebarWidth: 260,
+  }), 344);
+  assert.equal(getRightPanelMaxWidth({
+    viewportWidth: 1366,
+    sidebarOpen: true,
+    sidebarWidth: 260,
+  }), 686);
+});
+
+test("does not rewrite desktop widths while the file panel is in overlay mode", () => {
+  assert.equal(getRightPanelMaxWidth({
+    viewportWidth: 900,
+    sidebarOpen: true,
+    sidebarWidth: 480,
+  }), 1200);
+});

package/lib/panel-layout.ts

@@ -0,0 +1,52 @@
+export const MOBILE_MAX_WIDTH = 640;
+export const SPLIT_PANEL_MIN_WIDTH = 960;
+
+export const SIDEBAR_DEFAULT_WIDTH = 260;
+export const SIDEBAR_MIN_WIDTH = 180;
+export const SIDEBAR_MAX_WIDTH = 480;
+
+export const RIGHT_PANEL_FALLBACK_WIDTH = 560;
+export const RIGHT_PANEL_MIN_WIDTH = 300;
+export const RIGHT_PANEL_MAX_WIDTH = 1200;
+
+const COMPACT_CHAT_MIN_WIDTH = 320;
+const DESKTOP_CHAT_MIN_WIDTH = 420;
+
+export function clampPanelWidth(width: number, minWidth: number, maxWidth: number): number {
+  const finiteWidth = Number.isFinite(width) ? width : minWidth;
+  const effectiveMax = Math.max(minWidth, maxWidth);
+  return Math.round(Math.max(minWidth, Math.min(effectiveMax, finiteWidth)));
+}
+
+export function getDefaultRightPanelWidth(viewportWidth: number): number {
+  return clampPanelWidth(viewportWidth * 0.42, 360, 640);
+}
+
+export function getSidebarMaxWidth(options: {
+  viewportWidth: number;
+  rightPanelOpen: boolean;
+  rightPanelWidth: number;
+}): number {
+  const { viewportWidth, rightPanelOpen, rightPanelWidth } = options;
+  if (viewportWidth <= MOBILE_MAX_WIDTH) return SIDEBAR_MAX_WIDTH;
+
+  const compact = viewportWidth < SPLIT_PANEL_MIN_WIDTH;
+  const chatWidth = compact ? COMPACT_CHAT_MIN_WIDTH : DESKTOP_CHAT_MIN_WIDTH;
+  const visibleRightPanelWidth = !compact && rightPanelOpen ? rightPanelWidth : 0;
+  return Math.min(SIDEBAR_MAX_WIDTH, viewportWidth - chatWidth - visibleRightPanelWidth);
+}
+
+export function getRightPanelMaxWidth(options: {
+  viewportWidth: number;
+  sidebarOpen: boolean;
+  sidebarWidth: number;
+}): number {
+  const { viewportWidth, sidebarOpen, sidebarWidth } = options;
+  if (viewportWidth < SPLIT_PANEL_MIN_WIDTH) return RIGHT_PANEL_MAX_WIDTH;
+
+  const visibleSidebarWidth = sidebarOpen ? sidebarWidth : 0;
+  return Math.min(
+    RIGHT_PANEL_MAX_WIDTH,
+    viewportWidth - DESKTOP_CHAT_MIN_WIDTH - visibleSidebarWidth,
+  );
+}