create-loopengine 0.1.48 → 0.1.50

package/package.json

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

@@ -94,6 +94,12 @@ import {
   listDeclaredEnvVars,
   setEnvVar,
   unsetEnvVar,
+  setAgentEnvVar,
+  unsetAgentEnvVar,
+  createAgentEnv,
+  agentDirFor,
+  verifyProxyIdentity,
+  TRUSTED_PROXY_IDENTITY_HEADER,
   EnvVarNameError,
   readActauthConfig,
   addActauthRule,
@@ -1024,6 +1030,14 @@ function handleEnvGet(res: ServerResponse, agentName: string): void {
   res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(listDeclaredEnvVars(agentName)))
 }
 
+// `?slot=agent` targets this agent's own agents/<name>/.env (a per-agent
+// value, read by its tools through ToolContext.env) instead of the
+// project-wide .env — see loopengine's DeclaredEnvVar.slot.
+function envSlotOf(req: IncomingMessage): 'shared' | 'agent' | undefined {
+  const slot = new URL(req.url ?? '/', 'http://localhost').searchParams.get('slot') ?? 'shared'
+  return slot === 'shared' || slot === 'agent' ? slot : undefined
+}
+
 // Writes a raw secret value into .env — meaningfully more sensitive than
 // the rest of the admin surface (config/business data vs. an actual
 // credential), so unlike every other route here, this one refuses
@@ -1033,7 +1047,7 @@ function handleEnvGet(res: ServerResponse, agentName: string): void {
 // Admin UI" — LOOPENGINE_ADMIN_AUTH being optional today is an
 // acceptable gap for config, not for secrets).
 async function handleEnvPut(req: IncomingMessage, res: ServerResponse, agentName: string, varName: string): Promise<void> {
-  if (!adminAuth) {
+  if (!secretsProtected) {
     res.writeHead(403, { 'content-type': 'application/json' }).end(
       JSON.stringify({ error: 'Refusing to set an env var without LOOPENGINE_ADMIN_AUTH configured — set it before managing secrets through this route.' }),
     )
@@ -1043,16 +1057,31 @@ async function handleEnvPut(req: IncomingMessage, res: ServerResponse, agentName
     res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `unknown agent '${agentName}'` }))
     return
   }
+  const slot = envSlotOf(req)
+  if (!slot) {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: "slot must be 'shared' or 'agent'" }))
+    return
+  }
   const body = await readJsonBody(req)
   if (typeof body.value !== 'string') {
     res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'value is required' }))
     return
   }
+  const declaredRows = listDeclaredEnvVars(agentName).filter((v) => v.name === varName)
+  // A shared value for an agent-scoped var would never be read
+  // (loopengine's createAgentEnv never falls back for one) — refuse it
+  // rather than accept a write that silently does nothing.
+  if (slot === 'shared' && declaredRows.some((v) => v.scope === 'agent')) {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(
+      JSON.stringify({ error: `${varName} is declared scope 'agent' — set it per agent (slot=agent), not project-wide.` }),
+    )
+    return
+  }
   // A dropdown-backed var (AbilityEnvDecl.options) is still writable
   // through this same raw route — worth rejecting an out-of-set value
   // here too, not just skipping validation because the Admin UI's own
   // <select> would never have produced one.
-  const declared = listDeclaredEnvVars(agentName).find((v) => v.name === varName)
+  const declared = declaredRows.find((v) => v.slot === slot) ?? declaredRows[0]
   if (declared?.options && !declared.options.includes(body.value)) {
     res.writeHead(400, { 'content-type': 'application/json' }).end(
       JSON.stringify({ error: `"${body.value}" isn't one of this var's allowed values: ${declared.options.join(', ')}` }),
@@ -1060,7 +1089,8 @@ async function handleEnvPut(req: IncomingMessage, res: ServerResponse, agentName
     return
   }
   try {
-    setEnvVar(varName, body.value)
+    if (slot === 'agent') await setAgentEnvVar(agentName, varName, body.value)
+    else await setEnvVar(varName, body.value)
   } catch (err) {
     const status = err instanceof EnvVarNameError ? 400 : 500
     res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
@@ -1073,8 +1103,8 @@ async function handleEnvPut(req: IncomingMessage, res: ServerResponse, agentName
 // removing a secret from .env is still a secrets-management action,
 // not just config, so this refuses outright rather than proceeding
 // open when LOOPENGINE_ADMIN_AUTH isn't configured at all.
-async function handleEnvDelete(res: ServerResponse, agentName: string, varName: string): Promise<void> {
-  if (!adminAuth) {
+async function handleEnvDelete(req: IncomingMessage, res: ServerResponse, agentName: string, varName: string): Promise<void> {
+  if (!secretsProtected) {
     res.writeHead(403, { 'content-type': 'application/json' }).end(
       JSON.stringify({ error: 'Refusing to unset an env var without LOOPENGINE_ADMIN_AUTH configured — set it before managing secrets through this route.' }),
     )
@@ -1084,8 +1114,14 @@ async function handleEnvDelete(res: ServerResponse, agentName: string, varName:
     res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `unknown agent '${agentName}'` }))
     return
   }
+  const slot = envSlotOf(req)
+  if (!slot) {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: "slot must be 'shared' or 'agent'" }))
+    return
+  }
   try {
-    unsetEnvVar(varName)
+    if (slot === 'agent') await unsetAgentEnvVar(agentName, varName)
+    else await unsetEnvVar(varName)
   } catch (err) {
     const status = err instanceof EnvVarNameError ? 400 : 500
     res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
@@ -1168,7 +1204,7 @@ async function handleAbilitiesSearchGet(res: ServerResponse, agentName: string,
 // LOOPENGINE_ADMIN_AUTH isn't configured at all, rather than proceeding
 // open like most routes here do.
 async function handleAbilityInstallPost(req: IncomingMessage, res: ServerResponse, agentName: string): Promise<void> {
-  if (!adminAuth) {
+  if (!secretsProtected) {
     res.writeHead(403, { 'content-type': 'application/json' }).end(
       JSON.stringify({ error: 'Refusing to install an ability without LOOPENGINE_ADMIN_AUTH configured — set it before installing abilities through this route.' }),
     )
@@ -1203,7 +1239,7 @@ async function handleAbilityInstallPost(req: IncomingMessage, res: ServerRespons
 // third-party code inside the agent's project the next time it's
 // loaded, same as install does.
 async function handleAbilityUpgradePost(req: IncomingMessage, res: ServerResponse, agentName: string, abilityName: string): Promise<void> {
-  if (!adminAuth) {
+  if (!secretsProtected) {
     res.writeHead(403, { 'content-type': 'application/json' }).end(
       JSON.stringify({ error: 'Refusing to upgrade an ability without LOOPENGINE_ADMIN_AUTH configured — set it before upgrading abilities through this route.' }),
     )
@@ -1238,7 +1274,7 @@ async function handleAbilityUpgradePost(req: IncomingMessage, res: ServerRespons
 // behavior, is a normal partial outcome the Admin UI shows and offers
 // to retry with force, not a failure).
 async function handleAbilityUninstallDelete(res: ServerResponse, agentName: string, abilityName: string, force: boolean): Promise<void> {
-  if (!adminAuth) {
+  if (!secretsProtected) {
     res.writeHead(403, { 'content-type': 'application/json' }).end(
       JSON.stringify({ error: 'Refusing to uninstall an ability without LOOPENGINE_ADMIN_AUTH configured — set it before uninstalling abilities through this route.' }),
     )
@@ -1280,7 +1316,7 @@ const NPM_INSTALL_DEPS_TIMEOUT_MS = 180_000
 // package.json happened to declare, not something to trust for shell
 // interpolation.
 async function handleAbilityInstallDepsPost(req: IncomingMessage, res: ServerResponse, agentName: string, abilityName: string): Promise<void> {
-  if (!adminAuth) {
+  if (!secretsProtected) {
     res.writeHead(403, { 'content-type': 'application/json' }).end(
       JSON.stringify({ error: 'Refusing to run npm install without LOOPENGINE_ADMIN_AUTH configured — set it before installing dependencies through this route.' }),
     )
@@ -1694,6 +1730,8 @@ async function handleMessagesStream(req: IncomingMessage, res: ServerResponse, a
   }
   const { entry, message, rawSessionId, storageSessionId, tenant } = parsed.value
 
+  openStreams++
+  res.on('close', () => openStreams--)
   res.writeHead(200, {
     'content-type': 'text/event-stream',
     'cache-control': 'no-cache',
@@ -1797,7 +1835,15 @@ async function handleMessagesStream(req: IncomingMessage, res: ServerResponse, a
 // default. A real deployment opts in by setting it; either way, a
 // startup warning makes "I forgot to set this" loud instead of silent.
 const adminAuth = process.env.LOOPENGINE_ADMIN_AUTH
-if (!adminAuth) {
+// Hosted mode (see loopengine's core/trusted-proxy.ts): every request
+// must carry an X-LoopEngine-Identity header signed with this secret by
+// the router in front of this server. Unset (the default, and every
+// self-hosted install) means this file behaves exactly as it always has.
+const trustedProxySecret = process.env.LOOPENGINE_TRUSTED_PROXY_SECRET
+// Routes that write secrets or install code refuse to run on a server
+// with no auth at all — either form of auth counts.
+const secretsProtected = Boolean(adminAuth || trustedProxySecret)
+if (!adminAuth && !trustedProxySecret) {
   console.warn(
     '[loopengine] LOOPENGINE_ADMIN_AUTH is not set — every route on this server (including tool-call approvals, conversation history, and permission rules) is open to anyone who can reach it. Set LOOPENGINE_ADMIN_AUTH="user:pass" to require HTTP Basic Auth.',
   )
@@ -1810,7 +1856,12 @@ if (!adminAuth) {
 // first; a length mismatch isn't sensitive information worth spending a
 // constant-time comparison to protect.
 function isAuthorized(req: IncomingMessage): boolean {
-  if (!adminAuth) return true
+  if (trustedProxySecret && verifyProxyIdentity(req.headers[TRUSTED_PROXY_IDENTITY_HEADER], trustedProxySecret)) return true
+  // Basic Auth still works alongside trusted-proxy mode (direct operator
+  // access to one workspace) — but with neither form of credentials, a
+  // trusted-proxy server is closed, never open the way a server with no
+  // auth configured at all is.
+  if (!adminAuth) return !trustedProxySecret
   const header = req.headers.authorization
   if (!header || !header.startsWith('Basic ')) return false
   const provided = Buffer.from(header.slice('Basic '.length), 'base64')
@@ -1927,7 +1978,12 @@ async function handlePendingApprovalResolve(req: IncomingMessage, res: ServerRes
           return { checkpoint, result: { kind: 'validation-error', error: validationError } }
         }
         try {
-          const output = await tool.execute(editedArgs ?? item.args)
+          const output = await tool.execute(editedArgs ?? item.args, {
+            agentName: entry.config.name,
+            tenant: checkpoint.tenant,
+            sessionId: checkpoint.sessionId,
+            env: createAgentEnv(entry.config.name, agentDirFor(entry.config)),
+          })
           resultBlock = { type: 'tool_result', tool_use_id: item.toolUseId, content: JSON.stringify(output), is_error: false }
         } catch (err) {
           resultBlock = { type: 'tool_result', tool_use_id: item.toolUseId, content: `ERROR: ${err}`, is_error: true }
@@ -2245,11 +2301,43 @@ async function handleLocalFile(req: IncomingMessage, res: ServerResponse): Promi
   createReadStream(resolved).pipe(res)
 }
 
+// Opt-in (LOOPENGINE_EXIT_ON_CODE_CHANGE=1): Node caches an imported
+// module, so a tool file an ability install/upgrade/uninstall just wrote
+// isn't picked up until the process restarts. Under a supervisor that
+// restarts it (a hosting platform, Docker's restart policy, systemd),
+// exiting cleanly right after the change is the simplest way to apply
+// it. Off by default — a plain `loopengine serve` has nothing to restart
+// it, so exiting there would just take the server down.
+const exitOnCodeChange = process.env.LOOPENGINE_EXIT_ON_CODE_CHANGE === '1'
+function exitIfCodeChanged(res: ServerResponse): void {
+  if (!exitOnCodeChange || res.statusCode >= 300) return
+  console.log('[loopengine] ability code changed — exiting so the supervisor restarts this server with it loaded')
+  // shutdown() drains in-flight requests (this one's response included)
+  // before exiting.
+  setImmediate(() => void shutdown())
+}
+
+// Backs GET /internal/activity (trusted-proxy mode only) — what a host
+// checks before stopping an idle server, so it never stops one mid-turn.
+let openStreams = 0
+let lastRequestAt = Date.now()
+
+function handleActivityGet(res: ServerResponse): void {
+  res.writeHead(200, { 'content-type': 'application/json' }).end(
+    JSON.stringify({
+      inFlightTurns: sessionTurns.size,
+      openStreams,
+      lastRequestAt: new Date(lastRequestAt).toISOString(),
+      idleSeconds: Math.floor((Date.now() - lastRequestAt) / 1000),
+    }),
+  )
+}
+
 const server = createServer(async (req, res) => {
   if (!isAuthorized(req)) {
-    res
-      .writeHead(401, { 'content-type': 'application/json', 'www-authenticate': 'Basic realm="loopengine"' })
-      .end(JSON.stringify({ error: 'authorization required' }))
+    const headers: Record<string, string> = { 'content-type': 'application/json' }
+    if (adminAuth) headers['www-authenticate'] = 'Basic realm="loopengine"'
+    res.writeHead(401, headers).end(JSON.stringify({ error: 'authorization required' }))
     return
   }
 
@@ -2269,6 +2357,14 @@ const server = createServer(async (req, res) => {
     // route individually.
     const pathname = (req.url ?? '/').split('?')[0]
 
+    // Only exists in trusted-proxy mode, and polling it doesn't count as
+    // activity itself.
+    if (trustedProxySecret && req.method === 'GET' && pathname === '/internal/activity') {
+      handleActivityGet(res)
+      return
+    }
+    lastRequestAt = Date.now()
+
     const streamMatch = req.method === 'POST' && pathname.match(/^\/agents\/([^/]+)\/messages\/stream$/)
     if (streamMatch) {
       await handleMessagesStream(req, res, decodeURIComponent(streamMatch[1]))
@@ -2626,7 +2722,7 @@ const server = createServer(async (req, res) => {
       return
     }
     if (envVarMatch && req.method === 'DELETE') {
-      await handleEnvDelete(res, decodeURIComponent(envVarMatch[1]), decodeURIComponent(envVarMatch[2]))
+      await handleEnvDelete(req, res, decodeURIComponent(envVarMatch[1]), decodeURIComponent(envVarMatch[2]))
       return
     }
 
@@ -2646,17 +2742,20 @@ const server = createServer(async (req, res) => {
     const abilityUpgradeMatch = pathname.match(/^\/agents\/([^/]+)\/abilities\/([^/]+)\/upgrade$/)
     if (abilityUpgradeMatch && req.method === 'POST') {
       await handleAbilityUpgradePost(req, res, decodeURIComponent(abilityUpgradeMatch[1]), decodeURIComponent(abilityUpgradeMatch[2]))
+      exitIfCodeChanged(res)
       return
     }
     const abilityInstallDepsMatch = pathname.match(/^\/agents\/([^/]+)\/abilities\/([^/]+)\/install-deps$/)
     if (abilityInstallDepsMatch && req.method === 'POST') {
       await handleAbilityInstallDepsPost(req, res, decodeURIComponent(abilityInstallDepsMatch[1]), decodeURIComponent(abilityInstallDepsMatch[2]))
+      exitIfCodeChanged(res)
       return
     }
     const abilityMatch = pathname.match(/^\/agents\/([^/]+)\/abilities\/([^/]+)$/)
     if (abilityMatch && req.method === 'DELETE') {
       const force = new URL(req.url ?? '/', 'http://localhost').searchParams.get('force') === 'true'
       await handleAbilityUninstallDelete(res, decodeURIComponent(abilityMatch[1]), decodeURIComponent(abilityMatch[2]), force)
+      exitIfCodeChanged(res)
       return
     }
     const abilitiesMatch = pathname.match(/^\/agents\/([^/]+)\/abilities$/)
@@ -2666,6 +2765,7 @@ const server = createServer(async (req, res) => {
     }
     if (abilitiesMatch && req.method === 'POST') {
       await handleAbilityInstallPost(req, res, decodeURIComponent(abilitiesMatch[1]))
+      exitIfCodeChanged(res)
       return
     }
 

package/template/package.json

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