Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

8.3 KB
Raw Blame
#!/usr/bin/env python3
"""Prepare the pinned upstream ARM agent without npm or install-time scripts."""
import argparse
import hashlib
import json
from pathlib import Path, PurePosixPath
import re
import shutil
import struct
import tarfile
import tempfile
import urllib.request


ROOT = Path(__file__).resolve().parents[2]
LOCK = ROOT / 'os/packaging/fedora/opencode.lock.json'


def digest(path):
    with path.open('rb') as handle:
        return hashlib.file_digest(handle, 'sha256').hexdigest()


def read_lock(path=LOCK):
    info = json.loads(path.read_text())
    if (info.get('schema'), info.get('name'), info.get('architecture'), info.get('license')) != (
            1, 'OpenCode', 'aarch64', 'MIT') or not re.fullmatch(r'\d+\.\d+\.\d+', str(info.get('version'))):
        raise ValueError('Use a versioned OpenCode ARM lock.')
    if set(info.get('archives', {})) != {'binary', 'license'} or set(info.get('files', {})) != {'opencode', 'LICENSE'}:
        raise ValueError('Agent lock must include the binary and its license.')
    for key, package in [('binary', 'opencode-linux-arm64'), ('license', 'opencode-ai')]:
        entry = info['archives'][key]
        url = f'https://registry.npmjs.org/{package}/-/{package}-{info["version"]}.tgz'
        if entry.get('package') != package or entry.get('url') != url:
            raise ValueError('Use the pinned upstream npm package URL.')
    for entry in [*info['archives'].values(), *info['files'].values()]:
        if (type(entry.get('bytes')) is not int or not 0 < entry['bytes'] <= 300 * 1024**2 or
                not re.fullmatch(r'[a-f0-9]{64}', str(entry.get('sha256')))):
            raise ValueError('Every agent input needs a bounded size and SHA-256.')
    for name, archive, member in [('opencode', 'binary', 'package/bin/opencode'), ('LICENSE', 'license', 'package/LICENSE')]:
        if (info['files'][name].get('archive'), info['files'][name].get('member')) != (archive, member):
            raise ValueError('Unexpected upstream agent member.')
    return info


def verify(path, entry):
    if (path.is_symlink() or not path.is_file() or path.stat().st_size != entry['bytes'] or
            digest(path) != entry['sha256']):
        raise ValueError('Agent checksum mismatch: ' + str(path))


def check_elf(path):
    with path.open('rb') as handle:
        header = handle.read(64)
        if (len(header) != 64 or header[:7] != b'\x7fELF\x02\x01\x01' or
                struct.unpack_from('<H', header, 16)[0] not in (2, 3) or
                struct.unpack_from('<H', header, 18)[0] != 183):
            raise ValueError('OpenCode must be a little-endian ARM64 ELF executable.')
        offset = struct.unpack_from('<Q', header, 32)[0]
        size, count = struct.unpack_from('<HH', header, 54)
        if size != 56 or not 0 < count <= 256 or offset + size * count > path.stat().st_size:
            raise ValueError('Invalid agent ELF program headers.')
        handle.seek(offset)
        entries = [struct.unpack('<IIQQQQQQ', handle.read(size)) for _ in range(count)]
        loads = [entry for entry in entries if entry[0] == 1]
        if not loads or any(entry[7] < 16384 or entry[7] & (entry[7] - 1) or
                            entry[2] % 16384 != entry[3] % 16384 for entry in loads):
            raise ValueError('OpenCode must support 16 KiB ARM pages.')


def archive_members(archive):
    members = {}
    for member in archive.getmembers():
        path = PurePosixPath(member.name)
        if (not member.isfile() or path.is_absolute() or '..' in path.parts or
                str(path) != member.name or not member.name.startswith('package/') or member.name in members):
            raise ValueError('Unsafe or duplicate agent archive member: ' + member.name)
        members[member.name] = member
    return members


def prepare(lock, archives, output):
    if output.exists() or output.is_symlink():
        raise ValueError('Agent output must be a new directory.')
    archives.mkdir(parents=True, exist_ok=True)
    output.parent.mkdir(parents=True, exist_ok=True)
    # Do not expose a partly prepared payload after a download or checksum failure.
    with tempfile.TemporaryDirectory(prefix='.opencode-', dir=output.parent) as temp:
        payload = Path(temp) / 'payload'
        payload.mkdir()
        for key, entry in lock['archives'].items():
            path = archives / (entry['package'] + '-' + lock['version'] + '.tgz')
            if not path.exists() and not path.is_symlink():
                partial = Path(temp) / (key + '.download')
                with urllib.request.urlopen(entry['url'], timeout=30) as response, partial.open('xb') as handle:
                    remaining = entry['bytes'] + 1
                    while remaining:
                        chunk = response.read(min(1024 * 1024, remaining))
                        if not chunk:
                            break
                        handle.write(chunk)
                        remaining -= len(chunk)
                verify(partial, entry)
                partial.replace(path)
            verify(path, entry)
            with tarfile.open(path, 'r:gz') as archive:
                members = archive_members(archive)
                metadata = members.get('package/package.json')
                if metadata is None or metadata.size > 65536:
                    raise ValueError('Missing agent package metadata.')
                package = json.load(archive.extractfile(metadata))
                if (package.get('name'), package.get('version')) != (entry['package'], lock['version']):
                    raise ValueError('Agent package metadata does not match its lock.')
                if key == 'binary' and (package.get('os'), package.get('cpu')) != (['linux'], ['arm64']):
                    raise ValueError('Unexpected agent platform metadata.')
                if key == 'license' and (package.get('license') != 'MIT' or
                        package.get('optionalDependencies', {}).get('opencode-linux-arm64') != lock['version']):
                    raise ValueError('Agent license or binary dependency does not match.')
                for name, file in lock['files'].items():
                    if file['archive'] != key:
                        continue
                    member = members.get(file['member'])
                    if member is None or member.size != file['bytes']:
                        raise ValueError('Missing or wrong-size agent payload: ' + name)
                    with archive.extractfile(member) as src, (payload / name).open('xb') as dest:
                        shutil.copyfileobj(src, dest)
                    verify(payload / name, file)
                    (payload / name).chmod(0o755 if name == 'opencode' else 0o644)
        check_elf(payload / 'opencode')
        (payload / 'manifest.json').write_text(json.dumps(lock, indent=2) + '\n')
        payload.rename(output)


def identity(folder, lock):
    manifest = folder / 'manifest.json'
    if manifest.is_symlink() or not manifest.is_file() or json.loads(manifest.read_text()) != lock:
        raise ValueError('Agent provenance does not match the reviewed lock.')
    for name, entry in lock['files'].items():
        verify(folder / name, entry)
    check_elf(folder / 'opencode')
    return lock


def stage(folder, destination, lock):
    identity(folder, lock)
    for name, target in [('opencode', 'usr/lib/harness-opencode/opencode'),
                         ('LICENSE', 'usr/share/licenses/harness-opencode/LICENSE'),
                         ('manifest.json', 'usr/share/harness-os/opencode.json')]:
        path = destination / target
        path.parent.mkdir(parents=True, exist_ok=True)
        shutil.copyfile(folder / name, path)
        path.chmod(0o755 if name == 'opencode' else 0o644)
    link = destination / 'usr/bin/opencode'
    link.parent.mkdir(parents=True, exist_ok=True)
    link.symlink_to('../lib/harness-opencode/opencode')
    return lock


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--archives', type=Path, required=True, help='Reusable verified archive cache.')
    parser.add_argument('--output', type=Path, required=True)
    args = parser.parse_args()
    lock = read_lock()
    prepare(lock, args.archives.resolve(), args.output.absolute())
    print(json.dumps({'version': lock['version'], 'architecture': lock['architecture'],
                      'binary_sha256': lock['files']['opencode']['sha256']}))


if __name__ == '__main__':
    main()