pi-harness-runtime 1.1.333 → 1.1.334

package/scripts/r2-storage.ts

@@ -0,0 +1,217 @@
+/**
+ * R2 Storage - Cloudflare R2 integration for Telegram log storage
+ * 
+ * Uses @aws-sdk/client-s3 and @aws-sdk/s3-request-presigner
+ * Credentials loaded from key files per sensitive data rules.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+// ============================================================================
+// Configuration - Load from key files
+// ============================================================================
+
+export interface R2Config {
+  accountId: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  bucket: string;
+  endpoint?: string;
+  publicUrl?: string;
+}
+
+/**
+ * Load R2 config from key files
+ */
+export function loadR2Config(): R2Config | null {
+  const keysDir = join(process.env.HOME || "/home/frappe", ".pi-harness-runtime", "keys");
+
+  const accountIdFile = join(keysDir, "r2-account-id.txt");
+  const accessKeyFile = join(keysDir, "r2-access-key-id.txt");
+  const secretKeyFile = join(keysDir, "r2-secret-access-key.txt");
+  const bucketFile = join(keysDir, "r2-bucket-name.txt");
+  const endpointFile = join(keysDir, "r2-endpoint.txt");
+  const publicUrlFile = join(keysDir, "r2-public-url.txt");
+
+  // Check if R2 is configured
+  if (!existsSync(accountIdFile) || !existsSync(accessKeyFile) || !existsSync(secretKeyFile)) {
+    return null;
+  }
+
+  return {
+    accountId: readFileSync(accountIdFile, "utf8").trim(),
+    accessKeyId: readFileSync(accessKeyFile, "utf8").trim(),
+    secretAccessKey: readFileSync(secretKeyFile, "utf8").trim(),
+    bucket: existsSync(bucketFile) ? readFileSync(bucketFile, "utf8").trim() : "telegram-logs",
+    endpoint: existsSync(endpointFile) ? readFileSync(endpointFile, "utf8").trim() : undefined,
+    publicUrl: existsSync(publicUrlFile) ? readFileSync(publicUrlFile, "utf8").trim() : undefined,
+  };
+}
+
+// ============================================================================
+// R2 Client
+// ============================================================================
+
+let r2Client: R2Client | null = null;
+
+export class R2Client {
+  private client: S3Client;
+  private bucket: string;
+  private publicUrl: string | null;
+
+  constructor(config: R2Config) {
+    // Build endpoint from accountId or use explicit endpoint
+    const endpoint = config.endpoint || `https://${config.accountId}.r2.cloudflarestorage.com`;
+
+    this.client = new S3Client({
+      region: "auto",
+      endpoint,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+      },
+    });
+
+    this.bucket = config.bucket;
+    this.publicUrl = config.publicUrl || null;
+  }
+
+  /**
+   * Upload content to R2
+   */
+  async upload(options: {
+    key: string;
+    body: string;
+    contentType?: string;
+    expiresIn?: number; // For signed URL
+  }): Promise<{ key: string; signedUrl: string; expiresIn: number }> {
+    const { key, body, contentType = "text/plain", expiresIn = 86400 } = options;
+
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: body,
+        ContentType: contentType,
+      })
+    );
+
+    // Generate signed URL for access
+    const { GetObjectCommand } = await import("@aws-sdk/client-s3");
+    const signedUrl = await getSignedUrl(this.client, new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    }), { expiresIn });
+
+    console.log(`[R2] Uploaded: ${key}`);
+
+    return {
+      key,
+      signedUrl,
+      expiresIn,
+    };
+  }
+
+  /**
+   * Get public URL for a key (if publicUrl is configured)
+   */
+  getPublicUrl(key: string): string | null {
+    if (this.publicUrl) {
+      return `${this.publicUrl}/${key}`;
+    }
+    return null;
+  }
+}
+
+/**
+ * Get or create R2 client singleton
+ */
+export function getR2Client(): R2Client | null {
+  if (r2Client) return r2Client;
+
+  const config = loadR2Config();
+  if (!config) return null;
+
+  r2Client = new R2Client(config);
+  return r2Client;
+}
+
+/**
+ * Check if R2 is configured
+ */
+export function isR2Configured(): boolean {
+  return loadR2Config() !== null;
+}
+
+// ============================================================================
+// High-level API
+// ============================================================================
+
+interface UploadResult {
+  key: string;
+  url: string;
+  expiresIn: number;
+}
+
+/**
+ * Upload logs to R2 and return a signed URL
+ * 
+ * @param content - Log content to upload
+ * @param prefix - Path prefix (default: "logs")
+ * @param expiresIn - URL expiration in seconds (default: 86400 = 24h)
+ */
+export async function uploadLogsToR2(
+  content: string,
+  prefix: string = "logs",
+  expiresIn: number = 86400
+): Promise<UploadResult | null> {
+  const client = getR2Client();
+  if (!client) {
+    console.log("[R2] Not configured - skipping upload");
+    return null;
+  }
+
+  const key = `${prefix}/${Date.now()}-${generateId()}.txt`;
+
+  try {
+    const result = await client.upload({
+      key,
+      body: content,
+      contentType: "text/plain",
+      expiresIn,
+    });
+
+    return {
+      key: result.key,
+      url: result.signedUrl,
+      expiresIn: result.expiresIn,
+    };
+  } catch (error) {
+    console.error("[R2] Upload failed:", error);
+    return null;
+  }
+}
+
+/**
+ * Generate a short random ID
+ */
+function generateId(): string {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+// ============================================================================
+// Key Files Required
+// ============================================================================
+
+/**
+ * Required key files for R2:
+ * - ~/.pi-harness-runtime/keys/r2-account-id.txt
+ * - ~/.pi-harness-runtime/keys/r2-access-key-id.txt
+ * - ~/.pi-harness-runtime/keys/r2-secret-access-key.txt
+ * - ~/.pi-harness-runtime/keys/r2-bucket-name.txt (optional, default: "telegram-logs")
+ * - ~/.pi-harness-runtime/keys/r2-endpoint.txt (optional)
+ * - ~/.pi-harness-runtime/keys/r2-public-url.txt (optional)
+ */

package/scripts/telegram-mobile-bot.ts

@@ -0,0 +1,438 @@
+/**
+ * Telegram Mobile Bot - Mobile-First Control Surface
+ * 
+ * Design principles:
+ * - ZERO typing - all actions via buttons
+ * - One-tap navigation - contextual action buttons
+ * - Persistent context - job state always visible
+ * - Quick status - current job at a glance
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { existsSync, readFileSync, writeFileSync, appendFileSync } from "node:fs";
+
+const keysDir = path.join(process.env.HOME || "/home/frappe", ".pi-harness-runtime", "keys");
+const dataDir = path.join(process.env.HOME || "/home/frappe", ".pi-harness-runtime", "data");
+
+// Load config
+const botToken = fs.readFileSync(path.join(keysDir, "telegram-bot-token.txt"), "utf8").trim();
+const chatId = fs.readFileSync(path.join(keysDir, "telegram-chat-id.txt"), "utf8").trim();
+
+// API helpers
+async function sendMessage(text: string, keyboard?: InlineKeyboard): Promise<number | null> {
+  const response = await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      chat_id: chatId,
+      text,
+      parse_mode: "HTML",
+      reply_markup: keyboard ? { inline_keyboard: keyboard } : undefined,
+    }),
+  });
+  const data = await response.json() as { ok: boolean; result?: { message_id: number } };
+  return data.ok ? data.result?.message_id ?? null : null;
+}
+
+async function editMessage(messageId: number, text: string, keyboard?: InlineKeyboard): Promise<boolean> {
+  const response = await fetch(`https://api.telegram.org/bot${botToken}/editMessageText`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      chat_id: chatId,
+      message_id: messageId,
+      text,
+      parse_mode: "HTML",
+      reply_markup: keyboard ? { inline_keyboard: keyboard } : undefined,
+    }),
+  });
+  const data = await response.json() as { ok: boolean };
+  return data.ok;
+}
+
+async function answerCallback(queryId: string, text?: string): Promise<void> {
+  await fetch(`https://api.telegram.org/bot${botToken}/answerCallbackQuery`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      callback_query_id: queryId,
+      text,
+      show_alert: false,
+    }),
+  });
+}
+
+// Types
+type InlineKeyboard = Array<Array<{ text: string; callback_data: string }>>;
+
+interface JobStatus {
+  id: string;
+  title: string;
+  status: "pending" | "running" | "done" | "failed";
+  progress?: string;
+  updatedAt: string;
+  messageId?: number;
+}
+
+interface JobDetail {
+  id: string;
+  title: string;
+  description?: string;
+  status: string;
+  logs?: string[];
+  diff?: string;
+  error?: string;
+}
+
+// State management
+class JobState {
+  private stateFile: string;
+  private jobs: Map<string, JobStatus> = new Map();
+  private currentJobId: string | null = null;
+
+  constructor() {
+    fs.mkdirSync(dataDir, { recursive: true });
+    this.stateFile = path.join(dataDir, "telegram-jobs.json");
+    this.load();
+  }
+
+  private load() {
+    try {
+      if (existsSync(this.stateFile)) {
+        const data = JSON.parse(readFileSync(this.stateFile, "utf8"));
+        this.jobs = new Map(data.jobs || []);
+        this.currentJobId = data.currentJobId || null;
+      }
+    } catch (e) {
+      console.error("Failed to load state:", e);
+    }
+  }
+
+  private save() {
+    writeFileSync(this.stateFile, JSON.stringify({
+      jobs: Array.from(this.jobs.entries()),
+      currentJobId: this.currentJobId,
+    }));
+  }
+
+  setCurrentJob(jobId: string | null) {
+    this.currentJobId = jobId;
+    this.save();
+  }
+
+  getCurrentJob(): JobStatus | null {
+    return this.currentJobId ? this.jobs.get(this.currentJobId) ?? null : null;
+  }
+
+  updateJob(job: JobStatus) {
+    this.jobs.set(job.id, job);
+    this.save();
+  }
+
+  getAllJobs(): JobStatus[] {
+    return Array.from(this.jobs.values()).sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+  }
+
+  removeJob(jobId: string) {
+    this.jobs.delete(jobId);
+    if (this.currentJobId === jobId) {
+      this.currentJobId = this.jobs.keys().next().value ?? null;
+    }
+    this.save();
+  }
+}
+
+// Button generators - NO typing required!
+class ButtonKit {
+  static jobCard(job: JobStatus): InlineKeyboard {
+    const statusIcon = job.status === "running" ? "🔄" : job.status === "done" ? "✅" : job.status === "failed" ? "❌" : "⏳";
+    return [
+      [
+        { text: "📋 Details", callback_data: `job:details:${job.id}` },
+        { text: "📜 Logs", callback_data: `job:logs:${job.id}` },
+      ],
+      [
+        { text: "🔄 Retry", callback_data: `job:retry:${job.id}` },
+        { text: "❌ Cancel", callback_data: `job:cancel:${job.id}` },
+      ],
+    ];
+  }
+
+  static mainMenu(): InlineKeyboard {
+    return [
+      [
+        { text: "📋 My Jobs", callback_data: "nav:jobs" },
+        { text: "🔍 Search", callback_data: "nav:search" },
+      ],
+      [
+        { text: "📊 Status", callback_data: "nav:status" },
+        { text: "⚙️ Settings", callback_data: "nav:settings" },
+      ],
+    ];
+  }
+
+  static jobList(jobs: JobStatus[]): InlineKeyboard {
+    const buttons: InlineKeyboard = [];
+    for (const job of jobs.slice(0, 5)) {
+      const icon = job.status === "running" ? "🔄" : job.status === "done" ? "✅" : job.status === "failed" ? "❌" : "⏳";
+      buttons.push([{ text: `${icon} ${job.title.slice(0, 30)}`, callback_data: `job:select:${job.id}` }]);
+    }
+    buttons.push([{ text: "🔙 Back to Menu", callback_data: "nav:menu" }]);
+    return buttons;
+  }
+
+  static detailsPage(job: JobDetail): InlineKeyboard {
+    return [
+      [
+        { text: "📜 Full Logs", callback_data: `job:logs:${job.id}` },
+        { text: "📝 View Diff", callback_data: `job:diff:${job.id}` },
+      ],
+      [
+        { text: "🔄 Retry", callback_data: `job:retry:${job.id}` },
+        { text: "🗑️ Dismiss", callback_data: `job:dismiss:${job.id}` },
+      ],
+      [
+        { text: "🔙 Back", callback_data: "nav:jobs" },
+      ],
+    ];
+  }
+
+  static confirmAction(action: string, targetId: string): InlineKeyboard {
+    return [
+      [
+        { text: "✅ Confirm", callback_data: `action:confirm:${action}:${targetId}` },
+        { text: "❌ Cancel", callback_data: `action:cancel:${action}:${targetId}` },
+      ],
+    ];
+  }
+}
+
+// Renderers
+function formatJobCard(job: JobStatus): string {
+  const statusIcon = job.status === "running" ? "🔄" : job.status === "done" ? "✅" : job.status === "failed" ? "❌" : "⏳";
+  const time = new Date(job.updatedAt).toLocaleTimeString();
+  
+  return `<b>${statusIcon} ${job.title}</b>\n` +
+    `Status: ${job.status}${job.progress ? ` (${job.progress})` : ""}\n` +
+    `Updated: ${time}`;
+}
+
+function formatJobDetail(job: JobDetail): string {
+  const statusIcon = job.status === "running" ? "🔄" : job.status === "done" ? "✅" : job.status === "failed" ? "❌" : "⏳";
+  
+  let text = `<b>${statusIcon} ${job.title}</b>\n`;
+  text += `─────────────────\n`;
+  text += `Status: <code>${job.status}</code>\n`;
+  
+  if (job.description) {
+    text += `\n${job.description}\n`;
+  }
+  
+  if (job.error) {
+    text += `\n⚠️ <b>Error:</b>\n<code>${job.error.slice(0, 200)}</code>`;
+  }
+  
+  if (job.logs && job.logs.length > 0) {
+    text += `\n\n📜 <b>Recent Logs:</b>`;
+    for (const log of job.logs.slice(0, 3)) {
+      text += `\n<code>${log.slice(0, 100)}</code>`;
+    }
+  }
+  
+  return text;
+}
+
+// Actions
+async function handleJobDetails(jobId: string): Promise<string> {
+  // In real implementation, fetch from job state or API
+  return formatJobDetail({
+    id: jobId,
+    title: "Sample Job",
+    status: "running",
+    description: "This job is processing...",
+    logs: ["Starting process...", "Running tests...", "All tests passed"],
+  });
+}
+
+async function handleJobLogs(jobId: string, page = 0): Promise<{ text: string; keyboard: InlineKeyboard }> {
+  // In real implementation, fetch from log storage
+  const logs = [
+    `[10:00] Job started`,
+    `[10:01] Running tests...`,
+    `[10:02] Test 1: PASS`,
+    `[10:02] Test 2: PASS`,
+    `[10:03] All 24 tests passed!`,
+  ];
+  
+  const startIdx = page * 5;
+  const pageLogs = logs.slice(startIdx, startIdx + 5);
+  
+  const text = `<b>📜 Job Logs</b>\n<code>${jobId}</code>\n─────────────────\n` +
+    pageLogs.map(l => `📍 ${l}`).join("\n") +
+    `\n─────────────────\nPage ${page + 1}`;
+  
+  const keyboard: InlineKeyboard = [];
+  if (logs.length > startIdx + 5) {
+    keyboard.push([{ text: "▶️ Next", callback_data: `job:logs:${jobId}:${page + 1}` }]);
+  }
+  if (page > 0) {
+    keyboard.push([{ text: "◀️ Prev", callback_data: `job:logs:${jobId}:${page - 1}` }]);
+  }
+  keyboard.push([{ text: "🔙 Back", callback_data: `job:details:${jobId}` }]);
+  
+  return { text, keyboard };
+}
+
+// Command handlers - triggered by buttons
+export async function handleCallback(queryId: string, data: string): Promise<void> {
+  const parts = data.split(":");
+  const action = parts[0];
+  const subAction = parts[1];
+  const targetId = parts[2];
+  
+  switch (action) {
+    case "job": {
+      switch (subAction) {
+        case "select": {
+          // Show job details with action buttons
+          const job = new JobState().getAllJobs().find(j => j.id === targetId);
+          if (job) {
+            const details = await handleJobDetails(targetId);
+            await sendMessage(details, ButtonKit.detailsPage({ ...job, description: "" }));
+          }
+          break;
+        }
+        
+        case "details": {
+          const details = await handleJobDetails(targetId);
+          await sendMessage(details, ButtonKit.detailsPage({ id: targetId, title: "", status: "" }));
+          break;
+        }
+        
+        case "logs": {
+          const page = parseInt(parts[3] || "0");
+          const { text, keyboard } = await handleJobLogs(targetId, page);
+          await sendMessage(text, keyboard);
+          break;
+        }
+        
+        case "retry": {
+          await sendMessage(
+            `🔄 Retry <code>${targetId}</code>?`,
+            ButtonKit.confirmAction("retry", targetId)
+          );
+          break;
+        }
+        
+        case "cancel": {
+          await sendMessage(
+            `❌ Cancel <code>${targetId}</code>?`,
+            ButtonKit.confirmAction("cancel", targetId)
+          );
+          break;
+        }
+        
+        case "dismiss": {
+          new JobState().removeJob(targetId);
+          await sendMessage("🗑️ Job dismissed", ButtonKit.mainMenu());
+          break;
+        }
+      }
+      break;
+    }
+    
+    case "action": {
+      if (subAction === "confirm") {
+        const actionToConfirm = parts[2];
+        const id = parts[3];
+        
+        // Execute the confirmed action
+        const jobPipe = path.join(dataDir, "job-commands.jsonl");
+        appendFileSync(jobPipe, JSON.stringify({
+          command: actionToConfirm,
+          jobId: id,
+          timestamp: new Date().toISOString(),
+        }) + "\n");
+        
+        const messages: Record<string, string> = {
+          retry: `🔄 Retrying job <code>${id}</code>...`,
+          cancel: `❌ Cancelled job <code>${id}</code>`,
+        };
+        
+        await sendMessage(messages[actionToConfirm] || "Action completed", ButtonKit.mainMenu());
+      }
+      break;
+    }
+    
+    case "nav": {
+      switch (subAction) {
+        case "menu": {
+          await sendMessage(
+            "🏠 <b>pi-harness Control Panel</b>\n\nSelect an action:",
+            ButtonKit.mainMenu()
+          );
+          break;
+        }
+        
+        case "jobs": {
+          const jobs = new JobState().getAllJobs();
+          if (jobs.length === 0) {
+            await sendMessage("📋 <b>No Active Jobs</b>\n\nNo jobs in progress.", ButtonKit.mainMenu());
+          } else {
+            await sendMessage(
+              "📋 <b>Your Jobs</b>\n\nSelect a job:",
+              ButtonKit.jobList(jobs)
+            );
+          }
+          break;
+        }
+        
+        case "status": {
+          const current = new JobState().getCurrentJob();
+          const text = current 
+            ? formatJobCard(current) + "\n\n<i>Last updated: just now</i>"
+            : "✅ <b>All Clear</b>\n\nNo active jobs.";
+          await sendMessage(text, ButtonKit.mainMenu());
+          break;
+        }
+        
+        case "search": {
+          await sendMessage(
+            "🔍 <b>Search</b>\n\nClick a job to search its logs:",
+            ButtonKit.jobList(new JobState().getAllJobs())
+          );
+          break;
+        }
+        
+        case "settings": {
+          await sendMessage(
+            "⚙️ <b>Settings</b>\n\n" +
+            "• Notifications: ON\n" +
+            "• Auto-retry: OFF\n" +
+            "• Log verbosity: Normal",
+            ButtonKit.mainMenu()
+          );
+          break;
+        }
+      }
+      break;
+    }
+  }
+  
+  await answerCallback(queryId);
+}
+
+// Send initial welcome
+export async function sendWelcome(): Promise<void> {
+  await sendMessage(
+    "🏠 <b>pi-harness Control Panel</b>\n\n" +
+    "Manage your coding tasks from anywhere.\n" +
+    "Tap a button below to get started:",
+    ButtonKit.mainMenu()
+  );
+}
+
+