hearth-dash 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AIDHD
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cli/commands/config.js

@@ -0,0 +1,26 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { banner, bold, dim, cyan, warn } from "../lib/ui.js";
+
+const CONFIG_PATH = join(homedir(), ".hearth-dash", "config.json");
+
+export default async function configCommand(args) {
+  banner();
+
+  if (!existsSync(CONFIG_PATH)) {
+    warn("No config found. Run 'hearth-dash deploy' first.");
+    process.exit(1);
+  }
+
+  const config = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+  console.log(bold("  Current Configuration\n"));
+  console.log(`  ${bold("Dashboard URL:")}  ${cyan(config.workerUrl || "not set")}`);
+  console.log(`  ${bold("Partner 1:")}      ${config.partner1 || "not set"}`);
+  console.log(`  ${bold("Partner 2:")}      ${config.partner2 || "not set"}`);
+  console.log(`  ${bold("Database ID:")}    ${config.dbId ? config.dbId.substring(0, 8) + "..." : "not set"}`);
+  console.log(`  ${bold("MCP Secret:")}     ${config.mcpSecret ? config.mcpSecret.substring(0, 6) + "..." : "not set"}`);
+  console.log(`  ${bold("Deployed:")}       ${config.deployedAt || "never"}`);
+  console.log(`\n  ${dim("Config file: " + CONFIG_PATH)}\n`);
+}

package/cli/commands/deploy.js

@@ -0,0 +1,216 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { getPackageRoot, getNodeMajor } from "../lib/platform.js";
+import { ask, confirm, password } from "../lib/prompts.js";
+import {
+  execWrangler, parseD1CreateOutput, parseDeployOutput,
+  checkWranglerAuth, wranglerLogin, setSecret, executeSchema, listD1Databases,
+} from "../lib/wrangler.js";
+import { banner, step, bold, dim, cyan, green, yellow, red, success, fail, warn, info, spinner } from "../lib/ui.js";
+
+const TOTAL_STEPS = 6;
+const CONFIG_DIR = join(homedir(), ".hearth-dash");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+function saveConfig(data) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  let existing = {};
+  if (existsSync(CONFIG_PATH)) {
+    try { existing = JSON.parse(readFileSync(CONFIG_PATH, "utf-8")); } catch {}
+  }
+  const merged = { ...existing, ...data };
+  writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  return merged;
+}
+
+function genSecret() {
+  return randomBytes(16).toString("base64url");
+}
+
+async function createD1OrReuse(dbName, cwd) {
+  const result = await execWrangler(["d1", "create", dbName], cwd);
+  if (result.code === 0) return parseD1CreateOutput(result);
+  const combined = result.stdout + result.stderr;
+  if (combined.includes("already exists") || combined.includes("already a database")) {
+    warn(`Database "${dbName}" already exists. Looking up ID...`);
+    const databases = await listD1Databases(cwd);
+    const db = databases.find((d) => d.name === dbName);
+    if (db) { info(`Found: ${db.uuid}`); return db.uuid; }
+    fail("Could not find existing database ID.");
+    return null;
+  }
+  fail(`Failed to create database: ${combined}`);
+  return null;
+}
+
+export default async function deployCommand(args) {
+  banner();
+  console.log(bold("  Full Cloudflare Deployment\n"));
+
+  // ── Step 1: Preflight ────────────────────────────────────
+
+  step(1, TOTAL_STEPS, "Preflight checks");
+
+  const nodeMajor = getNodeMajor();
+  if (nodeMajor < 18) { fail(`Node.js ${nodeMajor} detected. Need >= 18.`); process.exit(1); }
+  success(`Node.js ${process.version}`);
+
+  const wranglerCheck = await execWrangler(["--version"], ".");
+  if (wranglerCheck.code !== 0) {
+    fail("Wrangler not found. Install: npm install -g wrangler");
+    process.exit(1);
+  }
+  success(`Wrangler installed`);
+
+  const authed = await checkWranglerAuth(".");
+  if (!authed) {
+    warn("Not logged into Cloudflare. Opening browser...");
+    const loginOk = await wranglerLogin(".");
+    if (!loginOk) { fail("Cloudflare login failed."); process.exit(1); }
+  }
+  success("Cloudflare authenticated");
+
+  // ── Step 2: Configuration ────────────────────────────────
+
+  step(2, TOTAL_STEPS, "Configuration");
+
+  const partner1 = await ask("  Partner 1 name", "Partner 1");
+  const partner2 = await ask("  Partner 2 name (or AI name)", "AI");
+  const dashPassword = await password("  Dashboard password");
+  if (!dashPassword) { fail("Password is required."); process.exit(1); }
+  const mcpSecret = genSecret();
+  success("MCP secret generated");
+
+  console.log();
+  info("Weather requires a free OpenWeatherMap API key.");
+  info("Get one at: https://openweathermap.org/api");
+  const weatherKey = await ask("  OpenWeatherMap API key (or skip)");
+  let weatherLat = "", weatherLon = "";
+  if (weatherKey) {
+    info("Find your coordinates at: https://www.latlong.net");
+    weatherLat = await ask("  Latitude (e.g. 51.5074)", "51.5074");
+    weatherLon = await ask("  Longitude (e.g. -0.1278)", "-0.1278");
+  }
+
+  // ── Step 3: Create D1 database ───────────────────────────
+
+  step(3, TOTAL_STEPS, "Creating D1 database");
+
+  const pkgRoot = getPackageRoot();
+  const deployDir = join(CONFIG_DIR, "deploy");
+  mkdirSync(deployDir, { recursive: true });
+
+  // Copy worker files to deploy dir
+  const s1 = spinner("Copying source files");
+  for (const file of ["worker.js", "schema.sql", "wrangler.toml"]) {
+    const src = join(pkgRoot, file);
+    if (!existsSync(src)) { s1.fail(`Missing: ${file}`); process.exit(1); }
+    writeFileSync(join(deployDir, file), readFileSync(src, "utf-8"), "utf-8");
+  }
+  s1.stop("Source files copied");
+
+  const s2 = spinner("Creating D1 database");
+  const dbId = await createD1OrReuse("hearth-dash-db", deployDir);
+  if (!dbId) { s2.fail("D1 creation failed"); process.exit(1); }
+  s2.stop(`D1 database ready: ${dbId.substring(0, 8)}...`);
+
+  // ── Step 4: Create R2 bucket ─────────────────────────────
+
+  step(4, TOTAL_STEPS, "Creating R2 bucket");
+
+  const s3 = spinner("Creating R2 bucket");
+  const r2Result = await execWrangler(["r2", "bucket", "create", "hearth-dash-photos"], deployDir);
+  if (r2Result.code !== 0) {
+    const combined = r2Result.stdout + r2Result.stderr;
+    if (combined.includes("already exists")) {
+      s3.stop("R2 bucket already exists");
+    } else {
+      s3.fail(`R2 creation failed: ${combined}`);
+      process.exit(1);
+    }
+  } else {
+    s3.stop("R2 bucket created");
+  }
+
+  // Patch wrangler.toml with real values
+  let toml = readFileSync(join(deployDir, "wrangler.toml"), "utf-8");
+  toml = toml.replace("YOUR_D1_DATABASE_ID", dbId);
+  toml = toml.replace('PARTNER_1 = "Partner 1"', `PARTNER_1 = "${partner1}"`);
+  toml = toml.replace('PARTNER_2 = "Partner 2"', `PARTNER_2 = "${partner2}"`);
+  if (weatherLat) {
+    toml = toml.replace('# WEATHER_LAT = "52.5726"', `WEATHER_LAT = "${weatherLat}"`);
+    toml = toml.replace('# WEATHER_LON = "-0.2405"', `WEATHER_LON = "${weatherLon}"`);
+  }
+  writeFileSync(join(deployDir, "wrangler.toml"), toml, "utf-8");
+
+  // ── Step 5: Deploy worker + set secrets ──────────────────
+
+  step(5, TOTAL_STEPS, "Deploying worker");
+
+  const s4 = spinner("Setting secrets");
+  await setSecret("DASHBOARD_PASSWORD", dashPassword, deployDir);
+  await setSecret("MCP_SECRET", mcpSecret, deployDir);
+  if (weatherKey) await setSecret("WEATHER_API_KEY", weatherKey, deployDir);
+  s4.stop("Secrets configured");
+
+  const s5 = spinner("Deploying to Cloudflare Workers");
+  const deployResult = await execWrangler(["deploy"], deployDir);
+  if (deployResult.code !== 0) {
+    s5.fail("Deploy failed");
+    console.error(deployResult.stderr || deployResult.stdout);
+    process.exit(1);
+  }
+  const workerUrl = parseDeployOutput(deployResult);
+  s5.stop(`Deployed: ${workerUrl}`);
+
+  // Init schema
+  const s6 = spinner("Initializing database schema");
+  const schemaResult = await executeSchema("hearth-dash-db", join(deployDir, "schema.sql"), deployDir);
+  if (!schemaResult.ok) {
+    s6.fail("Schema init failed: " + (schemaResult.error || "unknown error"));
+    warn("You can retry manually: npx wrangler d1 execute hearth-dash-db --remote --file schema.sql");
+  } else {
+    s6.stop("Database schema initialized");
+  }
+
+  // ── Step 6: Save config + print results ──────────────────
+
+  step(6, TOTAL_STEPS, "Finishing up");
+
+  const config = saveConfig({
+    workerUrl,
+    mcpSecret,
+    partner1,
+    partner2,
+    dbId,
+    deployedAt: new Date().toISOString(),
+  });
+
+  const mcpUrl = workerUrl + "/mcp/" + mcpSecret;
+
+  console.log(`
+${green(bold("  Done!"))} Your dashboard is live.
+
+  ${bold("Dashboard:")}  ${cyan(workerUrl)}
+  ${bold("Password:")}   ${dim("(the one you just set)")}
+
+  ${bold("MCP Endpoint:")}
+  ${dim(mcpUrl)}
+
+  ${bold("MCP Config")} (add to Claude Code ${dim("~/.claude.json")} or Claude Desktop):
+${dim("  {")}
+${dim('    "mcpServers": {')}
+${dim('      "hearth-dash": {')}
+${dim('        "url": "' + mcpUrl + '"')}
+${dim("      }")}
+${dim("    }")}
+${dim("  }")}
+
+  ${bold("Connector URL")} (for Claude.ai mobile):
+  ${cyan(mcpUrl)}
+
+  ${dim("Config saved to: " + CONFIG_PATH)}
+`);
+}

package/cli/commands/mcp.js

@@ -0,0 +1,69 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { banner, bold, dim, cyan, warn, info } from "../lib/ui.js";
+
+const CONFIG_PATH = join(homedir(), ".hearth-dash", "config.json");
+
+export default async function mcpCommand(args) {
+  banner();
+
+  if (!existsSync(CONFIG_PATH)) {
+    warn("No config found. Run 'hearth-dash deploy' first.");
+    process.exit(1);
+  }
+
+  const config = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  const mcpUrl = config.workerUrl + "/mcp/" + config.mcpSecret;
+
+  console.log(bold("  MCP Configuration\n"));
+
+  console.log(`  ${bold("Endpoint:")} ${cyan(mcpUrl)}\n`);
+
+  console.log(`  ${bold("For Claude Code")} (add to ${dim("~/.claude.json")}):\n`);
+  console.log(`  {`);
+  console.log(`    "mcpServers": {`);
+  console.log(`      "hearth-dash": {`);
+  console.log(`        "url": "${mcpUrl}"`);
+  console.log(`      }`);
+  console.log(`    }`);
+  console.log(`  }\n`);
+
+  console.log(`  ${bold("For Claude Desktop")} (Settings > Developer > MCP):\n`);
+  console.log(`  Name:     hearth-dash`);
+  console.log(`  URL:      ${mcpUrl}\n`);
+
+  console.log(`  ${bold("Connector URL")} (for Claude.ai mobile):`);
+  console.log(`  ${cyan(mcpUrl)}\n`);
+
+  console.log(`  ${bold("Available MCP tools:")}`);
+  const tools = [
+    "hearth_status       — Dashboard overview",
+    "hearth_mood         — Get/set moods",
+    "hearth_note         — Get/leave fridge notes",
+    "hearth_moment       — List/add moments",
+    "hearth_date         — Upcoming/add dates",
+    "hearth_shopping_list — Get shopping list",
+    "hearth_shopping_add — Add shopping item",
+    "hearth_pressure     — Barometric pressure data",
+    "hearth_food_diary_today    — Today's meals + water",
+    "hearth_food_diary_history  — Historical food data",
+    "hearth_food_review  — Post food review",
+    "hearth_water_status — Water intake status",
+  ];
+  tools.forEach(t => console.log(`    ${dim(t)}`));
+  console.log();
+
+  if (args.includes("--install")) {
+    const { writeFileSync } = await import("node:fs");
+    const claudeConfigPath = join(homedir(), ".claude.json");
+    let claudeConfig = {};
+    if (existsSync(claudeConfigPath)) {
+      try { claudeConfig = JSON.parse(readFileSync(claudeConfigPath, "utf-8")); } catch {}
+    }
+    if (!claudeConfig.mcpServers) claudeConfig.mcpServers = {};
+    claudeConfig.mcpServers["hearth-dash"] = { url: mcpUrl };
+    writeFileSync(claudeConfigPath, JSON.stringify(claudeConfig, null, 2) + "\n", "utf-8");
+    info("MCP config written to " + claudeConfigPath);
+  }
+}

package/cli/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+import { bold, dim, magenta, cyan } from "./lib/ui.js";
+
+const [,, command, ...args] = process.argv;
+
+const COMMANDS = {
+  deploy: () => import("./commands/deploy.js"),
+  mcp:    () => import("./commands/mcp.js"),
+  config: () => import("./commands/config.js"),
+};
+
+async function main() {
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (command === "--version" || command === "-v") {
+    const { readFileSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const { getPackageRoot } = await import("./lib/platform.js");
+    try {
+      const pkg = JSON.parse(readFileSync(join(getPackageRoot(), "package.json"), "utf-8"));
+      console.log(pkg.version);
+    } catch { console.log("unknown"); }
+    process.exit(0);
+  }
+
+  const loader = COMMANDS[command];
+  if (!loader) {
+    console.error(`Unknown command: ${command}\n`);
+    printHelp();
+    process.exit(1);
+  }
+
+  const mod = await loader();
+  await mod.default(args);
+}
+
+function printHelp() {
+  console.log(`
+${magenta(bold("HEARTH DASH"))} ${dim("— Personal dashboard")}
+
+${bold("Usage:")} hearth-dash <command> [options]
+
+${bold("Commands:")}
+  ${cyan("deploy")}    Deploy to Cloudflare (Workers + D1 + R2)
+  ${cyan("mcp")}       Print MCP config for Claude Code/Desktop
+  ${cyan("config")}    View current configuration
+
+${bold("Quick start:")}
+  ${dim("$")} npx hearth-dash deploy
+  ${dim("$")} npx hearth-dash mcp
+
+${bold("Requirements:")}
+  - Node.js 18+
+  - Cloudflare account (free tier works)
+  - OpenWeatherMap API key (free at ${dim("https://openweathermap.org/api")})
+`);
+}
+
+main();

package/cli/lib/platform.js

@@ -0,0 +1,12 @@
+import { existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+
+export function getPackageRoot() {
+  const url = new URL("../..", import.meta.url);
+  const decoded = decodeURIComponent(url.pathname);
+  return decoded.replace(/^\/([A-Z]:)/, "$1").replace(/\/$/, "");
+}
+
+export function getNodeMajor() {
+  return parseInt(process.versions.node.split(".")[0], 10);
+}

package/cli/lib/prompts.js

@@ -0,0 +1,44 @@
+import { createInterface } from "node:readline";
+
+function rl() { return createInterface({ input: process.stdin, output: process.stdout }); }
+
+export function ask(question, defaultValue) {
+  return new Promise((resolve) => {
+    const r = rl();
+    const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+    r.question(prompt, (a) => { r.close(); resolve(a.trim() || defaultValue || ""); });
+  });
+}
+
+export function confirm(question) {
+  return new Promise((resolve) => {
+    const r = rl();
+    r.question(`${question} (y/N): `, (a) => { r.close(); resolve(a.trim().toLowerCase() === "y"); });
+  });
+}
+
+export function password(question) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    process.stdout.write(`${question}: `);
+    if (!stdin.isTTY || !stdin.setRawMode) {
+      const r = rl();
+      r.question("", (a) => { r.close(); resolve(a.trim()); });
+      return;
+    }
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    let input = "";
+    const onData = (buf) => {
+      const ch = buf.toString("utf8");
+      if (ch === "\r" || ch === "\n") {
+        stdin.setRawMode(wasRaw || false); stdin.removeListener("data", onData); stdin.pause();
+        process.stdout.write("\n"); resolve(input.trim());
+      } else if (ch === "\u0003") { stdin.setRawMode(wasRaw || false); process.exit(1); }
+      else if (ch === "\u007f" || ch === "\b") { if (input.length) { input = input.slice(0, -1); process.stdout.write("\b \b"); } }
+      else if (ch.charCodeAt(0) >= 32) { input += ch; process.stdout.write("*"); }
+    };
+    stdin.on("data", onData);
+  });
+}

package/cli/lib/ui.js

@@ -0,0 +1,41 @@
+const isColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const fmt = (code) => (text) => isColor ? `\x1b[${code}m${text}\x1b[0m` : text;
+
+export const bold = fmt("1");
+export const dim = fmt("2");
+export const red = fmt("31");
+export const green = fmt("32");
+export const yellow = fmt("33");
+export const cyan = fmt("36");
+export const magenta = fmt("35");
+
+export function banner() {
+  console.log(magenta(bold("\n  HEARTH DASH")));
+  console.log(dim("  Personal dashboard\n"));
+}
+
+export function step(n, total, text) {
+  console.log(cyan(`[${n}/${total}]`) + ` ${text}`);
+}
+
+export function success(text) { console.log(green("  \u2713 ") + text); }
+export function warn(text) { console.log(yellow("  ! ") + text); }
+export function fail(text) { console.log(red("  \u2717 ") + text); }
+export function info(text) { console.log(dim("  \u2192 ") + text); }
+
+const FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+
+export function spinner(text) {
+  if (!isColor) {
+    process.stdout.write(`  ${text}...`);
+    return { stop: (f) => console.log(` ${f || "done"}`), fail: (f) => console.log(` ${f || "failed"}`) };
+  }
+  let i = 0;
+  const id = setInterval(() => {
+    process.stdout.write(`\r  ${cyan(FRAMES[i++ % FRAMES.length])} ${text}`);
+  }, 80);
+  return {
+    stop(f) { clearInterval(id); process.stdout.write(`\r  ${green("\u2713")} ${f || text}\n`); },
+    fail(f) { clearInterval(id); process.stdout.write(`\r  ${red("\u2717")} ${f || text}\n`); },
+  };
+}

package/cli/lib/wrangler.js

@@ -0,0 +1,73 @@
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+function spawnCmd(cmd, args, opts) {
+  if (process.platform === "win32") {
+    const full = [cmd, ...args].map((a) => a.includes(" ") ? `"${a}"` : a).join(" ");
+    return spawn(full, [], { ...opts, shell: true });
+  }
+  return spawn(cmd, args, opts);
+}
+
+export function execWrangler(args, cwd, stdinData) {
+  return new Promise((resolve) => {
+    const proc = spawnCmd("npx", ["wrangler", ...args], {
+      cwd, stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, FORCE_COLOR: "0" },
+    });
+    let stdout = "", stderr = "";
+    proc.stdout.on("data", (d) => { stdout += d.toString(); });
+    proc.stderr.on("data", (d) => { stderr += d.toString(); });
+    if (stdinData) { proc.stdin.write(stdinData); proc.stdin.end(); }
+    else { proc.stdin.end(); }
+    proc.on("close", (code) => resolve({ stdout: stdout.trim(), stderr: stderr.trim(), code }));
+  });
+}
+
+export function parseD1CreateOutput(output) {
+  const combined = output.stdout + "\n" + output.stderr;
+  const match = combined.match(/database_id\s*=\s*"([^"]+)"/);
+  return match ? match[1] : null;
+}
+
+export function parseDeployOutput(output) {
+  const combined = output.stdout + "\n" + output.stderr;
+  const match = combined.match(/https:\/\/[^\s)]+\.workers\.dev/);
+  return match ? match[0] : null;
+}
+
+export async function checkWranglerAuth(cwd) {
+  const result = await execWrangler(["whoami"], cwd);
+  if (result.code !== 0) return false;
+  const combined = result.stdout + result.stderr;
+  return !combined.includes("Not logged in") && !combined.includes("not authenticated");
+}
+
+export async function wranglerLogin(cwd) {
+  return new Promise((resolve) => {
+    const proc = spawnCmd("npx", ["wrangler", "login"], { cwd, stdio: "inherit" });
+    proc.on("close", (code) => resolve(code === 0));
+  });
+}
+
+export async function setSecret(name, value, cwd) {
+  return execWrangler(["secret", "put", name], cwd, value + "\n");
+}
+
+export async function executeSchema(dbName, schemaPath, cwd) {
+  const result = await execWrangler(["d1", "execute", dbName, "--remote", "--file=" + schemaPath], cwd);
+  if (result.code === 0) return { ok: true };
+  const sql = readFileSync(schemaPath, "utf-8");
+  const statements = sql.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+  for (const stmt of statements) {
+    const r = await execWrangler(["d1", "execute", dbName, "--remote", "--command", stmt + ";"], cwd);
+    if (r.code !== 0) return { ok: false, error: r.stderr || r.stdout };
+  }
+  return { ok: true };
+}
+
+export async function listD1Databases(cwd) {
+  const result = await execWrangler(["d1", "list", "--json"], cwd);
+  if (result.code !== 0) return [];
+  try { return JSON.parse(result.stdout); } catch { return []; }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "hearth-dash",
+  "version": "1.0.0",
+  "description": "Personal dashboard — moods, moments, food diary, weather, and more. Deploy to Cloudflare in one command.",
+  "type": "module",
+  "bin": {
+    "hearth-dash": "./cli/index.js"
+  },
+  "scripts": {
+    "dev": "npx wrangler dev",
+    "deploy": "npx wrangler deploy",
+    "db:init": "npx wrangler d1 execute hearth-dash-db --file schema.sql",
+    "db:init:remote": "npx wrangler d1 execute hearth-dash-db --remote --file schema.sql"
+  },
+  "keywords": [
+    "dashboard",
+    "cloudflare-workers",
+    "mcp",
+    "mood-tracker",
+    "food-diary",
+    "weather",
+    "personal"
+  ],
+  "author": "AIDHD",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/martusha89/hearth-dash.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "worker.js",
+    "schema.sql",
+    "wrangler.toml",
+    "cli/",
+    "README.md",
+    "LICENSE"
+  ]
+}