@flame0510/project-aether 1.5.1 → 1.5.2

package/lib/agent-recreate-state.ts

@@ -3,8 +3,9 @@
  *
  * Kept apart from lib/agent-recreate.ts so busy checks (lib/agent-busy.ts, the provider
  * sync) can ask which agents are being recreated without importing the recreate action.
+ * The machinery is lib/agent-job-state.ts; this file holds the table's types and names.
  */
-import { openDb } from '@/lib/db';
+import { createJobState } from '@/lib/agent-job-state';
 
 export type RecreateStatus = 'backing_up' | 'recreating' | 'done' | 'failed' | 'interrupted';
 
@@ -25,84 +26,42 @@ export interface AgentRecreateRow {
 
 const FINAL: readonly RecreateStatus[] = ['done', 'failed', 'interrupted'];
 
-export function insertRecreate(agentId: string, image: string): number {
-  const db = openDb(false);
-  try {
-    const now = Date.now();
-    const info = db.prepare(
-      `INSERT INTO agent_recreates (agent_id, status, image, started_at, updated_at)
-       VALUES (?, 'backing_up', ?, ?, ?)`,
-    ).run(agentId, image, now, now);
-    return Number(info.lastInsertRowid);
-  } finally {
-    db.close();
-  }
-}
+const state = createJobState({
+  table: 'agent_recreates',
+  initialStatus: 'backing_up',
+  activeStatuses: ACTIVE_RECREATE_STATUSES,
+  finalStatuses: FINAL,
+  insertColumns: ['image'],
+  writableColumns: ['backup_file'],
+});
 
 type Writable = Partial<Pick<AgentRecreateRow, 'status' | 'backup_file' | 'error'>>;
 
+export function insertRecreate(agentId: string, image: string): number {
+  return state.insert(agentId, image);
+}
+
 export function updateRecreateRow(id: number, fields: Writable): void {
-  const entries = Object.entries(fields).filter(([, v]) => v !== undefined);
-  const now = Date.now();
-  const sets = [...entries.map(([k]) => `${k} = ?`), 'updated_at = ?'];
-  const values: unknown[] = [...entries.map(([, v]) => v), now];
-  if (fields.status && FINAL.includes(fields.status)) {
-    sets.push('finished_at = ?');
-    values.push(now);
-  } else if (fields.status) {
-    sets.push('finished_at = NULL');
-  }
-  const db = openDb(false);
-  try {
-    db.prepare(`UPDATE agent_recreates SET ${sets.join(', ')} WHERE id = ?`).run(...values, id);
-  } finally {
-    db.close();
-  }
+  state.update(id, fields);
 }
 
 export function latestRecreate(agentId: string): AgentRecreateRow | null {
-  const db = openDb(true);
-  try {
-    return (db.prepare('SELECT * FROM agent_recreates WHERE agent_id = ? ORDER BY id DESC LIMIT 1').get(agentId) as AgentRecreateRow | undefined) ?? null;
-  } finally {
-    db.close();
-  }
+  return state.latest<AgentRecreateRow>(agentId);
 }
 
 export function isRecreateActive(agentId: string): boolean {
-  const row = latestRecreate(agentId);
-  return !!row && ACTIVE_RECREATE_STATUSES.includes(row.status);
+  return state.isActive(agentId);
 }
 
-/** AGENT_IDs with a recreate in an active status. */
 export function activeRecreateAgentIds(): Set<string> {
-  const db = openDb(true);
-  try {
-    const placeholders = ACTIVE_RECREATE_STATUSES.map(() => '?').join(', ');
-    const rows = db.prepare(`SELECT DISTINCT agent_id FROM agent_recreates WHERE status IN (${placeholders})`).all(...ACTIVE_RECREATE_STATUSES) as { agent_id: string }[];
-    return new Set(rows.map((r) => r.agent_id));
-  } finally {
-    db.close();
-  }
+  return state.activeAgentIds();
 }
 
-/**
- * At startup no recreate job can be running: any row still active was cut off by the
- * restart. It becomes `interrupted`, keeping the step it was in.
- */
 export function markInterruptedRecreates(): number {
-  const db = openDb(false);
-  try {
-    const placeholders = ACTIVE_RECREATE_STATUSES.map(() => '?').join(', ');
-    const now = Date.now();
-    const info = db.prepare(
-      `UPDATE agent_recreates
-         SET error = COALESCE(error, 'Rev4a restarted while this step was running: ' || status),
-             status = 'interrupted', updated_at = ?, finished_at = ?
-       WHERE status IN (${placeholders})`,
-    ).run(now, now, ...ACTIVE_RECREATE_STATUSES);
-    return info.changes;
-  } finally {
-    db.close();
-  }
+  return state.markInterrupted();
+}
+
+/** Keep the newest `keepPerAgent` recreates of each agent; the rest is history. */
+export function pruneRecreates(keepPerAgent: number): number {
+  return state.prune(keepPerAgent);
 }

package/lib/agent-restore-state.ts

@@ -2,9 +2,10 @@
  * Persisted state of agent restores: the `agent_restores` table (lib/db-bootstrap.mjs).
  *
  * Kept apart from lib/agent-restore.ts so busy checks (lib/agent-busy.ts) can ask which
- * agents are being restored without importing the restore action.
+ * agents are being restored without importing the restore action. The machinery is
+ * lib/agent-job-state.ts; this file holds the table's types and names.
  */
-import { openDb } from '@/lib/db';
+import { createJobState } from '@/lib/agent-job-state';
 
 export type RestoreStatus = 'restoring' | 'done' | 'failed' | 'interrupted';
 
@@ -24,84 +25,42 @@ export interface AgentRestoreRow {
 
 const FINAL: readonly RestoreStatus[] = ['done', 'failed', 'interrupted'];
 
-export function insertRestore(agentId: string, file: string): number {
-  const db = openDb(false);
-  try {
-    const now = Date.now();
-    const info = db.prepare(
-      `INSERT INTO agent_restores (agent_id, status, file, started_at, updated_at)
-       VALUES (?, 'restoring', ?, ?, ?)`,
-    ).run(agentId, file, now, now);
-    return Number(info.lastInsertRowid);
-  } finally {
-    db.close();
-  }
-}
+const state = createJobState({
+  table: 'agent_restores',
+  initialStatus: 'restoring',
+  activeStatuses: ACTIVE_RESTORE_STATUSES,
+  finalStatuses: FINAL,
+  insertColumns: ['file'],
+  writableColumns: [],
+});
 
 type Writable = Partial<Pick<AgentRestoreRow, 'status' | 'error'>>;
 
+export function insertRestore(agentId: string, file: string): number {
+  return state.insert(agentId, file);
+}
+
 export function updateRestoreRow(id: number, fields: Writable): void {
-  const entries = Object.entries(fields).filter(([, v]) => v !== undefined);
-  const now = Date.now();
-  const sets = [...entries.map(([k]) => `${k} = ?`), 'updated_at = ?'];
-  const values: unknown[] = [...entries.map(([, v]) => v), now];
-  if (fields.status && FINAL.includes(fields.status)) {
-    sets.push('finished_at = ?');
-    values.push(now);
-  } else if (fields.status) {
-    sets.push('finished_at = NULL');
-  }
-  const db = openDb(false);
-  try {
-    db.prepare(`UPDATE agent_restores SET ${sets.join(', ')} WHERE id = ?`).run(...values, id);
-  } finally {
-    db.close();
-  }
+  state.update(id, fields);
 }
 
 export function latestRestore(agentId: string): AgentRestoreRow | null {
-  const db = openDb(true);
-  try {
-    return (db.prepare('SELECT * FROM agent_restores WHERE agent_id = ? ORDER BY id DESC LIMIT 1').get(agentId) as AgentRestoreRow | undefined) ?? null;
-  } finally {
-    db.close();
-  }
+  return state.latest<AgentRestoreRow>(agentId);
 }
 
 export function isRestoreActive(agentId: string): boolean {
-  const row = latestRestore(agentId);
-  return !!row && ACTIVE_RESTORE_STATUSES.includes(row.status);
+  return state.isActive(agentId);
 }
 
-/** AGENT_IDs with a restore in an active status. */
 export function activeRestoreAgentIds(): Set<string> {
-  const db = openDb(true);
-  try {
-    const placeholders = ACTIVE_RESTORE_STATUSES.map(() => '?').join(', ');
-    const rows = db.prepare(`SELECT DISTINCT agent_id FROM agent_restores WHERE status IN (${placeholders})`).all(...ACTIVE_RESTORE_STATUSES) as { agent_id: string }[];
-    return new Set(rows.map((r) => r.agent_id));
-  } finally {
-    db.close();
-  }
+  return state.activeAgentIds();
 }
 
-/**
- * At startup no restore job can be running: a row still active was cut off by the
- * restart. It becomes `interrupted`, keeping the archive it was restoring.
- */
 export function markInterruptedRestores(): number {
-  const db = openDb(false);
-  try {
-    const placeholders = ACTIVE_RESTORE_STATUSES.map(() => '?').join(', ');
-    const now = Date.now();
-    const info = db.prepare(
-      `UPDATE agent_restores
-         SET error = COALESCE(error, 'Rev4a restarted while this step was running: ' || status),
-             status = 'interrupted', updated_at = ?, finished_at = ?
-       WHERE status IN (${placeholders})`,
-    ).run(now, now, ...ACTIVE_RESTORE_STATUSES);
-    return info.changes;
-  } finally {
-    db.close();
-  }
+  return state.markInterrupted();
+}
+
+/** Keep the newest `keepPerAgent` restores of each agent; the rest is history. */
+export function pruneRestores(keepPerAgent: number): number {
+  return state.prune(keepPerAgent);
 }

package/lib/agent-restore.ts

@@ -123,19 +123,42 @@ export function agentRestoreView(agentId: string): AgentRestoreView | null {
 
 /**
  * At startup no restore job can be running: rows still active were cut off by the
- * restart. They become `interrupted`; a container left stopped is started again,
- * best-effort, so nothing stays down.
+ * restart. A restore interrupted **mid-extract** leaves a half-written volume, so
+ * starting the container would present a partial workspace as if it were the restore: the
+ * extract is run again from the same archive (it is the source of truth and the file was
+ * checked before the job started), in the background, and the row lands in its final
+ * status. When the archive is gone the container is started on whatever the volume holds,
+ * and the row says so.
  */
 export async function recoverInterruptedRestores(): Promise<number> {
   const ids = activeRestoreAgentIds();
   if (ids.size === 0) return 0;
   const interrupted = markInterruptedRestores();
   for (const agentId of ids) {
-    const container = await inspectAgentContainer(agentId).catch(() => null);
-    const name = container?.Name?.replace(/^\//, '');
-    if (!name || container?.State?.Running) continue;
+    const row = latestRestore(agentId);
+    const name = (await inspectAgentContainer(agentId).catch(() => null))?.Name?.replace(/^\//, '');
+    if (row?.file && (await backupFileExists(agentId, row.file))) {
+      console.log(`[agent:restore] ${agentId}: re-running the interrupted restore from ${row.file}`);
+      void runRestore(row.id, agentId, row.file).finally(() => undefined);
+      continue;
+    }
+    if (!name) continue;
     const started = await startAndVerifyContainer(agentId, name);
     if (!started.ok) console.warn(`[agent:restore] ${agentId} did not come back after an interrupted restore: ${started.error}`);
   }
   return interrupted;
 }
+
+/** Whether the archive still exists in the backup volume. */
+async function backupFileExists(agentId: string, file: string): Promise<boolean> {
+  if (!isValidBackupFile(agentId, file)) return false;
+  try {
+    await runDocker(
+      ['run', '--rm', '-v', `${BACKUP_VOLUME}:/backup`, 'alpine', 'sh', '-c', 'test -f "/backup/$FILE"'],
+      { timeoutMs: 30_000, env: { FILE: file } },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}

package/lib/agent-update-state.ts

@@ -2,9 +2,10 @@
  * Persisted state of agent updates: the `agent_upgrades` table (lib/db-bootstrap.mjs).
  *
  * Kept apart from lib/agent-update.ts so the provider sync can ask which agents are
- * being updated without importing the update action, which imports the sync.
+ * being updated without importing the update action, which imports the sync. The
+ * machinery is lib/agent-job-state.ts; this file holds the table's types and names.
  */
-import { openDb } from '@/lib/db';
+import { createJobState } from '@/lib/agent-job-state';
 
 export type UpdateStatus =
   | 'pending'
@@ -38,65 +39,36 @@ export interface AgentUpdateRow {
 
 const FINAL: readonly UpdateStatus[] = ['done', 'failed', 'interrupted', 'rolled_back', 'rollback_failed'];
 
-export function insertUpdate(agentId: string, fromVersion: string | null, toVersion: string): number {
-  const db = openDb(false);
-  try {
-    const now = Date.now();
-    const info = db.prepare(
-      `INSERT INTO agent_upgrades (agent_id, status, from_version, to_version, started_at, updated_at)
-       VALUES (?, 'pending', ?, ?, ?, ?)`,
-    ).run(agentId, fromVersion, toVersion, now, now);
-    return Number(info.lastInsertRowid);
-  } finally {
-    db.close();
-  }
-}
+const state = createJobState({
+  table: 'agent_upgrades',
+  initialStatus: 'pending',
+  activeStatuses: ACTIVE_STATUSES,
+  finalStatuses: FINAL,
+  insertColumns: ['from_version', 'to_version'],
+  writableColumns: ['backup_file', 'baseline_json', 'verify_json'],
+});
 
 type Writable = Partial<Pick<AgentUpdateRow, 'status' | 'backup_file' | 'baseline_json' | 'verify_json' | 'error'>>;
 
+export function insertUpdate(agentId: string, fromVersion: string | null, toVersion: string): number {
+  return state.insert(agentId, fromVersion, toVersion);
+}
+
 export function updateRow(id: number, fields: Writable): void {
-  const entries = Object.entries(fields).filter(([, v]) => v !== undefined);
-  const now = Date.now();
-  const sets = [...entries.map(([k]) => `${k} = ?`), 'updated_at = ?'];
-  const values: unknown[] = [...entries.map(([, v]) => v), now];
-  if (fields.status && FINAL.includes(fields.status)) {
-    sets.push('finished_at = ?');
-    values.push(now);
-  } else if (fields.status) {
-    sets.push('finished_at = NULL');
-  }
-  const db = openDb(false);
-  try {
-    db.prepare(`UPDATE agent_upgrades SET ${sets.join(', ')} WHERE id = ?`).run(...values, id);
-  } finally {
-    db.close();
-  }
+  state.update(id, fields);
 }
 
 export function latestUpdate(agentId: string): AgentUpdateRow | null {
-  const db = openDb(true);
-  try {
-    return (db.prepare('SELECT * FROM agent_upgrades WHERE agent_id = ? ORDER BY id DESC LIMIT 1').get(agentId) as AgentUpdateRow | undefined) ?? null;
-  } finally {
-    db.close();
-  }
+  return state.latest<AgentUpdateRow>(agentId);
 }
 
 export function isUpdateActive(agentId: string): boolean {
-  const row = latestUpdate(agentId);
-  return !!row && ACTIVE_STATUSES.includes(row.status);
+  return state.isActive(agentId);
 }
 
 /** AGENT_IDs with an update in an active status. */
 export function activeUpdateAgentIds(): Set<string> {
-  const db = openDb(true);
-  try {
-    const placeholders = ACTIVE_STATUSES.map(() => '?').join(', ');
-    const rows = db.prepare(`SELECT DISTINCT agent_id FROM agent_upgrades WHERE status IN (${placeholders})`).all(...ACTIVE_STATUSES) as { agent_id: string }[];
-    return new Set(rows.map((r) => r.agent_id));
-  } finally {
-    db.close();
-  }
+  return state.activeAgentIds();
 }
 
 /**
@@ -105,18 +77,10 @@ export function activeUpdateAgentIds(): Set<string> {
  * between Rollback and a new Update.
  */
 export function markInterruptedUpdates(): number {
-  const db = openDb(false);
-  try {
-    const placeholders = ACTIVE_STATUSES.map(() => '?').join(', ');
-    const now = Date.now();
-    const info = db.prepare(
-      `UPDATE agent_upgrades
-         SET error = COALESCE(error, 'Rev4a restarted while this step was running: ' || status),
-             status = 'interrupted', updated_at = ?, finished_at = ?
-       WHERE status IN (${placeholders})`,
-    ).run(now, now, ...ACTIVE_STATUSES);
-    return info.changes;
-  } finally {
-    db.close();
-  }
+  return state.markInterrupted();
+}
+
+/** Keep the newest `keepPerAgent` updates of each agent; the rest is history. */
+export function pruneUpdates(keepPerAgent: number): number {
+  return state.prune(keepPerAgent);
 }

package/lib/channelManager.ts

@@ -287,6 +287,12 @@ export interface ApprovedPairing {
 export interface PairingState {
   pending: PendingPairing[];
   approved: ApprovedPairing[];
+  /**
+   * Why the approved list is empty, when that is not simply "none": the pairing store
+   * could not be read (the writer is not in this OpenClaw build, or the read failed).
+   * Callers must show it instead of "No approved senders", which would be a guess.
+   */
+  error?: string | null;
 }
 
 /**
@@ -428,8 +434,13 @@ export async function getPairings(agentId: string, channel: string = 'telegram')
   if (store.status === 'ok') {
     for (const entry of store.entries ?? []) approved.push({ senderId: String(entry) });
   }
+  // 'absent' is a real answer (no store yet, so no approved senders); anything else means
+  // the read did not succeed and an empty list must not be presented as "none".
+  const error = store.status === 'ok' || store.status === 'absent'
+    ? null
+    : (store.error ?? 'The approved senders could not be read');
 
-  return { pending, approved };
+  return { pending, approved, error };
 }
 
 /** Approve a pending pairing code */