tau-all-agent 0.1.2 → 0.1.4

package/extensions/sandbox/index.ts

@@ -25,8 +25,9 @@
  *   },
  *   "filesystem": {
  *     "denyRead": ["~/.ssh", "~/.aws"],
- *     "allowWrite": [".", "/tmp"],
+ *     "allowWrite": ["."],
  *     "denyWrite": [".env"],
+ *     "allowTempDirs": true,
  *     "allowGitCommonDir": true
  *   }
  * }
@@ -47,7 +48,7 @@
 
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import {
   SandboxManager,
@@ -62,8 +63,8 @@ import {
   globToRegex,
   normalizePathForSandbox,
 } from "@anthropic-ai/sandbox-runtime/dist/sandbox/sandbox-utils.js";
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { type BashOperations, createBashTool } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type BashOperations, createBashTool } from "@earendil-works/pi-coding-agent";
 
 // --- Constants ---
 
@@ -74,24 +75,69 @@ const DEFAULT_CONFIG: SandboxConfig = {
   mode: DEFAULT_PROMPT_MODE,
   network: {
     allowedDomains: [
+      "localhost",
+      "127.0.0.1",
       "npmjs.org",
       "*.npmjs.org",
       "registry.npmjs.org",
       "registry.yarnpkg.com",
       "pypi.org",
       "*.pypi.org",
+      "pythonhosted.org",
+      "*.pythonhosted.org",
+      "crates.io",
+      "*.crates.io",
+      "proxy.golang.org",
+      "sum.golang.org",
+      "go.dev",
+      "golang.org",
+      "rubygems.org",
+      "*.rubygems.org",
       "github.com",
       "*.github.com",
+      "githubusercontent.com",
+      "*.githubusercontent.com",
       "api.github.com",
       "raw.githubusercontent.com",
+      "ghcr.io",
+      "docker.io",
+      "*.docker.io",
+      "production.cloudflare.docker.com",
+      "sentry.io",
+      "*.sentry.io",
+      "datadoghq.com",
+      "*.datadoghq.com",
+      "datadoghq.eu",
+      "*.datadoghq.eu",
+      "anthropic.com",
+      "*.anthropic.com",
+      "claude.ai",
+      "*.claude.ai",
+      "openai.com",
+      "*.openai.com",
+      "chatgpt.com",
+      "*.chatgpt.com",
+      "google.com",
+      "*.google.com",
+      "googleapis.com",
+      "*.googleapis.com",
+      "todoist.com",
+      "*.todoist.com",
+      "twist.com",
+      "*.twist.com",
+      "doist.com",
+      "*.doist.com",
     ],
     deniedDomains: [],
+    allowLocalBinding: true,
   },
   filesystem: {
     denyRead: ["~/.ssh", "~/.aws", "~/.gnupg"],
-    allowWrite: [".", "/tmp"],
+    allowWrite: [".", "~/.cache", "~/.npm"],
     denyWrite: [".env", ".env.*", "*.pem", "*.key"],
-    allowGitCommonDir: false,
+    allowTempDirs: true,
+    allowGitConfig: true,
+    allowGitCommonDir: true,
   },
 };
 
@@ -120,6 +166,7 @@ type SandboxConfig = Omit<SandboxRuntimeConfig, "filesystem"> & {
   enabled?: boolean;
   mode?: PromptMode;
   filesystem: SandboxRuntimeConfig["filesystem"] & {
+    allowTempDirs?: boolean;
     allowGitCommonDir?: boolean;
   };
 };
@@ -582,6 +629,10 @@ function finalizeConfig(config: SandboxConfig): SandboxConfig {
         DEFAULT_CONFIG.filesystem.denyWrite,
         "filesystem.denyWrite",
       ),
+      allowTempDirs:
+        typeof config.filesystem?.allowTempDirs === "boolean"
+          ? config.filesystem.allowTempDirs
+          : DEFAULT_CONFIG.filesystem.allowTempDirs,
       allowGitCommonDir:
         typeof config.filesystem?.allowGitCommonDir === "boolean"
           ? config.filesystem.allowGitCommonDir
@@ -705,12 +756,32 @@ function deepMerge(base: SandboxConfig, overrides: Partial<SandboxConfig>): Sand
   return result;
 }
 
+let cachedTemporaryWritePaths: string[] | undefined;
+
+function getTemporaryWritePaths(): string[] {
+  if (cachedTemporaryWritePaths) return cachedTemporaryWritePaths;
+
+  // allowTempDirs always includes the conventional shared temp path, even when
+  // os.tmpdir() points at a platform-specific per-user directory.
+  const currentTmpDir = tmpdir();
+  const paths = ["/tmp", currentTmpDir, normalizePathForSandbox(currentTmpDir)];
+  if (process.platform === "darwin") paths.push("/private/tmp");
+
+  cachedTemporaryWritePaths = Array.from(
+    new Set(paths.map((path) => path.replace(/\/+$/, "") || "/")),
+  );
+  return cachedTemporaryWritePaths;
+}
+
 function toRuntimeConfig(config: SandboxConfig): SandboxRuntimeConfig {
-  const { allowGitCommonDir: _allowGitCommonDir, ...filesystem } = config.filesystem;
+  const { allowGitCommonDir: _allowGitCommonDir, allowTempDirs, ...filesystem } = config.filesystem;
+  const allowWrite = allowTempDirs
+    ? Array.from(new Set([...filesystem.allowWrite, ...getTemporaryWritePaths()]))
+    : filesystem.allowWrite;
 
   return {
     network: config.network,
-    filesystem,
+    filesystem: { ...filesystem, allowWrite },
     ignoreViolations: config.ignoreViolations,
     enableWeakerNestedSandbox: config.enableWeakerNestedSandbox,
     enableWeakerNetworkIsolation: config.enableWeakerNetworkIsolation,
@@ -2455,11 +2526,16 @@ export default function (pi: ExtensionAPI) {
           "  Network:",
           `    Allowed: ${runtimeConfig.network.allowedDomains.join(", ") || "(none)"}`,
           `    Denied: ${runtimeConfig.network.deniedDomains.join(", ") || "(none)"}`,
+          `    allowLocalBinding: ${runtimeConfig.network.allowLocalBinding ? "true" : "false"}`,
+          `    allowAllUnixSockets: ${runtimeConfig.network.allowAllUnixSockets ? "true" : "false"}`,
+          `    allowUnixSockets: ${runtimeConfig.network.allowUnixSockets?.join(", ") || "(none)"}`,
           "",
           "  Filesystem:",
           `    Deny Read: ${runtimeConfig.filesystem.denyRead.join(", ") || "(none)"}`,
           `    Allow Write: ${runtimeConfig.filesystem.allowWrite.join(", ") || "(none)"}`,
           `    Deny Write: ${runtimeConfig.filesystem.denyWrite.join(", ") || "(none)"}`,
+          `    allowTempDirs: ${sandboxConfig?.filesystem.allowTempDirs ? "true" : "false"}`,
+          `    allowGitConfig: ${runtimeConfig.filesystem.allowGitConfig ? "true" : "false"}`,
           `    allowGitCommonDir: ${sandboxConfig?.filesystem.allowGitCommonDir ? "true" : "false"}`,
           "",
           "  Advanced:",

package/extensions/telegram/daemon.mjs

@@ -6,7 +6,7 @@ import net from "node:net";
 import process from "node:process";
 import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import TelegramBot from "node-telegram-bot-api";
+import { EventEmitter } from "node:events";
 import { extractTextFromMessage } from "./message-text.mjs";
 
 const AGENT_DIR = path.join(os.homedir(), ".pi", "agent");
@@ -26,7 +26,8 @@ const TELEGRAM_COMMANDS = [
   { command: "help", description: "Show available commands" },
 ];
 
-const TELEGRAM_POLL_TIMEOUT_SECONDS = 30;
+const TELEGRAM_POLL_TIMEOUT_SEC = 30;
+const TELEGRAM_POLL_RETRY_MS = 1_000;
 const TELEGRAM_HTTP_TIMEOUT_MS = 35_000;
 const POLLING_STOP_TIMEOUT_MS = 4_000;
 const ACTIVITY_NOTICE_COOLDOWN_MS = 60 * 60 * 1000;
@@ -44,6 +45,146 @@ const PI_ENTRYPOINT = process.env.PI_TELEGRAM_PI_ENTRYPOINT?.trim() || undefined
 const RESOLVED_TMPDIR = await fsp.realpath(os.tmpdir()).catch(() => os.tmpdir());
 const HEADLESS_SESSION_PATH_ERROR = "Path must start with / or ~ and refer to a directory.";
 
+class TelegramApiError extends Error {
+  constructor(method, status, description) {
+    const suffix = description ? `: ${description}` : "";
+    super(`Telegram ${method} failed (${status})${suffix}`);
+    this.name = "TelegramApiError";
+    this.status = status;
+    this.description = description;
+  }
+}
+
+class TelegramPollingBot extends EventEmitter {
+  constructor(token, options = {}) {
+    super();
+    this.baseUrl = `https://api.telegram.org/bot${token}`;
+    this.pollTimeoutSeconds = options.polling?.params?.timeout ?? TELEGRAM_POLL_TIMEOUT_SEC;
+    this.httpTimeoutMs = options.request?.timeout ?? TELEGRAM_HTTP_TIMEOUT_MS;
+    this.offset = 0;
+    this.stopped = false;
+    this.pollController = new AbortController();
+    this.pollPromise = this.pollLoop();
+  }
+
+  async sendChatAction(chatId, action) {
+    return this.call("sendChatAction", { chat_id: chatId, action });
+  }
+
+  async sendMessage(chatId, text, options = {}) {
+    return this.call("sendMessage", { chat_id: chatId, text, ...options });
+  }
+
+  async setMyCommands(commands) {
+    return this.call("setMyCommands", { commands });
+  }
+
+  async answerCallbackQuery(callbackQueryId, options = {}) {
+    return this.call("answerCallbackQuery", { callback_query_id: callbackQueryId, ...options });
+  }
+
+  async stopPolling() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.pollController.abort();
+    await this.pollPromise.catch(() => {});
+  }
+
+  async pollLoop() {
+    while (!this.stopped) {
+      try {
+        const updates = await this.call(
+          "getUpdates",
+          {
+            offset: this.offset,
+            timeout: this.pollTimeoutSeconds,
+            allowed_updates: ["message", "callback_query"],
+          },
+          { signal: this.pollController.signal },
+        );
+
+        for (const update of Array.isArray(updates) ? updates : []) {
+          if (Number.isInteger(update.update_id)) {
+            this.offset = Math.max(this.offset, update.update_id + 1);
+          }
+          if (update.message) this.emit("message", update.message);
+          if (update.callback_query) this.emit("callback_query", update.callback_query);
+        }
+      } catch (error) {
+        if (this.stopped) return;
+        if (this.isAbortError(error)) continue;
+        this.emit("polling_error", error);
+        await sleep(TELEGRAM_POLL_RETRY_MS);
+      }
+    }
+  }
+
+  async call(method, payload, options = {}) {
+    const response = await this.fetchJson(method, payload, options);
+    if (!response || response.ok !== true) {
+      throw new TelegramApiError(
+        method,
+        response?.error_code ?? 200,
+        response?.description || "Unexpected response",
+      );
+    }
+    return response.result;
+  }
+
+  async fetchJson(method, payload, options = {}) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.httpTimeoutMs);
+    const onAbort = () => controller.abort();
+    if (options.signal?.aborted) {
+      clearTimeout(timeoutId);
+      throw new DOMException("Aborted", "AbortError");
+    }
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+
+    try {
+      const response = await fetch(`${this.baseUrl}/${method}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+      });
+
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = undefined;
+      }
+
+      if (!response.ok) {
+        throw new TelegramApiError(method, response.status, body?.description);
+      }
+
+      return body;
+    } finally {
+      clearTimeout(timeoutId);
+      options.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+
+  emit(eventName, ...args) {
+    let handled = false;
+    for (const listener of this.listeners(eventName)) {
+      handled = true;
+      try {
+        listener(...args);
+      } catch (error) {
+        console.error(`[telegram] ${eventName} handler error`, error);
+      }
+    }
+    return handled;
+  }
+
+  isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+  }
+}
+
 async function loadConfig() {
   try {
     const raw = await fsp.readFile(CONFIG_PATH, "utf8");
@@ -1857,10 +1998,10 @@ async function startServer() {
 
 server = await startServer();
 
-bot = new TelegramBot(botTokenInfo.token, {
+bot = new TelegramPollingBot(botTokenInfo.token, {
   polling: {
     params: {
-      timeout: TELEGRAM_POLL_TIMEOUT_SECONDS,
+      timeout: TELEGRAM_POLL_TIMEOUT_SEC,
     },
   },
   request: {
@@ -1869,9 +2010,9 @@ bot = new TelegramBot(botTokenInfo.token, {
 });
 
 void syncBotCommands();
-// node-telegram-bot-api already retries failed polls. Avoid stop/start
-// recovery here: cancelling an in-flight poll can spin up overlapping
-// pollers and replay the same Telegram update multiple times.
+// The polling client retries failed polls internally. Avoid stop/start recovery here:
+// cancelling an in-flight poll can spin up overlapping pollers and replay the same
+// Telegram update multiple times.
 bot.on("polling_error", (error) => {
   const message = errorMessage(error);
   const kind = isLikelyNetworkPollingError(error) ? "polling_error (network)" : "polling_error";

package/extensions/telegram/index.ts

@@ -3,7 +3,7 @@ import {
   type ExtensionAPI,
   type ExtensionContext,
   type ExtensionCommandContext,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";