pi-subagents 0.80.0 → 0.81.0

package/bundle/chunk-YFCK7H2S.js

@@ -0,0 +1,129 @@
+// src/shared/display-text.ts
+function codePointWidth(codePoint) {
+  return codePoint > 65535 ? 2 : 1;
+}
+function isWhitespaceOrControl(codePoint) {
+  if (codePoint <= 32 || codePoint >= 127 && codePoint <= 159) return true;
+  if (codePoint >= 55296 && codePoint <= 57343) return true;
+  return String.fromCodePoint(codePoint).trim().length === 0;
+}
+function consumeControlString(value, index, osc) {
+  while (index < value.length) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (osc && codePoint === 7) return index + width;
+    if (codePoint === 156) return index + width;
+    if (codePoint === 27 && value.charCodeAt(index + 1) === 92) return index + 2;
+    index += width;
+  }
+  return value.length;
+}
+function consumeCsi(value, index) {
+  while (index < value.length) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (codePoint >= 64 && codePoint <= 126) return index + width;
+    index += width;
+  }
+  return value.length;
+}
+function sanitizeDisplayText(value) {
+  const output = [];
+  let pendingSpace = false;
+  const appendSpace = () => {
+    if (output.length > 0) pendingSpace = true;
+  };
+  const appendText = (text) => {
+    if (pendingSpace) output.push(" ");
+    output.push(text);
+    pendingSpace = false;
+  };
+  for (let index = 0; index < value.length; ) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (codePoint === 27) {
+      const next = value.charCodeAt(index + 1);
+      appendSpace();
+      if (next === 91) {
+        index = consumeCsi(value, index + 2);
+        continue;
+      }
+      if (next === 93 || next === 80 || next === 88 || next === 94 || next === 95) {
+        index = consumeControlString(value, index + 2, next === 93);
+        continue;
+      }
+      index += next ? 2 : 1;
+      continue;
+    }
+    if (codePoint === 155) {
+      appendSpace();
+      index = consumeCsi(value, index + width);
+      continue;
+    }
+    if (codePoint === 144 || codePoint === 152 || codePoint === 157 || codePoint === 158 || codePoint === 159) {
+      appendSpace();
+      index = consumeControlString(value, index + width, codePoint === 157);
+      continue;
+    }
+    if (isWhitespaceOrControl(codePoint)) appendSpace();
+    else appendText(String.fromCodePoint(codePoint));
+    index += width;
+  }
+  return output.join("");
+}
+function truncateDisplayText(value, maxLength) {
+  if (maxLength <= 0) return "";
+  if (value.length <= maxLength) return value;
+  let output = "";
+  for (const char of value) {
+    if (output.length + char.length > maxLength) break;
+    output += char;
+  }
+  return output;
+}
+function previewDisplayText(value, maxLength) {
+  const normalized = sanitizeDisplayText(value);
+  if (normalized.length <= maxLength) return normalized;
+  if (maxLength <= 3) return truncateDisplayText(normalized, maxLength);
+  return `${truncateDisplayText(normalized, maxLength - 3)}...`;
+}
+var BINARY_CONTENT_PLACEHOLDER = "[binary content omitted for safe display]";
+function isUnsafeTerminalCodePoint(codePoint) {
+  const terminalControl = codePoint <= 31 && codePoint !== 9 && codePoint !== 10 || codePoint >= 127 && codePoint <= 159;
+  const bidiControl = codePoint === 1564 || codePoint === 8206 || codePoint === 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8294 && codePoint <= 8297;
+  const privateUse = codePoint >= 57344 && codePoint <= 63743 || codePoint >= 983040 && codePoint <= 1048573 || codePoint >= 1048576 && codePoint <= 1114109;
+  const invalidScalar = codePoint >= 55296 && codePoint <= 57343;
+  const nonCharacter = codePoint >= 64976 && codePoint <= 65007 || (codePoint & 65535) === 65534 || (codePoint & 65535) === 65535;
+  return terminalControl || bidiControl || privateUse || invalidScalar || nonCharacter;
+}
+function looksLikeBinaryContent(text) {
+  if (text.includes("\0")) return true;
+  let suspiciousControls = 0;
+  let replacementCharacters = 0;
+  let codePoints = 0;
+  for (const character of text) {
+    codePoints++;
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 8 || codePoint >= 14 && codePoint <= 31) suspiciousControls++;
+    if (codePoint === 65533) replacementCharacters++;
+  }
+  if (codePoints === 0) return false;
+  return suspiciousControls >= 4 && suspiciousControls / codePoints >= 0.1 || replacementCharacters >= 3 && replacementCharacters / codePoints >= 0.1;
+}
+function safeTerminalText(value) {
+  const normalized = value.replace(/\r\n/g, "\n");
+  if (looksLikeBinaryContent(normalized)) return BINARY_CONTENT_PLACEHOLDER;
+  let safe = "";
+  for (const character of normalized) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    safe += isUnsafeTerminalCodePoint(codePoint) ? `[U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}]` : character;
+  }
+  return safe;
+}
+
+export {
+  sanitizeDisplayText,
+  truncateDisplayText,
+  previewDisplayText,
+  safeTerminalText
+};

package/bundle/chunk-YYREO77V.js

@@ -0,0 +1,137 @@
+// src/api/external-job-provider.ts
+var EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION = 1;
+var EXTERNAL_JOB_PROVIDER_REGISTRY_KEY = "pi-subagents.external-job-providers.v1";
+var MAX_PROVIDER_NAME_LENGTH = 128;
+var MAX_PROVIDERS = 100;
+var MAX_JOB_ID_LENGTH = 256;
+var MAX_FAILURE_CODE_LENGTH = 128;
+var MAX_FAILURE_MESSAGE_LENGTH = 4096;
+var MAX_URL_LENGTH = 4096;
+var ExternalJobProviderError = class extends Error {
+  code;
+  blockingJobId;
+  constructor(message, options) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "ExternalJobProviderError";
+    this.code = options.code;
+    this.blockingJobId = options.blockingJobId;
+  }
+};
+function registry() {
+  const key = Symbol.for(EXTERNAL_JOB_PROVIDER_REGISTRY_KEY);
+  const globalObject = globalThis;
+  const existing = globalObject[key];
+  if (existing === void 0) {
+    const created = {
+      version: EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION,
+      providers: /* @__PURE__ */ new Map()
+    };
+    globalObject[key] = created;
+    return created;
+  }
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    throw new Error(`Malformed external-job provider registry at Symbol.for("${EXTERNAL_JOB_PROVIDER_REGISTRY_KEY}").`);
+  }
+  const candidate = existing;
+  if (candidate.version !== EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION || !(candidate.providers instanceof Map)) {
+    throw new Error(`Unsupported external-job provider registry at Symbol.for("${EXTERNAL_JOB_PROVIDER_REGISTRY_KEY}").`);
+  }
+  return candidate;
+}
+function validateString(value, field, maxLength) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
+    throw new Error(`${field} must be a non-empty string without leading or trailing whitespace.`);
+  }
+  if (value.length > maxLength) throw new Error(`${field} must be at most ${maxLength} characters.`);
+  if (value.includes("\0")) throw new Error(`${field} must not contain NUL characters.`);
+  return value;
+}
+function validateOptionalString(value, field, maxLength) {
+  if (value === void 0) return void 0;
+  return validateString(value, field, maxLength);
+}
+function validateState(value, field) {
+  if (value === "queued" || value === "running" || value === "completed" || value === "failed" || value === "stopped" || value === "blocked") return value;
+  throw new Error(`${field} must be queued, running, completed, failed, stopped, or blocked.`);
+}
+function validateHandle(provider, value, field, extraFields = []) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${field} from external-job provider '${provider}' must be an object.`);
+  const handle = value;
+  const supported = /* @__PURE__ */ new Set(["providerJobId", "state", "handleUrl", "conversationUrl", "failureCode", "failureMessage", "blockingJobId", ...extraFields]);
+  const unknown = Object.keys(handle).filter((key) => !supported.has(key));
+  if (unknown.length > 0) throw new Error(`${field} from external-job provider '${provider}' has unknown fields: ${unknown.join(", ")}.`);
+  const handleUrl = validateOptionalString(handle.handleUrl, `${field}.handleUrl`, MAX_URL_LENGTH);
+  const conversationUrl = validateOptionalString(handle.conversationUrl, `${field}.conversationUrl`, MAX_URL_LENGTH);
+  const failureCode = validateOptionalString(handle.failureCode, `${field}.failureCode`, MAX_FAILURE_CODE_LENGTH);
+  const failureMessage = validateOptionalString(handle.failureMessage, `${field}.failureMessage`, MAX_FAILURE_MESSAGE_LENGTH);
+  const blockingJobId = validateOptionalString(handle.blockingJobId, `${field}.blockingJobId`, MAX_JOB_ID_LENGTH);
+  return {
+    providerJobId: validateString(handle.providerJobId, `${field}.providerJobId`, MAX_JOB_ID_LENGTH),
+    state: validateState(handle.state, `${field}.state`),
+    ...handleUrl ? { handleUrl } : {},
+    ...conversationUrl ? { conversationUrl } : {},
+    ...failureCode ? { failureCode } : {},
+    ...failureMessage ? { failureMessage } : {},
+    ...blockingJobId ? { blockingJobId } : {}
+  };
+}
+function validateExternalJobHandle(provider, value, field = "External-job handle") {
+  return validateHandle(provider, value, field);
+}
+function validateExternalJobResult(provider, value, field = "External-job result") {
+  const result = validateHandle(provider, value, field, ["output", "artifactPath"]);
+  const record = value;
+  const output = validateOptionalString(record.output, `${field}.output`, 1024 * 1024);
+  const artifactPath = validateOptionalString(record.artifactPath, `${field}.artifactPath`, MAX_URL_LENGTH);
+  return {
+    ...result,
+    ...output !== void 0 ? { output } : {},
+    ...artifactPath !== void 0 ? { artifactPath } : {}
+  };
+}
+function validateProvider(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("External-job provider must be an object.");
+  const provider = value;
+  const name = validateString(provider.name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
+  for (const op of ["start", "status", "result", "reattach"]) {
+    if (typeof provider[op] !== "function") throw new Error(`External-job provider '${name}' must expose ${op}().`);
+  }
+  return value;
+}
+function registerExternalJobProvider(provider) {
+  const validated = validateProvider(provider);
+  const current = registry();
+  if (!current.providers.has(validated.name) && current.providers.size >= MAX_PROVIDERS) {
+    throw new Error(`External-job provider registry supports at most ${MAX_PROVIDERS} providers.`);
+  }
+  current.providers.set(validated.name, validated);
+  return () => {
+    if (current.providers.get(validated.name) === validated) current.providers.delete(validated.name);
+  };
+}
+function listExternalJobProviders() {
+  const current = registry();
+  if (current.providers.size > MAX_PROVIDERS) throw new Error(`External-job provider registry contains more than ${MAX_PROVIDERS} providers.`);
+  const providers = [];
+  for (const [key, value] of current.providers) {
+    const provider = validateProvider(value);
+    if (key !== provider.name) throw new Error(`External-job provider registry key '${key}' does not match provider name '${provider.name}'.`);
+    providers.push(provider);
+  }
+  return providers;
+}
+function getExternalJobProvider(name) {
+  const safeName = validateString(name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
+  return listExternalJobProviders().find((provider) => provider.name === safeName);
+}
+
+export {
+  EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION,
+  EXTERNAL_JOB_PROVIDER_REGISTRY_KEY,
+  ExternalJobProviderError,
+  validateExternalJobHandle,
+  validateExternalJobResult,
+  registerExternalJobProvider,
+  listExternalJobProviders,
+  getExternalJobProvider
+};

package/bundle/chunk-Z7KVHQHL.js

@@ -0,0 +1,173 @@
+// src/runs/shared/capability-ceiling.ts
+import { Buffer } from "node:buffer";
+var SUBAGENT_CAPABILITY_CEILING_VERSION = 1;
+var SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY = "pi-subagents.capability-ceiling.v1";
+function registry() {
+  const key = Symbol.for(SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY);
+  const store = globalThis;
+  const existing = store[key];
+  if (existing instanceof Map) return existing;
+  const created = /* @__PURE__ */ new Map();
+  store[key] = created;
+  return created;
+}
+function validateText(value, field) {
+  if (typeof value !== "string" || !value.trim() || /[\u0000-\u001f\u007f]/u.test(value) || Buffer.byteLength(value.trim(), "utf8") > 256) {
+    throw new Error(`Invalid capability ceiling ${field}; expected a non-empty string without control characters (max 256 UTF-8 bytes).`);
+  }
+  return value.trim();
+}
+function normalizeCapabilityCeilingAllowedAgents(values) {
+  return normalizeCeiling({ allowedAgents: values }).allowedAgents;
+}
+function normalizeCeiling(ceiling) {
+  if (!ceiling || typeof ceiling !== "object" || Array.isArray(ceiling)) throw new Error("Invalid capability ceiling; expected an object.");
+  const hasAllowedTools = Object.hasOwn(ceiling, "allowedTools");
+  const hasAllowedAgents = Object.hasOwn(ceiling, "allowedAgents");
+  const hasDenyExtensions = Object.hasOwn(ceiling, "denyExtensions");
+  if (!hasAllowedTools && !hasAllowedAgents && !hasDenyExtensions) throw new Error("Invalid capability ceiling; expected allowedTools, allowedAgents, or denyExtensions.");
+  if (hasDenyExtensions && typeof ceiling.denyExtensions !== "boolean") throw new Error("Invalid capability ceiling denyExtensions; expected a boolean.");
+  const normalizeList = (field, pattern) => {
+    if (!Object.hasOwn(ceiling, field)) return void 0;
+    const values = ceiling[field];
+    if (!Array.isArray(values)) throw new Error(`Invalid capability ceiling ${field}; expected an array.`);
+    if (values.length > 256) throw new Error(`Invalid capability ceiling ${field}; expected at most 256 names.`);
+    return [...new Set(values.map((entry) => {
+      const name = validateText(entry, `${field} entry`);
+      if (!pattern.test(name)) throw new Error(`Invalid capability ceiling ${field} entry '${name}'.`);
+      if (Buffer.byteLength(name, "utf8") > 128) throw new Error(`Invalid capability ceiling ${field} entry '${name}'; max 128 UTF-8 bytes.`);
+      return name;
+    }))].sort();
+  };
+  const allowedTools = normalizeList("allowedTools", /^[A-Za-z0-9_.:-]+$/u);
+  const allowedAgents = normalizeList("allowedAgents", /^[A-Za-z0-9_.:-]+$/u);
+  return {
+    version: SUBAGENT_CAPABILITY_CEILING_VERSION,
+    ...allowedTools !== void 0 ? { allowedTools } : {},
+    ...allowedAgents !== void 0 ? { allowedAgents } : {},
+    denyExtensions: ceiling.denyExtensions === true,
+    sources: []
+  };
+}
+function parseSubagentCapabilityCeiling(value, field = "capability ceiling") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid ${field}; expected an object.`);
+  const record = value;
+  if (record.version !== SUBAGENT_CAPABILITY_CEILING_VERSION) throw new Error(`Invalid ${field} version.`);
+  const normalized = normalizeCeiling(record);
+  const sources = record.sources;
+  if (!Array.isArray(sources) || sources.some((source) => typeof source !== "string")) throw new Error(`Invalid ${field} sources; expected an array of strings.`);
+  normalized.sources = [...new Set(sources.map((source) => validateText(source, `${field} source`)))].sort();
+  return normalized;
+}
+function registerSubagentCapabilityCeiling(options) {
+  const sessionId = validateText(options.sessionId, "sessionId");
+  const source = validateText(options.source, "source");
+  let normalized = normalizeCeiling(options.ceiling);
+  const token = Symbol(source);
+  const store = registry();
+  let session = store.get(sessionId);
+  if (!session) {
+    session = /* @__PURE__ */ new Map();
+    store.set(sessionId, session);
+  }
+  const setRegistration = () => {
+    normalized = normalizeCeiling(normalized);
+    normalized.sources = [source];
+    session.set(token, { source, ceiling: normalized });
+  };
+  setRegistration();
+  let disposed = false;
+  return {
+    update(ceiling) {
+      if (disposed) throw new Error("Cannot update a disposed capability ceiling handle.");
+      normalized = normalizeCeiling(ceiling);
+      normalized.sources = [source];
+      session.set(token, { source, ceiling: normalized });
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      session.delete(token);
+      if (session.size === 0) store.delete(sessionId);
+    }
+  };
+}
+function intersectSubagentCapabilityCeilings(...ceilings) {
+  const active = ceilings.filter((ceiling) => ceiling !== void 0);
+  if (active.length === 0) return void 0;
+  const intersectLists = (field) => {
+    const definedLists = active.filter((ceiling) => ceiling[field] !== void 0).map((ceiling) => new Set(ceiling[field]));
+    if (definedLists.length === 0) return void 0;
+    return [...definedLists[0]].filter((entry) => definedLists.every((list) => list.has(entry))).sort();
+  };
+  const allowedTools = intersectLists("allowedTools");
+  const allowedAgents = intersectLists("allowedAgents");
+  return {
+    version: SUBAGENT_CAPABILITY_CEILING_VERSION,
+    ...allowedTools !== void 0 ? { allowedTools } : {},
+    ...allowedAgents !== void 0 ? { allowedAgents } : {},
+    denyExtensions: active.some((ceiling) => ceiling.denyExtensions),
+    sources: [...new Set(active.flatMap((ceiling) => ceiling.sources))].sort()
+  };
+}
+function resolveSubagentCapabilityCeiling(sessionId, inherited) {
+  const active = [];
+  if (sessionId) {
+    const registrations = registry().get(sessionId);
+    if (registrations) active.push(...Array.from(registrations.values(), ({ ceiling }) => ceiling));
+  }
+  return intersectSubagentCapabilityCeilings(inherited, ...active);
+}
+function resolveCurrentSubagentCapabilityCeiling(sessionId) {
+  return resolveSubagentCapabilityCeiling(sessionId, void 0);
+}
+function isAgentAllowedByCapabilityCeiling(agentName, ceiling) {
+  return ceiling?.allowedAgents === void 0 || ceiling.allowedAgents.includes(agentName);
+}
+function capabilityCeilingAgentRestrictionMessage(agentName, ceiling) {
+  if (isAgentAllowedByCapabilityCeiling(agentName, ceiling)) return void 0;
+  const sources = ceiling?.sources.length ? ceiling.sources.join(", ") : "unknown source";
+  const allowed = ceiling?.allowedAgents?.length ? ceiling.allowedAgents.join(", ") : "(none)";
+  return `Capability ceiling from ${sources} does not allow agent '${agentName}'. Allowed agents: ${allowed}.`;
+}
+function assertAgentAllowedByCapabilityCeiling(agentName, ceiling) {
+  const message = capabilityCeilingAgentRestrictionMessage(agentName, ceiling);
+  if (message) throw new Error(message);
+}
+function capabilityCeilingAgentRestrictionSources(ceiling) {
+  return ceiling?.allowedAgents === void 0 ? void 0 : [...ceiling.sources];
+}
+function encodeSubagentCapabilityCeiling(ceiling) {
+  if (!ceiling) return void 0;
+  return Buffer.from(JSON.stringify(ceiling), "utf8").toString("base64url");
+}
+function decodeSubagentCapabilityCeiling(value) {
+  if (value === void 0 || value === "") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+  } catch (error) {
+    throw new Error(`Invalid inherited capability ceiling: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== SUBAGENT_CAPABILITY_CEILING_VERSION) {
+    throw new Error("Invalid inherited capability ceiling version.");
+  }
+  return parseSubagentCapabilityCeiling(parsed, "inherited capability ceiling");
+}
+
+export {
+  SUBAGENT_CAPABILITY_CEILING_VERSION,
+  SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY,
+  normalizeCapabilityCeilingAllowedAgents,
+  parseSubagentCapabilityCeiling,
+  registerSubagentCapabilityCeiling,
+  intersectSubagentCapabilityCeilings,
+  resolveSubagentCapabilityCeiling,
+  resolveCurrentSubagentCapabilityCeiling,
+  isAgentAllowedByCapabilityCeiling,
+  capabilityCeilingAgentRestrictionMessage,
+  assertAgentAllowedByCapabilityCeiling,
+  capabilityCeilingAgentRestrictionSources,
+  encodeSubagentCapabilityCeiling,
+  decodeSubagentCapabilityCeiling
+};