@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/types/personal/action-scheduler.d.ts

@@ -0,0 +1,23 @@
+export type PersonalQueuedAction = {
+    id: string;
+    requestHash: string;
+    request: {
+        kind?: string;
+        sessionId?: string;
+        command?: {
+            method?: string;
+            streamId?: string;
+        };
+    };
+};
+/** Native receipts own effects. This only admits bounded independent transport
+ * lanes; mutations keep their original global order and each TCP stream is serial. */
+export declare class PersonalActionScheduler {
+    private readonly execute;
+    private readonly failed;
+    private readonly limit;
+    private readonly active;
+    constructor(execute: (action: PersonalQueuedAction) => Promise<void>, failed: (error: unknown) => void, limit?: number);
+    accept(actions: PersonalQueuedAction[]): void;
+    drain(): Promise<void>;
+}

package/dist/types/personal/client.d.ts

@@ -0,0 +1,14 @@
+export type PersonalWorkerOptions = {
+    label: string;
+    baseUrl: string;
+    credential: string;
+    root: string;
+    cliEntrypoint?: string;
+};
+export declare function parsePersonalWorkerOptions(args: string[], environment?: Record<string, string | undefined>): PersonalWorkerOptions;
+/** HTTP reconnects never replace the local source/PTY keeper. */
+export declare function startPersonalWorker(options: PersonalWorkerOptions, version: string): Promise<{
+    resourceId: string;
+    root: string;
+    close(): Promise<void>;
+}>;

package/dist/types/personal/runtime.d.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import { WorkspaceAuthority } from "../runtime/workspace/authority";
+import { type StorageTransport } from "../runtime/workspace/storage-client";
+export declare const PersonalWorkerGrant: z.ZodObject<{
+    installationId: z.ZodString;
+    userId: z.ZodString;
+    resourceId: z.ZodString;
+    instanceId: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    workerFence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    workerHello: z.ZodObject<{
+        installationId: z.ZodString;
+        instanceId: z.ZodString;
+        releaseId: z.ZodString;
+        role: z.ZodEnum<{
+            web: "web";
+            scheduler: "scheduler";
+            runner: "runner";
+            gateway: "gateway";
+            "worker-adapter": "worker-adapter";
+            "browser-adapter": "browser-adapter";
+            executor: "executor";
+            keeper: "keeper";
+            storage: "storage";
+        }>;
+        protocol: z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, z.core.$strict>;
+        capabilities: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    leaseExpiresAt: z.ZodCoercedNumber<unknown>;
+}, z.core.$loose>;
+export declare const PersonalWorkspaceRequest: z.ZodObject<{
+    protocol: z.ZodLiteral<1>;
+    userId: z.ZodString;
+    sessionId: z.ZodString;
+    workbench: z.ZodObject<{
+        id: z.ZodString;
+        repositoryId: z.ZodString;
+        branch: z.ZodString;
+        sessionId: z.ZodString;
+        sharedSessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    sourceWorkbench: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        repositoryId: z.ZodString;
+        branch: z.ZodString;
+        sessionId: z.ZodString;
+        sharedSessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    sharedWorkbenches: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        repositoryId: z.ZodString;
+        branch: z.ZodString;
+        sessionId: z.ZodString;
+        sharedSessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    kind: z.ZodEnum<{
+        inspect: "inspect";
+        terminal: "terminal";
+        product: "product";
+        agent: "agent";
+        tcp: "tcp";
+    }>;
+    command: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    credentials: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        installationId: z.ZodString;
+        userId: z.ZodString;
+        generation: z.ZodNumber;
+        env: z.ZodRecord<z.ZodString, z.ZodString>;
+        files: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type PersonalWorkerRuntime = Awaited<ReturnType<typeof openPersonalWorkerRuntime>>;
+/** The host owns this keeper independently of every replaceable remote web/gateway generation. */
+export declare function openPersonalWorkerRuntime(options: {
+    root: string;
+    grant: z.infer<typeof PersonalWorkerGrant>;
+    storage: (sessionId: string) => StorageTransport;
+    cliEntrypoint?: string;
+}): Promise<{
+    grant: {
+        [x: string]: unknown;
+        installationId: string;
+        userId: string;
+        resourceId: string;
+        instanceId: string;
+        workerFence: {
+            installationId: string;
+            resourceType: string;
+            resourceId: string;
+            ownerId: string;
+            epoch: number;
+        };
+        workerHello: {
+            installationId: string;
+            instanceId: string;
+            releaseId: string;
+            role: "web" | "scheduler" | "runner" | "gateway" | "worker-adapter" | "browser-adapter" | "executor" | "keeper" | "storage";
+            protocol: {
+                min: number;
+                max: number;
+            };
+            capabilities: string[];
+        };
+        leaseExpiresAt: number;
+        label?: string | undefined;
+    };
+    renew: (value: unknown) => Promise<void>;
+    dispatch: (raw: unknown) => Promise<any>;
+    authority: WorkspaceAuthority;
+    close(): Promise<void>;
+}>;

package/dist/types/personal/tcp.d.ts

@@ -0,0 +1,14 @@
+export declare class PersonalTcpError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+/** The local worker owns sockets; replaceable web processes relay immutable bytes only. */
+export declare class PersonalTcpManager {
+    private readonly authorizeConnect?;
+    private readonly db;
+    private readonly sockets;
+    constructor(directory: string, authorizeConnect?: ((sessionId: string, port: number) => Promise<void>) | undefined);
+    private stream;
+    dispatch(sessionId: string, raw: unknown): Promise<Record<string, unknown>>;
+    close(): Promise<void>;
+}

package/dist/types/runtime/client.d.ts

@@ -0,0 +1,17 @@
+import type { OperationEnvelope, OwnershipFence } from "@ricsam/r5d-api/runtime-protocol";
+import { AdapterConfig, type ActionReceipt, type AdapterGrant, type AdapterRegistration, type ExecutorCommand, type PollResult, type RunIdentity, type RunReceipt } from "./protocol";
+/** Stateless one-request connections: disconnect/timeout never implies the operation did not happen. */
+export declare class HostExecutorClient {
+    readonly config: ReturnType<typeof AdapterConfig.parse>;
+    constructor(config: AdapterConfig);
+    request<T = unknown>(command: ExecutorCommand): Promise<T>;
+    status(): Promise<unknown>;
+    registerAdapter(grant: AdapterGrant): Promise<AdapterRegistration>;
+    retireAdapter(principalId: string): Promise<AdapterRegistration>;
+    setAuthority(fence: OwnershipFence, validUntil: number): Promise<unknown>;
+    start(operation: OperationEnvelope): Promise<RunReceipt>;
+    poll(run: RunIdentity, stdoutOffset?: number, stderrOffset?: number, maxBytes?: number): Promise<PollResult>;
+    write(run: RunIdentity, actionId: string, data: string, eof?: boolean): Promise<ActionReceipt>;
+    resize(run: RunIdentity, actionId: string, cols: number, rows: number): Promise<ActionReceipt>;
+    cancel(run: RunIdentity, actionId: string): Promise<ActionReceipt>;
+}

package/dist/types/runtime/daemon.d.ts

@@ -0,0 +1,8 @@
+import { HostExecutor } from "./executor";
+import { type ExecutorConfig as Config } from "./protocol";
+/** Start only from an independently supervised daemon entrypoint, never an adapter. */
+export declare function startHostExecutor(input: Config): Promise<{
+    executor: HostExecutor;
+    socketPath: string;
+    close(): Promise<void>;
+}>;

package/dist/types/runtime/executor.d.ts

@@ -0,0 +1,35 @@
+import { type RuntimeHello } from "@ricsam/r5d-api/runtime-protocol";
+import { ExecutorConfig, type ResolvedConfig } from "./protocol";
+import { ExecutorStore } from "./storage";
+type PtyModule = typeof import("node-pty");
+export declare const tokenHash: (token: string) => string;
+/** Resource owner, never instantiated in a replaceable adapter. No legacy worker singleton imports. */
+export declare class HostExecutor {
+    private readonly nativePty?;
+    readonly config: ResolvedConfig;
+    readonly store: ExecutorStore;
+    private readonly adapters;
+    readonly hello: RuntimeHello;
+    private readonly active;
+    private readonly leaseTimer;
+    private closing;
+    private poisoned;
+    private serial;
+    constructor(config: ExecutorConfig, nativePty?: PtyModule | undefined);
+    /** Authority is synchronous and authenticated; never queue lease renewal behind a blocked OS write.
+     * Resource commands retain one ordered admission/action boundary. Commands already admitted may
+     * complete after promotion; queued commands and yielded admission hashes must recheck the fence.
+     */
+    handle(input: unknown): Promise<unknown>;
+    private authenticate;
+    private authority;
+    private workerFence;
+    private authorize;
+    private authorizeAdmission;
+    private receipt;
+    private dispatch;
+    private output;
+    private finish;
+    close(): Promise<void>;
+}
+export {};

package/dist/types/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export { startHostExecutor } from "./daemon";
+export { HostExecutorClient } from "./client";
+export { tokenHash } from "./executor";
+export { AdapterConfig, ExecutorConfig, ExecutorCommand, ExecutorError, EXECUTOR_CAPABILITY, ShellPayload } from "./protocol";
+export type { ActionReceipt, PollResult, RunIdentity, RunReceipt } from "./protocol";