opencandle 0.11.1 → 0.12.0

package/src/pi/session-action-dedupe.ts

@@ -1,155 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { type SessionLockScopeSource, writerLockScopeForSession } from "./session-writer-lock.js";
-
-interface AcceptedActionStore {
-  acceptedActionIds: string[];
-  pendingActions: PendingActionRecord[];
-}
-
-interface PendingActionRecord {
-  id: string;
-  pendingAtMs: number;
-}
-
-const pendingSessionActionTtlMs = 2 * 60 * 1000;
-
-export function hasAcceptedSessionAction(
-  sessionManager: SessionLockScopeSource,
-  actionId: string,
-): boolean {
-  const normalizedActionId = actionId.trim();
-  if (!normalizedActionId) return false;
-  return readAcceptedActionStore(sessionManager).acceptedActionIds.includes(normalizedActionId);
-}
-
-export function hasPendingSessionAction(
-  sessionManager: SessionLockScopeSource,
-  actionId: string,
-): boolean {
-  const normalizedActionId = actionId.trim();
-  if (!normalizedActionId) return false;
-  return readAcceptedActionStore(sessionManager).pendingActions.some(
-    (record) => record.id === normalizedActionId,
-  );
-}
-
-export function recordPendingSessionAction(
-  sessionManager: SessionLockScopeSource,
-  actionId: string,
-): void {
-  const normalizedActionId = actionId.trim();
-  if (!normalizedActionId || hasAcceptedSessionAction(sessionManager, normalizedActionId)) return;
-  const storePath = acceptedActionStorePath(sessionManager);
-  if (!storePath) return;
-  const store = readAcceptedActionStore(sessionManager);
-  if (store.pendingActions.some((record) => record.id === normalizedActionId)) return;
-  writeAcceptedActionStore(storePath, {
-    acceptedActionIds: store.acceptedActionIds,
-    pendingActions: [
-      ...store.pendingActions.slice(-499),
-      { id: normalizedActionId, pendingAtMs: Date.now() },
-    ],
-  });
-}
-
-export function clearPendingSessionAction(
-  sessionManager: SessionLockScopeSource,
-  actionId: string,
-): void {
-  const normalizedActionId = actionId.trim();
-  if (!normalizedActionId) return;
-  const storePath = acceptedActionStorePath(sessionManager);
-  if (!storePath) return;
-  const store = readAcceptedActionStore(sessionManager);
-  if (!store.pendingActions.some((record) => record.id === normalizedActionId)) return;
-  writeAcceptedActionStore(storePath, {
-    acceptedActionIds: store.acceptedActionIds,
-    pendingActions: store.pendingActions.filter((record) => record.id !== normalizedActionId),
-  });
-}
-
-export function recordAcceptedSessionAction(
-  sessionManager: SessionLockScopeSource,
-  actionId: string,
-): void {
-  const normalizedActionId = actionId.trim();
-  if (!normalizedActionId) return;
-  const storePath = acceptedActionStorePath(sessionManager);
-  if (!storePath) return;
-  const store = readAcceptedActionStore(sessionManager);
-  if (store.acceptedActionIds.includes(normalizedActionId)) return;
-  writeAcceptedActionStore(storePath, {
-    acceptedActionIds: [...store.acceptedActionIds.slice(-499), normalizedActionId],
-    pendingActions: store.pendingActions.filter((record) => record.id !== normalizedActionId),
-  });
-}
-
-function readAcceptedActionStore(sessionManager: SessionLockScopeSource): AcceptedActionStore {
-  try {
-    const storePath = acceptedActionStorePath(sessionManager);
-    if (!storePath) return { acceptedActionIds: [], pendingActions: [] };
-    const parsed = JSON.parse(readFileSync(storePath, "utf8")) as {
-      acceptedActionIds?: unknown;
-      pendingActionIds?: unknown;
-    };
-    const pendingRecords = readPendingActionRecords(parsed.pendingActionIds);
-    const acceptedActionIds = Array.isArray(parsed.acceptedActionIds)
-      ? parsed.acceptedActionIds.filter((id): id is string => typeof id === "string")
-      : [];
-    return {
-      acceptedActionIds,
-      pendingActions: pendingRecords.activeRecords,
-    };
-  } catch {
-    return { acceptedActionIds: [], pendingActions: [] };
-  }
-}
-
-function writeAcceptedActionStore(storePath: string, store: AcceptedActionStore): void {
-  mkdirSync(dirname(storePath), { recursive: true });
-  writeFileSync(
-    storePath,
-    JSON.stringify(
-      {
-        acceptedActionIds: store.acceptedActionIds,
-        pendingActionIds: store.pendingActions,
-      },
-      null,
-      2,
-    ),
-    { mode: 0o600 },
-  );
-}
-
-function readPendingActionRecords(value: unknown): {
-  activeRecords: PendingActionRecord[];
-} {
-  if (!Array.isArray(value)) return { activeRecords: [] };
-  const now = Date.now();
-  const activeRecords: PendingActionRecord[] = [];
-  for (const entry of value) {
-    const record = (() => {
-      if (typeof entry === "string") return null;
-      if (!entry || typeof entry !== "object") return null;
-      const pending = entry as { id?: unknown; pendingAtMs?: unknown };
-      if (typeof pending.id !== "string" || typeof pending.pendingAtMs !== "number") return null;
-      return { id: pending.id, pendingAtMs: pending.pendingAtMs };
-    })();
-    if (!record) continue;
-    if (now - record.pendingAtMs <= pendingSessionActionTtlMs) activeRecords.push(record);
-  }
-  return { activeRecords };
-}
-
-function acceptedActionStorePath(sessionManager: SessionLockScopeSource): string {
-  let scope: string;
-  try {
-    scope = writerLockScopeForSession(sessionManager);
-  } catch {
-    return "";
-  }
-  return scope.endsWith(".jsonl")
-    ? `${scope}.accepted-actions.json`
-    : join(scope, "accepted-actions.json");
-}

package/src/pi/session-storage.ts

@@ -1,5 +0,0 @@
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-
-export function continueOpenCandleSession(cwd: string, sessionDir?: string): SessionManager {
-  return SessionManager.continueRecent(cwd, sessionDir);
-}

package/src/pi/session-writer-lock.ts

@@ -1,426 +0,0 @@
-import {
-  closeSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
-
-export type ProcessKind = "tui" | "gui";
-
-export interface WriterLock {
-  pid: number;
-  processKind: ProcessKind;
-  acquiredAt: string;
-  lastHeartbeat: string;
-  protocolVersion?: number;
-  scope?: string;
-  ownerId?: string;
-  coordinatorEndpoint?: string;
-  coordinatorSecret?: string;
-  recoveryState?: "ambiguous" | "live";
-}
-
-export interface AcquireOptions {
-  pid?: number;
-  ownerId?: string;
-  coordinatorEndpoint?: string;
-  coordinatorSecret?: string;
-  staleGraceMs?: number;
-  now?: () => Date;
-  isPidAlive?: (pid: number) => boolean;
-}
-
-export type AcquireResult =
-  | { role: "writer"; lock: WriterLock }
-  | { role: "follower"; lock: WriterLock };
-
-export interface SessionLockScopeSource {
-  getSessionFile(): string | undefined;
-  getSessionDir(): string;
-}
-
-const DEFAULT_STALE_GRACE_MS = 15_000;
-const WRITER_LOCK_PROTOCOL_VERSION = 1;
-const PROCESS_STARTED_AT = new Date(Date.now() - process.uptime() * 1000).toISOString();
-const PENDING_SESSION_ACTION_TTL_MS = 2 * 60 * 1000;
-
-export async function acquireWriterLock(
-  scopePath: string,
-  processKind: ProcessKind,
-  options: AcquireOptions = {},
-): Promise<AcquireResult> {
-  mkdirSync(dirname(lockPath(scopePath)), { recursive: true });
-  const identity = lockIdentity(options);
-  const staleGraceMs = options.staleGraceMs ?? DEFAULT_STALE_GRACE_MS;
-  const pidAlive = options.isPidAlive ?? isPidAlive;
-  const now = options.now ?? (() => new Date());
-
-  const created = tryCreate(scopePath, processKind, identity, now);
-  if (created) return { role: "writer", lock: created };
-
-  const existing = readWriterLock(scopePath);
-  if (existing) {
-    const status = classifyLock(existing, staleGraceMs, pidAlive);
-    if (status !== "recoverable")
-      return { role: "follower", lock: withRecoveryState(existing, status) };
-  }
-
-  await sleep(staleGraceMs);
-  const afterGrace = readWriterLock(scopePath);
-  if (afterGrace) {
-    const status = classifyLock(afterGrace, staleGraceMs, pidAlive);
-    if (status !== "recoverable") {
-      return { role: "follower", lock: withRecoveryState(afterGrace, status) };
-    }
-  }
-
-  try {
-    unlinkSync(lockPath(scopePath));
-  } catch {
-    // Missing or concurrently removed is fine; the next create decides ownership.
-  }
-
-  const recovered = tryCreate(scopePath, processKind, identity, now);
-  if (recovered) return { role: "writer", lock: recovered };
-
-  const current = readWriterLock(scopePath) ?? afterGrace ?? existing;
-  if (!current) throw new Error("Unable to determine active writer lock");
-  return { role: "follower", lock: current };
-}
-
-export function readWriterLock(scopePath: string): WriterLock | null {
-  try {
-    return JSON.parse(readFileSync(lockPath(scopePath), "utf8")) as WriterLock;
-  } catch {
-    return null;
-  }
-}
-
-export function refreshWriterLock(
-  scopePath: string,
-  holder: number | { pid?: number; ownerId?: string; now?: () => Date } = process.pid,
-): void {
-  const identity =
-    typeof holder === "number"
-      ? { pid: holder, ownerId: holder === process.pid ? defaultOwnerId(holder) : undefined }
-      : { pid: holder.pid ?? process.pid, ownerId: holder.ownerId, now: holder.now };
-  const lock = readWriterLock(scopePath);
-  if (!lock || !isSameLockOwner(lock, identity)) return;
-  writeFileSync(
-    lockPath(scopePath),
-    JSON.stringify(
-      { ...lock, lastHeartbeat: (identity.now?.() ?? new Date()).toISOString() },
-      null,
-      2,
-    ),
-  );
-}
-
-export function releaseWriterLock(
-  scopePath: string,
-  holder: number | { pid?: number; ownerId?: string } = process.pid,
-): void {
-  const identity =
-    typeof holder === "number"
-      ? { pid: holder, ownerId: holder === process.pid ? defaultOwnerId(holder) : undefined }
-      : { pid: holder.pid ?? process.pid, ownerId: holder.ownerId };
-  const lock = readWriterLock(scopePath);
-  if (!lock || !isSameLockOwner(lock, identity)) return;
-  try {
-    unlinkSync(lockPath(scopePath));
-  } catch {
-    // Best effort shutdown cleanup.
-  }
-}
-
-export const acquireSessionWriterLock = acquireWriterLock;
-export const refreshSessionWriterLock = refreshWriterLock;
-export const releaseSessionWriterLock = releaseWriterLock;
-
-export function writerLockScopeForSession(sessionManager: SessionLockScopeSource): string {
-  return sessionManager.getSessionFile() ?? sessionManager.getSessionDir();
-}
-
-export function migrateWriterLockScope(
-  fromScopePath: string,
-  toScopePath: string,
-  holder: { pid?: number; ownerId?: string } = {},
-): boolean {
-  if (fromScopePath === toScopePath) return true;
-  const pid = holder.pid ?? process.pid;
-  const identity = {
-    pid,
-    ownerId: holder.ownerId ?? (pid === process.pid ? defaultOwnerId(pid) : undefined),
-  };
-  const lock = readWriterLock(fromScopePath);
-  if (!lock || !isSameLockOwner(lock, identity)) return false;
-
-  mkdirSync(dirname(lockPath(toScopePath)), { recursive: true });
-  const nextLock = { ...lock, scope: toScopePath };
-  let fd: number | undefined;
-  try {
-    fd = openSync(lockPath(toScopePath), "wx", 0o600);
-    writeFileSync(fd, JSON.stringify(nextLock, null, 2));
-  } catch {
-    const destinationLock = readWriterLock(toScopePath);
-    if (destinationLock && isSameLockOwner(destinationLock, identity)) {
-      try {
-        unlinkSync(lockPath(fromScopePath));
-      } catch {
-        // Best effort; destination lock is already authoritative for this owner.
-      }
-      migrateAcceptedActionStore(fromScopePath, toScopePath);
-      return true;
-    }
-    if (destinationLock && !isSameLockOwner(destinationLock, identity)) {
-      try {
-        unlinkSync(lockPath(fromScopePath));
-      } catch {
-        // The canonical lock is already owned elsewhere; do not keep refreshing fallback.
-      }
-    }
-    return false;
-  } finally {
-    if (fd !== undefined) closeSync(fd);
-  }
-
-  try {
-    unlinkSync(lockPath(fromScopePath));
-  } catch {
-    // Best effort; destination lock is now authoritative for the canonical scope.
-  }
-  migrateAcceptedActionStore(fromScopePath, toScopePath);
-  return true;
-}
-
-function migrateAcceptedActionStore(fromScopePath: string, toScopePath: string): void {
-  const fromPath = acceptedActionStorePath(fromScopePath);
-  const toPath = acceptedActionStorePath(toScopePath);
-  let fromActions: AcceptedActionStore;
-  try {
-    const parsed = JSON.parse(readFileSync(fromPath, "utf8")) as { acceptedActionIds?: unknown };
-    fromActions = parseAcceptedActionStore(parsed);
-  } catch {
-    return;
-  }
-  let toActions: AcceptedActionStore = {
-    acceptedActionIds: [],
-    pendingActions: [],
-  };
-  try {
-    const parsed = JSON.parse(readFileSync(toPath, "utf8")) as { acceptedActionIds?: unknown };
-    toActions = parseAcceptedActionStore(parsed);
-  } catch {
-    // Destination store does not exist yet.
-  }
-  const acceptedActionIds = [
-    ...new Set([...toActions.acceptedActionIds, ...fromActions.acceptedActionIds]),
-  ].slice(-500);
-  const pendingActionsById = new Map<string, PendingActionRecord>();
-  for (const action of [...toActions.pendingActions, ...fromActions.pendingActions]) {
-    if (!acceptedActionIds.includes(action.id)) pendingActionsById.set(action.id, action);
-  }
-  const pendingActions = [...pendingActionsById.values()].slice(-500);
-  mkdirSync(dirname(toPath), { recursive: true });
-  writeFileSync(
-    toPath,
-    JSON.stringify(
-      {
-        acceptedActionIds,
-        pendingActionIds: pendingActions.map((action) => ({
-          id: action.id,
-          pendingAtMs: action.pendingAtMs,
-        })),
-      },
-      null,
-      2,
-    ),
-    {
-      mode: 0o600,
-    },
-  );
-  try {
-    unlinkSync(fromPath);
-  } catch {
-    // Best effort; destination store now contains the merged accepted action ids.
-  }
-}
-
-interface PendingActionRecord {
-  id: string;
-  pendingAtMs: number;
-}
-
-interface AcceptedActionStore {
-  acceptedActionIds: string[];
-  pendingActions: PendingActionRecord[];
-}
-
-function parseAcceptedActionStore(parsed: {
-  acceptedActionIds?: unknown;
-  pendingActionIds?: unknown;
-}): AcceptedActionStore {
-  const acceptedActionIds = Array.isArray(parsed.acceptedActionIds)
-    ? parsed.acceptedActionIds.filter((id): id is string => typeof id === "string")
-    : [];
-  const pending = parsePendingActionRecords(parsed.pendingActionIds);
-  return {
-    acceptedActionIds,
-    pendingActions: pending.activeRecords,
-  };
-}
-
-function parsePendingActionRecords(value: unknown): {
-  activeRecords: PendingActionRecord[];
-} {
-  if (!Array.isArray(value)) return { activeRecords: [] };
-  const now = Date.now();
-  const activeRecords: PendingActionRecord[] = [];
-  for (const entry of value) {
-    const record = (() => {
-      if (!entry || typeof entry !== "object") return null;
-      const pending = entry as { id?: unknown; pendingAtMs?: unknown };
-      if (typeof pending.id !== "string" || typeof pending.pendingAtMs !== "number") return null;
-      return { id: pending.id, pendingAtMs: pending.pendingAtMs };
-    })();
-    if (!record) continue;
-    if (now - record.pendingAtMs <= PENDING_SESSION_ACTION_TTL_MS) activeRecords.push(record);
-  }
-  return { activeRecords };
-}
-
-function tryCreate(
-  scopePath: string,
-  processKind: ProcessKind,
-  identity: {
-    pid: number;
-    ownerId?: string;
-    coordinatorEndpoint?: string;
-    coordinatorSecret?: string;
-  },
-  nowFn: () => Date,
-): WriterLock | null {
-  const now = nowFn().toISOString();
-  const lock: WriterLock = {
-    pid: identity.pid,
-    processKind,
-    acquiredAt: now,
-    lastHeartbeat: now,
-    protocolVersion: WRITER_LOCK_PROTOCOL_VERSION,
-    scope: scopePath,
-    ...(identity.ownerId ? { ownerId: identity.ownerId } : {}),
-    ...(identity.coordinatorEndpoint ? { coordinatorEndpoint: identity.coordinatorEndpoint } : {}),
-    ...(identity.coordinatorSecret ? { coordinatorSecret: identity.coordinatorSecret } : {}),
-  };
-  try {
-    const fd = openSync(lockPath(scopePath), "wx", 0o600);
-    try {
-      writeFileSync(fd, JSON.stringify(lock, null, 2));
-    } finally {
-      closeSync(fd);
-    }
-    return lock;
-  } catch {
-    return null;
-  }
-}
-
-function isPidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Unlike isPidAlive, EPERM counts as alive: the process exists but belongs to
-// another user, so its coordinator may still be serving the session.
-export function isCoordinatorOwnerAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return (error as NodeJS.ErrnoException).code === "EPERM";
-  }
-}
-
-export function shouldBlockFailedCoordinatorAction(
-  sessionManager: SessionLockScopeSource,
-): boolean {
-  const lock = readWriterLock(writerLockScopeForSession(sessionManager));
-  if (!lock || lock.pid === process.pid) return false;
-  return isCoordinatorOwnerAlive(lock.pid);
-}
-
-function classifyLock(
-  lock: WriterLock,
-  staleGraceMs: number,
-  pidAlive: (pid: number) => boolean,
-): "current" | "ambiguous" | "recoverable" {
-  const heartbeat = Date.parse(lock.lastHeartbeat);
-  const hasFreshHeartbeat = Number.isFinite(heartbeat) && Date.now() - heartbeat <= staleGraceMs;
-  if (!pidAlive(lock.pid)) return "recoverable";
-  if (hasFreshHeartbeat) return "current";
-  if (lock.pid === process.pid && lock.ownerId === defaultOwnerId(process.pid)) return "current";
-  return "ambiguous";
-}
-
-function withRecoveryState(lock: WriterLock, status: "current" | "ambiguous"): WriterLock {
-  if (status === "current") return { ...lock, recoveryState: "live" };
-  return { ...lock, recoveryState: "ambiguous" };
-}
-
-function isSameLockOwner(lock: WriterLock, identity: { pid: number; ownerId?: string }): boolean {
-  if (lock.pid !== identity.pid) return false;
-  if (lock.ownerId) return lock.ownerId === identity.ownerId;
-  return !identity.ownerId;
-}
-
-function lockIdentity(options: AcquireOptions): {
-  pid: number;
-  ownerId?: string;
-  coordinatorEndpoint?: string;
-  coordinatorSecret?: string;
-} {
-  const pid = options.pid ?? process.pid;
-  const ownerId =
-    options.ownerId === undefined && pid === process.pid ? defaultOwnerId(pid) : options.ownerId;
-  return {
-    pid,
-    ...(ownerId ? { ownerId } : {}),
-    ...(options.coordinatorEndpoint ? { coordinatorEndpoint: options.coordinatorEndpoint } : {}),
-    ...(options.coordinatorSecret ? { coordinatorSecret: options.coordinatorSecret } : {}),
-  };
-}
-
-function defaultOwnerId(pid: number): string {
-  return `${pid}:${process.ppid}:${PROCESS_STARTED_AT}`;
-}
-
-function lockPath(scopePath: string): string {
-  return isFileScope(scopePath) ? `${scopePath}.writer.lock` : join(scopePath, "writer.lock");
-}
-
-function acceptedActionStorePath(scopePath: string): string {
-  return isFileScope(scopePath)
-    ? `${scopePath}.accepted-actions.json`
-    : join(scopePath, "accepted-actions.json");
-}
-
-function isFileScope(scopePath: string): boolean {
-  if (scopePath.endsWith(".jsonl")) return true;
-  try {
-    return statSync(scopePath).isFile();
-  } catch {
-    return false;
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/pi/session.ts

@@ -1,84 +0,0 @@
-import {
-  type AuthStorage,
-  type CreateAgentSessionResult,
-  createAgentSession,
-  DefaultResourceLoader,
-  getAgentDir,
-  type ModelRegistry,
-  type SessionManager,
-  type SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import { loadEnv } from "../config.js";
-import { assertSupportedNodeVersion } from "../infra/node-version.js";
-import type { AskUserHandler } from "../types/index.js";
-import openCandleExtension from "./opencandle-extension.js";
-
-export interface CreateOpenCandleSessionOptions {
-  cwd?: string;
-  agentDir?: string;
-  authStorage?: AuthStorage;
-  modelRegistry?: ModelRegistry;
-  settingsManager?: SettingsManager;
-  sessionManager?: SessionManager;
-  useInlineExtension?: boolean;
-  bindExtensions?: boolean;
-  askUserHandler?: AskUserHandler;
-}
-
-export async function createOpenCandleSession(
-  options: CreateOpenCandleSessionOptions = {},
-): Promise<CreateAgentSessionResult> {
-  assertSupportedNodeVersion();
-  loadEnv();
-
-  const cwd = options.cwd ?? process.cwd();
-  const agentDir = options.agentDir ?? getAgentDir();
-  const useInlineExtension = options.useInlineExtension ?? true;
-  const resourceLoader = useInlineExtension
-    ? new DefaultResourceLoader({
-        cwd,
-        agentDir,
-        settingsManager: options.settingsManager,
-        extensionFactories: [
-          (pi) => openCandleExtension(pi, { askUserHandler: options.askUserHandler }),
-        ],
-      })
-    : undefined;
-
-  if (resourceLoader) {
-    await resourceLoader.reload();
-  }
-
-  const result = await createAgentSession({
-    cwd,
-    agentDir,
-    authStorage: options.authStorage,
-    modelRegistry: options.modelRegistry,
-    sessionManager: options.sessionManager,
-    settingsManager: options.settingsManager,
-    resourceLoader,
-    noTools: "builtin",
-  });
-
-  await applySavedDefaultModel(result);
-
-  if (options.bindExtensions !== false) {
-    await result.session.bindExtensions({});
-  }
-
-  return result;
-}
-
-async function applySavedDefaultModel(result: CreateAgentSessionResult): Promise<void> {
-  const provider = result.session.settingsManager.getDefaultProvider();
-  const modelId = result.session.settingsManager.getDefaultModel();
-  if (!provider || !modelId) return;
-
-  const savedDefault = result.session.modelRegistry.find(provider, modelId);
-  if (!savedDefault || !result.session.modelRegistry.hasConfiguredAuth(savedDefault)) return;
-
-  const current = result.session.model;
-  if (current?.provider === savedDefault.provider && current.id === savedDefault.id) return;
-
-  await result.session.setModel(savedDefault);
-}