webhelm 1.0.14 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webhelm",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Agent browser automation in a visible managed Chrome with persistent JavaScript sessions",
   "type": "module",
   "bin": {

package/runtime/cli.mjs

@@ -75,6 +75,7 @@ async function runPlatform(args) {
   const config = loadConfig(args);
   const mode = validateMode(platform, action, args, config);
   const sid = arg(args, '--session-id');
+  if (sid) await requireCliSession(sid);
   const auto = has(args, '--auto-session');
   validateConfig(platform, action, config);
   if (sid && auto) throw Error('--session-id and --auto-session are mutually exclusive');
@@ -94,7 +95,6 @@ async function runPlatform(args) {
     };
   }
   if (mode === 'sync' && (!sid || auto)) throw Error('sync new-turn requires a caller-owned --session-id');
-  if (sid) await requireCliSession(sid);
   if (!sid && !auto) throw Error('platform run requires --session-id; use --auto-session only for one-shot actions');
   return request({op:'platform-run', platform, action, config: {...config, ...(mode ? {mode} : {})},
     session_id:sid, auto_session:auto, url:arg(args, '--url'), workspace:CLI_WORKSPACE});
@@ -119,6 +119,7 @@ async function requireCliSession(sessionId) {
 async function main(args = process.argv.slice(2)) {
   const [group, command] = args;
   if (!group || ['--help', '-h', 'help'].includes(group) || has(args, '--help') || has(args, '-h')) return help();
+  rejectWorkspaceOverride(args);
   if (group === 'migrate') {
     await ensureActions(); // ~/.local/webhelm is the Actions Git checkout, never create an empty replacement.
     const legacy=await migrateConfig();
@@ -135,7 +136,20 @@ async function main(args = process.argv.slice(2)) {
     const login_guard=installLoginGuard({cliPath,nodePath:process.execPath,sourceMode});
     return emit({status:'ready',...repo,daemon_pid:chrome.pid,managed_chrome:chrome.managed_chrome,login_guard});
   }
-  if (group === 'ensure') return emit(await request({op:'guard-check'}));
+  if (group === 'ensure') {
+    try { return emit(await request({op:'guard-check'})); }
+    catch(error) {
+      // An older, still-busy daemon can hold the same socket during a
+      // rolling source upgrade. Preserve its Sessions; never hot-swap it.
+      if (!String(error.message).includes('unknown op: guard-check')) throw error;
+      const legacy=await request({op:'ping'});
+      if (legacy.session_count>0)
+        return emit({ok:true,deferred_upgrade:true,reason:'legacy_daemon_has_active_sessions',
+          session_count:legacy.session_count,daemon_version:legacy.version||'unknown',
+          chrome_health:'not_verified'});
+      throw Error('Legacy WebHelm daemon lacks health guard; drain and migrate it before activating the new source Runtime');
+    }
+  }
   if (group === 'status') {
     const daemon = await ensureDaemon();
     return emit({version:daemon.version, platform_dir:PLATFORMS, root:ROOT,
@@ -152,7 +166,6 @@ async function main(args = process.argv.slice(2)) {
     return emit(await request(payload));
   }
   if (group === 'session') {
-    rejectWorkspaceOverride(args);
     if (command === 'start') return emit(await request({op:'start', workspace:CLI_WORKSPACE, url:arg(args,'--url')}));
     if (command === 'list') {
       const result=await request({op:'list'});

package/runtime/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "WebHelm",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "Own named Chrome tab-group workspaces and lazy reusable tab pools for browser agents.",
   "permissions": [
     "storage",

package/runtime/extension/service-worker.mjs

@@ -102,6 +102,8 @@ globalThis.browserWorkspaceManagerRpc = async (request) => {
 const APPLICATION_ONLY_METHODS = new Set([
   "workspace.create", "workspace.resize", "workspace.delete",
   "workspace.ensure", "workspace.migrateDefault",
+  "workspace.acquire", "workspace.acquireIdentity",
+  "workspace.release", "workspace.releaseAll",
 ]);
 chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
   if (APPLICATION_ONLY_METHODS.has(request?.method)) {

package/runtime/extension/workspace-manager.mjs

@@ -552,9 +552,12 @@ export class WorkspaceManager {
     const normalizedName = normalizeWorkspaceName(name);
     // Leasing may allocate a Tab inside an existing Workspace, but must never
     // provision a new Workspace as a side effect. Only app-owned creation can.
-    const ready = await this.status(normalizedName);
-    if (!ready.initialized)
+    const { entry } = await this.configuredWorkspace(normalizedName);
+    if (!entry)
       throw new Error(`Workspace ${normalizedName} does not exist; an application must provision it first`);
+    // Previously provisioned workspaces may restore a missing physical group
+    // from their durable configuration; this never creates a new name.
+    const ready = await this.ensureWorkspace(normalizedName);
     const tabs = await this.groupTabs(ready.groupId);
     const { idle, leased } = this.classify(normalizedName, tabs);
     if (!idle.length && leased.length >= ready.poolSize) {
@@ -597,9 +600,12 @@ export class WorkspaceManager {
 
     // Leasing may allocate a Tab inside an existing Workspace, but must never
     // provision a new Workspace as a side effect. Only app-owned creation can.
-    const ready = await this.status(normalizedName);
-    if (!ready.initialized)
+    const { entry } = await this.configuredWorkspace(normalizedName);
+    if (!entry)
       throw new Error(`Workspace ${normalizedName} does not exist; an application must provision it first`);
+    // Previously provisioned workspaces may restore a missing physical group
+    // from their durable configuration; this never creates a new name.
+    const ready = await this.ensureWorkspace(normalizedName);
     const tabs = await this.groupTabs(ready.groupId);
     const { idle, leased } = this.classify(normalizedName, tabs);
     if (!idle.length && leased.length >= ready.poolSize) {

package/runtime/node-daemon.mjs

@@ -312,36 +312,48 @@ async function extensionCallSerialized(_session,method,args={}) {
       `globalThis.browserWorkspaceManagerRpc(${request})`);
     }catch(error){debuggerSession=null;throw error;}
   }
-  const page=targetInfos.find(t=>t.type==='page'&&t.url.startsWith(EXTENSION_PREFIX)&&(t.url.includes('/workspace.html')||t.url.includes('/helm.html')));
-  if(page){
-    const {sessionId}=await browser.send('Target.attachToTarget',{targetId:page.targetId,flatten:true});
-    try{return await evaluateExtension(browser,sessionId,`chrome.runtime.sendMessage(${request})`);}
-    finally{await browser.send('Target.detachFromTarget',{sessionId}).catch(()=>{});}
-  }
-  if(!extensionConfigured())throw Error('WebHelm workspace extension is not installed or enabled');
-  // Wake a suspended MV3 worker from a temporary background extension page.
-  // Only this temporary target is closed; no user tab is reused or modified.
-  const {targetId}=await browser.send('Target.createTarget',{
-    url:`${EXTENSION_PREFIX}helm.html?webhelm_wakeup=1`,background:true});
-  let sessionId;
-  try{
-    ({sessionId}=await browser.send('Target.attachToTarget',{targetId,flatten:true}));
-    let ready=false;
+  // Pages (including an agent-opened extension page) cannot mutate groups.
+  // Wake the MV3 worker using a read-only message, then invoke the actual
+  // operation directly in the worker over daemon-owned CDP.
+  const page=targetInfos.find(t=>t.type==='page'&&t.url.startsWith(EXTENSION_PREFIX)&&
+    (t.url.includes('/workspace.html')||t.url.includes('/helm.html')));
+  if(!page && !extensionConfigured())
+    throw Error('WebHelm workspace extension is not installed or enabled');
+  const wakeTarget=page?.targetId||(await browser.send('Target.createTarget',{
+    url:`${EXTENSION_PREFIX}helm.html?webhelm_wakeup=1`,background:true})).targetId;
+  const temporary=!page;
+  let wakeSession;
+  try {
+    ({sessionId:wakeSession}=await browser.send('Target.attachToTarget',{targetId:wakeTarget,flatten:true}));
+    let awake=false;
     for(let attempt=0;attempt<20;attempt++){
       try{
-        const reply=await browser.send('Runtime.evaluate',{
-          expression:`typeof chrome!=='undefined'&&chrome.runtime?.id===${JSON.stringify(EXTENSION_ID)}`,
-          returnByValue:true},sessionId);
-        if(reply.result?.value===true){ready=true;break;}
-      }catch{}
-      await delay(100);
+        await evaluateExtension(browser,wakeSession,
+          'chrome.runtime.sendMessage({method:"workspace.list"})');
+        awake=true;break;
+      }catch(error){
+        if(attempt===19)throw error;
+        await delay(100);
+      }
+    }
+    if(!awake)throw Error('WebHelm Extension did not awaken');
+  } finally {
+    if(wakeSession)await browser.send('Target.detachFromTarget',{sessionId:wakeSession}).catch(()=>{});
+    if(temporary)await browser.send('Target.closeTarget',{targetId:wakeTarget}).catch(()=>{});
+  }
+  for(let attempt=0;attempt<30;attempt++){
+    const {targetInfos:updated=[]}=await browser.send('Target.getTargets');
+    const active=updated.find(t=>t.type==='service_worker'&&t.url.startsWith(EXTENSION_PREFIX));
+    if(active){
+      const {sessionId}=await browser.send('Target.attachToTarget',{targetId:active.targetId,flatten:true});
+      debuggerSession={targetId:active.targetId,sessionId};
+      try{return await evaluateExtension(browser,sessionId,
+        `globalThis.browserWorkspaceManagerRpc(${request})`);}
+      catch(error){debuggerSession=null;throw error;}
     }
-    if(!ready)throw Error('WebHelm installed extension did not initialize its background page');
-    return await evaluateExtension(browser,sessionId,`chrome.runtime.sendMessage(${request})`);
-  }finally{
-    if(sessionId)await browser.send('Target.detachFromTarget',{sessionId}).catch(()=>{});
-    await browser.send('Target.closeTarget',{targetId}).catch(()=>{});
+    await delay(100);
   }
+  throw Error('WebHelm Extension Service Worker did not become available after wake');
 }
 
 function jsonSafe(value){try{JSON.stringify(value);return {value}}catch{return {value_repr:String(value)}}}