pi-oracle 0.1.0

package/extensions/oracle/lib/poller.ts

@@ -0,0 +1,156 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { isLockTimeoutError, withGlobalReconcileLock } from "./locks.js";
+import {
+  getSessionFile,
+  getStaleOracleJobReason,
+  isActiveOracleJob,
+  listOracleJobDirs,
+  markJobNotified,
+  readJob,
+  reconcileStaleOracleJobs,
+  releaseNotificationClaim,
+  tryClaimNotification,
+} from "./jobs.js";
+import { getProjectId, getSessionId } from "./runtime.js";
+
+const activePollers = new Map<string, NodeJS.Timeout>();
+const scansInFlight = new Set<string>();
+const POLLER_LOCK_TIMEOUT_MS = 50;
+
+export function getPollerSessionKey(sessionFile: string | undefined, cwd: string): string {
+  const projectId = getProjectId(cwd);
+  const sessionId = getSessionId(sessionFile, projectId);
+  return `${projectId}::${sessionId}`;
+}
+
+function jobMatchesContext(job: { projectId: string; sessionId: string }, sessionFile: string | undefined, cwd: string): boolean {
+  const projectId = getProjectId(cwd);
+  const sessionId = getSessionId(sessionFile, projectId);
+  return job.projectId === projectId && job.sessionId === sessionId;
+}
+
+function getActiveJobCount(ctx: ExtensionContext): number {
+  const currentSessionFile = getSessionFile(ctx);
+  return listOracleJobDirs()
+    .map((jobDir) => readJob(jobDir))
+    .filter((job): job is NonNullable<typeof job> => Boolean(job))
+    .filter((job) => {
+      if (!isActiveOracleJob(job)) return false;
+      if (getStaleOracleJobReason(job)) return false;
+      return jobMatchesContext(job, currentSessionFile, ctx.cwd);
+    }).length;
+}
+
+export function refreshOracleStatus(ctx: ExtensionContext): void {
+  const activeJobCount = getActiveJobCount(ctx);
+  if (activeJobCount > 0) {
+    const suffix = activeJobCount > 1 ? ` (${activeJobCount})` : "";
+    ctx.ui.setStatus("oracle", ctx.ui.theme.fg("success", `oracle: running${suffix}`));
+    return;
+  }
+
+  ctx.ui.setStatus("oracle", ctx.ui.theme.fg("accent", "oracle: ready"));
+}
+
+function notifyForJob(pi: ExtensionAPI, job: NonNullable<ReturnType<typeof readJob>>): void {
+  const responsePath = job.responsePath || `${job.id}/response.md`;
+  const artifactsPath = `/tmp/oracle-${job.id}/artifacts`;
+  pi.sendMessage(
+    {
+      customType: "oracle-job-complete",
+      display: true,
+      content: [
+        `Oracle job ${job.id} is ${job.status}.`,
+        `Read response: ${responsePath}`,
+        `Artifacts: ${artifactsPath}`,
+        job.error ? `Error: ${job.error}` : "Continue from the oracle output.",
+      ].join("\n"),
+      details: { jobId: job.id, status: job.status },
+    },
+    { triggerTurn: true },
+  );
+}
+
+async function scan(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  const currentSessionFile = getSessionFile(ctx);
+  const pollerKey = getPollerSessionKey(currentSessionFile, ctx.cwd);
+  const notificationClaimant = `${pollerKey}:${process.pid}`;
+
+  try {
+    await withGlobalReconcileLock(
+      { processPid: process.pid, cwd: ctx.cwd, sessionFile: currentSessionFile, source: "poller" },
+      async () => {
+        await reconcileStaleOracleJobs();
+      },
+      { timeoutMs: POLLER_LOCK_TIMEOUT_MS },
+    );
+  } catch (error) {
+    if (!isLockTimeoutError(error, "reconcile", "global")) throw error;
+  }
+
+  const candidateJobIds = listOracleJobDirs()
+    .map((jobDir) => readJob(jobDir))
+    .filter((job): job is NonNullable<typeof job> => Boolean(job))
+    .filter((job) => {
+      if (job.status !== "complete" && job.status !== "failed" && job.status !== "cancelled") return false;
+      if (!jobMatchesContext(job, currentSessionFile, ctx.cwd)) return false;
+      return !job.notifiedAt;
+    })
+    .map((job) => job.id);
+
+  for (const jobId of candidateJobIds) {
+    const claimed = await tryClaimNotification(jobId, notificationClaimant);
+    if (!claimed) continue;
+    if (!jobMatchesContext(claimed, currentSessionFile, ctx.cwd)) {
+      await releaseNotificationClaim(jobId, notificationClaimant).catch(() => undefined);
+      continue;
+    }
+
+    try {
+      notifyForJob(pi, claimed);
+      await markJobNotified(jobId, notificationClaimant);
+    } catch (error) {
+      await releaseNotificationClaim(jobId, notificationClaimant).catch(() => undefined);
+      throw error;
+    }
+  }
+}
+
+export function startPoller(pi: ExtensionAPI, ctx: ExtensionContext, intervalMs: number): void {
+  const sessionKey = getPollerSessionKey(getSessionFile(ctx), ctx.cwd);
+  const existing = activePollers.get(sessionKey);
+  if (existing) clearInterval(existing);
+
+  const runScan = async () => {
+    if (scansInFlight.has(sessionKey)) return;
+    scansInFlight.add(sessionKey);
+    try {
+      await scan(pi, ctx);
+    } catch (error) {
+      console.error(`Oracle poller scan failed (${sessionKey}):`, error);
+    } finally {
+      scansInFlight.delete(sessionKey);
+      refreshOracleStatus(ctx);
+    }
+  };
+
+  refreshOracleStatus(ctx);
+  void runScan();
+  const timer = setInterval(() => {
+    void runScan();
+  }, intervalMs);
+  activePollers.set(sessionKey, timer);
+}
+
+export function stopPollerForSession(sessionFile: string | undefined, cwd: string): void {
+  const sessionKey = getPollerSessionKey(sessionFile, cwd);
+  const timer = activePollers.get(sessionKey);
+  if (!timer) return;
+  clearInterval(timer);
+  activePollers.delete(sessionKey);
+  scansInFlight.delete(sessionKey);
+}
+
+export function stopPoller(ctx: ExtensionContext): void {
+  stopPollerForSession(getSessionFile(ctx), ctx.cwd);
+}

package/extensions/oracle/lib/runtime.ts

@@ -0,0 +1,197 @@
+import { randomUUID, createHash } 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 { basename, dirname, join } from "node:path";
+import type { OracleConfig } from "./config.js";
+import { createLease, listLeaseMetadata, readLeaseMetadata, releaseLease, withAuthLock } from "./locks.js";
+
+const SEED_GENERATION_FILE = ".oracle-seed-generation";
+
+export interface OracleRuntimeLeaseMetadata {
+  jobId: string;
+  runtimeId: string;
+  runtimeSessionName: string;
+  runtimeProfileDir: string;
+  projectId: string;
+  sessionId: string;
+  createdAt: string;
+}
+
+export interface OracleConversationLeaseMetadata {
+  jobId: string;
+  conversationId: string;
+  projectId: string;
+  sessionId: string;
+  createdAt: string;
+}
+
+export function getProjectId(cwd: string): string {
+  try {
+    return realpathSync(cwd);
+  } catch {
+    return cwd;
+  }
+}
+
+export function getSessionId(originSessionFile: string | undefined, projectId: string): string {
+  return originSessionFile || `ephemeral:${projectId}`;
+}
+
+export function parseConversationId(chatUrl: string | undefined): string | undefined {
+  if (!chatUrl) return undefined;
+  try {
+    const parsed = new URL(chatUrl);
+    const match = parsed.pathname.match(/\/c\/([^/?#]+)/i);
+    return match?.[1];
+  } catch {
+    return undefined;
+  }
+}
+
+export function allocateRuntime(config: OracleConfig): { runtimeId: string; runtimeSessionName: string; runtimeProfileDir: string } {
+  const runtimeId = randomUUID();
+  return {
+    runtimeId,
+    runtimeSessionName: `${config.browser.sessionPrefix}-${runtimeId}`,
+    runtimeProfileDir: join(config.browser.runtimeProfilesDir, runtimeId),
+  };
+}
+
+export function authSessionName(config: OracleConfig): string {
+  return `${config.browser.sessionPrefix}-auth`;
+}
+
+export function getSeedGeneration(config: OracleConfig): string | undefined {
+  const path = join(config.browser.authSeedProfileDir, SEED_GENERATION_FILE);
+  if (!existsSync(path)) return undefined;
+  try {
+    const value = readFileSync(path, "utf8").trim();
+    return value || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function writeSeedGeneration(config: OracleConfig, value = new Date().toISOString()): Promise<string> {
+  await mkdir(config.browser.authSeedProfileDir, { recursive: true, mode: 0o700 });
+  await writeFile(join(config.browser.authSeedProfileDir, SEED_GENERATION_FILE), `${value}\n`, { encoding: "utf8", mode: 0o600 });
+  return value;
+}
+
+function activeJobExists(jobId: string): boolean {
+  const path = join("/tmp", `oracle-${jobId}`, "job.json");
+  if (!existsSync(path)) return false;
+  try {
+    const job = JSON.parse(readFileSync(path, "utf8")) as { status?: string };
+    return ["preparing", "submitted", "waiting"].includes(job.status || "");
+  } catch {
+    return false;
+  }
+}
+
+export async function acquireRuntimeLease(config: OracleConfig, metadata: OracleRuntimeLeaseMetadata): Promise<void> {
+  const existing = listLeaseMetadata<OracleRuntimeLeaseMetadata>("runtime");
+  const liveLeases: OracleRuntimeLeaseMetadata[] = [];
+  for (const lease of existing) {
+    if (!activeJobExists(lease.jobId)) {
+      await releaseLease("runtime", lease.runtimeId).catch(() => undefined);
+      continue;
+    }
+    liveLeases.push(lease);
+  }
+  if (liveLeases.length >= config.browser.maxConcurrentJobs) {
+    const blocker = liveLeases[0];
+    throw new Error(
+      `Oracle is busy (${liveLeases.length}/${config.browser.maxConcurrentJobs} active). ` +
+        `Blocking job ${blocker?.jobId ?? "unknown"} in project ${blocker?.projectId ?? "unknown"}.`,
+    );
+  }
+  await createLease("runtime", metadata.runtimeId, metadata);
+}
+
+export async function releaseRuntimeLease(runtimeId: string | undefined): Promise<void> {
+  if (!runtimeId) return;
+  await releaseLease("runtime", runtimeId);
+}
+
+export async function acquireConversationLease(metadata: OracleConversationLeaseMetadata): Promise<void> {
+  const existing = await readLeaseMetadata<OracleConversationLeaseMetadata>("conversation", metadata.conversationId);
+  if (existing && existing.jobId !== metadata.jobId) {
+    if (!activeJobExists(existing.jobId)) {
+      await releaseLease("conversation", metadata.conversationId).catch(() => undefined);
+    } else {
+      throw new Error(
+        `Oracle conversation ${metadata.conversationId} is already in use by job ${existing.jobId}. ` +
+          `Concurrent follow-ups to the same ChatGPT thread are not allowed.`,
+      );
+    }
+  }
+  await createLease("conversation", metadata.conversationId, metadata);
+}
+
+export async function releaseConversationLease(conversationId: string | undefined): Promise<void> {
+  if (!conversationId) return;
+  await releaseLease("conversation", conversationId);
+}
+
+function profileCloneArgs(config: OracleConfig, sourceDir: string, destinationDir: string): string[] {
+  if (config.browser.cloneStrategy === "apfs-clone") {
+    return ["-cR", sourceDir, destinationDir];
+  }
+  return ["-R", sourceDir, destinationDir];
+}
+
+async function spawnCp(args: string[]): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn("cp", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (data) => {
+      stderr += String(data);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || `cp exited with code ${code}`));
+    });
+  });
+}
+
+export async function cloneSeedProfileToRuntime(config: OracleConfig, runtimeProfileDir: string): 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 withAuthLock({ runtimeProfileDir, seedDir }, async () => {
+    await rm(runtimeProfileDir, { recursive: true, force: true }).catch(() => undefined);
+    await mkdir(dirname(runtimeProfileDir), { recursive: true, mode: 0o700 }).catch(() => undefined);
+    await spawnCp(profileCloneArgs(config, seedDir, runtimeProfileDir));
+  });
+
+  return getSeedGeneration(config);
+}
+
+export async function cleanupRuntimeArtifacts(runtime: {
+  runtimeId?: string;
+  runtimeProfileDir?: string;
+  runtimeSessionName?: string;
+  conversationId?: string;
+}): Promise<void> {
+  if (runtime.runtimeSessionName) {
+    await new Promise<void>((resolve) => {
+      const child = spawn("agent-browser", ["--session", runtime.runtimeSessionName, "close"], { stdio: "ignore" });
+      child.on("error", () => resolve());
+      child.on("close", () => resolve());
+    });
+  }
+  if (runtime.runtimeProfileDir) {
+    await rm(runtime.runtimeProfileDir, { recursive: true, force: true }).catch(() => undefined);
+  }
+  await releaseConversationLease(runtime.conversationId);
+  await releaseRuntimeLease(runtime.runtimeId);
+}
+
+export function stableProjectLabel(projectId: string): string {
+  return basename(projectId) || createHash("sha256").update(projectId).digest("hex").slice(0, 8);
+}