pi-openai-codex-compat 0.0.16 → 0.0.17

package/extensions/settings-session.ts

@@ -0,0 +1,130 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { SettingsField } from "./settings-menu.ts";
+import {
+  observedSetting,
+  type SettingsSessionState,
+  type SettingValue,
+  type SettingValues,
+} from "./settings-store.ts";
+
+export type SettingsSessionContext = {
+  sessionManager: Pick<ExtensionContext["sessionManager"], "getSessionId" | "getEntries">;
+};
+
+function object(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function valid(field: SettingsField, value: unknown): value is SettingValue {
+  if (field.choices.some((choice) => choice === value)) return true;
+  const rule = field.number;
+  return Boolean(
+    rule &&
+    typeof value === "number" &&
+    Number.isFinite(value) &&
+    (!rule.integer || Number.isInteger(value)) &&
+    (rule.exclusiveMin ? value > rule.min : value >= rule.min) &&
+    value <= rule.max,
+  );
+}
+
+/** Session-wide preferences deliberately ignore tree position and copied fork entries. */
+export function readSessionSettings(
+  ctx: SettingsSessionContext,
+  customType: string,
+  fields: SettingsField[],
+): { values: SettingValues; session: SettingsSessionState } {
+  const entries = ctx.sessionManager.getEntries();
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (entry?.type !== "custom" || entry.customType !== customType) continue;
+    const data: unknown = entry.data;
+    if (
+      object(data) &&
+      typeof data["sessionId"] === "string" &&
+      data["sessionId"] !== ctx.sessionManager.getSessionId()
+    )
+      continue;
+    const fail = () => {
+      throw new Error(`Invalid saved session settings (${customType}).`);
+    };
+    if (
+      !object(data) ||
+      data["sessionId"] !== ctx.sessionManager.getSessionId() ||
+      data["version"] !== 1 ||
+      !object(data["values"]) ||
+      !object(data["changes"]) ||
+      !object(data["observed"])
+    )
+      return fail();
+    const values: SettingValues = {};
+    const session: SettingsSessionState = { changes: {} };
+    for (const [id, value] of Object.entries(data["values"])) {
+      const field = fields.find((candidate) => candidate.id === id);
+      if (!field || !valid(field, value)) return fail();
+      values[id] = value;
+    }
+    const observed: Record<string, [string, string]> = {};
+    for (const [id, change] of Object.entries(data["changes"])) {
+      const field = fields.find((candidate) => candidate.id === id);
+      if (!field || !Array.isArray(change) || change.length > 1 || !Object.hasOwn(values, id))
+        return fail();
+      const value: unknown = change[0];
+      if (change.length === 0) session.changes[id] = undefined;
+      else if (valid(field, value)) session.changes[id] = value;
+      else return fail();
+      const hashes = data["observed"][id];
+      if (!Array.isArray(hashes) || hashes.length !== 2) return fail();
+      const global: unknown = hashes[0];
+      const project: unknown = hashes[1];
+      if (
+        typeof global !== "string" ||
+        typeof project !== "string" ||
+        !/^[a-f0-9]{64}$/.test(global) ||
+        !/^[a-f0-9]{64}$/.test(project)
+      )
+        return fail();
+      observed[id] = [global, project];
+    }
+    if (Object.keys(session.changes).length) {
+      if (typeof data["file"] !== "string") return fail();
+      session.baseline = {
+        file: data["file"],
+        observed,
+        values: {},
+        inherited: {},
+        sources: {},
+        global: { text: undefined, data: {} },
+        project: { text: undefined, data: {} },
+      };
+    }
+    return { values, session };
+  }
+  return { values: {}, session: { changes: {} } };
+}
+
+/** Store only known preferences and conflict hashes, never raw configuration documents. */
+export function sessionSettingsEntry(
+  sessionId: string,
+  values: SettingValues,
+  session: SettingsSessionState,
+  locked: Record<string, string>,
+) {
+  const writable = Object.entries(values).filter(([id]) => !locked[id]);
+  const changes = Object.entries(session.changes).filter(([id]) => !locked[id]);
+  return {
+    version: 1,
+    sessionId,
+    values: Object.fromEntries(writable),
+    changes: Object.fromEntries(
+      changes.map(([id, value]) => [id, value === undefined ? [] : [value]]),
+    ),
+    file: session.baseline?.file,
+    observed: Object.fromEntries(
+      changes.map(([id]) => {
+        if (!session.baseline) throw new Error("Missing session settings conflict baseline.");
+        return [id, observedSetting(session.baseline, id)];
+      }),
+    ),
+  };
+}

package/extensions/settings-store.ts

@@ -0,0 +1,240 @@
+import { mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+
+// Keep this provider-independent contract aligned with pi-anthropic-compat.
+export type SettingValue = string | number | boolean | null;
+export type SettingValues = Record<string, SettingValue>;
+export type SettingChanges = Record<string, SettingValue | undefined>;
+type Document = Record<string, unknown>;
+type FileState = { text: string | undefined; data: Document };
+function isDocument(value: unknown): value is Document {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export type SettingsSnapshot = {
+  file: string;
+  values: SettingValues;
+  inherited: SettingValues;
+  sources: Record<string, string>;
+  global: FileState;
+  project: FileState;
+  observed?: Record<string, [string, string]>;
+};
+export type SettingsSessionState = {
+  changes: SettingChanges;
+  baseline?: SettingsSnapshot;
+};
+export function observedSetting(snapshot: SettingsSnapshot, id: string): [string, string] {
+  return (
+    snapshot.observed?.[id] ?? [
+      createHash("sha256")
+        .update(JSON.stringify(snapshot.global.data[id]) ?? "undefined")
+        .digest("hex"),
+      createHash("sha256")
+        .update(JSON.stringify(snapshot.project.data[id]) ?? "undefined")
+        .digest("hex"),
+    ]
+  );
+}
+
+/** Retain conflict evidence for session overrides across menu reopenings. */
+export function sessionBaseline(
+  snapshot: SettingsSnapshot,
+  session: SettingsSessionState,
+): SettingsSnapshot {
+  const baseline = session.baseline;
+  if (!baseline) return snapshot;
+  return {
+    ...snapshot,
+    file: baseline.file,
+    observed: Object.fromEntries(
+      Object.keys(session.changes).map((id) => [id, observedSetting(baseline, id)]),
+    ),
+  };
+}
+
+async function read(file: string): Promise<FileState> {
+  let text: string;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { text: undefined, data: {} };
+    }
+    throw new Error(`Cannot read ${file}. Check file permissions.`, { cause: error });
+  }
+  try {
+    const data: unknown = JSON.parse(text);
+    if (!isDocument(data)) throw new Error("Expected an object.");
+    return { text, data };
+  } catch (error) {
+    throw new Error(`Invalid settings in ${file}. Fix the JSON object and reopen the menu.`, {
+      cause: error,
+    });
+  }
+}
+
+export class SettingsStore {
+  readonly globalFile: string;
+  readonly projectFile: string | undefined;
+  readonly resolve: (global: Document, project: Document) => SettingValues;
+  readonly locked: Record<string, string>;
+  readonly normalize: (data: Document) => Document;
+  constructor(
+    globalFile: string,
+    projectFile: string | undefined,
+    resolve: (global: Document, project: Document) => SettingValues,
+    locked: Record<string, string> = {},
+    normalize: (data: Document) => Document = (data) => data,
+  ) {
+    this.globalFile = globalFile;
+    this.projectFile = projectFile;
+    this.resolve = resolve;
+    this.locked = locked;
+    this.normalize = normalize;
+  }
+
+  async load(): Promise<SettingsSnapshot> {
+    const global = await read(this.globalFile);
+    const project = this.projectFile ? await read(this.projectFile) : { text: undefined, data: {} };
+    const isProject = this.projectFile !== undefined && project.text !== undefined;
+    const globalData = this.normalize(global.data);
+    const projectData = this.normalize(project.data);
+    const values = this.resolve(global.data, project.data);
+    const inherited = this.resolve(isProject ? global.data : {}, {});
+    const sources: Record<string, string> = {};
+    for (const id of Object.keys(values)) {
+      sources[id] = this.locked[id]
+        ? `locked by ${this.locked[id]}`
+        : Object.hasOwn(projectData, id)
+          ? "project"
+          : Object.hasOwn(globalData, id)
+            ? "global"
+            : "default";
+    }
+    return {
+      file: isProject && this.projectFile ? this.projectFile : this.globalFile,
+      values,
+      inherited,
+      sources,
+      global,
+      project,
+    };
+  }
+
+  async save(
+    baseline: SettingsSnapshot,
+    changes: SettingChanges,
+    signal: AbortSignal,
+    guard: (values: SettingValues) => void,
+  ): Promise<SettingsSnapshot> {
+    const keys = Object.keys(changes);
+    if (keys.length === 0) return baseline;
+    if (baseline.file !== this.globalFile && baseline.file !== this.projectFile) {
+      throw new Error("The settings scope changed. Review the configuration before saving.");
+    }
+    if (keys.some((id) => this.locked[id])) throw new Error("Environment settings are locked.");
+    await mkdir(dirname(baseline.file), { recursive: true });
+    const lockPath = `${baseline.file}.settings-lock`;
+    let lock;
+    for (let attempt = 0; attempt < 40; attempt++) {
+      signal.throwIfAborted();
+      try {
+        lock = await open(lockPath, "wx", 0o600);
+        break;
+      } catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") throw error;
+        await setTimeout(50, undefined, { signal });
+      }
+    }
+    if (!lock) {
+      throw new Error(
+        `Settings are locked at ${lockPath}. Wait for the other writer or review the stale lock.`,
+      );
+    }
+    const temporary = `${baseline.file}.${randomUUID()}.tmp`;
+    let temporaryCreated = false;
+    try {
+      const current = await this.load();
+      if (current.file !== baseline.file) {
+        throw new Error("The settings scope changed. Reopen the menu to review the save target.");
+      }
+      for (const id of keys) {
+        if (
+          JSON.stringify(observedSetting(current, id)) !==
+          JSON.stringify(observedSetting(baseline, id))
+        ) {
+          throw new Error(`Setting ${id} changed on disk. Reopen the menu to review it.`);
+        }
+      }
+      const isProject = current.file !== this.globalFile;
+      const target = isProject ? current.project : current.global;
+      const data = { ...target.data };
+      for (const id of keys) {
+        if (changes[id] === undefined) delete data[id];
+        else data[id] = changes[id];
+      }
+      const values = this.resolve(
+        isProject ? current.global.data : data,
+        isProject ? data : current.project.data,
+      );
+      guard(values);
+      signal.throwIfAborted();
+      const mode = await stat(current.file).then(
+        (metadata) => metadata.mode & 0o777,
+        (error: unknown) => {
+          if (error instanceof Error && "code" in error && error.code === "ENOENT") return 0o600;
+          throw error;
+        },
+      );
+      await open(temporary, "wx", mode).then(async (handle) => {
+        temporaryCreated = true;
+        try {
+          await handle.writeFile(`${JSON.stringify(data, null, 2)}\n`);
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
+      });
+      const verified = await this.load();
+      if (
+        verified.file !== current.file ||
+        verified.global.text !== current.global.text ||
+        verified.project.text !== current.project.text
+      ) {
+        throw new Error("Settings changed while saving. Reopen the menu to review them.");
+      }
+      signal.throwIfAborted();
+      guard(values);
+      await rename(temporary, current.file);
+      temporaryCreated = false;
+      const saved = { text: `${JSON.stringify(data, null, 2)}\n`, data };
+      return {
+        ...current,
+        values,
+        sources: {
+          ...current.sources,
+          ...Object.fromEntries(
+            keys.map((id) => [
+              id,
+              changes[id] === undefined
+                ? isProject && Object.hasOwn(this.normalize(current.global.data), id)
+                  ? "global"
+                  : "default"
+                : isProject
+                  ? "project"
+                  : "global",
+            ]),
+          ),
+        },
+        global: isProject ? current.global : saved,
+        project: isProject ? saved : current.project,
+      };
+    } finally {
+      if (temporaryCreated) await unlink(temporary);
+      await lock.close();
+      await unlink(lockPath);
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"