@sentry/junior 0.21.1 → 0.22.0

package/dist/{chunk-N4ICA2BC.js → chunk-MCJJKEB3.js}

@@ -8,6 +8,14 @@ import {
 
 // src/chat/logging.ts
 import { AsyncLocalStorage } from "async_hooks";
+import path from "path";
+import { styleText } from "util";
+import {
+  ConfigError,
+  configureSync,
+  getConfig,
+  getLogger
+} from "@logtape/logtape";
 
 // src/chat/coerce.ts
 function toOptionalString(value) {
@@ -58,20 +66,13 @@ var LEGACY_KEY_MAP = {
 };
 var contextStorage = new AsyncLocalStorage();
 var logRecordSinks = /* @__PURE__ */ new Set();
-var ANSI = {
-  reset: "\x1B[0m",
-  faint: "\x1B[2m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  green: "\x1B[32m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m",
-  gray: "\x1B[90m"
-};
+var LOGTAPE_BODY_KEY = "__logtape_body";
+var ROOT_LOGGER_CATEGORY = ["junior"];
 var CONSOLE_PRIORITY_KEYS = [
   "gen_ai.conversation.id",
   "app.turn.id",
   "event.name",
+  "app.log.source",
   "error.message",
   "messaging.message.id",
   "app.trace_id",
@@ -119,6 +120,42 @@ function shouldEmitConsole(level) {
   }
   return true;
 }
+function isDevelopmentLoggingMode() {
+  if (process.env.NODE_ENV !== "development") {
+    return false;
+  }
+  if (process.env.CI) {
+    return false;
+  }
+  return true;
+}
+function shouldUseDevelopmentConsoleFormat() {
+  if (!isDevelopmentLoggingMode()) {
+    return false;
+  }
+  return process.env.JUNIOR_LOG_FORMAT?.trim().toLowerCase() !== "structured";
+}
+function shouldUsePrettyConsole(level) {
+  if (level === "warn" || level === "error") {
+    return false;
+  }
+  return shouldUseDevelopmentConsoleFormat();
+}
+function shouldUseConsoleColor() {
+  if (!shouldUseDevelopmentConsoleFormat()) {
+    return false;
+  }
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  return process.env.FORCE_COLOR?.trim() === "1" || Boolean(process.stdout?.isTTY) || Boolean(process.stderr?.isTTY);
+}
+function formatConsoleTimestamp(timestamp) {
+  if (shouldUseDevelopmentConsoleFormat()) {
+    return timestamp.toTimeString().slice(0, 8);
+  }
+  return timestamp.toISOString();
+}
 function findNextBlankLineBoundary(input, start) {
   const lfBoundary = input.indexOf("\n\n", start);
   const crlfBoundary = input.indexOf("\r\n\r\n", start);
@@ -311,6 +348,126 @@ function mergeAttributes(...maps) {
   }
   return merged;
 }
+function fromLogTapeLevel(level) {
+  if (level === "warning") {
+    return "warn";
+  }
+  if (level === "fatal") {
+    return "error";
+  }
+  if (level === "trace") {
+    return "debug";
+  }
+  return level;
+}
+function getLogSource(category) {
+  if (category.length <= ROOT_LOGGER_CATEGORY.length) {
+    return void 0;
+  }
+  const sourceParts = category.slice(ROOT_LOGGER_CATEGORY.length);
+  return sourceParts.length > 0 ? sourceParts.join(".") : void 0;
+}
+function toEmittedLogRecord(record) {
+  const properties = { ...record.properties };
+  const rawBody = properties[LOGTAPE_BODY_KEY];
+  delete properties[LOGTAPE_BODY_KEY];
+  const attributes = mergeAttributes(properties);
+  const source = getLogSource(record.category);
+  if (source && attributes["app.log.source"] === void 0) {
+    attributes["app.log.source"] = source;
+  }
+  const body = toOptionalString(rawBody) ?? record.message.map(
+    (segment) => typeof segment === "string" ? segment : String(segment ?? "")
+  ).join("");
+  const eventName = toOptionalString(attributes["event.name"]) ?? "log_record_emitted";
+  return {
+    level: fromLogTapeLevel(record.level),
+    eventName,
+    body,
+    attributes
+  };
+}
+function createConsoleSink() {
+  return (record) => {
+    const emitted = toEmittedLogRecord(record);
+    emitConsole(
+      emitted.level,
+      emitted.eventName,
+      emitted.body,
+      emitted.attributes
+    );
+  };
+}
+function createSentrySink() {
+  return (record) => {
+    const emitted = toEmittedLogRecord(record);
+    emitSentry(emitted.level, emitted.body, emitted.attributes);
+  };
+}
+function createRecordSink() {
+  return (record) => {
+    const emitted = toEmittedLogRecord(record);
+    for (const sink of logRecordSinks) {
+      try {
+        sink(emitted);
+      } catch {
+      }
+    }
+  };
+}
+var rootLogger;
+var ownsLogTapeBackend = false;
+var usesDirectEmissionFallback = false;
+function ensureLoggerBackend() {
+  if (rootLogger || usesDirectEmissionFallback) {
+    return;
+  }
+  if (getConfig() !== null) {
+    usesDirectEmissionFallback = true;
+    return;
+  }
+  try {
+    configureSync({
+      sinks: {
+        console: createConsoleSink(),
+        sentry: createSentrySink(),
+        records: createRecordSink()
+      },
+      loggers: [
+        {
+          category: [...ROOT_LOGGER_CATEGORY],
+          sinks: ["console", "sentry", "records"],
+          lowestLevel: "debug"
+        },
+        {
+          category: ["logtape"],
+          sinks: ["console"],
+          lowestLevel: "error"
+        }
+      ],
+      contextLocalStorage: contextStorage
+    });
+    ownsLogTapeBackend = true;
+    rootLogger = getLogger([...ROOT_LOGGER_CATEGORY]);
+  } catch (error) {
+    if (error instanceof ConfigError && getConfig() !== null) {
+      usesDirectEmissionFallback = true;
+      return;
+    }
+    throw error;
+  }
+}
+function getLogTapeLogger(category = []) {
+  ensureLoggerBackend();
+  if (!rootLogger) {
+    throw new Error("LogTape backend is unavailable");
+  }
+  let logger = rootLogger;
+  for (const part of category) {
+    logger = logger.getChild(part);
+  }
+  return logger;
+}
 function emitSentry(level, body, attributes) {
   if (shouldSuppressInfoLog(level)) {
     return;
@@ -343,11 +500,11 @@ function formatConsoleLevel(level) {
   if (level === "warn") return "WRN";
   return "ERR";
 }
-function consoleLevelColor(level) {
-  if (level === "error") return ANSI.red;
-  if (level === "warn") return ANSI.yellow;
-  if (level === "info") return ANSI.green;
-  return ANSI.blue;
+function consoleLevelStyle(level) {
+  if (level === "error") return "red";
+  if (level === "warn") return "yellow";
+  if (level === "info") return "green";
+  return "blue";
 }
 function quoteConsoleValue(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
@@ -412,6 +569,119 @@ function summarizeConsoleString(value, maxChars) {
   }
   return `${collapsed.slice(0, maxChars)}... [${collapsed.length} chars]`;
 }
+function abbreviateConsoleId(value) {
+  if (value.length <= 20) {
+    return value;
+  }
+  return `${value.slice(0, 12)}...${value.slice(-4)}`;
+}
+function toRelativeConsolePath(value) {
+  const normalized = value.trim();
+  if (!normalized) {
+    return normalized;
+  }
+  try {
+    const relative = path.relative(process.cwd(), normalized);
+    if (relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+      return relative;
+    }
+  } catch {
+  }
+  return normalized;
+}
+function pushPrettyConsoleToken(tokens, token) {
+  if (!token || tokens.includes(token)) {
+    return;
+  }
+  tokens.push(token);
+}
+function numericConsoleToken(label, value) {
+  return typeof value === "number" ? `${label}=${value}` : void 0;
+}
+function booleanConsoleToken(label, value) {
+  return typeof value === "boolean" ? `${label}=${value ? "yes" : "no"}` : void 0;
+}
+function shouldShowPrettyCorrelation(eventName) {
+  return !(eventName === "plugin_loaded" || eventName === "startup_discovery_summary" || eventName === "capability_catalog_loaded" || eventName.endsWith("_loaded"));
+}
+function getPrettyConsoleSummaryTokens(level, eventName, attributes) {
+  const tokens = [];
+  pushPrettyConsoleToken(
+    tokens,
+    toOptionalString(attributes["app.log.source"]) ?? void 0
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    toOptionalString(attributes["app.plugin.name"]) ?? void 0
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("caps", attributes["app.plugin.capability_count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("config", attributes["app.plugin.config_key_count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    booleanConsoleToken("mcp", attributes["app.plugin.has_mcp"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("plugins", attributes["app.plugin.count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("skills", attributes["app.skill.count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("capabilities", attributes["app.capability.count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("config", attributes["app.config.key_count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("chars", attributes["app.message.length"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken(
+      "attachments",
+      attributes["app.message.attachment_count"]
+    )
+  );
+  const filePath = toOptionalString(attributes["file.path"]);
+  if (filePath && eventName.endsWith("_loaded")) {
+    pushPrettyConsoleToken(tokens, toRelativeConsolePath(filePath));
+  }
+  if (shouldShowPrettyCorrelation(eventName)) {
+    const conversationId = toOptionalString(
+      attributes["gen_ai.conversation.id"]
+    );
+    const turnId = toOptionalString(attributes["app.turn.id"]);
+    const messageId = toOptionalString(attributes["messaging.message.id"]);
+    if (conversationId) {
+      pushPrettyConsoleToken(
+        tokens,
+        `conv=${abbreviateConsoleId(conversationId)}`
+      );
+    }
+    if (turnId) {
+      pushPrettyConsoleToken(tokens, `turn=${abbreviateConsoleId(turnId)}`);
+    }
+    if (messageId) {
+      pushPrettyConsoleToken(tokens, `msg=${abbreviateConsoleId(messageId)}`);
+    }
+  }
+  const model = toOptionalString(attributes["gen_ai.request.model"]);
+  if (model && shouldShowConsoleModel(level, eventName)) {
+    pushPrettyConsoleToken(tokens, `model=${model}`);
+  }
+  return tokens;
+}
 function projectConsoleValue(level, key, value) {
   if ((level === "debug" || level === "info") && CONSOLE_PREVIEW_KEYS.has(key) && typeof value === "string") {
     return summarizeConsoleString(
@@ -435,12 +705,25 @@ function projectConsoleAttributes(level, eventName, attributes) {
   return projected;
 }
 function formatConsoleLine(level, eventName, body, attributes) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const useColor = process.env.NODE_ENV === "development" && Boolean(process.stdout?.isTTY);
-  const levelColor = consoleLevelColor(level);
-  const colorize = (text, color) => useColor ? `${color}${text}${ANSI.reset}` : text;
+  const timestamp = /* @__PURE__ */ new Date();
+  const useColor = shouldUseConsoleColor();
+  const levelStyle = consoleLevelStyle(level);
+  const colorize = (text, style) => useColor ? styleText(style, text) : text;
+  if (shouldUsePrettyConsole(level)) {
+    const summaryTokens = getPrettyConsoleSummaryTokens(
+      level,
+      eventName,
+      attributes
+    );
+    const summary = [body, ...summaryTokens].join(" ");
+    return [
+      colorize(formatConsoleTimestamp(timestamp), "gray"),
+      colorize(formatConsoleLevel(level), levelStyle),
+      summary
+    ].join(" ");
+  }
   const parts = [
-    `${colorize(timestamp, ANSI.gray)} ${colorize(formatConsoleLevel(level), levelColor)} ${body}`
+    `${colorize(formatConsoleTimestamp(timestamp), "gray")} ${colorize(formatConsoleLevel(level), levelStyle)} ${body}`
   ];
   const projectedAttributes = projectConsoleAttributes(
     level,
@@ -460,7 +743,7 @@ function formatConsoleLine(level, eventName, body, attributes) {
     }
   );
   for (const [key, value] of sortedAttributes) {
-    const rendered = `${colorize(key, ANSI.cyan)}=${colorize(formatConsoleValue(value), ANSI.faint)}`;
+    const rendered = `${colorize(key, "cyan")}=${colorize(formatConsoleValue(value), "dim")}`;
     parts.push(rendered);
   }
   return parts.join(" ");
@@ -484,28 +767,58 @@ function emitConsole(level, eventName, body, attributes) {
   }
   console.debug(line);
 }
-function emit(level, eventName, attrs = {}, body) {
-  const contextAttributes = contextStorage.getStore() ?? {};
-  const traceAttributes = getTraceCorrelationAttributes();
-  const normalizedEventName = toSnakeCase(eventName);
-  const message = body ? redactSecrets(body) : normalizedEventName;
-  const attributes = mergeAttributes(contextAttributes, traceAttributes, {
-    "event.name": normalizedEventName,
-    ...attrs
-  });
+function emitDirect(level, eventName, body, attributes) {
   for (const sink of logRecordSinks) {
     try {
       sink({
         level,
-        eventName: normalizedEventName,
-        body: message,
+        eventName,
+        body,
         attributes
       });
     } catch {
     }
   }
-  emitConsole(level, normalizedEventName, message, attributes);
-  emitSentry(level, message, attributes);
+  emitConsole(level, eventName, body, attributes);
+  emitSentry(level, body, attributes);
+}
+function emitRecord(category, level, eventName, attrs = {}, body) {
+  ensureLoggerBackend();
+  const traceAttributes = getTraceCorrelationAttributes();
+  const normalizedEventName = toSnakeCase(eventName);
+  const message = body ? redactSecrets(body) : normalizedEventName;
+  const source = getLogSource([...ROOT_LOGGER_CATEGORY, ...category]);
+  const contextAttributes = ownsLogTapeBackend ? void 0 : contextStorage.getStore();
+  const attributes = mergeAttributes(contextAttributes, traceAttributes, {
+    "event.name": normalizedEventName,
+    ...source ? { "app.log.source": source } : {},
+    ...attrs
+  });
+  if (usesDirectEmissionFallback) {
+    emitDirect(level, normalizedEventName, message, attributes);
+    return;
+  }
+  const logger = getLogTapeLogger(category);
+  const properties = {
+    [LOGTAPE_BODY_KEY]: message,
+    ...attributes
+  };
+  if (level === "error") {
+    logger.error(`{${LOGTAPE_BODY_KEY}}`, properties);
+    return;
+  }
+  if (level === "warn") {
+    logger.warn(`{${LOGTAPE_BODY_KEY}}`, properties);
+    return;
+  }
+  if (level === "info") {
+    logger.info(`{${LOGTAPE_BODY_KEY}}`, properties);
+    return;
+  }
+  logger.debug(`{${LOGTAPE_BODY_KEY}}`, properties);
+}
+function emit(level, eventName, attrs = {}, body) {
+  emitRecord([], level, eventName, attrs, body);
 }
 var log = {
   debug(eventName, attrs = {}, body) {
@@ -555,6 +868,83 @@ var log = {
     return eventId;
   }
 };
+var CHAT_SDK_LEVEL_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function resolveChatSdkLogLevel() {
+  if (isDevelopmentLoggingMode()) {
+    return "warn";
+  }
+  return "info";
+}
+function shouldEmitChatSdkLevel(level, minimumLevel) {
+  if (minimumLevel === "silent") {
+    return false;
+  }
+  return CHAT_SDK_LEVEL_PRIORITY[level] >= CHAT_SDK_LEVEL_PRIORITY[minimumLevel];
+}
+function renderChatSdkArgument(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.message;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatChatSdkBody(message, args) {
+  const renderedArgs = args.map((arg) => renderChatSdkArgument(arg).trim()).filter((arg) => arg.length > 0);
+  if (renderedArgs.length === 0) {
+    return message;
+  }
+  return `${message} ${renderedArgs.join(" ")}`;
+}
+function createChatSdkLoggerImpl(category, minimumLevel) {
+  const emitChatSdkLog = (level, message, args) => {
+    if (!shouldEmitChatSdkLevel(level, minimumLevel)) {
+      return;
+    }
+    emitRecord(
+      category,
+      level === "warn" ? "warn" : level,
+      level === "error" ? "chat_sdk_error" : level === "warn" ? "chat_sdk_warning" : "chat_sdk_log",
+      args.length > 0 ? {
+        "app.log.args": args.length === 1 ? args[0] : args
+      } : {},
+      formatChatSdkBody(message, args)
+    );
+  };
+  return {
+    child(prefix) {
+      return createChatSdkLoggerImpl([...category, prefix], minimumLevel);
+    },
+    debug(message, ...args) {
+      emitChatSdkLog("debug", message, args);
+    },
+    info(message, ...args) {
+      emitChatSdkLog("info", message, args);
+    },
+    warn(message, ...args) {
+      emitChatSdkLog("warn", message, args);
+    },
+    error(message, ...args) {
+      emitChatSdkLog("error", message, args);
+    }
+  };
+}
+function createChatSdkLogger() {
+  return createChatSdkLoggerImpl(["chat-sdk"], resolveChatSdkLogLevel());
+}
 function withLogContext(context, callback) {
   const next = mergeAttributes(
     contextStorage.getStore(),
@@ -871,6 +1261,7 @@ import { parse as parseYaml } from "yaml";
 var PLUGIN_NAME_RE = /^[a-z][a-z0-9-]*$/;
 var SHORT_CAPABILITY_RE = /^[a-z0-9-]+(\.[a-z0-9-]+)*$/;
 var SHORT_CONFIG_KEY_RE = /^[a-z0-9]+(\.[a-z0-9-]+)*$/;
+var TARGET_FLAG_RE = /^-{1,2}[A-Za-z0-9][A-Za-z0-9-]*$/;
 var AUTH_TOKEN_ENV_RE = /^[A-Z][A-Z0-9_]*$/;
 var API_DOMAIN_RE = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 var RUNTIME_POSTINSTALL_CMD_RE = /^[A-Za-z0-9._/-]+$/;
@@ -1036,16 +1427,17 @@ var oauthSourceSchema = z.object({
 var mcpSourceSchema = z.object({
   transport: nonEmptyTrimmedString.refine((value) => value === "http", {
     error: 'must be "http"'
-  }),
+  }).optional(),
   url: httpsUrlString,
   headers: stringMapSchema.optional(),
   "allowed-tools": nonEmptyStringArraySchema("allowed-tools").optional()
 }).passthrough();
 var targetSourceSchema = z.object({
-  type: z.literal("repo", {
-    error: 'type must be "repo"'
+  type: nonEmptyTrimmedString.refine((value) => PLUGIN_NAME_RE.test(value), {
+    error: "type must be a lowercase target identifier"
   }),
-  "config-key": nonEmptyTrimmedString
+  "config-key": nonEmptyTrimmedString,
+  "command-flags": nonEmptyStringArraySchema("command-flags").optional()
 }).passthrough();
 var manifestSourceSchema = z.object({
   name: z.string().refine((value) => PLUGIN_NAME_RE.test(value), {
@@ -1077,8 +1469,8 @@ var manifestSourceSchema = z.object({
     error: "must be an object"
   }).optional()
 }).passthrough();
-function formatPath(path2) {
-  return path2.map((segment) => String(segment)).join(".");
+function formatPath(path3) {
+  return path3.map((segment) => String(segment)).join(".");
 }
 function issueMessage(error, prefix) {
   const issue = error.issues[0];
@@ -1305,51 +1697,51 @@ function parsePluginManifest(raw, dir) {
   const sourceResult = manifestSourceSchema.safeParse(parsedYaml);
   if (!sourceResult.success) {
     const issue = sourceResult.error.issues[0];
-    const path2 = formatPath(issue?.path ?? []);
-    if (path2 === "name") {
+    const path3 = formatPath(issue?.path ?? []);
+    if (path3 === "name") {
       throw new Error(
         `Invalid plugin name in ${dir}: "${parsedYaml.name}"`
       );
     }
-    if (path2 === "description") {
+    if (path3 === "description") {
       throw new Error(`Invalid plugin description in ${dir}`);
     }
-    if (path2 === "capabilities") {
+    if (path3 === "capabilities") {
       throw new Error(
         `Plugin ${parsedYaml.name ?? "unknown"} capabilities must be an array when provided`
       );
     }
-    if (path2 === "config-keys") {
+    if (path3 === "config-keys") {
       throw new Error(
         `Plugin ${parsedYaml.name ?? "unknown"} config-keys must be an array when provided`
       );
     }
-    if (path2 === "credentials") {
+    if (path3 === "credentials") {
       throw new Error(
         `Plugin ${parsedYaml.name ?? "unknown"} credentials must be an object when provided`
       );
     }
-    if (path2 === "runtime-dependencies") {
+    if (path3 === "runtime-dependencies") {
       throw new Error(
         `Plugin ${parsedYaml.name ?? "unknown"} runtime-dependencies must be an array`
       );
     }
-    if (path2 === "runtime-postinstall") {
+    if (path3 === "runtime-postinstall") {
       throw new Error(
         `Plugin ${parsedYaml.name ?? "unknown"} runtime-postinstall must be an array`
       );
     }
-    if (path2 === "mcp") {
+    if (path3 === "mcp") {
       throw new Error(
         `Plugin ${parsedYaml.name ?? "unknown"} mcp must be an object`
       );
     }
-    if (path2 === "oauth") {
+    if (path3 === "oauth") {
       throw new Error(
         `Plugin ${parsedYaml.name ?? "unknown"} oauth must be an object`
       );
     }
-    if (path2 === "target") {
+    if (path3 === "target") {
       throw new Error(
         `Plugin ${parsedYaml.name ?? "unknown"} target must be an object`
       );
@@ -1439,14 +1831,24 @@ function parsePluginManifest(raw, dir) {
         `Plugin ${data.name} target.config-key "${result.data["config-key"]}" must be listed in config-keys`
       );
     }
-    manifest.target = { type: "repo", configKey: qualifiedKey };
+    const commandFlags = result.data["command-flags"];
+    if (commandFlags && commandFlags.some((flag) => !TARGET_FLAG_RE.test(flag))) {
+      throw new Error(
+        `Plugin ${data.name} target.command-flags must contain CLI flags like --repo or -R`
+      );
+    }
+    manifest.target = {
+      type: result.data.type,
+      configKey: qualifiedKey,
+      ...commandFlags ? { commandFlags } : {}
+    };
   }
   return manifest;
 }
 
 // src/chat/plugins/registry.ts
 import { readFileSync, readdirSync, statSync } from "fs";
-import path from "path";
+import path2 from "path";
 
 // src/chat/plugins/auth/github-app-broker.ts
 import { createPrivateKey, createSign, randomUUID } from "crypto";
@@ -1462,13 +1864,26 @@ function resolveAuthTokenPlaceholder(credentials) {
 
 // src/chat/plugins/auth/github-app-broker.ts
 var MAX_LEASE_MS = 60 * 60 * 1e3;
-function normalizeTargetScope(target) {
-  const owner = target?.owner?.trim().toLowerCase();
-  const repo = target?.repo?.trim().toLowerCase();
-  if (!owner || !repo) {
-    return "all";
+function parseRepoTarget(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const [repoRef] = trimmed.split("#");
+  const [owner, repo, extra] = repoRef.split("/");
+  if (!owner || !repo || extra) {
+    return void 0;
   }
-  return `${owner}/${repo}`;
+  return {
+    owner: owner.toLowerCase(),
+    repo: repo.toLowerCase()
+  };
+}
+function getRepoTarget(target) {
+  if (!target || target.type !== "repo") {
+    return void 0;
+  }
+  return parseRepoTarget(target.value);
 }
 function base64Url(input) {
   return Buffer.from(input).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
@@ -1527,8 +1942,8 @@ function createAppJwt(appId, privateKeyEnv) {
   const signature = signer.sign(getPrivateKey(privateKeyEnv)).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
   return `${signingInput}.${signature}`;
 }
-async function githubRequest(apiBase, path2, params) {
-  const response = await fetch(`${apiBase}${path2}`, {
+async function githubRequest(apiBase, path3, params) {
+  const response = await fetch(`${apiBase}${path3}`, {
     method: params.method ?? "GET",
     headers: {
       Accept: "application/vnd.github+json",
@@ -1553,10 +1968,6 @@ async function githubRequest(apiBase, path2, params) {
   }
   return parsed;
 }
-var CAPABILITY_ALIASES = {
-  "issues.comment": { permission: "issues", level: "write" },
-  "labels.write": { permission: "issues", level: "write" }
-};
 var KNOWN_SCOPES = /* @__PURE__ */ new Set([
   "actions",
   "administration",
@@ -1585,10 +1996,6 @@ function capabilityToPermissions(capability, pluginName) {
     throw new Error(`Unsupported GitHub capability: ${capability}`);
   }
   const suffix = capability.slice(prefix.length);
-  const alias = CAPABILITY_ALIASES[suffix];
-  if (alias) {
-    return { [alias.permission]: alias.level };
-  }
   const lastDot = suffix.lastIndexOf(".");
   if (lastDot === -1) {
     throw new Error(`Unsupported GitHub capability: ${capability}`);
@@ -1632,6 +2039,17 @@ function createGitHubAppBroker(manifest, credentials) {
     return `Bearer ${token}`;
   }
   const supportedCapabilities = new Set(manifest.capabilities);
+  function resolveInstallationId() {
+    const installationIdRaw = process.env[installationIdEnv]?.trim();
+    if (!installationIdRaw) {
+      throw new Error(`Missing ${installationIdEnv}`);
+    }
+    const installationId = Number(installationIdRaw);
+    if (!Number.isFinite(installationId)) {
+      throw new Error(`Invalid ${installationIdEnv}`);
+    }
+    return installationId;
+  }
   return {
     async issue(input) {
       if (!supportedCapabilities.has(input.capability)) {
@@ -1640,19 +2058,20 @@ function createGitHubAppBroker(manifest, credentials) {
         );
       }
       const permissions = capabilityToPermissions(input.capability, provider);
-      const appId = process.env[appIdEnv];
-      if (!appId) {
-        throw new Error(`Missing ${appIdEnv}`);
-      }
-      const installationIdRaw = process.env[installationIdEnv]?.trim();
-      if (!installationIdRaw) {
-        throw new Error(`Missing ${installationIdEnv}`);
-      }
-      const installationId = Number(installationIdRaw);
-      if (!Number.isFinite(installationId)) {
-        throw new Error(`Invalid ${installationIdEnv}`);
+      const installationId = resolveInstallationId();
+      let repoTarget;
+      if (input.target) {
+        if (input.target.type !== "repo") {
+          throw new Error(
+            `Unsupported github target type: ${input.target.type}`
+          );
+        }
+        repoTarget = getRepoTarget(input.target);
+        if (!repoTarget) {
+          throw new Error("Invalid github repo target: expected owner/repo");
+        }
       }
-      const targetScope = normalizeTargetScope(input.target);
+      const targetScope = repoTarget ? `${repoTarget.owner}/${repoTarget.repo}` : "all";
       const cacheKey = `${installationId}:${input.capability}:${targetScope}`;
       const cached = tokenCache.get(cacheKey);
       const now = Date.now();
@@ -1678,14 +2097,17 @@ function createGitHubAppBroker(manifest, credentials) {
           }
         };
       }
-      const appJwt = createAppJwt(appId, privateKeyEnv);
-      const repositoryName = input.target?.repo?.trim().toLowerCase();
       const tokenRequestBody = {
         permissions
       };
-      if (repositoryName) {
-        tokenRequestBody.repositories = [repositoryName];
+      if (repoTarget) {
+        tokenRequestBody.repositories = [repoTarget.repo];
       }
+      const appId = process.env[appIdEnv];
+      if (!appId) {
+        throw new Error(`Missing ${appIdEnv}`);
+      }
+      const appJwt = createAppJwt(appId, privateKeyEnv);
       const accessTokenResponse = await githubRequest(apiBase, `/app/installations/${installationId}/access_tokens`, {
         method: "POST",
         token: appJwt,
@@ -2034,7 +2456,7 @@ function registerPluginManifest(state, raw, pluginDir) {
   const definition = {
     manifest,
     dir: pluginDir,
-    skillsDir: path.join(pluginDir, "skills")
+    skillsDir: path2.join(pluginDir, "skills")
   };
   state.pluginDefinitions.push(definition);
   state.pluginsByName.set(manifest.name, definition);
@@ -2049,7 +2471,7 @@ function normalizePluginRoots(roots) {
   const resolved = [];
   const seen = /* @__PURE__ */ new Set();
   for (const root of roots) {
-    const normalized = path.resolve(root);
+    const normalized = path2.resolve(root);
     if (seen.has(normalized)) {
       continue;
     }
@@ -2076,7 +2498,7 @@ function getExtraPluginRoots() {
     }
   }
   return normalizePluginRoots(
-    raw.split(path.delimiter).map((entry) => entry.trim()).filter((entry) => entry.length > 0)
+    raw.split(path2.delimiter).map((entry) => entry.trim()).filter((entry) => entry.length > 0)
   );
 }
 function getPluginCatalogSource() {
@@ -2124,7 +2546,7 @@ function buildLoadedPluginState(source) {
       continue;
     }
     if (rootStat.isDirectory()) {
-      const manifestPath = path.join(pluginsRoot, "plugin.yaml");
+      const manifestPath = path2.join(pluginsRoot, "plugin.yaml");
       let hasRootManifest = false;
       try {
         hasRootManifest = statSync(manifestPath).isFile();
@@ -2152,14 +2574,14 @@ function buildLoadedPluginState(source) {
       continue;
     }
     for (const entry of entries.sort()) {
-      const pluginDir = path.join(pluginsRoot, entry);
+      const pluginDir = path2.join(pluginsRoot, entry);
       try {
         const stat = statSync(pluginDir);
         if (!stat.isDirectory()) continue;
       } catch {
         continue;
       }
-      const manifestPath = path.join(pluginDir, "plugin.yaml");
+      const manifestPath = path2.join(pluginDir, "plugin.yaml");
       let raw;
       try {
         raw = readFileSync(manifestPath, "utf8");
@@ -2214,7 +2636,12 @@ function getPluginCapabilityProviders() {
     provider: plugin.manifest.name,
     capabilities: [...plugin.manifest.capabilities],
     configKeys: [...plugin.manifest.configKeys],
-    ...plugin.manifest.target ? { target: { ...plugin.manifest.target } } : {}
+    ...plugin.manifest.target ? {
+      target: {
+        ...plugin.manifest.target,
+        ...plugin.manifest.target.commandFlags ? { commandFlags: [...plugin.manifest.target.commandFlags] } : {}
+      }
+    } : {}
   }));
 }
 function getPluginProviders() {
@@ -2295,10 +2722,10 @@ function getPluginSkillRoots() {
 }
 function getPluginForSkillPath(skillPath) {
   const state = ensurePluginsLoaded();
-  const resolvedSkillPath = path.resolve(skillPath);
+  const resolvedSkillPath = path2.resolve(skillPath);
   return state.pluginDefinitions.find((plugin) => {
-    const resolvedSkillsDir = path.resolve(plugin.skillsDir);
-    return resolvedSkillPath === resolvedSkillsDir || resolvedSkillPath.startsWith(`${resolvedSkillsDir}${path.sep}`);
+    const resolvedSkillsDir = path2.resolve(plugin.skillsDir);
+    return resolvedSkillPath === resolvedSkillsDir || resolvedSkillPath.startsWith(`${resolvedSkillsDir}${path2.sep}`);
   });
 }
 function getPluginDefinition(provider) {
@@ -2336,6 +2763,7 @@ export {
   toOptionalString,
   toOptionalNumber,
   isRecord,
+  createChatSdkLogger,
   logInfo,
   logWarn,
   logError,