jialing-code 1.1.0

package/dist/chunk-e4q49asn.js

@@ -0,0 +1,155 @@
+// @bun
+import {
+  AGENT_COLORS,
+  getTranscriptPath,
+  init_agentColorManager,
+  init_sessionStorage,
+  saveAgentColor
+} from "./chunk-ewsgsw9h.js";
+import"./chunk-z1zj044v.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-key6jr7p.js";
+import"./chunk-0m2861gw.js";
+import"./chunk-0x9b2nmd.js";
+import"./chunk-89e1v45e.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-x679thag.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-msjfc5ba.js";
+import"./chunk-7zsapntc.js";
+import"./chunk-0rg6yrhy.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-x0mwzt38.js";
+import"./chunk-9e2kqv5g.js";
+import"./chunk-1qakq4sn.js";
+import"./chunk-s9mesaw0.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-tw0q7ynt.js";
+import"./chunk-xe9cc860.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-ygbf0ezx.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-7sb5axvf.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-3f7rypmf.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import {
+  init_teammate,
+  isTeammate
+} from "./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-1eapde8a.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/color/color.ts
+async function call(onDone, context, args) {
+  if (isTeammate()) {
+    onDone("Cannot set color: This session is a swarm teammate. Teammate colors are assigned by the team leader.", { display: "system" });
+    return null;
+  }
+  if (!args || args.trim() === "") {
+    const colorList = AGENT_COLORS.join(", ");
+    onDone(`Please provide a color. Available colors: ${colorList}, default`, {
+      display: "system"
+    });
+    return null;
+  }
+  const colorArg = args.trim().toLowerCase();
+  if (RESET_ALIASES.includes(colorArg)) {
+    const sessionId2 = getSessionId();
+    const fullPath2 = getTranscriptPath();
+    await saveAgentColor(sessionId2, "default", fullPath2);
+    context.setAppState((prev) => ({
+      ...prev,
+      standaloneAgentContext: {
+        ...prev.standaloneAgentContext,
+        name: prev.standaloneAgentContext?.name ?? "",
+        color: undefined
+      }
+    }));
+    onDone("Session color reset to default", { display: "system" });
+    return null;
+  }
+  if (!AGENT_COLORS.includes(colorArg)) {
+    const colorList = AGENT_COLORS.join(", ");
+    onDone(`Invalid color "${colorArg}". Available colors: ${colorList}, default`, { display: "system" });
+    return null;
+  }
+  const sessionId = getSessionId();
+  const fullPath = getTranscriptPath();
+  await saveAgentColor(sessionId, colorArg, fullPath);
+  context.setAppState((prev) => ({
+    ...prev,
+    standaloneAgentContext: {
+      ...prev.standaloneAgentContext,
+      name: prev.standaloneAgentContext?.name ?? "",
+      color: colorArg
+    }
+  }));
+  onDone(`Session color set to: ${colorArg}`, { display: "system" });
+  return null;
+}
+var RESET_ALIASES;
+var init_color = __esm(() => {
+  init_state();
+  init_agentColorManager();
+  init_sessionStorage();
+  init_teammate();
+  RESET_ALIASES = ["default", "reset", "none", "gray", "grey"];
+});
+init_color();
+
+export {
+  call
+};

package/dist/chunk-e5pntxye.js

@@ -0,0 +1,37 @@
+// @bun
+import {
+  cacheKeys,
+  init_fileStateCache
+} from "./chunk-9gbamk79.js";
+import"./chunk-qnfx3qtx.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/files/files.ts
+import { relative } from "path";
+async function call(_args, context) {
+  const files = context.readFileState ? cacheKeys(context.readFileState) : [];
+  if (files.length === 0) {
+    return { type: "text", value: "No files in context" };
+  }
+  const fileList = files.map((file) => relative(getCwd(), file)).join(`
+`);
+  return { type: "text", value: `Files in context:
+${fileList}` };
+}
+var init_files = __esm(() => {
+  init_cwd();
+  init_fileStateCache();
+});
+init_files();
+
+export {
+  call
+};

package/dist/chunk-e7393td6.js

@@ -0,0 +1,42 @@
+// @bun
+import {
+  init_browser,
+  openBrowser
+} from "./chunk-m06q12hg.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/stickers/stickers.ts
+async function call() {
+  const url = "https://www.stickermule.com/claudecode";
+  const success = await openBrowser(url);
+  if (success) {
+    return { type: "text", value: "Opening sticker page in browser\u2026" };
+  } else {
+    return {
+      type: "text",
+      value: `Failed to open browser. Visit: ${url}`
+    };
+  }
+}
+var init_stickers = __esm(() => {
+  init_browser();
+});
+init_stickers();
+
+export {
+  call
+};

package/dist/chunk-ead42yrh.js

@@ -0,0 +1,87 @@
+// @bun
+import {
+  addFlaggedPlugin,
+  getFlaggedPlugins,
+  init_pluginFlagging,
+  loadFlaggedPlugins
+} from "./chunk-5kbt1mbt.js";
+import {
+  init_pluginOperations,
+  uninstallPluginOp
+} from "./chunk-z7ycmrb3.js";
+import {
+  getMarketplace,
+  init_installedPluginsManager,
+  init_marketplaceManager,
+  loadInstalledPluginsV2,
+  loadKnownMarketplacesConfigSafe
+} from "./chunk-ewsgsw9h.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+
+// src/utils/plugins/pluginBlocklist.ts
+init_pluginOperations();
+init_debug();
+init_errors();
+init_installedPluginsManager();
+init_marketplaceManager();
+init_pluginFlagging();
+function detectDelistedPlugins(installedPlugins, marketplace, marketplaceName) {
+  const marketplacePluginNames = new Set(marketplace.plugins.map((p) => p.name));
+  const suffix = `@${marketplaceName}`;
+  const delisted = [];
+  for (const pluginId of Object.keys(installedPlugins.plugins)) {
+    if (!pluginId.endsWith(suffix))
+      continue;
+    const pluginName = pluginId.slice(0, -suffix.length);
+    if (!marketplacePluginNames.has(pluginName)) {
+      delisted.push(pluginId);
+    }
+  }
+  return delisted;
+}
+async function detectAndUninstallDelistedPlugins() {
+  await loadFlaggedPlugins();
+  const installedPlugins = loadInstalledPluginsV2();
+  const alreadyFlagged = getFlaggedPlugins();
+  const knownMarketplaces = await loadKnownMarketplacesConfigSafe();
+  const newlyFlagged = [];
+  for (const marketplaceName of Object.keys(knownMarketplaces)) {
+    try {
+      const marketplace = await getMarketplace(marketplaceName);
+      if (!marketplace.forceRemoveDeletedPlugins)
+        continue;
+      const delisted = detectDelistedPlugins(installedPlugins, marketplace, marketplaceName);
+      for (const pluginId of delisted) {
+        if (pluginId in alreadyFlagged)
+          continue;
+        const installations = installedPlugins.plugins[pluginId] ?? [];
+        const hasUserInstall = installations.some((i) => i.scope === "user" || i.scope === "project" || i.scope === "local");
+        if (!hasUserInstall)
+          continue;
+        for (const installation of installations) {
+          const { scope } = installation;
+          if (scope !== "user" && scope !== "project" && scope !== "local") {
+            continue;
+          }
+          try {
+            await uninstallPluginOp(pluginId, scope);
+          } catch (error) {
+            logForDebugging(`Failed to auto-uninstall delisted plugin ${pluginId} from ${scope}: ${errorMessage(error)}`, { level: "error" });
+          }
+        }
+        await addFlaggedPlugin(pluginId);
+        newlyFlagged.push(pluginId);
+      }
+    } catch (error) {
+      logForDebugging(`Failed to check for delisted plugins in "${marketplaceName}": ${errorMessage(error)}`, { level: "warn" });
+    }
+  }
+  return newlyFlagged;
+}
+
+export { detectAndUninstallDelistedPlugins };

package/dist/chunk-eb90vwvr.js

@@ -0,0 +1,152 @@
+// @bun
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-hrzerbfw.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonParse,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+
+// src/bridge/jwtUtils.ts
+init_analytics();
+init_debug();
+init_diagLogs();
+init_errors();
+init_slowOperations();
+function formatDuration(ms) {
+  if (ms < 60000)
+    return `${Math.round(ms / 1000)}s`;
+  const m = Math.floor(ms / 60000);
+  const s = Math.round(ms % 60000 / 1000);
+  return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
+function decodeJwtPayload(token) {
+  const jwt = token.startsWith("sk-ant-si-") ? token.slice("sk-ant-si-".length) : token;
+  const parts = jwt.split(".");
+  if (parts.length !== 3 || !parts[1])
+    return null;
+  try {
+    return jsonParse(Buffer.from(parts[1], "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function decodeJwtExpiry(token) {
+  const payload = decodeJwtPayload(token);
+  if (payload !== null && typeof payload === "object" && "exp" in payload && typeof payload.exp === "number") {
+    return payload.exp;
+  }
+  return null;
+}
+var TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+var FALLBACK_REFRESH_INTERVAL_MS = 30 * 60 * 1000;
+var MAX_REFRESH_FAILURES = 3;
+var REFRESH_RETRY_DELAY_MS = 60000;
+function createTokenRefreshScheduler({
+  getAccessToken,
+  onRefresh,
+  label,
+  refreshBufferMs = TOKEN_REFRESH_BUFFER_MS
+}) {
+  const timers = new Map;
+  const failureCounts = new Map;
+  const generations = new Map;
+  function nextGeneration(sessionId) {
+    const gen = (generations.get(sessionId) ?? 0) + 1;
+    generations.set(sessionId, gen);
+    return gen;
+  }
+  function schedule(sessionId, token) {
+    const expiry = decodeJwtExpiry(token);
+    if (!expiry) {
+      logForDebugging(`[${label}:token] Could not decode JWT expiry for sessionId=${sessionId}, token prefix=${token.slice(0, 15)}\u2026, keeping existing timer`);
+      return;
+    }
+    const existing = timers.get(sessionId);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const gen = nextGeneration(sessionId);
+    const expiryDate = new Date(expiry * 1000).toISOString();
+    const delayMs = expiry * 1000 - Date.now() - refreshBufferMs;
+    if (delayMs <= 0) {
+      logForDebugging(`[${label}:token] Token for sessionId=${sessionId} expires=${expiryDate} (past or within buffer), refreshing immediately`);
+      doRefresh(sessionId, gen);
+      return;
+    }
+    logForDebugging(`[${label}:token] Scheduled token refresh for sessionId=${sessionId} in ${formatDuration(delayMs)} (expires=${expiryDate}, buffer=${refreshBufferMs / 1000}s)`);
+    const timer = setTimeout(doRefresh, delayMs, sessionId, gen);
+    timers.set(sessionId, timer);
+  }
+  function scheduleFromExpiresIn(sessionId, expiresInSeconds) {
+    const existing = timers.get(sessionId);
+    if (existing)
+      clearTimeout(existing);
+    const gen = nextGeneration(sessionId);
+    const delayMs = Math.max(expiresInSeconds * 1000 - refreshBufferMs, 30000);
+    logForDebugging(`[${label}:token] Scheduled token refresh for sessionId=${sessionId} in ${formatDuration(delayMs)} (expires_in=${expiresInSeconds}s, buffer=${refreshBufferMs / 1000}s)`);
+    const timer = setTimeout(doRefresh, delayMs, sessionId, gen);
+    timers.set(sessionId, timer);
+  }
+  async function doRefresh(sessionId, gen) {
+    let oauthToken;
+    try {
+      oauthToken = await getAccessToken();
+    } catch (err) {
+      logForDebugging(`[${label}:token] getAccessToken threw for sessionId=${sessionId}: ${errorMessage(err)}`, { level: "error" });
+    }
+    if (generations.get(sessionId) !== gen) {
+      logForDebugging(`[${label}:token] doRefresh for sessionId=${sessionId} stale (gen ${gen} vs ${generations.get(sessionId)}), skipping`);
+      return;
+    }
+    if (!oauthToken) {
+      const failures = (failureCounts.get(sessionId) ?? 0) + 1;
+      failureCounts.set(sessionId, failures);
+      logForDebugging(`[${label}:token] No OAuth token available for refresh, sessionId=${sessionId} (failure ${failures}/${MAX_REFRESH_FAILURES})`, { level: "error" });
+      logForDiagnosticsNoPII("error", "bridge_token_refresh_no_oauth");
+      if (failures < MAX_REFRESH_FAILURES) {
+        const retryTimer = setTimeout(doRefresh, REFRESH_RETRY_DELAY_MS, sessionId, gen);
+        timers.set(sessionId, retryTimer);
+      }
+      return;
+    }
+    failureCounts.delete(sessionId);
+    logForDebugging(`[${label}:token] Refreshing token for sessionId=${sessionId}: new token prefix=${oauthToken.slice(0, 15)}\u2026`);
+    logEvent("tengu_bridge_token_refreshed", {});
+    onRefresh(sessionId, oauthToken);
+    const timer = setTimeout(doRefresh, FALLBACK_REFRESH_INTERVAL_MS, sessionId, gen);
+    timers.set(sessionId, timer);
+    logForDebugging(`[${label}:token] Scheduled follow-up refresh for sessionId=${sessionId} in ${formatDuration(FALLBACK_REFRESH_INTERVAL_MS)}`);
+  }
+  function cancel(sessionId) {
+    nextGeneration(sessionId);
+    const timer = timers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      timers.delete(sessionId);
+    }
+    failureCounts.delete(sessionId);
+  }
+  function cancelAll() {
+    for (const sessionId of generations.keys()) {
+      nextGeneration(sessionId);
+    }
+    for (const timer of timers.values()) {
+      clearTimeout(timer);
+    }
+    timers.clear();
+    failureCounts.clear();
+  }
+  return { schedule, scheduleFromExpiresIn, cancel, cancelAll };
+}
+
+export { decodeJwtExpiry, createTokenRefreshScheduler };