create-loopengine 0.1.65 → 0.1.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "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

@@ -125,6 +125,13 @@ import {
   listAgentSlackChannels,
   slackCredentialsFor,
   slackConversationsOn,
+  slackClickAllowed,
+  agentApprovers,
+  setAgentApprovers,
+  listAgentSlackMembers,
+  replyPrivatelyInSlack,
+  type MessagingDecision,
+  type DecisionOutcome,
   openSlackAnswerModal,
   parseSlackInteraction,
   replyInSlack,
@@ -1256,6 +1263,44 @@ async function handleSlackChannels(req: IncomingMessage, res: ServerResponse, ag
   }
 }
 
+// Messaging tab → Approvers: who can decide this agent's Slack requests
+// by replying (core/messaging/), and the people in its channel to pick
+// from. Changing the list needs the admin login, like saving a secret:
+// it decides who can approve what the agent does.
+async function handleApproversPut(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
+  }
+  if (!secretsProtected) {
+    res.writeHead(403, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'Changing approvers needs LOOPENGINE_ADMIN_AUTH set on the server.' }))
+    return
+  }
+  const body = await readJsonBody(req)
+  try {
+    const approvers = setAgentApprovers(entry.config, body.approvers)
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ approvers }))
+  } catch (err) {
+    const status = err instanceof NotifierFileError ? 400 : 500
+    res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
+  }
+}
+
+async function handleSlackMembers(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
+  }
+  try {
+    const members = await listAgentSlackMembers(entry.config)
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ members }))
+  } 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> {
@@ -2709,6 +2754,17 @@ async function handleSlackInteraction(req: IncomingMessage, res: ServerResponse,
     return
   }
   const interaction = parseSlackInteraction(rawBody)
+  // Once the agent has approvers (Messaging tab), only their clicks count.
+  if (interaction.type !== 'ignore') {
+    const gate = slackClickAllowed(entry.config, interaction.user)
+    if (!gate.allowed) {
+      res.writeHead(200).end()
+      if ('responseUrl' in interaction && interaction.responseUrl) {
+        await replyPrivatelyInSlack(interaction.responseUrl, gate.message ?? 'Only approvers can decide this.').catch((err) => console.error('[loopengine] Slack reply failed:', err))
+      }
+      return
+    }
+  }
   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()
@@ -2770,9 +2826,26 @@ async function handleSlackEvents(req: IncomingMessage, res: ServerResponse, agen
     getCheckpoint: (pendingId) => checkpoints.get(pendingId),
     getHistory: (checkpoint) => sessions.getHistory(`${checkpoint.tenant}:${environment}:${checkpoint.agent}:${checkpoint.sessionId}`),
     plan: process.env.LOOPENGINE_PLAN,
+    approvers: () => agentApprovers(entry.config),
+    decide: decideFromMessaging,
   })
 }
 
+// A decision made by replying in a request's thread (core/messaging/),
+// recorded through the same resolve and answer handlers as the console's
+// buttons.
+async function decideFromMessaging(pendingId: string, decision: MessagingDecision): Promise<DecisionOutcome> {
+  const capture = captureResponse()
+  if (decision.kind === 'answer') await answerPendingQuestion(capture.res, pendingId, { answer: decision.answer })
+  else await resolvePendingApproval(capture.res, pendingId, { decision: decision.kind })
+  const { status, body } = await capture.done
+  if (status >= 400) return { error: typeof body.error === 'string' ? body.error : `HTTP ${status}` }
+  if (body.alreadyResolved) return { alreadyResolved: true }
+  if (body.resolved) return { stillWaiting: true }
+  if (Array.isArray(body.pending) && body.pending.length) return { morePending: true }
+  return { text: typeof body.text === 'string' ? body.text : undefined }
+}
+
 // Set once shutdown() starts, so /healthz turns 503 while the server
 // drains and a router or load balancer stops sending it new requests.
 let shuttingDown = false
@@ -3098,7 +3171,11 @@ const server = createServer(async (req, res) => {
     // The Settings section's Upgrade button (web/upgrade-admin.ts).
     if (req.method === 'GET' && pathname === '/config/upgrade') {
       res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' }).end(
-        JSON.stringify({ ...(await describeUpgrade()), canUpgrade: secretsProtected, restartsItself: exitOnCodeChange }),
+        JSON.stringify({
+          ...(await describeUpgrade(undefined, { refresh: new URL(req.url ?? '/', 'http://localhost').searchParams.get('refresh') === '1' })),
+          canUpgrade: secretsProtected,
+          restartsItself: exitOnCodeChange,
+        }),
       )
       return
     }
@@ -3323,6 +3400,16 @@ const server = createServer(async (req, res) => {
       return
     }
 
+    const approversMatch = req.method === 'PUT' && pathname.match(/^\/agents\/([^/]+)\/notifier\/approvers$/)
+    if (approversMatch) {
+      await handleApproversPut(req, res, decodeURIComponent(approversMatch[1]))
+      return
+    }
+    const slackMembersMatch = req.method === 'GET' && pathname.match(/^\/agents\/([^/]+)\/notifier\/slack-members$/)
+    if (slackMembersMatch) {
+      await handleSlackMembers(res, decodeURIComponent(slackMembersMatch[1]))
+      return
+    }
     const slackChannelsMatch = req.method === 'POST' && pathname.match(/^\/agents\/([^/]+)\/notifier\/slack-channels$/)
     if (slackChannelsMatch) {
       await handleSlackChannels(req, res, decodeURIComponent(slackChannelsMatch[1]))

package/template/package.json

@@ -9,7 +9,7 @@
     "cli": "tsx adapters/cli.ts"
   },
   "dependencies": {
-    "loopengine": "^0.1.81",
+    "loopengine": "^0.1.83",
     "actauth": "^0.0.12",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0"