codex-team 0.1.0__py3-none-any.whl

codex_team/__init__.py

@@ -0,0 +1,4 @@
+"""Codex teams backed by tmux, Git submodules and durable task queues."""
+from .cli import VERSION as __version__
+
+__all__ = ['__version__']

codex_team/__main__.py

@@ -0,0 +1,3 @@
+from .cli import entrypoint
+
+raise SystemExit(entrypoint())

codex_team/cli.py

@@ -0,0 +1,579 @@
+#!/usr/bin/env python3
+"""Local Codex team: tmux display, Git submodules and durable task queues."""
+import argparse
+import contextlib
+import fcntl
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import select
+import shlex
+import shutil
+import sqlite3
+import subprocess
+import sys
+import time
+import uuid
+
+VERSION = '0.1.0'
+
+SLUG = re.compile(r'^[a-zA-Z0-9][a-zA-Z0-9_-]{0,47}$')
+TERMINAL = {'done', 'failed', 'interrupted'}
+
+
+def run(args, **kwargs):
+    return subprocess.run([str(a) for a in args], check=True, text=True, **kwargs)
+
+
+def capture(args):
+    return run(args, stdout=subprocess.PIPE).stdout.strip()
+
+
+def emit(value):
+    print(json.dumps(value, ensure_ascii=False, indent=2), flush=True)
+
+
+def now():
+    return time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
+
+
+class Team:
+    def __init__(self, root):
+        self.root = Path(root).expanduser().resolve()
+        self.state = self.root / '.codex-team'
+        self.config_path = self.state / 'settings.json'
+
+    def settings(self):
+        if not self.config_path.exists():
+            raise ValueError('Time não inicializado. Execute start primeiro.')
+        return json.loads(self.config_path.read_text())
+
+    @contextlib.contextmanager
+    def lock(self, name='topology', nonblocking=False):
+        with (self.state / (name + '.lock')).open('a') as handle:
+            fcntl.flock(handle, fcntl.LOCK_EX | (fcntl.LOCK_NB if nonblocking else 0))
+            yield
+
+    @contextlib.contextmanager
+    def db(self):
+        conn = sqlite3.connect(self.state / 'team.sqlite3', timeout=30)
+        conn.row_factory = sqlite3.Row
+        try:
+            with conn:
+                yield conn
+        finally:
+            conn.close()
+
+    def init(self, session=None, layout='panes'):
+        if self.config_path.exists():
+            return
+        session = session or 'codex-team-' + hashlib.sha256(str(self.root).encode()).hexdigest()[:10]
+        if not SLUG.fullmatch(session):
+            raise ValueError('Nome da sessão inválido. Use letras, números, hífen e sublinhado (até 48 caracteres).')
+        if self.root.exists() and any(self.root.iterdir()):
+            raise ValueError('Use uma pasta nova ou vazia para a raiz do time; nenhum repositório existente será convertido.')
+        self.root.mkdir(parents=True, exist_ok=True)
+        self.state.mkdir(mode=0o700)
+        for directory in ['bin', 'logs', 'results', 'wake']:
+            (self.state / directory).mkdir()
+        run(['git', 'init', self.root], stdout=subprocess.DEVNULL)
+        self.config_path.write_text(json.dumps({'session': session, 'layout': layout, 'stopping': False}))
+        (self.root / '.gitignore').write_text('.codex-team/\n')
+        (self.root / 'repos').mkdir()
+        destination = self.state / 'bin/team.py'
+        shutil.copy2(Path(__file__).resolve(), destination)
+        wrapper = '#!/usr/bin/env bash\nset -euo pipefail\nROOT=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)\nexec python3 "$ROOT/.codex-team/bin/team.py" --root "$ROOT" "$@"\n'
+        (self.root / 'team').write_text(wrapper)
+        (self.root / 'team').chmod(0o755)
+        (self.root / 'AGENTS.md').write_text(CONTROLLER_RULES)
+        (self.root / 'README.md').write_text('# Equipe Codex\n\nLeia AGENTS.md. Use `./team --help` para gerenciar o time.\n'
+            'Os projetos em repos/ são submódulos; não há commits ou pushes automáticos.\n'
+            'O runtime local fica em .codex-team/ (ignorado pelo Git).\n')
+        with self.db() as db:
+            db.executescript('''
+                CREATE TABLE agents(name TEXT PRIMARY KEY, repo TEXT NOT NULL, branch TEXT,
+                    thread TEXT, pane TEXT, status TEXT NOT NULL DEFAULT 'stopped');
+                CREATE TABLE tasks(id TEXT PRIMARY KEY, agent TEXT NOT NULL, message TEXT NOT NULL,
+                    status TEXT NOT NULL, created TEXT NOT NULL, started TEXT, finished TEXT, error TEXT);
+            ''')
+
+    def save_settings(self, data):
+        temp = self.state / 'settings.tmp'
+        temp.write_text(json.dumps(data, indent=2))
+        temp.replace(self.config_path)
+
+    def agent(self, name):
+        with self.db() as db:
+            row = db.execute('SELECT * FROM agents WHERE name=?', (name,)).fetchone()
+        if row is None:
+            raise ValueError(f'Agente desconhecido: {name}')
+        return dict(row)
+
+    def session_alive(self):
+        return subprocess.run(['tmux', 'has-session', '-t', self.settings()['session']],
+                              stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0
+
+    def pane_alive(self, pane):
+        if not pane or not re.fullmatch(r'%\d+', pane):
+            return False
+        result = subprocess.run(['tmux', 'display-message', '-p', '-t', pane,
+                                 '#{pane_dead}'], capture_output=True, text=True)
+        return result.returncode == 0 and result.stdout.strip() == '0'
+
+    def create_controller(self):
+        config = self.settings()
+        alive = self.session_alive()
+        if alive:
+            marker = subprocess.run(['tmux', 'show-options', '-v', '-t', config['session'],
+                                     '@codex-team-root'], capture_output=True, text=True)
+            if marker.stdout.strip() != str(self.root):
+                raise ValueError('O nome da sessão tmux já está em uso por outro time ou processo.')
+        if alive and self.pane_alive(config.get('controller_pane')):
+            return
+        command = shlex.join([sys.executable, str(self.state / 'bin/team.py'),
+                              '--root', str(self.root), '_controller'])
+        if alive:
+            pane = capture(['tmux', 'new-window', '-d', '-P', '-F', '#{pane_id}',
+                            '-t', config['session'] + ':', '-n', 'controlador', '-c', self.root, command])
+        else:
+            pane = capture(['tmux', 'new-session', '-d', '-P', '-F', '#{pane_id}',
+                            '-s', config['session'], '-n', 'equipe', '-c', self.root, command])
+        config['controller_pane'] = pane
+        self.save_settings(config)
+        run(['tmux', 'set-option', '-t', config['session'], '@codex-team-root', str(self.root)])
+        run(['tmux', 'set-option', '-t', config['session'], 'mouse', 'on'])
+        run(['tmux', 'set-option', '-t', config['session'], 'pane-border-status', 'top'])
+        run(['tmux', 'set-option', '-t', config['session'], 'pane-border-format', ' #{pane_title} '])
+        run(['tmux', 'select-pane', '-t', pane, '-T', 'Controlador'])
+
+    def add(self, name, repo, branch=None):
+        validate_agent(name, repo, branch)
+        with self.lock():
+            if self.settings()['stopping']:
+                raise ValueError('O time está parando. Execute start para reabrir a entrada de tarefas.')
+            if not self.session_alive():
+                raise ValueError('Sessão tmux indisponível. Execute start antes de adicionar agentes.')
+            with self.db() as db:
+                old = db.execute('SELECT * FROM agents WHERE name=?', (name,)).fetchone()
+            if old:
+                if old['repo'] != repo or old['branch'] != branch:
+                    raise ValueError('Este nome já está associado a outro repositório ou branch.')
+            else:
+                target = self.root / 'repos' / name
+                if target.exists():
+                    raise ValueError(f'O destino já existe; revise antes de cadastrar: {target}')
+                args = ['git', '-C', str(self.root), 'submodule', 'add']
+                if branch:
+                    args += ['--branch', branch]
+                args += ['--', repo, 'repos/' + name]
+                run(args)
+                with self.db() as db:
+                    db.execute('INSERT INTO agents(name,repo,branch) VALUES(?,?,?)', (name, repo, branch))
+            self.launch_worker(name)
+        return self.agent(name)
+
+    def launch_worker(self, name):
+        row = self.agent(name)
+        if self.pane_alive(row['pane']):
+            # A pane id can be reused by a fresh server; verify its identity too.
+            result = subprocess.run(['tmux', 'show-options', '-p', '-v', '-t', row['pane'],
+                                     '@codex-team-agent'], capture_output=True, text=True)
+            marker = result.stdout.strip()
+            if marker == str(self.root) + ':' + name:
+                return
+        fifo = self.state / 'wake' / name
+        if not fifo.exists():
+            os.mkfifo(fifo, mode=0o600)
+        config = self.settings()
+        command = shlex.join([sys.executable, str(self.state / 'bin/team.py'), '--root', str(self.root), '_worker', name])
+        if config['layout'] == 'panes':
+            args = ['tmux', 'split-window', '-d', '-P', '-F', '#{pane_id}',
+                    '-t', config['controller_pane'], '-c', self.root / 'repos' / name, command]
+            result = subprocess.run([str(a) for a in args], capture_output=True, text=True)
+        else:
+            result = None
+        if result is None or result.returncode:
+            pane = capture(['tmux', 'new-window', '-d', '-P', '-F', '#{pane_id}',
+                            '-t', config['session'] + ':', '-n', name, '-c', self.root / 'repos' / name, command])
+        else:
+            pane = result.stdout.strip()
+            run(['tmux', 'select-layout', '-t', config['controller_pane'], 'tiled'], stdout=subprocess.DEVNULL)
+        run(['tmux', 'select-pane', '-t', pane, '-T', name])
+        run(['tmux', 'set-option', '-p', '-t', pane, '@codex-team-agent', str(self.root) + ':' + name])
+        with self.db() as db:
+            db.execute('UPDATE agents SET pane=? WHERE name=?', (pane, name))
+
+    def wake(self, name):
+        try:
+            fd = os.open(self.state / 'wake' / name, os.O_WRONLY | os.O_NONBLOCK)
+        except OSError:
+            return
+        try:
+            os.write(fd, b'!')
+        finally:
+            os.close(fd)
+
+    def enqueue(self, name, message):
+        if not message.strip():
+            raise ValueError('A tarefa não pode ser vazia.')
+        with self.lock():
+            if self.settings()['stopping']:
+                raise ValueError('Time em encerramento; novas tarefas não são aceitas.')
+            row = self.agent(name)
+            if not self.session_alive() or not self.pane_alive(row['pane']):
+                raise ValueError('O agente não está aberto. Execute start para restaurar os painéis.')
+            task_id = uuid.uuid4().hex
+            with self.db() as db:
+                db.execute('INSERT INTO tasks(id,agent,message,status,created) VALUES(?,?,?,?,?)',
+                           (task_id, name, message, 'queued', now()))
+        self.wake(name)
+        return task_id
+
+    def task(self, task_id):
+        with self.db() as db:
+            row = db.execute('SELECT * FROM tasks WHERE id=?', (task_id,)).fetchone()
+        if row is None:
+            raise ValueError('Tarefa desconhecida: ' + task_id)
+        result = dict(row)
+        output = self.state / 'results' / (task_id + '.md')
+        result['result_file'] = str(output)
+        if output.exists():
+            result['result'] = output.read_text()
+        return result
+
+    def snapshot(self):
+        with self.db() as db:
+            agents = [dict(row) for row in db.execute('SELECT * FROM agents ORDER BY name')]
+            tasks = [dict(row) for row in db.execute('SELECT id,agent,status,created,error FROM tasks ORDER BY created,rowid')]
+        for agent in agents:
+            agent['pane_alive'] = self.pane_alive(agent['pane'])
+        return {'root': str(self.root), 'session': self.settings()['session'],
+                'stopping': self.settings()['stopping'], 'agents': agents, 'tasks': tasks}
+
+    def worker(self, name):
+        # Lock spans the complete worker lifetime: one executor per repository.
+        with self.lock('worker-' + name, nonblocking=True):
+            fd = os.open(self.state / 'wake' / name, os.O_RDWR | os.O_NONBLOCK)
+            try:
+                with self.db() as db:
+                    db.execute("UPDATE tasks SET status='interrupted',finished=?,error=? WHERE agent=? AND status='running'",
+                               (now(), 'Executor anterior terminou sem confirmar o resultado. Revise os arquivos antes de reenviar.', name))
+                    db.execute("UPDATE agents SET status='idle' WHERE name=?", (name,))
+                print(f'Agente {name}: responsável por {self.root / "repos" / name}. Aguardando tarefas.', flush=True)
+                while True:
+                    with self.lock():
+                        if self.settings()['stopping']:
+                            break
+                        with self.db() as db:
+                            db.execute('BEGIN IMMEDIATE')
+                            task = db.execute("SELECT * FROM tasks WHERE agent=? AND status='queued' ORDER BY rowid LIMIT 1", (name,)).fetchone()
+                            if task:
+                                db.execute("UPDATE tasks SET status='running',started=? WHERE id=?", (now(), task['id']))
+                                db.execute("UPDATE agents SET status='running' WHERE name=?", (name,))
+                    if task:
+                        self.execute(name, dict(task))
+                        print(f'Agente {name}: aguardando tarefas.', flush=True)
+                    else:
+                        # FIFO blocks while idle; timeout only checks unexpected session shutdown.
+                        ready, _, _ = select.select([fd], [], [], 30)
+                        if ready:
+                            os.read(fd, 4096)
+            finally:
+                os.close(fd)
+                with self.db() as db:
+                    db.execute("UPDATE agents SET status='stopped' WHERE name=?", (name,))
+
+    def execute(self, name, task):
+        row = self.agent(name)
+        result_path = self.state / 'results' / (task['id'] + '.md')
+        log_path = self.state / 'logs' / (task['id'] + '.jsonl')
+        error = None
+        thread = row['thread']
+        command = ['codex', '--sandbox', 'workspace-write', '--ask-for-approval', 'never',
+                   '-C', str(self.root / 'repos' / name), 'exec', '--json', '-o', str(result_path)]
+        if thread:
+            command += ['resume', thread]
+        command += ['-']
+        prompt = (f'Você é o responsável pelo repositório {name}, no diretório atual. '
+                  'Siga o AGENTS.md aplicável e as regras específicas do repositório. '
+                  'Trabalhe apenas neste submódulo. Não edite o Git raiz, outros repositórios, '
+                  'nem execute deploy, push ou operações destrutivas sem autorização explícita na tarefa. '
+                  'Execute a tarefa e termine relatando alterações, validações e impedimentos. '
+                  'Se uma ação depender de permissão indisponível, registre o bloqueio sem contornar o sandbox.\n\n'
+                  f'Tarefa {task["id"]}:\n{task["message"]}')
+        print(f'\n▶ Tarefa {task["id"]}\n{task["message"]}\n', flush=True)
+        completed = False
+        try:
+            with log_path.open('w') as log:
+                process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                           stderr=log, text=True, cwd=self.root / 'repos' / name)
+                process.stdin.write(prompt)
+                process.stdin.close()
+                for line in process.stdout:
+                    log.write(line)
+                    log.flush()
+                    try:
+                        event = json.loads(line)
+                    except ValueError:
+                        continue
+                    if event.get('type') == 'thread.started':
+                        with self.db() as db:
+                            db.execute('UPDATE agents SET thread=? WHERE name=?', (event['thread_id'], name))
+                    elif event.get('type') == 'turn.completed':
+                        completed = True
+                    elif event.get('type') in ('turn.failed', 'error'):
+                        error = json.dumps(event, ensure_ascii=False)
+                    elif event.get('type') in ('item.started', 'item.completed'):
+                        item = event.get('item', {})
+                        if item.get('type') == 'agent_message':
+                            print(item.get('text', ''), flush=True)
+                        elif item.get('type') == 'command_execution':
+                            print('$ ' + item.get('command', ''), flush=True)
+                            if item.get('aggregated_output'):
+                                print(item['aggregated_output'], flush=True)
+                        else:
+                            print('• ' + item.get('type', 'evento'), flush=True)
+                code = process.wait()
+                if code or not completed or not result_path.exists():
+                    error = error or f'Codex terminou com código {code}; conclusão ou resultado ausente. Consulte {log_path}.'
+        except (OSError, KeyError) as exc:
+            error = str(exc)
+        status = 'failed' if error else 'done'
+        with self.db() as db:
+            db.execute('UPDATE tasks SET status=?,finished=?,error=? WHERE id=?', (status, now(), error, task['id']))
+            db.execute("UPDATE agents SET status='idle' WHERE name=?", (name,))
+        print(f'\n■ {task["id"]}: {status}' + (f' — {error}' if error else ''), flush=True)
+
+    def stop(self, timeout):
+        with self.lock():
+            config = self.settings()
+            config['stopping'] = True
+            self.save_settings(config)
+        with self.db() as db:
+            names = [row['name'] for row in db.execute('SELECT name FROM agents')]
+        for name in names:
+            self.wake(name)
+        deadline = time.monotonic() + timeout
+        while True:
+            busy = []
+            for name in names:
+                try:
+                    with self.lock('worker-' + name, nonblocking=True):
+                        pass
+                except BlockingIOError:
+                    busy.append(name)
+            if not busy:
+                break
+            if time.monotonic() >= deadline:
+                emit({'stopping': True, 'waiting_for': busy,
+                      'message': 'Nenhum processo foi forçado a parar. Aguarde e execute stop novamente.'})
+                return 2
+            time.sleep(.25)
+        # Workers that were killed externally may have left a running marker.
+        with self.db() as db:
+            db.execute("UPDATE tasks SET status='interrupted',finished=?,error=? WHERE status='running'",
+                       (now(), 'Executor encerrado sem confirmação; revise antes de reenviar.'))
+            db.execute("UPDATE agents SET status='stopped'")
+        emit({'stopped': True, 'message': 'Responsáveis encerrados. Tarefas pendentes preservadas. '
+              'O controlador e a sessão tmux continuam abertos; encerre-os quando o controlador estiver ocioso.'})
+        return 0
+
+
+CONTROLLER_RULES = '''# Equipe Codex — instruções de coordenação
+
+Na raiz você é o controlador. Os projetos em repos/ são submódulos Git e têm
+responsáveis próprios. Dentro de cada submódulo, atue como responsável daquele
+projeto, respeitando suas instruções locais e o escopo da tarefa recebida.
+
+## Comandos do controlador (execute a partir da raiz)
+
+- `./team add --name NOME --repo URL [--branch BRANCH]`: cadastra um submódulo
+  e abre um responsável. Use nomes únicos com letras, números, hífen ou sublinhado.
+- `./team task NOME --message 'TAREFA'`: devolve um identificador de tarefa.
+  Para texto longo use `--file caminho`; o conteúdo é lido literalmente.
+- `./team status`: consulta agentes e tarefas em JSON.
+- `./team wait ID [ID ...] --timeout 50`: aguarda resultados (retorna 2 se ainda
+  estiverem pendentes). Continue aguardando enquanto houver trabalho necessário.
+- `./team result ID`: lê resultado, erro e estado. Não trate failed/interrupted
+  como sucesso, nem done como prova de testes aprovados: leia o relatório.
+- `./team stop --timeout 50`: impede novas tarefas e deixa a atual terminar;
+  preserva pendentes e não interrompe processos à força.
+
+## Fluxo
+
+Ao receber um pedido, defina contratos e dependências, distribua tarefas com
+critérios de aceitação e acompanhe até concluir ou registrar um bloqueio real.
+Os responsáveis ficam ociosos sem chamadas ao modelo e só executam tarefas da
+fila. Recebem as instruções de papel na primeira tarefa e reutilizam sua sessão.
+O controlador deve usar wait/result para receber conclusões: não há mensagem
+espontânea para reativar um controlador que já encerrou sua resposta.
+Só o controlador altera arquivos da raiz e coordena atualizações dos gitlinks.
+Não faça commits, pushes, deploys ou ações destrutivas sem autorização do usuário.
+Não altere simultaneamente um submódulo que já possui tarefa em execução.
+Não acrescente outros worktrees ou clones em repos/: todos os projetos devem
+ser submódulos. Consulte git status na raiz e nos submódulos antes da integração.
+O histórico e resultados locais ficam em .codex-team/ e não são versionados.
+Quando o usuário pedir um novo responsável, use add com o nome e URL informados,
+sem pedir que ele abra um terminal manualmente. Permissões do sandbox continuam
+válidas; registre ou solicite a permissão necessária quando um comando for negado.
+'''
+
+
+def validate_agent(name, repo, branch=None):
+    if not SLUG.fullmatch(name) or name.lower() in {'controlador', 'controller', 'chefe'}:
+        raise ValueError('Nome de agente inválido ou reservado (até 48 caracteres).')
+    if not isinstance(repo, str) or not repo or repo.startswith('-') or any(c in repo for c in '\n\r\x00'):
+        raise ValueError('URL de repositório inválida.')
+    if re.match(r'https?://[^/]*@', repo):
+        raise ValueError('Não inclua credenciais na URL; use o login Git/SSH da máquina.')
+    if branch is not None and (not isinstance(branch, str) or not branch or branch.startswith('-')
+                               or subprocess.run(['git', 'check-ref-format', '--branch', branch],
+                                                 capture_output=True).returncode):
+        raise ValueError('Branch inválida.')
+
+
+def load_agents(filename):
+    value = json.loads(Path(filename).read_text())
+    agents = value.get('agents') if isinstance(value, dict) else value
+    if not isinstance(agents, list):
+        raise ValueError('O config precisa conter {"agents": [{"name": ..., "repo": ...}]}.')
+    names = set()
+    for item in agents:
+        if not isinstance(item, dict) or not isinstance(item.get('name'), str):
+            raise ValueError('Cada agente precisa de name e repo.')
+        validate_agent(item['name'], item.get('repo'), item.get('branch'))
+        if item['name'].lower() in names:
+            raise ValueError('Nome duplicado no config: ' + item['name'])
+        names.add(item['name'].lower())
+    return agents
+
+
+def parser():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--version', action='version', version='codex-team ' + VERSION)
+    p.add_argument('--root', default='codex-team', help='Raiz própria do time (padrão: ./codex-team)')
+    subs = p.add_subparsers(dest='command', required=True)
+    start = subs.add_parser('start', help='Inicializa ou retoma o time')
+    start.add_argument('--root', default=argparse.SUPPRESS, help='Raiz própria do time (padrão: ./codex-team)')
+    start.add_argument('--version', action='version', version='codex-team ' + VERSION)
+    start.add_argument('--agents', help='JSON de agentes; usa ./config.json se existir')
+    start.add_argument('--session')
+    start.add_argument('--layout', choices=['panes', 'windows'], default='panes')
+    start.add_argument('--no-attach', action='store_true')
+    add = subs.add_parser('add', help='Adiciona um responsável/submódulo')
+    add.add_argument('--name', required=True)
+    add.add_argument('--repo', required=True)
+    add.add_argument('--branch')
+    task = subs.add_parser('task', help='Enfileira uma tarefa para um responsável')
+    task.add_argument('name')
+    messages = task.add_mutually_exclusive_group(required=True)
+    messages.add_argument('--message')
+    messages.add_argument('--file', type=Path)
+    subs.add_parser('example-config', help='Imprime um JSON de exemplo (substitua as URLs)')
+    subs.add_parser('status')
+    result = subs.add_parser('result')
+    result.add_argument('task_id')
+    wait = subs.add_parser('wait')
+    wait.add_argument('task_ids', nargs='+')
+    wait.add_argument('--timeout', type=float, default=50)
+    stop = subs.add_parser('stop')
+    stop.add_argument('--timeout', type=float, default=50)
+    subs.add_parser('attach')
+    subs.add_parser('_controller', help=argparse.SUPPRESS)
+    worker = subs.add_parser('_worker', help=argparse.SUPPRESS)
+    worker.add_argument('name')
+    return p
+
+
+def attach(team):
+    if not team.session_alive():
+        raise ValueError('Sessão tmux indisponível. Execute start.')
+    if os.environ.get('TMUX'):
+        run(['tmux', 'switch-client', '-t', team.settings()['session']])
+    else:
+        os.execvp('tmux', ['tmux', 'attach-session', '-t', team.settings()['session']])
+
+
+def main(argv=None):
+    args = parser().parse_args(argv)
+    if args.command == 'example-config':
+        emit({'agents': [
+            {'name': 'publicapi', 'repo': 'git@github.com:SUA_ORGANIZACAO/publicapi.git'},
+            {'name': 'anunciantes', 'repo': 'git@github.com:SUA_ORGANIZACAO/flutter_anunciantes.git'},
+            {'name': 'parceiros', 'repo': 'git@github.com:SUA_ORGANIZACAO/flutter_parceiros.git'},
+        ]})
+        return 0
+    team = Team(args.root)
+    if args.command == 'start':
+        for cmd in ('git', 'tmux', 'codex'):
+            if not shutil.which(cmd):
+                raise ValueError('Comando necessário não encontrado: ' + cmd)
+        filename = args.agents or ('config.json' if Path('config.json').is_file() else None)
+        agents = load_agents(filename) if filename else []
+        team.init(args.session, args.layout)
+        with team.lock():
+            config = team.settings()
+            config['stopping'] = False
+            team.save_settings(config)
+            team.create_controller()
+        for item in agents:
+            team.add(item['name'], item['repo'], item.get('branch'))
+        with team.lock():
+            with team.db() as db:
+                names = [row['name'] for row in db.execute('SELECT name FROM agents')]
+            for name in names:
+                team.launch_worker(name)
+        emit({'root': str(team.root), 'session': team.settings()['session'], 'agents': names})
+        if not args.no_attach:
+            attach(team)
+    elif args.command == '_controller':
+        # Interactive TUI remains available for the user's instructions.
+        command = ['codex', '--sandbox', 'workspace-write', '--ask-for-approval', 'on-request',
+                   '-C', str(team.root), 'Você é o controlador deste time. Leia AGENTS.md, '
+                   'consulte ./team status e aguarde o pedido do usuário. Gerencie os responsáveis usando ./team.']
+        os.execvp(command[0], command)
+    elif args.command == '_worker':
+        team.worker(args.name)
+    elif args.command == 'add':
+        emit(team.add(args.name, args.repo, args.branch))
+    elif args.command == 'task':
+        message = args.file.read_text() if args.file else args.message
+        emit({'task_id': team.enqueue(args.name, message)})
+    elif args.command == 'status':
+        emit(team.snapshot())
+    elif args.command == 'result':
+        emit(team.task(args.task_id))
+    elif args.command == 'wait':
+        deadline = time.monotonic() + max(0, min(args.timeout, 3600))
+        while True:
+            tasks = [team.task(task_id) for task_id in args.task_ids]
+            if all(task['status'] in TERMINAL for task in tasks):
+                emit(tasks)
+                return 1 if any(task['status'] != 'done' for task in tasks) else 0
+            if time.monotonic() >= deadline:
+                emit(tasks)
+                return 2
+            time.sleep(.25)
+    elif args.command == 'stop':
+        return team.stop(max(0, args.timeout))
+    elif args.command == 'attach':
+        attach(team)
+    return 0
+
+
+def entrypoint(argv=None):
+    try:
+        return main(argv)
+    except (ValueError, OSError, subprocess.CalledProcessError, sqlite3.Error) as exc:
+        print('Erro: ' + str(exc), file=sys.stderr)
+        return 1
+
+
+def start_entrypoint():
+    return entrypoint(['start', *sys.argv[1:]])
+
+
+if __name__ == '__main__':
+    sys.exit(entrypoint())

codex_team-0.1.0.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: codex-team
+Version: 0.1.0
+Summary: Orchestrate local Codex agents with tmux, Git submodules, and persistent task queues.
+Author: PixPool
+Keywords: codex,tmux,agents,orchestration,git,submodules
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Codex Team
+
+Linux, Python 3.10+, Git, tmux e Codex CLI autenticado. Compatibilidade conferida
+com Codex CLI 0.163.0 e tmux 3.3a. Usa a autenticação e o modelo configurados no
+Codex local; não instala SDK nem exige uma chave de API separada.
+
+## Instalar pelo pip
+
+```bash
+python3 -m pip install codex-team
+```
+
+Em um Python gerenciado pelo sistema operacional, use um ambiente virtual ou
+`pipx install codex-team`. Git, tmux e Codex CLI são dependências externas
+que precisam estar no PATH. Nenhuma biblioteca Python adicional é necessária.
+
+```bash
+codex-team --version
+codex-team example-config > config.json
+# Edite config.json para informar os repositórios reais.
+start-git-codex-team --root /caminho/novo-time --agents config.json
+```
+
+O comando completo equivalente é:
+
+```bash
+codex-team start --root /caminho/novo-time --agents config.json
+```
+
+Também funciona como módulo: `python3 -m codex_team --help`.
+Depois da criação, use `./team` dentro da pasta do time para adicionar agentes,
+enviar tarefas e consultar resultados. Fora dela, use por exemplo
+`codex-team --root /caminho/novo-time status`.
+
+## Iniciar a partir deste checkout
+
+Copie `config.example.json` para um `config.json` e substitua as URLs pelos
+repositórios reais. Repositórios privados precisam de acesso Git/SSH na máquina.
+Não inclua tokens ou senhas nas URLs.
+
+```bash
+./ops/start-git-codex-team.sh --root /caminho/novo-time --agents /caminho/config.json
+```
+
+O diretório passado em `--root` precisa estar vazio ou já
+pertencer a este gerenciador. Por padrão a raiz é `./codex-team`; sem `--agents`,
+carrega `./config.json` se existir. Sem JSON, inicia apenas o controlador.
+Também aceita uma lista JSON diretamente, além do objeto com a chave `agents`.
+Cada agente exige `name` e `repo`; `branch` é opcional (branch existente no remoto).
+
+Use `--no-attach` para iniciar sem anexar o terminal. O layout padrão usa painéis
+lado a lado; `--layout windows` cria uma janela por agente. Quando não há espaço
+para mais divisões, um novo agente ganha uma janela própria. Escolha o layout na
+primeira inicialização. A sessão tem nome derivado da pasta; `--session equipe-x`
+permite escolher o nome na primeira inicialização. Não reutilize o mesmo nome
+para times diferentes.
+
+A raiz passa a ter:
+
+```text
+novo-time/
+├── .git/                   # Repositório Git raiz, sem commit automático
+├── .gitmodules             # Projetos registrados como submódulos
+├── AGENTS.md               # Instruções do controlador
+├── README.md
+├── team                    # Gerenciador local, executável
+├── repos/
+│   ├── publicapi/          # Submódulo Git
+│   └── parceiros/          # Submódulo Git
+└── .codex-team/             # Banco, filas, sessões e resultados locais
+```
+
+`git submodule add` deixa `.gitmodules` e os gitlinks no índice. O gerenciador não
+faz commit nem push na raiz ou nos projetos. A raiz ainda não possui remoto;
+configure um se quiser compartilhar a composição do time. O runtime é local e
+ignorado pelo Git; os arquivos versionados sozinhos não reinstalam o gerenciador
+em outra máquina. Preserve essa pasta para retomar este time.
+
+## Conversar com o controlador
+
+O painel Controlador é uma sessão interativa do Codex. Você pode pedir:
+
+> Adicione um responsável chamado pagamentos para o repositório
+> git@github.com:empresa/pagamentos.git e aguarde as tarefas.
+
+O AGENTS.md instrui o chefe a executar:
+
+```bash
+./team add --name pagamentos --repo git@github.com:empresa/pagamentos.git
+```
+
+O novo projeto é cadastrado como submódulo e seu painel é aberto. Um responsável
+inicialmente fica ocioso; não há chamada ao modelo para apenas aguardar. Ao
+receber uma tarefa, o executor chama `codex exec --json`, registra seu thread ID e
+reutiliza a conversa usando `codex exec resume` nas tarefas seguintes.
+
+Os painéis dos responsáveis mostram mensagens, comandos e resultados da
+execução. São consoles do executor, não TUIs interativas do Codex. Envie tarefas
+pelo controlador ou pelo comando abaixo, sem digitar no painel do responsável.
+
+```bash
+cd /caminho/novo-time
+./team task publicapi --message 'Implemente o endpoint X e valide os testes.'
+./team task parceiros --file /caminho/tarefa.txt
+./team status
+./team wait ID_DA_TAREFA --timeout 50
+./team result ID_DA_TAREFA
+```
+
+`wait` retorna 0 se todas terminaram com sucesso de execução, 1 se alguma falhou
+ou foi interrompida, e 2 se ainda há pendentes. Leia o relatório para conferir
+se os critérios de aceitação e os testes passaram; `done` indica que a chamada
+Codex terminou normalmente, não substitui revisão. Não há dependências implícitas
+na fila: o chefe deve esperar a API antes de enviar uma integração dependente.
+Cada responsável executa uma tarefa por vez; repositórios diferentes trabalham
+em paralelo. Uma tarefa interrompida é marcada e não é reenviada automaticamente.
+
+A fila usa SQLite e a espera ociosa dos responsáveis usa FIFO. Resultados ficam
+em `.codex-team/results/ID.md`, logs em `.codex-team/logs/ID.jsonl`. Esses arquivos
+podem conter conteúdo do projeto; não os publique inadvertidamente.
+
+O chefe deve chamar `wait`/`result` enquanto acompanha um pedido. O gerenciador
+não reativa espontaneamente um controlador que já encerrou sua resposta.
+Ele pode distribuir várias tarefas e aguardar resultados na mesma conversa.
+
+## Permissões e escopo
+
+O controlador usa `workspace-write` com aprovação `on-request`. Git remoto, tmux
+ou ações fora do sandbox podem exigir aprovação conforme sua instalação. Os
+responsáveis usam `workspace-write` e aprovação `never`: se uma ação não for
+permitida, devem relatar o impedimento ao chefe. O gerenciador não usa bypass de
+sandbox nem executa comandos recebidos por interpolação de shell.
+
+A tarefa instrui cada responsável a alterar apenas seu submódulo. Isso é uma
+regra de coordenação, não um isolamento de leitura ou segurança entre processos
+que compartilham o mesmo usuário Linux. Instruções locais do repositório e
+configurações do Codex continuam aplicáveis.
+
+## Sair, parar e retomar
+
+- Desconectar mantendo o trabalho: `Ctrl+B`, depois `D`.
+- Voltar: `./team attach` na raiz do time.
+- Parar os responsáveis com segurança, em outro terminal:
+
+```bash
+cd /caminho/novo-time
+./team stop --timeout 50
+```
+
+`stop` fecha a entrada de tarefas. A tarefa atual de cada responsável pode
+terminar, mas as pendentes ficam preservadas. Se o prazo expirar, retorna 2 e
+não força a interrupção. Execute `stop` novamente depois. O controlador e a
+sessão tmux permanecem abertos. Quando ele estiver ocioso e os responsáveis
+parados, encerre a sessão usando o nome mostrado em `./team status`:
+
+```bash
+tmux kill-session -t NOME_DA_SESSAO
+```
+
+Para reabrir o time, reaproveite a mesma raiz:
+
+```bash
+./ops/start-git-codex-team.sh --root /caminho/novo-time
+```
+
+Isso restaura os painéis ausentes, as filas e os IDs das conversas dos
+responsáveis. Tarefas pendentes voltam a ser executadas. Se um controlador foi
+fechado, abre uma conversa nova que consulta o estado persistido; a conversa
+interativa anterior pode ser retomada manualmente pelo Codex. Nenhum arquivo
+modificado ou commit dos submódulos é descartado.
+
+## Validação
+
+```bash
+python3 -m unittest discover -s ops/codex-team -p 'test_*.py' -v
+```
+
+Os testes usam repositórios Git locais, servidor tmux isolado e um executável
+Codex simulado. Não fazem chamadas ao modelo, não clonam projetos reais e não
+alteram o servidor tmux do usuário.
+
+Referência: [execução não interativa do Codex](https://developers.openai.com/codex/noninteractive).
+
+## Desenvolvimento e build
+
+```bash
+cd ops/codex-team
+python3 -m pip install -e .
+python3 -m pip install build twine
+python3 -m build
+python3 -m twine check dist/*
+```
+
+A distribuição inclui somente o gerenciador, a documentação e os exemplos;
+nenhum repositório de trabalho, fila, credencial ou configuração de usuário é
+incluído nos artefatos. A versão inicial é 0.1.0 (alpha). A implementação usa
+tmux; GNU screen não é um backend suportado por este pacote.

codex_team-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+codex_team/__init__.py,sha256=jWP8Lp1qNj01zb-UoB535MAOOVv_fGi3xs7RatklI90,141
+codex_team/__main__.py,sha256=PIJIOolexzGnrOJz3yXWQZ6eCKD9h2LLAao-qtQ8HYE,60
+codex_team/cli.py,sha256=AiZDuDyByyb5hx5r-S5b_x71nZSXMlLj8DAPhqrv094,28889
+codex_team-0.1.0.dist-info/METADATA,sha256=vkma9v3iamzYbApZbut1p2fFacgPxapl0qLxSGh96to,8928
+codex_team-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+codex_team-0.1.0.dist-info/entry_points.txt,sha256=l97m-HSFmjMzd5l4Djb4h-zEYLBkMM08hzvIgBgSlfQ,112
+codex_team-0.1.0.dist-info/top_level.txt,sha256=9-CdtNoAAQJ590wambLcCn_5kyLdc9wkvs5x7pFeyQA,11
+codex_team-0.1.0.dist-info/RECORD,,

codex_team-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codex_team-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+codex-team = codex_team.cli:entrypoint
+start-git-codex-team = codex_team.cli:start_entrypoint

codex_team-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codex_team