@integrity-labs/agt-cli 0.28.220 → 0.28.222

package/dist/mcp/direct-chat-channel.js

@@ -14303,7 +14303,16 @@ function readLockHolder(path) {
 // src/direct-chat-channel.ts
 import { homedir as homedir2 } from "os";
 import { join as join5 } from "path";
-import { watch, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { randomUUID } from "crypto";
+import {
+  watch,
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync4,
+  existsSync as existsSync4,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync2
+} from "fs";
 
 // src/direct-chat-inbound-attachments.ts
 import { dirname as dirname2, join as join3 } from "path";
@@ -14492,6 +14501,215 @@ function computeStreamSlices(content, config2 = DEFAULT_STREAM_SLICE_CONFIG) {
   return slices;
 }
 
+// src/channel-progress.ts
+function channelLiveProgressEnabled() {
+  return resolveHostBooleanFlag({
+    key: "channel-live-progress",
+    envVar: "AGT_CHANNEL_PROGRESS_ENABLED",
+    defaultValue: false
+  });
+}
+function decideProgressAction(input) {
+  const { now, heartbeat, target, tracked, freshnessMs, minPendingMs } = input;
+  const fresh = heartbeat != null && now - heartbeat.updatedAtMs <= freshnessMs;
+  const active = target != null && fresh;
+  if (active && input.targetHasCard === true) {
+    if (tracked) {
+      return { type: "delete", channel: tracked.channel, threadTs: tracked.threadTs, ts: tracked.ts };
+    }
+    return { type: "none" };
+  }
+  if (!active) {
+    if (tracked) {
+      return { type: "delete", channel: tracked.channel, threadTs: tracked.threadTs, ts: tracked.ts };
+    }
+    return { type: "none" };
+  }
+  const t = target;
+  const hb = heartbeat;
+  if (tracked && (tracked.threadTs !== t.threadTs || tracked.channel !== t.channel)) {
+    return { type: "delete", channel: tracked.channel, threadTs: tracked.threadTs, ts: tracked.ts };
+  }
+  if (!tracked) {
+    if (now - t.receivedAtMs < minPendingMs) return { type: "none" };
+    return { type: "post", channel: t.channel, threadTs: t.threadTs, step: hb.step };
+  }
+  if (hb.step !== tracked.lastStep) {
+    return { type: "update", channel: t.channel, threadTs: t.threadTs, ts: tracked.ts, step: hb.step };
+  }
+  return { type: "none" };
+}
+function progressHeartbeatFreshMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_PROGRESS_FRESH_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 45e3;
+}
+function progressMinPendingMs() {
+  const raw = parseInt(process.env.AGT_CHANNEL_PROGRESS_MIN_PENDING_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 12e3;
+}
+function composeProgressBody(step) {
+  const s = (step ?? "").trim();
+  if (!s) return "Working\u2026";
+  if (/^working/i.test(s)) return s;
+  return `Working\u2026 \xB7 ${s}`;
+}
+function parseProgressHeartbeat(raw) {
+  if (!raw) return null;
+  try {
+    const obj = JSON.parse(raw);
+    const step = typeof obj.step === "string" ? obj.step.trim() : "";
+    const updatedAtMs = typeof obj.updated_at_ms === "number" ? obj.updated_at_ms : NaN;
+    if (!step || !Number.isFinite(updatedAtMs)) return null;
+    return { step, updatedAtMs };
+  } catch {
+    return null;
+  }
+}
+var SEED_PROGRESS_STEP = "Working\u2026";
+function serializeProgressHeartbeat(step, nowMs) {
+  return JSON.stringify({ step, updated_at_ms: nowMs });
+}
+
+// src/direct-chat-progress.ts
+async function runDirectChatProgressTick(deps, state) {
+  if (!deps.enabled()) {
+    const t = state.tracked;
+    if (t) {
+      if (await deps.clear(t.channel, t.ts)) state.tracked = null;
+      return { type: "delete", channel: t.channel, threadTs: t.threadTs, ts: t.ts };
+    }
+    return { type: "none" };
+  }
+  const baseInput = {
+    now: deps.now(),
+    heartbeat: deps.readHeartbeat(),
+    target: deps.resolveTarget(),
+    tracked: state.tracked,
+    freshnessMs: deps.freshnessMs,
+    minPendingMs: deps.minPendingMs
+  };
+  let action = decideProgressAction(baseInput);
+  if (deps.isCardActive && baseInput.target && (action.type === "post" || action.type === "update" || action.type === "none" && state.tracked)) {
+    if (await deps.isCardActive(baseInput.target.threadTs)) {
+      action = decideProgressAction({ ...baseInput, targetHasCard: true });
+    }
+  }
+  switch (action.type) {
+    case "post": {
+      const id = await deps.post(action.channel, action.step);
+      if (id) {
+        state.tracked = { channel: action.channel, threadTs: action.threadTs, ts: id, lastStep: action.step };
+      }
+      break;
+    }
+    case "update": {
+      if (await deps.update(action.channel, action.ts, action.step)) {
+        if (state.tracked) state.tracked.lastStep = action.step;
+      }
+      break;
+    }
+    case "delete": {
+      if (await deps.clear(action.channel, action.ts)) state.tracked = null;
+      break;
+    }
+    case "none":
+      break;
+  }
+  return action;
+}
+function resolveDirectChatProgressTarget(receivedAt, stillOwed) {
+  let best = null;
+  let bestMs = Infinity;
+  for (const [sessionId, ms] of receivedAt) {
+    if (!stillOwed(sessionId)) {
+      receivedAt.delete(sessionId);
+      continue;
+    }
+    if (ms < bestMs) {
+      bestMs = ms;
+      best = { channel: sessionId, threadTs: sessionId, receivedAtMs: ms };
+    }
+  }
+  return best;
+}
+
+// src/kanban-card-active-client.ts
+var REQUEST_TIMEOUT_MS2 = 8e3;
+var POSITIVE_TTL_MS = 10 * 6e4;
+var NEGATIVE_TTL_MS = 15e3;
+function createKanbanCardActiveClient(args) {
+  if (!args.agtHost || !args.agtApiKey || !args.agentId) return null;
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const now = args.now ?? (() => Date.now());
+  const positiveTtlMs = args.positiveTtlMs ?? POSITIVE_TTL_MS;
+  const negativeTtlMs = args.negativeTtlMs ?? NEGATIVE_TTL_MS;
+  const log = args.log ?? (() => {
+  });
+  const base = args.agtHost.replace(/\/+$/, "");
+  const agentId = args.agentId;
+  const apiKey = args.agtApiKey;
+  const cache = /* @__PURE__ */ new Map();
+  let cachedToken = null;
+  let cachedTokenExpiresAt = 0;
+  async function getToken() {
+    if (cachedToken && now() < cachedTokenExpiresAt) return cachedToken;
+    const resp = await fetchImpl(`${base}/host/exchange`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ host_key: apiKey }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`/host/exchange failed (${resp.status}): ${body.slice(0, 200)}`);
+    }
+    const data = await resp.json();
+    cachedToken = data.token;
+    cachedTokenExpiresAt = data.expires_at ? new Date(data.expires_at).getTime() - 12e4 : now() + 55 * 6e4;
+    return cachedToken;
+  }
+  async function queryOnce(sourceIntegration, sourceExternalId) {
+    const token = await getToken();
+    const qs = new URLSearchParams({
+      agent_id: agentId,
+      source_integration: sourceIntegration,
+      source_external_id: sourceExternalId
+    });
+    return fetchImpl(`${base}/host/kanban/progress-card-active?${qs.toString()}`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+  }
+  async function query(sourceIntegration, sourceExternalId) {
+    let resp = await queryOnce(sourceIntegration, sourceExternalId);
+    if (resp.status === 401) {
+      cachedToken = null;
+      cachedTokenExpiresAt = 0;
+      resp = await queryOnce(sourceIntegration, sourceExternalId);
+    }
+    if (!resp.ok) return false;
+    const data = await resp.json();
+    return data.active === true;
+  }
+  return {
+    async isCardActive(sourceIntegration, sourceExternalId) {
+      const key = `${sourceIntegration}:${sourceExternalId}`;
+      const t = now();
+      const hit = cache.get(key);
+      if (hit && t < hit.expiresAt) return hit.active;
+      try {
+        const active = await query(sourceIntegration, sourceExternalId);
+        cache.set(key, { active, expiresAt: t + (active ? positiveTtlMs : negativeTtlMs) });
+        return active;
+      } catch (err) {
+        log(`kanban-card-active: query threw key=${key}: ${err.message}`);
+        return false;
+      }
+    }
+  };
+}
+
 // src/maintenance-mode.ts
 var FLAG_KEY = "platform-maintenance-mode";
 var MAINTENANCE_OFFLINE_MESSAGE = "The Augmented Team platform is offline for scheduled maintenance right now, so I can't pick this up \u2014 please try again shortly.";
@@ -14535,6 +14753,117 @@ var INBOUND_ATTACHMENTS_DIR = resolveInboundAttachmentsDir({
   agentId: AGT_AGENT_ID,
   homeDir: homedir2()
 });
+var AGT_AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME;
+var PROGRESS_HEARTBEAT_PATH = AGT_AGENT_CODE_NAME ? join5(homedir2(), ".augmented", AGT_AGENT_CODE_NAME, "channel-progress-heartbeat.json") : null;
+var progressReceivedAt = /* @__PURE__ */ new Map();
+var directChatProgressState = { tracked: null };
+var directChatProgressTickRunning = false;
+var PROGRESS_PREFIX = "\u23F3";
+var PROGRESS_TICK_MS = (() => {
+  const raw = parseInt(process.env.AGT_CHANNEL_PROGRESS_TICK_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 3e3;
+})();
+var directChatKanbanCardClient = createKanbanCardActiveClient({
+  agtHost: AGT_HOST ?? null,
+  agtApiKey: AGT_API_KEY ?? null,
+  agentId: AGT_AGENT_ID ?? null,
+  log: (line) => process.stderr.write(`direct-chat-channel: ${line}
+`)
+});
+function readProgressHeartbeat() {
+  if (!PROGRESS_HEARTBEAT_PATH || !existsSync4(PROGRESS_HEARTBEAT_PATH)) return null;
+  try {
+    return parseProgressHeartbeat(readFileSync4(PROGRESS_HEARTBEAT_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function seedProgressHeartbeat() {
+  if (!PROGRESS_HEARTBEAT_PATH) return;
+  const tmp = `${PROGRESS_HEARTBEAT_PATH}.${process.pid}.tmp`;
+  try {
+    mkdirSync3(join5(homedir2(), ".augmented", AGT_AGENT_CODE_NAME), { recursive: true });
+    writeFileSync3(tmp, serializeProgressHeartbeat(SEED_PROGRESS_STEP, Date.now()), { mode: 384 });
+    renameSync3(tmp, PROGRESS_HEARTBEAT_PATH);
+  } catch {
+    try {
+      unlinkSync2(tmp);
+    } catch {
+    }
+  }
+}
+async function postDirectChatProgress(sessionId, step) {
+  const messageId = `progress:${randomUUID()}`;
+  try {
+    const res = await apiPost("/host/direct-chat/progress", {
+      agent_id: AGT_AGENT_ID,
+      session_id: sessionId,
+      message_id: messageId,
+      action: "post",
+      content: `${PROGRESS_PREFIX} ${composeProgressBody(step)}`
+    });
+    if (!res.ok) return null;
+    const data = await res.json().catch(() => ({}));
+    return data.error == null ? messageId : null;
+  } catch {
+    return null;
+  }
+}
+async function updateDirectChatProgress(sessionId, messageId, step) {
+  try {
+    const res = await apiPost("/host/direct-chat/progress", {
+      agent_id: AGT_AGENT_ID,
+      session_id: sessionId,
+      message_id: messageId,
+      action: "update",
+      content: `${PROGRESS_PREFIX} ${composeProgressBody(step)}`
+    });
+    if (!res.ok) return false;
+    const data = await res.json().catch(() => ({}));
+    return data.error == null;
+  } catch {
+    return false;
+  }
+}
+async function clearDirectChatProgress(sessionId, messageId) {
+  try {
+    const res = await apiPost("/host/direct-chat/progress", {
+      agent_id: AGT_AGENT_ID,
+      session_id: sessionId,
+      message_id: messageId,
+      action: "clear"
+    });
+    if (!res.ok) return false;
+    const data = await res.json().catch(() => ({}));
+    return data.error == null;
+  } catch {
+    return false;
+  }
+}
+async function directChatProgressTick() {
+  if (directChatProgressTickRunning) return;
+  directChatProgressTickRunning = true;
+  try {
+    await runDirectChatProgressTick(
+      {
+        enabled: channelLiveProgressEnabled,
+        readHeartbeat: readProgressHeartbeat,
+        resolveTarget: () => resolveDirectChatProgressTarget(progressReceivedAt, (sid) => claimTracker.peek(sid).length > 0),
+        freshnessMs: progressHeartbeatFreshMs(),
+        minPendingMs: progressMinPendingMs(),
+        now: Date.now,
+        post: postDirectChatProgress,
+        update: updateDirectChatProgress,
+        clear: clearDirectChatProgress,
+        ...directChatKanbanCardClient ? { isCardActive: (sid) => directChatKanbanCardClient.isCardActive("direct-chat", sid) } : {}
+      },
+      directChatProgressState
+    );
+  } catch {
+  } finally {
+    directChatProgressTickRunning = false;
+  }
+}
 var inboundContextClient = createInboundContextClient({
   agtHost: AGT_HOST ?? null,
   agtApiKey: AGT_API_KEY ?? null,
@@ -14891,6 +15220,10 @@ async function pollForMessages(sinceMs) {
       if (!isNotice && !maintenanceActive) {
         markProcessed(msg.id);
         claimTracker.track(msg.session_id, msg.id);
+        if (!progressReceivedAt.has(msg.session_id)) {
+          progressReceivedAt.set(msg.session_id, Date.now());
+        }
+        seedProgressHeartbeat();
       }
       if (maintenanceActive) {
         const throttleKey = `${msg.session_id}|maintenance`;
@@ -15070,6 +15403,13 @@ if (DOORBELL_ENABLED && DIRECT_CHAT_AGENT_DIR) {
 `
   );
 }
+var progressTickTimer = null;
+if (PROGRESS_HEARTBEAT_PATH) {
+  progressTickTimer = setInterval(() => {
+    void directChatProgressTick();
+  }, PROGRESS_TICK_MS);
+  progressTickTimer.unref?.();
+}
 var isShuttingDown = false;
 function shutdown(reason) {
   if (isShuttingDown) return;
@@ -15081,6 +15421,7 @@ function shutdown(reason) {
   } catch {
   }
   if (safetyNetTimer) clearInterval(safetyNetTimer);
+  if (progressTickTimer) clearInterval(progressTickTimer);
   try {
     releaseMcpSpawnLock(acquiredLockPath);
   } catch {

package/dist/{persistent-session-S2REZDHF.js → persistent-session-M4ZTLCDP.js}

@@ -36,7 +36,7 @@ import {
   writeDirectChatSessionState,
   writeEgressAllowlist,
   writePersistentClaudeWrapper
-} from "./chunk-M2PGJQP3.js";
+} from "./chunk-B3E4B7JF.js";
 import "./chunk-XWVM4KPK.js";
 export {
   EGRESS_BASELINE_DOMAINS,
@@ -77,4 +77,4 @@ export {
   writeEgressAllowlist,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-S2REZDHF.js.map
+//# sourceMappingURL=persistent-session-M4ZTLCDP.js.map

package/dist/{responsiveness-probe-BHFLFXY5.js → responsiveness-probe-E25HFGJL.js}

@@ -1,6 +1,6 @@
 import {
   paneLogPath
-} from "./chunk-M2PGJQP3.js";
+} from "./chunk-B3E4B7JF.js";
 import "./chunk-XWVM4KPK.js";
 
 // src/lib/responsiveness-probe.ts
@@ -303,4 +303,4 @@ export {
   readAndResetChannelDeflections,
   readAndResetChannelLaneClassifications
 };
-//# sourceMappingURL=responsiveness-probe-BHFLFXY5.js.map
+//# sourceMappingURL=responsiveness-probe-E25HFGJL.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.28.220",
+  "version": "0.28.222",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {