feat(work): stage authenticated remote approvals with scoped execution fencing

This commit is contained in:
ex_tianzy
2026-11-17 11:43:33 +08:00
parent d2881b82b0
commit c80c6a0d27
19 changed files with 1586 additions and 25 deletions
+103
View File
@@ -0,0 +1,103 @@
"""Opt-in device-authenticated approval API, with no business execution route."""
import asyncio
from fastapi import APIRouter,HTTPException,Request
from fastapi.responses import JSONResponse
from pydantic import Field
from .approval_callback import ApprovalCallbackVerifier,decision_toast
from .approval_cards import ApprovalCardSender
from .approval_policy import describe_action
from .approval_store import ApprovalError
from .common import no_cache,require_secret
from .task_delivery import TaskRequest
class CreateApproval(TaskRequest):
operation_id:str=Field(pattern=r'^[A-Za-z0-9_-]{8,100}$')
action:dict=Field(repr=False)
ttl:int=Field(default=120,strict=True,ge=30,le=600)
class ApprovalReference(TaskRequest):
approval_id:str=Field(pattern=r'^apr_[a-f0-9]{64}$')
operation_digest:str=Field(pattern=r'^[a-f0-9]{64}$')
class ApprovalAPI:
def __init__(self,auth,worker,platform,spawn):
self.auth,self.worker,self.spawn=auth,worker,spawn
self.sender=ApprovalCardSender(worker,platform)
self.scheduled=set()
s=auth.s
self.verifier=ApprovalCallbackVerifier(environment=s.environment,app_id=s.feishu_app_id,
tenant_key=s.feishu_tenant_key,verification_token=s.feishu_verification_token,
internal_secret=s.internal_secret,encrypt_key=s.feishu_encrypt_key)
self.router=APIRouter()
for name in ('create','status','consume','cancel'):
self.router.add_api_route('/work/v2/approvals/'+name,getattr(self,name),methods=['POST'])
self.router.add_api_route('/internal/approval-callback',self.callback,methods=['POST'])
async def _call(self,method,*args):
try:return await self.worker.call(method,*args)
except ApprovalError:
raise HTTPException(409,'approval_unavailable_or_unconfirmed')from None
def _schedule(self,kind,approval_id):
key=(kind,approval_id)
if key in self.scheduled or len(self.scheduled)>=32:return
self.scheduled.add(key)
async def deliver():
try:
if kind=='send':await self.sender.send(approval_id)
else:await self.sender.update_closed(approval_id)
finally:self.scheduled.discard(key)
self.spawn(deliver())
async def create(self,body:CreateApproval,request:Request):
await self.auth.authenticate(body,request)
try:summary,impact=describe_action(body.action)
except (ApprovalError,TypeError,ValueError,RecursionError):
raise HTTPException(400,'unsupported_approval_action')from None
result=await self._call('create',body.task_id,body.binding_owner,body.host_id,
body.binding_generation,body.operation_id,body.action,summary,impact,body.ttl)
self._schedule('send',result['approval_id'])
return no_cache(JSONResponse(result))
async def _reference(self,method,body,request):
await self.auth.authenticate(body,request)
args=(body.approval_id,body.task_id,body.binding_owner,body.host_id,body.binding_generation)
# Cancel requires the same request digest too, not just visibility of an ID.
if method=='cancel':
await self._call('status',*args,body.operation_digest)
result=await self._call('cancel',*args)
else:result=await self._call(method,*args,body.operation_digest)
if method in {'consume','cancel'}:self._schedule('close',body.approval_id)
return no_cache(JSONResponse(result))
async def status(self,body:ApprovalReference,request:Request):
return await self._reference('status',body,request)
async def consume(self,body:ApprovalReference,request:Request):
return await self._reference('consume',body,request)
async def cancel(self,body:ApprovalReference,request:Request):
return await self._reference('cancel',body,request)
async def callback(self,request:Request):
if self.auth.s.feishu_event_source!='longconn':raise HTTPException(404,'not_found')
supplied=request.headers.get('X-Internal-Secret','')
require_secret(supplied,self.auth.s.internal_secret)
try:
raw=await asyncio.wait_for(request.body(),timeout=.2)
decision=self.verifier.from_sdk_channel(raw,supplied)
result=await self.worker.call('decide',decision)
except (ApprovalError,asyncio.TimeoutError):
return no_cache(JSONResponse({'toast':{'type':'warning',
'content':'确认未完成或结果待核对,请查看原任务状态,勿重复发起操作。'}}))
self._schedule('close',decision.approval_id)
return no_cache(JSONResponse(decision_toast(result)))
async def maintain(self):
await self.worker.call('close_unavailable')
for approval_id in await self.worker.call('cards_to_send'):self._schedule('send',approval_id)
for approval_id in await self.worker.call('cards_to_close'):self._schedule('close',approval_id)
+153
View File
@@ -0,0 +1,153 @@
"""C2 callback verifier; HTTP registration is opt-in in approval_api.
Only the SDK worker's authenticated internal channel or a signed platform
webhook may enter here. action.value is a reference, never actor identity.
"""
import base64
import hashlib
import hmac
import json
import re
import time
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from .approval_store import ApprovalError, VerifiedDecision
from .crypto import canonical
class CallbackError(ApprovalError):
pass
def _pairs(pairs):
result = {}
for key, value in pairs:
if key in result:
raise CallbackError('ambiguous_callback')
result[key] = value
return result
def _json(raw):
if not isinstance(raw, bytes) or not 0 < len(raw) <= 65536:
raise CallbackError('invalid_callback_budget')
try:
data = json.loads(raw, object_pairs_hook=_pairs,
parse_constant=lambda _: (_ for _ in ()).throw(ValueError()))
if not isinstance(data, dict):
raise ValueError()
return data
except (ValueError, RecursionError, UnicodeError):
raise CallbackError('invalid_callback_json') from None
def _text(value, pattern=r'[A-Za-z0-9_-]{1,128}'):
if not isinstance(value, str) or not re.fullmatch(pattern, value):
raise CallbackError('invalid_callback_field')
return value
def _equal_secret(actual, expected):
return (isinstance(actual, str) and isinstance(expected, str) and bool(expected)
and hmac.compare_digest(actual.encode(), expected.encode()))
class ApprovalCallbackVerifier:
def __init__(self, *, environment, app_id, tenant_key, verification_token,
internal_secret='', encrypt_key='', clock=time.time):
self.environment = _text(environment)
self.app_id = _text(app_id)
self.tenant_key = _text(tenant_key)
if not isinstance(verification_token, str) or not verification_token:
raise CallbackError('callback_verifier_not_configured')
self.verification_token = verification_token
self.internal_secret = internal_secret
self.encrypt_key = encrypt_key
self.clock = clock
def from_sdk_channel(self, raw, supplied_secret):
"""Future internal handler only; never expose as an unauthenticated API.
Caller must enforce selected event source, a bounded body and the
private network boundary. The secret is not read from callback JSON.
"""
if len(self.internal_secret) < 32 or not _equal_secret(supplied_secret, self.internal_secret):
raise CallbackError('unauthenticated_callback_channel')
return self._decision(_json(raw))
def from_webhook(self, raw, *, timestamp, nonce, signature):
"""Verify the original bytes before decrypting. No token-only fallback."""
if not self.encrypt_key:
raise CallbackError('callback_verifier_not_configured')
_text(timestamp, r'[0-9]{1,12}')
_text(nonce)
_text(signature, r'[a-f0-9]{64}')
if abs(self.clock() - int(timestamp)) > 300:
raise CallbackError('stale_callback')
if not isinstance(raw, bytes) or not 0 < len(raw) <= 65536:
raise CallbackError('invalid_callback_budget')
expected = hashlib.sha256((timestamp + nonce + self.encrypt_key).encode() + raw).hexdigest()
if not hmac.compare_digest(expected, signature):
raise CallbackError('unauthenticated_callback_channel')
envelope = _json(raw)
try:
if set(envelope) != {'encrypt'} or not isinstance(envelope['encrypt'], str):
raise ValueError()
ciphertext = base64.b64decode(envelope['encrypt'], validate=True)
if len(ciphertext) < 32 or len(ciphertext) % 16:
raise ValueError()
decryptor = Cipher(algorithms.AES(hashlib.sha256(self.encrypt_key.encode()).digest()),
modes.CBC(ciphertext[:16])).decryptor()
padded = decryptor.update(ciphertext[16:]) + decryptor.finalize()
unpadder = padding.PKCS7(128).unpadder()
plaintext = unpadder.update(padded) + unpadder.finalize()
except (ValueError, TypeError):
raise CallbackError('invalid_callback_ciphertext') from None
return self._decision(_json(plaintext))
def _decision(self, data):
header, event = data.get('header'), data.get('event')
if data.get('schema') != '2.0' or not isinstance(header, dict) or not isinstance(event, dict):
raise CallbackError('unsupported_callback')
if (header.get('event_type') != 'card.action.trigger'
or header.get('app_id') != self.app_id
or header.get('tenant_key') != self.tenant_key
or not _equal_secret(header.get('token'), self.verification_token)):
raise CallbackError('callback_application_conflict')
event_id = _text(header.get('event_id'))
created = _text(header.get('create_time'), r'[0-9]{1,20}')
if abs(self.clock() - int(created) / 1000000) > 300:
raise CallbackError('stale_callback')
operator, context, action = event.get('operator'), event.get('context'), event.get('action')
if not all(isinstance(item, dict) for item in (operator, context, action)):
raise CallbackError('invalid_callback_context')
if (event.get('host') != 'im_message' or action.get('tag') != 'button'
or operator.get('tenant_key') != self.tenant_key):
raise CallbackError('unsupported_callback_context')
value = action.get('value')
if isinstance(value, str):
value = _json(value.encode())
if not isinstance(value, dict) or set(value) != {'kind', 'approval_id', 'nonce', 'choice'}:
raise CallbackError('invalid_approval_reference')
if value['kind'] != 'hainuo.approval.v1' or value['choice'] not in ('allow', 'deny'):
raise CallbackError('invalid_approval_choice')
fields = dict(environment=self.environment, app_id=self.app_id,
actor_open_id=_text(operator.get('open_id'), r'ou_[A-Za-z0-9_-]{1,120}'),
chat_id=_text(context.get('open_chat_id'), r'oc_[A-Za-z0-9_-]{1,120}'),
card_message_id=_text(context.get('open_message_id'), r'om_[A-Za-z0-9_-]{1,120}'),
approval_id=_text(value['approval_id'], r'apr_[a-f0-9]{64}'),
nonce=_text(value['nonce'], r'[A-Za-z0-9_-]{43}'), choice=value['choice'])
# No token, raw callback or user text is persisted in the receipt.
digest = hashlib.sha256(canonical(fields)).hexdigest()
return VerifiedDecision(**fields, event_id=event_id, event_digest=digest)
def decision_toast(status):
"""Bounded platform response; never starts a task or executes an action."""
state = status.get('state') if isinstance(status, dict) else None
messages = {'approved': '已允许本次操作,等待客户端继续。',
'rejected': '已拒绝本次操作。', 'expired': '确认已过期,请重新发起。',
'consumed': '本次确认已使用,请勿重复操作。', 'cancelled': '本次操作已取消。'}
return {'toast': {'type': 'info', 'content': messages.get(state, '确认未完成,请核对任务状态。')}}
+81
View File
@@ -0,0 +1,81 @@
"""C2 approval presentation and delivery through the dedicated DB worker."""
import asyncio
import hashlib
import math
import re
import time
from .approval_store import ApprovalError, _public_text
def approval_card(material, clock=time.time):
reference, nonce = material.get('approval_id'), material.get('nonce')
if (not isinstance(reference, str) or not re.fullmatch(r'apr_[a-f0-9]{64}', reference)
or not isinstance(nonce, str) or not re.fullmatch(r'[A-Za-z0-9_-]{43}', nonce)):
raise ApprovalError('invalid_approval_reference')
summary = _public_text(material.get('summary'), 200)
impact = _public_text(material.get('impact'), 500)
expiry = material.get('expires_at')
if type(expiry) not in (int, float) or not math.isfinite(expiry) or expiry <= clock():
raise ApprovalError('approval_task_expired')
seconds = min(600, max(1, math.ceil(expiry - clock())))
buttons = []
for choice, label, style in (('allow', '允许本次', 'primary'), ('deny', '拒绝', 'default')):
buttons.append({'tag': 'button', 'text': {'tag': 'plain_text', 'content': label},
'type': style, 'value': {'kind': 'hainuo.approval.v1', 'approval_id': reference,
'nonce': nonce, 'choice': choice}})
return {'config': {'wide_screen_mode': True, 'enable_forward': False},
'header': {'template': 'orange', 'title': {'tag': 'plain_text', 'content': '海诺操作确认'}},
'elements': [
{'tag': 'div', 'text': {'tag': 'plain_text', 'content': '准备做什么:' + summary}},
{'tag': 'div', 'text': {'tag': 'plain_text', 'content': '可能的影响:' + impact}},
{'tag': 'div', 'text': {'tag': 'plain_text', 'content': '仅允许本次操作;约' + str(seconds) + '秒后失效。'}},
{'tag': 'action', 'actions': buttons}]}
class ApprovalCardSender:
def __init__(self, approvals, platform):
self.approvals, self.platform = approvals, platform
async def send(self, approval_id):
material = await self.approvals.call('card_material',approval_id)
# Prepare before claiming: invalid presentation must not consume an intent.
card = approval_card(material, self.approvals.clock)
token = await self.platform.tenant_token()
if not await self.approvals.call('claim_card',approval_id):
return {'state': 'already_sent_or_unconfirmed'}
delivery_id = hashlib.sha256(('approval-card-v1\0' + approval_id).encode()).hexdigest()[:32]
try:
# Receipt is the actual reply card ID, never the source user message.
message_id = await asyncio.wait_for(self.platform.reply_task_card(
material['source_message_id'], card, delivery_id, token=token), timeout=10)
await self.approvals.call('bind_card',approval_id, message_id)
except BaseException:
# Cancellation/timeout can occur after platform acceptance. Never
# infer "not sent" and automatically issue another confirmation.
await self.approvals.call('card_send_unknown',approval_id)
raise
return {'state': 'sent'}
async def update_closed(self,approval_id):
receipt=await self.approvals.call('closed_card_receipt',approval_id)
if not receipt:return {'state':'no_closed_card'}
card=closed_approval_card(receipt['state'])
token=await self.platform.tenant_token()
# Updating the known original message is retryable; sending a new
# confirmation card after a lost create receipt is not.
await asyncio.wait_for(self.platform.update_task_card(
receipt['message_id'],card,token=token),timeout=5)
await self.approvals.call('mark_card_closed',approval_id,receipt['state'])
return {'state':'updated'}
def closed_approval_card(state):
messages={'rejected':'你已拒绝本次操作。',
'expired':'本次确认已过期,未获得新的执行许可;需要时请重新发起任务。',
'cancelled':'本次确认已取消,不能再通过这张卡片批准。',
'consumed':'本次许可已交给客户端;是否执行及执行结果请查看任务进度。'}
if state not in messages:raise ApprovalError('approval_not_closed')
return {'config':{'wide_screen_mode':True,'enable_forward':False},
'header':{'template':'grey','title':{'tag':'plain_text','content':'海诺操作确认已结束'}},
'elements':[{'tag':'div','text':{'tag':'plain_text','content':messages[state]}}]}
+33
View File
@@ -0,0 +1,33 @@
"""Describe exactly the request being approved; never trust model risk prose."""
import json
import re
from .approval_store import ApprovalError
def describe_action(action):
if (not isinstance(action,dict)or set(action)!={'kind','method','path','params','body'}
or action['kind']!='work-api-v1' or action['method']not in ('GET','POST','PUT','PATCH','DELETE')
or not isinstance(action['path'],str)or len(action['path'])>1500
or not re.fullmatch(r'/open-apis/[A-Za-z0-9_./@!:$-]+',action['path'])
or '..'in action['path']or '//'in action['path']
or not isinstance(action['params'],dict)or not isinstance(action['body'],dict)):
raise ApprovalError('unsupported_approval_action')
encoded=json.dumps(action,sort_keys=True,ensure_ascii=True,separators=(',',':'),allow_nan=False).encode()
if len(encoded)>32000:raise ApprovalError('operation_budget_exceeded')
parts=action['path'].split('/');namespace=parts[2]
targets={'calendar':'日历','contact':'通讯录','search':'搜索','drive':'云盘',
'docx':'文档','wiki':'知识库','bitable':'多维表格','task':'任务','sheets':'电子表格','vc':'会议'}
if namespace not in targets:raise ApprovalError('unsupported_approval_action')
method=action['method'];label=targets[namespace]
verb={'GET':'查询','POST':'提交','PUT':'更新','PATCH':'修改','DELETE':'删除'}[method]
subject=next((action['body'][key].strip()[:80]for key in ('summary','title','name')
if isinstance(action['body'].get(key),str)and action['body'][key].strip()),'')
if any(ord(char)<32 for char in subject):subject=''
summary=verb+label+'中的指定数据'+(':'+subject if subject else'')
resource=parts[-1][:100]
impact=('本次是查询,但该接口尚未列入自动放行范围。'if method=='GET'else
'可能修改平台数据或触发通知;已经发生的操作不能保证自动撤销。')
if method=='DELETE':impact='会删除指定数据或移除关联,可能影响其他人,且不一定能够恢复。'
if re.search(r'/(permissions|members|collaborators|share)(/|$)',action['path']):
impact='可能改变其他人的访问权限或成员关系,请核对授权范围。'
return summary,impact+'\n目标范围:'+label+';目标标识:'+resource
+304
View File
@@ -0,0 +1,304 @@
"""Offline foundation for C2: task-scoped approvals with one-time consumption.
No HTTP routes, event subscription, platform message or execution adapter is
registered by this module. VerifiedDecision must only be constructed by a
platform callback verifier; a browser/button payload alone is not evidence.
"""
from dataclasses import dataclass
import hashlib
import hmac
import json
import re
import secrets
import time
from .crypto import canonical
class ApprovalError(ValueError):
pass
@dataclass(frozen=True)
class VerifiedDecision:
environment: str
app_id: str
actor_open_id: str
chat_id: str
card_message_id: str
approval_id: str
nonce: str
choice: str
event_id: str
event_digest: str
def _public_text(value,limit):
if not isinstance(value,str)or not value.strip()or len(value)>limit or any(ord(c)<32 and c!='\n'for c in value):
raise ApprovalError('invalid_approval_text')
return value
class ApprovalStore:
def __init__(self,state,keyring,clock=time.time,enforce_execution_state=False):
self.state,self.db,self.keyring,self.clock=state,state.db,keyring,clock
self.enforce_execution_state=enforce_execution_state
self._sweep_after=''
with self.db:
self.db.execute('''CREATE TABLE IF NOT EXISTS work_approvals_v3(
approval_id TEXT PRIMARY KEY,environment TEXT NOT NULL,app_id TEXT NOT NULL,
task_id TEXT NOT NULL,owner TEXT NOT NULL,host_id TEXT NOT NULL,
binding_generation BIGINT NOT NULL,operation_id TEXT NOT NULL,
operation_digest TEXT NOT NULL,nonce_digest TEXT NOT NULL,
key_id TEXT NOT NULL,ciphertext TEXT NOT NULL,card_message_id TEXT NOT NULL,
state TEXT NOT NULL,expires_at DOUBLE PRECISION NOT NULL,
updated_at DOUBLE PRECISION NOT NULL,
UNIQUE(environment,app_id,task_id,operation_id))''')
self.db.execute('''CREATE TABLE IF NOT EXISTS work_approval_callbacks_v1(
environment TEXT NOT NULL,app_id TEXT NOT NULL,event_id TEXT NOT NULL,
approval_id TEXT NOT NULL,event_digest TEXT NOT NULL,
received_at DOUBLE PRECISION NOT NULL,
PRIMARY KEY(environment,app_id,event_id))''')
self.db.execute('''CREATE TABLE IF NOT EXISTS work_approval_card_outbox_v1(
approval_id TEXT PRIMARY KEY,state TEXT NOT NULL,
updated_at DOUBLE PRECISION NOT NULL)''')
self.db.execute('''CREATE INDEX IF NOT EXISTS work_approvals_expiry_v3
ON work_approvals_v3(environment,app_id,state,expires_at)''')
def _task(self,task_id,owner,host,generation):
if type(generation)is not int or generation<1:
raise ApprovalError('invalid_binding_generation')
task=self.state.task(task_id)
if (not self.state.task_current(task)or not task['chat_id']or not task['source_message_id']or
(task['owner'],task['host_id'],task['binding_generation'])!=(owner,host,generation)or
task['status']!='inflight'or self._execution_closed(task_id)):
raise ApprovalError('approval_task_unavailable')
return task
def _execution_closed(self,task_id):
if not self.enforce_execution_state:return False
row=self.db.execute('SELECT execution_state FROM work_execution_state_v3 WHERE task_id=?',(task_id,)).fetchone()
return bool(row and row['execution_state']in {'completed','failed','cancelled','interrupted','unknown'})
def _aad(self,row):
return canonical(['work-approval-v3',*[row[k]for k in ('environment','app_id','task_id',
'owner','host_id','binding_generation','operation_id','operation_digest','approval_id')]])
def _row(self,approval_id):
if not isinstance(approval_id,str)or not re.fullmatch(r'apr_[a-f0-9]{64}',approval_id):
raise ApprovalError('invalid_approval_reference')
row=self.db.execute('SELECT * FROM work_approvals_v3 WHERE approval_id=? AND environment=? AND app_id=?',
(approval_id,self.state.environment,self.state.app_id)).fetchone()
if not row:raise ApprovalError('approval_not_found')
return dict(row)
def _expire(self,row):
if row['expires_at']<=self.clock()and row['state']in {'pending','approved'}:
self.db.execute("UPDATE work_approvals_v3 SET state='expired',updated_at=? WHERE approval_id=? AND state IN ('pending','approved')",
(self.clock(),row['approval_id']))
row=self._row(row['approval_id'])
return row
@staticmethod
def _status(row):
return {k:row[k]for k in ('approval_id','state','expires_at','operation_digest')}
def create(self,task_id,owner,host,generation,operation_id,action,summary,impact,ttl=120):
if not isinstance(operation_id,str)or not re.fullmatch(r'[A-Za-z0-9_-]{8,100}',operation_id):
raise ApprovalError('invalid_operation_id')
if type(ttl)is not int or not 30<=ttl<=600:raise ApprovalError('invalid_approval_lifetime')
if not isinstance(action,dict)or not action:raise ApprovalError('invalid_operation')
encoded=json.dumps(action,sort_keys=True,ensure_ascii=True,separators=(',',':'),allow_nan=False).encode()
if len(encoded)>32000:raise ApprovalError('operation_budget_exceeded')
summary=_public_text(summary,200);impact=_public_text(impact,500)
digest=hashlib.sha256(encoded).hexdigest()
approval_id='apr_'+hashlib.sha256(canonical([self.state.environment,self.state.app_id,task_id,operation_id])).hexdigest()
with self.db:
self.state._owner_lock(owner)
task=self._task(task_id,owner,host,generation)
old=self.db.execute('SELECT * FROM work_approvals_v3 WHERE approval_id=?',(approval_id,)).fetchone()
if old:
row=self._expire(dict(old))
if (row['owner'],row['host_id'],row['binding_generation'],row['operation_digest'])!=(owner,host,generation,digest):
raise ApprovalError('operation_identity_conflict')
return self._status(row)
nonce=secrets.token_urlsafe(32)
row={'approval_id':approval_id,'environment':task['environment'],'app_id':task['app_id'],
'task_id':task_id,'owner':owner,'host_id':host,'binding_generation':generation,
'operation_id':operation_id,'operation_digest':digest}
key,cipher=self.keyring.encrypt(canonical({'action':action,'summary':summary,'impact':impact,'nonce':nonce}),self._aad(row))
expires=min(self.clock()+ttl,task['deadline'])
if expires<=self.clock():raise ApprovalError('approval_task_expired')
self.db.execute('INSERT INTO work_approvals_v3 VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)',
(approval_id,row['environment'],row['app_id'],task_id,owner,host,generation,operation_id,digest,
hashlib.sha256(nonce.encode()).hexdigest(),key,cipher,'','pending',expires,self.clock()))
return self._status(self._row(approval_id))
def card_material(self,approval_id):
"""Internal sender only: private task origin + fixed confirmation text."""
with self.db:
row=self._row(approval_id);self.state._owner_lock(row['owner']);row=self._expire(self._row(approval_id))
task=self._task(row['task_id'],row['owner'],row['host_id'],row['binding_generation'])
if row['state']!='pending':raise ApprovalError('approval_not_pending')
material=json.loads(self.keyring.decrypt(row['key_id'],row['ciphertext'],self._aad(row)))
return {'source_message_id':task['source_message_id'],'chat_id':task['chat_id'],
'approval_id':approval_id,'summary':material['summary'],'impact':material['impact'],
'nonce':material['nonce'],'expires_at':row['expires_at']}
def bind_card(self,approval_id,message_id):
if not isinstance(message_id,str)or not re.fullmatch(r'om_[A-Za-z0-9_-]{1,120}',message_id):
raise ApprovalError('invalid_card_receipt')
with self.db:
row=self._row(approval_id);self.state._owner_lock(row['owner']);row=self._expire(self._row(approval_id))
task=self.state.task(row['task_id'])
if row['state']in {'pending','approved'}and(not self.state.task_current(task)or task['status']!='inflight'or self._execution_closed(row['task_id'])):
self.db.execute("UPDATE work_approvals_v3 SET state='cancelled',updated_at=? WHERE approval_id=?",(self.clock(),approval_id))
if not self.db.execute('SELECT approval_id FROM work_approval_card_outbox_v1 WHERE approval_id=?',(approval_id,)).fetchone():
raise ApprovalError('approval_send_intent_required')
if row['card_message_id']not in ('',message_id):raise ApprovalError('approval_card_conflict')
self.db.execute('UPDATE work_approvals_v3 SET card_message_id=?,updated_at=? WHERE approval_id=?',
(message_id,self.clock(),approval_id))
self.db.execute("UPDATE work_approval_card_outbox_v1 SET state='sent',updated_at=? WHERE approval_id=?",
(self.clock(),approval_id))
def claim_card(self,approval_id):
"""Persist send intent before network I/O; lost receipt is not resendable."""
with self.db:
row=self._row(approval_id);self.state._owner_lock(row['owner']);row=self._expire(self._row(approval_id))
self._task(row['task_id'],row['owner'],row['host_id'],row['binding_generation'])
if row['state']!='pending':raise ApprovalError('approval_not_pending')
if row['card_message_id']:return False
previous=self.db.execute('SELECT state FROM work_approval_card_outbox_v1 WHERE approval_id=?',(approval_id,)).fetchone()
if previous:return False
self.db.execute("INSERT INTO work_approval_card_outbox_v1 VALUES(?,'sending',?)",(approval_id,self.clock()))
return True
def card_send_unknown(self,approval_id):
with self.db:
self.db.execute("UPDATE work_approval_card_outbox_v1 SET state='unknown',updated_at=? WHERE approval_id=? AND state='sending'",
(self.clock(),approval_id))
def close_unavailable(self,limit=100):
"""Future bounded maintenance: expiry or invalid task never grants consent."""
if type(limit)is not int or not 1<=limit<=100:raise ApprovalError('invalid_approval_budget')
rows=self.db.execute("SELECT approval_id FROM work_approvals_v3 WHERE environment=? AND app_id=? AND state IN ('pending','approved') AND approval_id>? ORDER BY approval_id LIMIT ?",
(self.state.environment,self.state.app_id,self._sweep_after,limit)).fetchall()
if not rows:self._sweep_after=''
closed=[];started=time.monotonic()
for candidate in rows:
if time.monotonic()-started>=.5:break
with self.db:
row=self._row(candidate['approval_id']);self.state._owner_lock(row['owner']);row=self._row(row['approval_id'])
if row['state']not in {'pending','approved'}:continue
task=self.state.task(row['task_id'])
expired=row['expires_at']<=self.clock()or bool(task and task['deadline']<=self.clock())
invalid=(not self.state.task_current(task)or task['status']!='inflight'or self._execution_closed(row['task_id'])or
(task['owner'],task['host_id'],task['binding_generation'])!=
(row['owner'],row['host_id'],row['binding_generation']))
if expired or invalid:
state='expired'if expired else'cancelled'
self.db.execute("UPDATE work_approvals_v3 SET state=?,updated_at=? WHERE approval_id=? AND state IN ('pending','approved')",
(state,self.clock(),row['approval_id']))
closed.append({'approval_id':row['approval_id'],'state':state})
self._sweep_after=candidate['approval_id']
return closed
def closed_card_receipt(self,approval_id):
"""Internal renderer only. Never return action/nonce or imply execution success."""
with self.db:
row=self._row(approval_id);self.state._owner_lock(row['owner']);row=self._expire(self._row(approval_id))
if row['state']not in {'rejected','expired','cancelled','consumed'}or not row['card_message_id']:
return None
sent=self.db.execute('SELECT state FROM work_approval_card_outbox_v1 WHERE approval_id=?',(approval_id,)).fetchone()
if sent and sent['state']=='closed':return None
self.db.execute('UPDATE work_approval_card_outbox_v1 SET updated_at=? WHERE approval_id=?',
(self.clock(),approval_id))
return {'message_id':row['card_message_id'],'state':row['state']}
def mark_card_closed(self,approval_id,state):
with self.db:
row=self._row(approval_id);self.state._owner_lock(row['owner']);row=self._row(approval_id)
if row['state']!=state or state not in {'rejected','expired','cancelled','consumed'}:
raise ApprovalError('approval_state_changed')
self.db.execute("UPDATE work_approval_card_outbox_v1 SET state='closed',updated_at=? WHERE approval_id=?",
(self.clock(),approval_id))
def cards_to_send(self):
rows=self.db.execute("""SELECT a.approval_id FROM work_approvals_v3 a
WHERE a.environment=? AND a.app_id=? AND a.state='pending' AND a.expires_at>?
AND a.card_message_id='' AND NOT EXISTS(SELECT 1 FROM work_approval_card_outbox_v1 o WHERE o.approval_id=a.approval_id)
ORDER BY a.updated_at LIMIT 5""",(self.state.environment,self.state.app_id,self.clock())).fetchall()
return [row['approval_id']for row in rows]
def cards_to_close(self):
rows=self.db.execute("""SELECT a.approval_id FROM work_approvals_v3 a
JOIN work_approval_card_outbox_v1 o ON o.approval_id=a.approval_id
WHERE a.environment=? AND a.app_id=? AND a.state IN ('rejected','expired','cancelled','consumed')
AND a.card_message_id<>'' AND o.state<>'closed' ORDER BY o.updated_at LIMIT 5""",
(self.state.environment,self.state.app_id)).fetchall()
return [row['approval_id']for row in rows]
def decide(self,decision):
if not isinstance(decision,VerifiedDecision):raise ApprovalError('verified_callback_required')
if decision.choice not in {'allow','deny'}:raise ApprovalError('invalid_approval_choice')
if (not isinstance(decision.event_id,str)or not re.fullmatch(r'[A-Za-z0-9_-]{1,128}',decision.event_id)
or not isinstance(decision.event_digest,str)or not re.fullmatch(r'[a-f0-9]{64}',decision.event_digest)):
raise ApprovalError('invalid_callback_receipt')
fields={key:getattr(decision,key)for key in ('environment','app_id','actor_open_id',
'chat_id','card_message_id','approval_id','nonce','choice')}
if not hmac.compare_digest(hashlib.sha256(canonical(fields)).hexdigest(),decision.event_digest):
raise ApprovalError('callback_receipt_conflict')
with self.db:
row=self._row(decision.approval_id);self.state._owner_lock(row['owner']);row=self._expire(self._row(decision.approval_id))
task=self._task(row['task_id'],row['owner'],row['host_id'],row['binding_generation'])
if (decision.environment,decision.app_id,decision.actor_open_id,decision.chat_id,decision.card_message_id)!=\
(row['environment'],row['app_id'],row['owner'],task['chat_id'],row['card_message_id'])or not row['card_message_id']:
raise ApprovalError('callback_identity_conflict')
if not isinstance(decision.nonce,str)or len(decision.nonce)>128 or not hmac.compare_digest(hashlib.sha256(decision.nonce.encode()).hexdigest(),row['nonce_digest']):
raise ApprovalError('invalid_approval_nonce')
# Owner lock serializes duplicate clicks for this approval. Reused
# event IDs for a different approval also fail the database PK.
receipt=self.db.execute('SELECT approval_id,event_digest FROM work_approval_callbacks_v1 WHERE environment=? AND app_id=? AND event_id=?',
(row['environment'],row['app_id'],decision.event_id)).fetchone()
if receipt:
if (receipt['approval_id'],receipt['event_digest'])!=(row['approval_id'],decision.event_digest):
raise ApprovalError('callback_receipt_conflict')
return self._status(row)
target='approved'if decision.choice=='allow'else'rejected'
if row['state']not in {'pending',target}:raise ApprovalError('approval_already_closed')
self.db.execute('INSERT INTO work_approval_callbacks_v1 VALUES(?,?,?,?,?,?)',
(row['environment'],row['app_id'],decision.event_id,row['approval_id'],decision.event_digest,self.clock()))
self.db.execute("UPDATE work_approvals_v3 SET state=?,updated_at=? WHERE approval_id=? AND state='pending'",
(target,self.clock(),row['approval_id']))
return self._status(self._row(row['approval_id']))
def status(self,approval_id,task_id,owner,host,generation,operation_digest):
"""Future device-authenticated polling endpoint; no nonce/action returned."""
with self.db:
self.state._owner_lock(owner);row=self._expire(self._row(approval_id))
self._task(task_id,owner,host,generation)
if (row['task_id'],row['owner'],row['host_id'],row['binding_generation'],row['operation_digest'])!=\
(task_id,owner,host,generation,operation_digest):raise ApprovalError('operation_identity_conflict')
return self._status(row)
def consume(self,approval_id,task_id,owner,host,generation,operation_digest):
with self.db:
self.state._owner_lock(owner)
row=self._expire(self._row(approval_id))
self._task(task_id,owner,host,generation)
if (row['task_id'],row['owner'],row['host_id'],row['binding_generation'],row['operation_digest'])!=(task_id,owner,host,generation,operation_digest):
raise ApprovalError('operation_identity_conflict')
if row['state']!='approved':return {**self._status(row),'execute':False}
material=json.loads(self.keyring.decrypt(row['key_id'],row['ciphertext'],self._aad(row)))
changed=self.db.execute("UPDATE work_approvals_v3 SET state='consumed',updated_at=? WHERE approval_id=? AND state='approved'",
(self.clock(),approval_id)).rowcount
if changed!=1:return {**self._status(self._row(approval_id)),'execute':False}
return {**self._status(self._row(approval_id)),'execute':True,'action':material['action']}
def cancel(self,approval_id,task_id,owner,host,generation):
with self.db:
self.state._owner_lock(owner);row=self._row(approval_id)
self._task(task_id,owner,host,generation)
if (row['task_id'],row['owner'],row['host_id'],row['binding_generation'])!=(task_id,owner,host,generation):raise ApprovalError('approval_identity_conflict')
self.db.execute("UPDATE work_approvals_v3 SET state='cancelled',updated_at=? WHERE approval_id=? AND state IN ('pending','approved')",
(self.clock(),approval_id))
return self._status(self._row(approval_id))
+68
View File
@@ -0,0 +1,68 @@
"""Single bounded approval worker with its own database connection."""
import asyncio
from concurrent.futures import ThreadPoolExecutor
import time
from .approval_store import ApprovalError, ApprovalStore
class ApprovalWorker:
def __init__(self,settings,keyring):
self.settings,self.keyring,self.clock=settings,keyring,time.time
self.executor=ThreadPoolExecutor(max_workers=1,thread_name_prefix='work-approval')
self.slots=asyncio.Semaphore(8)
self.store=None
def _start(self):
from .store import Store
from .binding_state import BindingState
self.connection=Store(self.settings.data_dir/'metadata.sqlite',self.settings.database_url)
if self.settings.database_url:
self.connection.db.execute("SET lock_timeout TO '500ms'")
self.connection.db.execute("SET statement_timeout TO '800ms'")
else:self.connection.db.execute('PRAGMA busy_timeout=500')
self.store=ApprovalStore(BindingState(self.connection,self.settings.environment,
self.settings.feishu_app_id),self.keyring,enforce_execution_state=True)
async def start(self):
await asyncio.get_running_loop().run_in_executor(self.executor,self._start)
def _invoke(self,deadline,method,args):
if time.monotonic()>deadline or self.store is None:
raise ApprovalError('approval_temporarily_unavailable')
try:
# Postgres may reconnect after a lost connection. Reapply this
# worker's limits before opening a new approval transaction.
if self.settings.database_url:
db=self.connection.db
if db.conn.closed or db.conn.broken:
db.execute("SET lock_timeout TO '500ms'")
db.execute("SET statement_timeout TO '800ms'")
return getattr(self.store,method)(*args)
except ApprovalError:raise
except Exception:raise ApprovalError('approval_temporarily_unavailable')from None
async def call(self,method,*args):
allowed={'create','status','consume','cancel','decide','card_material','claim_card',
'bind_card','card_send_unknown','close_unavailable','closed_card_receipt',
'mark_card_closed','cards_to_send','cards_to_close'}
if method not in allowed:raise ApprovalError('unsupported_approval_operation')
try:await asyncio.wait_for(self.slots.acquire(),timeout=.05)
except asyncio.TimeoutError:raise ApprovalError('approval_temporarily_unavailable')from None
future=asyncio.get_running_loop().run_in_executor(self.executor,self._invoke,
time.monotonic()+1.2,method,args)
# Keep the queue slot until the worker really stops, even when a caller
# times out. A timeout is not proof that a database commit did not occur.
def settled(completed):
self.slots.release()
if not completed.cancelled():completed.exception()
future.add_done_callback(settled)
try:return await asyncio.wait_for(asyncio.shield(future),timeout=1.5)
except asyncio.TimeoutError:raise ApprovalError('approval_result_unconfirmed')from None
async def close(self):
def finish():
if self.store is not None:self.connection.close()
self.store=None
try:await asyncio.get_running_loop().run_in_executor(self.executor,finish)
finally:self.executor.shutdown(wait=False,cancel_futures=True)
+7
View File
@@ -42,6 +42,8 @@ class Settings(BaseSettings):
max_result: int = 16000
work_files_enabled: bool = False
work_task_cards_enabled: bool = False
work_remote_approvals_enabled: bool = False
feishu_tenant_key: str = ''
work_file_max_bytes: int = 10*1024*1024
work_file_batch_limit: int = 20
work_file_retention: int = 86400
@@ -57,6 +59,11 @@ class Settings(BaseSettings):
@model_validator(mode="after")
def validate_runtime(self):
if self.work_remote_approvals_enabled:
if (self.credential_mode!='broker'or self.feishu_event_source!='longconn'
or not self.feishu_enabled or not self.feishu_verification_token
or not re.fullmatch(r'[A-Za-z0-9_-]{1,128}',self.feishu_tenant_key)):
raise ValueError('remote approvals require broker, longconn and explicit callback identity')
if self.work_task_cards_enabled and self.credential_mode!='broker':raise ValueError('task cards require broker mode')
if not 1024<=self.work_file_max_bytes<=100*1024*1024 or not 1<=self.work_file_batch_limit<=50 or not 300<=self.work_file_retention<=7*86400:
raise ValueError('invalid work file deployment limits')
+16 -1
View File
@@ -265,6 +265,8 @@ def create_app(settings=None, redis=None, platform=None):
lifecycle = None
from .notifications import router as notification_router
background = set()
approvals = None
approval_worker = None
def spawn(coro):
task = asyncio.create_task(coro)
@@ -273,9 +275,16 @@ def create_app(settings=None, redis=None, platform=None):
# Retrieve errors without displaying possibly sensitive exception text.
task.add_done_callback(lambda t: t.exception() if not t.cancelled() else None)
if s.work_remote_approvals_enabled:
from .approval_api import ApprovalAPI
from .approval_worker import ApprovalWorker
approval_worker=ApprovalWorker(s,credential_store.keyring)
approvals=ApprovalAPI(oauth,approval_worker,f,spawn)
@asynccontextmanager
async def lifespan(app):
await r.ping()
if approval_worker:await approval_worker.start()
if lifecycle:
await lifecycle.maintain()
await deliveries.recover_interrupted_sends()
@@ -302,6 +311,7 @@ def create_app(settings=None, redis=None, platform=None):
await deliveries.recover_interrupted_sends()
if broker.files:await broker.files.flush()
await deliveries.flush()
if approvals:await approvals.maintain()
except Exception:
# No credentials or raw exception text in background logs.
pass
@@ -323,14 +333,19 @@ def create_app(settings=None, redis=None, platform=None):
await r.delete("hn:task-worker:"+broker.worker_id)
await pub.aclose()
await f.close()
if approval_worker:await approval_worker.close()
store.close()
if redis is None:
await r.aclose()
app = FastAPI(title="Hainuo B1 connector", lifespan=lifespan, docs_url=None, redoc_url=None)
app.add_middleware(BodyLimitMiddleware, max_body=s.max_body,
path_limits={'/work/v2/files/upload':s.work_file_max_bytes}if broker.files else {})
path_limits={**({'/work/v2/files/upload':s.work_file_max_bytes}if broker.files else {}),
**({'/internal/approval-callback':65536,'/work/v2/approvals/create':49152}if approvals else {})})
app.include_router(oauth.router)
if approvals:
app.include_router(approvals.router)
app.state.approvals=approvals
if lifecycle:
app.include_router(deliveries.router)
app.state.deliveries=deliveries
+1
View File
@@ -121,6 +121,7 @@ class CredentialAPI:
raise HTTPException(503, "credential_temporarily_unavailable") from None
self.require_binding(body.host_id, device["owner"], device["binding_generation"])
return no_cache(JSONResponse({"credential_mode": "broker", "protocol_version": 2,
"approval_protocol": "work-approval-v1" if self.s.work_remote_approvals_enabled else None,
"binding_owner": device["owner"],
"binding_generation": device["binding_generation"],
"permission_profiles": sorted(self.s.credential_permission_profiles), **result}))
+48 -1
View File
@@ -4,6 +4,7 @@ import logging
import os
import threading
import time
from concurrent.futures import ThreadPoolExecutor,TimeoutError as FutureTimeout
import httpx
import redis
@@ -51,7 +52,52 @@ def main():
raise RuntimeError("connector did not accept event")
print(json.dumps({"event": "platform_event_accepted", "type": data.get("header", {}).get("event_type")}), flush=True)
handler = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(received).build()
builder = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(received)
callback_pool=None
if s.work_remote_approvals_enabled:
from lark_oapi.event.callback.model.p2_card_action_trigger import P2CardActionTriggerResponse
callback_pool=ThreadPoolExecutor(max_workers=2,thread_name_prefix='work-card-callback')
callback_slots=threading.BoundedSemaphore(2)
def forward_card(raw):
deadline=time.monotonic()+2.1
# Own this client until the worker ends. The SDK response deadline
# does not imply an in-flight authenticated decision was rolled back.
with httpx.Client(base_url=url,trust_env=False,follow_redirects=False,
timeout=httpx.Timeout(.8,connect=.2,pool=.1))as callback_http:
with callback_http.stream('POST','/internal/approval-callback',content=raw,
headers={'X-Internal-Secret':s.internal_secret,'Content-Type':'application/json'})as response:
if response.status_code!=200:raise ValueError()
body=bytearray()
for chunk in response.iter_bytes():
body.extend(chunk)
if len(body)>4096 or time.monotonic()>deadline:raise ValueError()
return json.loads(body)
def decision(event):
# Same authenticated SDK connection/lease, no second consumer.
# Never log callback bodies or the card-update credential.
fallback={'toast':{'type':'warning','content':'确认结果待核对,请查看原任务状态。'}}
try:
raw=lark.JSON.marshal(event).encode('utf-8')
if len(raw)>65536:return P2CardActionTriggerResponse(fallback)
if not callback_slots.acquire(blocking=False):return P2CardActionTriggerResponse(fallback)
try:future=callback_pool.submit(forward_card,raw)
except BaseException:
callback_slots.release()
raise
def settled(completed):
callback_slots.release()
if not completed.cancelled():completed.exception()
future.add_done_callback(settled)
try:payload=future.result(timeout=2.3)
except FutureTimeout:return P2CardActionTriggerResponse(fallback)
toast=payload.get('toast')if isinstance(payload,dict)else None
if (not isinstance(toast,dict)or toast.get('type')not in {'info','success','warning','error'}
or not isinstance(toast.get('content'),str)or len(toast['content'])>200):
return P2CardActionTriggerResponse(fallback)
return P2CardActionTriggerResponse({'toast':toast})
except Exception:return P2CardActionTriggerResponse(fallback)
builder=builder.register_p2_card_action_trigger(decision)
handler=builder.build()
class ObservableClient(lark.ws.Client):
async def _connect(self):
try:
@@ -69,6 +115,7 @@ def main():
finally:
done.set()
client.close()
if callback_pool:callback_pool.shutdown(wait=False,cancel_futures=True)
try:
lease.release()
except redis.exceptions.LockError:
+8 -4
View File
@@ -10,7 +10,7 @@ DELIVERY={None:'尚未接收结果','ready':'已接收结果,等待投递','se
'replied':'结果已发送到当前会话','unknown':'结果投递待核对','discarded':'结果已停止交付'}
def card_content(task_id,execution,delivery,files=None,connection_lost=False):
def card_content(task_id,execution,delivery,files=None,connection_lost=False,remote_approvals=False):
execution=execution if execution in EXECUTION else 'unknown'
color='green' if execution=='completed' else 'red' if execution in {'failed','interrupted'} else 'orange' if execution in {'waiting_for_approval','unknown'} else 'blue'
label=EXECUTION[execution]
@@ -20,7 +20,9 @@ def card_content(task_id,execution,delivery,files=None,connection_lost=False):
{'tag':'div','text':{'tag':'plain_text','content':'文字回复:'+DELIVERY.get(delivery,'状态待核对')}},
{'tag':'note','elements':[{'tag':'plain_text','content':'任务编号:'+task_id}]}]
if execution=='waiting_for_approval':
elements.insert(1,{'tag':'div','text':{'tag':'plain_text','content':'请在客户端查看并确认具体操作。本卡片暂不提供远程批准。'}})
hint=('请在本任务的操作确认卡片中核对动作和影响,选择允许本次或拒绝。'if remote_approvals else
'请在客户端查看并确认具体操作。本卡片暂不提供远程批准。')
elements.insert(1,{'tag':'div','text':{'tag':'plain_text','content':hint}})
if execution=='completed' and delivery!='replied':
elements.insert(1,{'tag':'div','text':{'tag':'plain_text','content':'任务已执行完成,结果交付请看下方状态。'}})
return {'config':{'wide_screen_mode':True,'enable_forward':False},
@@ -28,9 +30,10 @@ def card_content(task_id,execution,delivery,files=None,connection_lost=False):
class TaskCards:
def __init__(self,state,platform,worker_id,clock=time.time,files_enabled=False):
def __init__(self,state,platform,worker_id,clock=time.time,files_enabled=False,remote_approvals=False):
self.state,self.db,self.platform,self.worker_id,self.clock=state,state.db,platform,worker_id,clock
self.files_enabled=files_enabled
self.remote_approvals=remote_approvals
with self.db:
self.db.execute('''CREATE TABLE IF NOT EXISTS work_task_connection_v3(
task_id TEXT PRIMARY KEY,reason TEXT NOT NULL)''')
@@ -57,7 +60,8 @@ class TaskCards:
if task['status']=='unknown' and execution not in {'completed','failed','cancelled','interrupted'}:execution='unknown'
if task['deadline']<=self.clock() and execution not in {'completed','failed','cancelled','interrupted'}:execution='unknown'
lost=self.db.execute('SELECT reason FROM work_task_connection_v3 WHERE task_id=?',(task['turn_id'],)).fetchone()
return card_content(task['turn_id'],execution,delivery['status'] if delivery else None,connection_lost=bool(lost))
return card_content(task['turn_id'],execution,delivery['status'] if delivery else None,
connection_lost=bool(lost),remote_approvals=self.remote_approvals)
async def flush(self):
# Bound one maintenance pass; business result delivery remains independent.
+2 -1
View File
@@ -43,7 +43,8 @@ class TaskDelivery:
self.cards=None
if auth.s.work_task_cards_enabled:
from .task_cards import TaskCards
self.cards=TaskCards(state,platform,broker.worker_id,files_enabled=auth.s.work_files_enabled)
self.cards=TaskCards(state,platform,broker.worker_id,files_enabled=auth.s.work_files_enabled,
remote_approvals=auth.s.work_remote_approvals_enabled)
broker.task_cards=self.cards
def current(self, body):