aws-runtime-bridge 1.9.175 → 1.9.180

package/dist/services/process-detector.d.ts

@@ -1,9 +1,31 @@
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export declare function isProcessRunningAsync(pid: number): Promise<boolean>;
 
+
+
+
+
+
 export declare function isProcessRunning(pid: number): Promise<boolean>;
 
+
+
 export interface ProcessInfo {
     pid: number;
     command: string;
@@ -12,10 +34,26 @@ export interface ProcessInfo {
     startedAt?: string;
 }
 
+
+
+
+
 export declare function findClaudeCodeProcesses(): Promise<ProcessInfo[]>;
 
+
+
+
+
+
+
+
+
+
+
 export declare function findOrphanProcessByAgentId(agentId: string): Promise<ProcessInfo | undefined>;
 
+
+
 interface ProcEntry {
     processId: number;
     parentProcessId: number;
@@ -23,29 +61,89 @@ interface ProcEntry {
     commandLine: string | null;
 }
 
+
+
 export interface ProcessSnapshotEntry extends ProcEntry {
     creationDate?: string | null;
     workingSetSize?: number | null;
     handleCount?: number | null;
 }
 
+
+
+
+
+
 export interface ProcessSnapshot {
     entries: ProcessSnapshotEntry[];
 }
 
+
+
+
+
+
+
+
+
+
 export declare function captureProcessSnapshot(): Promise<ProcessSnapshot | undefined>;
 
+
+
+
+
+
+
+
+
+
+
+
 export declare function findOrphanProcessByWorkspace(workspacePath: string): Promise<ProcessInfo | undefined>;
 
+
+
+
+
+
 export declare function terminateProcess(pid: number): boolean;
 
+
+
+
+
+
+
+
+
+
 export declare function terminateProcessTree(pid: number): Promise<{
     terminated: number;
     failed: number;
 }>;
 
+
+
+
+
+
+
 export declare function waitForProcessExit(pid: number, timeoutMs?: number): Promise<boolean>;
 
+
+
+
+
+
+
+
+
+
+
+
+
+
 export declare function detectOrphanProcesses(persistedSessions: Array<{
     agentId: string;
     pid?: number;
@@ -60,6 +158,8 @@ export declare function detectOrphanProcesses(persistedSessions: Array<{
     };
 }>>;
 
+
+
 export interface ProcessHealthStatus {
     pid: number;
     agentId: string;
@@ -70,15 +170,32 @@ export interface ProcessHealthStatus {
     lastUpdate: Date;
 }
 
+
+
+
+
+
+
 export declare function checkProcessHealth(pid: number, agentId: string): Promise<ProcessHealthStatus>;
 
+
+
+
+
+
+
+
 export declare function checkAllSessionsHealth(sessions: Array<{
     agentId: string;
     pid?: number;
 }>, snapshot?: ProcessSnapshot): Promise<Map<string, ProcessHealthStatus>>;
 
+
+
 export type ProcessManagementStatus = 'managed' | 'orphan' | 'unknown';
 
+
+
 export interface DiscoveredProcessInfo extends ProcessInfo {
     managementStatus: ProcessManagementStatus;
     sessionId?: string;
@@ -86,8 +203,23 @@ export interface DiscoveredProcessInfo extends ProcessInfo {
     lastSeen?: string;
 }
 
+
+
+
+
+
+
+
+
+
+
 export declare function discoverAllProcesses(managedPids?: Set<number>, managedAgentIds?: Set<string>): Promise<DiscoveredProcessInfo[]>;
 
+
+
+
+
+
 export declare function discoverAllProcessesFull(registryExport: Array<{
     agentId: string;
     pid: number;

package/dist/services/process-registry.d.ts

@@ -1,13 +1,23 @@
 
 
+
+
+
+
+
+
 export type ProcessState = 'creating' | 'running' | 'stopping' | 'orphaned' | 'terminated' | 'unknown';
 
+
+
 export interface HealthStatus {
     cpu: number;
     memoryMB: number;
     status: string;
 }
 
+
+
 export interface ProcessRecord {
     agentId: string;
     sessionId: string;
@@ -23,6 +33,8 @@ export interface ProcessRecord {
     metadata?: Record<string, unknown>;
 }
 
+
+
 export interface PersistedSessionInput {
     agentId: string;
     sessionId: string;
@@ -32,57 +44,165 @@ export interface PersistedSessionInput {
     mode?: 'sdk';
 }
 
+
+
+
+
 export declare function getProcessRegistryFile(): string;
 
+
+
+
+
 export declare class ProcessRegistry {
     private static instance;
     private readonly records;
     private readonly pidToAgentId;
     
+
+
     private constructor();
     
+
+
+
+
     static getInstance(): ProcessRegistry;
     
+
+
     private persist;
     private mutate;
     
+
+
+
+
+
     register(record: Omit<ProcessRecord, 'createdAt'>): Promise<void>;
     
+
+
+
+
+
+
     update(agentId: string, updates: Partial<ProcessRecord>): Promise<boolean>;
     
+
+
+
+
+
     get(agentId: string): ProcessRecord | undefined;
     
+
+
+
+
+
     getByPid(pid: number): ProcessRecord | undefined;
     
+
+
+
+
     getAll(): ProcessRecord[];
     
+
+
+
+
+
     getByState(state: ProcessState): ProcessRecord[];
     
+
+
+
+
+
     isManaged(agentId: string): boolean;
     
+
+
+
+
+
     isManagedByPid(pid: number): boolean;
     
+
+
+
+
+
     markOrphaned(agentId: string): Promise<boolean>;
     
+
+
+
+
+
     markTerminated(agentId: string): Promise<boolean>;
     
+
+
+
+
+
     remove(agentId: string): Promise<boolean>;
     
+
+
+
+
+
     updateHeartbeat(agentId: string): Promise<boolean>;
     
+
+
+
+
+
+
     updateHealth(agentId: string, health: HealthStatus): Promise<boolean>;
     
+
+
+
+
     rebuildFromPersisted(sessions: PersistedSessionInput[]): Promise<void>;
     
+
+
+
+
     exportState(): ProcessRecord[];
     
+
+
+
+
     getStats(): Record<ProcessState | 'total', number>;
     
+
+
     clear(): Promise<void>;
 }
 
+
+
+
+
 export declare function getProcessRegistry(): ProcessRegistry;
 
+
+
+
+
 export declare function loadPersistedProcessRegistry(): Promise<ProcessRecord[]>;
 
+
+
+
+
 export declare function savePersistedProcessRegistry(records: ProcessRecord[]): Promise<void>;

package/dist/services/process-top.d.ts

@@ -4,6 +4,9 @@ export interface ProcessTopSample {
     pid: number;
     name: string;
     
+
+
+
     value: number;
     readBytesPerSecond?: number;
     writeBytesPerSecond?: number;
@@ -50,4 +53,7 @@ export declare function parseLsofConnectionCounts(output: string): Map<number, {
 
 export declare function parseJsonRows<T>(stdout: string): T[];
 
+
+
+
 export declare function collectProcessTop(resource: ProcessTopResource, limit: number): Promise<ProcessTopSnapshot>;

package/dist/services/request-identity.d.ts

@@ -0,0 +1,77 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import type { Request } from "express";
+import { type UserScope } from "./user-scope.js";
+export type RequestIdentitySource = "connection-key" | "runtime-token" | "loopback" | "panel-session" | "untrusted";
+export interface RequestIdentity {
+    source: RequestIdentitySource;
+    
+    target?: {
+        serverUrl: string;
+        tenantId?: string;
+        userId?: string;
+        credentialId?: string;
+        instanceId?: string;
+    };
+    
+    scope: UserScope | null;
+}
+export declare function isLoopbackRequest(req: Request): boolean;
+
+
+
+
+
+
+
+export declare function resolveCredentialIdentity(req: Request, token: string): RequestIdentity;
+
+
+
+
+export declare function readTargetSelectors(req: Request): {
+    serverUrl?: string;
+    instanceId?: string;
+    credentialId?: string;
+    identity?: string;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+export declare function constrainScopeToTarget(requested: UserScope | null, targetTenantId?: string, targetUserId?: string): UserScope | null;
+
+
+
+
+
+
+export declare function findConfiguredTarget(selectors: ReturnType<typeof readTargetSelectors>): {
+    serverUrl: string;
+    tenantId?: string;
+    userId?: string;
+    credentialId?: string;
+    instanceId?: string;
+} | undefined;

package/dist/services/request-identity.js

@@ -0,0 +1,2 @@
+import{findConfigsByConnectionKey as S,getConfiguredConnectionKeys as p,loadConfigs as o}from"./auto-register.js";import{getScopedRuntimeAccessToken as U,validateRuntimeBindingToken as y}from"./runtime-binding.js";import{normalizeUserScope as c}from"./user-scope.js";const v=new Set(["127.0.0.1","::1","::ffff:127.0.0.1"]);function b(e){const n=e.ip||e.socket.remoteAddress||"";return v.has(n)}function B(e,n){const i=String(n||"").trim();if(!i)return{source:"untrusted",scope:null};if(p().includes(i)){const t=f(e),r=S(i);let d=r.length===1?r[0]:void 0;if(!d){const a=h(t);a&&(d=r.find(g=>u(g.serverUrl)===a.serverUrl))}const s=d?I(d,t):void 0;return s?{source:"connection-key",target:s,scope:m(l(e),s.tenantId,s.userId)}:{source:"connection-key",scope:null}}if(y(i)){for(const t of o()){const r=U(t.serverUrl,t.credentialId||t.userKey);if(!r||r!==i)continue;const d=I(t,f(e));return{source:"runtime-token",target:d,scope:m(l(e),d.tenantId,d.userId)}}return{source:"runtime-token",scope:null}}return{source:"untrusted",scope:null}}function l(e){const n=e.body??{};return c(e.header("X-Tenant-Id")??n.tenantId,e.header("X-User-Id")??n.ownerUserId??n.userId)}function I(e,n){return(!n.serverUrl||u(e.serverUrl)===u(n.serverUrl))&&(!n.instanceId||String(e.instanceId||"").trim()===n.instanceId)&&(!n.credentialId||String(e.credentialId||e.userKey||e.serverUrl||"").trim()===n.credentialId)?{serverUrl:u(e.serverUrl),tenantId:String(e.tenantId||"").trim()||void 0,userId:String(e.userId||"").trim()||void 0,credentialId:String(e.credentialId||"").trim()||void 0,instanceId:String(e.instanceId||"").trim()||void 0}:{serverUrl:u(e.serverUrl),tenantId:void 0,userId:void 0}}function f(e){const n=e.body??{},i=(...t)=>{for(const r of t){const d=String(r??"").trim();if(d)return d}};return{serverUrl:i(e.header("X-Scheduler-Base-Url"),n.serverUrl),instanceId:i(e.header("X-Bridge-Instance-Id"),n.instanceId),credentialId:i(e.header("X-Bridge-Credential-Id"),n.credentialId),identity:i(e.header("X-Bridge-Target-Identity"),n.targetIdentity)}}function m(e,n,i){const t=String(n||"").trim(),r=String(i||"").trim();return t?e?e.tenantId!==t||r&&e.userId!==r?null:e:r?c(t,r):null:null}function h(e){const i=o().filter(r=>!(e.serverUrl&&u(r.serverUrl)!==u(e.serverUrl)||e.instanceId&&String(r.instanceId||"").trim()!==e.instanceId||e.credentialId&&String(r.credentialId||"").trim()!==e.credentialId&&String(r.userKey||"").trim()!==e.credentialId||e.identity&&String(r.credentialId||r.userKey||"").trim()!==e.identity));if(i.length!==1)return;const t=i[0];return{serverUrl:u(String(t.serverUrl||"")),tenantId:String(t.tenantId||"").trim()||void 0,userId:String(t.userId||"").trim()||void 0,credentialId:String(t.credentialId||"").trim()||void 0,instanceId:String(t.instanceId||"").trim()||void 0}}function u(e){const n=String(e??"").trim();if(!n)return"";try{return new URL(n).origin.toLowerCase()}catch{return n.replace(/\/+$/,"").toLowerCase()}}export{m as constrainScopeToTarget,h as findConfiguredTarget,b as isLoopbackRequest,f as readTargetSelectors,B as resolveCredentialIdentity};
+

package/dist/services/request-invalid-dump.d.ts

@@ -18,4 +18,8 @@ export declare function resetInvalidRequestDumpStateForTest(): void;
 
 export declare function getInvalidRequestDumpDir(): string;
 
+
+
+
+
 export declare function dumpInvalidProviderRequest(input: InvalidProviderRequestDumpInput): Promise<string | null>;

package/dist/services/ring-buffer.d.ts

@@ -1,4 +1,9 @@
 
+
+
+
+
+
 export interface RingBufferEntry<T> {
     data: T;
     readonly timestamp: number;
@@ -6,6 +11,10 @@ export interface RingBufferEntry<T> {
 }
 export type RingBufferSlice<T> = readonly RingBufferEntry<T>[];
 
+
+
+
+
 export declare class RingBuffer<T> {
     private readonly entries;
     private readonly capacity;
@@ -13,21 +22,45 @@ export declare class RingBuffer<T> {
     private totalAppended;
     constructor(capacity: number);
     
+
+
+
+
     append(item: T): RingBufferEntry<T>;
     
+
+
+
+
+
+
+
+
+
     appendOrMerge(item: T, condition: (lastEntry: RingBufferEntry<T>) => boolean, merge: (last: T, next: T) => T): RingBufferEntry<T>;
     
+
+
     slice(): RingBufferSlice<T>;
     
+
+
     get size(): number;
     
+
+
     getLastN(n: number): RingBufferSlice<T>;
     
+
+
+
     getSinceIndex(index: number): {
         entries: RingBufferSlice<T>;
         nextIndex: number;
         oldestIndex: number;
     };
     
+
+
     clear(): void;
 }

package/dist/services/runtime-binding.d.ts

@@ -4,37 +4,89 @@ export type RuntimeBindingState = {
     userId?: string;
     schedulerBaseUrl?: string;
     
+
+
+
+
     accessToken?: string;
     tokenHash?: string;
     createdAt?: string;
     updatedAt?: string;
     revokedAt?: string;
 };
+
+
+
+
 export declare function normalizeSchedulerBaseUrl(value: unknown): string | undefined;
 export declare function getRuntimePairingCode(): string;
 export declare function getRuntimeBindingFilePath(): string;
 export declare function getRuntimeTokenStoreFilePath(): string;
-export declare function buildRuntimeTokenKey(serverBaseUrl: unknown): string;
+
+
+
+
+
+
+
+export declare function buildLegacyRuntimeTokenKey(serverBaseUrl: unknown): string;
+
+
+
+
+
+
+export declare function buildRuntimeTokenKey(serverBaseUrl: unknown, userKey?: unknown): string;
 export declare function saveScopedRuntimeAccessToken(input: {
     serverBaseUrl: string;
     accessToken: string;
+    
+    userKey?: string;
 }): string;
-export declare function getScopedRuntimeAccessToken(serverBaseUrl: unknown): string | undefined;
-export declare function clearScopedRuntimeAccessToken(serverBaseUrl: unknown): boolean;
+
+export declare function getScopedRuntimeAccessToken(serverBaseUrl: unknown, userKey?: unknown): string | undefined;
+
+export declare function listScopedRuntimeAccessTokens(serverBaseUrl: unknown): Array<{
+    userKeyFingerprint: string;
+    accessToken: string;
+}>;
+export declare function clearScopedRuntimeAccessToken(serverBaseUrl: unknown, userKey?: unknown): boolean;
 export declare function loadRuntimeBinding(): RuntimeBindingState;
 export declare function getRuntimeBindingPublicState(): Omit<RuntimeBindingState, "tokenHash" | "accessToken"> & {
     paired: boolean;
 };
 export declare function hasRuntimeBinding(): boolean;
 export declare function validateRuntimeBindingToken(token: unknown): boolean;
-export declare function getRuntimeAccessToken(serverBaseUrl?: unknown): string | undefined;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export declare function getRuntimeAccessToken(serverBaseUrl?: unknown, userKey?: unknown): string | undefined;
 export declare function validateRuntimePairingCode(code: unknown): boolean;
 export declare function saveRuntimeBinding(input: {
     accessToken: string;
     instanceId?: string;
     userId?: string;
     schedulerBaseUrl?: string;
+    
+
+
+
+    userKey?: string;
 }): RuntimeBindingState;
 export declare function clearRuntimeBinding(): void;
 
+
+
+
 export declare function migrateOldBindingDir(): void;