@synsci/sdk 2.0.2-test.36.1 → 2.0.2-test.37.1

package/dist/{v2 → src/v2}/gen/types.gen.d.ts

@@ -4173,6 +4173,108 @@ export type ProjectCurrentResponses = {
     200: Project;
 };
 export type ProjectCurrentResponse = ProjectCurrentResponses[keyof ProjectCurrentResponses];
+export type ProjectTrustGetData = {
+    body?: never;
+    path: {
+        projectID: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/project/{projectID}/trust";
+};
+export type ProjectTrustGetErrors = {
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type ProjectTrustGetError = ProjectTrustGetErrors[keyof ProjectTrustGetErrors];
+export type ProjectTrustGetResponses = {
+    /**
+     * Project trust state and remediation
+     */
+    200: {
+        projectID: string;
+        root: string;
+        state: "trusted" | "untrusted" | "revoked";
+        source: "default" | "persisted";
+        canExecuteProjectCode: boolean;
+        time?: {
+            updated: number;
+            trusted?: number;
+            revoked?: number;
+        };
+        remediation?: {
+            code: "trust_project_required";
+            message: string;
+            method: "PUT";
+            path: string;
+            body: {
+                trusted: true;
+                root: string;
+            };
+        };
+    };
+};
+export type ProjectTrustGetResponse = ProjectTrustGetResponses[keyof ProjectTrustGetResponses];
+export type ProjectTrustUpdateData = {
+    body?: {
+        trusted: true;
+        /**
+         * Canonical root returned by the trust status endpoint
+         */
+        root: string;
+    } | {
+        trusted: false;
+    };
+    path: {
+        projectID: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/project/{projectID}/trust";
+};
+export type ProjectTrustUpdateErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type ProjectTrustUpdateError = ProjectTrustUpdateErrors[keyof ProjectTrustUpdateErrors];
+export type ProjectTrustUpdateResponses = {
+    /**
+     * Updated project trust state
+     */
+    200: {
+        projectID: string;
+        root: string;
+        state: "trusted" | "untrusted" | "revoked";
+        source: "default" | "persisted";
+        canExecuteProjectCode: boolean;
+        time?: {
+            updated: number;
+            trusted?: number;
+            revoked?: number;
+        };
+        remediation?: {
+            code: "trust_project_required";
+            message: string;
+            method: "PUT";
+            path: string;
+            body: {
+                trusted: true;
+                root: string;
+            };
+        };
+    };
+};
+export type ProjectTrustUpdateResponse = ProjectTrustUpdateResponses[keyof ProjectTrustUpdateResponses];
 export type ProjectUpdateData = {
     body?: {
         name?: string;
@@ -6793,6 +6895,476 @@ export type FileStatusResponses = {
     200: Array<File>;
 };
 export type FileStatusResponse = FileStatusResponses[keyof FileStatusResponses];
+export type NotebookKernelsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+        sessionID?: string;
+    };
+    url: "/notebook/kernels";
+};
+export type NotebookKernelsResponses = {
+    /**
+     * Project kernel records and live process state
+     */
+    200: {
+        kernels: Array<{
+            id: string;
+            active: boolean;
+            state: "lazy" | "starting" | "idle" | "running" | "stopped" | "crashed";
+            projectID: string;
+            sessionID: string;
+            name: string;
+            language: string;
+            incarnation: number | null;
+            execution_count: number;
+            queue_depth: number;
+            environment: {
+                cwd: string;
+                atlas: {
+                    access: "host_broker";
+                    credentials: "withheld";
+                    sources: "source_ids_only";
+                };
+                sandbox: {
+                    requested: boolean;
+                    enforced: boolean;
+                    backend: "seatbelt" | "bubblewrap" | "none";
+                    network: "allow" | "deny";
+                    platform: string;
+                    available: boolean;
+                    tool?: string;
+                    reason?: string;
+                    warning?: string;
+                };
+            } | null;
+            process_id: number | null;
+            process_started_at: number | null;
+            process_identity_verified: boolean | null;
+            started_at: number | null;
+            last_activity_at: number | null;
+        }>;
+    };
+};
+export type NotebookKernelsResponse = NotebookKernelsResponses[keyof NotebookKernelsResponses];
+export type NotebookKernelRestartData = {
+    body?: {
+        sessionID: string;
+    };
+    path: {
+        kernelID: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/notebook/kernels/{kernelID}/restart";
+};
+export type NotebookKernelRestartResponses = {
+    /**
+     * Fresh live kernel state
+     */
+    200: {
+        id: string;
+        active: boolean;
+        state: "lazy" | "starting" | "idle" | "running" | "stopped" | "crashed";
+        projectID: string;
+        sessionID: string;
+        name: string;
+        language: string;
+        incarnation: number | null;
+        execution_count: number;
+        queue_depth: number;
+        environment: {
+            cwd: string;
+            atlas: {
+                access: "host_broker";
+                credentials: "withheld";
+                sources: "source_ids_only";
+            };
+            sandbox: {
+                requested: boolean;
+                enforced: boolean;
+                backend: "seatbelt" | "bubblewrap" | "none";
+                network: "allow" | "deny";
+                platform: string;
+                available: boolean;
+                tool?: string;
+                reason?: string;
+                warning?: string;
+            };
+        } | null;
+        process_id: number | null;
+        process_started_at: number | null;
+        process_identity_verified: boolean | null;
+        started_at: number | null;
+        last_activity_at: number | null;
+    };
+};
+export type NotebookKernelRestartResponse = NotebookKernelRestartResponses[keyof NotebookKernelRestartResponses];
+export type NotebookKernelStopData = {
+    body?: {
+        sessionID: string;
+    };
+    path: {
+        kernelID: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/notebook/kernels/{kernelID}/stop";
+};
+export type NotebookKernelStopResponses = {
+    /**
+     * Stopped kernel state
+     */
+    200: {
+        id: string;
+        active: boolean;
+        state: "lazy" | "starting" | "idle" | "running" | "stopped" | "crashed";
+        projectID: string;
+        sessionID: string;
+        name: string;
+        language: string;
+        incarnation: number | null;
+        execution_count: number;
+        queue_depth: number;
+        environment: {
+            cwd: string;
+            atlas: {
+                access: "host_broker";
+                credentials: "withheld";
+                sources: "source_ids_only";
+            };
+            sandbox: {
+                requested: boolean;
+                enforced: boolean;
+                backend: "seatbelt" | "bubblewrap" | "none";
+                network: "allow" | "deny";
+                platform: string;
+                available: boolean;
+                tool?: string;
+                reason?: string;
+                warning?: string;
+            };
+        } | null;
+        process_id: number | null;
+        process_started_at: number | null;
+        process_identity_verified: boolean | null;
+        started_at: number | null;
+        last_activity_at: number | null;
+    };
+};
+export type NotebookKernelStopResponse = NotebookKernelStopResponses[keyof NotebookKernelStopResponses];
+export type NotebookKernelInterruptData = {
+    body?: {
+        sessionID: string;
+    };
+    path: {
+        kernelID: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/notebook/kernels/{kernelID}/interrupt";
+};
+export type NotebookKernelInterruptResponses = {
+    /**
+     * Kernel state
+     */
+    200: {
+        id: string;
+        active: boolean;
+        state: "lazy" | "starting" | "idle" | "running" | "stopped" | "crashed";
+        projectID: string;
+        sessionID: string;
+        name: string;
+        language: string;
+        incarnation: number | null;
+        execution_count: number;
+        queue_depth: number;
+        environment: {
+            cwd: string;
+            atlas: {
+                access: "host_broker";
+                credentials: "withheld";
+                sources: "source_ids_only";
+            };
+            sandbox: {
+                requested: boolean;
+                enforced: boolean;
+                backend: "seatbelt" | "bubblewrap" | "none";
+                network: "allow" | "deny";
+                platform: string;
+                available: boolean;
+                tool?: string;
+                reason?: string;
+                warning?: string;
+            };
+        } | null;
+        process_id: number | null;
+        process_started_at: number | null;
+        process_identity_verified: boolean | null;
+        started_at: number | null;
+        last_activity_at: number | null;
+        state_preserved?: boolean;
+    };
+};
+export type NotebookKernelInterruptResponse = NotebookKernelInterruptResponses[keyof NotebookKernelInterruptResponses];
+export type NotebookKernelDeleteData = {
+    body?: never;
+    path: {
+        kernelID: string;
+    };
+    query: {
+        directory?: string;
+        sessionID: string;
+    };
+    url: "/notebook/kernels/{kernelID}";
+};
+export type NotebookKernelDeleteResponses = {
+    /**
+     * Kernel record forgotten
+     */
+    204: void;
+};
+export type NotebookKernelDeleteResponse = NotebookKernelDeleteResponses[keyof NotebookKernelDeleteResponses];
+export type NotebookExecuteData = {
+    body?: {
+        sessionID: string;
+        id: string;
+        language: "python" | "r";
+        code: string;
+        timeout?: number;
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/notebook/execute";
+};
+export type NotebookExecuteResponses = {
+    /**
+     * Jupyter-compatible cell outputs
+     */
+    200: unknown;
+};
+export type NotebookStatusData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        sessionID: string;
+        id: string;
+        language: "python" | "r";
+    };
+    url: "/notebook/status";
+};
+export type NotebookStatusResponses = {
+    /**
+     * Kernel state
+     */
+    200: {
+        id: string;
+        active: boolean;
+        state: "lazy" | "starting" | "idle" | "running" | "stopped" | "crashed";
+        projectID: string;
+        sessionID: string;
+        name: string;
+        language: string;
+        incarnation: number | null;
+        execution_count: number;
+        queue_depth: number;
+        environment: {
+            cwd: string;
+            atlas: {
+                access: "host_broker";
+                credentials: "withheld";
+                sources: "source_ids_only";
+            };
+            sandbox: {
+                requested: boolean;
+                enforced: boolean;
+                backend: "seatbelt" | "bubblewrap" | "none";
+                network: "allow" | "deny";
+                platform: string;
+                available: boolean;
+                tool?: string;
+                reason?: string;
+                warning?: string;
+            };
+        } | null;
+        process_id: number | null;
+        process_started_at: number | null;
+        process_identity_verified: boolean | null;
+        started_at: number | null;
+        last_activity_at: number | null;
+    };
+};
+export type NotebookStatusResponse = NotebookStatusResponses[keyof NotebookStatusResponses];
+export type NotebookRestartData = {
+    body?: {
+        sessionID: string;
+        id: string;
+        language: "python" | "r";
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/notebook/restart";
+};
+export type NotebookRestartResponses = {
+    /**
+     * Fresh live kernel state
+     */
+    200: {
+        id: string;
+        active: boolean;
+        state: "lazy" | "starting" | "idle" | "running" | "stopped" | "crashed";
+        projectID: string;
+        sessionID: string;
+        name: string;
+        language: string;
+        incarnation: number | null;
+        execution_count: number;
+        queue_depth: number;
+        environment: {
+            cwd: string;
+            atlas: {
+                access: "host_broker";
+                credentials: "withheld";
+                sources: "source_ids_only";
+            };
+            sandbox: {
+                requested: boolean;
+                enforced: boolean;
+                backend: "seatbelt" | "bubblewrap" | "none";
+                network: "allow" | "deny";
+                platform: string;
+                available: boolean;
+                tool?: string;
+                reason?: string;
+                warning?: string;
+            };
+        } | null;
+        process_id: number | null;
+        process_started_at: number | null;
+        process_identity_verified: boolean | null;
+        started_at: number | null;
+        last_activity_at: number | null;
+    };
+};
+export type NotebookRestartResponse = NotebookRestartResponses[keyof NotebookRestartResponses];
+export type NotebookStopData = {
+    body?: {
+        sessionID: string;
+        id: string;
+        language: "python" | "r";
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/notebook/stop";
+};
+export type NotebookStopResponses = {
+    /**
+     * Stopped kernel state
+     */
+    200: {
+        id: string;
+        active: boolean;
+        state: "lazy" | "starting" | "idle" | "running" | "stopped" | "crashed";
+        projectID: string;
+        sessionID: string;
+        name: string;
+        language: string;
+        incarnation: number | null;
+        execution_count: number;
+        queue_depth: number;
+        environment: {
+            cwd: string;
+            atlas: {
+                access: "host_broker";
+                credentials: "withheld";
+                sources: "source_ids_only";
+            };
+            sandbox: {
+                requested: boolean;
+                enforced: boolean;
+                backend: "seatbelt" | "bubblewrap" | "none";
+                network: "allow" | "deny";
+                platform: string;
+                available: boolean;
+                tool?: string;
+                reason?: string;
+                warning?: string;
+            };
+        } | null;
+        process_id: number | null;
+        process_started_at: number | null;
+        process_identity_verified: boolean | null;
+        started_at: number | null;
+        last_activity_at: number | null;
+    };
+};
+export type NotebookStopResponse = NotebookStopResponses[keyof NotebookStopResponses];
+export type NotebookInterruptData = {
+    body?: {
+        sessionID: string;
+        id: string;
+        language: "python" | "r";
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/notebook/interrupt";
+};
+export type NotebookInterruptResponses = {
+    /**
+     * Kernel state
+     */
+    200: {
+        id: string;
+        active: boolean;
+        state: "lazy" | "starting" | "idle" | "running" | "stopped" | "crashed";
+        projectID: string;
+        sessionID: string;
+        name: string;
+        language: string;
+        incarnation: number | null;
+        execution_count: number;
+        queue_depth: number;
+        environment: {
+            cwd: string;
+            atlas: {
+                access: "host_broker";
+                credentials: "withheld";
+                sources: "source_ids_only";
+            };
+            sandbox: {
+                requested: boolean;
+                enforced: boolean;
+                backend: "seatbelt" | "bubblewrap" | "none";
+                network: "allow" | "deny";
+                platform: string;
+                available: boolean;
+                tool?: string;
+                reason?: string;
+                warning?: string;
+            };
+        } | null;
+        process_id: number | null;
+        process_started_at: number | null;
+        process_identity_verified: boolean | null;
+        started_at: number | null;
+        last_activity_at: number | null;
+        state_preserved?: boolean;
+    };
+};
+export type NotebookInterruptResponse = NotebookInterruptResponses[keyof NotebookInterruptResponses];
 export type ProvenanceListData = {
     body?: never;
     path?: never;

package/dist/test/notebook-contract.d.ts

@@ -0,0 +1,38 @@
+import type { OpenScienceClient } from "../src/v2/client.js";
+import type { NotebookExecuteData, NotebookInterruptData, NotebookKernelDeleteData, NotebookKernelInterruptData, NotebookKernelRestartData, NotebookKernelStopData, NotebookRestartData, NotebookStatusData, NotebookStopData } from "../src/v2/gen/types.gen.js";
+type Assert<T extends true> = T;
+type Owner<T> = NonNullable<T> extends {
+    sessionID: string;
+} ? true : false;
+type Field<T, K extends PropertyKey> = K extends keyof NonNullable<T> ? true : false;
+type _executeOwner = Assert<Owner<NotebookExecuteData["body"]>>;
+type _statusOwner = Assert<Owner<NotebookStatusData["query"]>>;
+type _restartOwner = Assert<Owner<NotebookRestartData["body"]>>;
+type _stopOwner = Assert<Owner<NotebookStopData["body"]>>;
+type _interruptOwner = Assert<Owner<NotebookInterruptData["body"]>>;
+type _kernelRestartOwner = Assert<Owner<NotebookKernelRestartData["body"]>>;
+type _kernelStopOwner = Assert<Owner<NotebookKernelStopData["body"]>>;
+type _kernelInterruptOwner = Assert<Owner<NotebookKernelInterruptData["body"]>>;
+type _kernelDeleteOwner = Assert<Owner<NotebookKernelDeleteData["query"]>>;
+type Notebook = OpenScienceClient["notebook"];
+type _executeMethodOwner = Assert<Field<Parameters<Notebook["execute"]>[0], "sessionID">>;
+type _statusMethodOwner = Assert<Field<Parameters<Notebook["status"]>[0], "sessionID">>;
+type _restartMethodOwner = Assert<Field<Parameters<Notebook["restart"]>[0], "sessionID">>;
+type _stopMethodOwner = Assert<Field<Parameters<Notebook["stop"]>[0], "sessionID">>;
+type _interruptMethodOwner = Assert<Field<Parameters<Notebook["interrupt"]>[0], "sessionID">>;
+type _kernelRestart = Assert<Field<Notebook["kernel"], "restart">>;
+type _kernelStop = Assert<Field<Notebook["kernel"], "stop">>;
+type _kernelInterrupt = Assert<Field<Notebook["kernel"], "interrupt">>;
+type _kernelDelete = Assert<Field<Notebook["kernel"], "delete">>;
+export declare const notebookContract: {
+    readonly execute: _executeOwner & _executeMethodOwner;
+    readonly status: _statusOwner & _statusMethodOwner;
+    readonly restart: _restartOwner & _restartMethodOwner;
+    readonly stop: _stopOwner & _stopMethodOwner;
+    readonly interrupt: _interruptOwner & _interruptMethodOwner;
+    readonly kernelRestart: _kernelRestartOwner & _kernelRestart;
+    readonly kernelStop: _kernelStopOwner & _kernelStop;
+    readonly kernelInterrupt: _kernelInterruptOwner & _kernelInterrupt;
+    readonly kernelDelete: _kernelDeleteOwner & _kernelDelete;
+};
+export {};

package/dist/test/notebook-contract.js

@@ -0,0 +1,11 @@
+export const notebookContract = {
+    execute: true,
+    status: true,
+    restart: true,
+    stop: true,
+    interrupt: true,
+    kernelRestart: true,
+    kernelStop: true,
+    kernelInterrupt: true,
+    kernelDelete: true,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@synsci/sdk",
-  "version": "2.0.2-test.36.1",
+  "version": "2.0.2-test.37.1",
   "type": "module",
   "license": "Apache-2.0",
   "scripts": {