@tt-a1i/openpi 0.4.0 → 0.6.0

package/extensions/shared/child-session.ts

@@ -1,12 +1,22 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import {
-  type AgentSession,
+  DefaultPackageManager,
   DefaultResourceLoader,
   getAgentDir,
+  type LoadExtensionsResult,
+  type PackageSource,
   ProjectTrustStore,
+  type ResolvedPaths,
   type SessionShutdownEvent,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
+import {
+  OPENPI_OWNER_SOURCE_PATHS,
+  OPENPI_TOOL_SURFACE,
+  type OpenPiToolOwner,
+} from "./tool-surface.ts";
 
 export const CHILD_SHUTDOWN_TIMEOUT_MS = 5_000;
 
@@ -37,16 +47,405 @@ export const CHILD_SAFE_PACKAGE_TOOL_NAMES = [
  * Loading it in children can therefore cross-wire identities; the parent
  * extension remains loaded and fully usable.
  */
-function isPiIntercomNpmResource(resource: {
-  resolvedPath?: string;
-  filePath?: string;
+function manifestNamesPiIntercom(manifestPath: string) {
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as unknown;
+    return (
+      typeof manifest === "object" &&
+      manifest !== null &&
+      !Array.isArray(manifest) &&
+      (manifest as Record<string, unknown>).name === "pi-intercom"
+    );
+  } catch (error) {
+    throw new Error(
+      `Cannot verify child package identity from ${manifestPath}`,
+      { cause: error },
+    );
+  }
+}
+
+function installedPathNamesPiIntercom(installedPath: string) {
+  try {
+    const stats = statSync(installedPath);
+    if (stats.isDirectory()) {
+      const manifestPath = path.join(installedPath, "package.json");
+      if (existsSync(manifestPath)) {
+        return manifestNamesPiIntercom(manifestPath);
+      }
+      if (path.basename(installedPath) === "pi-intercom") {
+        throw new Error(
+          `Cannot verify child package identity from ${installedPath}`,
+        );
+      }
+      return false;
+    }
+    if (!stats.isFile()) {
+      throw new Error(
+        `Cannot verify child package identity from ${installedPath}`,
+      );
+    }
+
+    let current = path.dirname(installedPath);
+    let hasIntercomDirectoryName = false;
+    while (true) {
+      hasIntercomDirectoryName ||= path.basename(current) === "pi-intercom";
+      const manifestPath = path.join(current, "package.json");
+      if (existsSync(manifestPath)) {
+        return manifestNamesPiIntercom(manifestPath);
+      }
+      const parent = path.dirname(current);
+      if (parent === current) {
+        if (hasIntercomDirectoryName) {
+          throw new Error(
+            `Cannot verify child package identity from ${installedPath}`,
+          );
+        }
+        return false;
+      }
+      current = parent;
+    }
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message.startsWith("Cannot verify child package identity")
+    ) {
+      throw error;
+    }
+    throw new Error(
+      `Cannot verify child package identity from ${installedPath}`,
+      { cause: error },
+    );
+  }
+}
+
+function piMatchesPublishedIntercomSource(options: {
+  source: string;
+  cwd: string;
+  agentDir: string;
+}) {
+  const settingsManager = SettingsManager.inMemory({
+    packages: [options.source],
+  });
+  const packageManager = new DefaultPackageManager({
+    cwd: options.cwd,
+    agentDir: options.agentDir,
+    settingsManager,
+  });
+  return (
+    packageManager.removeSourceFromSettings("npm:pi-intercom") ||
+    packageManager.removeSourceFromSettings(
+      "git:https://github.com/nicobailon/pi-intercom",
+    )
+  );
+}
+
+function createPiIntercomPackageMatcher(options: {
+  cwd: string;
+  agentDir: string;
+}) {
+  const sourceMatches = new Map<string, boolean>();
+  const installedPathMatches = new Map<string, boolean>();
+  return (source: string, installedPath?: string) => {
+    let sourceMatch = sourceMatches.get(source);
+    if (sourceMatch === undefined) {
+      sourceMatch = piMatchesPublishedIntercomSource({
+        source,
+        cwd: options.cwd,
+        agentDir: options.agentDir,
+      });
+      sourceMatches.set(source, sourceMatch);
+    }
+    if (sourceMatch || installedPath === undefined) return sourceMatch;
+
+    const resolvedPath = path.resolve(installedPath);
+    let installedPathMatch = installedPathMatches.get(resolvedPath);
+    if (installedPathMatch === undefined) {
+      installedPathMatch = installedPathNamesPiIntercom(resolvedPath);
+      installedPathMatches.set(resolvedPath, installedPathMatch);
+    }
+    return installedPathMatch;
+  };
+}
+
+function packageSourceValue(source: PackageSource) {
+  return typeof source === "string" ? source : source.source;
+}
+
+const CHILD_DISABLED_OPENPI_EXTENSION =
+  "-extensions/git-info/index.ts" as const;
+
+function canonicalExistingPath(value: string) {
+  try {
+    return realpathSync.native(value);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * ENOENT means git-info is truly absent (trimmed fork, partial install):
+ * nothing to exclude. Any other failure (permissions, symlink loops) means we
+ * cannot verify the Git-polling extension is present, so fail closed instead
+ * of running a child with an unverifiable extension.
+ */
+export function resolveGitInfoPathOrThrow(
+  resolve: (value: string) => string = realpathSync.native,
+): string | undefined {
+  try {
+    return resolve(
+      fileURLToPath(new URL("../git-info/index.ts", import.meta.url)),
+    );
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+function excludeOpenPiGitInfoExtension(
+  resources: LoadExtensionsResult,
+  resolve: (value: string) => string = realpathSync.native,
+): LoadExtensionsResult {
+  const gitInfoPath = resolveGitInfoPathOrThrow(resolve);
+  // undefined = absent (ENOENT): nothing to exclude. Non-ENOENT failures
+  // throw from resolveGitInfoPathOrThrow and fail child creation upstream.
+  if (gitInfoPath === undefined) return resources;
+  return {
+    ...resources,
+    extensions: resources.extensions.filter(
+      (extension) =>
+        canonicalExistingPath(extension.resolvedPath) !== gitInfoPath,
+    ),
+  };
+}
+
+function installedPathNamesOpenPi(installedPath: string) {
+  try {
+    const stats = statSync(installedPath);
+    if (stats.isDirectory()) {
+      const manifestPath = path.join(installedPath, "package.json");
+      if (!existsSync(manifestPath)) return false;
+      const manifest = JSON.parse(
+        readFileSync(manifestPath, "utf8"),
+      ) as unknown;
+      return (
+        typeof manifest === "object" &&
+        manifest !== null &&
+        !Array.isArray(manifest) &&
+        (manifest as Record<string, unknown>).name === "@tt-a1i/openpi"
+      );
+    }
+    let current = stats.isFile() ? path.dirname(installedPath) : undefined;
+    while (current) {
+      const manifestPath = path.join(current, "package.json");
+      if (existsSync(manifestPath)) {
+        const manifest = JSON.parse(
+          readFileSync(manifestPath, "utf8"),
+        ) as unknown;
+        return (
+          typeof manifest === "object" &&
+          manifest !== null &&
+          !Array.isArray(manifest) &&
+          (manifest as Record<string, unknown>).name === "@tt-a1i/openpi"
+        );
+      }
+      const parent = path.dirname(current);
+      if (parent === current) return false;
+      current = parent;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+function piMatchesPublishedOpenPiSource(options: {
+  source: string;
+  cwd: string;
+  agentDir: string;
+}) {
+  const settingsManager = SettingsManager.inMemory({
+    packages: [options.source],
+  });
+  const packageManager = new DefaultPackageManager({
+    cwd: options.cwd,
+    agentDir: options.agentDir,
+    settingsManager,
+  });
+  return (
+    packageManager.removeSourceFromSettings("npm:@tt-a1i/openpi") ||
+    packageManager.removeSourceFromSettings(
+      "git:https://github.com/openpi-dev/openpi",
+    ) ||
+    packageManager.removeSourceFromSettings(
+      "git:https://github.com/tt-a1i/openpi",
+    )
+  );
+}
+
+function createOpenPiPackageMatcher(options: {
+  cwd: string;
+  agentDir: string;
+}) {
+  const sourceMatches = new Map<string, boolean>();
+  const installedPathMatches = new Map<string, boolean>();
+  return (source: string, installedPath?: string) => {
+    let sourceMatch = sourceMatches.get(source);
+    if (sourceMatch === undefined) {
+      sourceMatch = piMatchesPublishedOpenPiSource({ source, ...options });
+      sourceMatches.set(source, sourceMatch);
+    }
+    if (sourceMatch || installedPath === undefined) return sourceMatch;
+
+    const resolvedPath = path.resolve(installedPath);
+    let installedPathMatch = installedPathMatches.get(resolvedPath);
+    if (installedPathMatch === undefined) {
+      installedPathMatch = installedPathNamesOpenPi(resolvedPath);
+      installedPathMatches.set(resolvedPath, installedPathMatch);
+    }
+    return installedPathMatch;
+  };
+}
+
+function openPiPackageSources(
+  packageManager: DefaultPackageManager,
+  options: { cwd: string; agentDir: string },
+) {
+  const isOpenPiPackage = createOpenPiPackageMatcher(options);
+  const sources = {
+    user: new Set<string>(),
+    project: new Set<string>(),
+  };
+  for (const configured of packageManager.listConfiguredPackages()) {
+    if (isOpenPiPackage(configured.source, configured.installedPath)) {
+      sources[configured.scope].add(configured.source);
+    }
+  }
+  return sources;
+}
+
+function disablesOpenPiGitInfo(pattern: string) {
+  return (
+    pattern.startsWith("-") &&
+    pattern.slice(1).replace(/^\.\//, "") ===
+      CHILD_DISABLED_OPENPI_EXTENSION.slice(1)
+  );
+}
+
+function disableOpenPiGitInfo(source: PackageSource): PackageSource {
+  if (typeof source !== "string") {
+    if (source.extensions?.length === 0) return source;
+    if (source.autoload === false && source.extensions === undefined) {
+      return source;
+    }
+  }
+  const configured = typeof source === "string" ? { source } : source;
+  const extensions = [...(configured.extensions ?? [])];
+  if (!extensions.some(disablesOpenPiGitInfo)) {
+    extensions.push(CHILD_DISABLED_OPENPI_EXTENSION);
+  }
+  return { ...configured, extensions };
+}
+
+function blockedPackageSources(
+  packageManager: DefaultPackageManager,
+  resolvedPaths: ResolvedPaths,
+  options: { cwd: string; agentDir: string },
+) {
+  const isPiIntercomPackage = createPiIntercomPackageMatcher(options);
+  const blocked = {
+    user: new Set<string>(),
+    project: new Set<string>(),
+  };
+  for (const configured of packageManager.listConfiguredPackages()) {
+    if (isPiIntercomPackage(configured.source, configured.installedPath)) {
+      blocked[configured.scope].add(configured.source);
+    }
+  }
+
+  const resources = [
+    ...resolvedPaths.extensions,
+    ...resolvedPaths.skills,
+    ...resolvedPaths.prompts,
+    ...resolvedPaths.themes,
+  ];
+  for (const resource of resources) {
+    const { metadata } = resource;
+    if (
+      metadata.origin !== "package" ||
+      metadata.scope === "temporary" ||
+      !isPiIntercomPackage(metadata.source, metadata.baseDir)
+    ) {
+      continue;
+    }
+    blocked[metadata.scope].add(metadata.source);
+  }
+  return blocked;
+}
+
+function createEphemeralChildSettings(
+  sourceSettings: SettingsManager,
+  blockedSources: { user: Set<string>; project: Set<string> },
+  openPiSources: { user: Set<string>; project: Set<string> },
+  projectTrusted: boolean,
+) {
+  const globalSettings = sourceSettings.getGlobalSettings();
+  const projectSettings = sourceSettings.getProjectSettings();
+  const settingsForScope = (
+    settings: typeof globalSettings,
+    scope: "user" | "project",
+  ) => ({
+    ...settings,
+    packages: settings.packages
+      ?.filter(
+        (source) => !blockedSources[scope].has(packageSourceValue(source)),
+      )
+      .map((source) =>
+        openPiSources[scope].has(packageSourceValue(source))
+          ? disableOpenPiGitInfo(source)
+          : source,
+      ),
+  });
+  const contents = {
+    global: JSON.stringify(settingsForScope(globalSettings, "user")),
+    project: JSON.stringify(settingsForScope(projectSettings, "project")),
+  };
+  const storage: Parameters<typeof SettingsManager.fromStorage>[0] = {
+    withLock(scope, update) {
+      const next = update(contents[scope]);
+      if (next !== undefined) contents[scope] = next;
+    },
+  };
+  return SettingsManager.fromStorage(storage, { projectTrusted });
+}
+
+async function createChildSettingsManager(options: {
+  cwd: string;
+  agentDir: string;
+  projectTrusted: boolean;
 }) {
-  const resourcePath = resource.resolvedPath ?? resource.filePath;
-  if (!resourcePath) return false;
-  const segments = path.resolve(resourcePath).split(path.sep);
-  return segments.some(
-    (segment, index) =>
-      segment === "node_modules" && segments[index + 1] === "pi-intercom",
+  const sourceSettings = SettingsManager.create(options.cwd, options.agentDir, {
+    projectTrusted: options.projectTrusted,
+  });
+  const packageManager = new DefaultPackageManager({
+    cwd: options.cwd,
+    agentDir: options.agentDir,
+    settingsManager: sourceSettings,
+  });
+  const resolvedPaths = await packageManager.resolve(async () => "skip");
+  const blockedSources = blockedPackageSources(packageManager, resolvedPaths, {
+    cwd: options.cwd,
+    agentDir: options.agentDir,
+  });
+  const openPiSources = openPiPackageSources(packageManager, {
+    cwd: options.cwd,
+    agentDir: options.agentDir,
+  });
+
+  return createEphemeralChildSettings(
+    sourceSettings,
+    blockedSources,
+    openPiSources,
+    options.projectTrusted,
   );
 }
 
@@ -96,6 +495,42 @@ export const CHILD_EXCLUDED_TOOL_NAMES = [
   "context_pivot",
 ] as const;
 
+const PARENT_ONLY_OPENPI_EXTENSION_PATHS = new Set(
+  (Object.keys(OPENPI_TOOL_SURFACE) as OpenPiToolOwner[])
+    .filter((owner) => {
+      const { entry, deferred } = OPENPI_TOOL_SURFACE[owner];
+      const toolNames = [...entry, ...deferred];
+      return (
+        toolNames.length > 0 &&
+        toolNames.every((name) =>
+          CHILD_EXCLUDED_TOOL_NAMES.includes(name as never),
+        )
+      );
+    })
+    .map((owner) => canonicalExistingPath(OPENPI_OWNER_SOURCE_PATHS[owner]))
+    .filter(
+      (extensionPath): extensionPath is string => extensionPath !== undefined,
+    ),
+);
+
+function isVerifiedParentOnlyOpenPiExtension(extension: {
+  path: string;
+  resolvedPath: string;
+  sourceInfo: { path: string };
+}) {
+  return [
+    extension.path,
+    extension.resolvedPath,
+    extension.sourceInfo.path,
+  ].some((candidate) => {
+    const canonicalPath = canonicalExistingPath(candidate);
+    return (
+      canonicalPath !== undefined &&
+      PARENT_ONLY_OPENPI_EXTENSION_PATHS.has(canonicalPath)
+    );
+  });
+}
+
 /**
  * Fresh SDK options avoid turning the denylist into an accidental allowlist.
  *
@@ -133,26 +568,27 @@ export interface ChildResourceOptions {
 /** Load normal global/package resources and trust-gated project resources. */
 export async function createChildResources(options: ChildResourceOptions) {
   const agentDir = options.agentDir ?? getAgentDir();
-  const settingsManager = SettingsManager.create(options.cwd, agentDir, {
+  const settingsManager = await createChildSettingsManager({
+    cwd: options.cwd,
+    agentDir,
     projectTrusted: options.projectTrusted,
   });
   const loader = new DefaultResourceLoader({
     cwd: options.cwd,
     agentDir,
     settingsManager,
+    extensionsOverride(base) {
+      const withoutGitInfo = excludeOpenPiGitInfoExtension(base);
+      return {
+        ...withoutGitInfo,
+        extensions: withoutGitInfo.extensions.filter(
+          (extension) => !isVerifiedParentOnlyOpenPiExtension(extension),
+        ),
+      };
+    },
     ...(options.appendSystemPrompt
       ? { appendSystemPrompt: options.appendSystemPrompt }
       : {}),
-    extensionsOverride: (base) => ({
-      ...base,
-      extensions: base.extensions.filter(
-        (extension) => !isPiIntercomNpmResource(extension),
-      ),
-    }),
-    skillsOverride: (base) => ({
-      ...base,
-      skills: base.skills.filter((skill) => !isPiIntercomNpmResource(skill)),
-    }),
   });
   await loader.reload();
   return { loader, settingsManager };

package/extensions/shared/completion-inbox.ts

@@ -0,0 +1,193 @@
+export type CompletionProducer = "subagent" | "workflow" | "background";
+export type CompletionWakePolicy =
+  | "follow-up"
+  | "next-turn"
+  | "producer-policy";
+
+export interface CompletionOwner {
+  readonly sessionId: string;
+  readonly epoch: number;
+}
+
+export interface CompletionSessionIdentity {
+  getSessionId(): string;
+}
+
+/** Transport metadata only; producer state remains the terminal authority. */
+export interface CompletionEnvelope<T> {
+  readonly deliveryId: string;
+  readonly owner: CompletionOwner;
+  readonly producer: CompletionProducer;
+  readonly producerId: string;
+  readonly terminalRef: unknown;
+  readonly wake: CompletionWakePolicy;
+  readonly payload: T;
+}
+
+export interface CompletionDeadLetter {
+  readonly deliveryId: string;
+  readonly producer: CompletionProducer;
+  readonly producerId: string;
+  readonly failure: "owner-unavailable" | "stale-owner";
+}
+
+function sameOwner(left: CompletionOwner, right: CompletionOwner) {
+  return (
+    Boolean(left.sessionId) &&
+    left.sessionId !== "unowned" &&
+    left.sessionId === right.sessionId &&
+    left.epoch === right.epoch
+  );
+}
+
+let nextOwnerEpoch = 1;
+const ownerBySessionIdentity = new WeakMap<object, CompletionOwner>();
+
+/**
+ * Bind one process-local generation to a Pi SessionManager identity.
+ *
+ * All OpenPI producers observing the same manager share an owner. A replaced
+ * manager, or a manager whose Session id changes, receives a new epoch so late
+ * callbacks cannot target the replacement transcript.
+ */
+export function completionOwnerFor(
+  identity: CompletionSessionIdentity,
+): CompletionOwner {
+  const sessionId = identity.getSessionId();
+  const existing = ownerBySessionIdentity.get(identity);
+  if (existing?.sessionId === sessionId) return existing;
+  const owner = { sessionId, epoch: nextOwnerEpoch++ };
+  ownerBySessionIdentity.set(identity, owner);
+  return owner;
+}
+
+/**
+ * One atomic consumption gate shared by all background producers.
+ *
+ * Claim removes before transport; a failed transport retries the exact
+ * envelopes. A successful transport leaves them consumed. No execution facts
+ * or result bytes are stored here.
+ */
+export function createCompletionInbox<T>() {
+  const pending = new Map<string, CompletionEnvelope<T>>();
+  const inFlight = new Map<string, CompletionEnvelope<T>>();
+  const deadLetters: CompletionDeadLetter[] = [];
+
+  const reject = (
+    envelope: CompletionEnvelope<T>,
+    failure: CompletionDeadLetter["failure"],
+  ) => {
+    deadLetters.push({
+      deliveryId: envelope.deliveryId,
+      producer: envelope.producer,
+      producerId: envelope.producerId,
+      failure,
+    });
+    return false;
+  };
+
+  const admit = (
+    envelope: CompletionEnvelope<T>,
+    owner: CompletionOwner | undefined,
+  ) => {
+    if (!owner) return reject(envelope, "owner-unavailable");
+    if (!sameOwner(envelope.owner, owner)) {
+      return reject(envelope, "stale-owner");
+    }
+    pending.set(envelope.deliveryId, envelope);
+    return true;
+  };
+
+  /** Restore a failed attempt ahead of completions that arrived meanwhile. */
+  const retry = (
+    envelopes: readonly CompletionEnvelope<T>[],
+    owner: CompletionOwner | undefined,
+  ) => {
+    const current = [...pending.values()];
+    pending.clear();
+    for (const envelope of envelopes) {
+      inFlight.delete(envelope.deliveryId);
+      admit(envelope, owner);
+    }
+    for (const envelope of current) admit(envelope, owner);
+  };
+
+  return {
+    defer(envelope: CompletionEnvelope<T>, owner: CompletionOwner | undefined) {
+      return admit(envelope, owner);
+    },
+
+    /** Explicit status/wait and automatic delivery atomically race here. */
+    consume(producer: CompletionProducer, producerIds: Iterable<string>) {
+      const ids = new Set(producerIds);
+      for (const [deliveryId, envelope] of pending) {
+        if (envelope.producer === producer && ids.has(envelope.producerId)) {
+          pending.delete(deliveryId);
+          inFlight.delete(deliveryId);
+        }
+      }
+    },
+
+    consumeDeliveryIds(deliveryIds: Iterable<string>) {
+      for (const deliveryId of deliveryIds) {
+        pending.delete(deliveryId);
+        inFlight.delete(deliveryId);
+      }
+    },
+
+    claim(
+      owner: CompletionOwner | undefined,
+      maximum = Number.POSITIVE_INFINITY,
+    ) {
+      const claimed: CompletionEnvelope<T>[] = [];
+      for (const [deliveryId, envelope] of pending) {
+        if (claimed.length >= maximum) break;
+        pending.delete(deliveryId);
+        if (!owner) {
+          reject(envelope, "owner-unavailable");
+          continue;
+        }
+        if (!sameOwner(envelope.owner, owner)) {
+          reject(envelope, "stale-owner");
+          continue;
+        }
+        inFlight.set(deliveryId, envelope);
+        claimed.push(envelope);
+      }
+      return claimed;
+    },
+
+    retry,
+
+    retryClaimed(
+      producer: CompletionProducer,
+      producerIds: Iterable<string>,
+      owner: CompletionOwner | undefined,
+    ) {
+      const ids = new Set(producerIds);
+      const envelopes = [...inFlight.values()].filter(
+        (envelope) =>
+          envelope.producer === producer && ids.has(envelope.producerId),
+      );
+      retry(envelopes, owner);
+    },
+
+    acknowledge(deliveryIds: Iterable<string>) {
+      for (const deliveryId of deliveryIds) inFlight.delete(deliveryId);
+    },
+
+    size() {
+      return pending.size;
+    },
+
+    inspectDeadLetters() {
+      return [...deadLetters];
+    },
+
+    clear() {
+      pending.clear();
+      inFlight.clear();
+      deadLetters.length = 0;
+    },
+  };
+}