browser-workspace 0.4.0

package/platforms/youtube/actions/_post.py

@@ -0,0 +1,100 @@
+import time, json
+
+CFG = json.load(open("__CFG_PATH__"))
+
+tags = CFG.get("tags", [])
+thumbnail = CFG.get("thumbnail", "")
+has_extras = bool(tags or thumbnail)
+total_steps = 7 + (1 if tags else 0) + (1 if thumbnail else 0)
+step = [0]
+def next_step(label):
+    step[0] += 1
+    print(f"[{step[0]}/{total_steps}] {label}")
+
+def click_btn(text):
+    for _ in range(5):
+        r = js('var btns=document.querySelectorAll("ytcp-button");var b=Array.from(btns).find(function(x){return x.textContent.trim()==="' + text + '"});b?JSON.stringify(b.getBoundingClientRect()):null')
+        if r and r != "None":
+            rect = json.loads(r)
+            click_at_xy(int(rect["x"]+rect["width"]/2), int(rect["y"]+rect["height"]/2))
+            return True
+        time.sleep(1)
+    return False
+
+next_step("Opening YouTube Studio upload...")
+new_tab("https://www.youtube.com/upload")
+wait_for_load()
+time.sleep(3)
+
+url = page_info()["url"]
+if "accounts.google.com" in url:
+    print("ERROR: Not logged in")
+    capture_screenshot()
+    raise SystemExit(1)
+
+next_step("Uploading video...")
+upload_file("input[type=file]", CFG["video"])
+time.sleep(5)
+
+next_step("Waiting for processing...")
+time.sleep(3)
+
+next_step("Setting title: " + CFG["title"])
+title_escaped = json.dumps(CFG["title"])
+js('var b=document.querySelectorAll("#textbox")[0];b.textContent=' + title_escaped + ';b.dispatchEvent(new Event("input",{bubbles:true}));""')
+time.sleep(0.5)
+
+next_step("Setting description...")
+desc_escaped = json.dumps(CFG["desc"])
+js('var b=document.querySelectorAll("#textbox")[1];b.textContent=' + desc_escaped + ';b.dispatchEvent(new Event("input",{bubbles:true}));""')
+time.sleep(0.5)
+
+# Upload thumbnail if provided
+if thumbnail:
+    next_step("Uploading thumbnail...")
+    # Click "Upload thumbnail" button to reveal file input
+    js('var btn=document.querySelector("#still-picker ytcp-button,#upload-prompt");if(btn)btn.click();""')
+    time.sleep(1)
+    upload_file("#file-loader input[type=file],input[accept*=image]", thumbnail)
+    time.sleep(3)
+
+# Add tags via "Show more" → tags input
+if tags:
+    next_step("Adding tags: " + ", ".join(tags))
+    # Expand "Show more" section
+    js('var btn=document.querySelector("#toggle-button ytcp-button,ytcp-button#toggle-button");if(btn)btn.click();""')
+    time.sleep(1)
+    # Find tags input and type comma-separated tags
+    tag_str = ",".join(tags)
+    tag_escaped = json.dumps(tag_str)
+    js('var inp=document.querySelector("input.tags-input,input[aria-label*=Tag],input[placeholder*=Tag]");if(inp){var ns=Object.getOwnPropertyDescriptor(HTMLInputElement.prototype,"value").set;ns.call(inp,' + tag_escaped + ');inp.dispatchEvent(new Event("input",{bubbles:true}));inp.dispatchEvent(new Event("change",{bubbles:true}))};"done"')
+    time.sleep(0.5)
+
+next_step("Setting audience" + (" (MADE FOR KIDS)" if CFG.get("made_for_kids") else "") + " + advancing wizard...")
+if CFG.get("made_for_kids"):
+    # COPPA: select explicitly by name — never rely on radio order
+    js('var r=document.querySelector("tp-yt-paper-radio-button[name=VIDEO_MADE_FOR_KIDS_MFK]");if(r){r.click()}')
+else:
+    js('var g=document.querySelector(".made-for-kids-group");if(g){g.querySelectorAll("tp-yt-paper-radio-button")[1].click()}')
+time.sleep(1)
+
+for w_step in ["Video elements", "Initial check", "Visibility"]:
+    print("  -> " + w_step)
+    click_btn("Next")
+    time.sleep(2)
+
+vis = CFG["vis"]
+next_step("Setting visibility to " + vis + " and saving...")
+for _ in range(5):
+    found = js('document.querySelector("[name=' + vis + ']") ? "found" : "notfound"')
+    if found == "found":
+        js('document.querySelector("[name=' + vis + ']").click()')
+        time.sleep(1)
+        break
+    time.sleep(1)
+
+click_btn("Save")
+time.sleep(5)
+
+capture_screenshot()
+print("Done! Video saved as " + vis + ".")

package/platforms/youtube/manifest.yaml

@@ -0,0 +1,94 @@
+platform: youtube
+status: migrated_unverified
+last_verified: null
+actions:
+  post: actions/_post.py
+verification:
+  status: migrated_unverified
+  last_verified: null
+  evidence: Existing Studio upload mechanics migrated from the working post adapter.
+    Current Browser Workspace live verification pending.
+url_patterns:
+- https://www.youtube.com/upload
+- https://studio.youtube.com/*
+authentication:
+  required: true
+  notes: Use the caller's authenticated browser context; never store credentials.
+provenance:
+  source: skills/post/scripts/platforms/youtube
+  migrated_code: true
+flows:
+  post:
+    status: migrated_unverified
+    evidence: Migrated action; current Browser Workspace live verification pending.
+display_name: YouTube
+aliases:
+- yt
+media:
+  modes:
+  - video
+  video:
+    required: true
+fields:
+  title:
+    cli: --title
+    required: true
+    type: string
+    max_chars: 100
+    implemented: true
+  desc:
+    cli: --desc
+    required: false
+    type: string
+    max_chars: 5000
+    implemented: true
+  tags:
+    cli: --tags
+    required: false
+    type: string_list
+    max_total_chars: 500
+    max_chars_each: 30
+    implemented: true
+  thumbnail:
+    cli: --thumbnail
+    required: false
+    type: file
+    formats:
+    - jpg
+    - png
+    max_size_mb: 2
+    implemented: true
+  visibility:
+    cli_group:
+    - --private
+    - --unlisted
+    - --public
+    required: false
+    type: enum
+    values:
+    - PRIVATE
+    - UNLISTED
+    - PUBLIC
+    default: PRIVATE
+    implemented: true
+  made_for_kids:
+    cli: --made-for-kids
+    required: false
+    type: boolean
+    default: false
+    implemented: true
+capabilities:
+  draft: false
+  publish: true
+  visibility: true
+  custom_thumbnail: true
+  audience_made_for_kids: true
+  post_status: false
+  read_comments: false
+  write_comment: false
+  reply_comments: false
+content_mapping:
+  headline: title
+  main_text: desc
+  discovery_terms: tags
+  visual_packaging: thumbnail

package/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools==84.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "browser-workspace"
+version = "0.4.0"
+description = "Agent browser workspace with persistent Python sessions, tab leasing, snapshots, and platform workflows."
+requires-python = ">=3.11"
+dependencies = [
+  "cdp-use==1.4.5",
+  "fetch-use==0.4.0",
+  "pillow==12.3.0",
+  "PyYAML==6.0.2",
+  "websockets==15.0.1",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+browser_harness = ["video-template.html"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = "--import-mode=importlib"

package/session_client.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+import fcntl, json, os, shutil, socket, subprocess, sys, time
+from pathlib import Path
+
+ROOT=Path(__file__).resolve().parent
+RUNTIME_DIR=Path.home()/'.config/browser-workspace/runtime'
+SOCKET_PATH=(Path(os.environ['BROWSER_WORKSPACE_SESSION_SOCKET']) if os.environ.get('BROWSER_WORKSPACE_TEST_MODE')=='1' and os.environ.get('BROWSER_WORKSPACE_SESSION_SOCKET') else RUNTIME_DIR/'session.sock')
+
+def package_version():
+    try:
+        return json.loads((ROOT/'package.json').read_text()).get('version','dev')
+    except Exception:
+        return 'dev'
+
+def runtime_source():
+    configured=os.environ.get('BROWSER_WORKSPACE_RUNTIME_SOURCE')
+    if configured: return Path(configured)
+    if not (ROOT/'package.json').exists(): return ROOT
+    target=RUNTIME_DIR/'packages'/package_version()
+    marker=target/'.ready'
+    if marker.exists(): return target
+    target.parent.mkdir(parents=True,exist_ok=True)
+    tmp=target.with_name(target.name+'.tmp')
+    shutil.rmtree(tmp,ignore_errors=True)
+    tmp.mkdir(parents=True)
+    for name in ['pyproject.toml','session_daemon.py','session_client.py','platform_runner.py','managed_chrome.py','src','agent-workspace','interaction-skills','platforms','extension','licenses']:
+        source=ROOT/name
+        if not source.exists(): continue
+        destination=tmp/name
+        if source.is_dir(): shutil.copytree(source,destination)
+        else: shutil.copy2(source,destination)
+    (tmp/'.ready').write_text(package_version())
+    shutil.rmtree(target,ignore_errors=True)
+    tmp.rename(target)
+    return target
+
+SOURCE=runtime_source()
+PYTHON=Path(os.environ.get('BROWSER_WORKSPACE_SESSION_PYTHON',RUNTIME_DIR/'venv'/package_version()/'bin/python'))
+
+
+
+def ensure_runtime_python():
+    if PYTHON.exists():
+        return PYTHON
+    RUNTIME_DIR.mkdir(parents=True, exist_ok=True)
+    lock_path=RUNTIME_DIR/'runtime-bootstrap.lock'
+    with open(lock_path,'a+b') as lock:
+        fcntl.flock(lock,fcntl.LOCK_EX)
+        if PYTHON.exists():
+            return PYTHON
+        uv=shutil.which('uv')
+        if uv:
+            subprocess.run([uv,'venv','--python','3.11',str(PYTHON.parent.parent)],check=True)
+            subprocess.run([uv,'pip','install','--python',str(PYTHON),'-e',str(SOURCE)],check=True)
+            return PYTHON
+        if sys.version_info < (3,11):
+            raise RuntimeError(
+                'Browser Workspace needs Python 3.11+ for first-use bootstrap. '
+                'Install uv or Python 3.11+, then retry.'
+            )
+        subprocess.run([sys.executable,'-m','venv',str(PYTHON.parent.parent)],check=True)
+        subprocess.run([str(PYTHON),'-m','pip','install','-e',str(SOURCE)],check=True)
+        return PYTHON
+
+def request(payload, ensure=True):
+    if ensure: ensure_daemon()
+    s=socket.socket(socket.AF_UNIX,socket.SOCK_STREAM)
+    try: s.connect(str(SOCKET_PATH))
+    except Exception:
+        s.close(); raise
+    with s:
+        f=s.makefile('rwb'); f.write((json.dumps(payload,ensure_ascii=False)+'\n').encode()); f.flush(); line=f.readline()
+    if not line: raise RuntimeError('browser-workspace session daemon closed without a response')
+    return json.loads(line)
+
+def ping():
+    try: return request({'op':'ping'},ensure=False)
+    except Exception: return None
+
+def ensure_daemon():
+    p=ping()
+    if p and p.get('ok'): return p
+    RUNTIME_DIR.mkdir(parents=True,exist_ok=True)
+    lock_path=RUNTIME_DIR/'session-daemon.lock'
+    with open(lock_path,'a+b') as lock:
+        fcntl.flock(lock,fcntl.LOCK_EX)
+        p=ping()
+        if p and p.get('ok'): return p
+        runtime_python=ensure_runtime_python()
+        log=open(RUNTIME_DIR/'session-daemon.log','ab',buffering=0)
+        subprocess.Popen([str(runtime_python),str(SOURCE/'session_daemon.py')],stdin=subprocess.DEVNULL,stdout=log,stderr=log,start_new_session=True,close_fds=True)
+        deadline=time.time()+15
+        while time.time()<deadline:
+            time.sleep(.1); p=ping()
+            if p and p.get('ok'): return p
+    raise RuntimeError(f'browser-workspace session daemon did not start; see {RUNTIME_DIR / "session-daemon.log"}')

package/session_daemon.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+import ast, atexit, contextlib, io, json, os, secrets, socket, sys, threading, time, traceback
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT/'src'))
+os.environ.setdefault('BH_HOME', str(Path.home()/'.config/browser-workspace/browser-core'))
+# Preserve the canonical single Browser Harness daemon socket during migration.
+# This is runtime-state compatibility only; Browser Workspace owns the code/venv.
+os.environ.setdefault('BH_RUNTIME_DIR', str(Path.home()/'.config/browser-workspace/browser-core-runtime'))
+os.environ.setdefault('BU_NAME', 'browser-workspace')
+os.environ.setdefault('BH_AGENT_WORKSPACE', str(ROOT/'agent-workspace'))
+os.environ.setdefault('BH_WORKSPACE_NAME', 'Harness')
+
+from managed_chrome import ensure_managed_chrome
+MANAGED_CHROME = ensure_managed_chrome()
+from browser_harness.admin import ensure_daemon
+ensure_daemon()
+from browser_harness import helpers as bh
+
+DEFAULT_WORKSPACE = os.environ.get('BH_WORKSPACE_NAME','Harness')
+RUNTIME_DIR = Path.home()/'.config/browser-workspace/runtime'
+SOCKET_PATH = (Path(os.environ['BROWSER_WORKSPACE_SESSION_SOCKET']) if os.environ.get('BROWSER_WORKSPACE_TEST_MODE')=='1' and os.environ.get('BROWSER_WORKSPACE_SESSION_SOCKET') else RUNTIME_DIR/'session.sock')
+OWNER_LOCK_PATH = RUNTIME_DIR/'session-daemon.owner.lock'
+SESSIONS = {}
+SESSIONS_LOCK = threading.Lock()
+BROWSER_LOCK = threading.RLock()
+
+
+def compilable_module_body(body):
+    """Return a module body that remains valid after trailing-result extraction.
+
+    Submitted sessions commonly contain ordinary imports before a future import.
+    Python accepts that source form, but recompiling an AST after removing the
+    trailing result expression requires future imports to be moved first.
+    """
+    leading = []
+    if body and isinstance(body[0], ast.Expr) and isinstance(body[0].value, ast.Constant) and isinstance(body[0].value.value, str):
+        leading.append(body.pop(0))
+    future = [node for node in body if isinstance(node, ast.ImportFrom) and node.module == '__future__']
+    if not future:
+        return leading + body
+    rest = [node for node in body if node not in future]
+    return leading + future + rest
+
+
+class SessionBrowserProxy:
+    def __init__(self, session): self._session=session
+    def __getattr__(self, name): return getattr(bh, name)
+    def new_tab(self, url='about:blank'): return self._session._new_tab(url)
+    def close_tab(self, target=None): return self._session._close_tab(target)
+    def cdp(self, method, **kwargs): return self._session._cdp(method, **kwargs)
+
+class Session:
+    def __init__(self, sid, workspace, target_id, workspace_supported):
+        self.session_id=sid; self.workspace=workspace; self.target_id=target_id; self.workspace_supported=bool(workspace_supported)
+        self.created_at=time.time(); self.last_used_at=self.created_at
+        self.owned_target_ids={target_id}
+        self.lock=threading.Lock()
+        self.browser=SessionBrowserProxy(self)
+        self.namespace={'__name__':'__browser_workspace_session__','bh':self.browser,'target_id':target_id}
+        for name in dir(bh):
+            if not name.startswith('_'): self.namespace[name]=getattr(bh,name)
+        self.namespace['new_tab']=self._new_tab
+        self.namespace['close_tab']=self._close_tab
+        self.namespace['cdp']=self._cdp
+
+    def _remember_target(self, tid):
+        if tid:
+            self.owned_target_ids.add(tid)
+            self.target_id=tid
+            self.namespace['target_id']=tid
+        return tid
+
+    def _new_tab(self, url='about:blank'):
+        return self._remember_target(bh.new_tab(url))
+
+    def _close_tab(self, target=None):
+        wanted=target
+        if isinstance(wanted, dict): wanted=wanted.get('targetId') or wanted.get('target_id')
+        if wanted is None: wanted=bh.current_tab().get('targetId')
+        result=bh.close_tab(target)
+        if wanted: self.owned_target_ids.discard(wanted)
+        return result
+
+    def _cdp(self, method, **kwargs):
+        result=bh.cdp(method, **kwargs)
+        if method == 'Target.createTarget' and isinstance(result, dict):
+            self._remember_target(result.get('targetId'))
+        elif method == 'Target.closeTarget':
+            self.owned_target_ids.discard(kwargs.get('targetId'))
+        return result
+
+def with_workspace(name, supported=None):
+    class Scope:
+        def __enter__(self):
+            self.name_token=bh.workspace_set_name(name)
+            self.support_token=bh.workspace_set_supported(supported) if supported is not None else None
+            return self
+        def __exit__(self,*_):
+            if self.support_token is not None: bh.workspace_reset_supported(self.support_token)
+            bh.workspace_reset_name(self.name_token)
+    return Scope()
+
+def execute(source, namespace):
+    out,err=io.StringIO(),io.StringIO(); value=None
+    try:
+        tree=ast.parse(source,mode='exec'); body=list(tree.body)
+        tail=body.pop() if body and isinstance(body[-1],ast.Expr) else None
+        body=compilable_module_body(body)
+        with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
+            if body: exec(compile(ast.Module(body=body,type_ignores=[]),'<browser-workspace-session>','exec'),namespace,namespace)
+            if tail is not None:
+                value=eval(compile(ast.Expression(tail.value),'<browser-workspace-session>','eval'),namespace,namespace); namespace['_']=value
+        result={'ok':True,'stdout':out.getvalue(),'stderr':err.getvalue()}
+        if value is not None:
+            try: json.dumps(value); result['value']=value
+            except (TypeError,ValueError): result['value_repr']=repr(value)
+        return result
+    except BaseException as exc:
+        traceback.print_exc(file=err)
+        return {'ok':False,'stdout':out.getvalue(),'stderr':err.getvalue(),'error':f'{type(exc).__name__}: {exc}'}
+
+def start_session(workspace=None, url=None):
+    workspace=(workspace or DEFAULT_WORKSPACE).strip()
+    if not workspace: raise ValueError('workspace must not be empty')
+    sid=secrets.token_hex(8)
+    start_url=(url or 'about:blank').strip()
+    extension=bh.workspace_extension_status()
+    supported=bool(extension.get('supported'))
+    with BROWSER_LOCK, with_workspace(workspace, supported): tid=bh.new_tab(start_url)
+    s=Session(sid,workspace,tid,supported)
+    with SESSIONS_LOCK: SESSIONS[sid]=s
+    result={'session_id':sid,'workspace':workspace,'target_id':tid,'url':start_url,'workspace_supported':supported}
+    if not supported:
+        result['warning']='Browser Workspace extension is not installed; workspace grouping/leases are unavailable. Browser automation will continue without workspace isolation.'
+        result['extension_url']=extension.get('extensionUrl')
+    return result
+
+
+def absorb_owned_children(session):
+    """Adopt popup/child page targets whose opener ancestry belongs to this session."""
+    try:
+        infos=bh.cdp('Target.getTargets').get('targetInfos', [])
+    except Exception:
+        return
+    pages={i.get('targetId'): i for i in infos if i.get('type') == 'page' and i.get('targetId')}
+    changed=True
+    while changed:
+        changed=False
+        for tid, info in pages.items():
+            if tid in session.owned_target_ids:
+                continue
+            opener=info.get('openerId')
+            if opener and opener in session.owned_target_ids:
+                session.owned_target_ids.add(tid)
+                changed=True
+
+def close_owned_tabs(session):
+    """Close/release every live tab owned by the session, children before parents."""
+    absorb_owned_children(session)
+    errors=[]
+    # Close descendants/current tabs first. Repeatedly inspect live targets so already
+    # closed tabs disappear harmlessly and opener relationships remain usable.
+    while session.owned_target_ids:
+        try:
+            infos=bh.cdp('Target.getTargets').get('targetInfos', [])
+        except Exception:
+            infos=[]
+        live={i.get('targetId'): i for i in infos if i.get('type') == 'page' and i.get('targetId')}
+        owned_live=[tid for tid in session.owned_target_ids if tid in live]
+        if not owned_live:
+            session.owned_target_ids.clear()
+            break
+        parent_ids={live[tid].get('openerId') for tid in owned_live}
+        leaves=[tid for tid in owned_live if tid not in parent_ids]
+        targets=leaves or owned_live
+        for tid in targets:
+            try:
+                if session.workspace_supported:
+                    try:
+                        # Workspace-owned session tabs are leases. Release them back
+                        # to the persistent pool instead of destroying the Chrome tab
+                        # group when the final leased tab is stopped. Popup/child
+                        # targets that are outside the workspace are still closed.
+                        bh.close_tab(tid)
+                    except RuntimeError as exc:
+                        if 'outside workspace' not in str(exc):
+                            raise
+                        bh.cdp('Target.closeTarget', targetId=tid)
+                else:
+                    bh.cdp('Target.closeTarget', targetId=tid)
+            except Exception as exc:
+                errors.append(f'{tid}: {type(exc).__name__}: {exc}')
+            finally:
+                session.owned_target_ids.discard(tid)
+    return errors
+
+def get_session(sid):
+    with SESSIONS_LOCK: s=SESSIONS.get(sid)
+    if not s: raise KeyError(f'unknown session_id: {sid}')
+    return s
+
+def exec_session(sid, code):
+    s=get_session(sid)
+    s.last_used_at=time.time()
+    with s.lock, BROWSER_LOCK, with_workspace(s.workspace, s.workspace_supported):
+        bh.switch_tab(s.target_id,activate=False)
+        r=execute(code,s.namespace)
+        absorb_owned_children(s)
+        try:
+            cur=bh.current_tab(); s.target_id=cur.get('targetId') or s.target_id; s.namespace['target_id']=s.target_id
+        except Exception: pass
+    return {'session_id':sid,'workspace':s.workspace,'target_id':s.target_id,**r}
+
+def list_sessions():
+    with SESSIONS_LOCK:
+        sessions=list(SESSIONS.values())
+    return {
+        'session_count': len(sessions),
+        'sessions': [
+            {
+                'session_id': s.session_id,
+                'workspace': s.workspace,
+                'target_id': s.target_id,
+                'created_at': s.created_at,
+                'last_used_at': s.last_used_at,
+            }
+            for s in sessions
+        ],
+    }
+
+def stop_all_sessions():
+    with SESSIONS_LOCK:
+        ids=list(SESSIONS)
+    stopped=[]
+    errors=[]
+    for sid in ids:
+        try:
+            stopped.append(stop_session(sid))
+        except Exception as exc:
+            errors.append({'session_id':sid,'error':f'{type(exc).__name__}: {exc}'})
+    return {'stopped_count':len(stopped),'error_count':len(errors),'stopped':stopped,'errors':errors}
+
+def stop_session(sid):
+    with SESSIONS_LOCK: s=SESSIONS.pop(sid,None)
+    if not s: raise KeyError(f'unknown session_id: {sid}')
+    release_error=None
+    with s.lock, BROWSER_LOCK, with_workspace(s.workspace, s.workspace_supported):
+        absorb_owned_children(s)
+        closed_count=len(s.owned_target_ids)
+        errors=close_owned_tabs(s)
+        if errors: release_error='; '.join(errors)
+    return {'session_id':sid,'workspace':s.workspace,'target_id':s.target_id,'closed_tabs':closed_count,'release_error':release_error}
+
+def cleanup():
+    with SESSIONS_LOCK: ids=list(SESSIONS)
+    for sid in ids:
+        try: stop_session(sid)
+        except Exception: pass
+    try: SOCKET_PATH.unlink(missing_ok=True)
+    except Exception: pass
+atexit.register(cleanup)
+
+def create_workspace(name, pool_size=5):
+    if not isinstance(name, str) or not name.strip():
+        raise ValueError('workspace name must be a non-empty string')
+    size=int(pool_size)
+    if size < 1:
+        raise ValueError('workspace pool size must be at least 1')
+    with BROWSER_LOCK:
+        result=bh.workspace_create(name.strip(), size)
+    return {
+        'name': result.get('name', name.strip()),
+        'poolSize': result.get('poolSize', size),
+        'maxCapacity': result.get('maxCapacity', result.get('poolSize', size)),
+        'initialized': result.get('initialized', True),
+        'workspace_supported': True,
+    }
+
+def delete_workspace(name, force=False):
+    if not isinstance(name, str) or not name.strip():
+        raise ValueError('workspace name must be a non-empty string')
+    with BROWSER_LOCK:
+        return bh.workspace_delete(name.strip(), bool(force))
+
+def handle(req):
+    op=req.get('op')
+    if op=='ping': return {'ok':True,'pid':os.getpid(),'session_count':len(SESSIONS),'managed_chrome':MANAGED_CHROME}
+    if op=='list': return list_sessions()
+    if op=='start': return start_session(req.get('workspace'), req.get('url'))
+    if op=='exec': return exec_session(req['session_id'],req.get('code',''))
+    if op=='stop': return stop_session(req['session_id'])
+    if op=='stop-all': return stop_all_sessions()
+    if op=='workspace-create': return create_workspace(req['name'], req.get('pool_size', 5))
+    if op=='workspace-delete': return delete_workspace(req['name'], req.get('force', False))
+    raise ValueError(f'unknown op: {op}')
+
+def serve_conn(conn):
+    with conn:
+        f=conn.makefile('rwb')
+        line=f.readline()
+        if not line: return
+        try: result=handle(json.loads(line))
+        except Exception as exc: result={'error':f'{type(exc).__name__}: {exc}'}
+        f.write((json.dumps(result,ensure_ascii=False)+'\n').encode()); f.flush()
+
+def main():
+    RUNTIME_DIR.mkdir(parents=True,exist_ok=True)
+    try: os.chmod(RUNTIME_DIR,0o700)
+    except Exception: pass
+    import fcntl
+    owner=open(OWNER_LOCK_PATH,'a+b')
+    try:
+        fcntl.flock(owner,fcntl.LOCK_EX|fcntl.LOCK_NB)
+    except BlockingIOError:
+        owner.close(); return
+    SOCKET_PATH.unlink(missing_ok=True)
+    srv=socket.socket(socket.AF_UNIX,socket.SOCK_STREAM); srv.bind(str(SOCKET_PATH)); os.chmod(SOCKET_PATH,0o600); srv.listen(32)
+    try:
+        while True:
+            conn,_=srv.accept(); threading.Thread(target=serve_conn,args=(conn,),daemon=True).start()
+    finally:
+        srv.close(); owner.close()
+if __name__=='__main__': main()

package/src/browser_harness/__init__.py

@@ -0,0 +1,2 @@
+"""Browser Harness core package."""
+