npm - @hellcoder/companion - Versions diffs - 0.113.2 → 0.113.3 - Mend

@hellcoder/companion 0.113.2 → 0.113.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

package/dist/assets/{sw-register-U38bnRB2.js → sw-register-B9GK06Mo.js} RENAMED Viewed

	@@ -1 +1 @@
1	- import{_ as u}from"./index-~~Ck0r9rSX~~.js";function w(r={}){const{immediate:i=!1,onNeedReload:d,onNeedRefresh:_,onOfflineReady:s,onRegistered:n,onRegisteredSW:o,onRegisterError:t}=r;let a,c;const l=async(e=!0)=>{await c};async function f(){if("serviceWorker"in navigator){if(a=await u(async()=>{const{Workbox:e}=await import("./workbox-window.prod.es5-BBnX5xw4.js");return{Workbox:e}},[]).then(({Workbox:e})=>new e("/sw.js",{scope:"/",type:"classic"})).catch(e=>{t==null\|\|t(e)}),!a)return;a.addEventListener("activated",e=>{(e.isUpdate\|\|e.isExternal)&&(d?d():window.location.reload())}),a.addEventListener("installed",e=>{e.isUpdate\|\|s==null\|\|s()}),a.register({immediate:i}).then(e=>{o?o("/sw.js",e):n==null\|\|n(e)}).catch(e=>{t==null\|\|t(e)})}}return c=f(),l}w({onRegisteredSW(r,i){i&&setInterval(()=>{i.update()},3600*1e3)},onOfflineReady(){console.log("[SW] Offline-ready: all assets precached")}});
1	+ import{_ as u}from"./index-B1Oejky6.js";function w(r={}){const{immediate:i=!1,onNeedReload:d,onNeedRefresh:_,onOfflineReady:s,onRegistered:n,onRegisteredSW:o,onRegisterError:t}=r;let a,c;const l=async(e=!0)=>{await c};async function f(){if("serviceWorker"in navigator){if(a=await u(async()=>{const{Workbox:e}=await import("./workbox-window.prod.es5-BBnX5xw4.js");return{Workbox:e}},[]).then(({Workbox:e})=>new e("/sw.js",{scope:"/",type:"classic"})).catch(e=>{t==null\|\|t(e)}),!a)return;a.addEventListener("activated",e=>{(e.isUpdate\|\|e.isExternal)&&(d?d():window.location.reload())}),a.addEventListener("installed",e=>{e.isUpdate\|\|s==null\|\|s()}),a.register({immediate:i}).then(e=>{o?o("/sw.js",e):n==null\|\|n(e)}).catch(e=>{t==null\|\|t(e)})}}return c=f(),l}w({onRegisteredSW(r,i){i&&setInterval(()=>{i.update()},3600*1e3)},onOfflineReady(){console.log("[SW] Offline-ready: all assets precached")}});

package/dist/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
     <meta name="apple-mobile-web-app-title" content="Companion ME" />
     <meta name="theme-color" content="#d97757" />
     <title>The Companion — Moritz Edition</title>
-    <script type="module" crossorigin src="/assets/index-Ck0r9rSX.js"></script>
+    <script type="module" crossorigin src="/assets/index-B1Oejky6.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C86AT0KJ.css">
   </head>
   <body class="bg-cc-bg text-cc-fg">

package/dist/sw.js CHANGED Viewed

@@ -1,2 +1,2 @@
 try{self["workbox:core:7.4.0"]&&_()}catch{}const x=(a,...e)=>{let t=a;return e.length>0&&(t+=` :: ${JSON.stringify(e)}`),t},N=x;class l extends Error{constructor(e,t){const s=N(e,t);super(s),this.name=e,this.details=t}}const E=new Set,f={googleAnalytics:"googleAnalytics",precache:"precache-v2",prefix:"workbox",runtime:"runtime",suffix:typeof registration<"u"?registration.scope:""},b=a=>[f.prefix,a,f.suffix].filter(e=>e&&e.length>0).join("-"),O=a=>{for(const e of Object.keys(f))a(e)},C={updateDetails:a=>{O(e=>{typeof a[e]=="string"&&(f[e]=a[e])})},getGoogleAnalyticsName:a=>a||b(f.googleAnalytics),getPrecacheName:a=>a||b(f.precache),getPrefix:()=>f.prefix,getRuntimeName:a=>a||b(f.runtime),getSuffix:()=>f.suffix};function P(a,e){const t=new URL(a);for(const s of e)t.searchParams.delete(s);return t.href}async function I(a,e,t,s){const n=P(e.url,t);if(e.url===n)return a.match(e,s);const r=Object.assign(Object.assign({},s),{ignoreSearch:!0}),c=await a.keys(e,r);for(const i of c){const o=P(i.url,t);if(n===o)return a.match(i,s)}}let y;function M(){if(y===void 0){const a=new Response("");if("body"in a)try{new Response(a.body),y=!0}catch{y=!1}y=!1}return y}class D{constructor(){this.promise=new Promise((e,t)=>{this.resolve=e,this.reject=t})}}async function S(){for(const a of E)await a()}const W=a=>new URL(String(a),location.href).href.replace(new RegExp(`^${location.origin}`),"");function A(a){return new Promise(e=>setTimeout(e,a))}function K(a,e){const t=e();return a.waitUntil(t),t}async function q(a,e){let t=null;if(a.url&&(t=new URL(a.url).origin),t!==self.location.origin)throw new l("cross-origin-copy-response",{origin:t});const s=a.clone(),r={headers:new Headers(s.headers),status:s.status,statusText:s.statusText},c=M()?s.body:await s.blob();return new Response(c,r)}function j(){self.addEventListener("activate",()=>self.clients.claim())}try{self["workbox:precaching:7.4.0"]&&_()}catch{}const H="__WB_REVISION__";function F(a){if(!a)throw new l("add-to-cache-list-unexpected-type",{entry:a});if(typeof a=="string"){const r=new URL(a,location.href);return{cacheKey:r.href,url:r.href}}const{revision:e,url:t}=a;if(!t)throw new l("add-to-cache-list-unexpected-type",{entry:a});if(!e){const r=new URL(t,location.href);return{cacheKey:r.href,url:r.href}}const s=new URL(t,location.href),n=new URL(t,location.href);return s.searchParams.set(H,e),{cacheKey:s.href,url:n.href}}class B{constructor(){this.updatedURLs=[],this.notUpdatedURLs=[],this.handlerWillStart=async({request:e,state:t})=>{t&&(t.originalRequest=e)},this.cachedResponseWillBeUsed=async({event:e,state:t,cachedResponse:s})=>{if(e.type==="install"&&t&&t.originalRequest&&t.originalRequest instanceof Request){const n=t.originalRequest.url;s?this.notUpdatedURLs.push(n):this.updatedURLs.push(n)}return s}}}class ${constructor({precacheController:e}){this.cacheKeyWillBeUsed=async({request:t,params:s})=>{const n=(s==null?void 0:s.cacheKey)||this._precacheController.getCacheKeyForURL(t.url);return n?new Request(n,{headers:t.headers}):t},this._precacheController=e}}try{self["workbox:strategies:7.4.0"]&&_()}catch{}function m(a){return typeof a=="string"?new Request(a):a}class G{constructor(e,t){this._cacheKeys={},Object.assign(this,t),this.event=t.event,this._strategy=e,this._handlerDeferred=new D,this._extendLifetimePromises=[],this._plugins=[...e.plugins],this._pluginStateMap=new Map;for(const s of this._plugins)this._pluginStateMap.set(s,{});this.event.waitUntil(this._handlerDeferred.promise)}async fetch(e){const{event:t}=this;let s=m(e);if(s.mode==="navigate"&&t instanceof FetchEvent&&t.preloadResponse){const c=await t.preloadResponse;if(c)return c}const n=this.hasCallback("fetchDidFail")?s.clone():null;try{for(const c of this.iterateCallbacks("requestWillFetch"))s=await c({request:s.clone(),event:t})}catch(c){if(c instanceof Error)throw new l("plugin-error-request-will-fetch",{thrownErrorMessage:c.message})}const r=s.clone();try{let c;c=await fetch(s,s.mode==="navigate"?void 0:this._strategy.fetchOptions);for(const i of this.iterateCallbacks("fetchDidSucceed"))c=await i({event:t,request:r,response:c});return c}catch(c){throw n&&await this.runCallbacks("fetchDidFail",{error:c,event:t,originalRequest:n.clone(),request:r.clone()}),c}}async fetchAndCachePut(e){const t=await this.fetch(e),s=t.clone();return this.waitUntil(this.cachePut(e,s)),t}async cacheMatch(e){const t=m(e);let s;const{cacheName:n,matchOptions:r}=this._strategy,c=await this.getCacheKey(t,"read"),i=Object.assign(Object.assign({},r),{cacheName:n});s=await caches.match(c,i);for(const o of this.iterateCallbacks("cachedResponseWillBeUsed"))s=await o({cacheName:n,matchOptions:r,cachedResponse:s,request:c,event:this.event})||void 0;return s}async cachePut(e,t){const s=m(e);await A(0);const n=await this.getCacheKey(s,"write");if(!t)throw new l("cache-put-with-no-response",{url:W(n.url)});const r=await this._ensureResponseSafeToCache(t);if(!r)return!1;const{cacheName:c,matchOptions:i}=this._strategy,o=await self.caches.open(c),h=this.hasCallback("cacheDidUpdate"),p=h?await I(o,n.clone(),["__WB_REVISION__"],i):null;try{await o.put(n,h?r.clone():r)}catch(u){if(u instanceof Error)throw u.name==="QuotaExceededError"&&await S(),u}for(const u of this.iterateCallbacks("cacheDidUpdate"))await u({cacheName:c,oldResponse:p,newResponse:r.clone(),request:n,event:this.event});return!0}async getCacheKey(e,t){const s=`${e.url} | ${t}`;if(!this._cacheKeys[s]){let n=e;for(const r of this.iterateCallbacks("cacheKeyWillBeUsed"))n=m(await r({mode:t,request:n,event:this.event,params:this.params}));this._cacheKeys[s]=n}return this._cacheKeys[s]}hasCallback(e){for(const t of this._strategy.plugins)if(e in t)return!0;return!1}async runCallbacks(e,t){for(const s of this.iterateCallbacks(e))await s(t)}*iterateCallbacks(e){for(const t of this._strategy.plugins)if(typeof t[e]=="function"){const s=this._pluginStateMap.get(t);yield r=>{const c=Object.assign(Object.assign({},r),{state:s});return t[e](c)}}}waitUntil(e){return this._extendLifetimePromises.push(e),e}async doneWaiting(){for(;this._extendLifetimePromises.length;){const e=this._extendLifetimePromises.splice(0),s=(await Promise.allSettled(e)).find(n=>n.status==="rejected");if(s)throw s.reason}}destroy(){this._handlerDeferred.resolve(null)}async _ensureResponseSafeToCache(e){let t=e,s=!1;for(const n of this.iterateCallbacks("cacheWillUpdate"))if(t=await n({request:this.request,response:t,event:this.event})||void 0,s=!0,!t)break;return s||t&&t.status!==200&&(t=void 0),t}}class V{constructor(e={}){this.cacheName=C.getRuntimeName(e.cacheName),this.plugins=e.plugins||[],this.fetchOptions=e.fetchOptions,this.matchOptions=e.matchOptions}handle(e){const[t]=this.handleAll(e);return t}handleAll(e){e instanceof FetchEvent&&(e={event:e,request:e.request});const t=e.event,s=typeof e.request=="string"?new Request(e.request):e.request,n="params"in e?e.params:void 0,r=new G(this,{event:t,request:s,params:n}),c=this._getResponse(r,s,t),i=this._awaitComplete(c,r,s,t);return[c,i]}async _getResponse(e,t,s){await e.runCallbacks("handlerWillStart",{event:s,request:t});let n;try{if(n=await this._handle(t,e),!n||n.type==="error")throw new l("no-response",{url:t.url})}catch(r){if(r instanceof Error){for(const c of e.iterateCallbacks("handlerDidError"))if(n=await c({error:r,event:s,request:t}),n)break}if(!n)throw r}for(const r of e.iterateCallbacks("handlerWillRespond"))n=await r({event:s,request:t,response:n});return n}async _awaitComplete(e,t,s,n){let r,c;try{r=await e}catch{}try{await t.runCallbacks("handlerDidRespond",{event:n,request:s,response:r}),await t.doneWaiting()}catch(i){i instanceof Error&&(c=i)}if(await t.runCallbacks("handlerDidComplete",{event:n,request:s,response:r,error:c}),t.destroy(),c)throw c}}class d extends V{constructor(e={}){e.cacheName=C.getPrecacheName(e.cacheName),super(e),this._fallbackToNetwork=e.fallbackToNetwork!==!1,this.plugins.push(d.copyRedirectedCacheableResponsesPlugin)}async _handle(e,t){const s=await t.cacheMatch(e);return s||(t.event&&t.event.type==="install"?await this._handleInstall(e,t):await this._handleFetch(e,t))}async _handleFetch(e,t){let s;const n=t.params||{};if(this._fallbackToNetwork){const r=n.integrity,c=e.integrity,i=!c||c===r;s=await t.fetch(new Request(e,{integrity:e.mode!=="no-cors"?c||r:void 0})),r&&i&&e.mode!=="no-cors"&&(this._useDefaultCacheabilityPluginIfNeeded(),await t.cachePut(e,s.clone()))}else throw new l("missing-precache-entry",{cacheName:this.cacheName,url:e.url});return s}async _handleInstall(e,t){this._useDefaultCacheabilityPluginIfNeeded();const s=await t.fetch(e);if(!await t.cachePut(e,s.clone()))throw new l("bad-precaching-response",{url:e.url,status:s.status});return s}_useDefaultCacheabilityPluginIfNeeded(){let e=null,t=0;for(const[s,n]of this.plugins.entries())n!==d.copyRedirectedCacheableResponsesPlugin&&(n===d.defaultPrecacheCacheabilityPlugin&&(e=s),n.cacheWillUpdate&&t++);t===0?this.plugins.push(d.defaultPrecacheCacheabilityPlugin):t>1&&e!==null&&this.plugins.splice(e,1)}}d.defaultPrecacheCacheabilityPlugin={async cacheWillUpdate({response:a}){return!a||a.status>=400?null:a}};d.copyRedirectedCacheableResponsesPlugin={async cacheWillUpdate({response:a}){return a.redirected?await q(a):a}};class Q{constructor({cacheName:e,plugins:t=[],fallbackToNetwork:s=!0}={}){this._urlsToCacheKeys=new Map,this._urlsToCacheModes=new Map,this._cacheKeysToIntegrities=new Map,this._strategy=new d({cacheName:C.getPrecacheName(e),plugins:[...t,new $({precacheController:this})],fallbackToNetwork:s}),this.install=this.install.bind(this),this.activate=this.activate.bind(this)}get strategy(){return this._strategy}precache(e){this.addToCacheList(e),this._installAndActiveListenersAdded||(self.addEventListener("install",this.install),self.addEventListener("activate",this.activate),this._installAndActiveListenersAdded=!0)}addToCacheList(e){const t=[];for(const s of e){typeof s=="string"?t.push(s):s&&s.revision===void 0&&t.push(s.url);const{cacheKey:n,url:r}=F(s),c=typeof s!="string"&&s.revision?"reload":"default";if(this._urlsToCacheKeys.has(r)&&this._urlsToCacheKeys.get(r)!==n)throw new l("add-to-cache-list-conflicting-entries",{firstEntry:this._urlsToCacheKeys.get(r),secondEntry:n});if(typeof s!="string"&&s.integrity){if(this._cacheKeysToIntegrities.has(n)&&this._cacheKeysToIntegrities.get(n)!==s.integrity)throw new l("add-to-cache-list-conflicting-integrities",{url:r});this._cacheKeysToIntegrities.set(n,s.integrity)}if(this._urlsToCacheKeys.set(r,n),this._urlsToCacheModes.set(r,c),t.length>0){const i=`Workbox is precaching URLs without revision info: ${t.join(", ")}
-This is generally NOT safe. Learn more at https://bit.ly/wb-precache`;console.warn(i)}}}install(e){return K(e,async()=>{const t=new B;this.strategy.plugins.push(t);for(const[r,c]of this._urlsToCacheKeys){const i=this._cacheKeysToIntegrities.get(c),o=this._urlsToCacheModes.get(r),h=new Request(r,{integrity:i,cache:o,credentials:"same-origin"});await Promise.all(this.strategy.handleAll({params:{cacheKey:c},request:h,event:e}))}const{updatedURLs:s,notUpdatedURLs:n}=t;return{updatedURLs:s,notUpdatedURLs:n}})}activate(e){return K(e,async()=>{const t=await self.caches.open(this.strategy.cacheName),s=await t.keys(),n=new Set(this._urlsToCacheKeys.values()),r=[];for(const c of s)n.has(c.url)||(await t.delete(c),r.push(c.url));return{deletedURLs:r}})}getURLsToCacheKeys(){return this._urlsToCacheKeys}getCachedURLs(){return[...this._urlsToCacheKeys.keys()]}getCacheKeyForURL(e){const t=new URL(e,location.href);return this._urlsToCacheKeys.get(t.href)}getIntegrityForCacheKey(e){return this._cacheKeysToIntegrities.get(e)}async matchPrecache(e){const t=e instanceof Request?e.url:e,s=this.getCacheKeyForURL(t);if(s)return(await self.caches.open(this.strategy.cacheName)).match(s)}createHandlerBoundToURL(e){const t=this.getCacheKeyForURL(e);if(!t)throw new l("non-precached-url",{url:e});return s=>(s.request=new Request(e),s.params=Object.assign({cacheKey:t},s.params),this.strategy.handle(s))}}let U;const L=()=>(U||(U=new Q),U);try{self["workbox:routing:7.4.0"]&&_()}catch{}const v="GET",R=a=>a&&typeof a=="object"?a:{handle:a};class g{constructor(e,t,s=v){this.handler=R(t),this.match=e,this.method=s}setCatchHandler(e){this.catchHandler=R(e)}}class z extends g{constructor(e,t,s){const n=({url:r})=>{const c=e.exec(r.href);if(c&&!(r.origin!==location.origin&&c.index!==0))return c.slice(1)};super(n,t,s)}}class J{constructor(){this._routes=new Map,this._defaultHandlerMap=new Map}get routes(){return this._routes}addFetchListener(){self.addEventListener("fetch",(e=>{const{request:t}=e,s=this.handleRequest({request:t,event:e});s&&e.respondWith(s)}))}addCacheListener(){self.addEventListener("message",(e=>{if(e.data&&e.data.type==="CACHE_URLS"){const{payload:t}=e.data,s=Promise.all(t.urlsToCache.map(n=>{typeof n=="string"&&(n=[n]);const r=new Request(...n);return this.handleRequest({request:r,event:e})}));e.waitUntil(s),e.ports&&e.ports[0]&&s.then(()=>e.ports[0].postMessage(!0))}}))}handleRequest({request:e,event:t}){const s=new URL(e.url,location.href);if(!s.protocol.startsWith("http"))return;const n=s.origin===location.origin,{params:r,route:c}=this.findMatchingRoute({event:t,request:e,sameOrigin:n,url:s});let i=c&&c.handler;const o=e.method;if(!i&&this._defaultHandlerMap.has(o)&&(i=this._defaultHandlerMap.get(o)),!i)return;let h;try{h=i.handle({url:s,request:e,event:t,params:r})}catch(u){h=Promise.reject(u)}const p=c&&c.catchHandler;return h instanceof Promise&&(this._catchHandler||p)&&(h=h.catch(async u=>{if(p)try{return await p.handle({url:s,request:e,event:t,params:r})}catch(k){k instanceof Error&&(u=k)}if(this._catchHandler)return this._catchHandler.handle({url:s,request:e,event:t});throw u})),h}findMatchingRoute({url:e,sameOrigin:t,request:s,event:n}){const r=this._routes.get(s.method)||[];for(const c of r){let i;const o=c.match({url:e,sameOrigin:t,request:s,event:n});if(o)return i=o,(Array.isArray(i)&&i.length===0||o.constructor===Object&&Object.keys(o).length===0||typeof o=="boolean")&&(i=void 0),{route:c,params:i}}return{}}setDefaultHandler(e,t=v){this._defaultHandlerMap.set(t,R(e))}setCatchHandler(e){this._catchHandler=R(e)}registerRoute(e){this._routes.has(e.method)||this._routes.set(e.method,[]),this._routes.get(e.method).push(e)}unregisterRoute(e){if(!this._routes.has(e.method))throw new l("unregister-route-but-not-found-with-method",{method:e.method});const t=this._routes.get(e.method).indexOf(e);if(t>-1)this._routes.get(e.method).splice(t,1);else throw new l("unregister-route-route-not-registered")}}let w;const X=()=>(w||(w=new J,w.addFetchListener(),w.addCacheListener()),w);function T(a,e,t){let s;if(typeof a=="string"){const r=new URL(a,location.href),c=({url:i})=>i.href===r.href;s=new g(c,e,t)}else if(a instanceof RegExp)s=new z(a,e,t);else if(typeof a=="function")s=new g(a,e,t);else if(a instanceof g)s=a;else throw new l("unsupported-route-type",{moduleName:"workbox-routing",funcName:"registerRoute",paramName:"capture"});return X().registerRoute(s),s}function Y(a,e=[]){for(const t of[...a.searchParams.keys()])e.some(s=>s.test(t))&&a.searchParams.delete(t);return a}function*Z(a,{ignoreURLParametersMatching:e=[/^utm_/,/^fbclid$/],directoryIndex:t="index.html",cleanURLs:s=!0,urlManipulation:n}={}){const r=new URL(a,location.href);r.hash="",yield r.href;const c=Y(r,e);if(yield c.href,t&&c.pathname.endsWith("/")){const i=new URL(c.href);i.pathname+=t,yield i.href}if(s){const i=new URL(c.href);i.pathname+=".html",yield i.href}if(n){const i=n({url:r});for(const o of i)yield o.href}}class ee extends g{constructor(e,t){const s=({request:n})=>{const r=e.getURLsToCacheKeys();for(const c of Z(n.url,t)){const i=r.get(c);if(i){const o=e.getIntegrityForCacheKey(i);return{cacheKey:i,integrity:o}}}};super(s,e.strategy)}}function te(a){const e=L(),t=new ee(e,a);T(t)}const se="-precache-",ae=async(a,e=se)=>{const s=(await self.caches.keys()).filter(n=>n.includes(e)&&n.includes(self.registration.scope)&&n!==a);return await Promise.all(s.map(n=>self.caches.delete(n))),s};function ne(){self.addEventListener("activate",(a=>{const e=C.getPrecacheName();a.waitUntil(ae(e).then(t=>{}))}))}function re(a){return L().createHandlerBoundToURL(a)}function ce(a){L().precache(a)}function ie(a,e){ce(a),te(e)}class oe extends g{constructor(e,{allowlist:t=[/./],denylist:s=[]}={}){super(n=>this._match(n),e),this._allowlist=t,this._denylist=s}_match({url:e,request:t}){if(t&&t.mode!=="navigate")return!1;const s=e.pathname+e.search;for(const n of this._denylist)if(n.test(s))return!1;return!!this._allowlist.some(n=>n.test(s))}}self.skipWaiting();j();ie([{"revision":"fab346dacb0b9b9af12554e9a59f004d","url":"logo.svg"},{"revision":"623840baec64a3438663496bb1050d30","url":"logo-docker.svg"},{"revision":"c5c8611b432190ec28522f1a2dfcbb7f","url":"logo-codex.svg"},{"revision":"33285017c4820702bdae9571e0b1997b","url":"index.html"},{"revision":"1421e9c6cad8218ef5689b85034d3a95","url":"icon-512.png"},{"revision":"b96da5a0b6636012517f54b0e69c304d","url":"icon-192.png"},{"revision":"c64ca8ae8596d4ffe13d0f591beb2274","url":"favicon.svg"},{"revision":"6481face04bd08e6f0bfc2a633840b57","url":"apple-touch-icon.png"},{"revision":"83304194a3c8be2b5b61242eeb1c1046","url":"fonts/MesloLGSNerdFontMono-Regular.woff2"},{"revision":"60fafe18cbcb717c51cdabf87f9490f0","url":"fonts/MesloLGSNerdFontMono-Bold.woff2"},{"revision":null,"url":"assets/workbox-window.prod.es5-BBnX5xw4.js"},{"revision":null,"url":"assets/sw-register-U38bnRB2.js"},{"revision":null,"url":"assets/index-Ck0r9rSX.js"},{"revision":null,"url":"assets/index-C86AT0KJ.css"},{"revision":null,"url":"assets/TailscalePage-DyKEeXYp.js"},{"revision":null,"url":"assets/SettingsPage-BOzfigwV.js"},{"revision":null,"url":"assets/SandboxManager-DUH9hgUI.js"},{"revision":null,"url":"assets/RunsPage-DN71HYQf.js"},{"revision":null,"url":"assets/PromptsPage-aPQqBbHT.js"},{"revision":null,"url":"assets/Playground-CtT6Yg7z.js"},{"revision":null,"url":"assets/LinearSettingsPage-cPsVQjgm.js"},{"revision":null,"url":"assets/LinearOAuthSettingsPage-B4FLu5lN.js"},{"revision":null,"url":"assets/IntegrationsPage-CI70O4xo.js"},{"revision":null,"url":"assets/DashboardPage-CbI1O6Zk.js"},{"revision":null,"url":"assets/CronManager-BZyF07KE.js"},{"revision":null,"url":"assets/AgentsPage-1K8kPnm0.js"}]);ne();T(new oe(re("index.html"),{denylist:[/^\/api/,/^\/ws/]}));
+This is generally NOT safe. Learn more at https://bit.ly/wb-precache`;console.warn(i)}}}install(e){return K(e,async()=>{const t=new B;this.strategy.plugins.push(t);for(const[r,c]of this._urlsToCacheKeys){const i=this._cacheKeysToIntegrities.get(c),o=this._urlsToCacheModes.get(r),h=new Request(r,{integrity:i,cache:o,credentials:"same-origin"});await Promise.all(this.strategy.handleAll({params:{cacheKey:c},request:h,event:e}))}const{updatedURLs:s,notUpdatedURLs:n}=t;return{updatedURLs:s,notUpdatedURLs:n}})}activate(e){return K(e,async()=>{const t=await self.caches.open(this.strategy.cacheName),s=await t.keys(),n=new Set(this._urlsToCacheKeys.values()),r=[];for(const c of s)n.has(c.url)||(await t.delete(c),r.push(c.url));return{deletedURLs:r}})}getURLsToCacheKeys(){return this._urlsToCacheKeys}getCachedURLs(){return[...this._urlsToCacheKeys.keys()]}getCacheKeyForURL(e){const t=new URL(e,location.href);return this._urlsToCacheKeys.get(t.href)}getIntegrityForCacheKey(e){return this._cacheKeysToIntegrities.get(e)}async matchPrecache(e){const t=e instanceof Request?e.url:e,s=this.getCacheKeyForURL(t);if(s)return(await self.caches.open(this.strategy.cacheName)).match(s)}createHandlerBoundToURL(e){const t=this.getCacheKeyForURL(e);if(!t)throw new l("non-precached-url",{url:e});return s=>(s.request=new Request(e),s.params=Object.assign({cacheKey:t},s.params),this.strategy.handle(s))}}let U;const L=()=>(U||(U=new Q),U);try{self["workbox:routing:7.4.0"]&&_()}catch{}const v="GET",R=a=>a&&typeof a=="object"?a:{handle:a};class g{constructor(e,t,s=v){this.handler=R(t),this.match=e,this.method=s}setCatchHandler(e){this.catchHandler=R(e)}}class z extends g{constructor(e,t,s){const n=({url:r})=>{const c=e.exec(r.href);if(c&&!(r.origin!==location.origin&&c.index!==0))return c.slice(1)};super(n,t,s)}}class J{constructor(){this._routes=new Map,this._defaultHandlerMap=new Map}get routes(){return this._routes}addFetchListener(){self.addEventListener("fetch",(e=>{const{request:t}=e,s=this.handleRequest({request:t,event:e});s&&e.respondWith(s)}))}addCacheListener(){self.addEventListener("message",(e=>{if(e.data&&e.data.type==="CACHE_URLS"){const{payload:t}=e.data,s=Promise.all(t.urlsToCache.map(n=>{typeof n=="string"&&(n=[n]);const r=new Request(...n);return this.handleRequest({request:r,event:e})}));e.waitUntil(s),e.ports&&e.ports[0]&&s.then(()=>e.ports[0].postMessage(!0))}}))}handleRequest({request:e,event:t}){const s=new URL(e.url,location.href);if(!s.protocol.startsWith("http"))return;const n=s.origin===location.origin,{params:r,route:c}=this.findMatchingRoute({event:t,request:e,sameOrigin:n,url:s});let i=c&&c.handler;const o=e.method;if(!i&&this._defaultHandlerMap.has(o)&&(i=this._defaultHandlerMap.get(o)),!i)return;let h;try{h=i.handle({url:s,request:e,event:t,params:r})}catch(u){h=Promise.reject(u)}const p=c&&c.catchHandler;return h instanceof Promise&&(this._catchHandler||p)&&(h=h.catch(async u=>{if(p)try{return await p.handle({url:s,request:e,event:t,params:r})}catch(k){k instanceof Error&&(u=k)}if(this._catchHandler)return this._catchHandler.handle({url:s,request:e,event:t});throw u})),h}findMatchingRoute({url:e,sameOrigin:t,request:s,event:n}){const r=this._routes.get(s.method)||[];for(const c of r){let i;const o=c.match({url:e,sameOrigin:t,request:s,event:n});if(o)return i=o,(Array.isArray(i)&&i.length===0||o.constructor===Object&&Object.keys(o).length===0||typeof o=="boolean")&&(i=void 0),{route:c,params:i}}return{}}setDefaultHandler(e,t=v){this._defaultHandlerMap.set(t,R(e))}setCatchHandler(e){this._catchHandler=R(e)}registerRoute(e){this._routes.has(e.method)||this._routes.set(e.method,[]),this._routes.get(e.method).push(e)}unregisterRoute(e){if(!this._routes.has(e.method))throw new l("unregister-route-but-not-found-with-method",{method:e.method});const t=this._routes.get(e.method).indexOf(e);if(t>-1)this._routes.get(e.method).splice(t,1);else throw new l("unregister-route-route-not-registered")}}let w;const X=()=>(w||(w=new J,w.addFetchListener(),w.addCacheListener()),w);function T(a,e,t){let s;if(typeof a=="string"){const r=new URL(a,location.href),c=({url:i})=>i.href===r.href;s=new g(c,e,t)}else if(a instanceof RegExp)s=new z(a,e,t);else if(typeof a=="function")s=new g(a,e,t);else if(a instanceof g)s=a;else throw new l("unsupported-route-type",{moduleName:"workbox-routing",funcName:"registerRoute",paramName:"capture"});return X().registerRoute(s),s}function Y(a,e=[]){for(const t of[...a.searchParams.keys()])e.some(s=>s.test(t))&&a.searchParams.delete(t);return a}function*Z(a,{ignoreURLParametersMatching:e=[/^utm_/,/^fbclid$/],directoryIndex:t="index.html",cleanURLs:s=!0,urlManipulation:n}={}){const r=new URL(a,location.href);r.hash="",yield r.href;const c=Y(r,e);if(yield c.href,t&&c.pathname.endsWith("/")){const i=new URL(c.href);i.pathname+=t,yield i.href}if(s){const i=new URL(c.href);i.pathname+=".html",yield i.href}if(n){const i=n({url:r});for(const o of i)yield o.href}}class ee extends g{constructor(e,t){const s=({request:n})=>{const r=e.getURLsToCacheKeys();for(const c of Z(n.url,t)){const i=r.get(c);if(i){const o=e.getIntegrityForCacheKey(i);return{cacheKey:i,integrity:o}}}};super(s,e.strategy)}}function te(a){const e=L(),t=new ee(e,a);T(t)}const se="-precache-",ae=async(a,e=se)=>{const s=(await self.caches.keys()).filter(n=>n.includes(e)&&n.includes(self.registration.scope)&&n!==a);return await Promise.all(s.map(n=>self.caches.delete(n))),s};function ne(){self.addEventListener("activate",(a=>{const e=C.getPrecacheName();a.waitUntil(ae(e).then(t=>{}))}))}function re(a){return L().createHandlerBoundToURL(a)}function ce(a){L().precache(a)}function ie(a,e){ce(a),te(e)}class oe extends g{constructor(e,{allowlist:t=[/./],denylist:s=[]}={}){super(n=>this._match(n),e),this._allowlist=t,this._denylist=s}_match({url:e,request:t}){if(t&&t.mode!=="navigate")return!1;const s=e.pathname+e.search;for(const n of this._denylist)if(n.test(s))return!1;return!!this._allowlist.some(n=>n.test(s))}}self.skipWaiting();j();ie([{"revision":"fab346dacb0b9b9af12554e9a59f004d","url":"logo.svg"},{"revision":"623840baec64a3438663496bb1050d30","url":"logo-docker.svg"},{"revision":"c5c8611b432190ec28522f1a2dfcbb7f","url":"logo-codex.svg"},{"revision":"7f44d9303f254456c9939ad64d6d7c34","url":"index.html"},{"revision":"1421e9c6cad8218ef5689b85034d3a95","url":"icon-512.png"},{"revision":"b96da5a0b6636012517f54b0e69c304d","url":"icon-192.png"},{"revision":"c64ca8ae8596d4ffe13d0f591beb2274","url":"favicon.svg"},{"revision":"6481face04bd08e6f0bfc2a633840b57","url":"apple-touch-icon.png"},{"revision":"83304194a3c8be2b5b61242eeb1c1046","url":"fonts/MesloLGSNerdFontMono-Regular.woff2"},{"revision":"60fafe18cbcb717c51cdabf87f9490f0","url":"fonts/MesloLGSNerdFontMono-Bold.woff2"},{"revision":null,"url":"assets/workbox-window.prod.es5-BBnX5xw4.js"},{"revision":null,"url":"assets/sw-register-B9GK06Mo.js"},{"revision":null,"url":"assets/index-C86AT0KJ.css"},{"revision":null,"url":"assets/index-B1Oejky6.js"},{"revision":null,"url":"assets/TailscalePage-CZ6V3kc7.js"},{"revision":null,"url":"assets/SettingsPage-BehGv-KV.js"},{"revision":null,"url":"assets/SandboxManager-BA6-RlkR.js"},{"revision":null,"url":"assets/RunsPage-jk2yW392.js"},{"revision":null,"url":"assets/PromptsPage-Ma4gA0R7.js"},{"revision":null,"url":"assets/Playground-C4t0-Zia.js"},{"revision":null,"url":"assets/LinearSettingsPage-DFh8jfhh.js"},{"revision":null,"url":"assets/LinearOAuthSettingsPage-DUQik5kh.js"},{"revision":null,"url":"assets/IntegrationsPage-C_tZ2P0K.js"},{"revision":null,"url":"assets/DashboardPage-aFf4uQfU.js"},{"revision":null,"url":"assets/CronManager-CES2-E0_.js"},{"revision":null,"url":"assets/AgentsPage-B2NtxJig.js"}]);ne();T(new oe(re("index.html"),{denylist:[/^\/api/,/^\/ws/]}));

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@hellcoder/companion",
-  "version": "0.113.2",
+  "version": "0.113.3",
   "type": "module",
   "description": "Web UI for launching and interacting with Claude Code agents — Moritz Edition (fork of the-companion)",
   "license": "MIT",

package/server/claude-adapter.ts CHANGED Viewed

@@ -47,7 +47,7 @@ import type {
 import type { SocketData } from "./ws-bridge-types.js";
 import type { PendingControlRequest } from "./ws-bridge-types.js";
 import type { RecorderManager } from "./recorder.js";
-import { captureProcState, hasLiveDescendants, countDescendants, getDescendants, type ProcDescendant } from "./proc-diagnostics.js";
+import { captureProcState, hasLiveDescendants, countDescendants, getDescendants, stdoutFdOpen, type ProcDescendant } from "./proc-diagnostics.js";
 import { getSettings } from "./settings-manager.js";
 import { parseNDJSON, isDuplicateCLIMessage } from "./ws-bridge-cli-ingest.js";
 import type { CLIDedupState } from "./ws-bridge-cli-ingest.js";
@@ -499,6 +499,7 @@ export class ClaudeAdapter implements IBackendAdapter {
         log.info("claude-adapter", "stdout closed but wedge-kill is disabled; leaving process alone", {
           sessionId: this.sessionId,
           pid: proc.pid,
+          cliStdoutOpen: stdoutFdOpen(proc.pid),
           proc: captureProcState(proc.pid),
           stderrTail: this.stderrTailForLog(),
         });
@@ -533,9 +534,12 @@ export class ClaudeAdapter implements IBackendAdapter {
             // Capture kernel state BEFORE the kill: once we SIGTERM, the
             // evidence is gone. A wedged CLI writes nothing to stderr, so this
             // is the only signal about why it is still alive.
+            const cliStdoutOpen = stdoutFdOpen(proc.pid);
+            this.warnIfReaderSideEof(cliStdoutOpen, proc.pid);
             log.warn("claude-adapter", "stdout closed after result but process did not exit within grace; killing wedged process", {
               sessionId: this.sessionId,
               pid: proc.pid,
+              cliStdoutOpen,
               graceReason: this.lastInboundWasResult ? "result" : "descendants_alive",
               teardownOutcome: this.lastTeardownOutcome,
               proc: captureProcState(proc.pid),
@@ -560,9 +564,12 @@ export class ClaudeAdapter implements IBackendAdapter {
             // Reaching here now means a genuine wedge: stdout closed, no live
             // descendants to reap, and still not exited. Snapshot kernel state
             // before the kill destroys it.
+            const cliStdoutOpen = stdoutFdOpen(proc.pid);
+            this.warnIfReaderSideEof(cliStdoutOpen, proc.pid);
             log.warn("claude-adapter", "stdout closed mid-stream and process did not exit within grace; killing wedged process", {
               sessionId: this.sessionId,
               pid: proc.pid,
+              cliStdoutOpen,
               graceMs: STDOUT_CLOSE_GRACE_MS,
               graceReason: "no_descendants",
               proc: captureProcState(proc.pid),
@@ -637,6 +644,24 @@ export class ClaudeAdapter implements IBackendAdapter {
     }
   }
+  /**
+   * Called on the kill path when the stdout-fd probe says the CLI still holds
+   * its stdout open. A pipe cannot EOF at the read end while a write end is
+   * open, so this state proves the "EOF" was synthetic on OUR side (Bun
+   * subprocess-stream teardown), not the CLI closing its output. The process
+   * is still killed — the stream cannot be re-attached, and an unkilled live
+   * PID blocks `handleAutoRelaunch`'s liveness guard, wedging recovery — but
+   * the warning attributes the root cause so these events can be counted and
+   * the reader-side failure fixed where it lives.
+   */
+  private warnIfReaderSideEof(cliStdoutOpen: boolean | null, pid: number | undefined): void {
+    if (cliStdoutOpen !== true) return;
+    log.warn("claude-adapter", "CLI still holds its stdout open — EOF was reader-side (server stream failure), not a CLI wedge; killing anyway so --resume recovery can proceed", {
+      sessionId: this.sessionId,
+      pid,
+    });
+  }
   private checkSilence(): void {
     if (this.transportKind !== "stdio" || !this.stdioConnected) return;

package/server/fs-utils.test.ts ADDED Viewed

@@ -0,0 +1,105 @@
+import { describe, it, expect } from "vitest";
+import { mkdtempSync, writeFileSync, appendFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  countFileLines,
+  countFileLinesAsync,
+  countFileLinesCached,
+  cachedFileLines,
+  type FileLinesCacheEntry,
+} from "./fs-utils.js";
+function makeTmpFile(content: string): { dir: string; path: string } {
+  const dir = mkdtempSync(join(tmpdir(), "fs-utils-test-"));
+  const path = join(dir, "file.log");
+  writeFileSync(path, content);
+  return { dir, path };
+}
+describe("countFileLinesAsync", () => {
+  // The async counter exists because the sync one reads whole files on the
+  // event loop (a 5-minute rotation scan of a multi-hundred-MB dir starved
+  // live CLI stdio streams). It must agree with the sync counter exactly.
+  it("matches countFileLines on the same content", async () => {
+    const { dir, path } = makeTmpFile("a\nb\nc\nno-trailing-newline");
+    try {
+      expect(await countFileLinesAsync(path)).toBe(countFileLines(path));
+      expect(await countFileLinesAsync(path)).toBe(3);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+  it("resolves 0 for a missing file instead of throwing", async () => {
+    expect(await countFileLinesAsync("/nonexistent/definitely/missing.log")).toBe(0);
+  });
+  it("counts across chunk boundaries on a file larger than one chunk", async () => {
+    // 2.5MB of 100-byte lines crosses the 1MB highWaterMark multiple times.
+    const line = "x".repeat(99) + "\n";
+    const { dir, path } = makeTmpFile(line.repeat(25_000));
+    try {
+      expect(await countFileLinesAsync(path)).toBe(25_000);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+describe("countFileLinesCached", () => {
+  // Rotated log/recording files are immutable, so a (size, mtime) match must
+  // serve from cache without re-reading — that is the whole point: in steady
+  // state only the actively-written file is ever re-counted.
+  it("serves an unchanged file from cache and recounts after append", async () => {
+    const { dir, path } = makeTmpFile("1\n2\n");
+    const cache = new Map<string, FileLinesCacheEntry>();
+    try {
+      expect(await countFileLinesCached(path, cache)).toBe(2);
+      expect(cache.size).toBe(1);
+      // Poison the cached count to prove the second call does NOT re-read.
+      const entry = cache.get(path)!;
+      cache.set(path, { ...entry, lines: 999 });
+      expect(await countFileLinesCached(path, cache)).toBe(999);
+      // Append (size changes) → cache invalidated → real recount.
+      appendFileSync(path, "3\n4\n");
+      expect(await countFileLinesCached(path, cache)).toBe(4);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+  it("returns 0 and drops the cache entry for a deleted file", async () => {
+    const { dir, path } = makeTmpFile("1\n");
+    const cache = new Map<string, FileLinesCacheEntry>();
+    try {
+      await countFileLinesCached(path, cache);
+      rmSync(path);
+      expect(await countFileLinesCached(path, cache)).toBe(0);
+      expect(cache.has(path)).toBe(false);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+describe("cachedFileLines", () => {
+  it("returns the cached count on a hit and null on a miss", async () => {
+    const { dir, path } = makeTmpFile("1\n2\n3\n");
+    const cache = new Map<string, FileLinesCacheEntry>();
+    try {
+      // Cold cache → miss.
+      expect(cachedFileLines(path, cache)).toBeNull();
+      // Warm via the async path → hit.
+      await countFileLinesCached(path, cache);
+      expect(cachedFileLines(path, cache)).toBe(3);
+      // Stale after append → miss again (must not serve a wrong count).
+      appendFileSync(path, "4\n");
+      expect(cachedFileLines(path, cache)).toBeNull();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/server/fs-utils.ts CHANGED Viewed

@@ -1,6 +1,14 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, createReadStream, statSync } from "node:fs";
-/** Count newlines in a file. Fast: reads raw buffer, counts 0x0A bytes. */
+/** Count newlines in a file. Fast: reads raw buffer, counts 0x0A bytes.
+ *
+ * Synchronous — reads the ENTIRE file on the event loop. Only safe for small
+ * files or cold paths. Periodic rotation over multi-hundred-MB log/recording
+ * directories must use `countFileLinesAsync`/`countFileLinesCached` instead:
+ * measured on a production box, sync counting of 66MB logs + 385MB recordings
+ * every 5 minutes stalled the event loop long enough to starve live CLI
+ * stdio streams.
+ */
 export function countFileLines(path: string): number {
   try {
     const buf = readFileSync(path);
@@ -13,3 +21,93 @@ export function countFileLines(path: string): number {
     return 0;
   }
 }
+/**
+ * Count newlines in a file without monopolizing the event loop.
+ *
+ * Streams the file in 1MB chunks; between chunks the event loop is free to
+ * service WebSocket frames and child-process stdio. Resolves 0 on any error
+ * (missing file, permission) — counting is always best-effort here.
+ */
+export function countFileLinesAsync(path: string): Promise<number> {
+  return new Promise((resolve) => {
+    let count = 0;
+    let stream: ReturnType<typeof createReadStream>;
+    try {
+      stream = createReadStream(path, { highWaterMark: 1 << 20 });
+    } catch {
+      resolve(0);
+      return;
+    }
+    stream.on("data", (chunk: Buffer | string) => {
+      const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+      for (let i = 0; i < buf.length; i++) {
+        if (buf[i] === 0x0a) count++;
+      }
+    });
+    stream.on("error", () => resolve(0));
+    stream.on("end", () => resolve(count));
+  });
+}
+/** Cache entry for `countFileLinesCached`: valid while size AND mtime match. */
+export interface FileLinesCacheEntry {
+  size: number;
+  mtimeMs: number;
+  lines: number;
+}
+/**
+ * Count newlines with a stat-validated cache.
+ *
+ * Rotated log/recording files are append-only while active and immutable once
+ * rotated, so an unchanged (size, mtime) pair means the cached count is still
+ * exact. In steady state only the currently-written file misses the cache,
+ * turning the periodic rotation scan from "re-read every byte of the
+ * directory" into one stat per file plus one streamed read of the active file.
+ */
+export async function countFileLinesCached(
+  path: string,
+  cache: Map<string, FileLinesCacheEntry>,
+): Promise<number> {
+  let size: number;
+  let mtimeMs: number;
+  try {
+    const st = statSync(path);
+    size = st.size;
+    mtimeMs = st.mtimeMs;
+  } catch {
+    cache.delete(path);
+    return 0;
+  }
+  const cached = cache.get(path);
+  if (cached && cached.size === size && cached.mtimeMs === mtimeMs) {
+    return cached.lines;
+  }
+  const lines = await countFileLinesAsync(path);
+  cache.set(path, { size, mtimeMs, lines });
+  return lines;
+}
+/**
+ * Synchronous cache lookup: returns the cached line count if still valid,
+ * or null on a miss. Lets on-demand sync paths (REST listings) reuse counts
+ * warmed by the periodic async scan without re-reading files.
+ */
+export function cachedFileLines(
+  path: string,
+  cache: Map<string, FileLinesCacheEntry>,
+): number | null {
+  try {
+    const st = statSync(path);
+    const cached = cache.get(path);
+    if (cached && cached.size === st.size && cached.mtimeMs === st.mtimeMs) {
+      return cached.lines;
+    }
+  } catch {
+    cache.delete(path);
+  }
+  return null;
+}

package/server/logger.test.ts CHANGED Viewed

@@ -59,6 +59,69 @@ describe("logger", () => {
       spy.mockRestore();
     });
+    // Regression: warn/error used to go only to stderr. In service mode stdout
+    // and stderr are redirected to different files, so every kill/stall
+    // warning was invisible in companion.log (the main grep target) — weeks of
+    // "killing wedged process" warnings were hidden this way. warn/error must
+    // now be mirrored onto stdout whenever stdout is not a TTY.
+    it("mirrors warn and error lines to stdout when stdout is not a TTY", () => {
+      const ttyDesc = Object.getOwnPropertyDescriptor(process.stdout, "isTTY");
+      Object.defineProperty(process.stdout, "isTTY", { value: false, configurable: true });
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+      try {
+        log.warn("claude-adapter", "killing wedged process", { pid: 42 });
+        log.error("cli-launcher", "spawn failed", { exitCode: 1 });
+        const written = writeSpy.mock.calls.map((c) => String(c[0])).join("");
+        expect(written).toContain("killing wedged process");
+        expect(written).toContain("spawn failed");
+      } finally {
+        writeSpy.mockRestore();
+        warnSpy.mockRestore();
+        errorSpy.mockRestore();
+        if (ttyDesc) Object.defineProperty(process.stdout, "isTTY", ttyDesc);
+      }
+    });
+    // On a TTY both streams share the terminal — mirroring would double-print.
+    it("does not mirror to stdout when stdout is a TTY", () => {
+      const ttyDesc = Object.getOwnPropertyDescriptor(process.stdout, "isTTY");
+      Object.defineProperty(process.stdout, "isTTY", { value: true, configurable: true });
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+      try {
+        log.warn("claude-adapter", "tty warn line", {});
+        const written = writeSpy.mock.calls.map((c) => String(c[0])).join("");
+        expect(written).not.toContain("tty warn line");
+      } finally {
+        writeSpy.mockRestore();
+        warnSpy.mockRestore();
+        if (ttyDesc) Object.defineProperty(process.stdout, "isTTY", ttyDesc);
+      }
+    });
+    // Severity must survive in a combined stdout log: warn/error lines carry
+    // an explicit level tag ("WARN:"/"ERROR:") so `grep WARN: companion.log`
+    // finds them; info lines keep the historical untagged format.
+    it("tags warn and error lines with their level in human format", () => {
+      const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      try {
+        log.info("mod", "plain info");
+        log.warn("mod", "warned");
+        log.error("mod", "errored");
+        expect(String(logSpy.mock.calls[0][0])).toBe("[mod] plain info");
+        expect(String(warnSpy.mock.calls[0][0])).toContain("[mod] WARN: warned");
+        expect(String(errorSpy.mock.calls[0][0])).toContain("[mod] ERROR: errored");
+      } finally {
+        logSpy.mockRestore();
+        warnSpy.mockRestore();
+        errorSpy.mockRestore();
+      }
+    });
     it("handles messages without data", () => {
       const spy = vi.spyOn(console, "log").mockImplementation(() => {});
       log.info("server", "Started");
@@ -188,7 +251,7 @@ describe("LogFileWriter", () => {
   });
   describe("rotation", () => {
-    it("deletes oldest log files when total lines exceed maxLines", () => {
+    it("deletes oldest log files when total lines exceed maxLines", async () => {
       // Pre-create two old log files with known line counts and distinct mtimes
       // so rotation deletes the oldest first.
       const oldFile1 = join(tmpDir, "companion_2020-01-01T00-00-00_1.log");
@@ -207,7 +270,7 @@ describe("LogFileWriter", () => {
       const writer = new LogFileWriter({ logsDir: tmpDir, maxLines: 8 });
       try {
         // Initial cleanup is deferred — run it explicitly for the test
-        writer.cleanup();
+        await writer.cleanup();
         const files = readdirSync(tmpDir).filter((f) => f.endsWith(".log"));
         // oldFile1 should have been deleted by cleanup, oldFile2 and current remain
         expect(files).toHaveLength(2);
@@ -220,7 +283,7 @@ describe("LogFileWriter", () => {
       }
     });
-    it("does not delete the current log file during cleanup", () => {
+    it("does not delete the current log file during cleanup", async () => {
       // Pre-create one old file that puts us over the limit, with an old mtime
       const oldFile = join(tmpDir, "companion_2020-01-01T00-00-00_1.log");
       writeFileSync(oldFile, "line1\nline2\nline3\n");
@@ -234,7 +297,7 @@ describe("LogFileWriter", () => {
         writer.write("current line 3");
         // Force another cleanup pass
-        const deleted = writer.cleanup();
+        const deleted = await writer.cleanup();
         expect(deleted).toBeGreaterThanOrEqual(0);
         // Current file must still exist and be writable
@@ -246,7 +309,7 @@ describe("LogFileWriter", () => {
       }
     });
-    it("returns the number of files deleted during cleanup", () => {
+    it("returns the number of files deleted during cleanup", async () => {
       // Create 3 old files with 5 lines each = 15 lines total, with distinct mtimes
       for (let i = 0; i < 3; i++) {
         const f = join(tmpDir, `companion_2020-0${i + 1}-01T00-00-00_${i}.log`);
@@ -259,7 +322,7 @@ describe("LogFileWriter", () => {
       const writer = new LogFileWriter({ logsDir: tmpDir, maxLines: 5 });
       try {
         // Initial cleanup is deferred — run it explicitly for the test
-        writer.cleanup();
+        await writer.cleanup();
         const files = readdirSync(tmpDir).filter((f) => f.endsWith(".log"));
         // At most the newest old file + current file should remain
         expect(files.length).toBeLessThanOrEqual(2);

package/server/logger.ts CHANGED Viewed

@@ -25,7 +25,7 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { COMPANION_HOME } from "./paths.js";
-import { countFileLines } from "./fs-utils.js";
+import { countFileLinesCached, type FileLinesCacheEntry } from "./fs-utils.js";
 type LogLevel = "info" | "warn" | "error";
@@ -52,7 +52,9 @@ function formatEntry(level: LogLevel, module: string, msg: string, data?: Record
   }
   // Human-readable format (default): [module] msg key=value key=value
-  let line = `[${module}] ${msg}`;
+  // warn/error carry an explicit level tag so severity survives in a combined
+  // stdout log and stays greppable (`grep 'WARN:' companion.log`).
+  let line = level === "info" ? `[${module}] ${msg}` : `[${module}] ${level.toUpperCase()}: ${msg}`;
   if (data) {
     const pairs = Object.entries(data)
       .map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`)
@@ -83,6 +85,12 @@ export class LogFileWriter {
   private dirCreated = false;
   private initialCleanupTimer: ReturnType<typeof setTimeout> | null = null;
   private cleanupTimer: ReturnType<typeof setInterval> | null = null;
+  /** Stat-validated line-count cache: rotated files are immutable, so only the
+   *  active file is ever re-read. Keeps the 5-minute scan off the event loop's
+   *  critical path (a sync scan of a 66MB dir was starving CLI stdio streams). */
+  private lineCountCache = new Map<string, FileLinesCacheEntry>();
+  /** Serializes cleanup passes so a slow scan can't overlap the next timer tick. */
+  private cleanupInFlight: Promise<number> | null = null;
   constructor(options?: { logsDir?: string; maxLines?: number }) {
     this.logsDir = options?.logsDir ?? LogFileWriter.resolveDir();
@@ -101,10 +109,10 @@ export class LogFileWriter {
     // Defer initial cleanup so it doesn't block the event loop at startup
     this.initialCleanupTimer = setTimeout(() => {
       this.initialCleanupTimer = null;
-      this.cleanup();
+      void this.cleanup();
     }, 2000);
     if (this.initialCleanupTimer.unref) this.initialCleanupTimer.unref();
-    this.cleanupTimer = setInterval(() => this.cleanup(), LOG_CLEANUP_INTERVAL_MS);
+    this.cleanupTimer = setInterval(() => void this.cleanup(), LOG_CLEANUP_INTERVAL_MS);
     if (this.cleanupTimer.unref) this.cleanupTimer.unref();
   }
@@ -139,8 +147,21 @@ export class LogFileWriter {
   /**
    * Delete oldest log files until total lines are under maxLines.
    * Skips the current log file (still being written to).
+   *
+   * Async and cache-backed on purpose: the previous sync implementation
+   * re-read every byte of the logs directory on the event loop every 5
+   * minutes, which on a 66MB directory stalled the loop long enough to starve
+   * live CLI stdio streams. Overlapping passes are coalesced.
    */
-  cleanup(): number {
+  cleanup(): Promise<number> {
+    if (this.cleanupInFlight) return this.cleanupInFlight;
+    this.cleanupInFlight = this.runCleanup().finally(() => {
+      this.cleanupInFlight = null;
+    });
+    return this.cleanupInFlight;
+  }
+  private async runCleanup(): Promise<number> {
     try {
       this.ensureDir();
       const files = readdirSync(this.logsDir).filter((f) => f.endsWith(".log"));
@@ -151,7 +172,7 @@ export class LogFileWriter {
       for (const filename of files) {
         const fullPath = join(this.logsDir, filename);
-        const lines = countFileLines(fullPath);
+        const lines = await countFileLinesCached(fullPath, this.lineCountCache);
         let mtimeMs = 0;
         try {
           mtimeMs = statSync(fullPath).mtimeMs;
@@ -174,6 +195,7 @@ export class LogFileWriter {
         if (entry.path === this.filePath) continue;
         try {
           unlinkSync(entry.path);
+          this.lineCountCache.delete(entry.path);
           totalLines -= entry.lines;
           deleted++;
         } catch {
@@ -238,6 +260,25 @@ export function closeLogFile(): void {
 // ─── Public logger ──────────────────────────────────────────────────────────
+/**
+ * Mirror a warn/error line onto stdout when stdout is redirected to a file.
+ *
+ * In service mode stdout and stderr land in different files (`companion.log`
+ * vs `companion.error.log`). warn/error used to go only to stderr, so every
+ * kill and stall warning was invisible in `companion.log` — the file everyone
+ * greps first. That hid weeks of "killing wedged process" warnings while the
+ * main log showed only unexplained 143 exits. Mirroring is skipped on a TTY,
+ * where both streams share the terminal and would print twice.
+ */
+function mirrorToStdout(line: string): void {
+  if (process.stdout.isTTY) return;
+  try {
+    process.stdout.write(line + "\n");
+  } catch {
+    // Logging must never disrupt normal operation
+  }
+}
 export const log = {
   info(module: string, msg: string, data?: Record<string, unknown>): void {
     const line = formatEntry("info", module, msg, data);
@@ -248,12 +289,14 @@ export const log = {
   warn(module: string, msg: string, data?: Record<string, unknown>): void {
     const line = formatEntry("warn", module, msg, data);
     console.warn(line);
+    mirrorToStdout(line);
     fileWriter?.write(line);
   },
   error(module: string, msg: string, data?: Record<string, unknown>): void {
     const line = formatEntry("error", module, msg, data);
     console.error(line);
+    mirrorToStdout(line);
     fileWriter?.write(line);
   },
 };