@pikku/core 0.12.4 → 0.12.6

package/src/services/user-session-service.ts

@@ -0,0 +1,86 @@
+import type { ChannelStore } from '../wirings/channel/channel-store.js'
+import type { CoreUserSession } from '../types/core.types.js'
+
+export interface SessionService<UserSession extends CoreUserSession> {
+  sessionChanged: boolean
+  initial: UserSession | undefined
+  setInitial(session: UserSession): void
+  freezeInitial(): UserSession | undefined
+  set(session: UserSession): Promise<void> | void
+  clear(): Promise<void> | void
+  get(): Promise<UserSession> | UserSession | undefined
+}
+
+export class PikkuSessionService<UserSession extends CoreUserSession>
+  implements SessionService<UserSession>
+{
+  public sessionChanged = false
+  public initial: UserSession | undefined
+  private session: UserSession | undefined
+  constructor(
+    private channelStore?: ChannelStore<unknown, unknown, UserSession>,
+    private channelId?: string
+  ) {
+    if (channelStore && !channelId) {
+      throw new Error('Channel ID is required when using channel store')
+    }
+  }
+
+  public setInitial(session: UserSession) {
+    this.session = session
+  }
+
+  public freezeInitial() {
+    if (this.initial === undefined) {
+      this.initial = this.session
+    }
+    return this.initial
+  }
+
+  public set(session: UserSession) {
+    this.sessionChanged = true
+    this.session = session
+    return this.channelStore?.setUserSession(this.channelId!, session)
+  }
+
+  public clear() {
+    this.sessionChanged = true
+    this.session = undefined
+    return this.channelStore?.setUserSession(this.channelId!, null)
+  }
+
+  public get(): Promise<UserSession> | UserSession | undefined {
+    if (this.channelStore) {
+      const channel = this.channelStore.getChannelAndSession(this.channelId!)
+      if (channel instanceof Promise) {
+        return channel.then(({ session }) => session)
+      } else {
+        return channel.session
+      }
+    }
+    return this.session
+  }
+}
+
+export function createMiddlewareSessionWireProps<
+  UserSession extends CoreUserSession,
+>(session: SessionService<UserSession>) {
+  return {
+    session: session.get() as UserSession | undefined,
+    setSession: (s: UserSession) => session.setInitial(s),
+    getSession: () => session.get(),
+    hasSessionChanged: () => session.sessionChanged,
+  }
+}
+
+export function createFunctionSessionWireProps<
+  UserSession extends CoreUserSession,
+>(session: SessionService<UserSession>) {
+  return {
+    session: session.freezeInitial(),
+    setSession: (s: UserSession) => session.set(s),
+    clearSession: () => session.clear(),
+    getSession: () => session.get(),
+    hasSessionChanged: () => session.sessionChanged,
+  }
+}

package/src/services/variables-service.ts

@@ -0,0 +1,11 @@
+export interface VariablesService {
+  get: (name: string) => Promise<string | undefined> | string | undefined
+  getJSON: <T = unknown>(name: string) => Promise<T | undefined> | T | undefined
+  getAll: () =>
+    | Promise<Record<string, string | undefined>>
+    | Record<string, string | undefined>
+  set: (name: string, value: string) => Promise<void> | void
+  setJSON: (name: string, value: unknown) => Promise<void> | void
+  has: (name: string) => Promise<boolean> | boolean
+  delete: (name: string) => Promise<void> | void
+}

package/src/services/workflow-service.ts

@@ -0,0 +1,96 @@
+import type { SerializedError } from '../types/core.types.js'
+import type {
+  WorkflowRun,
+  WorkflowRunWire,
+  StepState,
+  WorkflowStatus,
+  WorkflowVersionStatus,
+} from '../wirings/workflow/workflow.types.js'
+
+/**
+ * Interface for workflow orchestration
+ * Handles workflow execution, replay, orchestration logic, and run-level state
+ */
+export interface WorkflowService {
+  // Run-level state operations
+  createRun(
+    workflowName: string,
+    input: any,
+    inline: boolean,
+    graphHash: string,
+    wire: WorkflowRunWire
+  ): Promise<string>
+  getRun(id: string): Promise<WorkflowRun | null>
+  getRunHistory(runId: string): Promise<Array<StepState & { stepName: string }>>
+  updateRunStatus(
+    id: string,
+    status: WorkflowStatus,
+    output?: any,
+    error?: SerializedError
+  ): Promise<void>
+  withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>
+  close(): Promise<void>
+
+  // Orchestration operations
+  resumeWorkflow(runId: string): Promise<void>
+  startWorkflow<I>(
+    name: string,
+    input: I,
+    wire: WorkflowRunWire,
+    rpcService: any,
+    options?: { inline?: boolean; startNode?: string }
+  ): Promise<{ runId: string }>
+  runWorkflowJob(runId: string, rpcService: any): Promise<void>
+  orchestrateWorkflow(runId: string, rpcService: any): Promise<void>
+  executeWorkflowSleepCompleted(runId: string, stepId: string): Promise<void>
+
+  // Step-level state operations
+  insertStepState(
+    runId: string,
+    stepName: string,
+    rpcName: string,
+    data: any,
+    stepOptions?: { retries?: number; retryDelay?: string | number }
+  ): Promise<StepState>
+  getStepState(runId: string, stepName: string): Promise<StepState>
+  setStepRunning(stepId: string): Promise<void>
+  setStepScheduled(stepId: string): Promise<void>
+  setStepResult(stepId: string, result: any): Promise<void>
+  setStepChildRunId(stepId: string, childRunId: string): Promise<void>
+  setStepError(stepId: string, error: Error): Promise<void>
+  createRetryAttempt(
+    stepId: string,
+    status: 'pending' | 'running'
+  ): Promise<StepState>
+
+  // Step execution
+  executeWorkflowStep(
+    runId: string,
+    stepName: string,
+    rpcName: string | null,
+    data: any,
+    rpcService: any
+  ): Promise<void>
+
+  // Version operations
+  upsertWorkflowVersion(
+    name: string,
+    graphHash: string,
+    graph: any,
+    source: string,
+    status?: WorkflowVersionStatus
+  ): Promise<void>
+  updateWorkflowVersionStatus(
+    name: string,
+    graphHash: string,
+    status: WorkflowVersionStatus
+  ): Promise<void>
+  getWorkflowVersion(
+    name: string,
+    graphHash: string
+  ): Promise<{ graph: any; source: string } | null>
+
+  getAIGeneratedWorkflows(
+    agentName?: string
+  ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>>
+}

package/src/testing/index.ts

@@ -0,0 +1,2 @@
+export { defineServiceTests } from './service-tests.js'
+export type { ServiceTestConfig } from './service-tests.js'