@jc_stack/ez-agents 0.1.0-beta.12 → 0.1.0-beta.18

package/src/host-executor.ts

@@ -1,3 +1,7 @@
+import { redactFailure } from './failure.js'
+import { RunStore } from './runs.js'
+import { Tasks } from './tasks.js'
+import { requireOwnerExecution } from './execution-authority.js'
 import { mkdir, readFile, writeFile, readdir, rename, rm, appendFile, realpath } from 'node:fs/promises'
 import path from 'node:path'
 import { isHostRunId } from './host-executor-protocol.js'
@@ -5,13 +9,14 @@ import { fileURLToPath } from 'node:url'
 import { startExecutorJob, terminateJob, resolveExecutor, type ExecutorOptions } from './executor.js'
 import { readModels, validateSelection } from './ai.js'
 import type { ChildProcess } from 'node:child_process'
+import { taskWorkspace } from './task-workspace.js'
 import { packageVersion } from './version.js'
 import { installedPluginVersions } from './software-status.js'
 
-export type HostBinding = { name: string; workspace: string; controlDir: string; binDir: string; toolsHome?: string }
+export type HostBinding = { name: string; workspace: string; controlDir: string; binDir: string; toolsHome?: string; sharedWorkspace?: string }
 export type HostInstallation = { cli: string; agents: HostBinding[] }
 
-export const serveHostExecutor = async (installation: HostInstallation, signal: AbortSignal) => {
+export const serveHostExecutor = async (installation: HostInstallation, signal: AbortSignal, launch = startExecutorJob) => {
   resolveExecutor(installation.cli)
   if (new Set(installation.agents.map(a=>a.workspace)).size !== installation.agents.length ||
       new Set(installation.agents.map(a=>a.controlDir)).size !== installation.agents.length)
@@ -20,9 +25,13 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
   const busy = new Set<string>()
   const tasks = new Set<Promise<void>>()
   const locks: string[] = []
+  const sharedWorkspaces = new Map<HostBinding, string>()
+  const catalog = (agent: HostBinding) => readModels(undefined, undefined, path.join(agent.controlDir, 'cli', 'codex'))
   try {
     for (const agent of installation.agents) {
       if (![agent.workspace,agent.controlDir,agent.binDir].every(path.isAbsolute)) throw new Error('Host bindings require absolute paths')
+      if (agent.sharedWorkspace && !path.isAbsolute(agent.sharedWorkspace)) throw new Error('Shared workspace requires an absolute path')
+      if (agent.sharedWorkspace) sharedWorkspaces.set(agent, await realpath(agent.sharedWorkspace))
       if (agent.toolsHome) {
         if (!path.isAbsolute(agent.toolsHome)) throw new Error('Plugin registry binding requires an absolute path')
         const config=JSON.parse(await readFile(path.join(agent.toolsHome,'config.json'),'utf8'))
@@ -35,7 +44,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
       catch(error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }
       await writeFile(lock,JSON.stringify({pid:process.pid}),{mode:0o600,flag:'wx'})
       locks.push(lock)
-      await writeFile(path.join(directory,'models.json'),JSON.stringify(await readModels()),{mode:0o600})
+      await writeFile(path.join(directory,'models.json'),JSON.stringify(await catalog(agent)),{mode:0o600})
       // A host crash is terminal for a claimed job. Never replay an action.
       for (const file of await readdir(directory)) if (file.endsWith('.running.json')) {
         const base=path.join(directory,file.slice(0,-13))
@@ -54,8 +63,8 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
       const parent=Number(process.env.EZ_HOST_SUPERVISOR_PID)
       if(parent) { try { process.kill(parent,0) } catch { break } }
       if(Date.now()-catalogAt>30000){
-        const models=JSON.stringify(await readModels())
         for(const agent of installation.agents){
+          const models=JSON.stringify(await catalog(agent))
           const file=path.join(agent.controlDir,'host-executor/models.json')
           await writeFile(file+'.tmp',models,{mode:0o600});await rename(file+'.tmp',file)
         }
@@ -66,10 +75,23 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
         await writeFile(path.join(directory,'heartbeat.tmp'),JSON.stringify({at:Date.now(),pid:process.pid,version:packageVersion,plugins:await installedPluginVersions(agent.toolsHome)}),{mode:0o600})
         await rename(path.join(directory,'heartbeat.tmp'),path.join(directory,'heartbeat.json'))
         for (const file of await readdir(directory)) {
-          if ((!file.endsWith('.request.json') || !isHostRunId(file.slice(0,-13))) || busy.has(agent.name)) continue
-          const base=path.join(directory,file.slice(0,-13))
+          if (!file.endsWith('.request.json') || !isHostRunId(file.slice(0,-13))) continue
+          const id=file.slice(0,-13)
+          let run
+          try {
+            run = await new RunStore(agent.controlDir).get(id)
+            if(id.startsWith('r_schedule_') && !run?.scheduled) throw new Error('Missing scheduled run')
+          } catch {
+            await appendFile(path.join(directory,id+'.events'),JSON.stringify({stream:'exit',code:1})+'\n',{mode:0o600})
+            await rm(path.join(directory,file))
+            continue
+          }
+          const sharedWorkspace=sharedWorkspaces.get(agent)
+          const lane=run?.replyOnly ? 'reply:'+agent.name : sharedWorkspace ? 'workspace:'+sharedWorkspace : run?.scheduled ? agent.name+':'+id : agent.name
+          if(busy.has(lane) || (run?.scheduled && [...busy].filter(k=>k.startsWith(agent.name+':')).length>=4)) continue
+          const base=path.join(directory,id)
           await rename(base+'.request.json',base+'.running.json')
-          busy.add(agent.name)
+          busy.add(lane)
           const task=(async()=>{
             let job: Awaited<ReturnType<typeof startExecutorJob>> | undefined
             let cancellation: ReturnType<typeof setInterval> | undefined
@@ -79,37 +101,44 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               try { await readFile(base+'.cancel'); throw new Error('Cancelled') } catch(error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }
               const request=JSON.parse(await readFile(base+'.running.json','utf8'))
               if (!Array.isArray(request.texts) || request.texts.some((text:unknown)=>typeof text!=='string')) throw new Error('Invalid job')
+              const run = await new RunStore(agent.controlDir).get(path.basename(base))
+              if (run?.taskId) {
+                if (run.status !== 'running') throw new Error('No active task run')
+                await new Tasks(agent.controlDir).authorize(run, false)
+              } else await requireOwnerExecution(agent.controlDir, path.basename(base))
               const opts=request.options as ExecutorOptions
               const cli = opts.cli || installation.cli
               resolveExecutor(cli)
-              if (cli !== installation.cli) await validateSelection({id:'selected',name:'Selected model',cli,model:opts.model,effort:opts.effort},await readModels())
-              const options:ExecutorOptions={workspace:agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,cli,
-                runId:path.basename(base),timeoutMs:Math.min(Math.max(Number(opts.timeoutMs)||300000,1000),1800000),
-                sessionId:opts.sessionId,isResume:opts.isResume,eventSource:opts.eventSource,model:opts.model,effort:opts.effort}
-              job=await startExecutorJob(request.texts,options)
-              active.set(agent.name,job.child)
+              if (cli !== installation.cli) await validateSelection({id:'selected',name:'Selected model',cli,model:opts.model,effort:opts.effort},await catalog(agent))
+              const options:ExecutorOptions={workspace:run?.scheduled ? await taskWorkspace(agent.workspace,id) : agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,sharedWorkspace,cli,
+                runId:path.basename(base),timeoutMs:0,repairEnabled:opts.repairEnabled,
+                sessionId:opts.sessionId,isResume:opts.isResume,eventSource:opts.eventSource,model:opts.model,effort:opts.effort,codexAutoCompactTokens:opts.codexAutoCompactTokens}
+              job=await launch(request.texts,options)
+              active.set(lane,job.child)
               await writeFile(base+'.process.json',JSON.stringify({pid:job.child.pid}),{mode:0o600})
               if(signal.aborted)terminateJob(job.child)
               job.child.stdout?.on('data',chunk=>emit({stream:'stdout',text:chunk.toString()}))
               job.child.stderr?.on('data',chunk=>emit({stream:'stderr',text:chunk.toString()}))
               cancellation=setInterval(()=>{void readFile(base+'.cancel').then(()=>terminateJob(job!.child)).catch(()=>{})},250)
               const code=await new Promise<number>(resolve=>job!.child.once('close',code=>resolve(code??1)))
+              if (cancellation) clearInterval(cancellation)
+              await job.cleanup()
+              job = undefined
               emit({stream:'exit',code})
-            } catch { emit({stream:'stderr',text:'Host CLI execution failed\n'}); emit({stream:'exit',code:1}) }
+            } catch (error) { emit({stream:'stderr',text:'Host CLI execution failed: '+redactFailure(error instanceof Error ? error.message : 'Unknown error')+'\n'}); emit({stream:'exit',code:1}) }
             finally {
               if(cancellation)clearInterval(cancellation)
-              await job?.cleanup()
+              await job?.cleanup().catch(() => {})
               await writes
               await rm(base+'.running.json',{force:true})
               await rm(base+'.process.json',{force:true})
               await rm(base+'.cancel',{force:true})
-              active.delete(agent.name)
-              busy.delete(agent.name)
+              active.delete(lane)
+              busy.delete(lane)
             }
           })()
           tasks.add(task); void task.finally(()=>tasks.delete(task))
-          // Do not claim a second job while asynchronous spawning is pending.
-          break
+          // The lane is reserved before spawning; other task workspaces may start.
         }
       }
       await new Promise(resolve=>setTimeout(resolve,250))

package/src/identity.ts

@@ -6,11 +6,16 @@ export const isOwner = (ctx: Pick<Context, 'from' | 'chat'>, owner: Owner | null
     owner &&
       ctx.from &&
       !ctx.from.is_bot &&
-      ctx.chat?.type === 'private' &&
-      ctx.from.id === owner.telegramUserId &&
-      ctx.chat.id === owner.telegramChatId,
+      (owner.kind === 'group'
+        ? ctx.chat?.type === 'group' || ctx.chat?.type === 'supergroup'
+        : ctx.chat?.type === 'private' && ctx.from.id === owner.telegramUserId) &&
+      ctx.chat?.id === owner.telegramChatId,
   )
 
+export const ownsRun = (owner: Owner | null, run: {telegramUserId: number; chatId: number}): boolean =>
+  Boolean(owner && Number.isSafeInteger(run.telegramUserId) && run.telegramUserId > 0 &&
+    run.chatId === owner.telegramChatId && (owner.kind === 'group' || run.telegramUserId === owner.telegramUserId))
+
 export const assertId = (id: string): string => {
   if (!/^[a-zA-Z0-9_-]+$/.test(id)) throw new Error('Invalid record identifier')
   return id

package/src/inbox.ts

@@ -2,9 +2,15 @@ import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import type { Update } from 'grammy/types'
 import { isExecutionChoice, type ExecutionChoice } from './ai.js'
+import { isOwner } from './identity.js'
+import type { Owner } from './control-state.js'
 
 export type IncomingItem = {
   text: string
+  attachment?: { path: string; type: string }
+  sentAt?: number
+  caption?: string
+  albumId?: string
   messageId?: number
   updateId: number
   chatId: number
@@ -96,11 +102,13 @@ export class InboxStore {
         this.now() - first.receivedAt < 30000
       )
         return
-      const boundary = state.waiting.findIndex((e) => JSON.stringify(e.execution) !== JSON.stringify(first.execution))
+      const chatId = (update: Update) => update.message?.chat.id ?? update.callback_query?.message?.chat.id
+      const boundary = state.waiting.findIndex((e) => JSON.stringify(e.execution) !== JSON.stringify(first.execution) || chatId(e.update) !== chatId(first.update))
       const entries = state.waiting.splice(0, boundary < 0 ? 10 : Math.min(10, boundary))
       // Telegram albums contain at most ten items. Don't split one at the batch boundary.
       const album = entries.at(-1)?.update.message?.media_group_id
       while (album && state.waiting[0]?.update.message?.media_group_id === album &&
+        chatId(state.waiting[0].update) === chatId(first.update) &&
         JSON.stringify(state.waiting[0].execution) === JSON.stringify(first.execution))
         entries.push(state.waiting.shift()!)
       const batch: InboxBatch = { id: `tg_${first.update.update_id}`, entries, status: 'pending' }
@@ -131,7 +139,7 @@ export class InboxStore {
     })
   }
 
-  retryLatest(userId: number, chatId: number): Promise<string | undefined> {
+  retryLatest(userId: number, chatId: number, owner?: Owner | null): Promise<string | undefined> {
     return this.change((state) => {
       const batch = [...state.batches].reverse().find(
         (b) =>
@@ -140,7 +148,7 @@ export class InboxStore {
             const message = e.update.message || e.update.callback_query?.message
             const from = e.update.message?.from || e.update.callback_query?.from
             return (
-              from?.id === userId &&
+              owner?.kind === 'group' ? !e.update.message?.sender_chat && isOwner({from, chat: message?.chat}, owner) : from?.id === userId &&
               !from.is_bot &&
               message?.chat.type === 'private' &&
               message.chat.id === chatId