pi-oracle 0.4.0 → 0.6.0

package/extensions/oracle/lib/jobs.ts

@@ -34,7 +34,7 @@ import { cleanupRuntimeArtifacts, getProjectId, getSessionId, parseConversationI
 export type OracleJobStatus = SharedOracleJobStatus;
 export type OracleJobPhase = SharedOracleJobPhase;
 
-export type OracleWakeupSettlementSource = "oracle_read" | "oracle_status";
+export type OracleWakeupSettlementSource = "oracle_read" | "oracle_status" | "oracle_read_command";
 
 export { ACTIVE_ORACLE_JOB_STATUSES, OPEN_ORACLE_JOB_STATUSES, TERMINAL_ORACLE_JOB_STATUSES };
 export const ORACLE_MISSING_WORKER_GRACE_MS = 30_000;
@@ -285,6 +285,16 @@ function notificationClaimIsLive(job: Pick<OracleJob, "notifyClaimedAt" | "notif
   return now - claimedAtMs < ORACLE_NOTIFICATION_CLAIM_TTL_MS;
 }
 
+function getWakeupRetentionGraceDeadline(job: Pick<OracleJob, "wakeupLastRequestedAt">, now = Date.now()): { retryAt: string; remainingMs: number } | undefined {
+  const lastRequestedAtMs = parseTimestamp(job.wakeupLastRequestedAt);
+  if (lastRequestedAtMs === undefined) return undefined;
+  const retryAtMs = lastRequestedAtMs + ORACLE_WAKEUP_POST_SEND_RETENTION_MS;
+  return {
+    retryAt: new Date(retryAtMs).toISOString(),
+    remainingMs: Math.max(0, retryAtMs - now),
+  };
+}
+
 function wakeupRetentionGraceIsActive(job: Pick<OracleJob, "wakeupLastRequestedAt">, now = Date.now()): boolean {
   const lastRequestedAtMs = parseTimestamp(job.wakeupLastRequestedAt);
   if (lastRequestedAtMs === undefined) return false;
@@ -464,12 +474,17 @@ export async function removeTerminalOracleJob(job: OracleJob): Promise<{ removed
         },
       };
     }
-    if (wakeupRetentionGraceIsActive(current)) {
+    const nowMs = Date.now();
+    if (wakeupRetentionGraceIsActive(current, nowMs)) {
+      const graceDeadline = getWakeupRetentionGraceDeadline(current, nowMs);
+      const retryHint = graceDeadline
+        ? ` Retry after ${graceDeadline.retryAt} (${Math.ceil(graceDeadline.remainingMs / 1000)}s remaining).`
+        : "";
       return {
         removed: false,
         cleanupReport: {
           attempted: [],
-          warnings: [`Refusing to remove terminal oracle job ${current.id} because its wake-up delivery is still within the post-send retention grace window.`],
+          warnings: [`Refusing to remove terminal oracle job ${current.id} because its wake-up delivery is still within the post-send retention grace window.${retryHint}`],
         },
       };
     }
@@ -713,8 +728,10 @@ export async function releaseNotificationClaim(jobId: string, claimedBy: string)
 export async function noteWakeupRequested(jobId: string, at = new Date().toISOString()): Promise<OracleJob | undefined> {
   try {
     return await updateJob(jobId, (job) => noteOracleJobWakeupRequested(job, { at, source: "oracle:poller" }));
-  } catch {
-    return readJob(jobId);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith("Oracle job not found:")) return undefined;
+    throw error;
   }
 }
 
@@ -912,7 +929,16 @@ export function resolveArchiveInputs(cwd: string, files: string[]): { absolute:
 
   const realCwd = realpathSync(cwd);
   return files.map((file) => {
+    if (!file.trim()) {
+      throw new Error("Archive input must be a non-empty project-relative path");
+    }
+    if (file.trim() === "." && file !== ".") {
+      throw new Error("Archive input must use '.' exactly for a whole-repo archive");
+    }
     const absolute = resolve(cwd, file);
+    if (absolute === cwd && file !== ".") {
+      throw new Error("Archive input must use '.' exactly for a whole-repo archive");
+    }
     const relative = absolute.startsWith(`${cwd}/`) ? absolute.slice(cwd.length + 1) : absolute === cwd ? "." : "";
     if (!relative) {
       throw new Error(`Archive input must be inside the project cwd: ${file}`);

package/extensions/oracle/lib/poller.ts

@@ -3,6 +3,7 @@
 // Scope: Poller/orchestration only; durable lifecycle mutations live in jobs.ts and shared observability formatting lives in extensions/oracle/shared.
 // Usage: Imported by the oracle extension entrypoint to start or stop per-session oracle polling.
 // Invariants/Assumptions: Poller scans are serialized per session key, wake-up delivery is best-effort, and terminal-job notifications always re-read durable job state before send.
+import { existsSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { buildOracleStatusText, buildOracleWakeupNotificationContent } from "../shared/job-observability-helpers.mjs";
 import { isProcessAlive, readProcessStartedAt } from "../shared/process-helpers.mjs";
@@ -154,7 +155,8 @@ function requestWakeupTurn(pi: ExtensionAPI, job: OraclePollerJob): void {
       customType: ORACLE_WAKEUP_REMINDER_CUSTOM_TYPE,
       display: false,
       content: buildOracleWakeupNotificationContent(job, {
-        responsePath: job.responsePath || `${getJobDir(job.id)}/response.md`,
+        responsePath: job.responsePath,
+        responseAvailable: Boolean(job.responsePath && existsSync(job.responsePath)),
         artifactsPath: `${getJobDir(job.id)}/artifacts`,
       }),
       details: { jobId: job.id, status: job.status },
@@ -243,8 +245,14 @@ async function scan(pi: ExtensionAPI, ctx: ExtensionContext, workerPath: string,
         continue;
       }
 
-      requestWakeupTurn(pi, deliverable);
-      await noteWakeupRequested(jobId).catch(() => undefined);
+      const notedWakeup = await noteWakeupRequested(jobId);
+      const deliverableAfterNote = notedWakeup ?? readJob(jobId);
+      if (!deliverableAfterNote || shouldPruneTerminalJob(deliverableAfterNote, Date.now())) {
+        await releaseNotificationClaim(jobId, notificationClaimant).catch(() => undefined);
+        continue;
+      }
+
+      requestWakeupTurn(pi, deliverableAfterNote);
       if (ctx.hasUI) {
         ctx.ui.notify(`Oracle job ${claimed.id} is ${claimed.status}.`, "info");
       }
@@ -292,12 +300,33 @@ export function stopPollerForSession(sessionFile: string | undefined, cwd: strin
   if (timer) {
     clearInterval(timer);
     activePollers.delete(sessionKey);
-    scansInFlight.delete(sessionKey);
   }
   const wakeupTargetLeaseKey = getWakeupTargetLeaseKey(sessionKey);
   void releaseLease(WAKEUP_TARGET_LEASE_KIND, wakeupTargetLeaseKey).catch(() => undefined);
 }
 
+export async function stopAllPollers(): Promise<void> {
+  const sessionKeys = [...activePollers.keys()];
+  for (const timer of activePollers.values()) {
+    clearInterval(timer);
+  }
+  activePollers.clear();
+  await Promise.all(sessionKeys.map(async (sessionKey) => {
+    const wakeupTargetLeaseKey = getWakeupTargetLeaseKey(sessionKey);
+    await releaseLease(WAKEUP_TARGET_LEASE_KIND, wakeupTargetLeaseKey).catch(() => undefined);
+  }));
+}
+
+export async function waitForAllPollersToQuiesce(timeoutMs = 2_000): Promise<void> {
+  const startedAt = Date.now();
+  while (scansInFlight.size > 0) {
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error(`Timed out waiting for oracle pollers to quiesce after ${timeoutMs}ms`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+}
+
 export function stopPoller(ctx: ExtensionContext): void {
   const sessionFile = getSessionFile(ctx);
   if (!sessionFile) return;

package/extensions/oracle/lib/runtime.ts

@@ -5,9 +5,9 @@
 // Invariants/Assumptions: Lease metadata is the admission source of truth, tracked worker identity checks defend against PID reuse, and runtime cleanup always attempts lease release.
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
-import { existsSync, realpathSync, readFileSync } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { constants as fsConstants, existsSync, realpathSync, readFileSync } from "node:fs";
+import { access, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { delimiter, dirname, join } from "node:path";
 import { jobBlocksAdmission } from "../shared/job-coordination-helpers.mjs";
 import { isTrackedProcessAlive } from "../shared/process-helpers.mjs";
 import type { OracleConfig } from "./config.js";
@@ -21,6 +21,14 @@ const AGENT_BROWSER_BIN = [process.env.AGENT_BROWSER_PATH, "/opt/homebrew/bin/ag
 ) || "agent-browser";
 const PROFILE_CLONE_TIMEOUT_MS = 120_000;
 const ORACLE_SUBPROCESS_KILL_GRACE_MS = 2_000;
+const WORKSPACE_ROOT_MARKERS = [
+  ".pi/extensions/oracle.json",
+] as const;
+const REQUIRED_ORACLE_DEPENDENCIES = [
+  { name: "agent-browser", command: AGENT_BROWSER_BIN },
+  { name: "tar", command: "tar" },
+  { name: "zstd", command: "zstd" },
+] as const;
 
 export interface OracleRuntimeLeaseMetadata {
   jobId: string;
@@ -51,7 +59,7 @@ export interface OracleConversationLeaseAttempt {
   blocker?: OracleConversationLeaseMetadata;
 }
 
-export function getProjectId(cwd: string): string {
+function resolveRealCwd(cwd: string): string {
   try {
     return realpathSync(cwd);
   } catch {
@@ -59,6 +67,26 @@ export function getProjectId(cwd: string): string {
   }
 }
 
+function hasWorkspaceRootMarker(path: string): boolean {
+  return WORKSPACE_ROOT_MARKERS.some((marker) => existsSync(join(path, marker)));
+}
+
+function resolveWorkspaceRoot(realCwd: string): string {
+  let current = realCwd;
+  let nearestMarkerRoot: string | undefined;
+  while (true) {
+    if (existsSync(join(current, ".git"))) return current;
+    if (!nearestMarkerRoot && hasWorkspaceRootMarker(current)) nearestMarkerRoot = current;
+    const parent = dirname(current);
+    if (parent === current) return nearestMarkerRoot ?? realCwd;
+    current = parent;
+  }
+}
+
+export function getProjectId(cwd: string): string {
+  return resolveWorkspaceRoot(resolveRealCwd(cwd));
+}
+
 export function hasPersistedSessionFile(originSessionFile: string | undefined): originSessionFile is string {
   return Boolean(originSessionFile);
 }
@@ -98,6 +126,144 @@ export function authSessionName(config: OracleConfig): string {
   return `${config.browser.sessionPrefix}-auth`;
 }
 
+function missingAuthSeedProfileMessage(seedDir: string): string {
+  return `Oracle auth seed profile not found: ${seedDir}. Run /oracle-auth first.`;
+}
+
+function invalidAuthSeedProfileTypeMessage(seedDir: string): string {
+  return `Oracle auth seed profile is not a directory: ${seedDir}. Remove the invalid path or rerun /oracle-auth.`;
+}
+
+function unreadableAuthSeedProfileMessage(seedDir: string): string {
+  return `Oracle auth seed profile is not readable: ${seedDir}. Fix its permissions or rerun /oracle-auth.`;
+}
+
+function missingBrowserExecutableMessage(executablePath: string): string {
+  return `Configured oracle browser executable does not exist: ${executablePath}. Fix browser.executablePath or install Chrome there.`;
+}
+
+function nonExecutableBrowserMessage(executablePath: string): string {
+  return `Configured oracle browser executable is not executable: ${executablePath}. Fix browser.executablePath permissions or point it at a runnable Chrome binary.`;
+}
+
+function missingLocalDependencyMessage(name: string): string {
+  return `Oracle prerequisite not found on PATH: ${name}. Install ${name} and retry.`;
+}
+
+function unwritableOracleDirectoryMessage(label: "runtime profiles" | "jobs", path: string): string {
+  return `Oracle ${label} directory is not writable: ${path}. Fix its permissions or configure a writable path, then retry.`;
+}
+
+async function resolveExecutableOnPath(command: string): Promise<string | undefined> {
+  if (!command) return undefined;
+  if (command.includes("/")) {
+    try {
+      await access(command, fsConstants.X_OK);
+      return command;
+    } catch {
+      return undefined;
+    }
+  }
+
+  const pathValue = process.env.PATH ?? "";
+  for (const segment of pathValue.split(delimiter)) {
+    if (!segment) continue;
+    const candidate = join(segment, command);
+    try {
+      await access(candidate, fsConstants.X_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return undefined;
+}
+
+async function assertConfiguredBrowserExecutableReady(executablePath: string | undefined): Promise<void> {
+  if (!executablePath) return;
+  let executableStats;
+  try {
+    executableStats = await stat(executablePath);
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") throw new Error(missingBrowserExecutableMessage(executablePath));
+    if (code === "EACCES" || code === "EPERM") throw new Error(nonExecutableBrowserMessage(executablePath));
+    throw new Error(`Failed to inspect configured oracle browser executable ${executablePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  if (!executableStats.isFile()) {
+    throw new Error(nonExecutableBrowserMessage(executablePath));
+  }
+
+  try {
+    await access(executablePath, fsConstants.X_OK);
+  } catch {
+    throw new Error(nonExecutableBrowserMessage(executablePath));
+  }
+}
+
+async function assertRequiredLocalDependencyReady(name: string, command: string): Promise<void> {
+  const resolved = await resolveExecutableOnPath(command);
+  if (!resolved) throw new Error(missingLocalDependencyMessage(name));
+}
+
+async function assertWritableDirectory(path: string, label: "runtime profiles" | "jobs"): Promise<void> {
+  try {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+  } catch {
+    throw new Error(unwritableOracleDirectoryMessage(label, path));
+  }
+
+  let directoryStats;
+  try {
+    directoryStats = await stat(path);
+  } catch {
+    throw new Error(unwritableOracleDirectoryMessage(label, path));
+  }
+  if (!directoryStats.isDirectory()) {
+    throw new Error(unwritableOracleDirectoryMessage(label, path));
+  }
+
+  try {
+    await access(path, fsConstants.W_OK | fsConstants.X_OK);
+  } catch {
+    throw new Error(unwritableOracleDirectoryMessage(label, path));
+  }
+}
+
+export async function assertOracleAuthSeedProfileReady(config: OracleConfig): Promise<void> {
+  const seedDir = config.browser.authSeedProfileDir;
+  let seedStats;
+  try {
+    seedStats = await stat(seedDir);
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") throw new Error(missingAuthSeedProfileMessage(seedDir));
+    if (code === "EACCES" || code === "EPERM") throw new Error(unreadableAuthSeedProfileMessage(seedDir));
+    throw new Error(`Failed to inspect oracle auth seed profile ${seedDir}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  if (!seedStats.isDirectory()) {
+    throw new Error(invalidAuthSeedProfileTypeMessage(seedDir));
+  }
+
+  try {
+    await access(seedDir, fsConstants.R_OK | fsConstants.X_OK);
+  } catch {
+    throw new Error(unreadableAuthSeedProfileMessage(seedDir));
+  }
+}
+
+export async function assertOracleSubmitPrerequisites(config: OracleConfig): Promise<void> {
+  await assertOracleAuthSeedProfileReady(config);
+  await assertConfiguredBrowserExecutableReady(config.browser.executablePath);
+  for (const dependency of REQUIRED_ORACLE_DEPENDENCIES) {
+    await assertRequiredLocalDependencyReady(dependency.name, dependency.command);
+  }
+  await assertWritableDirectory(config.browser.runtimeProfilesDir, "runtime profiles");
+  await assertWritableDirectory(ORACLE_JOBS_DIR, "jobs");
+}
+
 export function getSeedGeneration(config: OracleConfig): string | undefined {
   const path = join(config.browser.authSeedProfileDir, SEED_GENERATION_FILE);
   if (!existsSync(path)) return undefined;
@@ -267,9 +433,7 @@ export async function cloneSeedProfileToRuntime(
   options?: { cpTimeoutMs?: number },
 ): Promise<string | undefined> {
   const seedDir = config.browser.authSeedProfileDir;
-  if (!existsSync(seedDir)) {
-    throw new Error(`Oracle auth seed profile not found: ${seedDir}. Run /oracle-auth first.`);
-  }
+  await assertOracleAuthSeedProfileReady(config);
 
   await withAuthLock({ runtimeProfileDir, seedDir }, async () => {
     await rm(runtimeProfileDir, { recursive: true, force: true }).catch(() => undefined);