@mmmbuto/qwen-code-termux 0.16.1-termux → 0.18.0-termux

package/chunks/scheduler-5VOOYGBH.js

@@ -0,0 +1,308 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  msSinceLastInteraction
+} from "./chunk-MRO43B25.js";
+import {
+  FILE_HISTORY_DIR
+} from "./chunk-TD4OPI4T.js";
+import "./chunk-K5PGHDBN.js";
+import "./chunk-XBY7E2FX.js";
+import "./chunk-SKBPNJEW.js";
+import "./chunk-NVFMZBX2.js";
+import "./chunk-O4PICXES.js";
+import "./chunk-TW522KN6.js";
+import "./chunk-3DHXZ6EV.js";
+import "./chunk-J5MDQKJL.js";
+import "./chunk-MLZQVCF3.js";
+import "./chunk-LD2XBG6Z.js";
+import "./chunk-OHEGWO4L.js";
+import "./chunk-SNGELLWX.js";
+import "./chunk-77WXWU44.js";
+import "./chunk-A7B4ISQP.js";
+import "./chunk-OQ7NJIY7.js";
+import "./chunk-3PJXIDKI.js";
+import "./chunk-UWCTAVOD.js";
+import "./chunk-OFEVLU4C.js";
+import "./chunk-3HTIVKZE.js";
+import "./chunk-IDX6COTE.js";
+import "./chunk-KQJMQJPI.js";
+import "./chunk-D3RHSPAS.js";
+import "./chunk-2Y5SYSD3.js";
+import "./chunk-SEGYWKIH.js";
+import "./chunk-64WXLC72.js";
+import "./chunk-B7HXHOHU.js";
+import "./chunk-EYENRK4D.js";
+import "./chunk-M6VTDSVR.js";
+import "./chunk-55ZMG67I.js";
+import "./chunk-H6BD2ELD.js";
+import "./chunk-5IFG2VC4.js";
+import {
+  Storage,
+  createDebugLogger
+} from "./chunk-HR7SV7AY.js";
+import "./chunk-ZERZSAZL.js";
+import "./chunk-QN5NZ3UQ.js";
+import "./chunk-BR4QREVK.js";
+import "./chunk-Z2Z3GUXZ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/housekeeping/scheduler.ts
+init_esbuild_shims();
+import { stat as stat3 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// packages/cli/src/utils/housekeeping/cleanup.ts
+init_esbuild_shims();
+import { readdir, stat, rm, rmdir } from "node:fs/promises";
+import { join } from "node:path";
+var debugLogger = createDebugLogger("HOUSEKEEPING");
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var MS_PER_HOUR = 60 * 60 * 1e3;
+var SWEEP_CONCURRENCY = 20;
+function getCutoffDate(cleanupPeriodDays) {
+  const periodMs = cleanupPeriodDays > 0 ? cleanupPeriodDays * MS_PER_DAY : MS_PER_HOUR;
+  return new Date(Date.now() - periodMs);
+}
+__name(getCutoffDate, "getCutoffDate");
+async function cleanupOldFileHistoryBackups(opts) {
+  const result = { removed: 0, errors: 0 };
+  const root = join(Storage.getGlobalQwenDir(), FILE_HISTORY_DIR);
+  const excludes = opts.excludeSessionIds ?? /* @__PURE__ */ new Set();
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch (e) {
+    if (isENOENT(e)) return result;
+    debugLogger.error("readdir failed", e);
+    return result;
+  }
+  const sessionDirs = entries.filter((e) => e.isDirectory() && !excludes.has(e.name)).map((e) => join(root, e.name));
+  for (let i = 0; i < sessionDirs.length; i += SWEEP_CONCURRENCY) {
+    const batch = sessionDirs.slice(i, i + SWEEP_CONCURRENCY);
+    await Promise.all(
+      batch.map(async (dir) => {
+        try {
+          const s = await stat(dir);
+          if (s.mtime < opts.cutoffDate) {
+            await rm(dir, { recursive: true, force: true });
+            result.removed++;
+          }
+        } catch (err) {
+          result.errors++;
+          debugLogger.error(`failed to sweep ${dir}`, err);
+        }
+      })
+    );
+  }
+  await rmdir(root).catch(() => {
+  });
+  return result;
+}
+__name(cleanupOldFileHistoryBackups, "cleanupOldFileHistoryBackups");
+function isENOENT(e) {
+  return e?.code === "ENOENT";
+}
+__name(isENOENT, "isENOENT");
+
+// packages/cli/src/utils/housekeeping/throttledOnce.ts
+init_esbuild_shims();
+import { mkdir, open, stat as stat2, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+var debugLogger2 = createDebugLogger("HOUSEKEEPING");
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var STALE_LOCK_MS = 60 * 60 * 1e3;
+async function runThrottledOnce(opts, task) {
+  const minIntervalMs = opts.minIntervalMs ?? ONE_DAY_MS;
+  const staleLockMs = opts.staleLockMs ?? STALE_LOCK_MS;
+  await mkdir(dirname(opts.lockPath), { recursive: true, mode: 448 }).catch(
+    () => {
+    }
+  );
+  if (await markerIsFresh(opts.markerPath, minIntervalMs, opts.name)) {
+    return false;
+  }
+  let acquired = await tryAcquire(opts.lockPath);
+  if (!acquired) {
+    try {
+      const s = await stat2(opts.lockPath);
+      if (Date.now() - s.mtimeMs > staleLockMs) {
+        await unlink(opts.lockPath).catch(() => {
+        });
+        acquired = await tryAcquire(opts.lockPath);
+      }
+    } catch {
+      acquired = await tryAcquire(opts.lockPath);
+    }
+    if (!acquired) {
+      debugLogger2.debug(`${opts.name}: skipping, lock held`);
+      return false;
+    }
+  }
+  try {
+    if (await markerIsFresh(opts.markerPath, minIntervalMs, opts.name)) {
+      return false;
+    }
+    let taskCompleted = false;
+    try {
+      await task();
+      taskCompleted = true;
+    } finally {
+      if (taskCompleted) {
+        try {
+          await writeFile(opts.markerPath, (/* @__PURE__ */ new Date()).toISOString());
+        } catch (err) {
+          debugLogger2.debug(
+            `${opts.name}: marker write failed (cleanup succeeded)`,
+            err
+          );
+        }
+      }
+    }
+    return taskCompleted;
+  } finally {
+    await unlink(opts.lockPath).catch(() => {
+      debugLogger2.debug(`${opts.name}: lock unlink failed (harmless)`);
+    });
+  }
+}
+__name(runThrottledOnce, "runThrottledOnce");
+async function markerIsFresh(markerPath, minIntervalMs, name) {
+  try {
+    const s = await stat2(markerPath);
+    const age = Date.now() - s.mtimeMs;
+    if (age < minIntervalMs) {
+      debugLogger2.debug(`${name}: skipping, ran ${age}ms ago`);
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+__name(markerIsFresh, "markerIsFresh");
+async function tryAcquire(lockPath) {
+  try {
+    const fh = await open(lockPath, "wx");
+    await fh.close();
+    return true;
+  } catch (e) {
+    if (e?.code === "EEXIST") {
+      return false;
+    }
+    throw e;
+  }
+}
+__name(tryAcquire, "tryAcquire");
+
+// packages/cli/src/utils/housekeeping/scheduler.ts
+var debugLogger3 = createDebugLogger("HOUSEKEEPING");
+var STARTUP_DELAY_MS = 10 * 60 * 1e3;
+var RECURRING_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var RECENT_INTERACTION_MS = 60 * 1e3;
+var CATCHUP_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
+var STARTUP_DELAY_CATCHUP_MS = 60 * 1e3;
+var FILE_HISTORY_MARKER = ".file-history-cleanup";
+var started = false;
+function startBackgroundHousekeeping(config, settings) {
+  if (started) return;
+  started = true;
+  void scheduleFirstPass(config, settings).catch((err) => {
+    started = false;
+    debugLogger3.error(
+      "scheduleFirstPass failed; chain will retry on next start",
+      err
+    );
+  });
+}
+__name(startBackgroundHousekeeping, "startBackgroundHousekeeping");
+async function scheduleFirstPass(config, settings) {
+  const markerPath = join2(Storage.getGlobalQwenDir(), FILE_HISTORY_MARKER);
+  const delay = await needsCatchUp(markerPath) ? STARTUP_DELAY_CATCHUP_MS : STARTUP_DELAY_MS;
+  debugLogger3.debug(`first pass in ${delay / 1e3}s`);
+  setTimeout(() => scheduleNextPass(config, settings), delay).unref();
+}
+__name(scheduleFirstPass, "scheduleFirstPass");
+async function needsCatchUp(markerPath) {
+  try {
+    const s = await stat3(markerPath);
+    return Date.now() - s.mtimeMs > CATCHUP_THRESHOLD_MS;
+  } catch {
+    return true;
+  }
+}
+__name(needsCatchUp, "needsCatchUp");
+async function runPass(config, settings) {
+  if (msSinceLastInteraction() < RECENT_INTERACTION_MS) {
+    debugLogger3.debug("user active, deferring 10 min");
+    setTimeout(
+      () => scheduleNextPass(config, settings),
+      STARTUP_DELAY_MS
+    ).unref();
+    return;
+  }
+  try {
+    await runHousekeeping(config, settings);
+  } catch (err) {
+    debugLogger3.error("housekeeping pass failed; will retry next cycle", err);
+  }
+  setTimeout(
+    () => scheduleNextPass(config, settings),
+    RECURRING_INTERVAL_MS
+  ).unref();
+}
+__name(runPass, "runPass");
+function scheduleNextPass(config, settings) {
+  void runPass(config, settings).catch((err) => {
+    debugLogger3.error("runPass rejected unexpectedly", err);
+  });
+}
+__name(scheduleNextPass, "scheduleNextPass");
+async function runHousekeeping(config, settings) {
+  const days = settings.merged.general?.cleanupPeriodDays ?? 30;
+  const cutoff = getCutoffDate(days);
+  const currentSessionId = config.getSessionId();
+  const qwenDir = Storage.getGlobalQwenDir();
+  await runThrottledOnce(
+    {
+      name: "file-history-cleanup",
+      markerPath: join2(qwenDir, FILE_HISTORY_MARKER),
+      lockPath: join2(qwenDir, FILE_HISTORY_MARKER + ".lock")
+    },
+    async () => {
+      const r = await cleanupOldFileHistoryBackups({
+        cutoffDate: cutoff,
+        excludeSessionIds: /* @__PURE__ */ new Set([currentSessionId])
+      });
+      debugLogger3.debug(
+        `file-history: removed=${r.removed} errors=${r.errors}`
+      );
+    }
+  );
+}
+__name(runHousekeeping, "runHousekeeping");
+function _resetForTesting() {
+  started = false;
+}
+__name(_resetForTesting, "_resetForTesting");
+var _needsCatchUpForTesting = needsCatchUp;
+var _runHousekeepingForTesting = runHousekeeping;
+var _runPassForTesting = runPass;
+var _FILE_HISTORY_MARKER_FOR_TESTING = FILE_HISTORY_MARKER;
+export {
+  _FILE_HISTORY_MARKER_FOR_TESTING,
+  _needsCatchUpForTesting,
+  _resetForTesting,
+  _runHousekeepingForTesting,
+  _runPassForTesting,
+  startBackgroundHousekeeping
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/send-message-4QNWQJF4.js

@@ -0,0 +1,244 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  LEADER_NAME,
+  getAgentName,
+  isTeammate
+} from "./chunk-LD2XBG6Z.js";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-D3RHSPAS.js";
+import "./chunk-HR7SV7AY.js";
+import "./chunk-Z2Z3GUXZ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/send-message.ts
+init_esbuild_shims();
+var SendMessageInvocation = class extends BaseToolInvocation {
+  constructor(config, params) {
+    super(params);
+    this.config = config;
+  }
+  static {
+    __name(this, "SendMessageInvocation");
+  }
+  getDescription() {
+    if (this.params.task_id) {
+      return `Send message to task ${this.params.task_id}`;
+    }
+    const preview = this.params.summary ?? this.params.message.slice(0, 50);
+    return `Send to ${this.params.to}: ${preview}`;
+  }
+  /**
+   * Send-message routes free-form text into a running background task or a
+   * teammate, which will then execute it as a new instruction with full
+   * tool access. Treat it as a privileged sink — the L4 default must not be
+   * 'allow', because that would let the scheduler auto-approve in
+   * AUTO mode (where 'allow' short-circuits the classifier). 'ask' lets
+   * AUTO route through the classifier so the destination and message text
+   * can be inspected.
+   */
+  async getDefaultPermission() {
+    return "ask";
+  }
+  async execute(_signal) {
+    if (this.params.task_id) {
+      const registry = this.config.getBackgroundTaskRegistry();
+      const entry = registry.get(this.params.task_id);
+      if (!entry) {
+        return {
+          llmContent: `Error: No background task found with ID "${this.params.task_id}".`,
+          returnDisplay: "Task not found.",
+          error: {
+            message: `Task not found: ${this.params.task_id}`,
+            type: "send_message_not_found" /* SEND_MESSAGE_NOT_FOUND */
+          }
+        };
+      }
+      if (entry.status === "paused") {
+        const resumed = await this.config.resumeBackgroundAgent(
+          this.params.task_id,
+          this.params.message
+        );
+        if (!resumed) {
+          return {
+            llmContent: `Error: Background task "${this.params.task_id}" could not be resumed.`,
+            returnDisplay: "Task could not be resumed.",
+            error: {
+              message: `Task could not be resumed: ${this.params.task_id}`,
+              type: "send_message_not_running" /* SEND_MESSAGE_NOT_RUNNING */
+            }
+          };
+        }
+        return {
+          llmContent: `Background task "${this.params.task_id}" resumed with your message as the first continuation instruction.`,
+          returnDisplay: `Resumed ${entry.description}`
+        };
+      }
+      if (entry.status !== "running") {
+        return {
+          llmContent: `Error: Background task "${this.params.task_id}" is not running (status: ${entry.status}). Cannot send messages to stopped tasks.`,
+          returnDisplay: `Task not running (${entry.status}).`,
+          error: {
+            message: `Task is ${entry.status}: ${this.params.task_id}`,
+            type: "send_message_not_running" /* SEND_MESSAGE_NOT_RUNNING */
+          }
+        };
+      }
+      registry.queueMessage(this.params.task_id, this.params.message);
+      return {
+        llmContent: `Message queued for delivery to background task "${this.params.task_id}". The task will receive it at the next tool-round boundary.`,
+        returnDisplay: `Message queued for ${entry.description}`
+      };
+    }
+    const teamManager = this.config.getTeamManager();
+    if (!teamManager) {
+      const msg = "No active team and no task_id provided. Either create a team first, or pass `task_id` to message a background task.";
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    const to = this.params.to;
+    if (!to) {
+      const msg = 'Recipient "to" is required.';
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    try {
+      if (this.params.type === "shutdown_request") {
+        if (isTeammate()) {
+          const msg3 = "Only the team leader can request shutdowns.";
+          return {
+            llmContent: msg3,
+            returnDisplay: msg3,
+            error: { message: msg3 }
+          };
+        }
+        await teamManager.requestShutdown(to);
+        const msg2 = `Shutdown requested for "${to}".`;
+        return { llmContent: msg2, returnDisplay: msg2 };
+      }
+      if (to === "*") {
+        const sender = getAgentName() ?? LEADER_NAME;
+        await teamManager.broadcast(this.params.message, sender);
+        const msg2 = "Message broadcast to all teammates.";
+        return { llmContent: msg2, returnDisplay: msg2 };
+      }
+      await teamManager.sendMessage(
+        to,
+        this.params.message,
+        getAgentName() ?? LEADER_NAME,
+        this.params.summary
+      );
+      const msg = `Message sent to "${to}".`;
+      return { llmContent: msg, returnDisplay: msg };
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      return {
+        llmContent: `Failed to send message: ${errMsg}`,
+        returnDisplay: `Failed to send message: ${errMsg}`,
+        error: { message: errMsg }
+      };
+    }
+  }
+};
+var SendMessageTool = class _SendMessageTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _SendMessageTool.Name,
+      ToolDisplayNames.SEND_MESSAGE,
+      'Send a message to a teammate (use "to") or to a running background task (use "task_id"). For teams, set "to" to a bare teammate name (no @) or "*" to broadcast. For background tasks, set "task_id" to the id from the launch response or a recovered paused task. Running tasks receive it at the next tool-round boundary; paused recovered tasks are resumed with the message as their first continuation instruction. Your text output is NOT visible to other agents \u2014 use this tool to communicate.',
+      "other" /* Other */,
+      {
+        type: "object",
+        properties: {
+          to: {
+            type: "string",
+            description: 'Recipient teammate name, or "*" for broadcast.'
+          },
+          task_id: {
+            type: "string",
+            description: "The ID of the background task (from the launch response or a recovered paused task)."
+          },
+          message: {
+            type: "string",
+            description: "Message text to send.",
+            // Cap message size so a teammate can't grow the
+            // recipient's inbox file unboundedly with a single send.
+            maxLength: 65536
+          },
+          summary: {
+            type: "string",
+            description: "Optional 5-10 word summary for UI display."
+          },
+          type: {
+            type: "string",
+            enum: ["shutdown_request"],
+            description: "Structured message type for control flow. When set, routes through the mailbox instead of plain text delivery."
+          }
+        },
+        required: ["message"],
+        // Either a teammate recipient (`to`) or a background-task
+        // (`task_id`) must be specified — they correspond to the
+        // two routing modes. Letting the model send `{message}`
+        // alone wastes a round-trip on the runtime "Recipient is
+        // required" error.
+        oneOf: [{ required: ["to"] }, { required: ["task_id"] }],
+        additionalProperties: false
+      },
+      true,
+      // isOutputMarkdown
+      false,
+      // canUpdateOutput
+      true,
+      // shouldDefer — sending messages is infrequent
+      false,
+      // alwaysLoad
+      "send message task teammate team communicate notify"
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "SendMessageTool");
+  }
+  static Name = ToolNames.SEND_MESSAGE;
+  createInvocation(params) {
+    return new SendMessageInvocation(this.config, params);
+  }
+  /**
+   * Forward the routing fields and the message verbatim to the classifier —
+   * `to`/`task_id` identify the privileged sink and the `message` itself is
+   * the new instruction the recipient will execute, so the classifier needs
+   * the full text to evaluate the action's safety. `type` surfaces control
+   * messages (e.g. shutdown_request).
+   */
+  toAutoClassifierInput(params) {
+    return {
+      to: params.to,
+      task_id: params.task_id,
+      message: params.message,
+      type: params.type
+    };
+  }
+};
+export {
+  SendMessageTool
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */