File size: 9,209 Bytes
caf8059
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5ca3c16
caf8059
 
5ca3c16
caf8059
 
 
 
 
 
 
 
 
 
 
5ca3c16
caf8059
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
"""Independent local accounts, sessions and project membership. No WorkOS identity mutation."""
import hashlib
import hmac
import json
import secrets
import sqlite3
import time
import uuid
from contextlib import contextmanager
from pathlib import Path
from src.modules.skill.domain.models import Actor, SkillError


class LocalIdentity:
    def __init__(self, path):
        self.path = Path(path)
        self.path.parent.mkdir(parents=True, exist_ok=True)
        with self.connect() as db:
            db.executescript('''
            CREATE TABLE IF NOT EXISTS users(id TEXT PRIMARY KEY,username TEXT UNIQUE,salt TEXT,password TEXT,roles TEXT,enabled INTEGER,failures INTEGER DEFAULT 0,locked_until REAL DEFAULT 0);
            CREATE TABLE IF NOT EXISTS sessions(token_hash TEXT PRIMARY KEY,user_id TEXT,csrf TEXT,expires REAL);
            CREATE TABLE IF NOT EXISTS projects(id TEXT PRIMARY KEY,name TEXT);
            CREATE TABLE IF NOT EXISTS members(project_id TEXT,user_id TEXT,PRIMARY KEY(project_id,user_id));
            CREATE TABLE IF NOT EXISTS identity_audit(id INTEGER PRIMARY KEY,at REAL,actor TEXT,action TEXT,target TEXT);
            ''')

    @contextmanager
    def connect(self):
        db = sqlite3.connect(self.path, timeout=30)
        db.row_factory = sqlite3.Row
        try:
            with db:
                yield db
        finally:
            db.close()

    @staticmethod
    def hashed(password, salt):
        return hashlib.scrypt(password.encode(), salt=bytes.fromhex(salt), n=16384, r=8, p=1).hex()

    @staticmethod
    def admin(actor):
        if 'admin' not in actor.roles:
            raise SkillError('ROLE_REQUIRED', '需要管理员权限。', 403)

    def needs_setup(self):
        with self.connect() as db:
            return not db.execute("SELECT 1 FROM users WHERE enabled=1 LIMIT 1").fetchone()

    def create_user(self, username, password, roles, *, setup=False, actor=None):
        import re
        if not re.fullmatch(r'[A-Za-z][A-Za-z0-9_.-]{2,39}', username) or not 12 <= len(password) <= 128:
            raise SkillError('ACCOUNT_INPUT_INVALID', '账号需3–40位;密码需12–128位。')
        if not set(roles).issubset({'admin', 'reviewer', 'developer'}):
            raise SkillError('ROLE_INVALID', '角色无效。')
        if not setup:
            self.admin(actor)
        salt = secrets.token_hex(16)
        key = self.hashed(password, salt)
        with self.connect() as db:
            db.execute('BEGIN IMMEDIATE')
            if setup and db.execute('SELECT 1 FROM users WHERE enabled=1 LIMIT 1').fetchone():
                raise SkillError('SETUP_COMPLETE', '管理员已经初始化。', 409)
            uid = 'user-' + uuid.uuid4().hex
            try:
                db.execute('INSERT INTO users(id,username,salt,password,roles,enabled) VALUES(?,?,?,?,?,1)',
                           (uid, username, salt, key, json.dumps(['admin'] if setup else roles)))
            except sqlite3.IntegrityError:
                raise SkillError('USERNAME_EXISTS', '账号已存在。', 409) from None
            if setup:
                for row in db.execute('SELECT id FROM projects'):
                    db.execute('INSERT OR IGNORE INTO members VALUES(?,?)', (row['id'], uid))
            db.execute('INSERT INTO identity_audit(at,actor,action,target) VALUES(?,?,?,?)',
                       (time.time(), 'first-local-setup' if setup else actor.user_id, 'account.create', uid))
        return uid

    def login(self, username, password):
        if len(password) > 128:
            raise SkillError('LOGIN_FAILED', '账号或密码错误。', 401)
        with self.connect() as db:
            row = db.execute('SELECT * FROM users WHERE username=? AND enabled=1', (username,)).fetchone()
            # Do the expensive hash for nonexistent accounts too.
            computed = self.hashed(password, row['salt'] if row else '00' * 16)
            if row and row['locked_until'] > time.time():
                raise SkillError('LOGIN_RATE_LIMITED', '登录失败过多,请稍后重试。', 429)
            if not row or not hmac.compare_digest(computed, row['password']):
                if row:
                    count = row['failures'] + 1
                    db.execute('UPDATE users SET failures=?,locked_until=? WHERE id=?',
                               (count, time.time() + 300 if count >= 5 else 0, row['id']))
                    db.commit()
                raise SkillError('LOGIN_FAILED', '账号或密码错误。', 401)
            db.execute('UPDATE users SET failures=0,locked_until=0 WHERE id=?', (row['id'],))
            token, csrf = secrets.token_urlsafe(32), secrets.token_urlsafe(24)
            db.execute('INSERT INTO sessions VALUES(?,?,?,?)', (hashlib.sha256(token.encode()).hexdigest(), row['id'], csrf, time.time() + 28800))
        return token, csrf

    def session(self, token):
        with self.connect() as db:
            row = db.execute('SELECT users.*,sessions.csrf FROM sessions JOIN users ON users.id=sessions.user_id WHERE token_hash=? AND expires>? AND enabled=1',
                             (hashlib.sha256(token.encode()).hexdigest(), time.time())).fetchone()
        if not row:
            raise SkillError('TOKEN_INVALID', '请登录,或会话已过期。', 401)
        return Actor(tenant_id='demo-tenant', user_id=row['id'], roles=json.loads(row['roles'])), row['csrf'], row['username']

    def logout(self, token):
        with self.connect() as db:
            db.execute('DELETE FROM sessions WHERE token_hash=?', (hashlib.sha256(token.encode()).hexdigest(),))

    def actor(self, user_id):
        with self.connect() as db:
            row = db.execute('SELECT * FROM users WHERE id=?', (user_id,)).fetchone()
        if not row or (not row['enabled'] and user_id != 'local-example-builder'):
            raise SkillError('TOKEN_INVALID', '账号已停用。', 401)
        return Actor(tenant_id='demo-tenant', user_id=row['id'], roles=json.loads(row['roles']))

    def project_access(self, actor, project_id):
        with self.connect() as db:
            found = db.execute('SELECT 1 FROM members WHERE project_id=? AND user_id=?', (project_id, actor.user_id)).fetchone()
        if actor.tenant_id != 'demo-tenant' or not found:
            raise SkillError('PROJECT_NOT_FOUND', '项目不存在或不可见。', 404)

    def projects(self, actor):
        with self.connect() as db:
            return [dict(x) for x in db.execute('SELECT projects.* FROM projects JOIN members ON projects.id=members.project_id WHERE user_id=?', (actor.user_id,))]

    def set_member(self, actor, project_id, user_id, enabled):
        self.admin(actor)
        self.project_access(actor, project_id)
        self.actor(user_id)
        with self.connect() as db:
            if enabled:
                db.execute('INSERT OR IGNORE INTO members VALUES(?,?)', (project_id, user_id))
            else:
                db.execute('DELETE FROM members WHERE project_id=? AND user_id=?', (project_id, user_id))
            db.execute('INSERT INTO identity_audit(at,actor,action,target) VALUES(?,?,?,?)', (time.time(), actor.user_id, 'member.grant' if enabled else 'member.revoke', project_id + ':' + user_id))

    def seed_projects(self):
        with self.connect() as db:
            db.execute("INSERT OR IGNORE INTO users(id,username,salt,password,roles,enabled) VALUES('local-example-builder','local-example-builder','','','[\"admin\"]',0)")
            for key, name in [('erp-demo', 'ERP 采购编程'), ('wms-demo', 'WMS 库存编程'), ('equipment-demo', '设备运维编程'),('calculator-demo','网页计算器开发'),('pdf-demo','PDF解析开发'),('webapp-demo','网页应用开发')]:
                added=db.execute('INSERT OR IGNORE INTO projects VALUES(?,?)', (key, name)).rowcount
                db.execute('INSERT OR IGNORE INTO members VALUES(?,?)', (key, 'local-example-builder'))
                if added and key in {'calculator-demo','pdf-demo','webapp-demo'}:
                    for row in db.execute("SELECT id FROM users WHERE username IN ('programmer','manager','tester') AND enabled=1").fetchall():
                        db.execute('INSERT OR IGNORE INTO members VALUES(?,?)',(key,row['id']))

    def seed_demo_users(self):
        """Explicit loopback demo mode; never reset an existing account or its ACL."""
        for username, roles in [('programmer',['developer']),('manager',['admin']),('tester',['reviewer'])]:
            with self.connect() as db:
                if db.execute('SELECT 1 FROM users WHERE username=?',(username,)).fetchone():
                    continue
            uid=self.create_user(username,'VibeCoding@2026',roles,actor=self.actor('local-example-builder'))
            with self.connect() as db:
                for project in ('erp-demo','wms-demo','equipment-demo','calculator-demo','pdf-demo','webapp-demo'):
                    db.execute('INSERT INTO members VALUES(?,?)',(project,uid))

    def users(self, actor):
        self.admin(actor)
        with self.connect() as db:
            return [dict(x) for x in db.execute('SELECT id,username,roles,enabled FROM users')]