opencandle 0.10.0 → 0.11.1

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

@@ -0,0 +1,155 @@
+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-writer-lock.ts

@@ -16,11 +16,22 @@ export interface WriterLock {
   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 =
@@ -33,6 +44,9 @@ export interface SessionLockScopeSource {
 }
 
 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,
@@ -40,21 +54,28 @@ export async function acquireWriterLock(
   options: AcquireOptions = {},
 ): Promise<AcquireResult> {
   mkdirSync(dirname(lockPath(scopePath)), { recursive: true });
-  const pid = options.pid ?? process.pid;
+  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, pid);
+  const created = tryCreate(scopePath, processKind, identity, now);
   if (created) return { role: "writer", lock: created };
 
   const existing = readWriterLock(scopePath);
-  if (existing && isLockCurrent(existing, staleGraceMs)) {
-    return { role: "follower", lock: existing };
+  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 && isLockCurrent(afterGrace, staleGraceMs)) {
-    return { role: "follower", lock: afterGrace };
+  if (afterGrace) {
+    const status = classifyLock(afterGrace, staleGraceMs, pidAlive);
+    if (status !== "recoverable") {
+      return { role: "follower", lock: withRecoveryState(afterGrace, status) };
+    }
   }
 
   try {
@@ -63,7 +84,7 @@ export async function acquireWriterLock(
     // Missing or concurrently removed is fine; the next create decides ownership.
   }
 
-  const recovered = tryCreate(scopePath, processKind, pid);
+  const recovered = tryCreate(scopePath, processKind, identity, now);
   if (recovered) return { role: "writer", lock: recovered };
 
   const current = readWriterLock(scopePath) ?? afterGrace ?? existing;
@@ -79,18 +100,36 @@ export function readWriterLock(scopePath: string): WriterLock | null {
   }
 }
 
-export function refreshWriterLock(scopePath: string, pid = process.pid): void {
+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 || lock.pid !== pid) return;
+  if (!lock || !isSameLockOwner(lock, identity)) return;
   writeFileSync(
     lockPath(scopePath),
-    JSON.stringify({ ...lock, lastHeartbeat: new Date().toISOString() }, null, 2),
+    JSON.stringify(
+      { ...lock, lastHeartbeat: (identity.now?.() ?? new Date()).toISOString() },
+      null,
+      2,
+    ),
   );
 }
 
-export function releaseWriterLock(scopePath: string, pid = process.pid): void {
+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 || lock.pid !== pid) return;
+  if (!lock || !isSameLockOwner(lock, identity)) return;
   try {
     unlinkSync(lockPath(scopePath));
   } catch {
@@ -106,11 +145,179 @@ export function writerLockScopeForSession(sessionManager: SessionLockScopeSource
   return sessionManager.getSessionFile() ?? sessionManager.getSessionDir();
 }
 
-function tryCreate(scopePath: string, processKind: ProcessKind, pid: number): WriterLock | null {
-  const now = new Date().toISOString();
-  const lock: WriterLock = { pid, processKind, acquiredAt: now, lastHeartbeat: now };
+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 {
-    const fd = openSync(lockPath(scopePath), "wx");
+    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 {
@@ -131,17 +338,80 @@ function isPidAlive(pid: number): boolean {
   }
 }
 
-function isLockCurrent(lock: WriterLock, staleGraceMs: number): boolean {
+// 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);
-  return (
-    isPidAlive(lock.pid) && Number.isFinite(heartbeat) && Date.now() - heartbeat <= staleGraceMs
-  );
+  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 {

package/src/pi/setup.ts

@@ -211,10 +211,10 @@ async function runLoginDialog(ctx: ExtensionContext, providerId: string): Promis
 async function runApiKeySetup(ctx: ExtensionContext, provider: ApiKeyProviderId): Promise<boolean> {
   const label = API_KEY_PROVIDER_LABELS[provider];
   ctx.ui.notify(
-    `OpenCandle stores your ${label} API key locally and only sends it to ${label}.`,
+    `OpenCandle stores your ${label} API key locally. After saving it, OpenCandle will select a fast default model when one is available.`,
     "info",
   );
-  const key = await ctx.ui.input(`Paste your ${label} API key for OpenCandle`, "sk-...");
+  const key = await ctx.ui.input(`Paste your ${label} API key`, "API key");
   const trimmed = key?.trim();
   if (!trimmed) {
     ctx.ui.notify("No API key entered.", "warning");
@@ -323,11 +323,11 @@ async function runLlmSetup(
     }
 
     const choice = await ctx.ui.select(
-      "Welcome to OpenCandle — sign in or paste an API key to start chatting",
-      ["Sign in", "Paste API key", "Exit setup"],
+      "Welcome to OpenCandle — connect one AI model to start chatting",
+      ["Sign in with browser", "Paste API key", "Exit setup"],
     );
 
-    if (choice !== "Sign in" && choice !== "Paste API key") {
+    if (choice !== "Sign in with browser" && choice !== "Paste API key") {
       if (mode === "startup") {
         ctx.ui.notify("OpenCandle needs an AI model before chat can start.", "warning");
         ctx.shutdown();
@@ -336,7 +336,7 @@ async function runLlmSetup(
       return "cancelled";
     }
 
-    if (choice === "Sign in") {
+    if (choice === "Sign in with browser") {
       const providerChoice = await selectProviderForLogin(ctx);
       if (!providerChoice) {
         continue;