@code-yeongyu/senpi 2026.10.25-2 → 2026.10.25-4

package/dist/bundle/chunks/chunk-SCVRKIFK.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{fetchWithinOrigin,unfollowedRedirect}from"./chunk-YP72RYUP.js";import{LATEST_PROTOCOL_VERSION,NEVER,ZodIssueCode,any,array,boolean,coerce_exports,literal,looseObject,number,object,string,url}from"./chunk-HPCS4HM4.js";var crypto;crypto=globalThis.crypto?.webcrypto??globalThis.crypto??import("node:crypto").then(m=>m.webcrypto);async function getRandomValues(size){return(await crypto).getRandomValues(new Uint8Array(size))}async function random(size){let mask="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~",evenDistCutoff=Math.pow(2,8)-Math.pow(2,8)%mask.length,result="";for(;result.length<size;){let randomBytes=await getRandomValues(size-result.length);for(let randomByte of randomBytes)randomByte<evenDistCutoff&&(result+=mask[randomByte%mask.length])}return result}async function generateVerifier(length){return await random(length)}async function generateChallenge(code_verifier){let buffer=await(await crypto).subtle.digest("SHA-256",new TextEncoder().encode(code_verifier));return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g,"_").replace(/\+/g,"-").replace(/=/g,"")}async function pkceChallenge(length){if(length||(length=43),length<43||length>128)throw`Expected a length between 43 and 128. Received ${length}.`;let verifier=await generateVerifier(length),challenge=await generateChallenge(verifier);return{code_verifier:verifier,code_challenge:challenge}}var SafeUrlSchema=url().superRefine((val,ctx)=>{if(!URL.canParse(val))return ctx.addIssue({code:ZodIssueCode.custom,message:"URL must be parseable",fatal:!0}),NEVER}).refine(url2=>{let u=new URL(url2);return u.protocol!=="javascript:"&&u.protocol!=="data:"&&u.protocol!=="vbscript:"},{message:"URL cannot use javascript:, data:, or vbscript: scheme"}),OAuthProtectedResourceMetadataSchema=looseObject({resource:string().url(),authorization_servers:array(SafeUrlSchema).optional(),jwks_uri:string().url().optional(),scopes_supported:array(string()).optional(),bearer_methods_supported:array(string()).optional(),resource_signing_alg_values_supported:array(string()).optional(),resource_name:string().optional(),resource_documentation:string().optional(),resource_policy_uri:string().url().optional(),resource_tos_uri:string().url().optional(),tls_client_certificate_bound_access_tokens:boolean().optional(),authorization_details_types_supported:array(string()).optional(),dpop_signing_alg_values_supported:array(string()).optional(),dpop_bound_access_tokens_required:boolean().optional()}),OAuthMetadataSchema=looseObject({issuer:string(),authorization_endpoint:SafeUrlSchema,token_endpoint:SafeUrlSchema,registration_endpoint:SafeUrlSchema.optional(),scopes_supported:array(string()).optional(),response_types_supported:array(string()),response_modes_supported:array(string()).optional(),grant_types_supported:array(string()).optional(),token_endpoint_auth_methods_supported:array(string()).optional(),token_endpoint_auth_signing_alg_values_supported:array(string()).optional(),service_documentation:SafeUrlSchema.optional(),revocation_endpoint:SafeUrlSchema.optional(),revocation_endpoint_auth_methods_supported:array(string()).optional(),revocation_endpoint_auth_signing_alg_values_supported:array(string()).optional(),introspection_endpoint:string().optional(),introspection_endpoint_auth_methods_supported:array(string()).optional(),introspection_endpoint_auth_signing_alg_values_supported:array(string()).optional(),code_challenge_methods_supported:array(string()).optional(),client_id_metadata_document_supported:boolean().optional()}),OpenIdProviderMetadataSchema=looseObject({issuer:string(),authorization_endpoint:SafeUrlSchema,token_endpoint:SafeUrlSchema,userinfo_endpoint:SafeUrlSchema.optional(),jwks_uri:SafeUrlSchema,registration_endpoint:SafeUrlSchema.optional(),scopes_supported:array(string()).optional(),response_types_supported:array(string()),response_modes_supported:array(string()).optional(),grant_types_supported:array(string()).optional(),acr_values_supported:array(string()).optional(),subject_types_supported:array(string()),id_token_signing_alg_values_supported:array(string()),id_token_encryption_alg_values_supported:array(string()).optional(),id_token_encryption_enc_values_supported:array(string()).optional(),userinfo_signing_alg_values_supported:array(string()).optional(),userinfo_encryption_alg_values_supported:array(string()).optional(),userinfo_encryption_enc_values_supported:array(string()).optional(),request_object_signing_alg_values_supported:array(string()).optional(),request_object_encryption_alg_values_supported:array(string()).optional(),request_object_encryption_enc_values_supported:array(string()).optional(),token_endpoint_auth_methods_supported:array(string()).optional(),token_endpoint_auth_signing_alg_values_supported:array(string()).optional(),display_values_supported:array(string()).optional(),claim_types_supported:array(string()).optional(),claims_supported:array(string()).optional(),service_documentation:string().optional(),claims_locales_supported:array(string()).optional(),ui_locales_supported:array(string()).optional(),claims_parameter_supported:boolean().optional(),request_parameter_supported:boolean().optional(),request_uri_parameter_supported:boolean().optional(),require_request_uri_registration:boolean().optional(),op_policy_uri:SafeUrlSchema.optional(),op_tos_uri:SafeUrlSchema.optional(),client_id_metadata_document_supported:boolean().optional()}),OpenIdProviderDiscoveryMetadataSchema=object({...OpenIdProviderMetadataSchema.shape,...OAuthMetadataSchema.pick({code_challenge_methods_supported:!0}).shape}),OAuthTokensSchema=object({access_token:string(),id_token:string().optional(),token_type:string(),expires_in:coerce_exports.number().optional(),scope:string().optional(),refresh_token:string().optional(),issuer:string().optional().catch(void 0)}).strip(),OAuthErrorResponseSchema=object({error:string(),error_description:string().optional(),error_uri:string().optional()}),OptionalSafeUrlSchema=SafeUrlSchema.optional().or(literal("").transform(()=>{})),OAuthClientMetadataSchema=object({redirect_uris:array(SafeUrlSchema),token_endpoint_auth_method:string().optional(),grant_types:array(string()).optional(),response_types:array(string()).optional(),client_name:string().optional(),client_uri:SafeUrlSchema.optional(),logo_uri:OptionalSafeUrlSchema,scope:string().optional(),contacts:array(string()).optional(),tos_uri:OptionalSafeUrlSchema,policy_uri:string().optional(),jwks_uri:SafeUrlSchema.optional(),jwks:any().optional(),software_id:string().optional(),software_version:string().optional(),software_statement:string().optional()}).strip(),OAuthClientInformationSchema=object({client_id:string(),client_secret:string().optional(),client_id_issued_at:number().optional(),client_secret_expires_at:number().optional(),issuer:string().optional().catch(void 0)}).strip(),OAuthClientInformationFullSchema=OAuthClientMetadataSchema.merge(OAuthClientInformationSchema),OAuthClientRegistrationErrorSchema=object({error:string(),error_description:string().optional()}).strip(),OAuthTokenRevocationRequestSchema=object({token:string(),token_type_hint:string().optional()}).strip();function resourceUrlFromServerUrl(url2){let resourceURL=typeof url2=="string"?new URL(url2):new URL(url2.href);return resourceURL.hash="",resourceURL}function checkResourceAllowed({requestedResource,configuredResource}){let requested=typeof requestedResource=="string"?new URL(requestedResource):new URL(requestedResource.href),configured=typeof configuredResource=="string"?new URL(configuredResource):new URL(configuredResource.href);if(requested.origin!==configured.origin||requested.pathname.length<configured.pathname.length)return!1;let requestedPath=requested.pathname.endsWith("/")?requested.pathname:requested.pathname+"/",configuredPath=configured.pathname.endsWith("/")?configured.pathname:configured.pathname+"/";return requestedPath.startsWith(configuredPath)}var OAuthError=class extends Error{constructor(message,errorUri){super(message),this.errorUri=errorUri,this.name=this.constructor.name}toResponseObject(){let response={error:this.errorCode,error_description:this.message};return this.errorUri&&(response.error_uri=this.errorUri),response}get errorCode(){return this.constructor.errorCode}},InvalidRequestError=class extends OAuthError{};InvalidRequestError.errorCode="invalid_request";var InvalidClientError=class extends OAuthError{};InvalidClientError.errorCode="invalid_client";var InvalidGrantError=class extends OAuthError{};InvalidGrantError.errorCode="invalid_grant";var UnauthorizedClientError=class extends OAuthError{};UnauthorizedClientError.errorCode="unauthorized_client";var UnsupportedGrantTypeError=class extends OAuthError{};UnsupportedGrantTypeError.errorCode="unsupported_grant_type";var InvalidScopeError=class extends OAuthError{};InvalidScopeError.errorCode="invalid_scope";var AccessDeniedError=class extends OAuthError{};AccessDeniedError.errorCode="access_denied";var ServerError=class extends OAuthError{};ServerError.errorCode="server_error";var TemporarilyUnavailableError=class extends OAuthError{};TemporarilyUnavailableError.errorCode="temporarily_unavailable";var UnsupportedResponseTypeError=class extends OAuthError{};UnsupportedResponseTypeError.errorCode="unsupported_response_type";var UnsupportedTokenTypeError=class extends OAuthError{};UnsupportedTokenTypeError.errorCode="unsupported_token_type";var InvalidTokenError=class extends OAuthError{};InvalidTokenError.errorCode="invalid_token";var MethodNotAllowedError=class extends OAuthError{};MethodNotAllowedError.errorCode="method_not_allowed";var TooManyRequestsError=class extends OAuthError{};TooManyRequestsError.errorCode="too_many_requests";var InvalidClientMetadataError=class extends OAuthError{};InvalidClientMetadataError.errorCode="invalid_client_metadata";var InsufficientScopeError=class extends OAuthError{};InsufficientScopeError.errorCode="insufficient_scope";var InvalidTargetError=class extends OAuthError{};InvalidTargetError.errorCode="invalid_target";var OAUTH_ERRORS={[InvalidRequestError.errorCode]:InvalidRequestError,[InvalidClientError.errorCode]:InvalidClientError,[InvalidGrantError.errorCode]:InvalidGrantError,[UnauthorizedClientError.errorCode]:UnauthorizedClientError,[UnsupportedGrantTypeError.errorCode]:UnsupportedGrantTypeError,[InvalidScopeError.errorCode]:InvalidScopeError,[AccessDeniedError.errorCode]:AccessDeniedError,[ServerError.errorCode]:ServerError,[TemporarilyUnavailableError.errorCode]:TemporarilyUnavailableError,[UnsupportedResponseTypeError.errorCode]:UnsupportedResponseTypeError,[UnsupportedTokenTypeError.errorCode]:UnsupportedTokenTypeError,[InvalidTokenError.errorCode]:InvalidTokenError,[MethodNotAllowedError.errorCode]:MethodNotAllowedError,[TooManyRequestsError.errorCode]:TooManyRequestsError,[InvalidClientMetadataError.errorCode]:InvalidClientMetadataError,[InsufficientScopeError.errorCode]:InsufficientScopeError,[InvalidTargetError.errorCode]:InvalidTargetError};var UnauthorizedError=class extends Error{constructor(message){super(message??"Unauthorized")}};function isClientAuthMethod(method){return["client_secret_basic","client_secret_post","none"].includes(method)}var AUTHORIZATION_CODE_RESPONSE_TYPE="code",AUTHORIZATION_CODE_CHALLENGE_METHOD="S256";function selectClientAuthMethod(clientInformation,supportedMethods){let hasClientSecret=clientInformation.client_secret!==void 0;return"token_endpoint_auth_method"in clientInformation&&clientInformation.token_endpoint_auth_method&&isClientAuthMethod(clientInformation.token_endpoint_auth_method)&&(supportedMethods.length===0||supportedMethods.includes(clientInformation.token_endpoint_auth_method))?clientInformation.token_endpoint_auth_method:supportedMethods.length===0?hasClientSecret?"client_secret_basic":"none":hasClientSecret&&supportedMethods.includes("client_secret_basic")?"client_secret_basic":hasClientSecret&&supportedMethods.includes("client_secret_post")?"client_secret_post":supportedMethods.includes("none")?"none":hasClientSecret?"client_secret_post":"none"}function applyClientAuthentication(method,clientInformation,headers,params){let{client_id,client_secret}=clientInformation;switch(method){case"client_secret_basic":applyBasicAuth(client_id,client_secret,headers);return;case"client_secret_post":applyPostAuth(client_id,client_secret,params);return;case"none":applyPublicAuth(client_id,params);return;default:throw new Error(`Unsupported client authentication method: ${method}`)}}function applyBasicAuth(clientId,clientSecret,headers){if(!clientSecret)throw new Error("client_secret_basic authentication requires a client_secret");let credentials=btoa(`${clientId}:${clientSecret}`);headers.set("Authorization",`Basic ${credentials}`)}function applyPostAuth(clientId,clientSecret,params){params.set("client_id",clientId),clientSecret&&params.set("client_secret",clientSecret)}function applyPublicAuth(clientId,params){params.set("client_id",clientId)}async function parseErrorResponse(input){let statusCode=input instanceof Response?input.status:void 0,body=input instanceof Response?await input.text():input;try{let result=OAuthErrorResponseSchema.parse(JSON.parse(body)),{error,error_description,error_uri}=result,errorClass=OAUTH_ERRORS[error]||ServerError;return new errorClass(error_description||"",error_uri)}catch(error){let redirect=input instanceof Response?unfollowedRedirect(input,input.url):void 0,errorMessage=`${statusCode?`HTTP ${statusCode}: `:""}${redirect??`Invalid OAuth error response: ${error}. Raw body: ${body}`}`;return new ServerError(errorMessage)}}function issuersMatch(a,b){let[x,y]=[a,b];try{[x,y]=[new URL(a).href,new URL(b).href]}catch{}return x===y||x.endsWith("/")&&x.slice(0,-1)===y||y.endsWith("/")&&y.slice(0,-1)===x}function discardIfIssuerMismatch(stored,issuer){if(stored)return typeof stored.issuer!="string"?stored.issuer==null?stored:{...stored,issuer:void 0}:issuersMatch(stored.issuer,issuer)?stored:void 0}var TokenResponseSchema=OAuthTokensSchema.omit({issuer:!0}),RegistrationResponseSchema=OAuthClientInformationFullSchema.omit({issuer:!0});function boundElsewhereError(stored,issuer){return new Error(`OAuth client information is bound to authorization server ${stored.issuer} and is not presented to ${issuer}. Clear the stored client information, or correct \`expectedIssuer\`, if the authorization server has moved.`)}async function auth(provider,options){try{return await authInternal(provider,options)}catch(error){if(error instanceof InvalidClientError||error instanceof UnauthorizedClientError)return await provider.invalidateCredentials?.("all"),await authInternal(provider,options);if(error instanceof InvalidGrantError)return await provider.invalidateCredentials?.("tokens"),await authInternal(provider,options);throw error}}async function authInternal(provider,{serverUrl,authorizationCode,scope,resourceMetadataUrl,fetchFn}){let cachedState=await provider.discoveryState?.(),resourceMetadata,authorizationServerUrl,metadata,effectiveResourceMetadataUrl=resourceMetadataUrl;if(!effectiveResourceMetadataUrl&&cachedState?.resourceMetadataUrl&&(effectiveResourceMetadataUrl=new URL(cachedState.resourceMetadataUrl)),cachedState?.authorizationServerUrl){if(authorizationServerUrl=cachedState.authorizationServerUrl,resourceMetadata=cachedState.resourceMetadata,metadata=cachedState.authorizationServerMetadata??await discoverAuthorizationServerMetadata(authorizationServerUrl,{fetchFn}),!resourceMetadata)try{resourceMetadata=await discoverOAuthProtectedResourceMetadata(serverUrl,{resourceMetadataUrl:effectiveResourceMetadataUrl},fetchFn)}catch{}(metadata!==cachedState.authorizationServerMetadata||resourceMetadata!==cachedState.resourceMetadata)&&await provider.saveDiscoveryState?.({authorizationServerUrl:String(authorizationServerUrl),resourceMetadataUrl:effectiveResourceMetadataUrl?.toString(),resourceMetadata,authorizationServerMetadata:metadata})}else{let serverInfo=await discoverOAuthServerInfo(serverUrl,{resourceMetadataUrl:effectiveResourceMetadataUrl,fetchFn});authorizationServerUrl=serverInfo.authorizationServerUrl,metadata=serverInfo.authorizationServerMetadata,resourceMetadata=serverInfo.resourceMetadata,await provider.saveDiscoveryState?.({authorizationServerUrl:String(authorizationServerUrl),resourceMetadataUrl:effectiveResourceMetadataUrl?.toString(),resourceMetadata,authorizationServerMetadata:metadata})}let issuer=String(authorizationServerUrl),selectedResource=await selectResourceURL(serverUrl,provider,resourceMetadata),resource=selectedResource&&resourceMetadata&&!provider.validateResourceURL?resourceMetadata.resource:selectedResource,resolvedScope=scope||resourceMetadata?.scopes_supported?.join(" ")||provider.clientMetadata.scope,storedClientInformation=await Promise.resolve(provider.clientInformation()),clientInformation=discardIfIssuerMismatch(storedClientInformation,issuer),canRegisterAgain=provider.saveClientInformation!==void 0&&!!provider.redirectUrl;if(storedClientInformation&&!clientInformation&&!canRegisterAgain)throw boundElsewhereError(storedClientInformation,issuer);let unstampedClientInformation=clientInformation?.issuer==null?clientInformation:void 0,bindClientInformation=async()=>{try{unstampedClientInformation&&await provider.saveClientInformation?.({...unstampedClientInformation,issuer})}catch{}};if(!clientInformation){if(authorizationCode!==void 0)throw new Error("Existing OAuth client information is required when exchanging an authorization code");let supportsUrlBasedClientId=metadata?.client_id_metadata_document_supported===!0,clientMetadataUrl=provider.clientMetadataUrl;if(clientMetadataUrl&&!isHttpsUrl(clientMetadataUrl))throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);if(supportsUrlBasedClientId&&clientMetadataUrl)clientInformation={client_id:clientMetadataUrl,issuer},await provider.saveClientInformation?.(clientInformation);else{if(!provider.saveClientInformation)throw new Error("OAuth client information must be saveable for dynamic registration");clientInformation={...await registerClient(authorizationServerUrl,{metadata,clientMetadata:provider.clientMetadata,scope:resolvedScope,fetchFn}),issuer},await provider.saveClientInformation(clientInformation)}}let nonInteractiveFlow=!provider.redirectUrl;if(authorizationCode!==void 0||nonInteractiveFlow){let tokens2=await fetchToken(provider,authorizationServerUrl,{metadata,resource,authorizationCode,fetchFn});return await bindClientInformation(),await provider.saveTokens({...tokens2,issuer}),"AUTHORIZED"}let tokens=discardIfIssuerMismatch(await provider.tokens(),issuer);if(tokens?.refresh_token&&tokens.issuer==null&&console.warn("[mcp-sdk] stored OAuth tokens have no 'issuer' property (saved by an earlier version, or by a provider that does not keep it) and are used as-is; make sure your OAuthClientProvider stores what saveTokens() and saveClientInformation() receive unchanged."),tokens?.refresh_token)try{let newTokens=await refreshAuthorization(authorizationServerUrl,{metadata,clientInformation,refreshToken:tokens.refresh_token,resource,addClientAuthentication:provider.addClientAuthentication,fetchFn});return await bindClientInformation(),await provider.saveTokens({...newTokens,issuer}),"AUTHORIZED"}catch(error){if(!(!(error instanceof OAuthError)||error instanceof ServerError))throw error}let state=provider.state?await provider.state():void 0,{authorizationUrl,codeVerifier}=await startAuthorization(authorizationServerUrl,{metadata,clientInformation,state,redirectUrl:provider.redirectUrl,scope:resolvedScope,resource});return await provider.saveCodeVerifier(codeVerifier),await provider.redirectToAuthorization(authorizationUrl),"REDIRECT"}function isHttpsUrl(value){if(!value)return!1;try{let url2=new URL(value);return url2.protocol==="https:"&&url2.pathname!=="/"}catch{return!1}}async function selectResourceURL(serverUrl,provider,resourceMetadata){let defaultResource=resourceUrlFromServerUrl(serverUrl);if(provider.validateResourceURL)return await provider.validateResourceURL(defaultResource,resourceMetadata?.resource);if(resourceMetadata){if(!checkResourceAllowed({requestedResource:defaultResource,configuredResource:resourceMetadata.resource}))throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);return new URL(resourceMetadata.resource)}}function extractWWWAuthenticateParams(res){let authenticateHeader=res.headers.get("WWW-Authenticate");if(!authenticateHeader)return{};let[type,scheme]=authenticateHeader.split(" ");if(type.toLowerCase()!=="bearer"||!scheme)return{};let resourceMetadataMatch=extractFieldFromWwwAuth(res,"resource_metadata")||void 0,resourceMetadataUrl;if(resourceMetadataMatch)try{resourceMetadataUrl=new URL(resourceMetadataMatch)}catch{}let scope=extractFieldFromWwwAuth(res,"scope")||void 0,error=extractFieldFromWwwAuth(res,"error")||void 0;return{resourceMetadataUrl,scope,error}}function extractFieldFromWwwAuth(response,fieldName){let wwwAuthHeader=response.headers.get("WWW-Authenticate");if(!wwwAuthHeader)return null;let pattern=new RegExp(`${fieldName}=(?:"([^"]+)"|([^\\s,]+))`),match=wwwAuthHeader.match(pattern);return match?match[1]||match[2]:null}function extractResourceMetadataUrl(res){let authenticateHeader=res.headers.get("WWW-Authenticate");if(!authenticateHeader)return;let[type,scheme]=authenticateHeader.split(" ");if(type.toLowerCase()!=="bearer"||!scheme)return;let match=/resource_metadata="([^"]*)"/.exec(authenticateHeader);if(match)try{return new URL(match[1])}catch{return}}async function discoverOAuthProtectedResourceMetadata(serverUrl,opts,fetchFn=fetch){let response=await discoverMetadataWithFallback(serverUrl,"oauth-protected-resource",fetchFn,{protocolVersion:opts?.protocolVersion,metadataUrl:opts?.resourceMetadataUrl});if(!response||response.status===404)throw await response?.body?.cancel(),new Error("Resource server does not implement OAuth 2.0 Protected Resource Metadata.");if(!response.ok)throw await response.body?.cancel(),new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);return OAuthProtectedResourceMetadataSchema.parse(await response.json())}async function fetchWithCorsRetry(url2,headers,fetchFn=fetch){try{return await fetchWithinOrigin(fetchFn)(url2,{headers})}catch(error){if(error instanceof TypeError)return headers?fetchWithCorsRetry(url2,void 0,fetchFn):void 0;throw error}}function buildWellKnownPath(wellKnownPrefix,pathname="",options={}){return pathname.endsWith("/")&&(pathname=pathname.slice(0,-1)),options.prependPathname?`${pathname}/.well-known/${wellKnownPrefix}`:`/.well-known/${wellKnownPrefix}${pathname}`}async function tryMetadataDiscovery(url2,protocolVersion,fetchFn=fetch){return await fetchWithCorsRetry(url2,{"MCP-Protocol-Version":protocolVersion},fetchFn)}function shouldAttemptFallback(response,pathname){return!response||!response.ok&&response.status<500&&pathname!=="/"}async function discoverMetadataWithFallback(serverUrl,wellKnownType,fetchFn,opts){let issuer=new URL(serverUrl),protocolVersion=opts?.protocolVersion??LATEST_PROTOCOL_VERSION,url2;if(opts?.metadataUrl)url2=new URL(opts.metadataUrl);else{let wellKnownPath=buildWellKnownPath(wellKnownType,issuer.pathname);url2=new URL(wellKnownPath,opts?.metadataServerUrl??issuer),url2.search=issuer.search}let response=await tryMetadataDiscovery(url2,protocolVersion,fetchFn);if(!opts?.metadataUrl&&shouldAttemptFallback(response,issuer.pathname)){let rootUrl=new URL(`/.well-known/${wellKnownType}`,issuer);response=await tryMetadataDiscovery(rootUrl,protocolVersion,fetchFn)}return response}async function discoverOAuthMetadata(issuer,{authorizationServerUrl,protocolVersion}={},fetchFn=fetch){typeof issuer=="string"&&(issuer=new URL(issuer)),authorizationServerUrl||(authorizationServerUrl=issuer),typeof authorizationServerUrl=="string"&&(authorizationServerUrl=new URL(authorizationServerUrl)),protocolVersion??(protocolVersion=LATEST_PROTOCOL_VERSION);let response=await discoverMetadataWithFallback(authorizationServerUrl,"oauth-authorization-server",fetchFn,{protocolVersion,metadataServerUrl:authorizationServerUrl});if(!response||response.status===404){await response?.body?.cancel();return}if(!response.ok)throw await response.body?.cancel(),new Error(`HTTP ${response.status} trying to load well-known OAuth metadata`);return OAuthMetadataSchema.parse(await response.json())}function buildDiscoveryUrls(authorizationServerUrl){let url2=typeof authorizationServerUrl=="string"?new URL(authorizationServerUrl):authorizationServerUrl,hasPath=url2.pathname!=="/",urlsToTry=[];if(!hasPath)return urlsToTry.push({url:new URL("/.well-known/oauth-authorization-server",url2.origin),type:"oauth"}),urlsToTry.push({url:new URL("/.well-known/openid-configuration",url2.origin),type:"oidc"}),urlsToTry;let pathname=url2.pathname;return pathname.endsWith("/")&&(pathname=pathname.slice(0,-1)),urlsToTry.push({url:new URL(`/.well-known/oauth-authorization-server${pathname}`,url2.origin),type:"oauth"}),urlsToTry.push({url:new URL(`/.well-known/openid-configuration${pathname}`,url2.origin),type:"oidc"}),urlsToTry.push({url:new URL(`${pathname}/.well-known/openid-configuration`,url2.origin),type:"oidc"}),urlsToTry}async function discoverAuthorizationServerMetadata(authorizationServerUrl,{fetchFn=fetch,protocolVersion=LATEST_PROTOCOL_VERSION}={}){let headers={"MCP-Protocol-Version":protocolVersion,Accept:"application/json"},urlsToTry=buildDiscoveryUrls(authorizationServerUrl);for(let{url:endpointUrl,type}of urlsToTry){let response=await fetchWithCorsRetry(endpointUrl,headers,fetchFn);if(response){if(!response.ok){if(await response.body?.cancel(),response.status<500)continue;throw new Error(`HTTP ${response.status} trying to load ${type==="oauth"?"OAuth":"OpenID provider"} metadata from ${endpointUrl}`)}return type==="oauth"?OAuthMetadataSchema.parse(await response.json()):OpenIdProviderDiscoveryMetadataSchema.parse(await response.json())}}}async function discoverOAuthServerInfo(serverUrl,opts){let resourceMetadata,authorizationServerUrl;try{resourceMetadata=await discoverOAuthProtectedResourceMetadata(serverUrl,{resourceMetadataUrl:opts?.resourceMetadataUrl},opts?.fetchFn),resourceMetadata.authorization_servers&&resourceMetadata.authorization_servers.length>0&&(authorizationServerUrl=resourceMetadata.authorization_servers[0])}catch{}authorizationServerUrl||(authorizationServerUrl=String(new URL("/",serverUrl)));let authorizationServerMetadata=await discoverAuthorizationServerMetadata(authorizationServerUrl,{fetchFn:opts?.fetchFn});return{authorizationServerUrl,authorizationServerMetadata,resourceMetadata}}function resourceIndicatorToString(resource){return typeof resource=="string"?resource:resource.href}async function startAuthorization(authorizationServerUrl,{metadata,clientInformation,redirectUrl,scope,state,resource}){let authorizationUrl;if(metadata){if(authorizationUrl=new URL(metadata.authorization_endpoint),!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE))throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);if(metadata.code_challenge_methods_supported&&!metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD))throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`)}else authorizationUrl=new URL("/authorize",authorizationServerUrl);let challenge=await pkceChallenge(),codeVerifier=challenge.code_verifier,codeChallenge=challenge.code_challenge;return authorizationUrl.searchParams.set("response_type",AUTHORIZATION_CODE_RESPONSE_TYPE),authorizationUrl.searchParams.set("client_id",clientInformation.client_id),authorizationUrl.searchParams.set("code_challenge",codeChallenge),authorizationUrl.searchParams.set("code_challenge_method",AUTHORIZATION_CODE_CHALLENGE_METHOD),authorizationUrl.searchParams.set("redirect_uri",String(redirectUrl)),state&&authorizationUrl.searchParams.set("state",state),scope&&authorizationUrl.searchParams.set("scope",scope),scope?.includes("offline_access")&&authorizationUrl.searchParams.append("prompt","consent"),resource&&authorizationUrl.searchParams.set("resource",resourceIndicatorToString(resource)),{authorizationUrl,codeVerifier}}function prepareAuthorizationCodeRequest(authorizationCode,codeVerifier,redirectUri){return new URLSearchParams({grant_type:"authorization_code",code:authorizationCode,code_verifier:codeVerifier,redirect_uri:String(redirectUri)})}async function executeTokenRequest(authorizationServerUrl,{metadata,tokenRequestParams,clientInformation,addClientAuthentication,resource,fetchFn}){let tokenUrl=metadata?.token_endpoint?new URL(metadata.token_endpoint):new URL("/token",authorizationServerUrl),headers=new Headers({"Content-Type":"application/x-www-form-urlencoded",Accept:"application/json"});if(resource&&tokenRequestParams.set("resource",resourceIndicatorToString(resource)),addClientAuthentication)await addClientAuthentication(headers,tokenRequestParams,tokenUrl,metadata);else if(clientInformation){let supportedMethods=metadata?.token_endpoint_auth_methods_supported??[],authMethod=selectClientAuthMethod(clientInformation,supportedMethods);applyClientAuthentication(authMethod,clientInformation,headers,tokenRequestParams)}let response=await fetchWithinOrigin(fetchFn??fetch)(tokenUrl,{method:"POST",headers,body:tokenRequestParams});if(!response.ok)throw await parseErrorResponse(response);return TokenResponseSchema.parse(await response.json())}async function exchangeAuthorization(authorizationServerUrl,{metadata,clientInformation,authorizationCode,codeVerifier,redirectUri,resource,addClientAuthentication,fetchFn}){let tokenRequestParams=prepareAuthorizationCodeRequest(authorizationCode,codeVerifier,redirectUri);return executeTokenRequest(authorizationServerUrl,{metadata,tokenRequestParams,clientInformation,addClientAuthentication,resource,fetchFn})}async function refreshAuthorization(authorizationServerUrl,{metadata,clientInformation,refreshToken,resource,addClientAuthentication,fetchFn}){let tokenRequestParams=new URLSearchParams({grant_type:"refresh_token",refresh_token:refreshToken}),tokens=await executeTokenRequest(authorizationServerUrl,{metadata,tokenRequestParams,clientInformation,addClientAuthentication,resource,fetchFn});return{refresh_token:refreshToken,...tokens}}async function fetchToken(provider,authorizationServerUrl,{metadata,resource,authorizationCode,fetchFn}={}){let readClientInformation=async()=>{let storedClientInformation=await provider.clientInformation(),checked=discardIfIssuerMismatch(storedClientInformation,String(authorizationServerUrl));if(storedClientInformation&&!checked)throw boundElsewhereError(storedClientInformation,String(authorizationServerUrl));return checked},clientInformation=await readClientInformation(),scope=provider.clientMetadata.scope,tokenRequestParams;if(provider.prepareTokenRequest&&(tokenRequestParams=await provider.prepareTokenRequest(scope)),!tokenRequestParams){if(!authorizationCode)throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");if(!provider.redirectUrl)throw new Error("redirectUrl is required for authorization_code flow");let codeVerifier=await provider.codeVerifier();tokenRequestParams=prepareAuthorizationCodeRequest(authorizationCode,codeVerifier,provider.redirectUrl)}return clientInformation??(clientInformation=await readClientInformation()),executeTokenRequest(authorizationServerUrl,{metadata,tokenRequestParams,clientInformation,addClientAuthentication:provider.addClientAuthentication,resource,fetchFn})}async function registerClient(authorizationServerUrl,{metadata,clientMetadata,scope,fetchFn}){let registrationUrl;if(metadata){if(!metadata.registration_endpoint)throw new Error("Incompatible auth server: does not support dynamic client registration");registrationUrl=new URL(metadata.registration_endpoint)}else registrationUrl=new URL("/register",authorizationServerUrl);let response=await fetchWithinOrigin(fetchFn??fetch)(registrationUrl,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({...clientMetadata,...scope!==void 0?{scope}:{}})});if(!response.ok)throw await parseErrorResponse(response);return RegistrationResponseSchema.parse(await response.json())}export{UnauthorizedError,selectClientAuthMethod,parseErrorResponse,auth,isHttpsUrl,selectResourceURL,extractWWWAuthenticateParams,extractResourceMetadataUrl,discoverOAuthProtectedResourceMetadata,discoverOAuthMetadata,buildDiscoveryUrls,discoverAuthorizationServerMetadata,discoverOAuthServerInfo,startAuthorization,prepareAuthorizationCodeRequest,exchangeAuthorization,refreshAuthorization,fetchToken,registerClient};

package/dist/bundle/chunks/cli-main-SWKFMTZQ.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import"./chunk-MYAENL22.js";import{enableStartupCompileCache}from"./chunk-KUE4AQN6.js";import"./chunk-UFJ2K7Q7.js";import{installStaleExtensionContainment,main}from"./chunk-J2U5VDG7.js";import"./chunk-MXZPAUFB.js";import"./chunk-FHXR4ZAC.js";import{configureHttpDispatcher}from"./chunk-2EFVQWXZ.js";import"./chunk-DXJJP6RP.js";import"./chunk-GXY5JEI5.js";import"./chunk-JRXKLIEQ.js";import"./chunk-GY5MR5KR.js";import"./chunk-EHQXLHRB.js";import"./chunk-XF3LJC3O.js";import"./chunk-CNPDUC4D.js";import"./chunk-CDRFFHLL.js";import"./chunk-RXKNOEQQ.js";import"./chunk-Y5OTHMXO.js";import"./chunk-MLVIYDHK.js";import"./chunk-TIVW4P37.js";import"./chunk-H4QOEVS5.js";import"./chunk-3LNSLJ7N.js";import"./chunk-MSQCTH6V.js";import"./chunk-KLAX467B.js";import"./chunk-JFFS72FL.js";import"./chunk-ORXZXUMC.js";import"./chunk-GZVCRV7I.js";import"./chunk-SOMFLLPD.js";import"./chunk-MTQQ2VQH.js";import"./chunk-KJZAY5YH.js";import"./chunk-W2BKZBYJ.js";import"./chunk-QMRJYMNH.js";import"./chunk-LYGAV6KU.js";import"./chunk-4AOMNOGY.js";import"./chunk-KUPQO7MC.js";import"./chunk-U67ML6CQ.js";import"./chunk-26UBFF6N.js";import"./chunk-YN7ELQ43.js";import"./chunk-OI4NMCKP.js";import"./chunk-G2UETS2R.js";import"./chunk-VNN2V74Y.js";import"./chunk-4WZRVZNX.js";import"./chunk-U3VOXCGP.js";import"./chunk-WFXUCVIR.js";import"./chunk-HB35RBP4.js";import"./chunk-Z6WGAK7W.js";import"./chunk-DLAY7CIU.js";import"./chunk-3BTN337S.js";import"./chunk-QXREUA5F.js";import"./chunk-RUGYFYH7.js";import"./chunk-OEFCY46F.js";import"./chunk-KRNXUTZJ.js";import"./chunk-TAV6QZFM.js";import"./chunk-PELNNWGO.js";import"./chunk-TTU2RNVX.js";import"./chunk-FDL4CF6F.js";import"./chunk-BWA4FVFW.js";import"./chunk-YU4AYH4C.js";import"./chunk-E6WYH3ZL.js";import"./chunk-COH5F7QV.js";import"./chunk-RFB5CBW7.js";import"./chunk-2VZJTDUX.js";import"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-WASCMT6Y.js";import"./chunk-T36LJ6MW.js";import"./chunk-QGJLZ6BI.js";import"./chunk-WHPDEDCC.js";import"./chunk-AA2L2RHH.js";import"./chunk-HK46JMSC.js";import"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import"./chunk-DMI55M2N.js";import"./chunk-PJ34QVL5.js";import"./chunk-BMX2U22F.js";import"./chunk-YU2P3CAR.js";import{installEarlyInspectorVmImportRecovery}from"./chunk-XBUSVKWC.js";import"./chunk-ZOFZRJSL.js";import"./chunk-2SOVDETB.js";import"./chunk-V3CK2AVC.js";import"./chunk-VRDU425E.js";import"./chunk-ZGAB7WQA.js";import{APP_NAME,scrubBrandFromEnvironment}from"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-MIENF2YK.js";import"./chunk-OXNWERO4.js";import"./chunk-QN2BHP3M.js";import"./chunk-NTK2MHJ5.js";import"./chunk-O5RYI3IW.js";import"./chunk-IKOFCODM.js";await enableStartupCompileCache();installEarlyInspectorVmImportRecovery();installStaleExtensionContainment();process.title=APP_NAME;scrubBrandFromEnvironment();process.env.PI_CODING_AGENT="true";process.emitWarning=(()=>{});configureHttpDispatcher();await main(process.argv.slice(2));

package/dist/bundle/chunks/dispatch-DEP4PEDZ.js

@@ -1,10 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{fetchWithinOrigin}from"./chunk-YP72RYUP.js";import{InitializeResultSchema,JSONRPCMessageSchema,LATEST_PROTOCOL_VERSION}from"./chunk-HPCS4HM4.js";import{ConnectError,createMcpLogger,isMcpNeedsAuthError,loadMcpSdkAuth,loadMcpSdkClient,loadMcpSdkStdioTransport,loadMcpSdkStreamableHttpTransport,loadMcpSdkTypes,reapProcessTree,safeOn,safeTimer}from"./chunk-CDRFFHLL.js";import{external_exports}from"./chunk-KUPQO7MC.js";import"./chunk-DLAY7CIU.js";import"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-IKOFCODM.js";var MCP_CLIENT_ELICITATION_CAPABILITY={elicitation:{}};function mcpClientCapabilities(elicitationEnabled=!0){return elicitationEnabled?MCP_CLIENT_ELICITATION_CAPABILITY:{}}var MCP_ELICITATION_TIMEOUT_MS=300*1e3,legacyUiProvider;async function rejectElicitation(){let{ErrorCode,McpError}=await loadMcpSdkTypes();throw new McpError(ErrorCode.InternalError,"Elicitation cannot be processed")}async function configureMcpElicitation(client,owner=legacyUiProvider,timeoutMs=MCP_ELICITATION_TIMEOUT_MS,elicitationEnabled=!0){if(!elicitationEnabled){let{ErrorCode,McpError}=await loadMcpSdkTypes();client.fallbackRequestHandler=async request2=>{if(request2.method==="elicitation/create")return rejectElicitation();throw new McpError(ErrorCode.MethodNotFound,"Method not found")};return}let{ElicitRequestSchema}=await loadMcpSdkTypes();client.setRequestHandler(ElicitRequestSchema,async request2=>{let params=request2.params;if(!("requestedSchema"in params))return rejectElicitation();let ui=typeof owner=="function"?owner():owner?.getMcpElicitationUi();return ui===void 0?rejectElicitation():await runElicitationForm(ui,params.message,params.requestedSchema,timeoutMs)})}async function runElicitationForm(ui,message,requestedSchema,timeoutMs=MCP_ELICITATION_TIMEOUT_MS){let timer,timeout=new Promise(resolve=>{timer=safeTimer("mcp.elicitation.timeout",timeoutMs,()=>resolve({action:"cancel"}),{logger:createMcpLogger("elicitation")})});try{return await Promise.race([collectForm(ui,message,requestedSchema),timeout])}finally{timer!==void 0&&clearTimeout(timer)}}async function collectForm(ui,message,requestedSchema){let content={},required=new Set(requestedSchema.required??[]);for(let[name,property]of Object.entries(requestedSchema.properties??{})){let title=`${message} - ${property.title??name}`;if(property.type==="boolean"){let picked=await ui.select(property.description?`${title}
-${property.description}`:title,["Yes","No"]);if(picked===void 0)return{action:"cancel"};switch(picked.trim().toLowerCase()){case"yes":case"y":case"true":content[name]=!0;break;case"no":case"n":case"false":content[name]=!1;break;default:return rejectElicitation()}continue}if(Array.isArray(property.enum)&&property.enum.length>0){let picked=await ui.select(title,property.enum.map(String));if(picked===void 0)return{action:"cancel"};content[name]=picked;continue}let answer=await ui.input(title,property.description);if(answer===void 0)return{action:"cancel"};if(answer.length===0){if(required.has(name))return rejectElicitation();continue}if(property.type==="number"||property.type==="integer"){let parsed=Number(answer);if(!Number.isFinite(parsed))return rejectElicitation();content[name]=parsed;continue}content[name]=answer}return Object.keys(content).length===0&&await ui.select(message,["Submit"])!=="Submit"?{action:"cancel"}:{action:"accept",content}}import{PassThrough}from"node:stream";var ProjectStdioTransport=class{#resolve;#create;#current;#epoch;constructor(resolve,create){this.stderr=new PassThrough,this.#epoch=0,this.#resolve=resolve,this.#create=create}get pid(){return this.#current?.pid??null}async start(){let epoch=this.#epoch,spec=await this.#resolve();if(epoch!==this.#epoch)throw new ConnectError("Project MCP spawn was invalidated; retry",{phase:"create",retriable:!0});let transport=this.#create(spec);if(this.#current=transport,transport.onmessage=message=>this.onmessage?.(message),transport.onclose=()=>this.onclose?.(),transport.onerror=error=>this.onerror?.(error),transport.stderr?.pipe(this.stderr,{end:!1}),await transport.start(),epoch!==this.#epoch)throw await transport.close(),new ConnectError("Project MCP spawn was invalidated; retry",{phase:"create",retriable:!0})}async send(message,_options){if(this.#current===void 0)throw new ConnectError("Project MCP transport has not started",{phase:"send",retriable:!0});await this.#current.send(message)}async close(){this.#epoch++,await this.#current?.close()}};async function materializeMcpTransport(options){let client=await buildMcpClient(options.elicitationUiProvider,options.elicitationEnabled);return options.spec.kind==="stdio"?materializeStdio(options.spec,options,client):materializeHttp(options.spec,client)}async function materializeStdio(spec,options,client){let{getDefaultEnvironment,StdioClientTransport}=await loadMcpSdkStdioTransport(),create=current=>new StdioClientTransport({args:current.args,command:current.command,cwd:current.cwd,env:{...current.projectPolicy?{}:getDefaultEnvironment(),...current.env,...oauthAccessTokenEnv(current.authProvider)},stderr:"pipe"}),transport=spec.projectPolicy&&spec.resolveBeforeStart!==void 0?new ProjectStdioTransport(spec.resolveBeforeStart,create):create(spec);return trackStdioStart(transport,options.onStart),pipeStderr(transport,options.logger,options.sink),dropNullNextCursor(transport),{client,close:()=>closeClientAndTransport(transport,client),readPid:()=>transport.pid,transport}}async function materializeHttp(spec,client){let{StreamableHTTPClientTransport}=await loadMcpSdkStreamableHttpTransport(),transport=new StreamableHTTPClientTransport(spec.url,{authProvider:spec.authProvider,requestInit:spec.requestInit});return dropNullNextCursor(transport),{client,close:()=>closeClientAndTransport(transport,client),readPid:()=>null,transport}}async function buildMcpClient(elicitationUiProvider,elicitationEnabled=!0){let{Client:McpClient}=await loadMcpSdkClient(),client=new McpClient({name:"senpi-mcp-client",version:"0.0.0"},{capabilities:mcpClientCapabilities(elicitationEnabled)});return await configureMcpElicitation(client,elicitationUiProvider,void 0,elicitationEnabled),client}function oauthAccessTokenEnv(authProvider){let accessToken=authProvider?.tokens()?.access_token;return accessToken===void 0||accessToken.length===0?{}:{OAUTH_ACCESS_TOKEN:accessToken}}function dropNullNextCursor(transport){let originalStart=transport.start.bind(transport);transport.start=async()=>{let deliver=transport.onmessage;deliver!==void 0&&(transport.onmessage=(message,extra)=>{if("result"in message&&message.result!==null&&typeof message.result=="object"){let result=message.result;result.nextCursor===null&&delete result.nextCursor}deliver(message,extra)}),await originalStart()}}function trackStdioStart(transport,onStart){let start=transport.start.bind(transport);transport.start=async()=>{await start(),onStart()}}function pipeStderr(transport,logger,sink){let pending="",stderr=transport.stderr;stderr!=null&&(safeOn(stderr,"data","transport.stderr.data",chunk=>{if(!Buffer.isBuffer(chunk)&&typeof chunk!="string")return;pending+=Buffer.isBuffer(chunk)?chunk.toString("utf8"):chunk;let lines=pending.split(/\r?\n/);pending=lines.pop()??"";for(let line of lines)line.length>0&&logger.stderr(line)},sink),safeOn(stderr,"end","transport.stderr.end",()=>{pending.length>0&&logger.stderr(pending),pending=""},sink))}async function closeClientAndTransport(transport,client){isTerminableHttpTransport(transport)&&await transport.terminateSession().catch(()=>{}),await transport.close().catch(()=>{}),await client.close().catch(()=>{})}function isTerminableHttpTransport(transport){return"terminateSession"in transport&&typeof transport.terminateSession=="function"}import{Buffer as Buffer2}from"node:buffer";var MODERN_PROTOCOL_VERSION="2026-07-28",MODERN_ERROR_CODES={HeaderMismatch:-32020,MissingRequiredClientCapabilityError:-32021,UnsupportedProtocolVersionError:-32022};function buildModernRequest(id,method,clientInfo2,clientCapabilities,params={}){return{jsonrpc:"2.0",id,method,params:{...params,_meta:{...params._meta,"io.modelcontextprotocol/protocolVersion":MODERN_PROTOCOL_VERSION,"io.modelcontextprotocol/clientInfo":clientInfo2,"io.modelcontextprotocol/clientCapabilities":clientCapabilities}}}}function modernizeRequest(id,method,clientInfo2,clientCapabilities,version,params){let built=buildModernRequest(id,method,clientInfo2,clientCapabilities,params);return{...built,params:{...built.params,_meta:{...built.params._meta,"io.modelcontextprotocol/protocolVersion":version}}}}function deriveModernHeaders(request2){let headers={"MCP-Protocol-Version":request2.params._meta["io.modelcontextprotocol/protocolVersion"],"Mcp-Method":request2.method},name=request2.method==="resources/read"?request2.params.uri:request2.method==="tools/call"||request2.method==="prompts/get"?request2.params.name:void 0;return typeof name=="string"&&(headers["Mcp-Name"]=/^[\x20-\x7E]*$/.test(name)&&!name.startsWith("base64:")?name:`base64:${Buffer2.from(name,"utf8").toString("base64url")}`),headers}function classifyModernError(body2){let response=parseBody(body2);if(!isRecord(response)||response.jsonrpc!=="2.0"||!isRecord(response.error))return;let error=response.error;if(typeof error.message!="string")return;let common={message:error.message,..."data"in error?{data:error.data}:{}};switch(error.code){case MODERN_ERROR_CODES.HeaderMismatch:return{...common,kind:"HeaderMismatch",code:error.code};case MODERN_ERROR_CODES.MissingRequiredClientCapabilityError:return{...common,kind:"MissingRequiredClientCapabilityError",code:error.code};case MODERN_ERROR_CODES.UnsupportedProtocolVersionError:{let supported=isRecord(error.data)?error.data.supported:void 0;return{...common,kind:"UnsupportedProtocolVersionError",code:error.code,...Array.isArray(supported)&&supported.every(version=>typeof version=="string")?{supportedVersions:supported}:{}}}default:return}}function parseBody(body2){if(typeof body2!="string")return body2;try{return JSON.parse(body2)}catch(error){if(error instanceof SyntaxError)return;throw error}}function isRecord(value){return typeof value=="object"&&value!==null&&!Array.isArray(value)}var discoverySchema=external_exports.object({resultType:external_exports.literal("complete"),supportedVersions:external_exports.array(external_exports.string()),capabilities:external_exports.record(external_exports.string(),external_exports.unknown()),_meta:external_exports.object({"io.modelcontextprotocol/serverInfo":external_exports.object({name:external_exports.string(),version:external_exports.string()}).passthrough()}).passthrough(),instructions:external_exports.string().optional(),ttlMs:external_exports.number().nonnegative().optional(),cacheScope:external_exports.string().optional()}).passthrough(),modernError=classifyModernError,STDIO_PROBE_ID="senpi-era-probe",StdioProbeSilence=class extends Error{constructor(){super("MCP stdio server did not answer discovery in time"),this.name="StdioProbeSilence"}};function discoveryReply(value,id){return complete(value,id)}function request(options,version,id=1){let built=buildModernRequest(id,"server/discover",options.clientInfo,options.clientCapabilities);return{...built,params:{_meta:{...built.params._meta,"io.modelcontextprotocol/protocolVersion":version}}}}function complete(value,id=1){let parsed=external_exports.object({jsonrpc:external_exports.literal("2.0"),id:external_exports.literal(id),result:discoverySchema}).safeParse(value);return parsed.success?parsed.data.result:void 0}function errorReply(value,id){return external_exports.object({jsonrpc:external_exports.literal("2.0"),id:id===void 0?external_exports.union([external_exports.string(),external_exports.number(),external_exports.null()]):external_exports.literal(id),error:external_exports.object({code:external_exports.number(),message:external_exports.string()})}).safeParse(value).success}function mutualVersion(error,options){if(!(error.kind!=="UnsupportedProtocolVersionError"||!error.supportedVersions))return error.supportedVersions.filter(candidate=>options.supportedVersions.includes(candidate)).sort().at(-1)}function indeterminate(reason,action,details={}){return{kind:"indeterminate",reason,action,...details}}function parseJson(text){try{return JSON.parse(text)}catch(error){if(error instanceof SyntaxError)return;throw error}}async function body(response){let text=await response.text();if(!response.headers.get("Content-Type")?.includes("text/event-stream"))return parseJson(text);for(let event of text.replace(/\r\n/g,`
-`).split(`
-
-`)){let data=event.split(`
-`).filter(line=>line.startsWith("data:")).map(line=>line.slice(5).replace(/^ /,"")).join(`
-`),value=parseJson(data);if(complete(value)||modernError(value))return value}}async function probeHttpEra(url,fetch,options){let version=MODERN_PROTOCOL_VERSION;for(let attempt=0;attempt<2;attempt++){let response,value;try{let discoveryRequest=request(options,version);response=await fetch(url,{method:"POST",headers:{"Content-Type":"application/json",Accept:"application/json, text/event-stream",...deriveModernHeaders(discoveryRequest)},body:JSON.stringify(discoveryRequest)}),value=await body(response)}catch(cause){if(isMcpNeedsAuthError(cause))throw cause;return indeterminate("transport","Check the MCP endpoint connection and retry discovery.",{cause})}let error=modernError(value);if(response.status===400){if(!error)return attempt===0?{kind:"legacy-fallback"}:indeterminate("version-retry-rejected","Check server version negotiation; the modern retry failed.",{era:"modern"});if(error.code!==-32022)return{kind:attempt?"modern-version-retry":"modern-OK",version,error};if(attempt===1)return indeterminate("version-retry-rejected","Update client or server; the single version retry was rejected.",{era:"modern"});let mutual=mutualVersion(error,options);if(!mutual)return indeterminate("no-mutual-version","Update client or server to share a supported protocol version.",{era:"modern"});version=mutual;continue}if(!error&&errorReply(value))return attempt===0?{kind:"legacy-fallback"}:indeterminate("version-retry-rejected","Check server version negotiation; the modern retry failed.",{era:"modern"});if(!response.ok)return indeterminate("http-status","Check endpoint, authentication, or server health before retrying.",{status:response.status});let discovery=complete(value);return discovery?{kind:attempt?"modern-version-retry":"modern-OK",version,discovery}:error?{kind:attempt?"modern-version-retry":"modern-OK",version,error}:indeterminate("invalid-discovery","Check that the server returns a complete server/discover envelope.")}return indeterminate("version-retry-rejected","Update client or server protocol versions.",{era:"modern"})}async function probeStdioEra(send,options){let version=MODERN_PROTOCOL_VERSION,retryRejected=()=>indeterminate("version-retry-rejected","Update client or server; the single version retry was rejected.",{era:"modern"});for(let attempt=0;attempt<2;attempt++){let id=attempt===0?STDIO_PROBE_ID:`${STDIO_PROBE_ID}-${attempt}`,value;try{value=await send(request(options,version,id))}catch(error2){return attempt>0?retryRejected():error2 instanceof StdioProbeSilence?{kind:"legacy-fallback",silent:!0}:{kind:"legacy-fallback",restart:!0}}let kind=attempt===0?"modern-OK":"modern-version-retry",discovery=complete(value,id);if(discovery)return{kind,version,discovery};if(!errorReply(value,id))return attempt>0?retryRejected():{kind:"legacy-fallback",restart:!0};let error=modernError(value);if(!error)return attempt>0?retryRejected():{kind:"legacy-fallback"};let mutual=attempt===0?mutualVersion(error,options):void 0;if(!mutual)return{kind,version,error};version=mutual}return retryRejected()}function modernHttpFetch(spec,signal){let fetch=fetchWithinOrigin();return async(url,init)=>{let requestSignal=init?.signal?AbortSignal.any([signal,init.signal]):signal,send=()=>{let headers=new Headers,tokens=spec.authProvider?.tokens();tokens&&headers.set("Authorization",`Bearer ${tokens.access_token}`),new Headers(spec.requestInit?.headers).forEach((value,key)=>{headers.set(key,value)});for(let key of["Mcp-Session-Id","Mcp-Name","Mcp-Method","MCP-Protocol-Version"])headers.delete(key);return new Headers(init?.headers).forEach((value,key)=>{headers.set(key,value)}),headers.delete("Mcp-Session-Id"),fetch(url,{...spec.requestInit,...init,headers,signal:requestSignal})},response=await send();if(spec.authProvider&&(response.status===401||response.status===403)){let{auth,extractWWWAuthenticateParams,UnauthorizedError}=await loadMcpSdkAuth(),{resourceMetadataUrl,scope,error}=extractWWWAuthenticateParams(response);if(response.status===401||error==="insufficient_scope"){if(await response.body?.cancel(),await auth(spec.authProvider,{serverUrl:spec.url,resourceMetadataUrl,scope,fetchFn:(target,request2)=>fetch(target,{...request2,signal:request2?.signal?AbortSignal.any([requestSignal,request2.signal]):requestSignal})})!=="AUTHORIZED")throw new UnauthorizedError;if(response=await send(),response.status===401)throw await response.body?.cancel(),new UnauthorizedError("Server returned 401 after successful authentication")}}return response}}var ModernTransportError=class extends Error{constructor(message){super(message),this.name="ModernTransportError"}},ModernHttpTransport=class{#options;#abort=new AbortController;#started=!1;#closed=!1;constructor(options){this.#options=options}async start(){if(this.#started||this.#closed)throw new ModernTransportError("Modern MCP transport cannot be started twice");this.#started=!0}async close(){this.#closed||(this.#closed=!0,this.#abort.abort(),this.onclose?.())}async send(message){if(!this.#started||this.#closed)throw new ModernTransportError("Modern MCP transport is not open");try{let version=this.#options.protocolVersion??MODERN_PROTOCOL_VERSION,headers=new Headers(this.#options.headers);for(let name of["Mcp-Session-Id","Mcp-Name","Mcp-Method","MCP-Protocol-Version"])headers.delete(name);headers.set("Content-Type","application/json"),headers.set("Accept","application/json, text/event-stream");let body2=message;if("method"in message){let request2=modernizeRequest("id"in message?message.id:0,message.method,this.#options.clientInfo,this.#options.clientCapabilities,version,message.params);for(let[name,value]of Object.entries(deriveModernHeaders(request2)))headers.set(name,value);if("id"in message)body2=request2;else{let{id:_id,...notification}=request2;body2=notification}}else headers.set("MCP-Protocol-Version",version);let response=await this.#options.fetch(this.#options.url,{method:"POST",headers,body:JSON.stringify(body2),signal:this.#abort.signal});if(this.#abort.signal.throwIfAborted(),response.status===202||response.status===204)return;let mediaType=response.headers.get("Content-Type")?.split(";")[0].trim().toLowerCase();if(mediaType==="application/json"){let incoming=JSONRPCMessageSchema.parse(await response.json());if(!response.ok&&!("error"in incoming))throw new ModernTransportError(`Modern MCP POST failed with HTTP ${response.status}`);this.#abort.signal.throwIfAborted(),this.onmessage?.(incoming)}else if(response.ok&&mediaType==="text/event-stream"&&response.body)await this.#consumeSse(response.body,"method"in message&&"id"in message?message.id:void 0);else throw new ModernTransportError(`Modern MCP POST failed with HTTP ${response.status} (${mediaType??"no content type"})`)}catch(error){let failure=error instanceof Error?error:new ModernTransportError(String(error));throw this.onerror?.(failure),failure}}async#consumeSse(stream,requestId){let reader=stream.getReader(),decoder=new TextDecoder,aborted=Promise.withResolvers(),onabort=()=>aborted.reject(this.#abort.signal.reason);this.#abort.signal.addEventListener("abort",onabort,{once:!0});let buffer="",data=[],event="";try{for(;;){let{value,done}=await Promise.race([reader.read(),aborted.promise]);for(this.#abort.signal.throwIfAborted(),buffer+=done?decoder.decode():decoder.decode(value,{stream:!0});;){let match=/[\r\n]/.exec(buffer);if(match===null)break;let end=match.index;if(!done&&buffer[end]==="\r"&&end+1===buffer.length)break;let line=buffer.slice(0,end);if(buffer=buffer.slice(end+(buffer.slice(end,end+2)===`\r
-`?2:1)),line===""){if(data.length>0&&(event===""||event==="message")){let incoming=JSONRPCMessageSchema.parse(JSON.parse(data.join(`
-`)));if(this.onmessage?.(incoming),"id"in incoming&&!("method"in incoming)&&incoming.id===requestId)return}data=[],event=""}else if(!line.startsWith(":")){let colon=line.indexOf(":"),field=colon===-1?line:line.slice(0,colon),text=colon===-1?"":line.slice(colon+1).replace(/^ /,"");field==="data"&&data.push(text),field==="event"&&(event=text)}}if(done){if(requestId!==void 0)throw new ModernTransportError("Modern MCP SSE ended before the request response");return}}}finally{this.#abort.signal.removeEventListener("abort",onabort),await reader.cancel(),reader.releaseLock()}}};function modernInitializeResult(discovery,wireVersion){if(!discovery.supportedVersions.includes(wireVersion))throw new ModernTransportError(`Discovery does not support negotiated MCP version ${wireVersion}`);return InitializeResultSchema.parse({protocolVersion:LATEST_PROTOCOL_VERSION,capabilities:discovery.capabilities,serverInfo:discovery._meta["io.modelcontextprotocol/serverInfo"],...discovery.instructions===void 0?{}:{instructions:discovery.instructions}})}function normalizeModernResult(message){return"result"in message&&message.result.nextCursor===null&&delete message.result.nextCursor,message}var ModernSdkBridge=class{#transport;#initializeResult;#initialized=!1;constructor(transport,discovery,wireVersion){this.#initializeResult=modernInitializeResult(discovery,wireVersion),this.#transport=transport}async start(){this.#transport.onmessage=(message,extra)=>{this.onmessage?.(normalizeModernResult(message),extra)},this.#transport.onclose=()=>this.onclose?.(),this.#transport.onerror=error=>this.onerror?.(error),await this.#transport.start()}async send(message,options){if("method"in message&&message.method==="initialize"){if(!("id"in message)||this.#initialized)throw new ModernTransportError("Modern MCP bridge has already initialized");this.#initialized=!0,this.onmessage?.({jsonrpc:"2.0",id:message.id,result:this.#initializeResult});return}"method"in message&&message.method==="notifications/initialized"&&!("id"in message)||await this.#transport.send(message,options)}close(){return this.#transport.close()}};var STDIO_PROBE_MS=2e3;function probeStdioTransport(transport,options,logger,timeoutMs,serverName,onModern,probeMs=STDIO_PROBE_MS){let start=transport.start.bind(transport),close=transport.close.bind(transport),send=transport.send.bind(transport),abort=new AbortController;transport.close=async()=>{abort.abort(),await close()},transport.start=async()=>{await start();let outcome=await probeStdioEra(exchange,options);if(abort.signal.throwIfAborted(),outcome.kind==="legacy-fallback"){outcome.restart?await restart():outcome.silent&&awaitLateDiscovery();return}if(outcome.kind==="indeterminate"||!outcome.discovery){let reason=outcome.kind==="indeterminate"?outcome.reason:outcome.error?.message,message=`MCP server ${serverName} modern discovery failed: ${reason}`;throw logger.error(message),new ConnectError(message,{phase:"modern-stdio",serverName})}speakModern(outcome.discovery,outcome.version),onModern?.(outcome.version)};async function exchange(request2){let reply=Promise.withResolvers(),signal=AbortSignal.any([abort.signal,AbortSignal.timeout(Math.min(probeMs,Math.floor(timeoutMs/4)))]),onabort=()=>reply.reject(abort.signal.aborted?abort.signal.reason:new StdioProbeSilence),{onmessage,onclose,onerror}=transport;signal.addEventListener("abort",onabort,{once:!0}),transport.onmessage=(message,extra)=>{"id"in message&&!("method"in message)&&message.id===request2.id?reply.resolve(message):onmessage?.(message,extra)},transport.onclose=()=>reply.reject(new ModernTransportError("MCP stdio closed during discovery")),transport.onerror=error=>reply.reject(error);try{return signal.throwIfAborted(),send(request2).catch(reply.reject),await reply.promise}finally{signal.removeEventListener("abort",onabort),transport.onmessage=onmessage,transport.onclose=onclose,transport.onerror=onerror}}async function restart(){logger.info(`MCP server ${serverName}: no clean discovery answer; restarting it for the legacy handshake`);let pid=transport.pid,stale=pid==null?0:1,onclose=transport.onclose;transport.onclose=()=>{stale>0?stale--:onclose?.()},pid!=null&&await reapProcessTree(pid,{termWaitMs:200,killWaitMs:200}),await close(),stale=0,abort.signal.throwIfAborted(),await start(),abort.signal.aborted&&(await close(),abort.signal.throwIfAborted())}function awaitLateDiscovery(){let{onmessage:deliver,onclose,onerror}=transport,late,initialize,initializeId,restarting,settle=()=>{transport.onmessage=deliver,transport.onclose=onclose,transport.onerror=onerror,transport.send=send},unclean=report=>{if(restarting)return report();let replay=initialize;restarting=(async()=>{try{await restart(),replay&&await send(replay)}catch(error){abort.signal.aborted||onerror?.(error instanceof Error?error:new Error(String(error))),onclose?.()}})()};transport.onclose=()=>unclean(()=>onclose?.()),transport.onerror=error=>unclean(()=>onerror?.(error)),transport.onmessage=(message,extra)=>{if("id"in message&&!("method"in message)&&typeof message.id=="string"&&message.id.startsWith(STDIO_PROBE_ID)){late??=discoveryReply(message,message.id);return}let isInitializeReply=initializeId!==void 0&&"id"in message&&message.id===initializeId;if(isInitializeReply&&late&&"error"in message&&late.supportedVersions.includes(MODERN_PROTOCOL_VERSION)){let discovery=late;logger.info(`MCP server ${serverName}: late discovery reply; switching to modern`),settle(),speakModern(discovery,MODERN_PROTOCOL_VERSION),onModern?.(MODERN_PROTOCOL_VERSION),deliver?.({jsonrpc:"2.0",id:initializeId,result:modernInitializeResult(discovery,MODERN_PROTOCOL_VERSION)},extra);return}isInitializeReply&&settle(),deliver?.(message,extra)},transport.send=async(message,sendOptions)=>("method"in message&&message.method==="initialize"&&"id"in message&&(initialize=message,initializeId=message.id),restarting&&await restarting,send(message,sendOptions))}function speakModern(discovery,version){let initializeResult=modernInitializeResult(discovery,version),deliver=transport.onmessage,initialized=!1;transport.onmessage=(message,extra)=>deliver?.(normalizeModernResult(message),extra),transport.send=async(message,sendOptions)=>{if(!("method"in message))return send(message,sendOptions);if(message.method==="initialize"){if(!("id"in message)||initialized)throw new ModernTransportError("Modern MCP stdio has already initialized");initialized=!0,transport.onmessage?.({jsonrpc:"2.0",id:message.id,result:initializeResult});return}if(message.method==="notifications/initialized"&&!("id"in message))return;let request2=modernizeRequest("id"in message?message.id:0,message.method,options.clientInfo,options.clientCapabilities,version,message.params);if("id"in message)return send(request2,sendOptions);let{id:_id,...notification}=request2;return send(notification,sendOptions)}}}var clientInfo={name:"senpi-mcp-client",version:"0.0.0"};async function materializeNegotiatedTransport(options,serverName,timeoutMs,signal){signal.throwIfAborted();let clientCapabilities=mcpClientCapabilities(options.elicitationEnabled),probeOptions={clientInfo,clientCapabilities,supportedVersions:[MODERN_PROTOCOL_VERSION]},{spec,logger}=options,outcome={kind:"legacy-fallback"};if(spec.kind==="http"){let fetch=modernHttpFetch(spec,signal),timeout=AbortSignal.timeout(timeoutMs);if(outcome=await probeHttpEra(spec.url,(url,init)=>fetch(url,{...init,signal:timeout}),probeOptions),signal.throwIfAborted(),timeout.throwIfAborted(),outcome.kind==="modern-OK"||outcome.kind==="modern-version-retry"){if(!outcome.discovery)throw new ConnectError(`MCP server ${serverName} modern discovery failed: ${outcome.error?.message}`,{phase:"connect",serverName});let{Client}=await loadMcpSdkClient(),client=new Client(clientInfo,{capabilities:clientCapabilities});await configureMcpElicitation(client,options.elicitationUiProvider,void 0,options.elicitationEnabled);let transport=new ModernSdkBridge(new ModernHttpTransport({url:spec.url,fetch,clientInfo,clientCapabilities,protocolVersion:outcome.version}),outcome.discovery,outcome.version),version=outcome.version;return logVersion(transport,()=>version),{client,transport,readPid:()=>null,close:async()=>{await transport.close(),await client.close()}}}if(outcome.kind==="indeterminate"&&(outcome.era==="modern"||outcome.reason==="invalid-discovery"))throw new ConnectError(`MCP server ${serverName}: ${outcome.reason}. ${outcome.action}`,{phase:"connect",serverName,cause:outcome.cause})}let legacy=await materializeMcpTransport(options),stdioModernVersion;return spec.kind==="stdio"&&probeStdioTransport(legacy.transport,probeOptions,logger,timeoutMs,serverName,version=>{stdioModernVersion=version}),logVersion(legacy.transport,()=>stdioModernVersion),legacy;function logVersion(transport,readModernVersion){let setVersion=transport.setProtocolVersion?.bind(transport);transport.setProtocolVersion=sdkVersion=>{setVersion?.(sdkVersion);let modernVersion=readModernVersion();logger.info(`MCP server ${serverName} negotiated: era=${modernVersion?"modern":"legacy"} version=${modernVersion??sdkVersion}`)}}}export{materializeNegotiatedTransport};

package/dist/bundle/chunks/host-command-BC6UWP33.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{parseHostArgs,resolveHostSocket,runHostCommand}from"./chunk-KJZAY5YH.js";import"./chunk-W2BKZBYJ.js";import"./chunk-QMRJYMNH.js";import"./chunk-LYGAV6KU.js";import"./chunk-4AOMNOGY.js";import"./chunk-KUPQO7MC.js";import"./chunk-U67ML6CQ.js";import"./chunk-26UBFF6N.js";import"./chunk-YN7ELQ43.js";import"./chunk-OI4NMCKP.js";import"./chunk-G2UETS2R.js";import"./chunk-VNN2V74Y.js";import"./chunk-4WZRVZNX.js";import"./chunk-U3VOXCGP.js";import"./chunk-WFXUCVIR.js";import"./chunk-E6WYH3ZL.js";import"./chunk-COH5F7QV.js";import"./chunk-RFB5CBW7.js";import"./chunk-2VZJTDUX.js";import"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-T36LJ6MW.js";import"./chunk-QGJLZ6BI.js";import"./chunk-WHPDEDCC.js";import"./chunk-AA2L2RHH.js";import"./chunk-HK46JMSC.js";import"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import"./chunk-DMI55M2N.js";import"./chunk-PJ34QVL5.js";import"./chunk-VRDU425E.js";import"./chunk-ZGAB7WQA.js";import"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-MIENF2YK.js";import"./chunk-O5RYI3IW.js";import"./chunk-IKOFCODM.js";export{parseHostArgs,resolveHostSocket,runHostCommand};

package/dist/bundle/chunks/host-lifecycle-TN5NEGNF.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{INTERNAL_SUPERVISOR_FLAG,classifyChildExit,createInternalSocketPath,findInternalSupervisorArgs,parseSupervisorArgs,resolveCliMainPath,resolveHostChildLaunch,runHostSupervisor,spawnableChildLaunch}from"./chunk-G2UETS2R.js";import{DEFAULT_HANDOFF_GRACE_MS,DEFAULT_HOST_IDLE_EXIT_MS,HANDOFF_GRACE_MS_ENV,HOST_COLD_START_ENV,HOST_IDLE_EXIT_MS_ENV,IdleExitDecider,parseColdStart,parseIdleExitMs,resolveHostPolicy}from"./chunk-VNN2V74Y.js";import"./chunk-4WZRVZNX.js";import"./chunk-U3VOXCGP.js";import"./chunk-WFXUCVIR.js";import"./chunk-VRDU425E.js";import"./chunk-ZGAB7WQA.js";import"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-O5RYI3IW.js";import"./chunk-IKOFCODM.js";export{DEFAULT_HANDOFF_GRACE_MS,DEFAULT_HOST_IDLE_EXIT_MS,HANDOFF_GRACE_MS_ENV,HOST_COLD_START_ENV,HOST_IDLE_EXIT_MS_ENV,INTERNAL_SUPERVISOR_FLAG,IdleExitDecider,classifyChildExit,createInternalSocketPath,findInternalSupervisorArgs,parseColdStart,parseIdleExitMs,parseSupervisorArgs,resolveCliMainPath,resolveHostChildLaunch,resolveHostPolicy,runHostSupervisor,spawnableChildLaunch};

package/dist/bundle/chunks/host-session-command-MGVBLBRV.js

@@ -1,20 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{RpcClient,RpcCommandError,RpcRequestTimeoutError,RpcTransportGoneError,isTransportGoneError}from"./chunk-MXZPAUFB.js";import"./chunk-GY5MR5KR.js";import{SessionManager,assertValidSessionId}from"./chunk-XF3LJC3O.js";import"./chunk-CNPDUC4D.js";import"./chunk-KLAX467B.js";import"./chunk-SOMFLLPD.js";import{DEFAULT_HOST_LAUNCH_SPEC,HOST_EXIT_ERROR,HOST_EXIT_OK,HOST_EXIT_REFUSED,HOST_EXIT_USAGE,HostLaunchSpecError,STOP_WAIT_BUDGET_MS,daemonEnvKeys,daemonEnvOverrides,emit,ensureHost,loadHostLaunchSpec,refusal,resolveHostSocket,writeDaemonEnvKeys}from"./chunk-KJZAY5YH.js";import{HostEnsureRefusedError}from"./chunk-W2BKZBYJ.js";import"./chunk-QMRJYMNH.js";import{endpointKindOfSocket}from"./chunk-LYGAV6KU.js";import"./chunk-4AOMNOGY.js";import"./chunk-KUPQO7MC.js";import"./chunk-U67ML6CQ.js";import"./chunk-26UBFF6N.js";import"./chunk-YN7ELQ43.js";import{withRpcKeyRoot}from"./chunk-OI4NMCKP.js";import"./chunk-G2UETS2R.js";import"./chunk-VNN2V74Y.js";import{canonicalSessionPath,createHostDaemonPaths}from"./chunk-4WZRVZNX.js";import"./chunk-U3VOXCGP.js";import"./chunk-WFXUCVIR.js";import"./chunk-FDL4CF6F.js";import"./chunk-E6WYH3ZL.js";import"./chunk-COH5F7QV.js";import"./chunk-RFB5CBW7.js";import"./chunk-2VZJTDUX.js";import"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-T36LJ6MW.js";import"./chunk-QGJLZ6BI.js";import"./chunk-WHPDEDCC.js";import"./chunk-AA2L2RHH.js";import"./chunk-HK46JMSC.js";import"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import"./chunk-DMI55M2N.js";import"./chunk-PJ34QVL5.js";import"./chunk-VRDU425E.js";import"./chunk-ZGAB7WQA.js";import{APP_NAME,getAgentDir}from"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-MIENF2YK.js";import"./chunk-O5RYI3IW.js";import"./chunk-IKOFCODM.js";import{readFileSync}from"node:fs";import{resolve}from"node:path";var DETACH_ACK_TIMEOUT_MS=5e3;async function detachBeforeClose(client,report,timeoutMs=DETACH_ACK_TIMEOUT_MS){let timer,late=new Promise(resolve2=>{timer=setTimeout(()=>resolve2("late"),timeoutMs)});try{await Promise.race([client.detachConnection(),late])==="late"&&report(`the host did not confirm the detach within ${timeoutMs} ms; closing the connection anyway`)}catch(error){if(error instanceof RpcTransportGoneError)return;report(`the host refused the detach (${error instanceof Error?error.message:String(error)}); closing the connection anyway`)}finally{clearTimeout(timer)}}var USAGE_CODES=new Set(["missing_session_id","invalid_path","invalid_session_context","invalid_session_kind","invalid_launch_profile","invalid_session_id","invalid_release_reason","empty","unknown_command"]),FAILURE_CODES=new Set(["open_failed","warm_failed","release_failed"]),REASON_FOR_CODE={streaming:"busy",not_found:"unknown_cursor"},BARE_CODE=/^[a-z][a-z0-9_]*$/;function mapError(error,socket){let detail=error instanceof Error?error.message:String(error);if(error instanceof RpcCommandError){let code=error.errorCode??(BARE_CODE.test(detail)?detail:void 0);if(code===void 0)return hostError(detail,socket);let exitCode=USAGE_CODES.has(code)?HOST_EXIT_USAGE:FAILURE_CODES.has(code)?HOST_EXIT_ERROR:HOST_EXIT_REFUSED;return{exitCode,payload:{action:exitCode===HOST_EXIT_REFUSED?"refuse":"error",reason:REASON_FOR_CODE[code]??code,detail,socket,...error.errorData!==void 0&&{data:error.errorData}}}}return isTransportGoneError(error)?{exitCode:HOST_EXIT_ERROR,payload:{action:"error",reason:"transport_gone",detail,socket}}:hostError(detail,socket)}function hostError(detail,socket){return{exitCode:HOST_EXIT_ERROR,payload:{action:"error",reason:"host_error",detail,socket}}}async function openHostSession(client,request,socket,ensured){let opened=await client.openSession({cwd:request.cwd,retain_on_disconnect:!0,...request.model&&{provider:request.model.provider,modelId:request.model.id}});ensured?.release();let{state}=opened,identity={sessionId:opened.sessionId,sessionPath:state.sessionFile,durableSessionId:state.sessionId};try{request.name!==void 0&&await client.setSessionName(request.name);let disposition=request.prompt===void 0?void 0:await client.prompt(request.prompt);return{exitCode:HOST_EXIT_OK,payload:{action:"open",socket,pid:ensured?.pid,reused:ensured?.reused,...identity,cwd:state.cwd,model:state.model?{provider:state.model.provider,id:state.model.id}:null,attached:opened.attached??!1,...disposition!==void 0&&{prompt:{disposition}}}}}catch(error){let outcome=mapError(error,socket),closed=await closeOpened(client,opened.sessionId);return{...outcome,payload:{...outcome.payload,...identity,closed}}}}async function closeOpened(client,sessionId){try{return await client.closeSession(sessionId),!(await client.listSessions()).some(row=>row.sessionId===sessionId)}catch{return!1}}import{existsSync}from"node:fs";import{readdir}from"node:fs/promises";import{dirname,join}from"node:path";async function resolveSessionRef(client,ref,agentDir){let rows=await client.listSessions(),handle=rows.find(row=>row.sessionId===ref);if(handle)return{kind:"live",row:handle};if(isSessionId(ref)){let byId=await resolveDurableId(ref,rows,agentDir);if(byId)return byId}let named=rows.filter(row=>row.name===ref);if(named.length>1)return{kind:"ambiguous",candidates:named.map(row=>row.sessionId)};let live=named[0]??rows.find(row=>row.sessionPath!==void 0&&samePath(row.sessionPath,ref));return live?{kind:"live",row:live}:looksLikePath(ref)?parkedByPath(ref):{kind:"unknown"}}async function resolveDurableId(id,rows,agentDir){let liveRows=rows.filter(row=>row.durableSessionId===id),transcripts=(await transcriptsUnder(agentDir)).filter(session=>session.id===id),files=new Set([...liveRows.map(row=>row.sessionPath===void 0?row.sessionId:canonicalSessionPath(row.sessionPath)),...transcripts.map(session=>canonicalSessionPath(session.path))]);return files.size>1?{kind:"ambiguous",candidates:[...files]}:liveRows[0]?{kind:"live",row:liveRows[0]}:transcripts[0]?parked(transcripts[0]):void 0}function isSessionId(ref){try{return assertValidSessionId(ref),!0}catch{return!1}}function looksLikePath(ref){return ref.includes("/")||ref.includes("\\")||ref.endsWith(".jsonl")}async function parkedByPath(ref){let path=canonicalSessionPath(ref);if(!existsSync(path))return{kind:"unknown"};let info=(await SessionManager.listAll(dirname(path))).find(session=>samePath(session.path,path));return info?parked(info):{kind:"unknown"}}async function transcriptsUnder(agentDir){let root=join(agentDir,"sessions");if(!existsSync(root))return[];let dirs=(await readdir(root,{withFileTypes:!0})).filter(entry=>entry.isDirectory());return(await Promise.all(dirs.map(entry=>SessionManager.listAll(join(root,entry.name))))).flat()}function parked(info){return{kind:"parked",sessionPath:info.path,cwd:info.cwd,durableSessionId:info.id}}function samePath(left,right){return canonicalSessionPath(left)===canonicalSessionPath(right)}function waitForHostSession(client,sessionId,request,onTransportLoss){let started=Date.now();return new Promise((resolveWait,reject)=>{let finished=!1,observed=!1,state,timer,cleanup=()=>{finished=!0,clearTimeout(timer),unsubscribe(),onTransportLoss(void 0)},fail=error=>{finished||(cleanup(),reject(error))},finish=outcome=>{finished||(cleanup(),resolveWait({exitCode:HOST_EXIT_OK,payload:{action:"wait",sessionId,until:request.until,outcome,waited_ms:Date.now()-started,state:{isStreaming:state?.isStreaming??!1,pendingMessageCount:state?.pendingMessageCount??0,lastAbortSource:state?.lastAbortSource??null}}}))},unsubscribe=client.onEvent(record=>{let event=record;if(event.type==="session_closed"||event.type==="session_parked"){finish(event.type);return}if(event.type==="agent_settled"&&"reason"in event&&event.reason==="session_closed"){finish("session_closed");return}event.type!=="agent_idle"&&!(request.until==="done"&&event.type==="agent_settled")||(observed=!0,client.getState().then(snapshot=>{state=snapshot,request.until==="done"?finish("done"):isDrained(snapshot)&&finish("idle")},fail))});onTransportLoss(fail),timer=setTimeout(()=>{finished||(cleanup(),resolveWait({exitCode:HOST_EXIT_ERROR,payload:{action:"error",reason:"wait_timeout",sessionId,until:request.until,timeoutMs:request.timeoutMs}}))},request.timeoutMs),client.getState().then(snapshot=>{state=snapshot,!observed&&(request.until==="done"?!snapshot.isStreaming:isDrained(snapshot))&&finish("already_idle")},fail)})}function isDrained(state){return!state.isStreaming&&state.steering.length===0&&state.followUp.length===0&&state.ordered.length===0&&state.pendingMessageCount===0}async function runHostSessionRequest(request){let deadline=Date.now()+STOP_WAIT_BUDGET_MS;for(;;)try{return await runHostSessionRequestOnce(request,Math.max(0,deadline-Date.now()))}catch(error){if(request.action==="open"&&error instanceof RpcCommandError&&error.errorCode==="host_stopping"&&Date.now()<deadline)continue;return mapError(error,request.target.socket)}}async function runHostSessionRequestOnce(request,stoppingTimeoutMs){let{socket,agentDir}=request.target,client,ensured,disconnected,connectionUnusable=!1;try{if(await endpointKindOfSocket(socket,agentDir)==="tui")return refusal("refuse",void 0,{reason:"unsupported_endpoint_kind",socket,endpoint_kind:"tui"});request.action==="open"&&(ensured=await ensureHost({socket,agentDir,hostArgs:request.spec.hostArgs,env:daemonEnvOverrides(process.env,request.spec.env),policy:request.spec.policy,upgrade:"never",stoppingTimeoutMs}),ensured.reused||await writeDaemonEnvKeys(createHostDaemonPaths({socket,agentDir}),daemonEnvKeys(process.env,request.spec.env))),client=new RpcClient({socketPath:socket,onDisconnect:error=>{connectionUnusable=!0,disconnected?.(error)}});try{await client.start()}catch(error){if(error instanceof Error&&"code"in error&&(error.code==="ENOENT"||error.code==="ECONNREFUSED"))return refusal("refuse",void 0,{reason:"host_unavailable",socket,detail:error.message});throw error}let sessionId,durableSessionId;if("ref"in request){let found=await resolveSessionRef(client,request.ref,agentDir);if(found.kind==="unknown")return refusal("refuse",void 0,{reason:"unknown_session",ref:request.ref,socket});if(found.kind==="ambiguous"){let detail={reason:"ambiguous_session",ref:request.ref,candidates:found.candidates,socket};return refusal("refuse",void 0,detail)}let reopen=found.kind==="parked"?{sessionPath:found.sessionPath,cwd:found.cwd,retain_on_disconnect:!0,attended:!1}:{sessionPath:found.row.sessionPath,cwd:found.row.cwd};durableSessionId=found.kind==="parked"?found.durableSessionId:found.row.durableSessionId,sessionId=(await client.openSession(reopen)).sessionId}switch(request.action){case"open":return await openHostSession(client,request,socket,ensured);case"prompt":return{exitCode:HOST_EXIT_OK,payload:{action:"prompt",sessionId,disposition:await client.prompt(request.text)}};case"steer":{let streaming=(await client.getState()).isStreaming,disposition=await client.steer(request.text);return{exitCode:HOST_EXIT_OK,payload:{action:"steer",sessionId,disposition,streaming}}}case"abort":{let aborted=(await client.getState()).isStreaming;return await client.abortStrict(),{exitCode:HOST_EXIT_OK,payload:{action:"abort",sessionId,acknowledged:!0,aborted}}}case"model":{await client.setModel(request.model.provider,request.model.id);let state=await client.getState();return{exitCode:HOST_EXIT_OK,payload:{action:"model",sessionId,requested:request.model,model:state.model?{provider:state.model.provider,id:state.model.id}:null,pendingModelSwitch:state.pendingModelSwitch??null}}}case"list":return{exitCode:HOST_EXIT_OK,payload:{action:"list",socket,sessions:await client.listSessions({observe:!0})}};case"state":return{exitCode:HOST_EXIT_OK,payload:{action:"state",sessionId,durableSessionId,state:await client.getState()}};case"read":{if(request.messages){let all=await client.getMessages(),messages=request.tail===void 0?all:all.slice(-request.tail);return{exitCode:HOST_EXIT_OK,payload:{action:"read",sessionId,messages,count:messages.length}}}let{entries,leafId}=await client.getEntries(request.since),slice=request.tail===void 0?entries:entries.slice(-request.tail);return{exitCode:HOST_EXIT_OK,payload:{action:"read",sessionId,entries:slice,count:slice.length,total:entries.length,leafId,nextSince:slice.at(-1)?.id??request.since??null,...request.since!==void 0&&{since:request.since}}}}case"wait":return await waitForHostSession(client,sessionId,request,handler=>{disconnected=handler});case"unload":{let answer=await client.unloadSession({sessionId,interrupt:request.interrupt,force:request.force,clearQueue:request.clearQueue,children:request.children});return{exitCode:answer.outcome==="unloaded"?HOST_EXIT_OK:HOST_EXIT_REFUSED,payload:{action:"unload",sessionId,...answer}}}case"close":{let reason,unsubscribe=client.onEvent(record=>{let event=record;event.type==="session_closed"&&(reason=event.reason)});try{await client.closeSession(sessionId);let remaining=(await client.listSessions()).find(row=>row.sessionId===sessionId);return{exitCode:HOST_EXIT_OK,payload:remaining?{action:"close",sessionId,closed:!1,attachments:remaining.attachments}:{action:"close",sessionId,closed:!0,reason:reason??"client_close"}}}finally{unsubscribe()}}default:return assertNever(request)}}catch(error){if((error instanceof RpcRequestTimeoutError||isTransportGoneError(error))&&(connectionUnusable=!0),request.action==="open"&&error instanceof RpcCommandError&&error.errorCode==="host_stopping")throw error;return error instanceof HostEnsureRefusedError?refusal("refuse",void 0,{reason:error.reason,socket,detail:error.detail}):mapError(error,socket)}finally{ensured?.release(),client&&!connectionUnusable&&await detachBeforeClose(client,line=>process.stderr.write(`senpi host session: ${line}
-`)),await client?.stop()}}function assertNever(value){throw new Error(`unreachable host session request: ${JSON.stringify(value)}`)}var USAGE=`usage: ${APP_NAME} host session <command> [--socket <path>] [--rpc-key-root <dir>] [--json]
-
-  open --cwd <dir> [--model <provider/id>] [--name <text>] [--prompt <text|@file>] [--launch-spec <file>]
-  close <ref>
-  model <ref> <provider/id>
-  prompt <ref> <text|@file>
-  steer <ref> <text|@file>
-  abort <ref>
-  read <ref> [--tail <N>] [--since <entryId>] [--messages]
-  state <ref>
-  list
-  wait <ref> [--until idle|done] [--timeout <ms>]
-
-Every command prints one JSON line. wait defaults to idle and 600000 ms.
-@file is verbatim UTF-8 prompt text (BOM stripped), not an attachment wrapper.
-References accept a host session id, durable session id, path, or name.`;function parseHostSessionArgs(args){let[action,...rest]=args;if(!["open","close","unload","model","prompt","steer","abort","read","state","list","wait"].includes(action??""))return`Unknown host session command "${action??""}".`;let values={},positional=[],messages=!1,unloadFlags={interrupt:!1,force:!1,clearQueue:!1};for(let index=0;index<rest.length;index++){let flag=rest[index];if(flag==="--json")continue;if(action==="unload"&&(flag==="--interrupt"||flag==="--force"||flag==="--clear-queue")){unloadFlags[flag==="--clear-queue"?"clearQueue":flag.slice(2)]=!0;continue}if(flag==="--messages"&&action==="read"){messages=!0;continue}if(!flag.startsWith("--")){positional.push(flag);continue}let allowed=flag==="--socket"||flag==="--rpc-key-root"||action==="open"&&["--cwd","--model","--name","--prompt","--launch-spec"].includes(flag)||action==="read"&&["--tail","--since"].includes(flag)||action==="wait"&&["--until","--timeout"].includes(flag)||action==="unload"&&flag==="--children",value=rest[++index];if(!allowed||value===void 0||value.startsWith("--"))return`Invalid option or missing value: ${flag}.`;values[flag]=value}let count=action==="open"||action==="list"?0:["model","prompt","steer"].includes(action??"")?2:1;if(positional.length!==count)return`${action} expects ${count} positional argument(s).`;let ref=positional[0]??"",common={socket:values["--socket"],specPath:values["--launch-spec"],keyRoot:values["--rpc-key-root"]};switch(action){case"open":{if(!values["--cwd"])return"open requires --cwd <dir>.";let model=values["--model"]===void 0?void 0:parseModel(values["--model"]);return typeof model=="string"?model:{...common,command:{action,cwd:resolve(values["--cwd"]),model,name:values["--name"],prompt:values["--prompt"]}}}case"model":{let model=parseModel(positional[1]);return typeof model=="string"?model:{...common,command:{action,ref,model}}}case"prompt":case"steer":return{...common,command:{action,ref,text:positional[1]}};case"close":case"abort":case"state":return{...common,command:{action,ref}};case"list":return{...common,command:{action}};case"unload":{let children=values["--children"]??"refuse";return children!=="refuse"&&children!=="detach"?"--children must be refuse or detach.":{...common,command:{action,ref,...unloadFlags,children}}}case"read":{let tail=values["--tail"]===void 0?void 0:integer(values["--tail"],1);return tail===null?"--tail must be a positive integer.":messages&&values["--since"]!==void 0?"--since cannot be combined with --messages.":{...common,command:{action,ref,tail,since:values["--since"],messages}}}case"wait":{let until=values["--until"]??"idle",timeoutMs=integer(values["--timeout"]??"600000",0);return until!=="idle"&&until!=="done"?"--until must be idle or done.":timeoutMs===null?"--timeout must be a non-negative integer.":{...common,command:{action,ref,until,timeoutMs}}}default:return`Unknown host session command "${action}".`}}function parseModel(text){let parts=text.split("/");return parts.length!==2||!parts[0]||!parts[1]?"Model must be provider/id.":{provider:parts[0],id:parts[1]}}function integer(text,minimum){let value=Number(text);return/^\d+$/.test(text)&&Number.isSafeInteger(value)&&value>=minimum?value:null}function usage(reason,detail){return process.stderr.write(`${detail}
-${USAGE}
-`),emit({action:"error",reason,detail}),HOST_EXIT_USAGE}async function runHostSessionCommand(args){let parsed=parseHostSessionArgs(args);if(typeof parsed=="string")return usage("usage",parsed);try{let command=parsed.command;try{"text"in command&&(command.text=promptText(command.text)),command.action==="open"&&command.prompt!==void 0&&(command.prompt=promptText(command.prompt))}catch(error){return usage("prompt_file_unreadable",error instanceof Error?error.message:String(error))}let agentDir=getAgentDir(),target={socket:resolveHostSocket(parsed.socket,agentDir),agentDir},request=command.action==="open"?{...command,target,spec:parsed.specPath===void 0?DEFAULT_HOST_LAUNCH_SPEC:await loadHostLaunchSpec(parsed.specPath)}:{...command,target},outcome=await withRpcKeyRoot(parsed.keyRoot===void 0?process.env.SENPI_RPC_KEY_ROOT??agentDir:resolve(parsed.keyRoot),()=>runHostSessionRequest(request));return emit(outcome.payload),outcome.exitCode}catch(error){return error instanceof HostLaunchSpecError?usage(error.reason,error.detail):(emit({action:"error",reason:"host_error",detail:error instanceof Error?error.message:String(error)}),HOST_EXIT_ERROR)}}function promptText(text){return text.startsWith("@")?readFileSync(text.slice(1),"utf8").replace(/^\uFEFF/,""):text}export{parseHostSessionArgs,runHostSessionCommand};

package/dist/bundle/chunks/interactive-mode-SCSROHD5.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{InteractiveMode,OptimisticUserEchoController,createInteractiveTui,createInteractiveTuiReference,formatCrashExtensionHint,formatResumeCommand,isApiKeyLoginProvider,shouldShowRetryIndicator,showsStartupDetails,showsStartupHeader}from"./chunk-J2U5VDG7.js";import"./chunk-MXZPAUFB.js";import"./chunk-FHXR4ZAC.js";import"./chunk-2EFVQWXZ.js";import"./chunk-DXJJP6RP.js";import"./chunk-GXY5JEI5.js";import"./chunk-JRXKLIEQ.js";import"./chunk-GY5MR5KR.js";import"./chunk-EHQXLHRB.js";import"./chunk-XF3LJC3O.js";import"./chunk-CNPDUC4D.js";import"./chunk-CDRFFHLL.js";import"./chunk-RXKNOEQQ.js";import"./chunk-Y5OTHMXO.js";import"./chunk-MLVIYDHK.js";import"./chunk-TIVW4P37.js";import"./chunk-H4QOEVS5.js";import"./chunk-3LNSLJ7N.js";import"./chunk-MSQCTH6V.js";import"./chunk-KLAX467B.js";import"./chunk-JFFS72FL.js";import"./chunk-ORXZXUMC.js";import"./chunk-GZVCRV7I.js";import"./chunk-SOMFLLPD.js";import"./chunk-MTQQ2VQH.js";import"./chunk-KJZAY5YH.js";import"./chunk-W2BKZBYJ.js";import"./chunk-QMRJYMNH.js";import"./chunk-LYGAV6KU.js";import"./chunk-4AOMNOGY.js";import"./chunk-KUPQO7MC.js";import"./chunk-U67ML6CQ.js";import"./chunk-26UBFF6N.js";import"./chunk-YN7ELQ43.js";import"./chunk-OI4NMCKP.js";import"./chunk-G2UETS2R.js";import"./chunk-VNN2V74Y.js";import"./chunk-4WZRVZNX.js";import"./chunk-U3VOXCGP.js";import"./chunk-WFXUCVIR.js";import"./chunk-HB35RBP4.js";import"./chunk-Z6WGAK7W.js";import"./chunk-DLAY7CIU.js";import"./chunk-3BTN337S.js";import"./chunk-QXREUA5F.js";import"./chunk-RUGYFYH7.js";import"./chunk-OEFCY46F.js";import"./chunk-KRNXUTZJ.js";import"./chunk-TAV6QZFM.js";import"./chunk-PELNNWGO.js";import"./chunk-TTU2RNVX.js";import"./chunk-FDL4CF6F.js";import"./chunk-BWA4FVFW.js";import"./chunk-YU4AYH4C.js";import"./chunk-E6WYH3ZL.js";import"./chunk-COH5F7QV.js";import"./chunk-RFB5CBW7.js";import"./chunk-2VZJTDUX.js";import"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-WASCMT6Y.js";import"./chunk-T36LJ6MW.js";import"./chunk-QGJLZ6BI.js";import"./chunk-WHPDEDCC.js";import"./chunk-AA2L2RHH.js";import"./chunk-HK46JMSC.js";import"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import"./chunk-DMI55M2N.js";import"./chunk-PJ34QVL5.js";import"./chunk-BMX2U22F.js";import"./chunk-YU2P3CAR.js";import"./chunk-XBUSVKWC.js";import"./chunk-ZOFZRJSL.js";import"./chunk-2SOVDETB.js";import"./chunk-V3CK2AVC.js";import"./chunk-VRDU425E.js";import"./chunk-ZGAB7WQA.js";import"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-MIENF2YK.js";import"./chunk-OXNWERO4.js";import"./chunk-QN2BHP3M.js";import"./chunk-NTK2MHJ5.js";import"./chunk-O5RYI3IW.js";import"./chunk-IKOFCODM.js";export{InteractiveMode,OptimisticUserEchoController,createInteractiveTui,createInteractiveTuiReference,formatCrashExtensionHint,formatResumeCommand,isApiKeyLoginProvider,shouldShowRetryIndicator,showsStartupDetails,showsStartupHeader};

package/dist/bundle/chunks/rotation-stream-U7YQMC7H.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{STORE_BUSY,writeHealthUnlessStoreBusy}from"./chunk-OX5QL4YF.js";import{applyAccountOrder,classifyCredentialFailure,getConfigValueEnvVarNames,isCommittedRotationOutput,isRotationStreamStart,rendezvousOrder,resolveConfigValue,rotationErrorFromEvent,runCredentialFailover,slotsOfOwnKind}from"./chunk-3LNSLJ7N.js";import{activeModelBlockUntil,modelBlockKey,pruneModelBlocks,withModelBlock}from"./chunk-MSQCTH6V.js";import"./chunk-KLAX467B.js";import{acquireHalfOpenLease}from"./chunk-JFFS72FL.js";import"./chunk-ORXZXUMC.js";import"./chunk-GZVCRV7I.js";import{discoverEnvSlots}from"./chunk-4AOMNOGY.js";import"./chunk-KUPQO7MC.js";import"./chunk-U3VOXCGP.js";import"./chunk-Z6WGAK7W.js";import"./chunk-DLAY7CIU.js";import"./chunk-TAV6QZFM.js";import"./chunk-PELNNWGO.js";import"./chunk-BWA4FVFW.js";import"./chunk-YU4AYH4C.js";import"./chunk-E6WYH3ZL.js";import"./chunk-COH5F7QV.js";import"./chunk-RFB5CBW7.js";import"./chunk-2VZJTDUX.js";import"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-WASCMT6Y.js";import"./chunk-T36LJ6MW.js";import"./chunk-QGJLZ6BI.js";import"./chunk-WHPDEDCC.js";import"./chunk-AA2L2RHH.js";import"./chunk-HK46JMSC.js";import"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import{ConfigReferenceError}from"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import"./chunk-DMI55M2N.js";import"./chunk-PJ34QVL5.js";import"./chunk-BMX2U22F.js";import"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-MIENF2YK.js";import"./chunk-IKOFCODM.js";import{createHash,randomUUID}from"node:crypto";async function releaseLeaseIfModelBlocked(repository,providerId,lane,slotName,leaseId,until){until!==void 0&&await writeHealthUnlessStoreBusy(`lease release on ${slotName}`,()=>repository.mutateSlotState(providerId,lane,slotName,current=>{if(current?.lease?.id!==leaseId)return current;let{lease:_released,...rest}=current;return rest}))}function probeLease(repository,providerId,lane,slotName,now){return writeHealthUnlessStoreBusy(`probe lease on ${slotName}`,()=>acquireHalfOpenLease(repository,providerId,lane,slotName,{now}))}function overlayState(slot,state){return state?{...slot,...state.blockedUntil===void 0?{}:{blockedUntil:state.blockedUntil},...state.blockReason===void 0?{}:{blockReason:state.blockReason},...state.failureCount===void 0?{}:{failureCount:state.failureCount},...state.lease===void 0?{}:{lease:state.lease}}:slot}function overlayModelBlock(slot,until){return until===void 0||slot.blockedUntil!==void 0&&slot.blockedUntil>=until?slot:{...slot,blockedUntil:until,blockReason:slot.blockReason??"rate_limit"}}var warnedSlotReferences=new Set;async function listRotationSlots(sources,options={}){let acquireLeases=options.acquireLeases!==!1,modelId=options.modelId,now=sources.now??Date.now,{providerId,credential,env,repository}=sources,policySlots=[],referenceError;for(let[name,ref]of Object.entries(sources.policy?.slots??{})){let envVarName=ref.env??`models.json:${name}`,key;try{key=ref.env!==void 0?env(ref.env):ref.value!==void 0?await resolveConfigValue(ref.value,typeof ref.value=="string"?{}:Object.fromEntries(getConfigValueEnvVarNames(ref.value).flatMap(variable=>{let value=env(variable);return value===void 0?[]:[[variable,value]]}))):void 0}catch(error){if(!(error instanceof ConfigReferenceError))throw error;let notice=`${error.field}: configuration reference ${error.reason}; skipping credential slot`;warnedSlotReferences.has(notice)||(warnedSlotReferences.add(notice),console.warn(notice)),referenceError??=error;continue}key&&policySlots.push({name,envVarName,key,source:"env"})}if(credential){let state=await repository.listSlots(providerId,"stored"),slots=[];for(let slot of slotsOfOwnKind(credential)){let persisted=state[slot.name],storedRevision=await repository.storedCredentialRevision(providerId,slot.name,{key:slot.key,access:slot.access,refresh:slot.refresh}),applicable=persisted?.credentialRevision===storedRevision?persisted:void 0,modelUntil=activeModelBlockUntil(applicable?.modelBlocks,modelId,now()),lease;if(!(acquireLeases&&modelUntil===void 0&&applicable?.blockedUntil!==void 0&&applicable.blockedUntil<=now()&&(lease=await probeLease(repository,providerId,"stored",slot.name,now()),lease===void 0))){if(lease!==void 0&&lease!==STORE_BUSY){let leasedState=(await repository.listSlots(providerId,"stored"))[slot.name],leasedApplicable=leasedState?.credentialRevision===storedRevision?leasedState:void 0,leasedModelUntil=activeModelBlockUntil(leasedApplicable?.modelBlocks,modelId,now());await releaseLeaseIfModelBlocked(repository,providerId,"stored",slot.name,lease.leaseId,leasedModelUntil),slots.push(overlayModelBlock(overlayState({name:slot.name,lane:"stored",pinned:credential.pinned===slot.name,storedRevision},leasedApplicable),leasedModelUntil));continue}slots.push(overlayModelBlock(overlayState({name:slot.name,lane:"stored",pinned:credential.pinned===slot.name,storedRevision},applicable),modelUntil))}}if(policySlots.length===0){if(slots.length===0&&referenceError!==void 0)throw referenceError;return slots}let namedSources={...sources,credential:void 0,policy:{...sources.policy,slots:{}}},namedSlots=await listEnvRotationSlots(namedSources,policySlots,acquireLeases,modelId);return[...slots,...namedSlots]}let envSlots=[...discoverEnvSlots(providerId,env),...policySlots];if(envSlots.length===0&&referenceError!==void 0)throw referenceError;return listEnvRotationSlots(sources,envSlots,acquireLeases,modelId)}async function listEnvRotationSlots(sources,envSlots,acquireLeases,modelId){if(envSlots.length===0)return[];let{providerId,repository}=sources,now=sources.now??Date.now,state=await repository.listSlots(providerId,"env"),slots=[];for(let slot of envSlots){let persisted=state[slot.name],revision=await repository.envCredentialRevision(slot.envVarName,slot.key),applicable=persisted?.credentialRevision===revision?persisted:void 0,modelUntil=activeModelBlockUntil(applicable?.modelBlocks,modelId,now());if(acquireLeases&&modelUntil===void 0&&applicable?.blockedUntil!==void 0&&applicable.blockedUntil<=now()){let lease=await probeLease(repository,providerId,"env",slot.name,now());if(lease===void 0)continue;if(lease!==STORE_BUSY){let leasedState=(await repository.listSlots(providerId,"env"))[slot.name];applicable=leasedState?.credentialRevision===revision?leasedState:void 0,modelUntil=activeModelBlockUntil(applicable?.modelBlocks,modelId,now()),await releaseLeaseIfModelBlocked(repository,providerId,"env",slot.name,lease.leaseId,modelUntil)}}slots.push(overlayModelBlock(overlayState({name:slot.name,lane:"env",envKey:slot.key,envVarName:slot.envVarName},applicable),modelUntil))}return slots}var sha256SlotHasher=input=>createHash("sha256").update(input).digest().readBigUInt64BE(0);function modelBlockPatch(family,modelId,blockedUntil,current,now,credentialRevision){let sameMaterial=current!==void 0&&current.credentialRevision===credentialRevision,{stateVersion:_stateVersion,...kept}=sameMaterial?current:{stateVersion:0};return{...kept,lease:void 0,...credentialRevision===void 0?{}:{credentialRevision},modelBlocks:withModelBlock(sameMaterial?current.modelBlocks:void 0,modelBlockKey(family,modelId),blockedUntil,now)}}function blockPatch(block,current,now,credentialRevision,policy,modelId){if(block.reason==="rate_limit"&&block.modelFamily!==void 0&&modelId!==void 0){let blockedUntil=now+Math.min(policy?.cooldownCapMs??block.cooldownMs,block.cooldownMs);return modelBlockPatch(block.modelFamily,modelId,blockedUntil,current,now,credentialRevision)}let failureCount=(current?.failureCount??0)+1,liveModelBlocks=current?.credentialRevision===credentialRevision?pruneModelBlocks(current?.modelBlocks,now):void 0,base={failureCount,...credentialRevision===void 0?{}:{credentialRevision},...current?.lastSuccessAt===void 0?{}:{lastSuccessAt:current.lastSuccessAt},...liveModelBlocks===void 0?{}:{modelBlocks:liveModelBlocks}};return block.reason==="rate_limit"?{...base,blockedUntil:now+Math.min(policy?.cooldownCapMs??block.cooldownMs,block.cooldownMs),blockReason:"rate_limit"}:block.reason==="auth_error"?{...base,blockedUntil:now+9e5,blockReason:"auth_error"}:{...base,blockReason:block.reason}}function streamWithCredentialRotation(options){let{sources,runAttempt}=options,hasher=options.hasher??sha256SlotHasher,affinityKey=options.affinityKey??randomUUID(),useAffinity=sources.policy?.affinity!==!1,pooled=sources.credential,now=sources.now??Date.now;return runCredentialFailover({listSlots:()=>listRotationSlots(sources,options.modelId===void 0?{}:{modelId:options.modelId}),select:candidates=>{let pinned=candidates.find(candidate=>candidate.pinned===!0);if(pinned)return pinned;let ranked=useAffinity?rendezvousOrder(affinityKey,candidates,hasher):candidates,winner=applyAccountOrder(pooled?.order,ranked)[0];if(!winner)throw new Error("credential rotation selected from an empty candidate set");return winner},runAttempt,isCommittedOutput:isCommittedRotationOutput,isStreamStart:isRotationStreamStart,errorFromEvent:rotationErrorFromEvent,classify:(error,context)=>classifyCredentialFailure(error,{...context,nowMs:now(),cooldownBaseMs:sources.policy?.cooldownBaseMs,cooldownCapMs:sources.policy?.cooldownCapMs}),onSuccess:async slot=>{await writeHealthUnlessStoreBusy(`success on ${slot.name}`,()=>sources.repository.mutateSlotState(sources.providerId,slot.lane,slot.name,current=>current?{...current,lastSuccessAt:now(),lease:void 0,blockedUntil:void 0,blockReason:void 0,failureCount:void 0,modelBlocks:pruneModelBlocks(current.modelBlocks,now(),options.modelId)}:void 0))},persistBlock:async(slot,block)=>{let revision=slot.lane==="env"&&slot.envVarName!==void 0&&slot.envKey!==void 0?await sources.repository.envCredentialRevision(slot.envVarName,slot.envKey):slot.storedRevision;await writeHealthUnlessStoreBusy(`${block.reason} block on ${slot.name}`,()=>sources.repository.mutateSlotState(sources.providerId,slot.lane,slot.name,current=>blockPatch(block,current,now(),revision,sources.policy,options.modelId)))},now})}export{listRotationSlots,sha256SlotHasher,streamWithCredentialRotation};

package/dist/bundle/chunks/rpc-mode-TOXYD4XA.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{runRpcMode}from"./chunk-J2U5VDG7.js";import"./chunk-MXZPAUFB.js";import"./chunk-FHXR4ZAC.js";import"./chunk-2EFVQWXZ.js";import"./chunk-DXJJP6RP.js";import"./chunk-GXY5JEI5.js";import"./chunk-JRXKLIEQ.js";import"./chunk-GY5MR5KR.js";import"./chunk-EHQXLHRB.js";import"./chunk-XF3LJC3O.js";import"./chunk-CNPDUC4D.js";import"./chunk-CDRFFHLL.js";import"./chunk-RXKNOEQQ.js";import"./chunk-Y5OTHMXO.js";import"./chunk-MLVIYDHK.js";import"./chunk-TIVW4P37.js";import"./chunk-H4QOEVS5.js";import"./chunk-3LNSLJ7N.js";import"./chunk-MSQCTH6V.js";import"./chunk-KLAX467B.js";import"./chunk-JFFS72FL.js";import"./chunk-ORXZXUMC.js";import"./chunk-GZVCRV7I.js";import"./chunk-SOMFLLPD.js";import"./chunk-MTQQ2VQH.js";import"./chunk-KJZAY5YH.js";import"./chunk-W2BKZBYJ.js";import"./chunk-QMRJYMNH.js";import"./chunk-LYGAV6KU.js";import"./chunk-4AOMNOGY.js";import"./chunk-KUPQO7MC.js";import"./chunk-U67ML6CQ.js";import"./chunk-26UBFF6N.js";import"./chunk-YN7ELQ43.js";import"./chunk-OI4NMCKP.js";import"./chunk-G2UETS2R.js";import"./chunk-VNN2V74Y.js";import"./chunk-4WZRVZNX.js";import"./chunk-U3VOXCGP.js";import"./chunk-WFXUCVIR.js";import"./chunk-HB35RBP4.js";import"./chunk-Z6WGAK7W.js";import"./chunk-DLAY7CIU.js";import"./chunk-3BTN337S.js";import"./chunk-QXREUA5F.js";import"./chunk-RUGYFYH7.js";import"./chunk-OEFCY46F.js";import"./chunk-KRNXUTZJ.js";import"./chunk-TAV6QZFM.js";import"./chunk-PELNNWGO.js";import"./chunk-TTU2RNVX.js";import"./chunk-FDL4CF6F.js";import"./chunk-BWA4FVFW.js";import"./chunk-YU4AYH4C.js";import"./chunk-E6WYH3ZL.js";import"./chunk-COH5F7QV.js";import"./chunk-RFB5CBW7.js";import"./chunk-2VZJTDUX.js";import"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-WASCMT6Y.js";import"./chunk-T36LJ6MW.js";import"./chunk-QGJLZ6BI.js";import"./chunk-WHPDEDCC.js";import"./chunk-AA2L2RHH.js";import"./chunk-HK46JMSC.js";import"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import"./chunk-DMI55M2N.js";import"./chunk-PJ34QVL5.js";import"./chunk-BMX2U22F.js";import"./chunk-YU2P3CAR.js";import"./chunk-XBUSVKWC.js";import"./chunk-ZOFZRJSL.js";import"./chunk-2SOVDETB.js";import"./chunk-V3CK2AVC.js";import"./chunk-VRDU425E.js";import"./chunk-ZGAB7WQA.js";import"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-MIENF2YK.js";import"./chunk-OXNWERO4.js";import"./chunk-QN2BHP3M.js";import"./chunk-NTK2MHJ5.js";import"./chunk-O5RYI3IW.js";import"./chunk-IKOFCODM.js";export{runRpcMode};

package/dist/bundle/chunks/session-control-endpoint-HFFMBALG.js

@@ -1,3 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{SessionEventWriter,answerSubscribeSessions,answerUnsubscribeSessions,refusal,sessionRuntimeView,socketSink}from"./chunk-B6TPQDBW.js";import{WakeScheduler,answeredUiRequestId,availableModelsData,buildRpcSessionState,interruptRunningTurn,onProcessContinue,rpcCommandShapeError,runGetEffectStatus,settledQuestionStatus,subscribeSessionRecords,unansweredQuestionIds,unsupportedThinkingLevel,watchInbox}from"./chunk-JRXKLIEQ.js";import"./chunk-GY5MR5KR.js";import"./chunk-EHQXLHRB.js";import"./chunk-XF3LJC3O.js";import"./chunk-CNPDUC4D.js";import"./chunk-MLVIYDHK.js";import"./chunk-GZVCRV7I.js";import"./chunk-SOMFLLPD.js";import{SESSION_STATUS_CAPABILITY,acquireHostEnsureLock,engineBuildIdentity,gcHostEndpoints}from"./chunk-W2BKZBYJ.js";import"./chunk-QMRJYMNH.js";import"./chunk-LYGAV6KU.js";import"./chunk-KUPQO7MC.js";import"./chunk-U67ML6CQ.js";import"./chunk-26UBFF6N.js";import"./chunk-YN7ELQ43.js";import{tuiSocketName}from"./chunk-OI4NMCKP.js";import{thisProcessStartTime,writeHostRegistration}from"./chunk-VNN2V74Y.js";import{createDaemonDirectories,createHostDaemonPaths}from"./chunk-4WZRVZNX.js";import"./chunk-U3VOXCGP.js";import{MAX_RPC_LINE_CHARACTERS,attachJsonlLineReader,serializeJsonLine}from"./chunk-WFXUCVIR.js";import"./chunk-HB35RBP4.js";import"./chunk-RUGYFYH7.js";import"./chunk-KRNXUTZJ.js";import"./chunk-FDL4CF6F.js";import"./chunk-E6WYH3ZL.js";import"./chunk-COH5F7QV.js";import"./chunk-RFB5CBW7.js";import"./chunk-2VZJTDUX.js";import"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-T36LJ6MW.js";import"./chunk-QGJLZ6BI.js";import"./chunk-WHPDEDCC.js";import"./chunk-AA2L2RHH.js";import"./chunk-HK46JMSC.js";import"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import"./chunk-DMI55M2N.js";import"./chunk-PJ34QVL5.js";import"./chunk-YU2P3CAR.js";import{MAX_SOCKET_PATH_BYTES}from"./chunk-VRDU425E.js";import{authenticateSocket,createSocketSecret,socketSecretPath}from"./chunk-ZGAB7WQA.js";import{VERSION}from"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-MIENF2YK.js";import"./chunk-O5RYI3IW.js";import"./chunk-IKOFCODM.js";import{randomUUID as randomUUID2}from"node:crypto";import{rm as rm2}from"node:fs/promises";var ControlAttachments=class{constructor(session,pendingQuestions){this.writer=new SessionEventWriter(()=>{}),this.attached=new Set,this.session=session,this.writer.status.setSource({sessionIds:()=>[this.handle],entryView:id=>id===this.handle?this.entryView():void 0,view:id=>id===this.handle?{entry:this.entryView(),runtime:sessionRuntimeView(session,pendingQuestions())}:void 0}),this.writer.registerConnection(NULL_CONNECTION,{writeRaw:()=>{},waitForBackpressure:async()=>{}}),this.stopRecords=subscribeSessionRecords(session,record=>this.writer.enqueue(this.handle,record))}get handle(){return this.session.sessionId}opened(connection){this.writer.registerConnection(keyOf(connection),connection.transport)}closed(connection){let key=keyOf(connection);this.attached.delete(key)&&this.writer.status.publish(this.handle,"detach","client"),this.writer.unregisterConnection(key)}attach(connection){let key=keyOf(connection);return this.attached.has(key)?!1:(this.attached.add(key),this.writer.attachConnectionToSession(key,this.handle),this.writer.status.publish(this.handle,"attach","client"),!0)}isAttached(connection){return this.attached.has(keyOf(connection))}run(connection,task){return this.writer.withConnection(keyOf(connection),task)}respond(connection,answer2){this.writer.enqueueControl(answer2,keyOf(connection)).catch(()=>connection.transport.close?.())}dispose(){this.stopRecords()}entryView(){let manager=this.session.sessionManager,path=this.session.sessionFile,name=manager.getSessionName();return{state:"open",kind:"interactive",cwd:manager.getCwd(),attachments:1+this.attached.size,durableSessionId:this.session.sessionId,...path!==void 0?{sessionPath:path}:{},...name!==void 0?{name}:{},context:{}}}},NULL_CONNECTION="tui-null";function keyOf(connection){return`tui-${connection.id}`}import{randomUUID}from"node:crypto";import{realpathSync}from"node:fs";import{resolve}from"node:path";var TUI_RPC_COMMANDS=["open_session","subscribe_sessions","unsubscribe_sessions","steer","follow_up","prompt","get_effect_status"];async function runTuiRpcCommand(context,connection,command){switch(command.type){case"open_session":return openSession(context,connection,command);case"subscribe_sessions":return subscribe(context,connection,command);case"unsubscribe_sessions":return answerUnsubscribeSessions(command,keyOf(connection),context.attachments.writer.status);case"steer":case"follow_up":return admitInput(context,command,command.type==="steer"?"steer":"followUp",command.whenIdle);case"prompt":return admitPrompt(context,command);case"get_effect_status":return runGetEffectStatus({session:context.session,by:{connectionId:keyOf(connection)},sessionId:context.attachments.handle},command);default:return}}function idOf(command){return typeof command.id=="string"?command.id:void 0}function openSession(context,connection,command){let{session,attachments}=context,ownPath=typeof command.sessionPath=="string"&&samePath(command.sessionPath,session.sessionFile),ownId=command.sessionId!==void 0&&command.sessionId===session.sessionId;return!ownPath&&!ownId?refusal(idOf(command),"open_session","terminal_single_session",{reason:"this terminal hosts one session and the request names another",action:"open it by this terminal's sessionPath, or open the other session on a host"}):(attachments.run(connection,()=>{attachments.attach(connection),attachments.writer.enqueue(attachments.handle,{id:command.id,type:"response",command:"open_session",success:!0,data:{sessionId:attachments.handle,state:buildRpcSessionState(session),attached:!0}})}),null)}function subscribe(context,connection,command){let{writer}=context.attachments,key=keyOf(connection),{answer:answer2,activate}=answerSubscribeSessions(command,key,writer.status);return activate===void 0?answer2:(writer.enqueueControl(answer2,key).then(()=>{writer.hasConnection(key)?writer.status.activate(activate):writer.status.unsubscribe(key,activate)}).catch(()=>writer.status.unsubscribe(key,activate)),null)}function admitPrompt(context,command){let behavior=command.streamingBehavior;return behavior===void 0&&context.session.isStreaming?refusal(idOf(command),"prompt","session_busy",{reason:"a turn is running and the prompt names no streamingBehavior",action:'send it with streamingBehavior "steer" or "followUp", or as a steer/follow_up'}):admitInput(context,command,behavior==="followUp"?"followUp":"steer","start")}var UNSERVED_INPUT_FIELDS=["images","thinkingLevel","expandPromptTemplates","unknownCommandAsText","sessionTitlePrompt","enqueueOrder"];function samePath(requested,own){if(own===void 0)return!1;let canonical=path=>{try{return realpathSync(resolve(path))}catch{return resolve(path)}};return canonical(requested)===canonical(own)}function admitInput(context,command,deliverAs,whenIdle){let id=idOf(command),unserved=UNSERVED_INPUT_FIELDS.filter(field=>command[field]!==void 0);if(unserved.length>0)return refusal(id,command.type,"unsupported_field",{reason:`a terminal delivers input through its admission, which carries text only, not ${unserved.join(", ")}`,action:"send the message without those fields, or send it to a host session"});let message=command.message;if(typeof message!="string"||message.trim()==="")return refusal(id,command.type,"invalid_message",{reason:"message is empty",action:"send a non-empty message"});if(whenIdle!==void 0&&whenIdle!=="queue"&&whenIdle!=="start")return refusal(id,command.type,"invalid_when_idle",{reason:`whenIdle must be "queue" or "start", not ${JSON.stringify(whenIdle)}`,action:'send whenIdle: "queue" (the default) or "start"'});let admission=context.session.externalAdmission,clientMessageId=typeof command.clientMessageId=="string"?command.clientMessageId:void 0,expected=typeof command.expected_turn_id=="number"?command.expected_turn_id:admission.turnEpoch,result=admission.admit({delivery_id:clientMessageId??`tui-rpc-${randomUUID()}`,text:message,sender:{kind:"external",platform:"rpc"},deliverAs,expected_turn_id:expected,whenIdle:whenIdle==="start"?"start":"queue"}),identity=clientMessageId===void 0?{}:{clientMessageId};switch(result.kind){case"started":return answered(id,command.type,{disposition:"started",...identity});case"steered":case"queued":return answered(id,command.type,{disposition:"queued",...identity});case"already_admitted":return answered(id,command.type,{disposition:"queued",duplicate:!0,...identity});case"held_draft":return refusal(id,command.type,"held_draft",{reason:"the user is composing in this terminal, so nothing was delivered",action:"retry after the draft is sent or cleared"});case"turn_conflict":return refusal(id,command.type,"turn_conflict",{reason:`the turn moved on (now ${result.turn_epoch}); this steer named an earlier one`,action:"read get_state's turn_epoch and send it again"})}}function answered(id,command,data){return{...id===void 0?{}:{id},type:"response",command,success:!0,data}}import{chmod}from"node:fs/promises";import{createServer}from"node:net";async function listenControlSocket(socketPath,secret,handlers){let clients=new Set,nextConnection=0,server=createServer(socket=>{clients.add(socket),socket.once("close",()=>clients.delete(socket)),socket.on("error",()=>socket.destroy()),authenticateSocket(socket,secret,()=>acceptConnection(socket,++nextConnection,handlers))});return await new Promise((resolve2,reject)=>{server.once("error",reject),server.listen(socketPath,()=>{server.off("error",reject),resolve2()})}),server.on("error",error=>handlers.listenerError(error)),await chmod(socketPath,384),{close:()=>closeServer(server,clients)}}function acceptConnection(socket,id,handlers){let connection={id,send:record=>{handlers.respond!==void 0?handlers.respond(connection,record):socket.destroyed||socket.write(serializeJsonLine(record))},transport:socketSink(socket)};handlers.opened?.(connection);let detach=attachJsonlLineReader(socket,line=>{answer(connection,line,handlers)},{maxLineLength:MAX_RPC_LINE_CHARACTERS,onOversizedLine:()=>connection.send(failure(void 0,"parse","RPC line exceeds the size limit."))});socket.once("close",()=>{detach(),handlers.closed(connection)})}async function answer(connection,line,handlers){let parsed;try{parsed=JSON.parse(line)}catch{connection.send(failure(void 0,"parse","Invalid JSON."));return}let shapeError=rpcCommandShapeError(parsed);if(shapeError!==void 0||!isCommand(parsed)){connection.send(failure(void 0,"parse",shapeError??"RPC command needs a string `type`."));return}let answer2=await handlers.command(connection,parsed);answer2!==null&&connection.send(answer2)}function isCommand(value){return typeof value=="object"&&value!==null&&"type"in value&&typeof value.type=="string"}function failure(id,command,error){return{...id===void 0?{}:{id},type:"response",command,success:!1,error}}function success(id,command,data){return{...id===void 0?{}:{id},type:"response",command,success:!0,...data===void 0?{}:{data}}}function closeServer(server,clients){for(let client of clients)client.destroy();return new Promise(resolve2=>server.close(()=>resolve2()))}var SESSION_CONTROL_COMMANDS=["get_available_models","get_available_thinking_levels","set_model","set_thinking_level","interrupt"];async function runSessionControlCommand(session,controls,command){let{id,type}=command;switch(type){case"get_available_models":return success(id,type,await availableModelsData(session));case"get_available_thinking_levels":return success(id,type,{levels:session.getAvailableThinkingLevels()});case"set_model":return await setModel(session,controls,command);case"set_thinking_level":{let level=session.getAvailableThinkingLevels().find(candidate=>candidate===command.level);return level===void 0?failure(id,type,unsupportedThinkingLevel(command.level)):(controls.selectThinkingLevel(level,command.scope!=="turn"),success(id,type))}case"interrupt":return success(id,type,await interruptRunningTurn(session,command.turnId,()=>controls.interruptTurn()));default:return}}async function setModel(session,controls,command){let{id,type}=command,model=(await session.modelRegistry.getAvailable()).find(candidate=>candidate.provider===command.provider&&candidate.id===command.modelId);if(model===void 0)return failure(id,type,`Model not found: ${String(command.provider)}/${String(command.modelId)}`);try{let change=await controls.selectModel(model);return success(id,type,{...model,systemPromptName:change?.systemPromptName})}catch(error){return failure(id,type,error instanceof Error?error.message:String(error))}}var TUI_CONTROL_CAPABILITY="tui_control",TUI_CONTROL_COMMANDS=["get_protocol_info","list_sessions","get_state","get_messages","set_session_name","subscribe","wake","extension_ui_response",...SESSION_CONTROL_COMMANDS,...TUI_RPC_COMMANDS];async function runControlCommand(context,connection,command){let{id,type}=command,{session}=context;switch(type){case"get_protocol_info":{let build=engineBuildIdentity();return success(id,type,{protocolVersion:1,serverVersion:VERSION,capabilities:[TUI_CONTROL_CAPABILITY,SESSION_STATUS_CAPABILITY],mode:"tui",endpoint_kind:"tui",instanceId:context.instanceId,generation:0,engineVersion:build.text,engineOrdinal:build.ordinal,commands:TUI_CONTROL_COMMANDS})}case"list_sessions":return success(id,type,{sessions:[sessionRow(session)]});case"get_state":return success(id,type,{...buildRpcSessionState(session),turn_epoch:session.externalAdmission.turnEpoch,blocking_question:context.surface.blockingQuestion(),compacting:session.isCompacting,editor_has_draft:context.surface.draftHold()!==void 0,state_version:context.feed.stateVersion});case"get_messages":return success(id,type,{messages:session.messages});case"set_session_name":{let name=typeof command.name=="string"?command.name.trim():"";return name===""?failure(id,type,"Session name cannot be empty"):(session.setSessionName(name),success(id,type))}case"subscribe":{let cursor=typeof command.cursor=="number"?command.cursor:void 0;return success(id,type,{cursor:context.feed.subscribe(connection.id,cursor,connection.send)})}case"wake":{let ids=Array.isArray(command.delivery_ids)?command.delivery_ids.filter(entry=>typeof entry=="string"):void 0,result=await context.wake(ids);return success(id,type,{admitted:result.admitted??[]})}case"extension_ui_response":return answerQuestion(context.surface,command);default:{let rpc=await runTuiRpcCommand(context,connection,command);return rpc!==void 0?rpc:await runSessionControlCommand(session,context.surface,command)??failure(id,type,"unsupported")}}}function sessionRow(session){let manager=session.sessionManager,created=manager.getHeader()?.timestamp??null,last=manager.getEntries().at(-1);return{sessionId:session.sessionId,sessionPath:session.sessionFile??null,session_file:session.sessionFile??null,kind:"interactive",surface:"tui",cwd:manager.getCwd(),name:session.sessionName??null,created_at:created,updated_at:last?.timestamp??created,attachments:1}}function answerQuestion(surface,command){let frameId=command.id,requestId=answeredUiRequestId(command),request=requestId===void 0?void 0:surface.pendingQuestion(requestId);if(requestId===void 0||request===void 0)return failure(frameId,"extension_ui_response","unknown_request");let response=questionResponse(command,request.questions);return response==="question_incomplete"?failure(frameId,"extension_ui_response",response):response===void 0||!surface.answerQuestion(requestId,response)?failure(frameId,"extension_ui_response","invalid_response"):success(frameId,"extension_ui_response")}function questionResponse(command,questions){if(command.cancelled===!0)return{status:"cancelled",cancelOrigin:"user",answers:{},unanswered:[]};let answers=command.answers;if(typeof answers!="object"||answers===null||Array.isArray(answers))return;let parsed={};for(let[question,value]of Object.entries(answers)){if(typeof value!="object"||value===null||!("selected"in value)||!Array.isArray(value.selected))return;let selected=value.selected.filter(entry=>typeof entry=="string"),text="text"in value&&typeof value.text=="string"?value.text:void 0;parsed[question]=text===void 0?{selected}:{selected,text}}let comment=typeof command.comment=="string"?command.comment:void 0,status=settledQuestionStatus(parsed,comment);if(status===void 0)return"question_incomplete";let unanswered=unansweredQuestionIds(questions,parsed);return{status,resolvedBy:"control_endpoint",answers:parsed,unanswered,...comment===void 0?{}:{comment}}}var ControlFeed=class{constructor(){this.seq=0,this.stateVersionValue=0,this.ring=[],this.subscribers=new Map}get stateVersion(){return this.stateVersionValue}publish(kind,data={}){kind==="state"&&(this.stateVersionValue+=1);let event={type:"session_control_event",seq:++this.seq,kind,data:kind==="state"?{...data,state_version:this.stateVersionValue}:data};this.ring.push(event),this.ring.length>256&&this.ring.shift();for(let send of this.subscribers.values())send(event)}subscribe(connection,cursor,send){if(this.subscribers.set(connection,send),cursor!==void 0)for(let event of this.ring)event.seq>cursor&&send(event);return this.seq}unsubscribe(connection){this.subscribers.delete(connection)}clear(){this.subscribers.clear()}};import{createHash}from"node:crypto";import{rmSync}from"node:fs";import{chmod as chmod2,lstat,mkdir,realpath,rm}from"node:fs/promises";import{tmpdir}from"node:os";import{dirname,join}from"node:path";var PRIVATE_DIRECTORY_MODE=448,REGISTRY_LOCK_WAIT_MS=5e3;async function resolveTuiSocket(agentDir,instanceId){let name=tuiSocketName(instanceId),primary=join(agentDir,"rpc","tui",name);if(Buffer.byteLength(primary)<=MAX_SOCKET_PATH_BYTES)return await makePrivateDirectory(dirname(primary)),primary;let fallbackName=`senpi-rpc-${createHash("sha256").update(agentDir).digest("hex").slice(0,8)}`,scopedRoot=join(tmpdir(),fallbackName),root=Buffer.byteLength(join(scopedRoot,"tui",name))<=MAX_SOCKET_PATH_BYTES?scopedRoot:join("/tmp",fallbackName),tuiRoot=join(root,"tui");await makePrivateDirectory(tuiRoot);for(let directory of[root,tuiRoot])await assertPrivateDirectory(directory);let fallback=join(tuiRoot,name);if(Buffer.byteLength(fallback)>MAX_SOCKET_PATH_BYTES)throw new Error(`socket path ${fallback} exceeds ${MAX_SOCKET_PATH_BYTES} bytes`);return fallback}async function makePrivateDirectory(directory){await mkdir(directory,{recursive:!0,mode:PRIVATE_DIRECTORY_MODE}),await chmod2(directory,PRIVATE_DIRECTORY_MODE)}async function assertPrivateDirectory(directory){let stat=await lstat(await realpath(directory)),ownedByUs=process.getuid===void 0||stat.uid===process.getuid();if(!stat.isDirectory()||!ownedByUs||(stat.mode&63)!==0)throw new Error(`alt_root_unsafe: ${directory} is not a private directory of this user`)}async function registerTuiEndpoint(options){let paths=createHostDaemonPaths({socket:options.socket,agentDir:options.agentDir}),release=await acquireHostEnsureLock(options.socket,REGISTRY_LOCK_WAIT_MS);try{await writeHostRegistration(paths,{record:{pid:process.pid,processStartTime:await thisProcessStartTime()},socket:options.socket,instanceId:options.instanceId,generation:0,launchProfileId:"tui",build:engineBuildIdentity()},{fresh:!0}),await createDaemonDirectories(paths,{kind:"tui"})}finally{await release()}return{paths,socket:options.socket}}async function unregisterTuiEndpoint(entry){let release=await acquireHostEnsureLock(entry.socket,REGISTRY_LOCK_WAIT_MS).catch(()=>{});try{await rm(entry.socket,{force:!0}),await rm(socketSecretPath(entry.socket),{force:!0}),await rm(entry.paths.dir,{recursive:!0,force:!0})}finally{await release?.()}}function unregisterTuiEndpointSync(entry){rmSync(entry.socket,{force:!0}),rmSync(socketSecretPath(entry.socket),{force:!0}),rmSync(entry.paths.dir,{recursive:!0,force:!0})}var REPORT_TEXT_LIMIT=4e3;function activateControlEndpoint(parts){let{context,feed,wake}=parts,{session,surface}=context;session.externalAdmission.setEditorSource(()=>editorHold(context));let unsubscribeSession=session.subscribe(event=>{event.type==="agent_start"?feed.publish("state"):event.type==="agent_idle"?(feed.publish("completion",{turn_epoch:session.externalAdmission.turnEpoch}),feed.publish("state"),wake("idle")):event.type==="agent_end"||event.type==="queue_update"||event.type==="compaction_start"||event.type==="compaction_end"?feed.publish("state"):event.type==="message_end"&&event.message.role==="assistant"&&feed.publish("report",{text:assistantText(event.message).slice(0,REPORT_TEXT_LIMIT)})}),unsubscribeEmitted=session.externalAdmission.onEmitted(()=>{wake("emitted")}),unsubscribeInputs=session.externalAdmission.onInputsSettled(()=>queueMicrotask(()=>{wake("submission")})),stopContinue=onProcessContinue(()=>{wake("continue")}),exitCleanup=()=>unregisterTuiEndpointSync(parts.entry);process.once("exit",exitCleanup);let disposing,dispose=()=>(disposing??=(async()=>{process.removeListener("exit",exitCleanup),unsubscribeSession(),unsubscribeEmitted(),unsubscribeInputs(),stopContinue(),parts.stopInbox(),parts.scheduler.dispose(),feed.clear(),session.externalAdmission.setEditorSource(void 0),await parts.server.close(),await sessionReferenced(parts.options,surface)||await session.sessionManager.discardHeaderOnlyFile(),await unregisterTuiEndpoint(parts.entry)})(),disposing);return{socket:parts.entry.socket,wake:reason=>{wake(reason)},noteState:()=>feed.publish("state"),noteQuestions:()=>feed.publish("question",{pending:[...surface.pendingQuestionIds()]}),dispose}}function editorHold(context){let hold=context.surface.draftHold(),revision=context.editorRevision();return hold===void 0?{revision}:{hold_reason:hold,revision}}async function sessionReferenced(options,surface){if(options.isSessionReferenced===void 0)return!1;try{return await options.isSessionReferenced()}catch(error){return surface.notice(`control endpoint kept the session file: ${error instanceof Error?error.message:String(error)}`),!0}}function assistantText(message){return message.role!=="assistant"?"":message.content.flatMap(part=>part.type==="text"?[part.text]:[]).join(`
-`)}async function registerSessionControlEndpoint(context,options){let cleanups=[];try{let endpoint=await openEndpoint(context,options,cleanups);return{registration:{status:"registered",socket:endpoint.socket,dispose:endpoint.dispose},endpoint}}catch(error){for(let cleanup of cleanups.reverse())await Promise.resolve(cleanup()).catch(()=>{});let reason=errorText(error);return context.surface.notice(`control endpoint unavailable: ${reason}`),{registration:{status:"failed",reason}}}}async function openEndpoint(context,options,cleanups){let{session,agentDir,surface}=context;thisProcessStartTime();let headerDurable=session.sessionManager.persistHeaderNow();headerDurable.catch(()=>{});let instanceId=randomUUID2(),socket=await resolveTuiSocket(agentDir,instanceId);cleanups.push(()=>rm2(socket,{force:!0}),()=>rm2(socketSecretPath(socket),{force:!0}));let secret=await createSocketSecret(socketSecretPath(socket)),feed=new ControlFeed,failing,scheduler=new WakeScheduler(async event=>{await session.extensionRunner.emit(event);let result=await options.drain(event)??{admitted:[]};return failing=void 0,result},error=>{let reason=errorText(error);reason!==failing&&(failing=reason,surface.notice(`control endpoint drain failed: ${reason}`))});cleanups.push(()=>scheduler.dispose());let wake=(reason,ids)=>scheduler.request(reason,ids),attachments=new ControlAttachments(session,()=>surface.pendingQuestionIds().length);cleanups.push(()=>attachments.dispose());let commandContext={instanceId,session,surface,feed,wake:ids=>wake("command",ids),attachments},server=await listenControlSocket(socket,secret,{command:(connection,command)=>runControlCommand(commandContext,connection,command),opened:connection=>attachments.opened(connection),respond:(connection,answer2)=>attachments.respond(connection,answer2),closed:connection=>{feed.unsubscribe(connection.id),attachments.closed(connection)},listenerError:error=>surface.notice(`control endpoint listener failed: ${error.message}`)});cleanups.push(()=>server.close()),await headerDurable;let entry=await registerTuiEndpoint({agentDir,socket,instanceId});cleanups.push(()=>unregisterTuiEndpoint(entry));let inbox=await watchInbox(options.inboxDir,()=>{wake("inbox")},error=>surface.notice(`control endpoint inbox watch failed: ${errorText(error)}`));cleanups.push(()=>inbox.stop());let endpoint=activateControlEndpoint({context,options,entry,server,scheduler,feed,stopInbox:inbox.stop,wake});return endpoint.wake("inbox"),inbox.armed.then(()=>endpoint.wake("inbox")),setImmediate(()=>{gcHostEndpoints(agentDir,{kinds:["tui"]}).catch(error=>surface.notice(`control endpoint gc of dead terminals failed: ${errorText(error)}`))}),endpoint}function errorText(error){return error instanceof Error?error.message:String(error)}export{registerSessionControlEndpoint};

package/dist/bundle/chunks/session-picker-465FVXQG.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{SessionSelectorComponent,createStartupTui,startStartupTui}from"./chunk-2EFVQWXZ.js";import{KeybindingsManager}from"./chunk-GXY5JEI5.js";import"./chunk-EHQXLHRB.js";import"./chunk-XF3LJC3O.js";import"./chunk-CNPDUC4D.js";import"./chunk-MLVIYDHK.js";import"./chunk-MSQCTH6V.js";import"./chunk-KLAX467B.js";import"./chunk-ORXZXUMC.js";import"./chunk-GZVCRV7I.js";import"./chunk-SOMFLLPD.js";import"./chunk-QMRJYMNH.js";import"./chunk-26UBFF6N.js";import"./chunk-U3VOXCGP.js";import"./chunk-Z6WGAK7W.js";import"./chunk-DLAY7CIU.js";import"./chunk-PELNNWGO.js";import{setKeybindings}from"./chunk-FDL4CF6F.js";import"./chunk-YU4AYH4C.js";import"./chunk-E6WYH3ZL.js";import"./chunk-COH5F7QV.js";import"./chunk-RFB5CBW7.js";import"./chunk-2VZJTDUX.js";import"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-T36LJ6MW.js";import"./chunk-QGJLZ6BI.js";import"./chunk-WHPDEDCC.js";import"./chunk-AA2L2RHH.js";import"./chunk-HK46JMSC.js";import"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import"./chunk-DMI55M2N.js";import"./chunk-PJ34QVL5.js";import"./chunk-YU2P3CAR.js";import"./chunk-ZOFZRJSL.js";import"./chunk-7YO7VQZW.js";import"./chunk-ATQFN5HI.js";import"./chunk-MIENF2YK.js";import"./chunk-IKOFCODM.js";async function selectSession(currentSessionsLoader,allSessionsLoader,settingsManager){let ui=await createStartupTui(settingsManager);return new Promise(resolve=>{let keybindings=KeybindingsManager.create();setKeybindings(keybindings);let resolved=!1,selector=new SessionSelectorComponent(currentSessionsLoader,allSessionsLoader,path=>{resolved||(resolved=!0,ui.stop(),resolve(path))},()=>{resolved||(resolved=!0,ui.stop(),resolve(null))},()=>{ui.stop(),process.exit(0)},()=>ui.requestRender(),{showRenameHint:!1,keybindings});ui.addChild(selector),ui.setFocus(selector.getSessionList()),startStartupTui(ui,settingsManager)})}export{selectSession};