@tt-a1i/openpi 0.3.1 → 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;
 
@@ -22,7 +32,13 @@ export const CHILD_SHUTDOWN_TIMEOUT_MS = 5_000;
  * `registerTool(createEditToolDefinition(...))`); an unrecognized factory
  * registration fails the guard rather than escaping it.
  */
-export const CHILD_SAFE_PACKAGE_TOOL_NAMES = ["fd", "rg"] as const;
+export const CHILD_SAFE_PACKAGE_TOOL_NAMES = [
+  "fd",
+  "rg",
+  "git_show",
+  "git_diff",
+  "git_log",
+] as const;
 
 /**
  * pi-intercom resources are unsafe inside concurrent in-process child sessions.
@@ -31,16 +47,385 @@ export const CHILD_SAFE_PACKAGE_TOOL_NAMES = ["fd", "rg"] as const;
  * 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;
+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 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 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,
   );
 }
 
@@ -90,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.
  *
@@ -127,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-budget.ts

@@ -0,0 +1,134 @@
+export interface ParentContextUsage {
+  readonly tokens: number | null;
+  readonly contextWindow: number;
+}
+
+export interface ResultBudgetPolicy {
+  readonly maxBatchBytes: number;
+  readonly maxResultBytes: number;
+  readonly minResultBytes: number;
+  readonly headroomShare: number;
+  readonly estimatedBytesPerToken: number;
+  /** Batch metadata that consumes the same parent-context headroom. */
+  readonly fixedBytes?: number;
+}
+
+export interface ResultBudgetAllocation {
+  readonly budgets: readonly number[];
+  readonly batchBytes: number;
+  readonly source: "static" | "dynamic";
+}
+
+function validUsage(
+  usage: ParentContextUsage | null | undefined,
+): usage is { readonly tokens: number; readonly contextWindow: number } {
+  return Boolean(
+    usage &&
+      typeof usage.tokens === "number" &&
+      Number.isFinite(usage.tokens) &&
+      usage.tokens >= 0 &&
+      Number.isFinite(usage.contextWindow) &&
+      usage.contextWindow > 0,
+  );
+}
+
+function distribute(
+  desired: readonly number[],
+  batchBytes: number,
+  minResultBytes: number,
+) {
+  const budgets = desired.map((bytes) => Math.min(bytes, minResultBytes));
+  let remaining = Math.max(
+    0,
+    batchBytes - budgets.reduce((sum, bytes) => sum + bytes, 0),
+  );
+  let active = desired
+    .map((bytes, index) => ({ bytes, index }))
+    .filter(({ bytes, index }) => bytes > budgets[index]!);
+
+  while (remaining > 0 && active.length > 0) {
+    const share = Math.floor(remaining / active.length);
+    if (share === 0) {
+      for (const { bytes, index } of active) {
+        if (remaining === 0) break;
+        if (budgets[index]! >= bytes) continue;
+        budgets[index]! += 1;
+        remaining--;
+      }
+      break;
+    }
+
+    const satisfied = active.filter(
+      ({ bytes, index }) => bytes - budgets[index]! <= share,
+    );
+    if (satisfied.length > 0) {
+      for (const { bytes, index } of satisfied) {
+        const addition = bytes - budgets[index]!;
+        budgets[index]! = bytes;
+        remaining -= addition;
+      }
+      const settled = new Set(satisfied.map(({ index }) => index));
+      active = active.filter(({ index }) => !settled.has(index));
+      continue;
+    }
+
+    for (const { index } of active) budgets[index]! += share;
+    remaining -= share * active.length;
+  }
+
+  return budgets;
+}
+
+/**
+ * Allocate one bounded projection budget per result. Small results yield their
+ * unused share to larger siblings. Parent context usage is optional: Pi marks
+ * it unknown after compaction until a fresh response, in which case the
+ * deterministic static batch cap remains the source of truth.
+ */
+export function allocateResultBudgets(
+  resultBytes: readonly number[],
+  usage: ParentContextUsage | null | undefined,
+  policy: ResultBudgetPolicy,
+): ResultBudgetAllocation {
+  if (resultBytes.length === 0) {
+    return { budgets: [], batchBytes: 0, source: "static" };
+  }
+
+  const desired = resultBytes.map((bytes) =>
+    Math.min(policy.maxResultBytes, Math.max(0, Math.floor(bytes))),
+  );
+  const perResultFloor = Math.min(
+    policy.minResultBytes,
+    Math.floor(policy.maxBatchBytes / resultBytes.length),
+  );
+  const desiredTotal = desired.reduce((sum, bytes) => sum + bytes, 0);
+  const staticBatchBytes = Math.min(policy.maxBatchBytes, desiredTotal);
+  const minimumBatchBytes = desired.reduce(
+    (sum, bytes) => sum + Math.min(bytes, perResultFloor),
+    0,
+  );
+
+  let batchBytes = staticBatchBytes;
+  let source: ResultBudgetAllocation["source"] = "static";
+  if (validUsage(usage)) {
+    const headroomTokens = Math.max(0, usage.contextWindow - usage.tokens);
+    const dynamicBytes = Math.max(
+      0,
+      Math.floor(
+        headroomTokens * policy.headroomShare * policy.estimatedBytesPerToken,
+      ) - Math.max(0, policy.fixedBytes ?? 0),
+    );
+    const narrowed = Math.max(
+      minimumBatchBytes,
+      Math.min(staticBatchBytes, dynamicBytes),
+    );
+    if (narrowed < staticBatchBytes) source = "dynamic";
+    batchBytes = narrowed;
+  }
+
+  return {
+    budgets: distribute(desired, batchBytes, perResultFloor),
+    batchBytes,
+    source,
+  };
+}

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>;
+}