@hasna/loops 0.4.13 → 0.4.22

package/dist/sdk/http.js

@@ -0,0 +1,166 @@
+// @bun
+// src/sdk/http.ts
+class ApiError extends Error {
+  status;
+  body;
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+}
+
+class LoopsClient {
+  baseUrl;
+  apiKey;
+  fetchImpl;
+  baseHeaders;
+  constructor(options) {
+    if (!options.baseUrl)
+      throw new Error("LoopsClient requires a baseUrl.");
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.baseHeaders = options.headers ?? {};
+  }
+  async request(method, path, opts) {
+    const url = new URL(this.baseUrl + path);
+    if (opts.query) {
+      for (const [key, value] of Object.entries(opts.query)) {
+        if (value !== undefined && value !== null)
+          url.searchParams.set(key, String(value));
+      }
+    }
+    const headers = { Accept: "application/json", ...this.baseHeaders, ...opts.init?.headers };
+    if (this.apiKey)
+      headers["x-api-key"] = this.apiKey;
+    let payload;
+    if (opts.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      payload = JSON.stringify(opts.body);
+    }
+    const response = await this.fetchImpl(url.toString(), { ...opts.init, method, headers, body: payload });
+    const text = await response.text();
+    const data = text ? (() => {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    })() : undefined;
+    if (!response.ok) {
+      throw new ApiError(response.status, `${method} ${path} failed: ${response.status}`, data);
+    }
+    return data;
+  }
+  async healthCheck(init) {
+    return this.request("GET", `/health`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async readyCheck(init) {
+    return this.request("GET", `/ready`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async listLoops(query, init) {
+    return this.request("GET", `/v1/loops`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async createLoop(body, init) {
+    return this.request("POST", `/v1/loops`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async getLoop(id, init) {
+    return this.request("GET", `/v1/loops/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async deleteLoop(id, init) {
+    return this.request("DELETE", `/v1/loops/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async updateLoop(id, body, init) {
+    return this.request("PATCH", `/v1/loops/${encodeURIComponent(String(id))}`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async archiveLoop(id, init) {
+    return this.request("POST", `/v1/loops/${encodeURIComponent(String(id))}/archive`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async unarchiveLoop(id, init) {
+    return this.request("POST", `/v1/loops/${encodeURIComponent(String(id))}/unarchive`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async listRunReceipts(query, init) {
+    return this.request("GET", `/v1/receipts`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async writeRunReceipt(body, init) {
+    return this.request("POST", `/v1/receipts`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async getRunReceipt(runId, init) {
+    return this.request("GET", `/v1/receipts/${encodeURIComponent(String(runId))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async listRuns(query, init) {
+    return this.request("GET", `/v1/runs`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async getRun(id, init) {
+    return this.request("GET", `/v1/runs/${encodeURIComponent(String(id))}`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async getVersion(init) {
+    return this.request("GET", `/version`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+}
+export {
+  LoopsClient,
+  ApiError
+};

package/dist/sdk/index.d.ts

@@ -1,13 +1,22 @@
-import type { CreateLoopInput, Goal, GoalRun, Loop, LoopRun, LoopStatus, OpenAutomationsRuntimeBinding, RunStatus } from "../types.js";
+import type { CreateLoopInput, Goal, GoalRun, Loop, LoopRun, LoopStatus, OpenAutomationsRuntimeBinding, RunReceipt, RunStatus, WriteRunReceiptInput } from "../types.js";
 import { type DoctorReport } from "../lib/doctor.js";
-import { type LoopsHealthReport } from "../lib/health.js";
+import { type BuildHealthScanOptions, type LoopsHealthReport, type LoopsHealthScan } from "../lib/health.js";
 import { type ApplyLoopsMigrationResult, type ExportLoopsMigrationOptions, type ImportLoopsMigrationOptions, type LoopsMigrationBundle, type LoopsMigrationPlan, type SelfHostedPlanOptions } from "../lib/migration.js";
 import { tick } from "../lib/scheduler.js";
 import { Store } from "../lib/store.js";
+import { type LoopStore } from "../lib/store/index.js";
 export { runGoal } from "../lib/goal/runner.js";
 export { LOOPS_MIGRATION_SCHEMA, applyImportMigrationBundle, buildImportMigrationPlan, buildSelfHostedMigrationPlan, exportLoopsMigrationBundle, migrationHash, registerSelfHostedRunner, validateLoopsMigrationBundle, } from "../lib/migration.js";
 export type { ApplyLoopsMigrationResult, ExportLoopsMigrationOptions, ImportLoopsMigrationOptions, LoopsMigrationAction, LoopsMigrationBundle, LoopsMigrationPlan, LoopsMigrationPlanRow, LoopsMigrationPlanSummary, LoopsMigrationResource, RunnerRegistrationOptions, RunnerRegistrationResult, SelfHostedPlanOptions, } from "../lib/migration.js";
 export interface LoopsClientOptions {
+    /**
+     * Inject an on-box sqlite {@link Store} (mainly for tests and in-process local
+     * runtimes). When provided, both data and local-runtime operations run against
+     * it. When omitted, the data store is resolved from the client-flip env via
+     * {@link getStore} — the local sqlite store OR the hosted `/v1` API when
+     * HASNA_LOOPS_API_URL/HASNA_LOOPS_API_KEY (or HASNA_LOOPS_STORAGE_MODE) select
+     * it — so every data method routes through the one Store abstraction.
+     */
     store?: Store;
     /**
      * Claim owner id for inline runs. Keep the `<surface>:<pid>` shape (see
@@ -29,31 +38,59 @@ export interface ListRunsFilters {
     status?: RunStatus;
     limit?: number;
 }
+export interface ListRunReceiptsFilters {
+    loopId?: string;
+    repo?: string;
+    taskId?: string;
+    knowledgeId?: string;
+    status?: string;
+    limit?: number;
+}
 export declare class LoopsClient {
-    readonly store: Store;
+    /**
+     * The resolved data store: an on-box {@link LocalStore} (sqlite) or the hosted
+     * {@link ApiStore} (`/v1` + bearer key). EVERY data method routes through here,
+     * so nothing silently touches the on-box island while flipped to the cloud API.
+     */
+    readonly store: LoopStore;
     private readonly ownStore;
     private readonly runnerId;
     constructor(opts?: LoopsClientOptions);
-    create(input: CreateLoopInput): Loop;
-    list(filters?: ListLoopsFilters): Loop[];
-    get(idOrName: string): Loop;
-    pause(idOrName: string): Loop;
-    resume(idOrName: string): Loop;
-    stop(idOrName: string): Loop;
-    archive(idOrName: string): Loop;
-    unarchive(idOrName: string): Loop;
-    delete(idOrName: string): boolean;
-    runs(idOrName?: string, filters?: ListRunsFilters): LoopRun[];
+    /**
+     * The raw on-box sqlite {@link Store} for local-runtime operations that cannot
+     * route over HTTP — the scheduler (tick / inline run-now), migration
+     * export/import, and local diagnostics (doctor/health). These act on THIS
+     * machine's runtime and database, so they fail loudly instead of silently
+     * hitting the on-box island when the client is flipped to the hosted API.
+     */
+    private localRuntime;
+    create(input: CreateLoopInput): Promise<Loop>;
+    list(filters?: ListLoopsFilters): Promise<Loop[]>;
+    get(idOrName: string): Promise<Loop>;
+    pause(idOrName: string): Promise<Loop>;
+    resume(idOrName: string): Promise<Loop>;
+    stop(idOrName: string): Promise<Loop>;
+    archive(idOrName: string): Promise<Loop>;
+    unarchive(idOrName: string): Promise<Loop>;
+    delete(idOrName: string): Promise<boolean>;
+    runs(idOrName?: string, filters?: ListRunsFilters): Promise<LoopRun[]>;
+    writeReceipt(input: WriteRunReceiptInput): Promise<RunReceipt>;
+    receipt(runId: string): Promise<RunReceipt | undefined>;
+    receipts(filters?: ListRunReceiptsFilters): Promise<RunReceipt[]>;
+    goal(idOrName: string): Promise<{
+        goal?: Goal;
+        runs: GoalRun[];
+    }>;
     doctor(): DoctorReport;
     health(opts?: {
         includeArchived?: boolean;
         includeInactive?: boolean;
         limit?: number;
     }): LoopsHealthReport;
-    goal(idOrName: string): {
-        goal?: Goal;
-        runs: GoalRun[];
-    };
+    healthScan(opts?: Omit<BuildHealthScanOptions, "doctor" | "daemon" | "selfHeals"> & {
+        doctor?: boolean;
+        daemon?: boolean;
+    }): LoopsHealthScan;
     tick(): Promise<Awaited<ReturnType<typeof tick>>>;
     runNow(idOrName: string): Promise<LoopRun>;
     exportBundle(opts?: ExportLoopsMigrationOptions): LoopsMigrationBundle;
@@ -62,7 +99,7 @@ export declare class LoopsClient {
     planSelfHostedMigration(opts?: Omit<SelfHostedPlanOptions, "operation"> & {
         operation?: SelfHostedPlanOptions["operation"];
     }): Promise<LoopsMigrationPlan>;
-    close(): void;
+    close(): Promise<void>;
 }
 export declare function loops(opts?: LoopsClientOptions): LoopsClient;
 export declare function openAutomationsRuntimeBinding(overrides?: Partial<OpenAutomationsRuntimeBinding>): OpenAutomationsRuntimeBinding;