pacatui 0.1.11 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacatui",
-  "version": "0.1.11",
+  "version": "0.1.14",
   "description": "A simple tui app for task, timer and invoicing for projects.",
   "module": "src/index.tsx",
   "type": "module",
@@ -66,6 +66,7 @@
     "@prisma/adapter-libsql": "^7.2.0",
     "@prisma/client": "^7.2.0",
     "better-sqlite3": "^12.6.0",
+    "paca4": ".",
     "prisma": "^7.2.0",
     "react": "^19.2.3",
     "stripe": "^20.2.0"

package/src/components/Dashboard.tsx

@@ -109,29 +109,53 @@ function WeeklyTimeChart({
 }) {
 	const colors = theme.colors;
 	const chartColors = theme.projectColors;
-	const chartWidth = Math.max(width + 4, 40);
-	const maxBars = Math.min(data.length, 25, Math.floor(chartWidth / 3)); // Each bar needs ~3 chars min, max 25 weeks
+	// Braille chars filled bottom-up (both columns): ⠀ ⣀ ⣤ ⣶ ⣿
+	const brailleBlocks = [
+		String.fromCodePoint(0x2800), // 0/4 empty
+		String.fromCodePoint(0x28c0), // 1/4 dots 7,8
+		String.fromCodePoint(0x28e4), // 2/4 dots 3,6,7,8
+		String.fromCodePoint(0x28f6), // 3/4 dots 2,3,5,6,7,8
+		String.fromCodePoint(0x28ff), // 4/4 all dots
+	];
+
+	// Available width after parent padding (2 per side)
+	const availableWidth = Math.max(width - 4, 16);
+	const chartHeight = 8; // character rows for bar area (8 × 4 = 32 levels)
+	const gap = 1;
+	const minBarWidth = 2;
+	const maxBarWidth = 10;
+	const maxWeeks = 25;
+
+	// Determine how many bars fit
+	const maxBars = Math.min(
+		data.length,
+		maxWeeks,
+		Math.floor((availableWidth + gap) / (minBarWidth + gap)),
+	);
 	const recentData = data.slice(-maxBars);
 
 	if (recentData.length === 0) {
 		return (
 			<box style={{ flexDirection: "column", gap: 1, width: "100%" }}>
-				<text fg={colors.textSecondary}>No time entries in the last 6 months</text>
+				<text fg={colors.textSecondary}>
+					No time entries in the last 6 months
+				</text>
 			</box>
 		);
 	}
 
-	// Find max hours for scaling
-	const maxMs = Math.max(...recentData.map((d) => d.totalMs), 1);
-	const barHeight = 5; // Height of bars in rows
-
-	// Calculate bar width to fill available space
-	// Total width = (barWidth * n) + (n - 1) spaces = chartWidth
-	// barWidth = (chartWidth - n + 1) / n
-
-	const barWidth = 4;
+	// Dynamic bar width to fill available space, capped
+	const barWidth = Math.min(
+		maxBarWidth,
+		Math.max(
+			minBarWidth,
+			Math.floor(
+				(availableWidth - (recentData.length - 1) * gap) / recentData.length,
+			),
+		),
+	);
 
-	// Collect unique projects for legend (sorted by total time across all weeks)
+	// Collect unique projects for legend (sorted by total time)
 	const projectTotals = new Map<
 		string,
 		{ name: string; color: string; totalMs: number }
@@ -150,18 +174,16 @@ function WeeklyTimeChart({
 			}
 		}
 	}
-	// Sort projects by total time (descending) for consistent stacking order
 	const sortedProjects = Array.from(projectTotals.entries()).sort(
 		(a, b) => b[1].totalMs - a[1].totalMs,
 	);
 
-	// Assign dynamic colors to each project based on their sorted position
 	const projectColorMap = new Map<string, string>();
 	sortedProjects.forEach(([projectId], index) => {
 		projectColorMap.set(projectId, chartColors[index % chartColors.length]!);
 	});
 
-	// Pre-sort each week's projects by the global order for consistent stacking
+	// Pre-sort each week's projects by global order for consistent stacking
 	const weekProjectsSorted = recentData.map((week) =>
 		[...week.projects].sort((a, b) => {
 			const aIdx = sortedProjects.findIndex(([id]) => id === a.projectId);
@@ -170,109 +192,179 @@ function WeeklyTimeChart({
 		}),
 	);
 
-	// Pre-calculate bar heights for label positioning
-	const barHeights = recentData.map((week) =>
-		Math.round((week.totalMs / maxMs) * barHeight),
-	);
-
-	// Build bars row by row (from top to bottom, +1 row for labels on tallest bars)
-	const rows: ReactNode[] = [];
-	for (let row = barHeight; row >= 0; row--) {
-		const rowParts: ReactNode[] = [];
-
-		for (let i = 0; i < recentData.length; i++) {
-			const week = recentData[i]!;
-			const barTotalRows = barHeights[i]!;
+	const maxMs = Math.max(...recentData.map((d) => d.totalMs), 1);
 
-			if (row < barTotalRows) {
-				// This row should be filled - determine which project's color
-				// Use fraction-based calculation to avoid rounding errors
-				const rowFraction = (row + 0.5) / barTotalRows;
-				const weekProjects = weekProjectsSorted[i]!;
+	// Build each bar column: array of {char, color} from row 0 (bottom) to top
+	const barColumns = recentData.map((week, weekIdx) => {
+		const totalFourths = Math.round(
+			(week.totalMs / maxMs) * chartHeight * 4,
+		);
+		const weekProjects = weekProjectsSorted[weekIdx]!;
+		const cells: Array<{ char: string; color: string }> = [];
 
-				// Find which project this row belongs to based on cumulative fraction
-				let cumulativeFraction = 0;
-				let projectColor = chartColors[0]!;
+		for (let row = 0; row < chartHeight; row++) {
+			const rowBottom = row * 4;
+			const fill = Math.min(Math.max(totalFourths - rowBottom, 0), 4);
 
+			if (fill === 0) {
+				cells.push({ char: " ", color: colors.textMuted });
+			} else {
+				// Find project color at midpoint of filled portion of this row
+				const midFourths = rowBottom + fill / 2;
+				const midFraction =
+					totalFourths > 0 ? midFourths / totalFourths : 0;
+				let cumFraction = 0;
+				let color = chartColors[0]!;
 				for (const proj of weekProjects) {
-					const projFraction = proj.ms / week.totalMs;
-					cumulativeFraction += projFraction;
-					if (rowFraction <= cumulativeFraction) {
-						projectColor =
+					cumFraction += proj.ms / week.totalMs;
+					if (midFraction <= cumFraction) {
+						color =
 							projectColorMap.get(proj.projectId) || chartColors[0]!;
 						break;
 					}
 				}
+				cells.push({ char: brailleBlocks[fill]!, color });
+			}
+		}
+		return cells;
+	});
 
-				rowParts.push(
-					<span key={i} fg={projectColor}>
-						{"█".repeat(barWidth)}
-					</span>,
-				);
-			} else if (row === barTotalRows && week.totalMs > 0) {
-				// Show hour label just above the bar (centered)
-				const label = formatHours(week.totalMs);
-				const trimmed = label.slice(0, barWidth);
-				const padLeft = Math.floor((barWidth - trimmed.length) / 2);
+	// Render a label row where labels can extend beyond bar width.
+	// Labels are centered on their bar position and skipped if they'd overlap.
+	function buildLabelRow(
+		labels: string[],
+		color: string,
+		key: string,
+	): ReactNode {
+		const totalWidth =
+			labels.length * barWidth + (labels.length - 1) * gap;
+		const chars = new Array(totalWidth).fill(" ");
+
+		let lastEnd = -2;
+		for (let i = 0; i < labels.length; i++) {
+			const label = labels[i]!;
+			if (!label) continue;
+
+			const barStart = i * (barWidth + gap);
+			const barCenter = barStart + Math.floor(barWidth / 2);
+			const labelStart = Math.max(
+				0,
+				barCenter - Math.floor(label.length / 2),
+			);
+			const labelEnd = labelStart + label.length;
+
+			if (labelStart > lastEnd && labelEnd <= totalWidth) {
+				for (let j = 0; j < label.length; j++) {
+					chars[labelStart + j] = label[j];
+				}
+				lastEnd = labelEnd;
+			}
+		}
+
+		return (
+			<text key={key} fg={color}>
+				{chars.join("")}
+			</text>
+		);
+	}
+
+	// Short top labels: rounded hours with no unit
+	const topLabels = recentData.map((week) => {
+		if (week.totalMs === 0) return "";
+		const hours = week.totalMs / 3600000;
+		const rounded = Math.round(hours);
+		return String(rounded || "<1");
+	});
+
+	// Row where each label sits (0-indexed from bottom, just above bar top)
+	const barLabelRows = recentData.map((week) => {
+		const totalFourths = Math.round(
+			(week.totalMs / maxMs) * chartHeight * 4,
+		);
+		return Math.min(Math.ceil(totalFourths / 4), chartHeight - 1);
+	});
+
+	const rows: ReactNode[] = [];
+
+	// Bar rows (top to bottom), with labels embedded on top of each bar
+	for (let row = chartHeight - 1; row >= 0; row--) {
+		const rowParts: ReactNode[] = [];
+		for (let i = 0; i < barColumns.length; i++) {
+			const isLast = i === barColumns.length - 1;
+			if (row === barLabelRows[i] && topLabels[i]) {
+				const label = topLabels[i]!;
+				// Use barWidth + gap for centering (absorb trailing gap)
+				const slotWidth = isLast ? barWidth : barWidth + gap;
+				const padLeft = Math.floor((slotWidth - label.length) / 2);
 				const centered =
 					" ".repeat(padLeft) +
-					trimmed +
-					" ".repeat(barWidth - padLeft - trimmed.length);
+					label +
+					" ".repeat(Math.max(0, slotWidth - padLeft - label.length));
 				rowParts.push(
 					<span key={i} fg={colors.textSecondary}>
 						{centered}
 					</span>,
 				);
 			} else {
-				rowParts.push(<span key={i}>{" ".repeat(barWidth)}</span>);
-			}
-			// Add space between bars
-			if (i < recentData.length - 1) {
-				rowParts.push(<span key={`sp-${i}`}> </span>);
+				const cell = barColumns[i]![row]!;
+				rowParts.push(
+					<span key={i} fg={cell.color}>
+						{cell.char.repeat(barWidth)}
+					</span>,
+				);
+				if (!isLast) {
+					rowParts.push(
+						<span key={`sp-${i}`}>{" ".repeat(gap)}</span>,
+					);
+				}
 			}
 		}
-
-		rows.push(<text key={row}>{rowParts}</text>);
+		rows.push(<text key={`row-${row}`}>{rowParts}</text>);
 	}
 
-	// Calculate total hours for display
-	const totalMs = recentData.reduce((sum, w) => sum + w.totalMs, 0);
-
-	// Build date labels row
-	const dateLabelParts: ReactNode[] = [];
+	// Baseline
+	const baselineParts: ReactNode[] = [];
 	for (let i = 0; i < recentData.length; i++) {
-		const week = recentData[i]!;
-		const trimmed = week.weekLabel.slice(0, barWidth);
-		const padLeft = Math.floor((barWidth - trimmed.length) / 2);
-		const centered =
-			" ".repeat(padLeft) +
-			trimmed +
-			" ".repeat(barWidth - padLeft - trimmed.length);
-		dateLabelParts.push(
-			<span key={i} fg={colors.textSecondary}>
-				{centered}
+		baselineParts.push(
+			<span key={i} fg={colors.borderSubtle}>
+				{"─".repeat(barWidth)}
 			</span>,
 		);
 		if (i < recentData.length - 1) {
-			dateLabelParts.push(<span key={`sp-${i}`}> </span>);
+			baselineParts.push(
+				<span key={`sp-${i}`} fg={colors.borderSubtle}>
+					{" ".repeat(gap)}
+				</span>,
+			);
 		}
 	}
+	rows.push(<text key="baseline">{baselineParts}</text>);
+
+	// Date labels
+	const dateLabels = recentData.map((week) => week.weekLabel);
+	rows.push(buildLabelRow(dateLabels, colors.textSecondary, "dates"));
+
+	const totalMs = recentData.reduce((sum, w) => sum + w.totalMs, 0);
 
 	return (
-		<box style={{ flexDirection: "column", gap: 1, width: "100%" }}>
-			{/* Bars (with hour labels at top) */}
+		<box style={{ flexDirection: "column", width: "100%" }}>
 			{rows}
-			{/* Date labels */}
-			<text>{dateLabelParts}</text>
-
-			{/* Legend - show top projects by time */}
+			{/* Legend */}
 			<box
-				style={{ flexDirection: "row", gap: 2, marginTop: 1, flexWrap: "wrap" }}
+				style={{
+					flexDirection: "row",
+					gap: 2,
+					marginTop: 1,
+					flexWrap: "wrap",
+				}}
 			>
 				{sortedProjects.slice(0, 4).map(([id, proj]) => (
 					<text key={id}>
 						<span fg={projectColorMap.get(id)}>●</span>
-						<span fg={colors.textSecondary}> {proj.name.slice(0, 12)}</span>
+						<span fg={colors.textSecondary}>
+							{" "}
+							{proj.name.slice(0, 12)}
+						</span>
 					</text>
 				))}
 				<text>

package/src/index.tsx

@@ -138,6 +138,14 @@ function showSplash(theme: Theme): boolean {
 }
 
 async function main() {
+	// Handle menubar subcommand before TUI setup
+	const args = process.argv.slice(2);
+	if (args[0] === "menubar") {
+		const { menubarCommand } = await import("./menubar/index.ts");
+		await menubarCommand(args.slice(1));
+		return;
+	}
+
 	// Get stored theme and show splash with ASCII paca
 	const theme = getStoredTheme();
 	const splashShown = showSplash(theme);

package/src/menubar/action.ts

@@ -0,0 +1,80 @@
+import { join } from "path";
+import { homedir } from "os";
+
+/**
+ * Returns the content of the action handler script.
+ * This script is invoked by SwiftBar when the user clicks a menu item.
+ */
+export function getActionScript(bunPath: string): string {
+  const dbPath = join(homedir(), ".paca", "paca.db");
+
+  return `#!${bunPath}
+// Paca SwiftBar Action Handler — auto-generated, do not edit
+
+import Database from "bun:sqlite";
+
+const DB_PATH = ${JSON.stringify(dbPath)};
+
+function openDb() {
+  const db = new Database(DB_PATH);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA busy_timeout=5000");
+  return db;
+}
+
+async function askDescription(): Promise<string> {
+  try {
+    const proc = Bun.spawnSync([
+      "osascript", "-e",
+      'display dialog "What did you work on?" default answer "" with title "Paca — Stop Timer" buttons {"Cancel", "Save"} default button "Save"',
+    ]);
+    const output = proc.stdout.toString().trim();
+    // osascript returns: "button returned:Save, text returned:my description"
+    const match = output.match(/text returned:(.*)/);
+    return match?.[1]?.trim() ?? "";
+  } catch {
+    return "";
+  }
+}
+
+async function main() {
+  const action = process.argv[2];
+  const id = process.argv[3];
+
+  if (!action || !id) {
+    console.error("Usage: action.ts <start|stop> <id>");
+    process.exit(1);
+  }
+
+  const db = openDb();
+
+  try {
+    if (action === "stop") {
+      const description = await askDescription();
+      db.query(
+        \`UPDATE TimeEntry SET endTime = datetime('now'), description = ?, updatedAt = datetime('now') WHERE id = ?\`
+      ).run(description || null, id);
+    } else if (action === "start") {
+      // Stop any running timer first
+      const running = db.query("SELECT id FROM TimeEntry WHERE endTime IS NULL LIMIT 1").get();
+      if (running) {
+        db.query(
+          \`UPDATE TimeEntry SET endTime = datetime('now'), updatedAt = datetime('now') WHERE id = ?\`
+        ).run(running.id);
+      }
+
+      // Start new timer
+      const newId = crypto.randomUUID();
+      db.query(
+        \`INSERT INTO TimeEntry (id, projectId, startTime, createdAt, updatedAt)
+         VALUES (?, ?, datetime('now'), datetime('now'), datetime('now'))\`
+      ).run(newId, id);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+main();
+`;
+}

package/src/menubar/db-lite.ts

@@ -0,0 +1,95 @@
+import Database from "bun:sqlite";
+import { join } from "path";
+import { homedir } from "os";
+
+const DB_PATH = join(homedir(), ".paca", "paca.db");
+
+function openDb(): Database {
+  const db = new Database(DB_PATH);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA busy_timeout=5000");
+  return db;
+}
+
+export interface RunningTimerRow {
+  id: string;
+  startTime: string;
+  projectId: string;
+  projectName: string;
+  projectColor: string;
+}
+
+export interface ProjectRow {
+  id: string;
+  name: string;
+  color: string;
+}
+
+export function getRunningTimer(): RunningTimerRow | null {
+  const db = openDb();
+  try {
+    const row = db
+      .query<RunningTimerRow, []>(
+        `SELECT te.id, te.startTime, te.projectId,
+                p.name AS projectName, p.color AS projectColor
+         FROM TimeEntry te
+         JOIN Project p ON p.id = te.projectId
+         WHERE te.endTime IS NULL
+         LIMIT 1`,
+      )
+      .get();
+    return row ?? null;
+  } finally {
+    db.close();
+  }
+}
+
+export function getProjects(): ProjectRow[] {
+  const db = openDb();
+  try {
+    return db
+      .query<ProjectRow, []>(
+        `SELECT id, name, color FROM Project WHERE archived = 0 ORDER BY name ASC`,
+      )
+      .all();
+  } finally {
+    db.close();
+  }
+}
+
+export function startTimer(projectId: string): void {
+  const db = openDb();
+  try {
+    // Stop any running timer first
+    const running = db
+      .query<{ id: string }, []>(
+        `SELECT id FROM TimeEntry WHERE endTime IS NULL LIMIT 1`,
+      )
+      .get();
+    if (running) {
+      db.query(
+        `UPDATE TimeEntry SET endTime = datetime('now'), updatedAt = datetime('now') WHERE id = ?`,
+      ).run(running.id);
+    }
+
+    // Start new timer
+    const id = crypto.randomUUID();
+    db.query(
+      `INSERT INTO TimeEntry (id, projectId, startTime, createdAt, updatedAt)
+       VALUES (?, ?, datetime('now'), datetime('now'), datetime('now'))`,
+    ).run(id, projectId);
+  } finally {
+    db.close();
+  }
+}
+
+export function stopTimer(entryId: string, description?: string): void {
+  const db = openDb();
+  try {
+    db.query(
+      `UPDATE TimeEntry SET endTime = datetime('now'), description = ?, updatedAt = datetime('now') WHERE id = ?`,
+    ).run(description ?? null, entryId);
+  } finally {
+    db.close();
+  }
+}

package/src/menubar/index.ts

@@ -0,0 +1,212 @@
+import { existsSync, writeFileSync, unlinkSync, chmodSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+import { getPluginScript } from "./plugin.ts";
+import { getActionScript } from "./action.ts";
+import { getRunningTimer, getProjects } from "./db-lite.ts";
+
+const PLUGIN_FILENAME = "paca-timer.3s.ts";
+const ACTION_FILENAME = "menubar-action.ts";
+const PACA_DIR = join(homedir(), ".paca");
+const ACTION_PATH = join(PACA_DIR, ACTION_FILENAME);
+
+function resolveBunPath(): string {
+  try {
+    return execSync("which bun", { encoding: "utf-8" }).trim();
+  } catch {
+    throw new Error("Could not find bun in PATH. Is Bun installed?");
+  }
+}
+
+function findSwiftBarPluginDir(): string | null {
+  // Try reading from SwiftBar defaults
+  try {
+    const dir = execSync(
+      "defaults read com.ameba.SwiftBar PluginDirectory 2>/dev/null",
+      { encoding: "utf-8" },
+    ).trim();
+    if (dir && existsSync(dir)) return dir;
+  } catch {
+    // ignore
+  }
+
+  // Check common locations
+  const candidates = [
+    join(homedir(), "Library", "Application Support", "SwiftBar", "Plugins"),
+    join(homedir(), ".swiftbar"),
+  ];
+
+  for (const dir of candidates) {
+    if (existsSync(dir)) return dir;
+  }
+
+  return null;
+}
+
+function isSwiftBarInstalled(): boolean {
+  return (
+    existsSync("/Applications/SwiftBar.app") ||
+    existsSync(join(homedir(), "Applications", "SwiftBar.app"))
+  );
+}
+
+function formatElapsed(startTimeStr: string): string {
+  const startMs = new Date(startTimeStr + "Z").getTime();
+  const elapsedMs = Date.now() - startMs;
+  const totalSec = Math.floor(elapsedMs / 1000);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor((totalSec % 3600) / 60);
+  const s = totalSec % 60;
+  return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+
+async function install() {
+  if (!isSwiftBarInstalled()) {
+    console.log("SwiftBar is not installed.");
+    console.log("");
+    console.log("Install it with:");
+    console.log("  brew install --cask swiftbar");
+    console.log("");
+    console.log("Then run this command again:");
+    console.log("  paca menubar install");
+    process.exit(1);
+  }
+
+  const pluginDir = findSwiftBarPluginDir();
+  if (!pluginDir) {
+    console.log("Could not find SwiftBar plugin directory.");
+    console.log("");
+    console.log("Make sure SwiftBar has been launched at least once,");
+    console.log("or set a plugin directory in SwiftBar preferences.");
+    process.exit(1);
+  }
+
+  const bunPath = resolveBunPath();
+  const pluginPath = join(pluginDir, PLUGIN_FILENAME);
+
+  // Write plugin script
+  writeFileSync(pluginPath, getPluginScript(bunPath), "utf-8");
+  chmodSync(pluginPath, 0o755);
+
+  // Write action script
+  writeFileSync(ACTION_PATH, getActionScript(bunPath), "utf-8");
+  chmodSync(ACTION_PATH, 0o755);
+
+  console.log("Paca menu bar plugin installed!");
+  console.log("");
+  console.log(`  Plugin: ${pluginPath}`);
+  console.log(`  Action: ${ACTION_PATH}`);
+  console.log("");
+  console.log("The timer should appear in your menu bar shortly.");
+  console.log("If not, open SwiftBar and refresh plugins.");
+}
+
+async function uninstall() {
+  let removed = false;
+
+  // Remove plugin
+  const pluginDir = findSwiftBarPluginDir();
+  if (pluginDir) {
+    const pluginPath = join(pluginDir, PLUGIN_FILENAME);
+    if (existsSync(pluginPath)) {
+      unlinkSync(pluginPath);
+      console.log(`Removed plugin: ${pluginPath}`);
+      removed = true;
+    }
+  }
+
+  // Remove action script
+  if (existsSync(ACTION_PATH)) {
+    unlinkSync(ACTION_PATH);
+    console.log(`Removed action script: ${ACTION_PATH}`);
+    removed = true;
+  }
+
+  if (removed) {
+    console.log("");
+    console.log("Paca menu bar plugin uninstalled.");
+  } else {
+    console.log("No menu bar plugin files found to remove.");
+  }
+}
+
+function status() {
+  const DB_PATH = join(PACA_DIR, "paca.db");
+  if (!existsSync(DB_PATH)) {
+    console.log("No database found. Run paca to initialize.");
+    return;
+  }
+
+  const running = getRunningTimer();
+  if (running) {
+    const elapsed = formatElapsed(running.startTime);
+    console.log(`Timer running: ${running.projectName} (${elapsed})`);
+  } else {
+    console.log("No timer running.");
+  }
+
+  const projects = getProjects();
+  if (projects.length > 0) {
+    console.log("");
+    console.log("Projects:");
+    for (const p of projects) {
+      console.log(`  - ${p.name}`);
+    }
+  }
+}
+
+function showHelp() {
+  const running = getRunningTimer();
+  if (running) {
+    const elapsed = formatElapsed(running.startTime);
+    console.log(`Timer: ${running.projectName} (${elapsed})`);
+  } else {
+    console.log("No timer running.");
+  }
+
+  console.log("");
+  console.log("Menu bar commands:");
+  console.log("  paca menubar install    Install SwiftBar plugin");
+  console.log("  paca menubar uninstall  Remove SwiftBar plugin");
+  console.log("  paca menubar status     Show current timer status");
+  console.log("");
+
+  if (!isSwiftBarInstalled()) {
+    console.log("SwiftBar is not installed. Install it with:");
+    console.log("  brew install --cask swiftbar");
+  } else {
+    const pluginDir = findSwiftBarPluginDir();
+    if (pluginDir) {
+      const pluginPath = join(pluginDir, PLUGIN_FILENAME);
+      if (existsSync(pluginPath)) {
+        console.log("Status: Plugin installed");
+      } else {
+        console.log("Status: SwiftBar found, plugin not installed");
+        console.log("  Run: paca menubar install");
+      }
+    } else {
+      console.log("Status: SwiftBar found, but no plugin directory set");
+      console.log("  Launch SwiftBar first, then run: paca menubar install");
+    }
+  }
+}
+
+export async function menubarCommand(args: string[]) {
+  const subcommand = args[0];
+
+  switch (subcommand) {
+    case "install":
+      await install();
+      break;
+    case "uninstall":
+      await uninstall();
+      break;
+    case "status":
+      status();
+      break;
+    default:
+      showHelp();
+      break;
+  }
+}

package/src/menubar/plugin.ts

@@ -0,0 +1,88 @@
+import { join } from "path";
+import { homedir } from "os";
+
+/**
+ * Returns the content of the SwiftBar plugin script.
+ * The script is a self-contained Bun script that reads the Paca DB
+ * and outputs SwiftBar-formatted text.
+ */
+export function getPluginScript(bunPath: string): string {
+  const dbPath = join(homedir(), ".paca", "paca.db");
+  const actionPath = join(homedir(), ".paca", "menubar-action.ts");
+
+  return `#!${bunPath}
+// Paca SwiftBar Plugin — auto-generated, do not edit
+// Refresh: every 3 seconds (from filename)
+
+import Database from "bun:sqlite";
+
+const DB_PATH = ${JSON.stringify(dbPath)};
+const ACTION = ${JSON.stringify(actionPath)};
+const BUN = ${JSON.stringify(bunPath)};
+
+function main() {
+  let db;
+  try {
+    db = new Database(DB_PATH, { readonly: true });
+    db.exec("PRAGMA busy_timeout=5000");
+  } catch {
+    console.log("⏸ Paca | color=#6c7086");
+    console.log("---");
+    console.log("Database not found | color=#f38ba8");
+    console.log("Run paca to initialize | color=#6c7086");
+    return;
+  }
+
+  try {
+    // Check for running timer
+    const running = db
+      .query(
+        \`SELECT te.id, te.startTime, p.name AS projectName, p.color AS projectColor
+         FROM TimeEntry te
+         JOIN Project p ON p.id = te.projectId
+         WHERE te.endTime IS NULL
+         LIMIT 1\`
+      )
+      .get();
+
+    if (running) {
+      // Calculate elapsed time
+      const startMs = new Date(running.startTime + "Z").getTime();
+      const elapsedMs = Date.now() - startMs;
+      const totalSec = Math.floor(elapsedMs / 1000);
+      const h = Math.floor(totalSec / 3600);
+      const m = Math.floor((totalSec % 3600) / 60);
+      const s = totalSec % 60;
+      const elapsed = \`\${h}:\${String(m).padStart(2, "0")}:\${String(s).padStart(2, "0")}\`;
+
+      console.log(\`▶ \${running.projectName} \${elapsed} | color=#a6e3a1 sfimage=timer\`);
+      console.log("---");
+      console.log(\`Stop Timer | bash=\${BUN} param1=\${ACTION} param2=stop param3=\${running.id} terminal=false refresh=true\`);
+    } else {
+      console.log("⏸ Paca | color=#6c7086 sfimage=timer");
+    }
+
+    console.log("---");
+
+    // List projects
+    const projects = db
+      .query("SELECT id, name, color FROM Project WHERE archived = 0 ORDER BY name ASC")
+      .all();
+
+    if (projects.length === 0) {
+      console.log("No projects yet | color=#6c7086");
+      console.log("Open paca to create one | color=#6c7086");
+    } else {
+      console.log("Start Timer For... | disabled=true color=#6c7086");
+      for (const p of projects) {
+        console.log(\`\${p.name} | bash=\${BUN} param1=\${ACTION} param2=start param3=\${p.id} terminal=false refresh=true color=\${p.color}\`);
+      }
+    }
+  } finally {
+    db.close();
+  }
+}
+
+main();
+`;
+}