@sentry/junior 0.1.0 → 0.2.0

package/dist/chunk-TQSDLJVE.js

@@ -0,0 +1,272 @@
+import {
+  appSlackRuntime,
+  createQueueCallbackHandler,
+  downloadPrivateSlackFile,
+  getThreadMessageTopic,
+  removeReactionFromMessage
+} from "./chunk-RXNMJQPY.js";
+import {
+  acquireQueueMessageProcessingOwnership,
+  completeQueueMessageProcessingOwnership,
+  failQueueMessageProcessingOwnership,
+  getQueueMessageProcessingState,
+  getStateAdapter,
+  refreshQueueMessageProcessingOwnership
+} from "./chunk-QHDDCUTN.js";
+import {
+  createRequestContext,
+  logError,
+  logException,
+  logWarn,
+  setSpanStatus,
+  withContext,
+  withSpan
+} from "./chunk-PY4AI2GZ.js";
+
+// src/chat/queue/process-thread-message.ts
+import { Message, ThreadImpl } from "chat";
+
+// src/chat/thread-runtime/process-thread-message-runtime.ts
+function rehydrateAttachmentFetchers(payload) {
+  for (const attachment of payload.message.attachments) {
+    if (!attachment.fetchData && attachment.url) {
+      attachment.fetchData = () => downloadPrivateSlackFile(attachment.url);
+    }
+  }
+}
+async function processThreadMessageRuntime(args) {
+  const runtimePayload = {
+    message: args.message,
+    thread: args.thread
+  };
+  rehydrateAttachmentFetchers(runtimePayload);
+  if (args.kind === "new_mention") {
+    await appSlackRuntime.handleNewMention(args.thread, args.message, {
+      beforeFirstResponsePost: args.beforeFirstResponsePost
+    });
+    return;
+  }
+  if (args.kind === "subscribed_reply") {
+    await appSlackRuntime.handleSubscribedMessage(args.thread, args.message, {
+      beforeFirstResponsePost: args.beforeFirstResponsePost,
+      preApprovedReply: true
+    });
+    return;
+  }
+  await appSlackRuntime.handleSubscribedMessage(args.thread, args.message, {
+    beforeFirstResponsePost: args.beforeFirstResponsePost
+  });
+}
+
+// src/chat/queue/process-thread-message.ts
+var stateAdapterConnected = false;
+function isSerializedThread(thread) {
+  return typeof thread === "object" && thread !== null && thread._type === "chat:Thread";
+}
+function isSerializedMessage(message) {
+  return typeof message === "object" && message !== null && message._type === "chat:Message";
+}
+function getPayloadChannelId(payload) {
+  return payload.thread.channelId;
+}
+function getPayloadUserId(payload) {
+  return payload.message.author?.userId;
+}
+function createMessageOwnerToken() {
+  return `msg-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+var QueueMessageOwnershipError = class extends Error {
+  constructor(stage, dedupKey) {
+    super(`Queue message ownership lost during ${stage} for dedupKey=${dedupKey}`);
+    this.name = "QueueMessageOwnershipError";
+  }
+};
+var defaultProcessQueuedThreadMessageDeps = {
+  clearProcessingReaction: async ({ channelId, timestamp }) => {
+    await removeReactionFromMessage({
+      channelId,
+      timestamp,
+      emoji: "eyes"
+    });
+  },
+  logWarn,
+  processRuntime: processThreadMessageRuntime
+};
+function deserializeThread(thread) {
+  if (isSerializedThread(thread)) {
+    return ThreadImpl.fromJSON(thread);
+  }
+  return thread;
+}
+function deserializeMessage(message) {
+  if (isSerializedMessage(message)) {
+    return Message.fromJSON(message);
+  }
+  return message;
+}
+async function logThreadMessageFailure(payload, errorMessage) {
+  logError(
+    "queue_message_failed",
+    {
+      slackThreadId: payload.normalizedThreadId,
+      slackChannelId: getPayloadChannelId(payload),
+      slackUserId: getPayloadUserId(payload)
+    },
+    {
+      "messaging.message.id": payload.message.id,
+      "app.queue.message_kind": payload.kind,
+      "app.queue.message_id": payload.queueMessageId,
+      "error.message": errorMessage
+    },
+    "Queue message processing failed"
+  );
+}
+async function processQueuedThreadMessage(payload, deps = defaultProcessQueuedThreadMessageDeps) {
+  const existingMessageState = await getQueueMessageProcessingState(payload.dedupKey);
+  if (existingMessageState?.status === "completed") {
+    return;
+  }
+  const ownerToken = createMessageOwnerToken();
+  const claimResult = await acquireQueueMessageProcessingOwnership({
+    rawKey: payload.dedupKey,
+    ownerToken,
+    queueMessageId: payload.queueMessageId
+  });
+  if (claimResult === "blocked") {
+    return;
+  }
+  const threadWasSerialized = isSerializedThread(payload.thread);
+  if (threadWasSerialized && !stateAdapterConnected) {
+    await getStateAdapter().connect();
+    stateAdapterConnected = true;
+  }
+  const runtimePayload = {
+    ...payload,
+    thread: deserializeThread(payload.thread),
+    message: deserializeMessage(payload.message)
+  };
+  try {
+    const refreshed = await refreshQueueMessageProcessingOwnership({
+      rawKey: payload.dedupKey,
+      ownerToken,
+      queueMessageId: payload.queueMessageId
+    });
+    if (!refreshed) {
+      throw new QueueMessageOwnershipError("refresh", payload.dedupKey);
+    }
+    let reactionCleared = false;
+    const clearReactionBeforeFirstResponsePost = async () => {
+      if (reactionCleared) {
+        return;
+      }
+      reactionCleared = true;
+      try {
+        await deps.clearProcessingReaction({
+          channelId: runtimePayload.thread.channelId,
+          timestamp: runtimePayload.message.id
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        deps.logWarn(
+          "queue_processing_reaction_clear_failed",
+          {
+            slackThreadId: payload.normalizedThreadId,
+            slackChannelId: getPayloadChannelId(payload),
+            slackUserId: getPayloadUserId(payload)
+          },
+          {
+            "messaging.message.id": payload.message.id,
+            "app.queue.message_kind": payload.kind,
+            "app.queue.message_id": payload.queueMessageId,
+            "error.message": errorMessage
+          },
+          "Failed to remove processing reaction before sending queue response"
+        );
+      }
+    };
+    await deps.processRuntime({
+      kind: runtimePayload.kind,
+      thread: runtimePayload.thread,
+      message: runtimePayload.message,
+      beforeFirstResponsePost: clearReactionBeforeFirstResponsePost
+    });
+    const completed = await completeQueueMessageProcessingOwnership({
+      rawKey: payload.dedupKey,
+      ownerToken,
+      queueMessageId: payload.queueMessageId
+    });
+    if (!completed) {
+      throw new QueueMessageOwnershipError("complete", payload.dedupKey);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await logThreadMessageFailure(payload, errorMessage);
+    const failed = await failQueueMessageProcessingOwnership({
+      rawKey: payload.dedupKey,
+      ownerToken,
+      errorMessage,
+      queueMessageId: payload.queueMessageId
+    });
+    if (!failed && !(error instanceof QueueMessageOwnershipError)) {
+      throw new Error(`Failed to persist queue message failure state for dedupKey=${payload.dedupKey}: ${errorMessage}`);
+    }
+    throw error;
+  }
+}
+
+// src/handlers/queue-callback.ts
+var callbackHandler = createQueueCallbackHandler(async (message, metadata) => {
+  if (metadata.topicName === getThreadMessageTopic()) {
+    const payload = {
+      ...message,
+      queueMessageId: metadata.messageId
+    };
+    await withSpan(
+      "queue.process_message",
+      "queue.process_message",
+      {
+        slackThreadId: payload.normalizedThreadId,
+        slackChannelId: payload.thread.channelId,
+        slackUserId: payload.message.author?.userId
+      },
+      async () => {
+        await processQueuedThreadMessage(payload);
+      },
+      {
+        "messaging.message.id": payload.message.id,
+        "app.queue.message_kind": payload.kind,
+        "app.queue.message_id": payload.queueMessageId,
+        "app.queue.delivery_count": metadata.deliveryCount,
+        "app.queue.topic": metadata.topicName
+      }
+    );
+    return;
+  }
+  throw new Error(`Unexpected queue topic: ${metadata.topicName}`);
+});
+async function POST(request) {
+  const requestContext = createRequestContext(request, { platform: "queue" });
+  return withContext(requestContext, async () => {
+    try {
+      const response = await callbackHandler(request);
+      setSpanStatus(response.status >= 500 ? "error" : "ok");
+      return response;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logError(
+        "queue_callback_failed",
+        {},
+        {
+          "error.message": message
+        },
+        "Queue callback processing failed"
+      );
+      logException(error, "queue_callback_failed");
+      throw error;
+    }
+  });
+}
+
+export {
+  POST
+};

package/dist/cli/init.d.ts

@@ -0,0 +1,3 @@
+declare function runInit(dir: string, log?: (line: string) => void): Promise<void>;
+
+export { runInit };

package/dist/cli/init.js

@@ -0,0 +1,105 @@
+// src/cli/init.ts
+import fs from "fs";
+import path from "path";
+function writeRouteModule(filePath, exportLine) {
+  fs.writeFileSync(filePath, `${exportLine}
+export const runtime = "nodejs";
+`);
+}
+function writeWrapperFiles(targetDir) {
+  const routeDir = path.join(targetDir, "app", "api", "[...path]");
+  fs.mkdirSync(routeDir, { recursive: true });
+  writeRouteModule(path.join(routeDir, "route.js"), 'export { GET, POST } from "@sentry/junior/handler";');
+  const queueRouteDir = path.join(targetDir, "app", "api", "queue", "callback");
+  fs.mkdirSync(queueRouteDir, { recursive: true });
+  writeRouteModule(
+    path.join(queueRouteDir, "route.js"),
+    'export { POST } from "@sentry/junior/handlers/queue-callback";'
+  );
+  fs.mkdirSync(path.join(targetDir, "app"), { recursive: true });
+  fs.writeFileSync(
+    path.join(targetDir, "app", "layout.js"),
+    'export { default } from "@sentry/junior/app/layout";\n'
+  );
+  fs.writeFileSync(
+    path.join(targetDir, "next.config.mjs"),
+    'import { withJunior } from "@sentry/junior/config";\nexport default withJunior();\n'
+  );
+  fs.writeFileSync(
+    path.join(targetDir, "instrumentation.js"),
+    'export { register, onRequestError } from "@sentry/junior/instrumentation";\n'
+  );
+}
+async function runInit(dir, log = console.log) {
+  const targetDir = dir.trim();
+  if (!targetDir) {
+    throw new Error("usage: junior init <dir>");
+  }
+  const target = path.resolve(targetDir);
+  if (fs.existsSync(target)) {
+    const stat = fs.statSync(target);
+    if (!stat.isDirectory()) {
+      throw new Error(`refusing to initialize non-directory path: ${target}`);
+    }
+    if (fs.readdirSync(target).length > 0) {
+      throw new Error(`refusing to initialize non-empty directory: ${target}`);
+    }
+  } else {
+    fs.mkdirSync(target, { recursive: true });
+  }
+  const name = path.basename(target);
+  const pkg = {
+    name,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "next dev",
+      build: "next build",
+      start: "next start"
+    },
+    dependencies: {
+      "@sentry/junior": "latest",
+      next: "^16.0.0",
+      react: "^19.0.0",
+      "react-dom": "^19.0.0",
+      "@sentry/nextjs": "^10.0.0"
+    }
+  };
+  fs.writeFileSync(path.join(target, "package.json"), `${JSON.stringify(pkg, null, 2)}
+`);
+  const dataDir = path.join(target, "app", "data");
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(path.join(dataDir, "SOUL.md"), `# ${name}
+
+You are ${name}, a helpful assistant.
+`);
+  const skillsDir = path.join(target, "app", "skills");
+  fs.mkdirSync(skillsDir, { recursive: true });
+  fs.writeFileSync(path.join(skillsDir, ".gitkeep"), "");
+  const pluginsDir = path.join(target, "app", "plugins");
+  fs.mkdirSync(pluginsDir, { recursive: true });
+  fs.writeFileSync(path.join(pluginsDir, ".gitkeep"), "");
+  fs.writeFileSync(path.join(target, ".gitignore"), ["node_modules/", ".next/", ".env", ".env.local", ""].join("\n"));
+  fs.writeFileSync(
+    path.join(target, ".env.example"),
+    [
+      "SLACK_BOT_TOKEN=",
+      "SLACK_SIGNING_SECRET=",
+      "JUNIOR_BOT_NAME=",
+      "AI_MODEL=",
+      "AI_FAST_MODEL=",
+      "REDIS_URL=",
+      "NEXT_PUBLIC_SENTRY_DSN=",
+      ""
+    ].join("\n")
+  );
+  writeWrapperFiles(target);
+  log(`Created ${name} at ${target}`);
+  log("");
+  log(`  cd ${targetDir} && pnpm install && pnpm dev`);
+  log("");
+}
+export {
+  runInit
+};

package/dist/cli/run.d.ts

@@ -0,0 +1,11 @@
+declare const CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create";
+interface CliHandlers {
+    runInit: (dir: string) => Promise<void>;
+    runSnapshotCreate: () => Promise<void>;
+}
+interface CliIo {
+    error: (line: string) => void;
+}
+declare function runCli(argv: string[], handlers: CliHandlers, io?: CliIo): Promise<number>;
+
+export { CLI_USAGE, runCli };

package/dist/cli/run.js

@@ -0,0 +1,30 @@
+// src/cli/run.ts
+var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create";
+var DEFAULT_IO = {
+  error: console.error
+};
+async function runCli(argv, handlers, io = DEFAULT_IO) {
+  const [command, subcommand, ...rest] = argv;
+  if (command === "init") {
+    if (!subcommand || rest.length > 0) {
+      io.error(CLI_USAGE);
+      return 1;
+    }
+    await handlers.runInit(subcommand);
+    return 0;
+  }
+  if (command === "snapshot" && subcommand === "create") {
+    if (rest.length > 0) {
+      io.error(CLI_USAGE);
+      return 1;
+    }
+    await handlers.runSnapshotCreate();
+    return 0;
+  }
+  io.error(CLI_USAGE);
+  return 1;
+}
+export {
+  CLI_USAGE,
+  runCli
+};

package/dist/cli/snapshot-warmup.d.ts

@@ -0,0 +1,3 @@
+declare function runSnapshotCreate(log?: (line: string) => void): Promise<void>;
+
+export { runSnapshotCreate };

package/dist/cli/snapshot-warmup.js

@@ -0,0 +1,57 @@
+import {
+  disconnectStateAdapter,
+  resolveRuntimeDependencySnapshot
+} from "../chunk-QHDDCUTN.js";
+import "../chunk-PY4AI2GZ.js";
+
+// src/cli/snapshot-warmup.ts
+var DEFAULT_RUNTIME = "node22";
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+function progressMessage(phase) {
+  if (phase === "resolve_start") {
+    return "Resolving sandbox snapshot profile...";
+  }
+  if (phase === "cache_hit") {
+    return "Using cached sandbox snapshot.";
+  }
+  if (phase === "waiting_for_lock") {
+    return "Waiting for sandbox snapshot build lock...";
+  }
+  if (phase === "building_snapshot") {
+    return "Building sandbox snapshot...";
+  }
+  return "Sandbox snapshot build complete.";
+}
+async function runSnapshotCreate(log = console.log) {
+  const runtime = DEFAULT_RUNTIME;
+  const timeoutMs = DEFAULT_TIMEOUT_MS;
+  try {
+    const emitted = /* @__PURE__ */ new Set();
+    const snapshot = await resolveRuntimeDependencySnapshot({
+      runtime,
+      timeoutMs,
+      onProgress: async (phase) => {
+        if (emitted.has(phase)) {
+          return;
+        }
+        emitted.add(phase);
+        log(progressMessage(phase));
+      }
+    });
+    const fields = [
+      `runtime=${runtime}`,
+      `resolve_outcome=${snapshot.resolveOutcome}`,
+      `cache_hit=${snapshot.cacheHit}`,
+      `dependency_count=${snapshot.dependencyCount}`,
+      ...snapshot.profileHash ? [`profile_hash=${snapshot.profileHash}`] : [],
+      ...snapshot.snapshotId ? [`snapshot_id=${snapshot.snapshotId}`] : [],
+      ...snapshot.rebuildReason ? [`rebuild_reason=${snapshot.rebuildReason}`] : []
+    ];
+    log(`Sandbox snapshot create complete: ${fields.join(" ")}`);
+  } finally {
+    await disconnectStateAdapter();
+  }
+}
+export {
+  runSnapshotCreate
+};

package/dist/handlers/health.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Returns a minimal JSON health response for runtime health checks.
+ */
 declare function GET(): Promise<Response>;
 
 export { GET };

package/dist/handlers/queue-callback.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Handles `POST /api/queue/callback` for asynchronous thread processing.
+ *
+ * Keep this route as a dedicated handler in app code. The catch-all router can
+ * mirror this path for local/dev parity, but production queue delivery should
+ * always target the dedicated endpoint.
+ */
 declare function POST(request: Request): Promise<Response>;
 
 export { POST };