@onkernel/sdk 0.0.1-alpha.1 → 0.1.0-alpha.10

package/src/internal/utils/path.ts

@@ -0,0 +1,63 @@
+import { KernelError } from '../../core/error';
+
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export function encodeURIPath(str: string) {
+  return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+
+export const createPathTagFunction = (pathEncoder = encodeURIPath) =>
+  function path(statics: readonly string[], ...params: readonly unknown[]): string {
+    // If there are no params, no processing is needed.
+    if (statics.length === 1) return statics[0]!;
+
+    let postPath = false;
+    const path = statics.reduce((previousValue, currentValue, index) => {
+      if (/[?#]/.test(currentValue)) {
+        postPath = true;
+      }
+      return (
+        previousValue +
+        currentValue +
+        (index === params.length ? '' : (postPath ? encodeURIComponent : pathEncoder)(String(params[index])))
+      );
+    }, '');
+
+    const pathOnly = path.split(/[?#]/, 1)[0]!;
+    const invalidSegments = [];
+    const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+    let match;
+
+    // Find all invalid segments
+    while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+      invalidSegments.push({
+        start: match.index,
+        length: match[0].length,
+      });
+    }
+
+    if (invalidSegments.length > 0) {
+      let lastEnd = 0;
+      const underline = invalidSegments.reduce((acc, segment) => {
+        const spaces = ' '.repeat(segment.start - lastEnd);
+        const arrows = '^'.repeat(segment.length);
+        lastEnd = segment.start + segment.length;
+        return acc + spaces + arrows;
+      }, '');
+
+      throw new KernelError(`Path parameters result in path with invalid segments:\n${path}\n${underline}`);
+    }
+
+    return path;
+  };
+
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export const path = createPathTagFunction(encodeURIPath);

package/src/internal/utils/sleep.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

package/src/internal/utils/uuid.ts

@@ -0,0 +1,17 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export let uuid4 = function () {
+  const { crypto } = globalThis as any;
+  if (crypto?.randomUUID) {
+    uuid4 = crypto.randomUUID.bind(crypto);
+    return crypto.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0]! : () => (Math.random() * 0xff) & 0xff;
+  return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) =>
+    (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16),
+  );
+};

package/src/internal/utils/values.ts

@@ -0,0 +1,102 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { KernelError } from '../../core/error';
+
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+
+export const isAbsoluteURL = (url: string): boolean => {
+  return startsWithSchemeRegexp.test(url);
+};
+
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export function maybeObj(x: unknown): object {
+  if (typeof x !== 'object') {
+    return {};
+  }
+
+  return x ?? {};
+}
+
+// https://stackoverflow.com/a/34491287
+export function isEmptyObj(obj: Object | null | undefined): boolean {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+export function hasOwn<T extends object = object>(obj: T, key: PropertyKey): key is keyof T {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function isObj(obj: unknown): obj is Record<string, unknown> {
+  return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+
+export const ensurePresent = <T>(value: T | null | undefined): T => {
+  if (value == null) {
+    throw new KernelError(`Expected a value to be given but received ${value} instead.`);
+  }
+
+  return value;
+};
+
+export const validatePositiveInteger = (name: string, n: unknown): number => {
+  if (typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new KernelError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new KernelError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+
+export const coerceInteger = (value: unknown): number => {
+  if (typeof value === 'number') return Math.round(value);
+  if (typeof value === 'string') return parseInt(value, 10);
+
+  throw new KernelError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceFloat = (value: unknown): number => {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') return parseFloat(value);
+
+  throw new KernelError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceBoolean = (value: unknown): boolean => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value === 'true';
+  return Boolean(value);
+};
+
+export const maybeCoerceInteger = (value: unknown): number | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceInteger(value);
+};
+
+export const maybeCoerceFloat = (value: unknown): number | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceFloat(value);
+};
+
+export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceBoolean(value);
+};
+
+export const safeJSON = (text: string) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+};

package/src/internal/utils.ts

@@ -0,0 +1,8 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

package/src/resource.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/resource instead */
+export * from './core/resource';

package/src/resources/apps.ts

@@ -0,0 +1,187 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { type Uploadable } from '../core/uploads';
+import { RequestOptions } from '../internal/request-options';
+import { multipartFormRequestOptions } from '../internal/uploads';
+import { path } from '../internal/utils/path';
+
+export class Apps extends APIResource {
+  /**
+   * Deploy a new application
+   *
+   * @example
+   * ```ts
+   * const response = await client.apps.deploy({
+   *   entrypointRelPath: 'app.py',
+   *   file: fs.createReadStream('path/to/file'),
+   * });
+   * ```
+   */
+  deploy(body: AppDeployParams, options?: RequestOptions): APIPromise<AppDeployResponse> {
+    return this._client.post('/apps/deploy', multipartFormRequestOptions({ body, ...options }, this._client));
+  }
+
+  /**
+   * Invoke an application
+   *
+   * @example
+   * ```ts
+   * const response = await client.apps.invoke({
+   *   actionName: 'analyze',
+   *   appName: 'my-awesome-app',
+   *   payload: { data: 'example input' },
+   *   version: '1.0.0',
+   * });
+   * ```
+   */
+  invoke(body: AppInvokeParams, options?: RequestOptions): APIPromise<AppInvokeResponse> {
+    return this._client.post('/apps/invoke', { body, ...options });
+  }
+
+  /**
+   * Get an app invocation by id
+   *
+   * @example
+   * ```ts
+   * const response = await client.apps.retrieveInvocation(
+   *   'ckqwer3o20000jb9s7abcdef',
+   * );
+   * ```
+   */
+  retrieveInvocation(id: string, options?: RequestOptions): APIPromise<AppRetrieveInvocationResponse> {
+    return this._client.get(path`/apps/invocations/${id}`, options);
+  }
+}
+
+export interface AppDeployResponse {
+  apps: Array<AppDeployResponse.App>;
+
+  /**
+   * Success message
+   */
+  message: string;
+
+  /**
+   * Status of the deployment
+   */
+  success: boolean;
+}
+
+export namespace AppDeployResponse {
+  export interface App {
+    /**
+     * ID for the app version deployed
+     */
+    id: string;
+
+    actions: Array<App.Action>;
+
+    /**
+     * Name of the app
+     */
+    name: string;
+  }
+
+  export namespace App {
+    export interface Action {
+      /**
+       * Name of the action
+       */
+      name: string;
+    }
+  }
+}
+
+export interface AppInvokeResponse {
+  /**
+   * ID of the invocation
+   */
+  id: string;
+
+  /**
+   * Status of the invocation
+   */
+  status: 'QUEUED' | 'RUNNING' | 'SUCCEEDED' | 'FAILED';
+
+  /**
+   * Output from the invocation (if available)
+   */
+  output?: string;
+}
+
+export interface AppRetrieveInvocationResponse {
+  id: string;
+
+  appName: string;
+
+  finishedAt: string | null;
+
+  input: string;
+
+  output: string;
+
+  startedAt: string;
+
+  status: string;
+}
+
+export interface AppDeployParams {
+  /**
+   * Relative path to the entrypoint of the application
+   */
+  entrypointRelPath: string;
+
+  /**
+   * ZIP file containing the application source directory
+   */
+  file: Uploadable;
+
+  /**
+   * Allow overwriting an existing app version
+   */
+  force?: 'true' | 'false';
+
+  /**
+   * Region for deployment. Currently we only support "aws.us-east-1a"
+   */
+  region?: 'aws.us-east-1a';
+
+  /**
+   * Version of the application. Can be any string.
+   */
+  version?: string;
+}
+
+export interface AppInvokeParams {
+  /**
+   * Name of the action to invoke
+   */
+  actionName: string;
+
+  /**
+   * Name of the application
+   */
+  appName: string;
+
+  /**
+   * Input data for the application
+   */
+  payload: unknown;
+
+  /**
+   * Version of the application
+   */
+  version: string;
+}
+
+export declare namespace Apps {
+  export {
+    type AppDeployResponse as AppDeployResponse,
+    type AppInvokeResponse as AppInvokeResponse,
+    type AppRetrieveInvocationResponse as AppRetrieveInvocationResponse,
+    type AppDeployParams as AppDeployParams,
+    type AppInvokeParams as AppInvokeParams,
+  };
+}

package/src/resources/browser.ts

@@ -0,0 +1,48 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+
+export class Browser extends APIResource {
+  /**
+   * Create Browser Session
+   */
+  createSession(
+    body: BrowserCreateSessionParams,
+    options?: RequestOptions,
+  ): APIPromise<BrowserCreateSessionResponse> {
+    return this._client.post('/browser', { body, ...options });
+  }
+}
+
+export interface BrowserCreateSessionResponse {
+  /**
+   * Websocket URL for Chrome DevTools Protocol connections to the browser session
+   */
+  cdp_ws_url: string;
+
+  /**
+   * Remote URL for live viewing the browser session
+   */
+  remote_url: string;
+
+  /**
+   * Unique identifier for the browser session
+   */
+  sessionId: string;
+}
+
+export interface BrowserCreateSessionParams {
+  /**
+   * Kernel App invocation ID
+   */
+  invocationId: string;
+}
+
+export declare namespace Browser {
+  export {
+    type BrowserCreateSessionResponse as BrowserCreateSessionResponse,
+    type BrowserCreateSessionParams as BrowserCreateSessionParams,
+  };
+}

package/src/resources/index.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Apps,
+  type AppDeployResponse,
+  type AppInvokeResponse,
+  type AppRetrieveInvocationResponse,
+  type AppDeployParams,
+  type AppInvokeParams,
+} from './apps';
+export { Browser, type BrowserCreateSessionResponse, type BrowserCreateSessionParams } from './browser';

package/src/resources.ts

@@ -0,0 +1 @@
+export * from './resources/index';

package/src/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  // this config is included in the published src directory to prevent TS errors
+  // from appearing when users go to source, and VSCode opens the source .ts file
+  // via declaration maps
+  "include": ["index.ts"],
+  "compilerOptions": {
+    "target": "ES2015",
+    "lib": ["DOM", "DOM.Iterable", "ES2018"],
+    "moduleResolution": "node"
+  }
+}

package/src/uploads.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/uploads instead */
+export * from './core/uploads';

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.1.0-alpha.10'; // x-release-please-version

package/uploads.d.mts

@@ -0,0 +1,2 @@
+export * from "./core/uploads.mjs";
+//# sourceMappingURL=uploads.d.mts.map

package/uploads.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.d.mts","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""}

package/uploads.d.ts

@@ -0,0 +1,2 @@
+export * from "./core/uploads.js";
+//# sourceMappingURL=uploads.d.ts.map

package/uploads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.d.ts","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""}

package/uploads.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("./internal/tslib.js");
+/** @deprecated Import from ./core/uploads instead */
+tslib_1.__exportStar(require("./core/uploads.js"), exports);
+//# sourceMappingURL=uploads.js.map

package/uploads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.js","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":";;;AAAA,qDAAqD;AACrD,4DAA+B"}

package/uploads.mjs

@@ -0,0 +1,2 @@
+export * from "./core/uploads.mjs";
+//# sourceMappingURL=uploads.mjs.map

package/uploads.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.mjs","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""}

package/version.d.mts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.1.0-alpha.10";
+//# sourceMappingURL=version.d.mts.map

package/version.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.mts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,mBAAmB,CAAC"}

package/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.1.0-alpha.10";
+//# sourceMappingURL=version.d.ts.map

package/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,mBAAmB,CAAC"}

package/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = '0.1.0-alpha.10'; // x-release-please-version
+//# sourceMappingURL=version.js.map

package/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,gBAAgB,CAAC,CAAC,2BAA2B"}

package/version.mjs

@@ -0,0 +1,2 @@
+export const VERSION = '0.1.0-alpha.10'; // x-release-please-version
+//# sourceMappingURL=version.mjs.map

package/version.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.mjs","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,gBAAgB,CAAC,CAAC,2BAA2B"}

package/dist/index.cjs

@@ -1,71 +0,0 @@
-'use strict';
-
-// src/index.ts
-var KernelRegistry = class {
-  registry = /* @__PURE__ */ new Map();
-  register(item) {
-    this.registry.set(item.name, item);
-  }
-  getAll() {
-    return Array.from(this.registry.values());
-  }
-  getByName(name) {
-    return this.registry.get(name);
-  }
-  getByType(type) {
-    return this.getAll().filter((item) => item.type === type);
-  }
-};
-var registry = new KernelRegistry();
-var Kernel = {
-  /**
-   * Define a scheduled function
-   */
-  schedule: (cronExpression, fn) => {
-    registry.register({
-      type: "schedule",
-      name: fn.name || `schedule_${cronExpression.replace(/\s+/g, "_")}`,
-      cron: cronExpression,
-      handler: fn
-    });
-    return fn;
-  },
-  /**
-   * Define an HTTP endpoint
-   */
-  endpoint: (options, handler) => {
-    registry.register({
-      type: "http",
-      name: handler.name || `endpoint_${options.method.toLowerCase()}_${options.path.replace(/\//g, "_")}`,
-      path: options.path,
-      method: options.method,
-      handler
-    });
-    return handler;
-  },
-  /**
-   * Use a browser for automation
-   * The returned browser object contains cdp_ws_url which should be used with playwright:
-   * const browser = await chromium.connectOverCDP(cdp_ws_url);
-   */
-  useBrowser: (fn) => {
-    return fn({
-      cdp_ws_url: "ws://localhost:9222"
-    });
-  },
-  /**
-   * Define a function
-   */
-  func: (fn) => {
-    const name = fn.name || "default";
-    registry.register({
-      type: "function",
-      name,
-      handler: fn
-    });
-    return fn;
-  }
-};
-
-exports.Kernel = Kernel;
-exports.registry = registry;

package/dist/index.d.cts

@@ -1,59 +0,0 @@
-interface Request {
-    query: Record<string, string>;
-    body?: any;
-}
-interface Browser {
-    cdp_ws_url: string;
-}
-interface KernelFunction {
-    type: 'function';
-    name: string;
-    handler: (...args: any[]) => Promise<any>;
-}
-interface KernelSchedule {
-    type: 'schedule';
-    name: string;
-    cron: string;
-    handler: () => Promise<void>;
-}
-interface KernelEndpoint {
-    type: 'http';
-    name: string;
-    path: string;
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    handler: (req: Request) => Promise<any>;
-}
-type KernelRegistryItem = KernelFunction | KernelSchedule | KernelEndpoint;
-declare class KernelRegistry {
-    private registry;
-    register(item: KernelRegistryItem): void;
-    getAll(): KernelRegistryItem[];
-    getByName(name: string): KernelRegistryItem | undefined;
-    getByType(type: 'function' | 'schedule' | 'http'): KernelRegistryItem[];
-}
-declare const registry: KernelRegistry;
-declare const Kernel: {
-    /**
-     * Define a scheduled function
-     */
-    schedule: (cronExpression: string, fn: () => Promise<void>) => () => Promise<void>;
-    /**
-     * Define an HTTP endpoint
-     */
-    endpoint: <T>(options: {
-        path: string;
-        method: string;
-    }, handler: (req: Request) => Promise<T>) => (req: Request) => Promise<T>;
-    /**
-     * Use a browser for automation
-     * The returned browser object contains cdp_ws_url which should be used with playwright:
-     * const browser = await chromium.connectOverCDP(cdp_ws_url);
-     */
-    useBrowser: <T>(fn: (browser: Browser) => Promise<T>) => Promise<T>;
-    /**
-     * Define a function
-     */
-    func: <T, R>(fn: (input: T) => Promise<R>) => (input: T) => Promise<R>;
-};
-
-export { type Browser, Kernel, type KernelEndpoint, type KernelFunction, type KernelRegistryItem, type KernelSchedule, type Request, registry };