feat(work): stage authenticated remote approvals with scoped execution fencing
This commit is contained in:
@@ -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)
|
||||
@@ -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, '确认未完成,请核对任务状态。')}}
|
||||
@@ -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]}}]}
|
||||
@@ -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
|
||||
@@ -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))
|
||||
@@ -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)
|
||||
@@ -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')
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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}))
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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):
|
||||
|
||||
Reference in New Issue
Block a user