@tt-a1i/openpi 0.4.0 → 0.5.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,385 @@ 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 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 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;
+const OPENPI_GIT_INFO_EXTENSION_PATH = realpathSync.native(
+  fileURLToPath(new URL("../git-info/index.ts", import.meta.url)),
+);
+
+function canonicalExistingPath(value: string) {
+  try {
+    return realpathSync.native(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function excludeOpenPiGitInfoExtension(
+  resources: LoadExtensionsResult,
+): LoadExtensionsResult {
+  return {
+    ...resources,
+    extensions: resources.extensions.filter(
+      (extension) =>
+        canonicalExistingPath(extension.resolvedPath) !==
+        OPENPI_GIT_INFO_EXTENSION_PATH,
+    ),
+  };
+}
+
+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 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 +475,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 +548,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/result-delivery.ts

@@ -0,0 +1,34 @@
+/** Minimum lifecycle contract shared by deferred result queues. */
+export interface ResultDeliveryQueue<T> {
+  defer(result: T): void;
+  size(): number;
+  clear(): void;
+}
+
+/** One-shot results are removed by either an explicit consumer or delivery. */
+export interface ConsumableResultDeliveryQueue<T, TId = string>
+  extends ResultDeliveryQueue<T> {
+  consume(ids: Iterable<TId>): void;
+}
+
+/** Stable identity carried by a durable, at-least-once result. */
+export interface DurableResultEnvelope {
+  deliveryId: string;
+}
+
+/** Per-result acknowledgement for a durable delivery attempt. */
+export interface DurableResultDeliveryReceipt {
+  deliveryId: string;
+  delivered: boolean;
+  error?: string;
+}
+
+/**
+ * Durable queues can reconstruct pending ownership after restart and retry it
+ * at an explicit lifecycle boundary without changing the stable delivery id.
+ */
+export interface DurableResultDeliveryQueue<T extends DurableResultEnvelope>
+  extends ResultDeliveryQueue<T> {
+  restore(result: T): boolean;
+  retryPending(): Promise<void>;
+}