@hasna/loops 0.4.28 → 0.4.29

package/dist/lib/storage/provider-credentials.d.ts

@@ -0,0 +1,84 @@
+import { type SecretsManagerClientConfig } from "@aws-sdk/client-secrets-manager";
+import type { PoolQueryClient } from "../../generated/storage-kit/query.js";
+import { PostgresStorage } from "./postgres.js";
+export declare const PROVIDER_CREDENTIAL_SPECS: Readonly<{
+    migrator: Readonly<{
+        login: "open_loops_migrator_login";
+        secretOption: "migratorSecretArn";
+    }>;
+    runtime: Readonly<{
+        login: "open_loops_runtime_login";
+        secretOption: "runtimeSecretArn";
+        role: "open_loops_runtime";
+    }>;
+    authenticator: Readonly<{
+        login: "open_loops_authenticator_login";
+        secretOption: "authenticatorSecretArn";
+        role: "open_loops_authenticator";
+    }>;
+}>;
+type CredentialPurpose = keyof typeof PROVIDER_CREDENTIAL_SPECS;
+type ServicePurpose = Exclude<CredentialPurpose, "migrator">;
+type CredentialPhase = "pre_0010" | "post_0010";
+type SecretStage = "AWSCURRENT" | "AWSPENDING";
+export interface ProviderCredentialOptions {
+    region: string;
+    credentialsRelativeUri: string;
+    masterSecretArn: string;
+    migratorSecretArn: string;
+    runtimeSecretArn: string;
+    authenticatorSecretArn: string;
+    expectedInstanceId: string;
+    expectedEndpoint: string;
+    expectedPort: number;
+    expectedDatabase: string;
+    expectedMasterUsername: string;
+}
+interface SecretValue {
+    value: string;
+    versionId: string;
+}
+type ProviderCredentialFetch = (input: string, init?: RequestInit) => Promise<Response>;
+export interface ProviderCredentialSecretStore {
+    get(secretId: string, stage: SecretStage): Promise<SecretValue | undefined>;
+    putPending(secretId: string, value: string): Promise<SecretValue>;
+    promote(secretId: string, pendingVersionId: string, currentVersionId?: string): Promise<void>;
+}
+interface CredentialInspection {
+    valid: boolean;
+    enforcementApplied: boolean;
+}
+export interface ProviderCredentialDatabase {
+    bootstrapBeforeSecrets(): Promise<void>;
+    setPassword(purpose: CredentialPurpose, password: string): Promise<void>;
+    inspectCredential(purpose: CredentialPurpose, dsn: string, attached: boolean): Promise<CredentialInspection>;
+    probeMigrator(dsn: string): Promise<CredentialPhase>;
+    attachService(purpose: ServicePurpose): Promise<void>;
+    detachService(purpose: ServicePurpose): Promise<void>;
+    close(): Promise<void>;
+}
+export interface ProviderCredentialResult {
+    phase: CredentialPhase;
+    status: "ok";
+    invariants: {
+        bootstrapNormalized: true;
+        transportVerified: true;
+        ledgerExact: true;
+        serviceMembershipsSafe: true;
+    };
+    affectedSecrets: number;
+}
+export interface ProviderCredentialDependencies {
+    secretStore?: ProviderCredentialSecretStore;
+    createDatabase?: (masterDsn: string, probe: BootstrapProbe) => ProviderCredentialDatabase;
+    random?: (bytes: number) => Uint8Array;
+    bootstrapProbe: BootstrapProbe;
+}
+export type BootstrapProbe = (client: PoolQueryClient, schema: PostgresStorage) => Promise<void>;
+export declare function resolveProviderCredentialOptions(env?: NodeJS.ProcessEnv): ProviderCredentialOptions;
+export declare function reconcileProviderCredentials(options: ProviderCredentialOptions, dependencies: ProviderCredentialDependencies): Promise<ProviderCredentialResult>;
+export declare function logProviderCredentialSuccess(result: ProviderCredentialResult): void;
+export declare function createAwsSecretsManagerClientConfig(options: ProviderCredentialOptions, fetchImpl?: ProviderCredentialFetch): SecretsManagerClientConfig;
+export declare const PROVIDER_BOOTSTRAP_MEMBERSHIPS_SQL: string;
+export declare const PROVIDER_BOOTSTRAP_INVARIANT_SQL: string;
+export {};

package/dist/lib/storage/shared-database-transfer.d.ts

@@ -0,0 +1,136 @@
+import type { AppliedStorageMigration } from "./contract.js";
+export declare const SHARED_TRANSFER_SOURCE_DSN_ENV = "HASNA_LOOPS_TRANSFER_SOURCE_DATABASE_URL";
+export declare const SHARED_TRANSFER_TARGET_DSN_ENV = "HASNA_LOOPS_TRANSFER_TARGET_DATABASE_URL";
+export declare const SHARED_TRANSFER_SOURCE_DATABASE = "apps";
+export declare const SHARED_TRANSFER_TARGET_DATABASE = "loops";
+export declare const SHARED_TRANSFER_TARGET_BASE_THROUGH = "0007_work_item_gate_deaths";
+export declare const SHARED_TRANSFER_TARGET_PREPARE_THROUGH = "0008_tenant_prepare";
+export declare const SHARED_TRANSFER_FIXED_COMMAND: readonly ["bun", "dist/serve/index.js", "shared-to-dedicated-transfer"];
+export declare const SHARED_TRANSFER_TABLES: readonly [{
+    readonly name: "loops";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "workflow_specs";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "runner_machines";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "goals";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "loop_runs";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "workflow_invocations";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "workflow_runs";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "workflow_work_items";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "workflow_step_runs";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "workflow_events";
+    readonly orderBy: readonly ["workflow_run_id", "sequence", "id"];
+}, {
+    readonly name: "goal_plan_nodes";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "goal_runs";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "runner_leases";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "audit_events";
+    readonly orderBy: readonly ["id"];
+}, {
+    readonly name: "run_receipts";
+    readonly orderBy: readonly ["run_id"];
+}, {
+    readonly name: "daemon_lease";
+    readonly orderBy: readonly ["id"];
+}];
+export declare const SHARED_TRANSFER_API_KEY_COLUMNS: readonly ["kid", "app", "agent", "scopes", "token_hash", "issued_at", "expires_at", "revoked_at", "revoked_reason", "last_used_at", "created_by", "created_at"];
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface CommandRunner {
+    (command: readonly string[], opts?: {
+        env?: Record<string, string>;
+        input?: string;
+    }): Promise<CommandResult>;
+}
+export interface SharedTransferOptions {
+    env?: NodeJS.ProcessEnv;
+    runner?: CommandRunner;
+    migrateTargetThrough?: (targetDsn: string, through: string) => Promise<AppliedStorageMigration[]>;
+    now?: () => Date;
+}
+export interface TransferCount {
+    table_name: string;
+    row_count: string | number;
+}
+export interface TransferHash {
+    table: string;
+    sha256: string;
+}
+export interface TransferEvidence {
+    schema: "open-loops.shared-to-dedicated-transfer/v1";
+    executedAt: string;
+    command: readonly string[];
+    source: {
+        database: typeof SHARED_TRANSFER_SOURCE_DATABASE;
+    };
+    target: {
+        database: typeof SHARED_TRANSFER_TARGET_DATABASE;
+    };
+    archive: {
+        file: "openloops-allowlist.dump";
+        sha256: string;
+        cleaned: boolean;
+    };
+    ledgers: {
+        sourceContains0001Through0007: AppliedStorageMigration[];
+        targetExact0001Through0007: AppliedStorageMigration[];
+        targetContains0001Through0008: AppliedStorageMigration[];
+    };
+    sourceCounts: TransferCount[];
+    targetCounts: TransferCount[];
+    sourceHashes: TransferHash[];
+    targetHashes: TransferHash[];
+    apiKeys: {
+        copiedRows: number;
+        sha256: string;
+        nonLoopRowsOnTarget: number;
+    };
+    orphanChecks: Array<{
+        check_name: string;
+        orphan_count: string | number;
+    }>;
+    unexpectedTargetObjects: Array<{
+        object_name: string;
+        object_kind: string;
+    }>;
+    nextSequence: readonly string[];
+}
+export interface TenantEnforcementForeignKeyCheck {
+    checkName: string;
+    childTable: string;
+    childColumn: string;
+    parentTable: string;
+}
+export declare function tenantEnforcementForeignKeyChecks(): readonly TenantEnforcementForeignKeyCheck[];
+export declare function runSharedToDedicatedTransfer(opts?: SharedTransferOptions): Promise<TransferEvidence>;
+export declare function buildPgServiceFile(sourceDsn: string, targetDsn: string): string;
+export declare function expectedLedgerRows(through: string): AppliedStorageMigration[];
+export declare function assertExactLedger(rows: AppliedStorageMigration[], through: string, label: string): AppliedStorageMigration[];
+export declare function assertLedgerContainsExpected(rows: AppliedStorageMigration[], through: string, label: string): AppliedStorageMigration[];
+export declare function pgDumpCommand(archivePath: string): readonly string[];
+export declare function pgRestoreCommand(archivePath: string): readonly string[];

package/dist/lib/storage/sqlite.d.ts

@@ -15,9 +15,12 @@ export declare class SqliteLoopStorage implements LoopStorageContract {
     getLoop(...args: StoreMethod<"getLoop">["args"]): Promise<import("../../types.js").Loop | undefined>;
     findLoopByName(...args: StoreMethod<"findLoopByName">["args"]): Promise<import("../../types.js").Loop | undefined>;
     requireLoop(...args: StoreMethod<"requireLoop">["args"]): Promise<import("../../types.js").Loop>;
+    requireUniqueLoop(...args: StoreMethod<"requireUniqueLoop">["args"]): Promise<import("../../types.js").Loop>;
     listLoops(...args: StoreMethod<"listLoops">["args"]): Promise<import("../../types.js").Loop[]>;
     dueLoops(...args: StoreMethod<"dueLoops">["args"]): Promise<import("../../types.js").Loop[]>;
     updateLoop(...args: StoreMethod<"updateLoop">["args"]): Promise<import("../../types.js").Loop>;
+    advanceLoopIfCurrent(...args: StoreMethod<"advanceLoopIfCurrent">["args"]): Promise<import("../../types.js").Loop | undefined>;
+    tripCircuitBreakerIfCurrent(...args: StoreMethod<"tripCircuitBreakerIfCurrent">["args"]): Promise<import("../store.js").CircuitBreakerTransitionResult | undefined>;
     renameLoop(...args: StoreMethod<"renameLoop">["args"]): Promise<import("../../types.js").Loop>;
     archiveLoop(...args: StoreMethod<"archiveLoop">["args"]): Promise<import("../../types.js").Loop>;
     unarchiveLoop(...args: StoreMethod<"unarchiveLoop">["args"]): Promise<import("../../types.js").Loop>;
@@ -27,6 +30,7 @@ export declare class SqliteLoopStorage implements LoopStorageContract {
     upsertMigrationWorkflow(...args: StoreMethod<"upsertMigrationWorkflow">["args"]): Promise<import("../../types.js").WorkflowSpec>;
     createWorkflow(...args: StoreMethod<"createWorkflow">["args"]): Promise<import("../../types.js").WorkflowSpec>;
     getWorkflow(...args: StoreMethod<"getWorkflow">["args"]): Promise<import("../../types.js").WorkflowSpec | undefined>;
+    requireWorkflow(...args: StoreMethod<"requireWorkflow">["args"]): Promise<import("../../types.js").WorkflowSpec>;
     listWorkflows(...args: StoreMethod<"listWorkflows">["args"]): Promise<import("../../types.js").WorkflowSpec[]>;
     countWorkflows(...args: StoreMethod<"countWorkflows">["args"]): Promise<number>;
     archiveWorkflow(...args: StoreMethod<"archiveWorkflow">["args"]): Promise<import("../../types.js").WorkflowSpec>;
@@ -44,6 +48,8 @@ export declare class SqliteLoopStorage implements LoopStorageContract {
     admitWorkflowWorkItem(...args: StoreMethod<"admitWorkflowWorkItem">["args"]): Promise<import("../../types.js").WorkflowWorkItem>;
     createGoal(...args: StoreMethod<"createGoal">["args"]): Promise<import("../goal/types.js").Goal>;
     getGoal(...args: StoreMethod<"getGoal">["args"]): Promise<import("../goal/types.js").Goal | undefined>;
+    requireGoal(...args: StoreMethod<"requireGoal">["args"]): Promise<import("../goal/types.js").Goal>;
+    findGoalByContext(...args: StoreMethod<"findGoalByContext">["args"]): Promise<import("../goal/types.js").Goal | undefined>;
     listGoals(...args: StoreMethod<"listGoals">["args"]): Promise<import("../goal/types.js").Goal[]>;
     createGoalPlanNodes(...args: StoreMethod<"createGoalPlanNodes">["args"]): Promise<import("../goal/types.js").GoalPlanNode[]>;
     listGoalPlanNodes(...args: StoreMethod<"listGoalPlanNodes">["args"]): Promise<import("../goal/types.js").GoalPlanNode[]>;
@@ -53,26 +59,33 @@ export declare class SqliteLoopStorage implements LoopStorageContract {
     listGoalRuns(...args: StoreMethod<"listGoalRuns">["args"]): Promise<import("../goal/types.js").GoalRun[]>;
     createWorkflowRun(...args: StoreMethod<"createWorkflowRun">["args"]): Promise<import("../../types.js").WorkflowRun>;
     getWorkflowRun(...args: StoreMethod<"getWorkflowRun">["args"]): Promise<import("../../types.js").WorkflowRun | undefined>;
+    requireWorkflowRun(...args: StoreMethod<"requireWorkflowRun">["args"]): Promise<import("../../types.js").WorkflowRun>;
     listWorkflowRuns(...args: StoreMethod<"listWorkflowRuns">["args"]): Promise<import("../../types.js").WorkflowRun[]>;
     listWorkflowStepRuns(...args: StoreMethod<"listWorkflowStepRuns">["args"]): Promise<import("../../types.js").WorkflowStepRun[]>;
     getWorkflowStepRun(...args: StoreMethod<"getWorkflowStepRun">["args"]): Promise<import("../../types.js").WorkflowStepRun | undefined>;
+    isWorkflowRunTerminal(...args: StoreMethod<"isWorkflowRunTerminal">["args"]): Promise<boolean>;
     startWorkflowStepRun(...args: StoreMethod<"startWorkflowStepRun">["args"]): Promise<import("../../types.js").WorkflowStepRun>;
+    markWorkflowStepPid(...args: StoreMethod<"markWorkflowStepPid">["args"]): Promise<import("../../types.js").WorkflowStepRun>;
+    recordWorkflowStepProgress(...args: StoreMethod<"recordWorkflowStepProgress">["args"]): Promise<import("../../types.js").WorkflowStepRun>;
     recoverWorkflowRun(...args: StoreMethod<"recoverWorkflowRun">["args"]): Promise<{
         run: import("../../types.js").WorkflowRun;
         recoveredSteps: import("../../types.js").WorkflowStepRun[];
     }>;
     finalizeWorkflowStepRun(...args: StoreMethod<"finalizeWorkflowStepRun">["args"]): Promise<import("../../types.js").WorkflowStepRun>;
+    skipWorkflowStepRun(...args: StoreMethod<"skipWorkflowStepRun">["args"]): Promise<import("../../types.js").WorkflowStepRun>;
     finalizeWorkflowRun(...args: StoreMethod<"finalizeWorkflowRun">["args"]): Promise<import("../../types.js").WorkflowRun>;
-    appendWorkflowEvent(...args: StoreMethod<"appendWorkflowEvent">["args"]): Promise<import("../../types.js").WorkflowEvent>;
-    listWorkflowEvents(...args: StoreMethod<"listWorkflowEvents">["args"]): Promise<import("../../types.js").WorkflowEvent[]>;
+    appendWorkflowEvent(...args: StoreMethod<"appendWorkflowEvent">["args"]): Promise<import("../../types.js").StoredWorkflowEvent>;
+    listWorkflowEvents(...args: StoreMethod<"listWorkflowEvents">["args"]): Promise<import("../../types.js").StoredWorkflowEvent[]>;
     recordRunProcess(...args: StoreMethod<"recordRunProcess">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
     createSkippedRun(...args: StoreMethod<"createSkippedRun">["args"]): Promise<import("../../types.js").LoopRun>;
     getRun(...args: StoreMethod<"getRun">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
     getRunBySlot(...args: StoreMethod<"getRunBySlot">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
+    nextRetryableRun(...args: StoreMethod<"nextRetryableRun">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
     claimRun(...args: StoreMethod<"claimRun">["args"]): Promise<import("../store.js").ClaimRunResult | undefined>;
     finalizeRun(...args: StoreMethod<"finalizeRun">["args"]): Promise<import("../../types.js").LoopRun>;
     heartbeatRunLease(...args: StoreMethod<"heartbeatRunLease">["args"]): Promise<import("../../types.js").LoopRun | undefined>;
     listRuns(...args: StoreMethod<"listRuns">["args"]): Promise<import("../../types.js").LoopRun[]>;
+    listRecoveredLeaseRunsPage(...args: StoreMethod<"listRecoveredLeaseRunsPage">["args"]): Promise<import("../store.js").RecoveredLeaseRunPage>;
     writeRunReceipt(...args: StoreMethod<"writeRunReceipt">["args"]): Promise<import("../../types.js").RunReceipt>;
     getRunReceipt(...args: StoreMethod<"getRunReceipt">["args"]): Promise<import("../../types.js").RunReceipt | undefined>;
     listRunReceipts(...args: StoreMethod<"listRunReceipts">["args"]): Promise<import("../../types.js").RunReceipt[]>;