@sentry/junior 0.1.0

package/dist/instrumentation.d.ts

@@ -0,0 +1,6 @@
+import * as Sentry from '@sentry/nextjs';
+
+declare function register(): Promise<void>;
+declare const onRequestError: typeof Sentry.captureRequestError;
+
+export { onRequestError, register };

package/dist/instrumentation.js

@@ -0,0 +1,49 @@
+// src/instrumentation.ts
+import * as Sentry from "@sentry/nextjs";
+function getSampleRate(value, fallback) {
+  if (!value) return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function getBoolean(value, fallback) {
+  if (!value) return fallback;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return fallback;
+}
+function getCommonOptions() {
+  const dsn = process.env.SENTRY_DSN ?? process.env.NEXT_PUBLIC_SENTRY_DSN;
+  const enableLogs = getBoolean(process.env.SENTRY_ENABLE_LOGS, Boolean(dsn));
+  return {
+    dsn,
+    environment: process.env.SENTRY_ENVIRONMENT ?? process.env.VERCEL_ENV ?? process.env.NODE_ENV,
+    release: process.env.SENTRY_RELEASE ?? process.env.VERCEL_GIT_COMMIT_SHA,
+    tracesSampleRate: getSampleRate(process.env.SENTRY_TRACES_SAMPLE_RATE, 1),
+    sendDefaultPii: true,
+    enabled: Boolean(dsn),
+    enableLogs
+  };
+}
+async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    Sentry.init({
+      ...getCommonOptions(),
+      integrations: [
+        Sentry.vercelAIIntegration({
+          recordInputs: true,
+          recordOutputs: true
+        })
+      ]
+    });
+    return;
+  }
+  if (process.env.NEXT_RUNTIME === "edge") {
+    Sentry.init(getCommonOptions());
+  }
+}
+var onRequestError = Sentry.captureRequestError;
+export {
+  onRequestError,
+  register
+};

package/dist/next-config.d.ts

@@ -0,0 +1,14 @@
+import { NextConfig } from 'next';
+
+interface JuniorConfigOptions {
+    dataDir?: string;
+    skillsDir?: string;
+    pluginsDir?: string;
+    sentry?: boolean;
+}
+type NextConfigFactory = (phase: string, ctx: {
+    defaultConfig: NextConfig;
+}) => Promise<NextConfig> | NextConfig;
+declare function withJunior(nextConfig?: NextConfig | NextConfigFactory, options?: JuniorConfigOptions): NextConfig | NextConfigFactory;
+
+export { type JuniorConfigOptions, withJunior };

package/dist/next-config.js

@@ -0,0 +1,108 @@
+// src/next-config.ts
+import { createRequire } from "module";
+import { readFileSync, statSync } from "fs";
+import path from "path";
+var require2 = createRequire(import.meta.url);
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function discoverInstalledPluginPackageTracingIncludes(cwd = process.cwd()) {
+  const rootPackageJsonPath = path.join(cwd, "package.json");
+  let rootPackageJson;
+  try {
+    rootPackageJson = JSON.parse(readFileSync(rootPackageJsonPath, "utf8"));
+  } catch {
+    return [];
+  }
+  const dependencies = [
+    ...Object.keys(rootPackageJson.dependencies ?? {}),
+    ...Object.keys(rootPackageJson.optionalDependencies ?? {})
+  ];
+  const tracingIncludes = [];
+  for (const dependency of dependencies) {
+    const packageDir = path.join(cwd, "node_modules", ...dependency.split("/"));
+    if (!isDirectory(packageDir)) {
+      continue;
+    }
+    const base = `./node_modules/${dependency}`;
+    if (isFile(path.join(packageDir, "plugin.yaml"))) {
+      tracingIncludes.push(`${base}/plugin.yaml`);
+    }
+    if (isDirectory(path.join(packageDir, "plugins"))) {
+      tracingIncludes.push(`${base}/plugins/**/*`);
+    }
+    if (isDirectory(path.join(packageDir, "skills"))) {
+      tracingIncludes.push(`${base}/skills/**/*`);
+    }
+  }
+  return [...new Set(tracingIncludes)].sort((left, right) => left.localeCompare(right));
+}
+function applyJuniorConfig(nextConfig, options) {
+  const dataDir = options?.dataDir ?? "./app/data";
+  const skillsDir = options?.skillsDir ?? "./app/skills";
+  const pluginsDir = options?.pluginsDir ?? "./app/plugins";
+  const defaultDataTracingIncludes = options?.dataDir ? [`${dataDir}/**/*`] : ["./app/SOUL.md", "./app/ABOUT.md"];
+  const pluginPackageTracingIncludes = discoverInstalledPluginPackageTracingIncludes();
+  const tracingIncludes = Array.from(/* @__PURE__ */ new Set([
+    ...defaultDataTracingIncludes,
+    `${skillsDir}/**/*`,
+    `${pluginsDir}/**/*`,
+    ...pluginPackageTracingIncludes
+  ]));
+  const existingGlobalTracingIncludes = nextConfig?.outputFileTracingIncludes?.["/*"] ?? [];
+  const mergedGlobalTracingIncludes = Array.from(/* @__PURE__ */ new Set([
+    ...existingGlobalTracingIncludes,
+    ...tracingIncludes
+  ]));
+  const config = {
+    ...nextConfig,
+    serverExternalPackages: Array.from(/* @__PURE__ */ new Set([
+      ...nextConfig?.serverExternalPackages ?? [],
+      "@vercel/sandbox",
+      "bash-tool",
+      "just-bash",
+      "@chat-adapter/slack",
+      "@slack/web-api"
+    ])),
+    outputFileTracingIncludes: {
+      ...nextConfig?.outputFileTracingIncludes,
+      "/*": mergedGlobalTracingIncludes
+    }
+  };
+  if (options?.sentry) {
+    const { withSentryConfig } = require2("@sentry/nextjs");
+    return withSentryConfig(config, {
+      org: process.env.SENTRY_ORG,
+      project: process.env.SENTRY_PROJECT,
+      authToken: process.env.SENTRY_AUTH_TOKEN,
+      silent: !process.env.CI,
+      sourcemaps: {
+        disable: false
+      }
+    });
+  }
+  return config;
+}
+function withJunior(nextConfig, options) {
+  if (typeof nextConfig === "function") {
+    return async (phase, ctx) => {
+      const resolved = await nextConfig(phase, ctx);
+      return applyJuniorConfig(resolved, options);
+    };
+  }
+  return applyJuniorConfig(nextConfig, options);
+}
+export {
+  withJunior
+};

package/dist/route-XLYK6CKP.js

@@ -0,0 +1,309 @@
+import {
+  escapeXml,
+  generateAssistantReply,
+  getOAuthProviderConfig,
+  getUserTokenStore,
+  publishAppHomeView,
+  resolveBaseUrl,
+  truncateStatusText
+} from "./chunk-7E56WM6K.js";
+import {
+  getStateAdapter
+} from "./chunk-ZBFSIN6G.js";
+import "./chunk-MM3YNA4F.js";
+import {
+  botConfig,
+  getSlackClient
+} from "./chunk-GDNDYMGX.js";
+import {
+  logException,
+  logInfo
+} from "./chunk-BBOVH5RF.js";
+
+// app/api/oauth/callback/[provider]/route.ts
+import { after } from "next/server";
+var runtime = "nodejs";
+function htmlErrorResponse(title, message, status) {
+  const safeTitle = escapeXml(title);
+  const html = `<!DOCTYPE html>
+<html>
+<head><title>${safeTitle}</title></head>
+<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
+  <div style="text-align: center; max-width: 480px;">
+    <h1>${safeTitle}</h1>
+    <p>${message}</p>
+    <p style="margin-top: 2rem; color: #666; font-size: 0.9em;">You can close this tab and return to Slack to try again.</p>
+  </div>
+</body>
+</html>`;
+  return new Response(html, {
+    status,
+    headers: { "Content-Type": "text/html; charset=utf-8" }
+  });
+}
+async function postSlackMessage(channelId, threadTs, text) {
+  try {
+    await getSlackClient().chat.postMessage({ channel: channelId, thread_ts: threadTs, text });
+  } catch {
+  }
+}
+async function setAssistantStatus(channelId, threadTs, status) {
+  try {
+    await getSlackClient().assistant.threads.setStatus({ channel_id: channelId, thread_ts: threadTs, status });
+  } catch {
+  }
+}
+var STATUS_DEBOUNCE_MS = 1e3;
+function createDebouncedStatusPoster(channelId, threadTs) {
+  let lastPostAt = 0;
+  let currentStatus = "";
+  let pendingStatus = null;
+  let pendingTimer = null;
+  let stopped = false;
+  const flush = async () => {
+    if (stopped || !pendingStatus) return;
+    const status = pendingStatus;
+    pendingStatus = null;
+    pendingTimer = null;
+    lastPostAt = Date.now();
+    currentStatus = status;
+    await setAssistantStatus(channelId, threadTs, status);
+  };
+  const post = async (status) => {
+    if (stopped) return;
+    const truncated = truncateStatusText(status);
+    if (!truncated || truncated === currentStatus) return;
+    const now = Date.now();
+    const elapsed = now - lastPostAt;
+    if (elapsed >= STATUS_DEBOUNCE_MS) {
+      if (pendingTimer) {
+        clearTimeout(pendingTimer);
+        pendingTimer = null;
+      }
+      pendingStatus = null;
+      lastPostAt = now;
+      currentStatus = truncated;
+      await setAssistantStatus(channelId, threadTs, truncated);
+      return;
+    }
+    pendingStatus = truncated;
+    if (!pendingTimer) {
+      pendingTimer = setTimeout(() => {
+        void flush();
+      }, Math.max(1, STATUS_DEBOUNCE_MS - elapsed));
+    }
+  };
+  post.stop = () => {
+    stopped = true;
+    if (pendingTimer) {
+      clearTimeout(pendingTimer);
+      pendingTimer = null;
+    }
+    pendingStatus = null;
+  };
+  return post;
+}
+function createReadOnlyConfigService(values) {
+  const entries = Object.entries(values).map(([key, value]) => ({
+    key,
+    value,
+    scope: "conversation",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  return {
+    get: async (key) => entries.find((e) => e.key === key),
+    set: async () => {
+      throw new Error("Read-only configuration in resumed context");
+    },
+    unset: async () => false,
+    list: async ({ prefix } = {}) => entries.filter((e) => !prefix || e.key.startsWith(prefix)),
+    resolve: async (key) => values[key],
+    resolveValues: async ({ keys, prefix } = {}) => {
+      const filtered = {};
+      for (const [key, value] of Object.entries(values)) {
+        if (prefix && !key.startsWith(prefix)) continue;
+        if (keys && !keys.includes(key)) continue;
+        filtered[key] = value;
+      }
+      return filtered;
+    }
+  };
+}
+async function resumePendingMessage(stored) {
+  if (!stored.pendingMessage || !stored.channelId || !stored.threadTs) return;
+  const providerLabel = stored.provider.charAt(0).toUpperCase() + stored.provider.slice(1);
+  await postSlackMessage(
+    stored.channelId,
+    stored.threadTs,
+    `Your ${providerLabel} account is now connected. Processing your request...`
+  );
+  const postStatus = createDebouncedStatusPoster(stored.channelId, stored.threadTs);
+  await setAssistantStatus(stored.channelId, stored.threadTs, "Thinking...");
+  try {
+    const reply = await generateAssistantReply(stored.pendingMessage, {
+      assistant: { userName: botConfig.userName },
+      requester: { userId: stored.userId },
+      correlation: {
+        channelId: stored.channelId,
+        threadTs: stored.threadTs,
+        requesterId: stored.userId
+      },
+      configuration: stored.configuration,
+      channelConfiguration: stored.configuration ? createReadOnlyConfigService(stored.configuration) : void 0,
+      onStatus: postStatus
+    });
+    postStatus.stop();
+    if (reply.text) {
+      await postSlackMessage(stored.channelId, stored.threadTs, reply.text);
+    }
+    logInfo(
+      "oauth_callback_resume_complete",
+      {},
+      {
+        "app.credential.provider": stored.provider,
+        "app.ai.outcome": reply.diagnostics.outcome,
+        "app.ai.tool_calls": reply.diagnostics.toolCalls.length
+      },
+      "Auto-resumed pending message after OAuth callback"
+    );
+  } catch (error) {
+    postStatus.stop();
+    logException(
+      error,
+      "oauth_callback_resume_failed",
+      {},
+      { "app.credential.provider": stored.provider },
+      "Failed to auto-resume pending message after OAuth callback"
+    );
+    await postSlackMessage(
+      stored.channelId,
+      stored.threadTs,
+      `I connected your account but hit an error processing your request. Please try \`${stored.pendingMessage}\` again.`
+    );
+  }
+}
+async function GET(request, context) {
+  const { provider } = await context.params;
+  const providerConfig = getOAuthProviderConfig(provider);
+  if (!providerConfig) {
+    return htmlErrorResponse("Unknown provider", "The OAuth provider in this link is not recognized.", 404);
+  }
+  const providerLabel = provider.charAt(0).toUpperCase() + provider.slice(1);
+  const url = new URL(request.url);
+  const errorParam = url.searchParams.get("error");
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  if (errorParam) {
+    if (state) {
+      const cleanupAdapter = getStateAdapter();
+      await cleanupAdapter.delete(`oauth-state:${state}`);
+    }
+    if (errorParam === "access_denied") {
+      return htmlErrorResponse(
+        "Authorization declined",
+        `You declined the ${providerLabel} authorization request. Return to Slack and run the auth command again if you change your mind.`,
+        400
+      );
+    }
+    return htmlErrorResponse(
+      "Authorization failed",
+      `${providerLabel} returned an error: ${escapeXml(errorParam)}. Return to Slack and try again.`,
+      400
+    );
+  }
+  if (!code || !state) {
+    return htmlErrorResponse("Invalid request", "This authorization link is missing required parameters.", 400);
+  }
+  const stateAdapter = getStateAdapter();
+  const stateKey = `oauth-state:${state}`;
+  const stored = await stateAdapter.get(stateKey);
+  if (!stored) {
+    return htmlErrorResponse(
+      "Link expired",
+      `This authorization link has expired (links are valid for 10 minutes). Return to Slack and ask to connect your ${providerLabel} account again, or retry your original command to get a new link.`,
+      400
+    );
+  }
+  if (stored.provider !== provider) {
+    return htmlErrorResponse("Provider mismatch", "This authorization link does not match the expected provider.", 400);
+  }
+  await stateAdapter.delete(stateKey);
+  const clientId = process.env[providerConfig.clientIdEnv]?.trim();
+  const clientSecret = process.env[providerConfig.clientSecretEnv]?.trim();
+  if (!clientId || !clientSecret) {
+    return htmlErrorResponse("Configuration error", "OAuth client credentials are not configured on the server.", 500);
+  }
+  const baseUrl = resolveBaseUrl();
+  if (!baseUrl) {
+    return htmlErrorResponse("Configuration error", "The server cannot determine its base URL.", 500);
+  }
+  const redirectUri = `${baseUrl}${providerConfig.callbackPath}`;
+  let tokenResponse;
+  try {
+    tokenResponse = await fetch(providerConfig.tokenEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        code,
+        client_id: clientId,
+        client_secret: clientSecret,
+        redirect_uri: redirectUri
+      })
+    });
+  } catch {
+    return htmlErrorResponse("Connection failed", "Failed to exchange the authorization code. Please try again.", 500);
+  }
+  if (!tokenResponse.ok) {
+    return htmlErrorResponse("Connection failed", "The token exchange with the provider failed. Please try again.", 500);
+  }
+  const tokenData = await tokenResponse.json();
+  if (!tokenData.access_token || !tokenData.refresh_token || typeof tokenData.expires_in !== "number") {
+    return htmlErrorResponse("Connection failed", "The provider returned an incomplete token response. Please try again.", 500);
+  }
+  const accessToken = tokenData.access_token;
+  const refreshToken = tokenData.refresh_token;
+  const expiresAt = Date.now() + tokenData.expires_in * 1e3;
+  const userTokenStore = getUserTokenStore();
+  await userTokenStore.set(stored.userId, provider, {
+    accessToken,
+    refreshToken,
+    expiresAt
+  });
+  after(async () => {
+    try {
+      await publishAppHomeView(getSlackClient(), stored.userId, userTokenStore);
+    } catch {
+    }
+  });
+  if (stored.pendingMessage && stored.channelId && stored.threadTs) {
+    after(() => resumePendingMessage(stored));
+  } else if (stored.channelId && stored.threadTs) {
+    after(async () => {
+      await postSlackMessage(
+        stored.channelId,
+        stored.threadTs,
+        `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
+      );
+    });
+  }
+  const statusMessage = stored.pendingMessage ? "Your request is being processed in Slack." : "You can close this tab and return to Slack.";
+  const html = `<!DOCTYPE html>
+<html>
+<head><title>${providerLabel} Connected</title></head>
+<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
+  <div style="text-align: center;">
+    <h1>${providerLabel} account connected</h1>
+    <p>${statusMessage}</p>
+  </div>
+</body>
+</html>`;
+  return new Response(html, {
+    status: 200,
+    headers: { "Content-Type": "text/html; charset=utf-8" }
+  });
+}
+export {
+  GET,
+  runtime
+};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@sentry/junior",
+  "version": "0.1.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "junior": "bin/junior.mjs"
+  },
+  "exports": {
+    "./handler": "./dist/handlers/router.js",
+    "./handlers/webhooks": "./dist/handlers/webhooks.js",
+    "./handlers/queue-callback": "./dist/handlers/queue-callback.js",
+    "./handlers/health": "./dist/handlers/health.js",
+    "./config": "./dist/next-config.js",
+    "./instrumentation": "./dist/instrumentation.js",
+    "./app/layout": "./dist/app/layout.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "dependencies": {
+    "@ai-sdk/gateway": "^3.0.66",
+    "@chat-adapter/slack": "4.17.0",
+    "@chat-adapter/state-memory": "4.17.0",
+    "@chat-adapter/state-redis": "4.17.0",
+    "@mariozechner/pi-agent-core": "^0.56.3",
+    "@mariozechner/pi-ai": "^0.56.3",
+    "@sinclair/typebox": "^0.34.48",
+    "@slack/web-api": "^7.14.1",
+    "@vercel/queue": "^0.1.3",
+    "@vercel/sandbox": "^1.8.0",
+    "ai": "^6.0.116",
+    "bash-tool": "^1.3.15",
+    "chat": "4.17.0",
+    "just-bash": "^2.12.0",
+    "node-html-markdown": "^2.0.0",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6",
+    "@sentry/junior-github": "0.1.0",
+    "@sentry/junior-sentry": "0.1.0"
+  },
+  "peerDependencies": {
+    "@sentry/nextjs": ">=10.0.0",
+    "next": ">=15.0.0",
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "devDependencies": {
+    "@sentry/nextjs": "^10.42.0",
+    "@types/node": "^25.3.5",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "msw": "^2.12.10",
+    "next": "^16.1.6",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vercel": "^50.28.0",
+    "vitest": "^4.0.18",
+    "vitest-evals": "^0.6.0"
+  },
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "build:pkg": "tsup",
+    "start": "next start",
+    "test": "pnpm run test:slack-boundary && vitest run",
+    "test:watch": "vitest",
+    "preevals": "pnpm run test:slack-boundary",
+    "evals": "JUNIOR_STATE_ADAPTER=memory pnpm exec vitest run -c vitest.evals.config.ts",
+    "test:slack-boundary": "node scripts/check-slack-test-boundary.mjs",
+    "typecheck": "tsc --noEmit",
+    "skills:check": "node scripts/check-skills.mjs"
+  }
+}