create-loopengine 0.1.52 → 0.1.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.52",
+  "version": "0.1.54",
   "description": "Scaffold a new loopengine agent project — a runnable HTTP server with one example agent, in your own repo.",
   "license": "MIT",
   "type": "module",

package/template/adapters/http.ts

@@ -101,8 +101,19 @@ import {
   verifyProxyIdentity,
   TRUSTED_PROXY_IDENTITY_HEADER,
   NotifierFileError,
+  verifyDecisionToken,
+  renderDecidePage,
+  renderDecideGonePage,
+  renderDecideInvalidPage,
   describeAgentNotifier,
   listAgentPending,
+  listAgentSlackChannels,
+  slackCredentialsFor,
+  openSlackAnswerModal,
+  parseSlackInteraction,
+  replyInSlack,
+  slackOutcomeText,
+  verifySlackRequest,
   removeAgentNotifier,
   saveAgentNotifier,
   testAgentNotifier,
@@ -235,6 +246,15 @@ function resolveTenant(
   return result === undefined ? { ok: false } : { ok: true, value: result }
 }
 
+function readRawBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = ''
+    req.on('data', (chunk) => (data += chunk))
+    req.on('end', () => resolve(data))
+    req.on('error', reject)
+  })
+}
+
 function readJsonBody(req: IncomingMessage): Promise<Record<string, unknown>> {
   return new Promise((resolve, reject) => {
     let data = ''
@@ -1045,7 +1065,7 @@ function handleEnvGet(res: ServerResponse, agentName: string): void {
   res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(listDeclaredEnvVars(agentName)))
 }
 
-// Backs the console's Permissions → Approvals section — see
+// Backs the console's Permissions tab (where approval requests and questions are sent) — see
 // web/notifier-admin.ts. Reading is open like the rest of the admin
 // surface; saving or removing writes a secret and a file, so it gets the
 // same refuse-without-auth gate as the env routes below.
@@ -1055,7 +1075,7 @@ function handleNotifierGet(res: ServerResponse, agentName: string): void {
     res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `unknown agent '${agentName}'` }))
     return
   }
-  res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(describeAgentNotifier(entry.config, defaultWebhook)))
+  res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ ...describeAgentNotifier(entry.config, defaultWebhook), canSave: secretsProtected }))
 }
 
 async function handleNotifierPut(req: IncomingMessage, res: ServerResponse, agentName: string): Promise<void> {
@@ -1077,7 +1097,7 @@ async function handleNotifierPut(req: IncomingMessage, res: ServerResponse, agen
     res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
     return
   }
-  res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(describeAgentNotifier(entry.config, defaultWebhook)))
+  res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ ...describeAgentNotifier(entry.config, defaultWebhook), canSave: secretsProtected }))
 }
 
 function handleNotifierDelete(res: ServerResponse, agentName: string): void {
@@ -1093,7 +1113,7 @@ function handleNotifierDelete(res: ServerResponse, agentName: string): void {
     return
   }
   removeAgentNotifier(entry.config)
-  res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(describeAgentNotifier(entry.config, defaultWebhook)))
+  res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ ...describeAgentNotifier(entry.config, defaultWebhook), canSave: secretsProtected }))
 }
 
 async function handleNotifierTest(res: ServerResponse, agentName: string): Promise<void> {
@@ -1105,6 +1125,23 @@ async function handleNotifierTest(res: ServerResponse, agentName: string): Promi
   res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(await testAgentNotifier(entry.config, defaultWebhook)))
 }
 
+// Backs the console's Slack channel picker. A bot token typed into the form
+// (not saved yet) can be sent in the body; otherwise the saved one is used.
+async function handleSlackChannels(req: IncomingMessage, res: ServerResponse, agentName: string): Promise<void> {
+  const entry = getEntry(agentName)
+  if (!entry) {
+    res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `unknown agent '${agentName}'` }))
+    return
+  }
+  const body = await readJsonBody(req)
+  try {
+    const channels = await listAgentSlackChannels(entry.config, typeof body.botToken === 'string' ? body.botToken : undefined)
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ channels }))
+  } catch (err) {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
+  }
+}
+
 // Every approval/question still waiting for this agent — for an app that
 // can't receive webhooks (it polls this instead) and for the console.
 async function handlePendingGet(res: ServerResponse, agentName: string): Promise<void> {
@@ -2039,7 +2076,11 @@ async function createCheckpointFromPending(
  * response here is authoritative on its own, not a fallback for some
  * other channel. */
 async function handlePendingApprovalResolve(req: IncomingMessage, res: ServerResponse, pendingId: string): Promise<void> {
-  const body = await readJsonBody(req)
+  await resolvePendingApproval(res, pendingId, await readJsonBody(req))
+}
+
+// The resolve itself, shared with the decision page's POST /decide/<token>.
+async function resolvePendingApproval(res: ServerResponse, pendingId: string, body: Record<string, unknown>): Promise<void> {
   const decision = body.decision === 'approve' || body.decision === 'deny' ? body.decision : undefined
   if (!decision) {
     res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: "decision must be 'approve' or 'deny'" }))
@@ -2151,7 +2192,10 @@ async function handlePendingApprovalResolve(req: IncomingMessage, res: ServerRes
  * either answered or it isn't. Shares the same "outstanding empty →
  * resume, else report remaining count" tail via respondAfterResolution. */
 async function handlePendingQuestionAnswer(req: IncomingMessage, res: ServerResponse, pendingId: string): Promise<void> {
-  const body = await readJsonBody(req)
+  await answerPendingQuestion(res, pendingId, await readJsonBody(req))
+}
+
+async function answerPendingQuestion(res: ServerResponse, pendingId: string, body: Record<string, unknown>): Promise<void> {
   if (typeof body.answer !== 'string') {
     res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: "'answer' must be a string" }))
     return
@@ -2437,7 +2481,134 @@ function handleActivityGet(res: ServerResponse): void {
   )
 }
 
+// A decision link (loopengine's core/approval-links.ts): GET shows the decision page,
+// POST makes the decision. The signed token is the credential, so these
+// sit outside the admin login on purpose — the link is meant for
+// whoever gets the notification, not only admins.
+async function handleDecide(req: IncomingMessage, res: ServerResponse, rawToken: string): Promise<void> {
+  const html = { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', 'referrer-policy': 'no-referrer' }
+  const json = { 'content-type': 'application/json', 'cache-control': 'no-store' }
+  const token = verifyDecisionToken(rawToken)
+  if (!token) {
+    if (req.method === 'GET') res.writeHead(404, html).end(renderDecideInvalidPage())
+    else res.writeHead(400, json).end(JSON.stringify({ error: 'This link is not valid or has expired.' }))
+    return
+  }
+  const checkpoint = await checkpoints.get(token.pendingId)
+  const item = checkpoint?.outstanding[token.pendingId]
+  if (!checkpoint || !item || (item.kind ?? 'approval') !== token.kind) {
+    if (req.method === 'GET') res.writeHead(410, html).end(renderDecideGonePage())
+    else res.writeHead(410, json).end(JSON.stringify({ error: 'This decision has already been made.' }))
+    return
+  }
+  if (req.method === 'GET') {
+    res.writeHead(200, html).end(
+      renderDecidePage({
+        kind: token.kind,
+        agent: checkpoint.agent,
+        tool: item.tool,
+        args: item.args,
+        reason: item.reason,
+        sessionId: checkpoint.sessionId,
+        tenant: checkpoint.tenant,
+        createdAt: checkpoint.createdAt,
+        expiresAt: token.expiresAt,
+      }),
+    )
+    return
+  }
+  const body = await readJsonBody(req)
+  if (token.kind === 'question') await answerPendingQuestion(res, token.pendingId, { answer: body.answer })
+  else await resolvePendingApproval(res, token.pendingId, { decision: body.decision, editedArgs: body.editedArgs })
+}
+
+// Runs one of the resolve/answer handlers above without a real HTTP
+// response to write to — for the Slack endpoint below, which has already
+// answered Slack and reports the outcome back into the Slack message.
+function captureResponse(): { res: ServerResponse; done: Promise<{ status: number; body: Record<string, unknown> }> } {
+  let resolveDone: (value: { status: number; body: Record<string, unknown> }) => void
+  const done = new Promise<{ status: number; body: Record<string, unknown> }>((resolve) => (resolveDone = resolve))
+  let status = 200
+  const res = {
+    headersSent: false,
+    writeHead(code: number) {
+      status = code
+      return res
+    },
+    end(chunk?: string) {
+      let body: Record<string, unknown> = {}
+      try {
+        body = chunk ? (JSON.parse(chunk) as Record<string, unknown>) : {}
+      } catch {}
+      resolveDone({ status, body })
+      return res
+    },
+  }
+  return { res: res as unknown as ServerResponse, done }
+}
+
+// A Slack app's Interactivity Request URL (core/slack-interactions.ts):
+// Approve/Deny, an answer option, or the "Other…" modal, from a Slack
+// notifier's message. Outside the admin login on purpose — Slack can't
+// send it — and verified with that agent's Slack signing secret instead.
+// Slack wants an answer within three seconds, so the decision is acked
+// right away and its outcome posted back into the message afterwards.
+async function handleSlackInteraction(req: IncomingMessage, res: ServerResponse, agentName: string): Promise<void> {
+  const rawBody = await readRawBody(req)
+  const entry = getEntry(agentName)
+  const { botToken, signingSecret } = entry ? slackCredentialsFor(entry.config) : {}
+  if (!entry || !signingSecret) {
+    res.writeHead(404, { 'content-type': 'text/plain' }).end('No Slack signing secret is set for this agent.')
+    return
+  }
+  const timestamp = req.headers['x-slack-request-timestamp']
+  const signature = req.headers['x-slack-signature']
+  if (!verifySlackRequest(rawBody, typeof timestamp === 'string' ? timestamp : undefined, typeof signature === 'string' ? signature : undefined, signingSecret)) {
+    res.writeHead(401, { 'content-type': 'text/plain' }).end('Invalid Slack signature.')
+    return
+  }
+  const interaction = parseSlackInteraction(rawBody)
+  if (interaction.type === 'open_answer') {
+    if (botToken) await openSlackAnswerModal(botToken, interaction.triggerId, interaction.pendingId).catch((err) => console.error('[loopengine] Slack modal failed:', err))
+    res.writeHead(200).end()
+    return
+  }
+  res.writeHead(200).end()
+  if (interaction.type === 'ignore') return
+
+  const capture = captureResponse()
+  if (interaction.type === 'decide') await resolvePendingApproval(capture.res, interaction.pendingId, { decision: interaction.decision })
+  else await answerPendingQuestion(capture.res, interaction.pendingId, { answer: interaction.answer })
+  const outcome = await capture.done
+  if (interaction.responseUrl) {
+    const text = slackOutcomeText(interaction.type === 'decide' ? interaction.decision : 'answer', outcome.status, outcome.body, interaction.user)
+    await replyInSlack(interaction.responseUrl, text).catch((err) => console.error('[loopengine] Slack reply failed:', err))
+  }
+}
+
 const server = createServer(async (req, res) => {
+  const slackHookMatch = req.method === 'POST' && (req.url ?? '/').split('?')[0].match(/^\/hooks\/slack\/([^/]+)$/)
+  if (slackHookMatch) {
+    try {
+      await handleSlackInteraction(req, res, decodeURIComponent(slackHookMatch[1]))
+    } catch (err) {
+      console.error('[loopengine] Slack interaction failed:', err)
+      if (!res.headersSent) res.writeHead(500).end()
+    }
+    return
+  }
+
+  const decideMatch = (req.method === 'GET' || req.method === 'POST') && (req.url ?? '/').split('?')[0].match(/^\/decide\/([A-Za-z0-9_.-]+)$/)
+  if (decideMatch) {
+    try {
+      await handleDecide(req, res, decideMatch[1])
+    } catch (err) {
+      console.error('[loopengine] decision link failed:', err)
+      if (!res.headersSent) res.writeHead(500, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'Something went wrong; try again.' }))
+    }
+    return
+  }
+
   if (!isAuthorized(req)) {
     const headers: Record<string, string> = { 'content-type': 'application/json' }
     if (adminAuth) headers['www-authenticate'] = 'Basic realm="loopengine"'
@@ -2833,6 +3004,11 @@ const server = createServer(async (req, res) => {
       await handleNotifierTest(res, decodeURIComponent(notifierTestMatch[1]))
       return
     }
+    const slackChannelsMatch = req.method === 'POST' && pathname.match(/^\/agents\/([^/]+)\/notifier\/slack-channels$/)
+    if (slackChannelsMatch) {
+      await handleSlackChannels(req, res, decodeURIComponent(slackChannelsMatch[1]))
+      return
+    }
     const pendingListMatch = req.method === 'GET' && pathname.match(/^\/agents\/([^/]+)\/pending$/)
     if (pendingListMatch) {
       await handlePendingGet(res, decodeURIComponent(pendingListMatch[1]))

package/template/package.json

@@ -9,7 +9,7 @@
     "cli": "tsx adapters/cli.ts"
   },
   "dependencies": {
-    "loopengine": "^0.1.67",
+    "loopengine": "^0.1.69",
     "actauth": "^0.0.12"
   },
   "devDependencies": {