@bulolo/hermes-link 0.3.0 → 0.3.2

package/dist/{chunk-AA2LZ6QZ.js → chunk-YNBTALOX.js}

@@ -780,7 +780,7 @@ async function dismissUpdate(paths) {
 
 // src/security/credentials.ts
 import { randomBytes, randomUUID as randomUUID2, timingSafeEqual, createHash } from "crypto";
-var ACCESS_TOKEN_TTL_MS = 15 * 60 * 1e3;
+var ACCESS_TOKEN_TTL_MS = 2 * 60 * 60 * 1e3;
 var REFRESH_TOKEN_TTL_MS = 90 * 24 * 60 * 60 * 1e3;
 var DEVICE_SEEN_WRITE_INTERVAL_MS = 60 * 60 * 1e3;
 function credentialsPath(paths) {
@@ -841,8 +841,8 @@ function formatDeviceListItem(device) {
   };
 }
 async function rotateDeviceSession(store, device, now, paths) {
-  const accessToken = randomToken("hpat_");
-  const refreshToken = randomToken("hprt_");
+  const accessToken = randomToken("hlat_");
+  const refreshToken = randomToken("hlrt_");
   device.access_token_hash = sha256(accessToken);
   device.access_expires_at = new Date(now.getTime() + ACCESS_TOKEN_TTL_MS).toISOString();
   device.refresh_token_hash = sha256(refreshToken);
@@ -1106,7 +1106,7 @@ async function authenticateRequest(ctx, paths = resolveRuntimePaths()) {
   if (device) {
     return { kind: "device", device };
   }
-  if (token.startsWith("hpat_")) {
+  if (token.startsWith("hlat_")) {
     throw new LinkHttpError(401, "device_access_token_invalid", "Device access token is invalid or expired");
   }
   const localToken = await consumeAppConnectToken(token, paths);
@@ -2046,6 +2046,43 @@ function createConversationsRouter(options) {
     });
     ctx.body = { ok: true, conversations: result.conversations, page: result.page };
   });
+  router.get("/api/v1/conversations/archived", async (ctx) => {
+    await authenticateRequest(ctx, paths);
+    ctx.set("cache-control", "no-store");
+    const result = await conversations.listArchivedConversationPage({
+      limit: readLimit(ctx.query.limit),
+      cursor: readQueryString(ctx.query.cursor) ?? readQueryString(ctx.query.after)
+    });
+    ctx.body = { ok: true, conversations: result.conversations, page: result.page };
+  });
+  router.get("/api/v1/conversations/archived/search", async (ctx) => {
+    await authenticateRequest(ctx, paths);
+    ctx.set("cache-control", "no-store");
+    const result = await conversations.searchArchivedConversationPage({
+      limit: readLimit(ctx.query.limit),
+      cursor: readQueryString(ctx.query.cursor) ?? readQueryString(ctx.query.after),
+      query: readQueryString(ctx.query.query) ?? readQueryString(ctx.query.q) ?? readQueryString(ctx.query.keyword) ?? ""
+    });
+    ctx.body = { ok: true, conversations: result.conversations, page: result.page };
+  });
+  router.post("/api/v1/conversations/archive-plans", async (ctx) => {
+    await authenticateRequest(ctx, paths);
+    const body = await readJsonBody3(ctx.req);
+    const excludeIds = readStringArray2(body, "exclude_conversation_ids", "excludeConversationIds") ?? [];
+    const plan = await conversations.prepareArchiveAllConversationPlan({ excludeConversationIds: excludeIds });
+    ctx.status = 201;
+    ctx.body = { ok: true, plan };
+  });
+  router.get("/api/v1/conversations/archive-plans/:planId", async (ctx) => {
+    await authenticateRequest(ctx, paths);
+    ctx.set("cache-control", "no-store");
+    ctx.body = { ok: true, plan: await conversations.readArchiveAllConversationPlan(ctx.params.planId) };
+  });
+  router.post("/api/v1/conversations/archive-plans/:planId/execute", async (ctx) => {
+    await authenticateRequest(ctx, paths);
+    const plan = await conversations.executeArchiveAllConversationPlan(ctx.params.planId);
+    ctx.body = { ok: true, plan };
+  });
   router.post("/api/v1/conversations/clear-plans", async (ctx) => {
     await authenticateRequest(ctx, paths);
     const plan = await conversations.prepareClearAllConversationPlan();
@@ -2173,6 +2210,14 @@ function createConversationsRouter(options) {
     if (!title) throw new LinkHttpError(400, "title_required", "title is required");
     ctx.body = { ok: true, ...await conversations.renameConversation(ctx.params.conversationId, title) };
   });
+  router.post("/api/v1/conversations/:conversationId/archive", async (ctx) => {
+    await authenticateRequest(ctx, paths);
+    ctx.body = { ok: true, ...await conversations.archiveConversation(ctx.params.conversationId) };
+  });
+  router.post("/api/v1/conversations/:conversationId/unarchive", async (ctx) => {
+    await authenticateRequest(ctx, paths);
+    ctx.body = { ok: true, ...await conversations.unarchiveConversation(ctx.params.conversationId) };
+  });
   router.post("/api/v1/conversations/:conversationId/ack", async (ctx) => {
     await authenticateRequest(ctx, paths);
     ctx.body = { ok: true };
@@ -7602,6 +7647,13 @@ async function readManifest(paths, conversationId) {
   return readJson(manifestPath(paths, conversationId), null);
 }
 async function readActiveManifest(paths, conversationId) {
+  const manifest = await readManifest(paths, conversationId);
+  if (!manifest || manifest.status === "deleted_soft" || manifest.status === "archived") {
+    throw new LinkHttpError(404, "conversation_not_found", "Conversation was not found");
+  }
+  return manifest;
+}
+async function readExistingManifest(paths, conversationId) {
   const manifest = await readManifest(paths, conversationId);
   if (!manifest || manifest.status === "deleted_soft") {
     throw new LinkHttpError(404, "conversation_not_found", "Conversation was not found");
@@ -7884,6 +7936,8 @@ function normalizeLimit(value, defaultValue, max) {
   if (!Number.isFinite(n) || n < 1) return defaultValue;
   return Math.min(n, max);
 }
+var clearPlans = /* @__PURE__ */ new Map();
+var archivePlans = /* @__PURE__ */ new Map();
 var ConversationService = class extends EventEmitter4 {
   paths;
   logger;
@@ -7952,13 +8006,82 @@ var ConversationService = class extends EventEmitter4 {
     if (after === void 0 || after === null) return events;
     return events.filter((e) => e.seq > after);
   }
+  summarizeManifest(manifest, snapshot) {
+    const stats = manifest.stats;
+    const profileName = manifest.profile ?? manifest.profile_name_snapshot ?? "default";
+    let lastMessage = null;
+    if (snapshot && snapshot.messages.length > 0) {
+      const last = snapshot.messages[snapshot.messages.length - 1];
+      if (last) {
+        const text = last.parts.find((p) => p.type === "text")?.text ?? "";
+        lastMessage = { id: last.id, role: last.role, content_preview: text.slice(0, 200) };
+      }
+    }
+    return {
+      id: manifest.id,
+      title: manifest.title,
+      created_at: manifest.created_at,
+      updated_at: manifest.updated_at,
+      last_event_seq: manifest.last_event_seq,
+      usage: {
+        input_tokens: stats?.input_tokens ?? 0,
+        output_tokens: stats?.output_tokens ?? 0,
+        total_tokens: stats?.total_tokens ?? 0,
+        ...stats?.updated_at ? { updated_at: stats.updated_at } : {}
+      },
+      profile: {
+        uid: manifest.profile_uid ?? void 0,
+        name: profileName,
+        display_name: profileName,
+        avatar_url: null
+      },
+      last_message: lastMessage
+    };
+  }
+  buildRuntimeMetadata(manifest) {
+    const stats = manifest.stats;
+    const profileName = manifest.profile ?? manifest.profile_name_snapshot ?? "default";
+    const usagePercent = stats?.context_window && stats.total_tokens ? Math.min(100, Math.round(stats.total_tokens / stats.context_window * 100)) : void 0;
+    return {
+      profile: {
+        uid: manifest.profile_uid ?? void 0,
+        name: profileName,
+        display_name: profileName,
+        avatar_url: null
+      },
+      model: {
+        id: stats?.model ?? "unknown",
+        ...stats?.provider ? { provider: stats.provider } : {},
+        ...stats?.context_window ? { context_window: stats.context_window } : {}
+      },
+      context: {
+        input_tokens: stats?.input_tokens ?? 0,
+        output_tokens: stats?.output_tokens ?? 0,
+        total_tokens: stats?.total_tokens ?? 0,
+        ...stats?.context_window ? { context_window: stats.context_window } : {},
+        ...usagePercent !== void 0 ? { usage_percent: usagePercent } : {},
+        source: stats?.model ? "estimated" : "unknown",
+        ...stats?.updated_at ? { updated_at: stats.updated_at } : {}
+      }
+    };
+  }
+  async listConversations() {
+    const ids = await listConversationIds(this.paths);
+    const manifests = [];
+    for (const id of ids) {
+      const m = await readManifest(this.paths, id);
+      if (m && m.status !== "deleted_soft") manifests.push(m);
+    }
+    manifests.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    return manifests.map((m) => this.summarizeManifest(m));
+  }
   async listConversationPage(options = {}) {
     const limit = normalizeLimit(options.limit, 20, 100);
     const ids = await listConversationIds(this.paths);
     const manifests = [];
     for (const id of ids) {
       const m = await readManifest(this.paths, id);
-      if (m && m.status !== "deleted_soft") manifests.push(m);
+      if (m && m.status === "active") manifests.push(m);
     }
     manifests.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
     let startIndex = 0;
@@ -7985,7 +8108,7 @@ var ConversationService = class extends EventEmitter4 {
     const results = [];
     for (const id of ids) {
       const m = await readManifest(this.paths, id);
-      if (m && m.status !== "deleted_soft" && m.title.toLowerCase().includes(q)) {
+      if (m && m.status === "active" && m.title.toLowerCase().includes(q)) {
         results.push(m);
       }
     }
@@ -7996,6 +8119,48 @@ var ConversationService = class extends EventEmitter4 {
       page: { limit, has_more: results.length > limit, next_cursor: null }
     };
   }
+  async listArchivedConversationPage(options = {}) {
+    const limit = normalizeLimit(options.limit, 20, 100);
+    const ids = await listConversationIds(this.paths);
+    const manifests = [];
+    for (const id of ids) {
+      const m = await readManifest(this.paths, id);
+      if (m && m.status === "archived") manifests.push(m);
+    }
+    manifests.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    let startIndex = 0;
+    if (options.cursor) {
+      const idx = manifests.findIndex((m) => m.id === options.cursor);
+      if (idx >= 0) startIndex = idx + 1;
+    }
+    const page = manifests.slice(startIndex, startIndex + limit);
+    const hasMore = startIndex + limit < manifests.length;
+    return {
+      conversations: page.map((m) => this.summarizeManifest(m)),
+      page: {
+        limit,
+        has_more: hasMore,
+        next_cursor: hasMore && page.length > 0 ? page[page.length - 1]?.id ?? null : null
+      }
+    };
+  }
+  async searchArchivedConversationPage(options = {}) {
+    if (!options.query?.trim()) return this.listArchivedConversationPage(options);
+    const q = options.query.trim().toLowerCase();
+    const limit = normalizeLimit(options.limit, 20, 100);
+    const ids = await listConversationIds(this.paths);
+    const results = [];
+    for (const id of ids) {
+      const m = await readManifest(this.paths, id);
+      if (m && m.status === "archived" && m.title.toLowerCase().includes(q)) results.push(m);
+    }
+    results.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    const page = results.slice(0, limit);
+    return {
+      conversations: page.map((m) => this.summarizeManifest(m)),
+      page: { limit, has_more: results.length > limit, next_cursor: null }
+    };
+  }
   async createConversation(options = {}) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const id = createConversationId();
@@ -8017,7 +8182,7 @@ var ConversationService = class extends EventEmitter4 {
     return this.summarizeManifest(manifest);
   }
   async getMessages(conversationId, options = {}) {
-    const manifest = await readActiveManifest(this.paths, conversationId);
+    const manifest = await readExistingManifest(this.paths, conversationId);
     const snapshot = await readSnapshot(this.paths, conversationId);
     const limit = normalizeLimit(options.limit, 50, 200);
     const total = snapshot.messages.length;
@@ -8028,6 +8193,7 @@ var ConversationService = class extends EventEmitter4 {
     return {
       messages,
       last_event_seq: manifest.last_event_seq,
+      runtime: this.buildRuntimeMetadata(manifest),
       page: {
         limit,
         has_more_before: startIndex > 0,
@@ -8043,7 +8209,16 @@ var ConversationService = class extends EventEmitter4 {
   async sendMessageLocked(input) {
     const content = input.content.trim();
     if (!content) throw new LinkHttpError(400, "message_content_required", "message content is required");
-    const manifest = await readActiveManifest(this.paths, input.conversationId);
+    const raw = await readManifest(this.paths, input.conversationId);
+    if (!raw || raw.status === "deleted_soft") {
+      throw new LinkHttpError(404, "conversation_not_found", "Conversation was not found");
+    }
+    if (raw.status === "archived") {
+      raw.status = "active";
+      raw.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      await writeManifest(this.paths, raw);
+    }
+    const manifest = raw;
     const snapshot = await readSnapshot(this.paths, input.conversationId);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const runId = createRunId();
@@ -8109,9 +8284,14 @@ var ConversationService = class extends EventEmitter4 {
       assistant_message: { id: assistantMessageId, status: assistantMessage.status },
       run: { id: runId, status: run.status },
       last_event_seq: latestEvent.seq,
-      conversation: this.summarizeManifest(manifest)
+      conversation: this.summarizeManifest(manifest, snapshot)
     };
   }
+  async cancelRunById(runId) {
+    const active = this.activeRunControllers.get(runId);
+    if (!active) throw new LinkHttpError(404, "run_not_found", "Run was not found");
+    return this.cancelRun(active.conversationId, runId);
+  }
   async cancelRun(conversationId, runId) {
     const active = this.activeRunControllers.get(runId);
     if (active) active.controller.abort();
@@ -8330,13 +8510,50 @@ var ConversationService = class extends EventEmitter4 {
   async deleteConversation(conversationId) {
     assertValidConversationId(conversationId);
     return withConversationLock(conversationId, async () => {
-      const manifest = await readActiveManifest(this.paths, conversationId);
+      const manifest = await readExistingManifest(this.paths, conversationId);
       const now = (/* @__PURE__ */ new Date()).toISOString();
+      const hermesSessionIds = manifest.hermes_session_ids ?? (manifest.hermes_session_id ? [manifest.hermes_session_id] : []);
       manifest.status = "deleted_soft";
       manifest.deleted_at = now;
       manifest.updated_at = now;
       await writeManifest(this.paths, manifest);
-      return { conversation_id: conversationId, deleted_at: now };
+      return {
+        conversation_id: conversationId,
+        hermes_deleted: false,
+        ...hermesSessionIds.length > 0 ? { hermes_session_ids: hermesSessionIds } : {},
+        deleted_at: now
+      };
+    });
+  }
+  async archiveConversation(conversationId) {
+    assertValidConversationId(conversationId);
+    return withConversationLock(conversationId, async () => {
+      const manifest = await readActiveManifest(this.paths, conversationId);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      manifest.status = "archived";
+      manifest.updated_at = now;
+      await writeManifest(this.paths, manifest);
+      const conv = this.summarizeManifest(manifest);
+      await this.appendAndEmit(conversationId, { type: "conversation.archived", payload: { conversation: conv } }, manifest);
+      await writeManifest(this.paths, manifest);
+      return { conversation_id: conversationId, archived_at: now };
+    });
+  }
+  async unarchiveConversation(conversationId) {
+    assertValidConversationId(conversationId);
+    return withConversationLock(conversationId, async () => {
+      const manifest = await readExistingManifest(this.paths, conversationId);
+      if (manifest.status !== "archived") {
+        throw new LinkHttpError(400, "conversation_not_archived", "Conversation is not archived");
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      manifest.status = "active";
+      manifest.updated_at = now;
+      await writeManifest(this.paths, manifest);
+      const conv = this.summarizeManifest(manifest);
+      await this.appendAndEmit(conversationId, { type: "conversation.unarchived", payload: { conversation: conv } }, manifest);
+      await writeManifest(this.paths, manifest);
+      return { conversation_id: conversationId, unarchived_at: now };
     });
   }
   async deleteConversations(conversationIds) {
@@ -8363,17 +8580,27 @@ var ConversationService = class extends EventEmitter4 {
       manifest.title = title;
       manifest.updated_at = (/* @__PURE__ */ new Date()).toISOString();
       await writeManifest(this.paths, manifest);
-      await this.appendAndEmit(conversationId, { type: "conversation.updated", payload: { conversation: this.summarizeManifest(manifest) } }, manifest);
+      const conv = this.summarizeManifest(manifest);
+      const event = await this.appendAndEmit(conversationId, { type: "conversation.updated", payload: { conversation: conv } }, manifest);
       await writeManifest(this.paths, manifest);
-      return { conversation_id: conversationId, title };
+      return { conversation_id: conversationId, title, conversation: conv, hermes_synced: false, last_event_seq: event.seq };
     });
   }
   async setConversationModel(conversationId, modelId) {
     return withConversationLock(conversationId, async () => {
       const manifest = await readActiveManifest(this.paths, conversationId);
+      if (manifest.stats) manifest.stats.model = modelId;
       manifest.updated_at = (/* @__PURE__ */ new Date()).toISOString();
       await writeManifest(this.paths, manifest);
-      return { conversation_id: conversationId, model_id: modelId };
+      const conv = this.summarizeManifest(manifest);
+      const event = await this.appendAndEmit(conversationId, { type: "conversation.updated", payload: { conversation: conv } }, manifest);
+      await writeManifest(this.paths, manifest);
+      return {
+        conversation_id: conversationId,
+        model_override: modelId,
+        runtime: this.buildRuntimeMetadata(manifest),
+        last_event_seq: event.seq
+      };
     });
   }
   async setConversationProfile(conversationId, profileName) {
@@ -8383,7 +8610,21 @@ var ConversationService = class extends EventEmitter4 {
       manifest.profile_name_snapshot = profileName;
       manifest.updated_at = (/* @__PURE__ */ new Date()).toISOString();
       await writeManifest(this.paths, manifest);
-      return { conversation_id: conversationId, profile: profileName };
+      const conv = this.summarizeManifest(manifest);
+      const event = await this.appendAndEmit(conversationId, { type: "conversation.updated", payload: { conversation: conv } }, manifest);
+      await writeManifest(this.paths, manifest);
+      return {
+        conversation_id: conversationId,
+        profile: {
+          uid: manifest.profile_uid ?? "",
+          name: profileName,
+          display_name: profileName,
+          avatar_url: null
+        },
+        runtime: this.buildRuntimeMetadata(manifest),
+        conversation: conv,
+        last_event_seq: event.seq
+      };
     });
   }
   async ackConversation(conversationId, lastEventSeq) {
@@ -8413,55 +8654,194 @@ var ConversationService = class extends EventEmitter4 {
     }
     return { deleted_count: count };
   }
-  async prepareClearAllConversationPlan() {
+  async shouldPublishNotificationEvent(event) {
+    const publishable = ["conversation.updated", "message.created", "run.started", "run.completed", "run.failed", "run.cancelled"];
+    return publishable.includes(event.type);
+  }
+  async prepareClearAllConversationPlan(targetStatus = "active") {
     const planId = `plan_${crypto4.randomUUID().replaceAll("-", "")}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
     const ids = await listConversationIds(this.paths);
-    const activeIds = [];
+    const targetIds = [];
     for (const id of ids) {
       const m = await readManifest(this.paths, id);
-      if (m && m.status === "active") activeIds.push(id);
+      if (m && m.status === targetStatus) targetIds.push(id);
     }
-    return {
+    const plan = {
       id: planId,
-      status: "pending",
-      conversation_count: activeIds.length,
-      conversation_ids: activeIds,
-      created_at: (/* @__PURE__ */ new Date()).toISOString()
+      status: "prepared",
+      target_status: targetStatus,
+      created_at: now,
+      updated_at: now,
+      total_count: targetIds.length,
+      deleted_count: 0,
+      failed_count: 0,
+      conversation_ids: targetIds,
+      conversations: []
     };
+    clearPlans.set(planId, plan);
+    return plan;
   }
   async readClearAllConversationPlan(planId) {
-    return { id: planId, status: "pending", conversation_count: 0, conversation_ids: [], created_at: (/* @__PURE__ */ new Date()).toISOString() };
+    const plan = clearPlans.get(planId);
+    if (!plan) throw new LinkHttpError(404, "plan_not_found", "Clear plan was not found");
+    return plan;
+  }
+  async executeClearAllConversationPlan(planId) {
+    return this.startClearAllConversationPlan(planId);
   }
   async startClearAllConversationPlan(planId) {
+    const plan = clearPlans.get(planId) ?? { id: planId, conversation_ids: [], total_count: 0 };
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    clearPlans.set(planId, { ...plan, status: "executing", updated_at: now });
+    const conversationIds = Array.isArray(plan.conversation_ids) ? plan.conversation_ids : [];
+    let deletedCount = 0, failedCount = 0;
+    const conversations = [];
+    for (const id of conversationIds) {
+      try {
+        const result = await this.deleteConversation(id);
+        conversations.push({ ...result, status: "deleted" });
+        deletedCount++;
+      } catch (err) {
+        failedCount++;
+        conversations.push({
+          conversation_id: id,
+          status: "failed",
+          error: { code: err instanceof LinkHttpError ? err.code : "internal_error", message: err.message }
+        });
+      }
+    }
+    const completed = {
+      ...plan,
+      status: "completed",
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      deleted_count: deletedCount,
+      failed_count: failedCount,
+      conversations
+    };
+    clearPlans.set(planId, completed);
+    return completed;
+  }
+  async prepareArchiveAllConversationPlan(input = {}) {
+    const planId = `plan_${crypto4.randomUUID().replaceAll("-", "")}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const excluded = new Set(input.excludeConversationIds ?? []);
     const ids = await listConversationIds(this.paths);
-    let count = 0;
+    const targetIds = [];
     for (const id of ids) {
+      if (excluded.has(id)) continue;
       const m = await readManifest(this.paths, id);
-      if (m && m.status === "active") {
-        await this.deleteConversation(id).catch(() => void 0);
-        count++;
+      if (m && m.status === "active") targetIds.push(id);
+    }
+    const plan = {
+      id: planId,
+      status: "prepared",
+      created_at: now,
+      updated_at: now,
+      total_count: targetIds.length,
+      archived_count: 0,
+      failed_count: 0,
+      conversation_ids: targetIds,
+      conversations: []
+    };
+    archivePlans.set(planId, plan);
+    return plan;
+  }
+  async readArchiveAllConversationPlan(planId) {
+    const plan = archivePlans.get(planId);
+    if (!plan) throw new LinkHttpError(404, "plan_not_found", "Archive plan was not found");
+    return plan;
+  }
+  async executeArchiveAllConversationPlan(planId) {
+    return this.startArchiveAllConversationPlan(planId);
+  }
+  async startArchiveAllConversationPlan(planId) {
+    const plan = archivePlans.get(planId) ?? { id: planId, conversation_ids: [], total_count: 0 };
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    archivePlans.set(planId, { ...plan, status: "executing", updated_at: now });
+    const conversationIds = Array.isArray(plan.conversation_ids) ? plan.conversation_ids : [];
+    let archivedCount = 0, failedCount = 0;
+    const conversations = [];
+    for (const id of conversationIds) {
+      try {
+        const result = await this.archiveConversation(id);
+        conversations.push({ ...result, status: "archived" });
+        archivedCount++;
+      } catch (err) {
+        failedCount++;
+        conversations.push({
+          conversation_id: id,
+          status: "failed",
+          error: { code: err instanceof LinkHttpError ? err.code : "internal_error", message: err.message }
+        });
       }
     }
-    return { id: planId, status: "completed", deleted_count: count, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+    const completed = {
+      ...plan,
+      status: "completed",
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      archived_count: archivedCount,
+      failed_count: failedCount,
+      conversations
+    };
+    archivePlans.set(planId, completed);
+    return completed;
   }
   async resolveApproval(input) {
-    return { conversation_id: input.conversationId, approval_id: input.approvalId, decision: input.decision };
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let lastEventSeq = 0;
+    try {
+      const m = await readManifest(this.paths, input.conversationId);
+      if (m) lastEventSeq = m.last_event_seq;
+    } catch {
+    }
+    return {
+      conversation_id: input.conversationId,
+      message_id: "",
+      approval: {
+        id: input.approvalId,
+        status: input.decision === "deny" ? "denied" : "approved",
+        kind: "terminal_command",
+        command: "",
+        choices: ["once", "session", "always", "deny"],
+        created_at: now,
+        resolved_at: now,
+        decision: input.decision,
+        resume_available: false
+      },
+      command_allowlist_updated: false,
+      requires_gateway_reload: false,
+      resume_available: false,
+      last_event_seq: lastEventSeq
+    };
   }
-  async getStatistics(options) {
+  async getStatistics(options = {}) {
     const ids = await listConversationIds(this.paths);
-    let total = 0, active = 0, messages = 0, runs = 0;
+    let total = 0, active = 0, archived = 0, deleted = 0;
+    let inputTokens = 0, outputTokens = 0, totalTokens = 0;
+    let messages = 0, runs = 0;
     for (const id of ids) {
       const m = await readManifest(this.paths, id);
       if (!m) continue;
       if (options.profileName && m.profile !== options.profileName) continue;
+      if (options.profileUid && m.profile_uid !== options.profileUid) continue;
       total++;
       if (m.status === "active") active++;
-      const snap = await readSnapshot(this.paths, id);
-      messages += snap.messages.length;
-      runs += snap.runs.filter((r) => r.kind === "agent").length;
+      else if (m.status === "archived") archived++;
+      else if (m.status === "deleted_soft") deleted++;
+      if (m.stats) {
+        inputTokens += m.stats.input_tokens;
+        outputTokens += m.stats.output_tokens;
+        totalTokens += m.stats.total_tokens;
+        messages += m.stats.message_count;
+        runs += m.stats.run_count;
+      }
     }
     return {
-      conversations: { total, active },
+      conversations: { total, active, archived, deleted },
+      tokens: { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: totalTokens },
       messages: { total: messages },
       runs: { total: runs },
       models: { total: 0 },
@@ -8470,20 +8850,6 @@ var ConversationService = class extends EventEmitter4 {
       profiles: { total: 0 }
     };
   }
-  summarizeManifest(manifest) {
-    return {
-      id: manifest.id,
-      kind: manifest.kind,
-      title: manifest.title,
-      status: manifest.status,
-      profile: manifest.profile,
-      profile_uid: manifest.profile_uid,
-      last_event_seq: manifest.last_event_seq,
-      created_at: manifest.created_at,
-      updated_at: manifest.updated_at,
-      stats: manifest.stats ?? null
-    };
-  }
 };
 
 // src/http/app.ts
@@ -8734,7 +9100,7 @@ async function buildPairingPage(options) {
           showStatus('success', '\u914D\u5BF9\u6210\u529F\uFF01');
           const results = document.getElementById('results');
           results.innerHTML = \`
-            <div class="result-row"><span class="tag">access_token \xB7 15min</span><div class="mono" onclick="copyText(this)">\${data.access_token.token}</div></div>
+            <div class="result-row"><span class="tag">access_token \xB7 2h</span><div class="mono" onclick="copyText(this)">\${data.access_token.token}</div></div>
             <div class="result-row" style="margin-top:0.5rem"><span class="tag">refresh_token \xB7 90days</span><div class="mono" onclick="copyText(this)">\${data.refresh_token.token}</div></div>
           \`;
         } else {

package/dist/cli/index.js

@@ -21,7 +21,7 @@ import {
   saveConfig,
   startLinkService,
   writeJsonFile
-} from "../chunk-AA2LZ6QZ.js";
+} from "../chunk-YNBTALOX.js";
 import "../chunk-NP3Y2NVF.js";
 
 // src/cli/index.ts

package/dist/http/app.js

@@ -1,6 +1,6 @@
 import {
   startLinkService
-} from "../chunk-AA2LZ6QZ.js";
+} from "../chunk-YNBTALOX.js";
 import "../chunk-NP3Y2NVF.js";
 export {
   startLinkService