@refrainai/cli 0.4.1

package/dist/chunk-WEYR56ZN.js

@@ -0,0 +1,953 @@
+#!/usr/bin/env node
+import {
+  buildFlatRunbook,
+  copyVersionData,
+  insertSteps,
+  isDeletable,
+  isEditable,
+  loadVersionDetail,
+  resolveDisplayStatus
+} from "./chunk-Z33FCOTZ.js";
+import {
+  jobs,
+  runbookSecrets,
+  runbookSettings,
+  runbookSteps,
+  runbookVariables,
+  runbookVersionReviews,
+  runbookVersions,
+  runbooks
+} from "./chunk-CLYJHKPY.js";
+
+// src/server/store/runbook-store.ts
+import { eq as eq2, and as and2, desc as desc2, sql as sql2, count as count2 } from "drizzle-orm";
+
+// src/server/store/runbook-version-store.ts
+import { eq, and, desc, max, inArray, isNull, count } from "drizzle-orm";
+import { sql } from "drizzle-orm";
+var VersionStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  // ── 作成 ──
+  /**
+   * 初期バージョン（v1）を作成する。
+   * steps ありなら pending_verification、なしなら draft。
+   */
+  async createInitialVersion(tx, runbookId, data) {
+    const hasSteps = data.steps && data.steps.length > 0;
+    const status = hasSteps ? "pending_verification" : "draft";
+    const [verRow] = await tx.insert(runbookVersions).values({
+      runbookId,
+      versionNumber: 1,
+      status,
+      goal: data.goal,
+      startUrl: data.startUrl ?? null,
+      context: data.context ?? null,
+      generatedAt: data.generatedAt ?? null,
+      createdBy: data.createdBy ?? null,
+      changeDescription: data.changeDescription ?? null
+    }).returning();
+    if (data.settings) {
+      await tx.insert(runbookSettings).values({
+        versionId: verRow.id,
+        ...data.settings
+      });
+    }
+    if (data.variables) {
+      const vars = Object.entries(data.variables).map(([name, def]) => ({
+        versionId: verRow.id,
+        name,
+        source: def.source,
+        description: def.description ?? null,
+        required: def.required,
+        sensitive: def.sensitive,
+        value: def.value ?? null
+      }));
+      if (vars.length > 0) {
+        await tx.insert(runbookVariables).values(vars);
+      }
+    }
+    if (data.secrets) {
+      const secretRows = Object.entries(data.secrets).map(([key, val]) => ({
+        versionId: verRow.id,
+        key,
+        encryptedValue: val
+      }));
+      if (secretRows.length > 0) {
+        await tx.insert(runbookSecrets).values(secretRows);
+      }
+    }
+    if (data.steps && data.steps.length > 0) {
+      await insertSteps(tx, verRow.id, data.steps, null);
+    }
+    return verRow;
+  }
+  /**
+   * active バージョンからコピーして新 draft 作成。
+   * 同時に draft/pending_verification は 1 つまで。
+   */
+  async createVersionFromActive(tenantId, runbookId, createdBy, changeDescription) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and(eq(runbooks.id, runbookId), eq(runbooks.tenantId, tenantId))
+    });
+    if (!rb) return null;
+    const existingInProgress = await this.db.query.runbookVersions.findFirst({
+      where: and(
+        eq(runbookVersions.runbookId, runbookId),
+        inArray(runbookVersions.status, ["draft", "pending_verification"])
+      )
+    });
+    if (existingInProgress) {
+      return { error: "DRAFT_EXISTS", draftVersionId: existingInProgress.id };
+    }
+    return await this.db.transaction(async (tx) => {
+      const [maxResult] = await tx.select({ maxVer: max(runbookVersions.versionNumber) }).from(runbookVersions).where(eq(runbookVersions.runbookId, runbookId));
+      const nextVersion = (maxResult?.maxVer ?? 0) + 1;
+      let sourceVersionId = rb.activeVersionId;
+      if (!sourceVersionId) {
+        const latestVersion = await tx.query.runbookVersions.findFirst({
+          where: eq(runbookVersions.runbookId, runbookId),
+          orderBy: [desc(runbookVersions.versionNumber)]
+        });
+        if (latestVersion) {
+          sourceVersionId = latestVersion.id;
+        }
+      }
+      let sourceVersion = null;
+      if (sourceVersionId) {
+        const [sv] = await tx.select().from(runbookVersions).where(eq(runbookVersions.id, sourceVersionId));
+        sourceVersion = sv ?? null;
+      }
+      const [newVer] = await tx.insert(runbookVersions).values({
+        runbookId,
+        versionNumber: nextVersion,
+        status: "draft",
+        goal: sourceVersion?.goal ?? "",
+        startUrl: sourceVersion?.startUrl ?? null,
+        context: sourceVersion?.context ?? null,
+        generatedAt: sourceVersion?.generatedAt ?? null,
+        createdBy: createdBy ?? null,
+        changeDescription: changeDescription ?? null
+      }).returning();
+      if (sourceVersionId) {
+        await copyVersionData(tx, sourceVersionId, newVer.id, { skipSteps: true });
+      }
+      return { version: newVer };
+    });
+  }
+  // ── 更新 ──
+  /**
+   * バージョン更新（isEditable ガードつき）
+   */
+  async updateVersion(tenantId, runbookId, versionId, data) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and(eq(runbooks.id, runbookId), eq(runbooks.tenantId, tenantId))
+    });
+    if (!rb) return null;
+    const [ver] = await this.db.select().from(runbookVersions).where(and(
+      eq(runbookVersions.id, versionId),
+      eq(runbookVersions.runbookId, runbookId)
+    ));
+    if (!ver) return null;
+    if (!isEditable(ver.status)) return null;
+    return await this.db.transaction(async (tx) => {
+      const updates = {};
+      if (data.goal !== void 0) updates.goal = data.goal;
+      if (data.startUrl !== void 0) updates.startUrl = data.startUrl;
+      if (data.context !== void 0) updates.context = data.context;
+      if (data.changeDescription !== void 0) updates.changeDescription = data.changeDescription;
+      if (ver.status === "pending_verification" && ver.verificationJobId && !data.skipVerificationJobClear) {
+        updates.verificationJobId = null;
+      }
+      if (Object.keys(updates).length > 0) {
+        await tx.update(runbookVersions).set(updates).where(eq(runbookVersions.id, versionId));
+      }
+      if (data.settings !== void 0) {
+        await tx.delete(runbookSettings).where(eq(runbookSettings.versionId, versionId));
+        if (data.settings) {
+          await tx.insert(runbookSettings).values({ versionId, ...data.settings });
+        }
+      }
+      if (data.secrets !== void 0) {
+        await tx.delete(runbookSecrets).where(eq(runbookSecrets.versionId, versionId));
+        const secretRows = Object.entries(data.secrets).map(([key, val]) => ({
+          versionId,
+          key,
+          encryptedValue: val
+        }));
+        if (secretRows.length > 0) {
+          await tx.insert(runbookSecrets).values(secretRows);
+        }
+      }
+      if (data.variables !== void 0) {
+        await tx.delete(runbookVariables).where(eq(runbookVariables.versionId, versionId));
+        const vars = Object.entries(data.variables).map(([name, def]) => ({
+          versionId,
+          name,
+          source: def.source,
+          description: def.description ?? null,
+          required: def.required,
+          sensitive: def.sensitive,
+          value: def.value ?? null
+        }));
+        if (vars.length > 0) {
+          await tx.insert(runbookVariables).values(vars);
+        }
+      }
+      if (data.steps !== void 0) {
+        await tx.delete(runbookSteps).where(eq(runbookSteps.versionId, versionId));
+        await insertSteps(tx, versionId, data.steps, null);
+      }
+      if (data.title !== void 0) {
+        await tx.update(runbooks).set({ title: data.title }).where(eq(runbooks.id, runbookId));
+      }
+      return await this.findById(tenantId, runbookId, versionId);
+    });
+  }
+  // ── 状態遷移 ──
+  /**
+   * draft → pending_verification
+   */
+  async completeVersion(tenantId, runbookId, versionId, data) {
+    if (data) {
+      await this.updateVersion(tenantId, runbookId, versionId, data);
+    }
+    const [ver] = await this.db.select().from(runbookVersions).where(and(
+      eq(runbookVersions.id, versionId),
+      eq(runbookVersions.runbookId, runbookId)
+    ));
+    if (!ver || ver.status !== "draft") return null;
+    await this.db.update(runbookVersions).set({ status: "pending_verification" }).where(eq(runbookVersions.id, versionId));
+    return await this.findById(tenantId, runbookId, versionId);
+  }
+  /**
+   * pending_verification|pending_approval → active（旧 active を archived）
+   */
+  async publishVersion(tenantId, runbookId, versionId, publishedBy, maxVersions) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and(eq(runbooks.id, runbookId), eq(runbooks.tenantId, tenantId))
+    });
+    if (!rb) return null;
+    const [ver] = await this.db.select().from(runbookVersions).where(and(
+      eq(runbookVersions.id, versionId),
+      eq(runbookVersions.runbookId, runbookId)
+    ));
+    if (!ver) return null;
+    if (ver.status !== "pending_verification" && ver.status !== "pending_approval") {
+      return null;
+    }
+    return await this.db.transaction(async (tx) => {
+      if (rb.activeVersionId) {
+        if (maxVersions <= 1) {
+          await tx.delete(runbookVersions).where(eq(runbookVersions.id, rb.activeVersionId));
+        } else {
+          await tx.update(runbookVersions).set({ status: "archived" }).where(eq(runbookVersions.id, rb.activeVersionId));
+        }
+      }
+      await tx.update(runbookVersions).set({
+        status: "active",
+        publishedAt: /* @__PURE__ */ new Date(),
+        publishedBy: publishedBy ?? null
+      }).where(eq(runbookVersions.id, versionId));
+      await tx.update(runbooks).set({ activeVersionId: versionId }).where(eq(runbooks.id, runbookId));
+      if (maxVersions > 1) {
+        const archivedVersions = await tx.select({ id: runbookVersions.id }).from(runbookVersions).where(and(
+          eq(runbookVersions.runbookId, runbookId),
+          eq(runbookVersions.status, "archived")
+        )).orderBy(desc(runbookVersions.versionNumber));
+        const maxArchived = maxVersions - 1;
+        if (archivedVersions.length > maxArchived) {
+          const toDelete = archivedVersions.slice(maxArchived);
+          for (const v of toDelete) {
+            await tx.delete(runbookVersions).where(eq(runbookVersions.id, v.id));
+          }
+        }
+      }
+      return { status: "active" };
+    });
+  }
+  /**
+   * archived → active（現 active を archived）
+   */
+  async rollbackVersion(tenantId, runbookId, versionId, publishedBy, _maxVersions) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and(eq(runbooks.id, runbookId), eq(runbooks.tenantId, tenantId))
+    });
+    if (!rb) return null;
+    const [ver] = await this.db.select().from(runbookVersions).where(and(
+      eq(runbookVersions.id, versionId),
+      eq(runbookVersions.runbookId, runbookId)
+    ));
+    if (!ver || ver.status !== "archived") return null;
+    return await this.db.transaction(async (tx) => {
+      if (rb.activeVersionId) {
+        await tx.update(runbookVersions).set({ status: "archived" }).where(eq(runbookVersions.id, rb.activeVersionId));
+      }
+      await tx.update(runbookVersions).set({
+        status: "active",
+        publishedAt: /* @__PURE__ */ new Date(),
+        publishedBy: publishedBy ?? null
+      }).where(eq(runbookVersions.id, versionId));
+      await tx.update(runbooks).set({ activeVersionId: versionId }).where(eq(runbooks.id, runbookId));
+      return { status: "active" };
+    });
+  }
+  // ── 検証ジョブ ──
+  async setVerificationJob(versionId, jobId) {
+    const result = await this.db.update(runbookVersions).set({ verificationJobId: jobId }).where(eq(runbookVersions.id, versionId)).returning({ id: runbookVersions.id });
+    return result.length > 0;
+  }
+  async clearVerificationJob(versionId) {
+    const result = await this.db.update(runbookVersions).set({ verificationJobId: null }).where(eq(runbookVersions.id, versionId)).returning({ id: runbookVersions.id });
+    return result.length > 0;
+  }
+  /**
+   * バージョンのステータスを直接更新（internal use）
+   */
+  async updateStatus(versionId, status) {
+    const result = await this.db.update(runbookVersions).set({ status }).where(eq(runbookVersions.id, versionId)).returning({ id: runbookVersions.id });
+    return result.length > 0;
+  }
+  // ── レビュー ──
+  async requestReview(versionId, requestedBy) {
+    const [row] = await this.db.insert(runbookVersionReviews).values({
+      versionId,
+      requestedBy
+    }).returning();
+    return row;
+  }
+  async submitReview(reviewId, reviewerId, status, comment) {
+    const result = await this.db.update(runbookVersionReviews).set({
+      reviewerId,
+      reviewedAt: /* @__PURE__ */ new Date(),
+      status,
+      comment: comment ?? null
+    }).where(eq(runbookVersionReviews.id, reviewId)).returning();
+    return result.length > 0;
+  }
+  async getReviews(versionId) {
+    return await this.db.query.runbookVersionReviews.findMany({
+      where: eq(runbookVersionReviews.versionId, versionId)
+    });
+  }
+  // ── クエリ ──
+  /**
+   * バージョン詳細取得
+   */
+  async findById(tenantId, runbookId, versionId) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and(eq(runbooks.id, runbookId), eq(runbooks.tenantId, tenantId)),
+      columns: { id: true, activeVersionId: true }
+    });
+    if (!rb) return null;
+    const [ver] = await this.db.select().from(runbookVersions).where(and(
+      eq(runbookVersions.id, versionId),
+      eq(runbookVersions.runbookId, runbookId)
+    ));
+    if (!ver) return null;
+    const detail = await loadVersionDetail(this.db, versionId);
+    let verificationJobStatus = null;
+    if (ver.verificationJobId) {
+      const [job] = await this.db.select({ status: jobs.status }).from(jobs).where(eq(jobs.id, ver.verificationJobId));
+      verificationJobStatus = job?.status ?? null;
+    }
+    return {
+      ...ver,
+      isActive: rb.activeVersionId === versionId,
+      stepsCount: detail.steps.filter((s) => !s.parentStepId).length,
+      verificationJobStatus,
+      displayStatus: resolveDisplayStatus(ver.status, ver.verificationJobId, verificationJobStatus),
+      ...detail
+    };
+  }
+  /**
+   * バージョン一覧
+   */
+  async list(tenantId, runbookId) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and(eq(runbooks.id, runbookId), eq(runbooks.tenantId, tenantId)),
+      columns: { id: true, activeVersionId: true }
+    });
+    if (!rb) return null;
+    const versions = await this.db.select({
+      id: runbookVersions.id,
+      versionNumber: runbookVersions.versionNumber,
+      status: runbookVersions.status,
+      goal: runbookVersions.goal,
+      startUrl: runbookVersions.startUrl,
+      generatedAt: runbookVersions.generatedAt,
+      verificationJobId: runbookVersions.verificationJobId,
+      verificationJobStatus: sql`(
+          SELECT j.status FROM jobs j
+          WHERE j.id = ${runbookVersions.verificationJobId}
+        )`.as("verificationJobStatus"),
+      createdBy: runbookVersions.createdBy,
+      createdAt: runbookVersions.createdAt,
+      publishedAt: runbookVersions.publishedAt,
+      changeDescription: runbookVersions.changeDescription
+    }).from(runbookVersions).where(eq(runbookVersions.runbookId, runbookId)).orderBy(desc(runbookVersions.versionNumber));
+    if (versions.length === 0) return [];
+    const stepCounts = await this.db.select({
+      versionId: runbookSteps.versionId,
+      count: count()
+    }).from(runbookSteps).where(
+      and(
+        inArray(runbookSteps.versionId, versions.map((v) => v.id)),
+        isNull(runbookSteps.parentStepId)
+      )
+    ).groupBy(runbookSteps.versionId);
+    const countMap = new Map(stepCounts.map((sc) => [sc.versionId, sc.count]));
+    return versions.map((v) => ({
+      ...v,
+      stepsCount: countMap.get(v.id) ?? 0,
+      isActive: rb.activeVersionId === v.id,
+      displayStatus: resolveDisplayStatus(v.status, v.verificationJobId, v.verificationJobStatus)
+    }));
+  }
+  /**
+   * バージョン削除（isDeletable ガードつき）
+   */
+  async deleteVersion(tenantId, runbookId, versionId) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and(eq(runbooks.id, runbookId), eq(runbooks.tenantId, tenantId))
+    });
+    if (!rb) return false;
+    const [ver] = await this.db.select().from(runbookVersions).where(and(
+      eq(runbookVersions.id, versionId),
+      eq(runbookVersions.runbookId, runbookId)
+    ));
+    if (!ver || !isDeletable(ver.status)) return false;
+    await this.db.delete(runbookVersions).where(eq(runbookVersions.id, versionId));
+    return true;
+  }
+  /**
+   * ステップの部分更新
+   */
+  async patchSteps(tenantId, runbookId, versionId, patches) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and(eq(runbooks.id, runbookId), eq(runbooks.tenantId, tenantId))
+    });
+    if (!rb) return false;
+    await this.db.transaction(async (tx) => {
+      for (const patch of patches) {
+        const updates = {};
+        if (patch.description !== void 0) updates.description = patch.description;
+        if (patch.riskLevel !== void 0) updates.riskLevel = patch.riskLevel;
+        if (patch.requiresConfirmation !== void 0) updates.requiresConfirmation = patch.requiresConfirmation;
+        if (Object.keys(updates).length > 0) {
+          await tx.update(runbookSteps).set(updates).where(and(eq(runbookSteps.id, patch.id), eq(runbookSteps.versionId, versionId)));
+        }
+      }
+    });
+    return true;
+  }
+};
+
+// src/server/store/runbook-store.ts
+var RunbookStore = class {
+  constructor(db) {
+    this.db = db;
+    this.versions = new VersionStore(db);
+  }
+  // ── 作成 ──
+  /**
+   * Runbook + 初期バージョン（v1）を作成する。
+   * ParsedRunbook を含むフル作成。ステータスは pending_verification。
+   */
+  async insert(data) {
+    const { tenantId, createdBy, runbook, secrets, context, settings } = data;
+    return await this.db.transaction(async (tx) => {
+      const [rbRow] = await tx.insert(runbooks).values({
+        tenantId,
+        title: runbook.title,
+        createdBy: createdBy ?? null
+      }).returning();
+      const verRow = await this.versions.createInitialVersion(tx, rbRow.id, {
+        goal: runbook.metadata.goal,
+        startUrl: runbook.metadata.startUrl,
+        context: context ?? null,
+        generatedAt: runbook.metadata.generatedAt,
+        createdBy: createdBy ?? null,
+        settings,
+        secrets,
+        variables: runbook.variables,
+        steps: runbook.steps
+      });
+      await tx.update(runbooks).set({ activeVersionId: verRow.id }).where(eq2(runbooks.id, rbRow.id));
+      return { ...rbRow, activeVersionId: verRow.id };
+    });
+  }
+  /**
+   * Draft の Runbook + 初期 draft バージョンを作成する。
+   */
+  async insertDraft(data) {
+    return await this.db.transaction(async (tx) => {
+      const [rbRow] = await tx.insert(runbooks).values({
+        tenantId: data.tenantId,
+        title: data.title,
+        createdBy: data.createdBy ?? null
+      }).returning();
+      const verRow = await this.versions.createInitialVersion(tx, rbRow.id, {
+        goal: data.goal ?? "",
+        startUrl: data.startUrl ?? null,
+        context: data.context ?? null,
+        createdBy: data.createdBy ?? null,
+        secrets: data.secrets,
+        variables: data.variables
+      });
+      return { ...rbRow, versionId: verRow.id };
+    });
+  }
+  // ── クエリ ──
+  /**
+   * Runbook 詳細取得（active バージョンの情報を含む）
+   * 旧 API との互換性を維持するためにフラット構造で返す。
+   */
+  async findById(tenantId, id) {
+    const row = await this.db.query.runbooks.findFirst({
+      where: and2(eq2(runbooks.id, id), eq2(runbooks.tenantId, tenantId))
+    });
+    if (!row) return null;
+    const versionId = row.activeVersionId;
+    if (!versionId) {
+      const latestDraft = await this.db.query.runbookVersions.findFirst({
+        where: eq2(runbookVersions.runbookId, id),
+        orderBy: [desc2(runbookVersions.versionNumber)]
+      });
+      if (!latestDraft) {
+        const status = row.disabled ? "disabled" : "draft";
+        return {
+          ...row,
+          goal: "",
+          startUrl: null,
+          context: null,
+          generatedAt: null,
+          status,
+          verificationJobId: null,
+          verificationJobStatus: null,
+          displayStatus: resolveDisplayStatus(status, null, null),
+          settings: null,
+          variables: [],
+          secrets: [],
+          steps: [],
+          activeVersionId: null,
+          currentVersionId: null
+        };
+      }
+      return await buildFlatRunbook(this.db, row, latestDraft);
+    }
+    const [ver] = await this.db.select().from(runbookVersions).where(eq2(runbookVersions.id, versionId));
+    if (!ver) return null;
+    return await buildFlatRunbook(this.db, row, ver);
+  }
+  /**
+   * Runbook 一覧
+   */
+  async list(tenantId, opts = {}) {
+    const { limit = 50, offset = 0, status, includeDisabled = false } = opts;
+    const conditions = [eq2(runbooks.tenantId, tenantId)];
+    if (status === "disabled") {
+      conditions.push(eq2(runbooks.disabled, true));
+    } else if (status) {
+      conditions.push(eq2(runbooks.disabled, false));
+    } else if (!includeDisabled) {
+      conditions.push(eq2(runbooks.disabled, false));
+    }
+    const where = and2(...conditions);
+    const rows = await this.db.select({
+      id: runbooks.id,
+      title: runbooks.title,
+      disabled: runbooks.disabled,
+      activeVersionId: runbooks.activeVersionId,
+      createdAt: runbooks.createdAt,
+      updatedAt: runbooks.updatedAt,
+      goal: sql2`COALESCE((
+          SELECT rv.goal FROM runbook_versions rv
+          WHERE rv.id = ${runbooks.activeVersionId}
+        ), (
+          SELECT rv.goal FROM runbook_versions rv
+          WHERE rv.runbook_id = ${runbooks.id}
+          ORDER BY rv.version_number DESC LIMIT 1
+        ), '')`.as("goal"),
+      startUrl: sql2`COALESCE((
+          SELECT rv.start_url FROM runbook_versions rv
+          WHERE rv.id = ${runbooks.activeVersionId}
+        ), (
+          SELECT rv.start_url FROM runbook_versions rv
+          WHERE rv.runbook_id = ${runbooks.id}
+          ORDER BY rv.version_number DESC LIMIT 1
+        ))`.as("startUrl"),
+      generatedAt: sql2`COALESCE((
+          SELECT rv.generated_at FROM runbook_versions rv
+          WHERE rv.id = ${runbooks.activeVersionId}
+        ), (
+          SELECT rv.generated_at FROM runbook_versions rv
+          WHERE rv.runbook_id = ${runbooks.id}
+          ORDER BY rv.version_number DESC LIMIT 1
+        ))`.as("generatedAt"),
+      versionStatus: sql2`COALESCE((
+          SELECT rv.status FROM runbook_versions rv
+          WHERE rv.id = ${runbooks.activeVersionId}
+        ), (
+          SELECT rv.status FROM runbook_versions rv
+          WHERE rv.runbook_id = ${runbooks.id}
+          ORDER BY rv.version_number DESC LIMIT 1
+        ))`.as("versionStatus"),
+      verificationJobId: sql2`COALESCE((
+          SELECT rv.verification_job_id FROM runbook_versions rv
+          WHERE rv.id = ${runbooks.activeVersionId}
+        ), (
+          SELECT rv.verification_job_id FROM runbook_versions rv
+          WHERE rv.runbook_id = ${runbooks.id}
+          ORDER BY rv.version_number DESC LIMIT 1
+        ))`.as("verificationJobId"),
+      stepsCount: sql2`COALESCE((
+          SELECT count(*)::int FROM runbook_steps rs
+          JOIN runbook_versions rv ON rv.id = rs.version_id
+          WHERE rv.id = COALESCE(${runbooks.activeVersionId}, (
+            SELECT rv2.id FROM runbook_versions rv2
+            WHERE rv2.runbook_id = ${runbooks.id}
+            ORDER BY rv2.version_number DESC LIMIT 1
+          ))
+            AND rs.parent_step_id IS NULL
+        ), 0)`.as("stepsCount"),
+      lastJobStatus: sql2`(
+          SELECT ${jobs.status} FROM ${jobs}
+          WHERE ${jobs.runbookId} = ${runbooks.id}
+            AND ${jobs.mode} IN ('execute', 'self_heal')
+          ORDER BY ${jobs.createdAt} DESC
+          LIMIT 1
+        )`.as("lastJobStatus"),
+      lastJobCompletedAt: sql2`(
+          SELECT ${jobs.completedAt} FROM ${jobs}
+          WHERE ${jobs.runbookId} = ${runbooks.id}
+            AND ${jobs.mode} IN ('execute', 'self_heal')
+          ORDER BY ${jobs.createdAt} DESC
+          LIMIT 1
+        )`.as("lastJobCompletedAt"),
+      verificationJobStatus: sql2`(
+          SELECT j.status FROM jobs j
+          WHERE j.id = COALESCE((
+            SELECT rv.verification_job_id FROM runbook_versions rv
+            WHERE rv.id = ${runbooks.activeVersionId}
+          ), (
+            SELECT rv.verification_job_id FROM runbook_versions rv
+            WHERE rv.runbook_id = ${runbooks.id}
+            ORDER BY rv.version_number DESC LIMIT 1
+          ))
+        )`.as("verificationJobStatus"),
+      versionCount: sql2`(
+          SELECT count(*)::int FROM runbook_versions rv
+          WHERE rv.runbook_id = ${runbooks.id}
+        )`.as("versionCount"),
+      hasDraft: sql2`EXISTS(
+          SELECT 1 FROM runbook_versions rv
+          WHERE rv.runbook_id = ${runbooks.id} AND rv.status = 'draft'
+        )`.as("hasDraft")
+    }).from(runbooks).where(where).orderBy(desc2(runbooks.createdAt)).limit(limit).offset(offset);
+    let filteredRows = rows;
+    if (status && status !== "disabled") {
+      const mappedStatus = status === "active" ? "active" : status === "pending_verification" ? "pending_verification" : status;
+      filteredRows = rows.filter((r) => r.versionStatus === mappedStatus);
+    }
+    const items = filteredRows.map((r) => {
+      const itemStatus = r.disabled ? "disabled" : r.versionStatus ?? "draft";
+      return {
+        id: r.id,
+        title: r.title,
+        goal: r.goal ?? "",
+        startUrl: r.startUrl,
+        generatedAt: r.generatedAt ?? "",
+        status: itemStatus,
+        verificationJobId: r.verificationJobId,
+        verificationJobStatus: r.verificationJobStatus,
+        displayStatus: resolveDisplayStatus(itemStatus, r.verificationJobId, r.verificationJobStatus),
+        createdAt: r.createdAt,
+        updatedAt: r.updatedAt,
+        stepsCount: r.stepsCount,
+        lastJobStatus: r.lastJobStatus,
+        lastJobCompletedAt: r.lastJobCompletedAt,
+        versionCount: r.versionCount,
+        hasDraft: r.hasDraft,
+        activeVersionId: r.activeVersionId
+      };
+    });
+    const [totalResult] = await this.db.select({ count: count2() }).from(runbooks).where(where);
+    return { items, total: totalResult.count };
+  }
+  // ── 更新 ──
+  /**
+   * Runbook の active バージョンを更新する（旧 API 互換）。
+   */
+  async update(tenantId, id, data) {
+    const existing = await this.findById(tenantId, id);
+    if (!existing) return null;
+    const versionId = existing.currentVersionId;
+    if (!versionId) return null;
+    return await this.db.transaction(async (tx) => {
+      if (data.runbook) {
+        const rb = data.runbook;
+        const versionStatus = existing.status;
+        const statusReset = versionStatus === "active" && !data.skipStatusReset ? { status: "pending_verification", verificationJobId: null } : versionStatus === "draft" ? { status: "pending_verification" } : {};
+        await tx.update(runbookVersions).set({
+          goal: rb.metadata.goal,
+          startUrl: rb.metadata.startUrl,
+          context: data.context ?? existing.context,
+          generatedAt: rb.metadata.generatedAt,
+          ...statusReset
+        }).where(eq2(runbookVersions.id, versionId));
+        await tx.update(runbooks).set({ title: rb.title }).where(eq2(runbooks.id, id));
+        const nextVariables = data.variables ?? rb.variables;
+        if (nextVariables !== void 0) {
+          await tx.delete(runbookVariables).where(eq2(runbookVariables.versionId, versionId));
+          const vars = Object.entries(nextVariables).map(([name, def]) => ({
+            versionId,
+            name,
+            source: def.source,
+            description: def.description ?? null,
+            required: def.required,
+            sensitive: def.sensitive,
+            value: def.value ?? null
+          }));
+          if (vars.length > 0) {
+            await tx.insert(runbookVariables).values(vars);
+          }
+        }
+        await tx.delete(runbookSteps).where(eq2(runbookSteps.versionId, versionId));
+        await insertSteps(tx, versionId, rb.steps, null);
+      } else if (data.context !== void 0) {
+        await tx.update(runbookVersions).set({ context: data.context }).where(eq2(runbookVersions.id, versionId));
+      }
+      if (!data.runbook && data.variables !== void 0) {
+        await tx.delete(runbookVariables).where(eq2(runbookVariables.versionId, versionId));
+        const vars = Object.entries(data.variables).map(([name, def]) => ({
+          versionId,
+          name,
+          source: def.source,
+          description: def.description ?? null,
+          required: def.required,
+          sensitive: def.sensitive,
+          value: def.value ?? null
+        }));
+        if (vars.length > 0) {
+          await tx.insert(runbookVariables).values(vars);
+        }
+      }
+      if (data.settings !== void 0) {
+        await tx.delete(runbookSettings).where(eq2(runbookSettings.versionId, versionId));
+        if (data.settings) {
+          await tx.insert(runbookSettings).values({ versionId, ...data.settings });
+        }
+      }
+      if (data.secrets !== void 0) {
+        await tx.delete(runbookSecrets).where(eq2(runbookSecrets.versionId, versionId));
+        const secretRows = Object.entries(data.secrets).map(([key, val]) => ({
+          versionId,
+          key,
+          encryptedValue: val
+        }));
+        if (secretRows.length > 0) {
+          await tx.insert(runbookSecrets).values(secretRows);
+        }
+      }
+      return await this.findById(tenantId, id);
+    });
+  }
+  /**
+   * updateDraft: draft/pending_verification ステータスのバージョンを更新
+   */
+  async updateDraft(tenantId, id, data) {
+    const existing = await this.findById(tenantId, id);
+    if (!existing) return null;
+    const versionId = existing.currentVersionId;
+    if (!versionId) return null;
+    if (!isEditable(existing.versionStatus)) return null;
+    const result = await this.versions.updateVersion(tenantId, id, versionId, {
+      ...data
+    });
+    if (!result) return null;
+    return await this.findById(tenantId, id);
+  }
+  /**
+   * completeDraft: draft → pending_verification
+   */
+  async completeDraft(tenantId, id, data) {
+    const existing = await this.findById(tenantId, id);
+    if (!existing) return null;
+    const versionId = existing.currentVersionId;
+    if (!versionId) return null;
+    const result = await this.versions.completeVersion(tenantId, id, versionId, data);
+    if (!result) return null;
+    return await this.findById(tenantId, id);
+  }
+  /**
+   * updateStatus: 旧 API 互換。disabled フラグとバージョンステータスを操作。
+   */
+  async updateStatus(tenantId, id, status) {
+    if (status === "disabled") {
+      const result = await this.db.update(runbooks).set({ disabled: true }).where(and2(eq2(runbooks.id, id), eq2(runbooks.tenantId, tenantId))).returning({ id: runbooks.id });
+      return result.length > 0;
+    }
+    if (status === "active") {
+      const rb2 = await this.db.query.runbooks.findFirst({
+        where: and2(eq2(runbooks.id, id), eq2(runbooks.tenantId, tenantId))
+      });
+      if (!rb2) return false;
+      if (rb2.disabled) {
+        await this.db.update(runbooks).set({ disabled: false }).where(eq2(runbooks.id, id));
+        return true;
+      }
+      if (rb2.activeVersionId) {
+        const [ver] = await this.db.select().from(runbookVersions).where(eq2(runbookVersions.id, rb2.activeVersionId));
+        if (ver && ver.status === "pending_verification") {
+          await this.db.update(runbookVersions).set({ status: "active", publishedAt: /* @__PURE__ */ new Date() }).where(eq2(runbookVersions.id, rb2.activeVersionId));
+          return true;
+        }
+      }
+      const latestVer = await this.db.query.runbookVersions.findFirst({
+        where: and2(
+          eq2(runbookVersions.runbookId, id),
+          eq2(runbookVersions.status, "pending_verification")
+        ),
+        orderBy: [desc2(runbookVersions.versionNumber)]
+      });
+      if (latestVer) {
+        await this.db.update(runbookVersions).set({ status: "active", publishedAt: /* @__PURE__ */ new Date() }).where(eq2(runbookVersions.id, latestVer.id));
+        await this.db.update(runbooks).set({ activeVersionId: latestVer.id }).where(eq2(runbooks.id, id));
+        return true;
+      }
+      return false;
+    }
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and2(eq2(runbooks.id, id), eq2(runbooks.tenantId, tenantId))
+    });
+    if (!rb) return false;
+    const targetVersionId = rb.activeVersionId;
+    if (!targetVersionId) {
+      const latestVer = await this.db.query.runbookVersions.findFirst({
+        where: eq2(runbookVersions.runbookId, id),
+        orderBy: [desc2(runbookVersions.versionNumber)]
+      });
+      if (latestVer) {
+        await this.db.update(runbookVersions).set({ status }).where(eq2(runbookVersions.id, latestVer.id));
+        return true;
+      }
+      return false;
+    }
+    await this.db.update(runbookVersions).set({ status }).where(eq2(runbookVersions.id, targetVersionId));
+    return true;
+  }
+  /**
+   * getStatus: 旧 API 互換
+   */
+  async getStatus(tenantId, id) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and2(eq2(runbooks.id, id), eq2(runbooks.tenantId, tenantId)),
+      columns: { id: true, disabled: true, activeVersionId: true }
+    });
+    if (!rb) return null;
+    if (rb.disabled) return "disabled";
+    const verId = rb.activeVersionId;
+    if (verId) {
+      const [ver] = await this.db.select({ status: runbookVersions.status }).from(runbookVersions).where(eq2(runbookVersions.id, verId));
+      if (ver) return ver.status;
+    }
+    const latestVer = await this.db.query.runbookVersions.findFirst({
+      where: eq2(runbookVersions.runbookId, id),
+      orderBy: [desc2(runbookVersions.versionNumber)],
+      columns: { status: true }
+    });
+    return latestVer?.status ?? "draft";
+  }
+  /**
+   * setVerificationJob: 旧 API 互換
+   */
+  async setVerificationJob(tenantId, runbookId, jobId) {
+    const rb = await this.db.query.runbooks.findFirst({
+      where: and2(eq2(runbooks.id, runbookId), eq2(runbooks.tenantId, tenantId))
+    });
+    if (!rb) return false;
+    const targetVer = await this.db.query.runbookVersions.findFirst({
+      where: eq2(runbookVersions.runbookId, runbookId),
+      orderBy: [desc2(runbookVersions.versionNumber)]
+    });
+    if (!targetVer) return false;
+    return await this.versions.setVerificationJob(targetVer.id, jobId);
+  }
+  /**
+   * clearVerificationJob: 旧 API 互換
+   */
+  async clearVerificationJob(tenantId, runbookId) {
+    const targetVer = await this.db.query.runbookVersions.findFirst({
+      where: eq2(runbookVersions.runbookId, runbookId),
+      orderBy: [desc2(runbookVersions.versionNumber)]
+    });
+    if (!targetVer) return false;
+    return await this.versions.clearVerificationJob(targetVer.id);
+  }
+  // ── ライフサイクル ──
+  /**
+   * duplicate: Runbook をコピーする（active バージョンから draft 作成）
+   */
+  async duplicate(tenantId, sourceId, createdBy) {
+    const source = await this.findById(tenantId, sourceId);
+    if (!source) return null;
+    return await this.db.transaction(async (tx) => {
+      const [newRb] = await tx.insert(runbooks).values({
+        tenantId,
+        title: `${source.title} (Copy)`,
+        createdBy: createdBy ?? null
+      }).returning();
+      const verRow = await this.versions.createInitialVersion(tx, newRb.id, {
+        goal: source.goal,
+        startUrl: source.startUrl,
+        context: source.context,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        createdBy: createdBy ?? null
+      });
+      if (source.currentVersionId) {
+        const { copyVersionData: copyVersionData2 } = await import("./runbook-data-helpers-KRR2SH76.js");
+        await copyVersionData2(tx, source.currentVersionId, verRow.id);
+      }
+      return { id: newRb.id };
+    });
+  }
+  /**
+   * patchSteps: ステップの部分更新（最新バージョン対象）
+   */
+  async patchSteps(tenantId, runbookId, patches) {
+    const targetVer = await this.db.query.runbookVersions.findFirst({
+      where: eq2(runbookVersions.runbookId, runbookId),
+      orderBy: [desc2(runbookVersions.versionNumber)]
+    });
+    if (!targetVer) return false;
+    return await this.versions.patchSteps(tenantId, runbookId, targetVer.id, patches);
+  }
+  /**
+   * delete: Runbook を削除（CASCADE で全バージョン・子テーブルも削除）
+   */
+  async delete(tenantId, id) {
+    const result = await this.db.delete(runbooks).where(and2(eq2(runbooks.id, id), eq2(runbooks.tenantId, tenantId))).returning({ id: runbooks.id });
+    return result.length > 0;
+  }
+  /**
+   * disable: Runbook を無効化
+   */
+  async disable(tenantId, id) {
+    const result = await this.db.update(runbooks).set({ disabled: true }).where(and2(eq2(runbooks.id, id), eq2(runbooks.tenantId, tenantId))).returning({ id: runbooks.id });
+    return result.length > 0;
+  }
+  /**
+   * enable: Runbook を有効化
+   */
+  async enable(tenantId, id) {
+    const result = await this.db.update(runbooks).set({ disabled: false }).where(and2(eq2(runbooks.id, id), eq2(runbooks.tenantId, tenantId))).returning({ id: runbooks.id });
+    return result.length > 0;
+  }
+};
+
+export {
+  RunbookStore
+};
+//# sourceMappingURL=chunk-WEYR56ZN.js.map