pi-extended-teams 2.1.16

package/extensions/internal/pi-command.test.ts

@@ -0,0 +1,191 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { spawnSync } from "node:child_process";
+import { buildExtensionArgs, buildPiCommand, checkChildPiModelAvailability, getPiExtendedTeamsExtensionSource, getPiLaunchCommand, isModelListed, resolvePiExtendedTeamsExtensionSource } from "./pi-command";
+
+const originalExtendedSource = process.env.PI_EXTENDED_TEAMS_EXTENSION_SOURCE;
+const originalLegacySource = process.env.PI_TEAMS_EXTENSION_SOURCE;
+const originalPreflight = process.env.PI_EXTENDED_TEAMS_MODEL_PREFLIGHT;
+const originalLegacyPreflight = process.env.PI_TEAMS_MODEL_PREFLIGHT;
+
+function restoreEnv() {
+  if (originalExtendedSource === undefined) delete process.env.PI_EXTENDED_TEAMS_EXTENSION_SOURCE;
+  else process.env.PI_EXTENDED_TEAMS_EXTENSION_SOURCE = originalExtendedSource;
+
+  if (originalLegacySource === undefined) delete process.env.PI_TEAMS_EXTENSION_SOURCE;
+  else process.env.PI_TEAMS_EXTENSION_SOURCE = originalLegacySource;
+
+  if (originalPreflight === undefined) delete process.env.PI_EXTENDED_TEAMS_MODEL_PREFLIGHT;
+  else process.env.PI_EXTENDED_TEAMS_MODEL_PREFLIGHT = originalPreflight;
+
+  if (originalLegacyPreflight === undefined) delete process.env.PI_TEAMS_MODEL_PREFLIGHT;
+  else process.env.PI_TEAMS_MODEL_PREFLIGHT = originalLegacyPreflight;
+}
+
+describe("pi command helpers", () => {
+  afterEach(() => {
+    restoreEnv();
+  });
+
+  it("quotes the pi launch command so the shell cannot expand the install path", () => {
+    const originalArgv1 = process.argv[1];
+    try {
+      process.argv[1] = "/tmp/pi $(id -u)/dist/cli.js";
+      const launch = getPiLaunchCommand();
+
+      // Match the tmux adapter's `sh -c` boundary.
+      const echoed = spawnSync("sh", ["-c", launch.replace(/^node /, "echo ")], { encoding: "utf-8" });
+      expect(echoed.stdout.trim()).toBe("/tmp/pi $(id -u)/dist/cli.js");
+    } finally {
+      if (originalArgv1 === undefined) delete (process.argv as unknown as Record<number, string>)[1];
+      else process.argv[1] = originalArgv1;
+    }
+  });
+
+  it("falls back to a nearby checkout from cwd when the installed module path cannot find the extension", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "pet-pi-cwd-"));
+    try {
+      const cwd = path.join(root, "pi-extended-teams");
+      const extensionPath = path.join(cwd, "extensions", "index.ts");
+      fs.mkdirSync(path.dirname(extensionPath), { recursive: true });
+      fs.writeFileSync(extensionPath, "export default function () {}\n");
+
+      expect(resolvePiExtendedTeamsExtensionSource({
+        env: {},
+        filename: path.join(root, "missing-install", "extensions", "internal", "pi-command.js"),
+        cwd,
+      })).toBe(extensionPath);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("falls back to the extension entrypoint instead of the internal command helper", () => {
+    delete process.env.PI_EXTENDED_TEAMS_EXTENSION_SOURCE;
+    delete process.env.PI_TEAMS_EXTENSION_SOURCE;
+
+    const source = getPiExtendedTeamsExtensionSource().replace(/\\/g, "/");
+
+    expect(source).toMatch(/\/extensions\/index\.(ts|js|mjs|cjs)$/);
+    expect(source).not.toContain("/extensions/internal/");
+    expect(buildExtensionArgs()).toContain("--extension");
+    expect(buildPiCommand("pi", "provider/model")).toContain("/extensions/index.");
+  });
+
+  it("keeps normal Pi skill discovery enabled and propagates an untrusted parent", () => {
+    const command = buildPiCommand("pi", "provider/model", "high", [], false);
+    expect(command).toContain("--no-approve --no-extensions");
+    expect(command).toContain("--model 'provider/model:high'");
+    expect(command).not.toContain("--no-skills");
+  });
+
+  it("routes spawned Pi sessions to an explicitly quoted private directory", () => {
+    const command = buildPiCommand(
+      "pi",
+      "provider/model",
+      "high",
+      [],
+      false,
+      undefined,
+      "/tmp/$HOME/private agent sessions",
+    );
+
+    expect(command).toContain("--session-dir '/tmp/$HOME/private agent sessions'");
+    expect(command).toContain("--model 'provider/model:high'");
+  });
+
+  it("still honors explicit extension source environment overrides and loads self exactly once", () => {
+    process.env.PI_EXTENDED_TEAMS_EXTENSION_SOURCE = "/tmp/custom-extension.ts";
+    delete process.env.PI_TEAMS_EXTENSION_SOURCE;
+
+    expect(getPiExtendedTeamsExtensionSource()).toBe("/tmp/custom-extension.ts");
+    const args = buildExtensionArgs(["/tmp/custom-extension.ts", "/tmp/external.ts", "/tmp/external.ts"]);
+    expect(args.match(/'\/tmp\/custom-extension\.ts'/g)).toHaveLength(1);
+    expect(args.match(/'\/tmp\/external\.ts'/g)).toHaveLength(1);
+  });
+
+  it("canonical-dedupes self and selected extension symlinks", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "pet-pi-extension-args-"));
+    try {
+      const self = path.join(root, "self.ts");
+      const selfLink = path.join(root, "self-link.ts");
+      const selected = path.join(root, "selected.ts");
+      const selectedLink = path.join(root, "selected-link.ts");
+      fs.writeFileSync(self, "export default function () {}\n");
+      fs.writeFileSync(selected, "export default function () {}\n");
+      fs.symlinkSync(self, selfLink);
+      fs.symlinkSync(selected, selectedLink);
+
+      const args = buildExtensionArgs([selfLink, selected, selectedLink], true, self);
+      expect(args).toContain(`--approve --no-extensions --extension '${self}'`);
+      expect(args.match(/--extension/g)).toHaveLength(2);
+      expect(args).toContain(`--extension '${selected}'`);
+      expect(args).not.toContain(selfLink);
+      expect(args).not.toContain(selectedLink);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("single-quotes arbitrary selected paths so sh -c cannot expand dollar signs", () => {
+    const args = buildExtensionArgs(["/tmp/$HOME/selected extension.ts"]);
+    expect(args).toContain("--extension '/tmp/$HOME/selected extension.ts'");
+  });
+
+  it("matches fully qualified models in pi list output", () => {
+    const output = [
+      "provider                              model                     context  max-out  thinking  images",
+      "anthropic-250k-prefer-using-this-one  claude-opus-4-8           250K     128K     yes       yes",
+      "anthropic                             claude-opus-4-8           1M       128K     yes       yes",
+    ].join("\n");
+
+    expect(isModelListed(output, "anthropic-250k-prefer-using-this-one/claude-opus-4-8")).toBe(true);
+    expect(isModelListed(output, "anthropic-250k-prefer-using-this-one/claude-opus-4-7")).toBe(false);
+  });
+
+  it("checks the child Pi model registry with the spawn extension set", () => {
+    delete process.env.PI_EXTENDED_TEAMS_MODEL_PREFLIGHT;
+    delete process.env.PI_TEAMS_MODEL_PREFLIGHT;
+
+    const result = checkChildPiModelAvailability("pi", "provider/model", ["/tmp/bootstrap"], {
+      projectTrusted: true,
+      run: (command) => ({
+        status: 0,
+        stdout: command.includes("--extension '/tmp/bootstrap'") ? "provider  model  context" : "",
+        stderr: "",
+      }),
+    });
+
+    expect(result.status).toBe("available");
+    expect(result.command).toContain("--approve --no-extensions");
+    expect(result.command).toContain("--extension '/tmp/bootstrap'");
+  });
+
+  it("checks stderr when Pi writes the model table there", () => {
+    delete process.env.PI_EXTENDED_TEAMS_MODEL_PREFLIGHT;
+    delete process.env.PI_TEAMS_MODEL_PREFLIGHT;
+
+    const result = checkChildPiModelAvailability("pi", "provider/model", ["/tmp/bootstrap"], {
+      run: () => ({
+        status: 0,
+        stdout: "",
+        stderr: "provider  model  context",
+      }),
+    });
+
+    expect(result.status).toBe("available");
+  });
+
+  it("skips child Pi model checks when preflight is disabled", () => {
+    process.env.PI_EXTENDED_TEAMS_MODEL_PREFLIGHT = "0";
+
+    const result = checkChildPiModelAvailability("pi", "provider/model", ["/tmp/bootstrap"], {
+      run: () => { throw new Error("preflight should not run"); },
+    });
+
+    expect(result.status).toBe("skipped");
+    expect(result.command).toBeNull();
+  });
+});

package/extensions/internal/pi-command.ts

@@ -0,0 +1,224 @@
+import { spawnSync } from "node:child_process";
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+
+/**
+ * Build the command used to relaunch pi for teammate processes.
+ *
+ * There are three common cases:
+ * - npm/node install: pi runs as `node .../dist/cli.js`
+ * - standalone compiled binary: process.execPath is the actual `pi` executable
+ * - shim-based installs (e.g. Volta): process.execPath is `node` and argv[1]
+ *   may be a shim path, so the safest relaunch command is plain `pi`
+ */
+export function getPiLaunchCommand(): string {
+  const argv1 = process.argv[1];
+  const execPath = process.execPath;
+
+  if (argv1) {
+    const ext = path.extname(argv1).toLowerCase();
+    const looksLikeScript = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"].includes(ext)
+      || /(?:^|[/\\])dist[/\\]cli\.js$/i.test(argv1);
+
+    if (looksLikeScript) {
+      return `node ${shellQuote(argv1)}`;
+    }
+  }
+
+  if (execPath) {
+    const base = path.basename(execPath).toLowerCase();
+    if (base !== "node" && base !== "node.exe" && base !== "bun" && base !== "bun.exe") {
+      return shellQuote(execPath);
+    }
+  }
+
+  return "pi";
+}
+
+export function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+function extensionPathIdentity(source: string): string {
+  const absolute = path.resolve(source);
+  try {
+    return nodeFs.realpathSync(absolute);
+  } catch {
+    return absolute;
+  }
+}
+
+const EXTENSION_ENTRYPOINTS = ["index.ts", "index.js", "index.mjs", "index.cjs"];
+const DISABLED_PREFLIGHT_VALUES = new Set(["", "0", "false", "no", "off"]);
+
+interface ExtensionSourceFileSystem {
+  existsSync(filePath: string): boolean;
+}
+
+export interface ExtensionSourceResolutionOptions {
+  env?: Record<string, string | undefined>;
+  filename?: string;
+  cwd?: string;
+  fileSystem?: ExtensionSourceFileSystem;
+}
+
+const defaultFileSystem: ExtensionSourceFileSystem = {
+  existsSync: nodeFs.existsSync,
+};
+
+function firstExistingPath(candidates: string[], fileSystem: ExtensionSourceFileSystem): string | null {
+  return candidates.find(candidate => fileSystem.existsSync(candidate)) ?? null;
+}
+
+function findExtensionSourceFromCwd(cwd: string, fileSystem: ExtensionSourceFileSystem): string | null {
+  return firstExistingPath([
+    ...EXTENSION_ENTRYPOINTS.map(entrypoint => path.join(cwd, "extensions", entrypoint)),
+    ...EXTENSION_ENTRYPOINTS.map(entrypoint => path.join(cwd, "pi-extended-teams", "extensions", entrypoint)),
+    ...EXTENSION_ENTRYPOINTS.map(entrypoint => path.join(path.dirname(cwd), "pi-extended-teams", "extensions", entrypoint)),
+  ], fileSystem);
+}
+
+function getExtensionEntrypointFallback(options: Required<Omit<ExtensionSourceResolutionOptions, "env">>): string {
+  const ext = path.extname(options.filename) || ".js";
+  const moduleRelativeCandidate = path.join(path.dirname(path.dirname(options.filename)), `index${ext}`);
+  const moduleRelativeCandidates = [
+    moduleRelativeCandidate,
+    ...EXTENSION_ENTRYPOINTS.map(entrypoint => path.join(path.dirname(path.dirname(options.filename)), entrypoint)),
+  ];
+
+  return firstExistingPath(moduleRelativeCandidates, options.fileSystem)
+    ?? findExtensionSourceFromCwd(options.cwd, options.fileSystem)
+    ?? moduleRelativeCandidate;
+}
+
+export function resolvePiExtendedTeamsExtensionSource(options: ExtensionSourceResolutionOptions = {}): string {
+  const env = options.env ?? process.env;
+  const explicitSource = env.PI_EXTENDED_TEAMS_EXTENSION_SOURCE || env.PI_TEAMS_EXTENSION_SOURCE;
+  if (explicitSource) return explicitSource;
+
+  return getExtensionEntrypointFallback({
+    filename: options.filename ?? __filename,
+    cwd: options.cwd ?? process.cwd(),
+    fileSystem: options.fileSystem ?? defaultFileSystem,
+  });
+}
+
+export function getPiExtendedTeamsExtensionSource(): string {
+  return resolvePiExtendedTeamsExtensionSource();
+}
+
+export function buildExtensionArgs(
+  allowedExtensions: readonly string[] = [],
+  projectTrusted?: boolean,
+  selfExtensionSource = getPiExtendedTeamsExtensionSource(),
+): string {
+  const trustArgs = projectTrusted === undefined ? [] : [projectTrusted ? "--approve" : "--no-approve"];
+  const parts = [...trustArgs, "--no-extensions", "--extension", shellQuote(selfExtensionSource)];
+  const seen = new Set([extensionPathIdentity(selfExtensionSource)]);
+  for (const source of allowedExtensions) {
+    const identity = extensionPathIdentity(source);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    parts.push("--extension", shellQuote(source));
+  }
+  return parts.join(" ");
+}
+
+export function buildPiCommand(
+  piBinary: string,
+  chosenModel?: string,
+  thinking?: string,
+  allowedExtensions: readonly string[] = [],
+  projectTrusted?: boolean,
+  selfExtensionSource?: string,
+  sessionDir?: string,
+): string {
+  const extensionArgs = buildExtensionArgs(allowedExtensions, projectTrusted, selfExtensionSource);
+  const sessionArgs = sessionDir ? ` --session-dir ${shellQuote(sessionDir)}` : "";
+
+  if (chosenModel) {
+    const modelArg = thinking ? `${chosenModel}:${thinking}` : chosenModel;
+    return `${piBinary} ${extensionArgs}${sessionArgs} --model ${shellQuote(modelArg)}`;
+  }
+
+  if (thinking) {
+    return `${piBinary} ${extensionArgs}${sessionArgs} --thinking ${shellQuote(thinking)}`;
+  }
+
+  return `${piBinary} ${extensionArgs}${sessionArgs}`;
+}
+
+export type ChildPiModelAvailabilityStatus = "available" | "missing" | "unknown" | "skipped";
+
+export interface ChildPiModelAvailability {
+  status: ChildPiModelAvailabilityStatus;
+  command: string | null;
+  stdout: string;
+  stderr: string;
+  exitStatus: number | null;
+}
+
+export interface ChildPiModelAvailabilityOptions {
+  run?: (command: string) => { status: number | null; stdout: string; stderr: string };
+  timeoutMs?: number;
+  projectTrusted?: boolean;
+  selfExtensionSource?: string;
+}
+
+function defaultRun(command: string, timeoutMs: number): { status: number | null; stdout: string; stderr: string } {
+  const result = spawnSync("sh", ["-c", command], { encoding: "utf-8", timeout: timeoutMs });
+  return {
+    status: result.status,
+    stdout: result.stdout?.toString() ?? "",
+    stderr: result.stderr?.toString() ?? result.error?.message ?? "",
+  };
+}
+
+function parseModelSpecifier(model: string): { provider: string; model: string } | null {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex === -1) return null;
+
+  const provider = model.slice(0, slashIndex).trim();
+  const modelId = model.slice(slashIndex + 1).trim();
+  if (!provider || !modelId) return null;
+
+  return { provider, model: modelId };
+}
+
+export function isModelListed(output: string, chosenModel: string): boolean {
+  const parsed = parseModelSpecifier(chosenModel);
+  if (!parsed) return false;
+
+  return output.split("\n").some((line) => {
+    const [provider, model] = line.trim().split(/\s+/);
+    return provider === parsed.provider && model === parsed.model;
+  });
+}
+
+export function checkChildPiModelAvailability(
+  piBinary: string,
+  chosenModel: string | undefined,
+  allowedExtensions: readonly string[] = [],
+  options: ChildPiModelAvailabilityOptions = {}
+): ChildPiModelAvailability {
+  const preflightSetting = process.env.PI_EXTENDED_TEAMS_MODEL_PREFLIGHT ?? process.env.PI_TEAMS_MODEL_PREFLIGHT;
+  if (!chosenModel || DISABLED_PREFLIGHT_VALUES.has(preflightSetting?.trim().toLowerCase() ?? "enabled")) {
+    return { status: "skipped", command: null, stdout: "", stderr: "", exitStatus: null };
+  }
+
+  const command = `${piBinary} ${buildExtensionArgs(allowedExtensions, options.projectTrusted, options.selfExtensionSource)} --list-models`;
+  const run = options.run ?? ((cmd: string) => defaultRun(cmd, options.timeoutMs ?? 10000));
+  const result = run(command);
+  const modelListOutput = `${result.stdout}\n${result.stderr}`;
+  const status = result.status === 0
+    ? isModelListed(modelListOutput, chosenModel) ? "available" : "missing"
+    : "unknown";
+
+  return {
+    status,
+    command,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitStatus: result.status,
+  };
+}

package/extensions/internal/pi-runtime-api.test.ts

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { resolvePiRuntimeModulePath } from "./pi-runtime-api";
+
+const roots: string[] = [];
+
+function packageEntrypoint(root: string, scope: string, name: string): string {
+  const packageDir = path.join(root, "node_modules", scope, name);
+  const entrypoint = path.join(packageDir, "index.js");
+  fs.mkdirSync(packageDir, { recursive: true });
+  fs.writeFileSync(path.join(packageDir, "package.json"), JSON.stringify({
+    name: `${scope}/${name}`,
+    type: "module",
+    exports: "./index.js",
+  }));
+  fs.writeFileSync(entrypoint, "export const marker = true;\n");
+  return entrypoint;
+}
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe("active Pi runtime API resolution", () => {
+  it("prefers the active @earendil package over legacy local peers", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "pet-pi-runtime-"));
+    roots.push(root);
+    const current = packageEntrypoint(root, "@earendil-works", "pi-coding-agent");
+    packageEntrypoint(root, "@mariozechner", "pi-coding-agent");
+
+    expect(resolvePiRuntimeModulePath(path.join(root, "pi-cli.js"))).toBe(fs.realpathSync(current));
+  });
+
+  it("retains the legacy package as a compatibility fallback", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "pet-pi-runtime-"));
+    roots.push(root);
+    const legacy = packageEntrypoint(root, "@mariozechner", "pi-coding-agent");
+
+    expect(resolvePiRuntimeModulePath(path.join(root, "pi-cli.js"))).toBe(fs.realpathSync(legacy));
+  });
+});

package/extensions/internal/pi-runtime-api.ts

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type * as LegacyPiApi from "@mariozechner/pi-coding-agent";
+
+export type PiRuntimeApi = typeof LegacyPiApi;
+
+const CURRENT_PI_PACKAGE = "@earendil-works/pi-coding-agent";
+const LEGACY_PI_PACKAGE = "@mariozechner/pi-coding-agent";
+let runtimeApiPromise: Promise<PiRuntimeApi> | undefined;
+
+function requireRoots(fromFile?: string): string[] {
+  const roots = [fromFile, process.argv[1], __filename]
+    .filter((value): value is string => typeof value === "string" && value.length > 0)
+    .map((value) => path.resolve(value));
+  return Array.from(new Set(roots));
+}
+
+function packageExportPath(packageDir: string, expectedName: string): string | undefined {
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf-8"));
+    if (manifest.name !== expectedName) return undefined;
+    const rootExport = manifest.exports?.["."] ?? manifest.exports;
+    const relativeEntrypoint = typeof rootExport === "string"
+      ? rootExport
+      : rootExport?.import ?? rootExport?.default ?? rootExport?.require ?? manifest.module ?? manifest.main;
+    return typeof relativeEntrypoint === "string"
+      ? path.resolve(packageDir, relativeEntrypoint)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveImportOnlyPackage(packageName: string, fromFile: string): string | undefined {
+  let directory = path.dirname(fromFile);
+  while (true) {
+    const ownPackage = packageExportPath(directory, packageName);
+    if (ownPackage) return ownPackage;
+    const dependencyPackage = packageExportPath(path.join(directory, "node_modules", packageName), packageName);
+    if (dependencyPackage) return dependencyPackage;
+    const parent = path.dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+/** Resolve package exports from the active Pi executable before local peer fallbacks. */
+export function resolvePiRuntimeModulePath(fromFile?: string): string {
+  const roots = requireRoots(fromFile);
+  for (const packageName of [CURRENT_PI_PACKAGE, LEGACY_PI_PACKAGE]) {
+    for (const root of roots) {
+      try {
+        return createRequire(root).resolve(packageName);
+      } catch {
+        const importOnlyPath = resolveImportOnlyPackage(packageName, root);
+        if (importOnlyPath) return importOnlyPath;
+      }
+    }
+  }
+  throw new Error("Could not resolve the active Pi coding-agent API.");
+}
+
+async function importPiRuntimeApi(): Promise<PiRuntimeApi> {
+  const modulePath = resolvePiRuntimeModulePath();
+  return await import(pathToFileURL(modulePath).href) as PiRuntimeApi;
+}
+
+/**
+ * Use the SDK/configuration classes belonging to the running Pi process.
+ * This prevents a package-local legacy peer from replacing current resolver,
+ * trust, loader, or session behavior.
+ */
+export function loadPiRuntimeApi(): Promise<PiRuntimeApi> {
+  runtimeApiPromise ??= importPiRuntimeApi();
+  return runtimeApiPromise;
+}

package/extensions/internal/schema.ts

@@ -0,0 +1,19 @@
+import { Type } from "@sinclair/typebox";
+
+/**
+ * Creates a Google-compatible string enum schema using this package's TypeBox
+ * instance. The upstream `@mariozechner/pi-ai` helper can resolve to a
+ * different TypeBox instance in this package, which makes `Type.Optional()`
+ * reject its `TUnsafe` type at compile time.
+ */
+export function StringEnum<T extends readonly string[]>(
+  values: T,
+  options?: { description?: string; default?: T[number] }
+) {
+  return Type.Unsafe<T[number]>({
+    type: "string",
+    enum: values,
+    ...(options?.description && { description: options.description }),
+    ...(options?.default && { default: options.default }),
+  });
+}