@phpsandbox/sdk 0.0.68 → 0.1.2

package/dist/schemas/{deployments.d.ts → publications.d.ts}

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-export declare const DeploymentTargetProviderSchema: z.ZodEnum<{
-    okraCloudflareContainer: "okraCloudflareContainer";
-    okraSshAgent: "okraSshAgent";
-    okraLaravelCloud: "okraLaravelCloud";
+export declare const PublicationProviderNameSchema: z.ZodEnum<{
+    "cloudflare-containers": "cloudflare-containers";
+    "ssh-server": "ssh-server";
+    "laravel-cloud": "laravel-cloud";
 }>;
-export declare const DeploymentStatusSchema: z.ZodEnum<{
+export declare const PublicationStatusSchema: z.ZodEnum<{
     stopped: "stopped";
     deleted: "deleted";
     pending: "pending";
@@ -16,7 +16,7 @@ export declare const DeploymentStatusSchema: z.ZodEnum<{
     deleting: "deleting";
     delete_failed: "delete_failed";
 }>;
-export declare const DeploymentBuildStatusSchema: z.ZodEnum<{
+export declare const PublicationBuildStatusSchema: z.ZodEnum<{
     running: "running";
     pending: "pending";
     queued: "queued";
@@ -24,22 +24,22 @@ export declare const DeploymentBuildStatusSchema: z.ZodEnum<{
     succeeded: "succeeded";
     cancelled: "cancelled";
 }>;
-export declare const DeploymentReleaseStatusSchema: z.ZodEnum<{
+export declare const PublicationReleaseStatusSchema: z.ZodEnum<{
     created: "created";
     deleted: "deleted";
     ready: "ready";
 }>;
-export declare const DeploymentSizeSchema: z.ZodEnum<{
+export declare const PublicationSizeSchema: z.ZodEnum<{
     small: "small";
-    basic: "basic";
     nano: "nano";
     medium: "medium";
     large: "large";
     lite: "lite";
+    basic: "basic";
     "standard-1": "standard-1";
     "standard-2": "standard-2";
 }>;
-export declare const DeploymentRegionSchema: z.ZodEnum<{
+export declare const PublicationRegionSchema: z.ZodEnum<{
     ENAM: "ENAM";
     WNAM: "WNAM";
     EEUR: "EEUR";
@@ -50,45 +50,45 @@ export declare const DeploymentRegionSchema: z.ZodEnum<{
     OC: "OC";
     AFR: "AFR";
 }>;
-export declare const DeploymentJurisdictionSchema: z.ZodEnum<{
+export declare const PublicationJurisdictionSchema: z.ZodEnum<{
     eu: "eu";
     fedramp: "fedramp";
 }>;
-export declare const DeploymentDomainDnsRecordTypeSchema: z.ZodEnum<{
+export declare const PublicationDomainDnsRecordTypeSchema: z.ZodEnum<{
     CNAME: "CNAME";
     ALIAS: "ALIAS";
     ANAME: "ANAME";
 }>;
-export declare const DeploymentProtectionModeSchema: z.ZodEnum<{
+export declare const PublicationProtectionModeSchema: z.ZodEnum<{
     none: "none";
     password: "password";
 }>;
-export declare const DeploymentLogStreamSchema: z.ZodEnum<{
-    build: "build";
+export declare const PublicationLogStreamSchema: z.ZodEnum<{
     runtime: "runtime";
-}>;
-export declare const DeployStreamLogStreamSchema: z.ZodEnum<{
     build: "build";
+}>;
+export declare const PublishStreamLogStreamSchema: z.ZodEnum<{
     runtime: "runtime";
-    deploy: "deploy";
+    build: "build";
+    publish: "publish";
 }>;
-export declare const DeploymentEventDataSchema: z.ZodObject<{
+export declare const PublicationEventDataSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
     sequence: z.ZodNumber;
     type: z.ZodString;
     payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     createdAt: z.ZodNullable<z.ZodString>;
 }, z.core.$loose>;
-export declare const DeploymentLogChunkDataSchema: z.ZodObject<{
+export declare const PublicationLogChunkDataSchema: z.ZodObject<{
     sequence: z.ZodNumber;
     stream: z.ZodEnum<{
-        build: "build";
         runtime: "runtime";
+        build: "build";
     }>;
     content: z.ZodString;
     createdAt: z.ZodNullable<z.ZodString>;
 }, z.core.$loose>;
-export declare const DeployStreamPhaseSchema: z.ZodObject<{
+export declare const PublishStreamPhaseSchema: z.ZodObject<{
     name: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{
         running: "running";
@@ -97,17 +97,17 @@ export declare const DeployStreamPhaseSchema: z.ZodObject<{
     }>>;
     data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
-export declare const DeployStreamLogSchema: z.ZodObject<{
+export declare const PublishStreamLogSchema: z.ZodObject<{
     stream: z.ZodEnum<{
-        build: "build";
         runtime: "runtime";
-        deploy: "deploy";
+        build: "build";
+        publish: "publish";
     }>;
     content: z.ZodString;
 }, z.core.$strict>;
-export declare const DeployStreamResultSchema: z.ZodObject<{
+export declare const PublishStreamResultSchema: z.ZodObject<{
     success: z.ZodBoolean;
-    deploymentId: z.ZodString;
+    publicationId: z.ZodString;
     buildId: z.ZodString;
     releaseId: z.ZodString;
     status: z.ZodEnum<{
@@ -123,7 +123,7 @@ export declare const DeployStreamResultSchema: z.ZodObject<{
         delete_failed: "delete_failed";
     }>;
 }, z.core.$strict>;
-export declare const DeployStreamPhaseEventSchema: z.ZodObject<{
+export declare const PublishStreamPhaseEventSchema: z.ZodObject<{
     name: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{
         running: "running";
@@ -133,18 +133,18 @@ export declare const DeployStreamPhaseEventSchema: z.ZodObject<{
     data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"phase">;
 }, z.core.$strict>;
-export declare const DeployStreamLogEventSchema: z.ZodObject<{
+export declare const PublishStreamLogEventSchema: z.ZodObject<{
     stream: z.ZodEnum<{
-        build: "build";
         runtime: "runtime";
-        deploy: "deploy";
+        build: "build";
+        publish: "publish";
     }>;
     content: z.ZodString;
     type: z.ZodLiteral<"log">;
 }, z.core.$strict>;
-export declare const DeployStreamResultEventSchema: z.ZodObject<{
+export declare const PublishStreamResultEventSchema: z.ZodObject<{
     success: z.ZodBoolean;
-    deploymentId: z.ZodString;
+    publicationId: z.ZodString;
     buildId: z.ZodString;
     releaseId: z.ZodString;
     status: z.ZodEnum<{
@@ -161,7 +161,7 @@ export declare const DeployStreamResultEventSchema: z.ZodObject<{
     }>;
     type: z.ZodLiteral<"result">;
 }, z.core.$strict>;
-export declare const DeployStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const PublishStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     name: z.ZodString;
     status: z.ZodOptional<z.ZodEnum<{
         running: "running";
@@ -172,15 +172,15 @@ export declare const DeployStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     type: z.ZodLiteral<"phase">;
 }, z.core.$strict>, z.ZodObject<{
     stream: z.ZodEnum<{
-        build: "build";
         runtime: "runtime";
-        deploy: "deploy";
+        build: "build";
+        publish: "publish";
     }>;
     content: z.ZodString;
     type: z.ZodLiteral<"log">;
 }, z.core.$strict>, z.ZodObject<{
     success: z.ZodBoolean;
-    deploymentId: z.ZodString;
+    publicationId: z.ZodString;
     buildId: z.ZodString;
     releaseId: z.ZodString;
     status: z.ZodEnum<{
@@ -197,17 +197,17 @@ export declare const DeployStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     }>;
     type: z.ZodLiteral<"result">;
 }, z.core.$strict>], "type">;
-export declare const DeployStreamErrorSchema: z.ZodObject<{
+export declare const PublishStreamErrorSchema: z.ZodObject<{
     message: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
-export declare const DeployStreamSseEventNameSchema: z.ZodEnum<{
+export declare const PublishStreamSseEventNameSchema: z.ZodEnum<{
     error: "error";
-    log: "log";
     phase: "phase";
+    log: "log";
     result: "result";
     done: "done";
 }>;
-export declare const DeployStreamSsePhaseEventSchema: z.ZodObject<{
+export declare const PublishStreamSsePhaseEventSchema: z.ZodObject<{
     event: z.ZodLiteral<"phase">;
     data: z.ZodObject<{
         name: z.ZodString;
@@ -219,22 +219,22 @@ export declare const DeployStreamSsePhaseEventSchema: z.ZodObject<{
         data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export declare const DeployStreamSseLogEventSchema: z.ZodObject<{
+export declare const PublishStreamSseLogEventSchema: z.ZodObject<{
     event: z.ZodLiteral<"log">;
     data: z.ZodObject<{
         stream: z.ZodEnum<{
-            build: "build";
             runtime: "runtime";
-            deploy: "deploy";
+            build: "build";
+            publish: "publish";
         }>;
         content: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export declare const DeployStreamSseDoneEventSchema: z.ZodObject<{
+export declare const PublishStreamSseDoneEventSchema: z.ZodObject<{
     event: z.ZodLiteral<"done">;
     data: z.ZodObject<{
         success: z.ZodBoolean;
-        deploymentId: z.ZodString;
+        publicationId: z.ZodString;
         buildId: z.ZodString;
         releaseId: z.ZodString;
         status: z.ZodEnum<{
@@ -251,11 +251,11 @@ export declare const DeployStreamSseDoneEventSchema: z.ZodObject<{
         }>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export declare const DeployStreamSseResultEventSchema: z.ZodObject<{
+export declare const PublishStreamSseResultEventSchema: z.ZodObject<{
     event: z.ZodLiteral<"result">;
     data: z.ZodObject<{
         success: z.ZodBoolean;
-        deploymentId: z.ZodString;
+        publicationId: z.ZodString;
         buildId: z.ZodString;
         releaseId: z.ZodString;
         status: z.ZodEnum<{
@@ -272,13 +272,13 @@ export declare const DeployStreamSseResultEventSchema: z.ZodObject<{
         }>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export declare const DeployStreamSseErrorEventSchema: z.ZodObject<{
+export declare const PublishStreamSseErrorEventSchema: z.ZodObject<{
     event: z.ZodLiteral<"error">;
     data: z.ZodObject<{
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>;
 }, z.core.$strict>;
-export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const PublishStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
     event: z.ZodLiteral<"phase">;
     data: z.ZodObject<{
         name: z.ZodString;
@@ -293,9 +293,9 @@ export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUni
     event: z.ZodLiteral<"log">;
     data: z.ZodObject<{
         stream: z.ZodEnum<{
-            build: "build";
             runtime: "runtime";
-            deploy: "deploy";
+            build: "build";
+            publish: "publish";
         }>;
         content: z.ZodString;
     }, z.core.$strict>;
@@ -303,7 +303,7 @@ export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUni
     event: z.ZodLiteral<"done">;
     data: z.ZodObject<{
         success: z.ZodBoolean;
-        deploymentId: z.ZodString;
+        publicationId: z.ZodString;
         buildId: z.ZodString;
         releaseId: z.ZodString;
         status: z.ZodEnum<{
@@ -323,7 +323,7 @@ export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUni
     event: z.ZodLiteral<"result">;
     data: z.ZodObject<{
         success: z.ZodBoolean;
-        deploymentId: z.ZodString;
+        publicationId: z.ZodString;
         buildId: z.ZodString;
         releaseId: z.ZodString;
         status: z.ZodEnum<{
@@ -350,12 +350,12 @@ export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUni
     status?: "running" | "failed" | "completed";
     data?: Record<string, unknown>;
 } | {
-    stream: "build" | "runtime" | "deploy";
+    stream: "runtime" | "build" | "publish";
     content: string;
     type: "log";
 } | {
     success: boolean;
-    deploymentId: string;
+    publicationId: string;
     buildId: string;
     releaseId: string;
     status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
@@ -370,14 +370,14 @@ export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUni
 } | {
     event: "log";
     data: {
-        stream: "build" | "runtime" | "deploy";
+        stream: "runtime" | "build" | "publish";
         content: string;
     };
 } | {
     event: "done";
     data: {
         success: boolean;
-        deploymentId: string;
+        publicationId: string;
         buildId: string;
         releaseId: string;
         status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
@@ -386,7 +386,7 @@ export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUni
     event: "result";
     data: {
         success: boolean;
-        deploymentId: string;
+        publicationId: string;
         buildId: string;
         releaseId: string;
         status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
@@ -398,20 +398,20 @@ export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUni
         message?: string;
     };
 }>>;
-export type DeploymentTargetProvider = z.infer<typeof DeploymentTargetProviderSchema>;
-export type DeploymentStatus = z.infer<typeof DeploymentStatusSchema>;
-export type DeploymentBuildStatus = z.infer<typeof DeploymentBuildStatusSchema>;
-export type DeploymentReleaseStatus = z.infer<typeof DeploymentReleaseStatusSchema>;
-export type DeploymentSize = z.infer<typeof DeploymentSizeSchema>;
-export type DeploymentRegion = z.infer<typeof DeploymentRegionSchema>;
-export type DeploymentJurisdiction = z.infer<typeof DeploymentJurisdictionSchema>;
-export type DeploymentDomainDnsRecordType = z.infer<typeof DeploymentDomainDnsRecordTypeSchema>;
-export type DeploymentProtectionMode = z.infer<typeof DeploymentProtectionModeSchema>;
-export type DeploymentLogStream = z.infer<typeof DeploymentLogStreamSchema>;
-export type DeploymentEventData = z.infer<typeof DeploymentEventDataSchema>;
-export type DeploymentLogChunkData = z.infer<typeof DeploymentLogChunkDataSchema>;
-export type DeployStreamPhase = z.infer<typeof DeployStreamPhaseSchema>;
-export type DeployStreamLog = z.infer<typeof DeployStreamLogSchema>;
-export type DeployStreamResult = z.infer<typeof DeployStreamResultSchema>;
-export type DeployStreamEvent = z.infer<typeof DeployStreamEventSchema>;
-export type DeployStreamSseEvent = z.infer<typeof DeployStreamSseEventSchema>;
+export type BuiltInPublicationProviderName = z.infer<typeof PublicationProviderNameSchema>;
+export type PublicationStatus = z.infer<typeof PublicationStatusSchema>;
+export type PublicationBuildStatus = z.infer<typeof PublicationBuildStatusSchema>;
+export type PublicationReleaseStatus = z.infer<typeof PublicationReleaseStatusSchema>;
+export type PublicationSize = z.infer<typeof PublicationSizeSchema>;
+export type PublicationRegion = z.infer<typeof PublicationRegionSchema>;
+export type PublicationJurisdiction = z.infer<typeof PublicationJurisdictionSchema>;
+export type PublicationDomainDnsRecordType = z.infer<typeof PublicationDomainDnsRecordTypeSchema>;
+export type PublicationProtectionMode = z.infer<typeof PublicationProtectionModeSchema>;
+export type PublicationLogStream = z.infer<typeof PublicationLogStreamSchema>;
+export type PublicationEventData = z.infer<typeof PublicationEventDataSchema>;
+export type PublicationLogChunkData = z.infer<typeof PublicationLogChunkDataSchema>;
+export type PublishStreamPhase = z.infer<typeof PublishStreamPhaseSchema>;
+export type PublishStreamLog = z.infer<typeof PublishStreamLogSchema>;
+export type PublishStreamResult = z.infer<typeof PublishStreamResultSchema>;
+export type PublishStreamEvent = z.infer<typeof PublishStreamEventSchema>;
+export type PublishStreamSseEvent = z.infer<typeof PublishStreamSseEventSchema>;

package/dist/schemas/publications.js

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+export const PublicationProviderNameSchema = z.enum([
+    'cloudflare-containers',
+    'ssh-server',
+    'laravel-cloud',
+]);
+export const PublicationStatusSchema = z.enum([
+    'pending',
+    'queued',
+    'building',
+    'deploying',
+    'healthy',
+    'failed',
+    'stopped',
+    'deleting',
+    'deleted',
+    'delete_failed',
+]);
+export const PublicationBuildStatusSchema = z.enum([
+    'pending',
+    'queued',
+    'running',
+    'succeeded',
+    'failed',
+    'cancelled',
+]);
+export const PublicationReleaseStatusSchema = z.enum(['created', 'ready', 'deleted']);
+export const PublicationSizeSchema = z.enum([
+    'nano',
+    'small',
+    'medium',
+    'large',
+    'lite',
+    'basic',
+    'standard-1',
+    'standard-2',
+]);
+export const PublicationRegionSchema = z.enum([
+    'ENAM',
+    'WNAM',
+    'EEUR',
+    'WEUR',
+    'APAC',
+    'SAM',
+    'ME',
+    'OC',
+    'AFR',
+]);
+export const PublicationJurisdictionSchema = z.enum(['eu', 'fedramp']);
+export const PublicationDomainDnsRecordTypeSchema = z.enum(['CNAME', 'ALIAS', 'ANAME']);
+export const PublicationProtectionModeSchema = z.enum(['none', 'password']);
+export const PublicationLogStreamSchema = z.enum(['build', 'runtime']);
+export const PublishStreamLogStreamSchema = z.enum(['build', 'publish', 'runtime']);
+export const PublicationEventDataSchema = z.object({
+    id: z.union([z.number(), z.string()]).optional(),
+    sequence: z.number(),
+    type: z.string(),
+    payload: z.record(z.string(), z.unknown()),
+    createdAt: z.string().nullable(),
+}).passthrough();
+export const PublicationLogChunkDataSchema = z.object({
+    sequence: z.number(),
+    stream: PublicationLogStreamSchema,
+    content: z.string(),
+    createdAt: z.string().nullable(),
+}).passthrough();
+export const PublishStreamPhaseSchema = z.object({
+    name: z.string(),
+    status: z.enum(['running', 'completed', 'failed']).optional(),
+    data: z.record(z.string(), z.unknown()).optional(),
+}).strict();
+export const PublishStreamLogSchema = z.object({
+    stream: PublishStreamLogStreamSchema,
+    content: z.string(),
+}).strict();
+export const PublishStreamResultSchema = z.object({
+    success: z.boolean(),
+    publicationId: z.string(),
+    buildId: z.string(),
+    releaseId: z.string(),
+    status: PublicationStatusSchema,
+}).strict();
+export const PublishStreamPhaseEventSchema = PublishStreamPhaseSchema.extend({
+    type: z.literal('phase'),
+}).strict();
+export const PublishStreamLogEventSchema = PublishStreamLogSchema.extend({
+    type: z.literal('log'),
+}).strict();
+export const PublishStreamResultEventSchema = PublishStreamResultSchema.extend({
+    type: z.literal('result'),
+}).strict();
+export const PublishStreamEventSchema = z.discriminatedUnion('type', [
+    PublishStreamPhaseEventSchema,
+    PublishStreamLogEventSchema,
+    PublishStreamResultEventSchema,
+]);
+export const PublishStreamErrorSchema = z.object({
+    message: z.string().optional(),
+}).passthrough();
+export const PublishStreamSseEventNameSchema = z.enum(['phase', 'log', 'done', 'result', 'error']);
+export const PublishStreamSsePhaseEventSchema = z.object({
+    event: z.literal('phase'),
+    data: PublishStreamPhaseSchema,
+}).strict();
+export const PublishStreamSseLogEventSchema = z.object({
+    event: z.literal('log'),
+    data: PublishStreamLogSchema,
+}).strict();
+export const PublishStreamSseDoneEventSchema = z.object({
+    event: z.literal('done'),
+    data: PublishStreamResultSchema,
+}).strict();
+export const PublishStreamSseResultEventSchema = z.object({
+    event: z.literal('result'),
+    data: PublishStreamResultSchema,
+}).strict();
+export const PublishStreamSseErrorEventSchema = z.object({
+    event: z.literal('error'),
+    data: PublishStreamErrorSchema,
+}).strict();
+export const PublishStreamSseEventSchema = z.discriminatedUnion('event', [
+    PublishStreamSsePhaseEventSchema,
+    PublishStreamSseLogEventSchema,
+    PublishStreamSseDoneEventSchema,
+    PublishStreamSseResultEventSchema,
+    PublishStreamSseErrorEventSchema,
+]).transform((event) => {
+    if (event.event === 'error') {
+        throw new Error(event.data.message ?? 'Publish failed');
+    }
+    const type = event.event === 'done' ? 'result' : event.event;
+    return PublishStreamEventSchema.parse({ type, ...event.data });
+});

package/dist/services.d.ts

@@ -1,4 +1,4 @@
-import { Action, Disposable, NotebookInstance } from './index.js';
+import { Action, NotebookInstance } from './index.js';
 export type NotebookServiceKind = 'app' | 'web' | 'cache' | 'task';
 export type NotebookServiceSource = 'built_in' | 'setup_task';
 export type NotebookServiceState = 'running' | 'starting' | 'stopping' | 'backoff' | 'exited' | 'fatal' | 'stopped' | 'unknown';
@@ -64,20 +64,13 @@ export interface ServiceLogOptions {
     tail?: number;
     follow?: false;
 }
-export interface ServiceLogStream {
-    id: string;
-    output: ReadableStream<string>;
-    stop(): Promise<boolean>;
-}
 export default class Services {
     protected okra: NotebookInstance;
     constructor(okra: NotebookInstance);
     list(): Promise<NotebookServiceStatus[]>;
     run(name: NotebookServiceName, command?: NotebookServiceCommand): Promise<NotebookServiceStatus>;
     stop(name: NotebookServiceName): Promise<NotebookServiceStatus>;
-    onLog(id: string, handler: (data: ServiceEvents['service.log']) => void): Disposable;
-    listen<T extends keyof ServiceEvents>(event: T, handler: (data: ServiceEvents[T]) => void): Disposable;
-    logs(name: NotebookServiceName, options: ServiceLogStreamOptions): ServiceLogStream;
+    logs(name: NotebookServiceName, options: ServiceLogStreamOptions): ReadableStream<string>;
     logs(name: NotebookServiceName, options?: ServiceLogOptions): Promise<string>;
     private followLogs;
 }

package/dist/services.js

@@ -18,12 +18,6 @@ export default class Services {
     stop(name) {
         return this.okra.invoke('service.stop', { name });
     }
-    onLog(id, handler) {
-        return this.okra.listen(`service.log.${id}`, handler);
-    }
-    listen(event, handler) {
-        return this.okra.listen(event, handler);
-    }
     logs(name, options = {}) {
         if (options.follow) {
             return this.followLogs(name, options);
@@ -80,10 +74,10 @@ export default class Services {
             close();
             return this.okra.invoke('service.stop-logs', { id });
         });
-        const output = new ReadableStream({
+        return new ReadableStream({
             start: (_controller) => {
                 controller = _controller;
-                disposables.add(this.onLog(id, (data) => {
+                disposables.add(this.okra.listen(`service.log.${id}`, (data) => {
                     controller?.enqueue(data.output);
                 }));
                 void this.okra
@@ -98,9 +92,8 @@ export default class Services {
                 });
             },
             cancel: () => {
-                void stop();
+                return stop().then(() => undefined);
             },
         });
-        return { id, output, stop };
     }
 }

package/dist/shell.d.ts

@@ -1,8 +1,14 @@
-import { Action, Disposable, NotebookInstance } from './index.js';
+import type { Action, NotebookInstance } from './index.js';
 import type { SpawnOptions } from './terminal.js';
+export type ProcessOutputSource = 'output' | 'stdout' | 'stderr';
+export interface ProcessOutputChunk {
+    source: ProcessOutputSource;
+    data: Uint8Array;
+}
 export interface ShellEventData {
     'shell.output': {
         output: string;
+        source: ProcessOutputSource;
         id: string;
     };
 }
@@ -16,34 +22,58 @@ export interface ShellExecInput {
     opts?: Omit<SpawnOptions, 'abortSignal'>;
 }
 export interface ShellActions {
-    'shell.exec': Action<ShellExecInput, {
-        output: string;
-        exitCode: number;
-    }>;
-}
-export interface ShellExecution {
-    output: ReadableStream<string>;
-    result: Promise<Result>;
+    'shell.exec': Action<ShellExecInput, ProcessResultData>;
+    'shell.input': Action<{
+        id: string;
+        input: string;
+    }, boolean>;
+    'shell.kill': Action<{
+        id: string;
+    }, boolean>;
 }
-export declare class CommandError extends Error {
+export interface ProcessResultData {
     output: string;
+    stdout: string;
+    stderr: string;
     exitCode: number;
-    constructor(output: string, exitCode: number);
 }
-declare class Result {
-    output: string;
-    exitCode: number;
-    constructor(output: string, exitCode: number);
+export declare class CommandError extends Error {
+    readonly result: ProcessResult;
+    constructor(result: ProcessResult);
+}
+export declare class ProcessResult implements ProcessResultData {
+    readonly output: string;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number;
+    constructor(output: string, stdout: string, stderr: string, exitCode: number);
     throw(): this;
 }
+export declare class ProcessReadable<T> {
+    readonly stream: ReadableStream<T>;
+    private controller;
+    private closed;
+    constructor();
+    enqueue(value: T): void;
+    close(): void;
+    fail(error: unknown): void;
+}
+export declare class ShellProcess {
+    readonly id: string;
+    private readonly okra;
+    readonly output: ReadableStream<ProcessOutputChunk>;
+    readonly stdout: ReadableStream<Uint8Array>;
+    readonly stderr: ReadableStream<Uint8Array>;
+    readonly stdin: WritableStream<Uint8Array | string>;
+    private readonly completion;
+    constructor(id: string, okra: NotebookInstance, command: string | string[], opts: SpawnOptions);
+    wait(): Promise<ProcessResult>;
+    kill(): Promise<void>;
+}
 export default class Shell {
-    protected okra: NotebookInstance;
+    protected readonly okra: NotebookInstance;
     constructor(okra: NotebookInstance);
-    onOutput(id: string, handler: (data: ShellEvents['shell.output']) => void): Disposable;
-    listen<T extends keyof ShellEvents>(event: T, handler: (data: ShellEvents[T]) => void): Disposable;
-    exec(command: string | string[], opts?: SpawnOptions): Promise<Result>;
-    exec(command: string, args: string[], opts?: SpawnOptions): Promise<Result>;
-    execStream(command: string | string[], opts?: SpawnOptions): ShellExecution;
-    execStream(command: string, args: string[], opts?: SpawnOptions): ShellExecution;
+    run(command: string | string[], opts?: SpawnOptions): ShellProcess;
+    run(command: string, args: string[], opts?: SpawnOptions): ShellProcess;
 }
 export {};