@vite-hub/workflow 0.0.3 → 0.1.0

package/dist/operations-tNUdj3G4.d.ts

@@ -0,0 +1,212 @@
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region ../internal/src/operations.d.ts
+/** `read` never changes state. `write` changes state. `destructive` deletes or publishes. */
+type OperationKind = "read" | "write" | "destructive";
+/** The signed-in user of a call. */
+interface OperationUser {
+  id: string;
+  name?: string;
+  email?: string;
+  image?: string;
+  [key: string]: unknown;
+}
+/** The Agent Actor when an agent calls through a capability or MCP on behalf of a user. */
+interface OperationActor {
+  id: string;
+  kind?: string;
+  label?: string;
+  meta?: object;
+}
+/** The checked Console access of a call. `vite-hub` issues it. `ConsoleAccess` has this shape. */
+interface OperationAccess {
+  readonly mode: string;
+  /**
+   * The sections that the call may use. `"all"` when no section filter applies. An entry is a section id (`"kv"`, every
+   * operation of the section) or `"<section>:read"` (only the operations that read).
+   */
+  readonly sections: "all" | readonly string[];
+  readonly user?: OperationUser;
+}
+interface OperationContext {
+  /** The checked Console access of the call. */
+  access: OperationAccess;
+  /** The signed-in user, or null. */
+  user: OperationUser | null;
+  /** The Agent Actor when an agent calls on behalf of `user`. */
+  actor?: OperationActor;
+  surface: "console" | "cli" | "mcp" | "agent";
+  /** Set by the host from generated build identity, never from request input or runtime NODE_ENV. */
+  development?: boolean;
+  env?: Record<string, unknown>;
+  waitUntil?: (task: Promise<unknown>) => void;
+  request?: Request;
+  /** Operations set a success status here, such as 202 for an accepted call. */
+  response?: {
+    status?: number;
+  };
+  /**
+   * An agent or an MCP client may pass `lease: "override"` to `content.save`, `content.remove`, and `content.restore`
+   * only when the developer allowed it. Defaults to false, so a model cannot take over a document that a person is editing.
+   */
+  overrideLeases?: boolean;
+  /**
+   * What an Agent may read of the Channel conversations, set by `operations({ conversations })`. `participant`: only the
+   * threads that the Actor takes part in. `all`: every thread. Unset: none.
+   */
+  conversations?: "all" | "participant";
+}
+interface OperationDefinition<Input, Output> {
+  /** `<section>.<verb>`, such as `content.publish`. Unique per app. */
+  name: string;
+  /** One sentence. Becomes the CLI help line and the MCP tool description. */
+  description: string;
+  /**
+   * Console section that grants access, such as `content`. `false`: any Console user. A function reads the section
+   * from the input, for operations that serve several sections.
+   */
+  section: string | false | ((input: Input) => string | undefined);
+  /** `read` never changes state. `write` changes state. `destructive` deletes or publishes; the CLI asks for `--yes`, MCP marks `destructiveHint`, agents require approval by default. */
+  kind: OperationKind;
+  /** Standard Schema (valibot in this repo). Its Standard JSON Schema builds CLI flags and the MCP input schema. */
+  input: StandardSchemaV1<unknown, Input>;
+  output?: StandardSchemaV1<unknown, Output>;
+  cli?: {
+    /** Defaults: namespace = section, command = verb. */
+    namespace?: string;
+    command?: string;
+    /** Input keys read from positional arguments, in order. */
+    positional?: string[];
+    /** Human output, written verbatim. Without it the CLI prints JSON. `--json` always prints JSON. */
+    format?: (output: Output) => string;
+    /** `vitehub <namespace>` runs this command when no command is named, such as `vitehub usage`. */
+    default?: boolean;
+    /**
+     * Route of the app that takes a signed dispatch of this operation, such as `/_vitehub/schedules/run`. With `--url`
+     * and a dispatch key in the environment (`VITEHUB_DISPATCH_KEY`), the command signs the input and posts it there, so
+     * a CI job needs no Console credentials. Without a key it calls the RPC.
+     */
+    dispatch?: string;
+  };
+  /** Largest request body in bytes. It can raise the 64 KiB default but not lower it. */
+  maxRequestBytes?: number;
+  /**
+   * Returns true when this call only reads, such as a dry run of a `destructive` operation. The CLI then skips the
+   * confirmation, and agents run it without approval. Without it, every call of a `destructive` operation asks.
+   */
+  readOnlyWhen?: (input: Input) => boolean;
+  /** `false`: MCP does not offer the operation as a tool, such as an editor transport that only the Console uses. */
+  mcp?: false;
+  /** `false`: the operation never reads `context.user`, so the Console skips the session lookup for it. */
+  user?: false;
+  /**
+   * The operation runs code of the app, such as a workflow, a job, a task, or a schedule. The Console registers it only
+   * when `console.invoke` is on, which is the default in development and off in a production build.
+   */
+  invoke?: true;
+  run: (input: Input, context: OperationContext) => Output | Promise<Output>;
+}
+/** An operation of any input and output, as a registry holds it. */
+interface AnyOperation extends Omit<OperationDefinition<unknown, unknown>, "cli" | "input" | "output" | "readOnlyWhen" | "run" | "section"> {
+  readOnlyWhen?: (input: never) => boolean;
+  cli?: {
+    namespace?: string;
+    command?: string;
+    default?: boolean;
+    dispatch?: string;
+    positional?: string[];
+    format?: (output: never) => string;
+  };
+  input: StandardSchemaV1;
+  output?: StandardSchemaV1;
+  run: (input: never, context: OperationContext) => unknown;
+  section: string | false | ((input: never) => string | undefined);
+}
+/** The contribution of one plugin: operations, or a module that exports them. */
+interface OperationContributionEntry {
+  /** Module the app imports, such as `@vite-hub/content/operations`. */
+  module: string;
+  /** Named export that holds an operation or an array of operations. Defaults to `default`. */
+  export?: string;
+  /** Loads the export in the tool process, for a module that the tool cannot resolve by name. */
+  load?: () => Promise<unknown>;
+  /** `false`: the app already has these operations at runtime. Only tools such as the CLI and `vitehub inspect` read the entry. */
+  runtime?: false;
+}
+//#endregion
+export { OperationContributionEntry as n, AnyOperation as t };

package/dist/operations.d.ts

@@ -0,0 +1,37 @@
+import { E as WorkflowRunStatus, x as WorkflowProvider } from "./types-D82WmfZa.js";
+import { t as AnyOperation } from "./operations-tNUdj3G4.js";
+//#region src/results.d.ts
+/** One Workflow run as the operations return it. The start payload is not included. */
+interface WorkflowRunView {
+  completedAt?: string;
+  createdAt?: string;
+  error?: {
+    code?: string;
+    message: string;
+    name?: string;
+  };
+  id: string;
+  metadata?: unknown;
+  provider: WorkflowProvider;
+  result?: unknown;
+  startedAt?: string;
+  status: WorkflowRunStatus;
+  workflow: string;
+}
+/** The signal that `workflow.resume` delivered. */
+interface WorkflowSignalView {
+  id: string;
+  provider: WorkflowProvider;
+}
+interface WorkflowRunResult {
+  run: WorkflowRunView;
+}
+interface WorkflowSignalResult {
+  signal: WorkflowSignalView;
+}
+//#endregion
+//#region src/operations.d.ts
+/** The `workflow.*` operations: start, get, cancel, and resume. The Console, `vitehub workflow`, and agents run them. */
+export declare const workflowOperations: readonly AnyOperation[];
+//#endregion
+export type { WorkflowRunResult, WorkflowRunView, WorkflowSignalResult, WorkflowSignalView };