pi-maestro-teammate 2.1.0 → 2.2.0

package/bin/pi-teammate-outbox.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, { interopDefault: true });
+const { main } = await jiti.import("../src/completion-outbox/cli.ts");
+
+try {
+  process.exitCode = await main(process.argv.slice(2));
+} catch (error) {
+  process.stderr.write(`pi-teammate-outbox: ${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-maestro-teammate",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Pi extension — teammate agent dispatch with DAG task graphs, RPC messaging, and compact TUI",
   "type": "module",
   "engines": {
@@ -9,6 +9,7 @@
   "bin": {
     "pi-teammate-broker": "./bin/pi-teammate-broker.mjs",
     "pi-teammate-models": "./bin/pi-teammate-models.mjs",
+    "pi-teammate-outbox": "./bin/pi-teammate-outbox.mjs",
     "pi-teammate-remote": "./bin/pi-teammate-remote.mjs"
   },
   "keywords": [
@@ -19,7 +20,7 @@
     "agents"
   ],
   "scripts": {
-    "test": "node --experimental-transform-types --import ./test/setup.ts --test --test-concurrency=4 \"test/*.test.ts\"",
+    "test": "node --experimental-transform-types --import ./test/setup.ts --test --test-concurrency=2 \"test/*.test.ts\"",
     "typecheck": "tsc -p tsconfig.build.json",
     "build:declarations": "tsc -p tsconfig.declarations.json",
     "check:declarations": "node scripts/check-declarations.mjs",

package/src/backends/acp-cli.ts

@@ -796,6 +796,7 @@ export function createAcpCliBackend(
  * registration ship fields whose keys have no text.
  */
 export { ACP_CLI_SETTINGS_CATALOGS } from "./acp-cli-catalog.ts";
+export { probeSshCliExecutable } from "../remote/ssh-exec.ts";
 
 /**
  * The registered instance.

package/src/cli-tools/cli-tools-config.ts

@@ -17,7 +17,6 @@
  * ~/.maestro/cli-tools.json for pi-maestro-flow's original provider registration.
  */
 
-import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -82,7 +81,6 @@ export interface MaestroDelegateConfig {
 
 const GLOBAL_CONFIG_FILE = "teammate-cli-tools.json";
 const LEGACY_CONFIG_PATH = path.join(os.homedir(), ".maestro", "cli-tools.json");
-const PROBE_TIMEOUT_MS = 2_000;
 const PROBE_CACHE_TTL_MS = 30_000;
 
 export function getGlobalCliToolsConfigPath(): string {
@@ -326,6 +324,34 @@ function adapterInstallHint(command: string): string {
   return pkg === undefined ? "" : `; install it with: npm i -g ${pkg}`;
 }
 
+function localExecutableCandidates(command: string): string[] {
+  const hasPathSeparator = command.includes("/") || command.includes("\\");
+  const directories = hasPathSeparator
+    ? [process.cwd()]
+    : (process.env.PATH ?? "").split(path.delimiter).map((entry) => {
+      const trimmed = entry.trim();
+      return trimmed.replace(/^"|"$/g, "") || process.cwd();
+    });
+  const extensions = process.platform === "win32" && path.extname(command) === ""
+    ? ["", ...(process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";")]
+    : [""];
+  return [...new Set(directories.flatMap((directory) =>
+    extensions.map((extension) => path.resolve(directory, `${command}${extension.toLowerCase()}`)),
+  ))];
+}
+
+function localExecutableExists(command: string): boolean {
+  return localExecutableCandidates(command).some((candidate) => {
+    try {
+      if (!fs.statSync(candidate).isFile()) return false;
+      fs.accessSync(candidate, process.platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+
 function probeLocalExecutable(key: string, command: string): CliToolProbeResult {
   const quotedCommand = JSON.stringify(command);
   let result: CliToolProbeResult;
@@ -351,18 +377,9 @@ function probeLocalExecutable(key: string, command: string): CliToolProbeResult
       };
     }
   } else {
-    try {
-      const lookup = process.platform === "win32" ? "where" : "which";
-      execFileSync(lookup, [command], {
-        encoding: "utf8",
-        timeout: PROBE_TIMEOUT_MS,
-        stdio: ["ignore", "ignore", "pipe"],
-        windowsHide: true,
-      });
-      result = { ok: true, command };
-    } catch {
-      result = { ok: false, command, error: `executable ${quotedCommand} not found on PATH${adapterInstallHint(command)}` };
-    }
+    result = localExecutableExists(command)
+      ? { ok: true, command }
+      : { ok: false, command, error: `executable ${quotedCommand} not found on PATH${adapterInstallHint(command)}` };
   }
   probeCache.set(key, { result, at: Date.now() });
   return result;

package/src/completion-outbox/cli.ts

@@ -0,0 +1,123 @@
+import * as path from "node:path";
+import { CompletionOutboxFileStore } from "./file-store.ts";
+import { getRuntimeWorkspaceIdentity } from "../runtime-broker/private-state.ts";
+
+interface ParsedOptions {
+  command?: "cleanup";
+  workspace: string;
+  rootDir?: string;
+  apply: boolean;
+  json: boolean;
+  maxEntries?: number;
+  help: boolean;
+}
+
+function usage(): string {
+  return [
+    "Usage: pi-teammate-outbox cleanup [options]",
+    "",
+    "Safely removes obsolete atomic-replacement remnants while preserving the",
+    "latest recoverable transaction for every canonical outbox file.",
+    "",
+    "Options:",
+    "  --workspace <path>   Workspace whose outbox is cleaned (default: cwd)",
+    "  --root <path>        Completion outbox root directory",
+    "  --apply              Delete candidates; without this flag cleanup is dry-run",
+    "  --max-entries <n>    Refuse scans larger than n entries (default: 100000)",
+    "  --json               Emit one JSON result",
+    "  --help               Show this help",
+    "",
+    "Exit codes: 0 success, 2 usage error, 3 workspace outbox is busy.",
+  ].join("\n");
+}
+
+function parsePositiveInteger(value: string | undefined, option: string): number {
+  if (!value || !/^\d+$/.test(value)) throw new Error(`${option} requires a positive integer`);
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 1_000_000) {
+    throw new Error(`${option} must be between 1 and 1000000`);
+  }
+  return parsed;
+}
+
+function parseOptions(args: readonly string[]): ParsedOptions {
+  const first = args[0];
+  const command = first === "cleanup" ? first : undefined;
+  const help = args.includes("--help") || args.includes("-h");
+  const options: ParsedOptions = {
+    command,
+    workspace: process.cwd(),
+    apply: false,
+    json: false,
+    help,
+  };
+  for (let index = command ? 1 : (help ? 1 : 0); index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--help" || argument === "-h") continue;
+    if (argument === "--apply") {
+      options.apply = true;
+      continue;
+    }
+    if (argument === "--json") {
+      options.json = true;
+      continue;
+    }
+    const value = args[++index];
+    if (argument === "--workspace") {
+      if (!value) throw new Error("--workspace requires a path");
+      options.workspace = path.resolve(value);
+    } else if (argument === "--root") {
+      if (!value) throw new Error("--root requires a path");
+      options.rootDir = path.resolve(value);
+    } else if (argument === "--max-entries") {
+      options.maxEntries = parsePositiveInteger(value, argument);
+    } else {
+      throw new Error(`Unknown option: ${argument}`);
+    }
+  }
+  return options;
+}
+
+export async function main(args = process.argv.slice(2)): Promise<number> {
+  const options = parseOptions(args);
+  if (options.help || !options.command) {
+    process.stdout.write(`${usage()}\n`);
+    return options.help ? 0 : 2;
+  }
+
+  const identity = getRuntimeWorkspaceIdentity(options.workspace);
+  const store = new CompletionOutboxFileStore({
+    ...(options.rootDir === undefined ? {} : { rootDir: options.rootDir }),
+  });
+  const result = await store.cleanupRemnants(identity.workspaceId, {
+    apply: options.apply,
+    ...(options.maxEntries === undefined ? {} : { maxEntries: options.maxEntries }),
+  });
+  const output = {
+    workspace: identity.canonicalPath,
+    workspaceId: identity.workspaceId,
+    rootDir: store.rootDir,
+    ...result,
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+  } else if (result.busy) {
+    process.stderr.write(`Completion outbox is busy for ${identity.canonicalPath}; nothing was removed.\n`);
+  } else {
+    process.stdout.write([
+      `Completion outbox cleanup: ${result.apply ? "applied" : "dry-run"}`,
+      `Workspace: ${identity.canonicalPath}`,
+      `Scanned: ${result.scannedEntries} entries (${result.replacementFiles} replacement remnants)`,
+      `Preserved: ${result.preservedFiles}`,
+      `Candidates: ${result.candidateFiles} files, ${result.candidateBytes} bytes`,
+      `Removed: ${result.removedFiles} files, ${result.removedBytes} bytes`,
+      ...(result.candidateSample.length === 0 ? [] : [
+        "Candidate sample:",
+        ...result.candidateSample.map((candidate) => `  ${candidate}`),
+      ]),
+      ...(!result.apply && result.candidateFiles > 0 ? ["Re-run with --apply to remove these candidates."] : []),
+    ].join("\n") + "\n");
+  }
+  return result.busy ? 3 : 0;
+}