@aitne-sh/aitne 0.1.0

package/scripts/run-node.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+
+/**
+ * Smart build-gate runner.
+ *
+ * 1. Checks whether TypeScript sources are newer than .buildstamp
+ * 2. If stale, runs `turbo run build` (respects shared → daemon dep order)
+ * 3. Spawns `node personal-agent.mjs` with the compiled output
+ */
+
+const SOURCE_DIRS = ["packages/shared/src", "packages/daemon/src", "packages/dashboard/src"];
+const CONFIG_FILES = [
+  "tsconfig.base.json",
+  "packages/shared/tsconfig.json",
+  "packages/shared/package.json",
+  "packages/daemon/tsconfig.json",
+  "packages/daemon/package.json",
+  "packages/dashboard/package.json",
+  "packages/dashboard/next.config.ts",
+  "packages/dashboard/postcss.config.mjs",
+  "package.json",
+];
+const DIST_ENTRY = "packages/daemon/dist/index.js";
+const DASHBOARD_BUILD_ID = "packages/dashboard/.next/BUILD_ID";
+
+const statMtime = (filePath) => {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return null;
+  }
+};
+
+const isExcludedSource = (filePath) => {
+  return (
+    filePath.endsWith(".test.ts") ||
+    filePath.endsWith(".test.tsx") ||
+    filePath.endsWith("test-helpers.ts")
+  );
+};
+
+const findLatestMtime = (dirPath) => {
+  let latest = null;
+  const queue = [dirPath];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    if (!current) continue;
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (isExcludedSource(fullPath)) continue;
+      const mtime = statMtime(fullPath);
+      if (mtime != null && (latest == null || mtime > latest)) {
+        latest = mtime;
+      }
+    }
+  }
+  return latest;
+};
+
+const readBuildStamp = (stampPath) => {
+  const mtime = statMtime(stampPath);
+  if (mtime == null) return { mtime: null };
+  return { mtime };
+};
+
+function hasAnySourceTree(cwd) {
+  return SOURCE_DIRS.some((relDir) => {
+    try {
+      return fs.statSync(path.join(cwd, relDir)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+
+/**
+ * True when running from a published `pnpm add -g aitne` install. The aitne
+ * tarball excludes packages/ — sub-packages live as siblings under node_modules
+ * (@aitne/daemon, @aitne/dashboard, @aitne/shared) and ship their own dist/.
+ * In this layout there is nothing to build at the consumer's cwd, and the
+ * build toolchain (turbo, tsc, next) is not installed.
+ */
+export function isPublishedInstall(cwd) {
+  return !hasAnySourceTree(cwd);
+}
+
+export function hasPackagedBuild(cwd) {
+  return (
+    statMtime(path.join(cwd, DIST_ENTRY)) != null &&
+    statMtime(path.join(cwd, DASHBOARD_BUILD_ID)) != null &&
+    !hasAnySourceTree(cwd)
+  );
+}
+
+/** Check if daemon TypeScript needs rebuilding. */
+export function shouldBuild(cwd) {
+  // Published install: nothing to build at cwd, build toolchain not installed.
+  if (isPublishedInstall(cwd)) return false;
+  // Legacy fallback: source-less tree with prebuilt artifacts at cwd.
+  if (hasPackagedBuild(cwd)) return false;
+
+  const stampPath = path.join(cwd, ".buildstamp");
+
+  if (process.env.PA_FORCE_BUILD === "1") return true;
+
+  const stamp = readBuildStamp(stampPath);
+  if (stamp.mtime == null) return true;
+
+  if (statMtime(path.join(cwd, DIST_ENTRY)) == null) return true;
+  if (statMtime(path.join(cwd, DASHBOARD_BUILD_ID)) == null) return true;
+
+  for (const relPath of CONFIG_FILES) {
+    const mtime = statMtime(path.join(cwd, relPath));
+    if (mtime != null && mtime > stamp.mtime) return true;
+  }
+
+  for (const relDir of SOURCE_DIRS) {
+    const srcMtime = findLatestMtime(path.join(cwd, relDir));
+    if (srcMtime != null && srcMtime > stamp.mtime) return true;
+  }
+
+  return false;
+}
+
+/** Write .buildstamp after a successful build. */
+export function writeBuildStamp(cwd) {
+  const stampPath = path.join(cwd, ".buildstamp");
+  try {
+    const stamp = { builtAt: Date.now() };
+    fs.writeFileSync(stampPath, `${JSON.stringify(stamp)}\n`);
+  } catch (error) {
+    log(`Failed to write build stamp: ${error?.message ?? "unknown error"}`);
+  }
+}
+
+/** Run turbo build. Returns exit code. */
+export async function runBuild(cwd, { quiet = false } = {}) {
+  if (!quiet) log("Building TypeScript (dist is stale).");
+  const stdio = quiet ? ["ignore", "pipe", "pipe"] : "inherit";
+  // pnpm is installed as `pnpm.cmd` (and `.ps1`) on Windows. Batch shims
+  // require a shell on Windows; POSIX keeps shell:false for predictable argv
+  // handling.
+  const pnpmBin = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+  const build = spawn(pnpmBin, ["run", "build"], {
+    cwd,
+    env: process.env,
+    stdio,
+    windowsHide: true,
+    shell: process.platform === "win32",
+  });
+  let output = "";
+  if (quiet) {
+    build.stdout?.on("data", (chunk) => { output += chunk; });
+    build.stderr?.on("data", (chunk) => { output += chunk; });
+  }
+  const res = await new Promise((resolve) => {
+    build.on("exit", (exitCode, exitSignal) => resolve({ exitCode, exitSignal }));
+  });
+  const code = res.exitSignal ? 1 : (res.exitCode ?? 0);
+  if (quiet && code !== 0) {
+    process.stderr.write(output);
+  }
+  return code;
+}
+
+/** Ensure build is fresh. Returns exit code (0 = ok). */
+export async function ensureBuild(cwd, { quiet = false } = {}) {
+  if (!shouldBuild(cwd)) return 0;
+  const code = await runBuild(cwd, { quiet });
+  if (code === 0) writeBuildStamp(cwd);
+  return code;
+}
+
+export function log(message) {
+  if (process.env.PA_RUNNER_LOG === "0") return;
+  process.stderr.write(`[aiservant] ${message}\n`);
+}
+
+// ── Direct execution: build-if-needed → run daemon ──
+
+async function runNodeMain() {
+  const cwd = process.cwd();
+  const args = process.argv.slice(2);
+
+  const buildCode = await ensureBuild(cwd);
+  if (buildCode !== 0) return buildCode;
+
+  const child = spawn(process.execPath, ["personal-agent.mjs", ...args], {
+    cwd,
+    env: process.env,
+    stdio: "inherit",
+  });
+  const res = await new Promise((resolve) => {
+    child.on("exit", (exitCode, exitSignal) => resolve({ exitCode, exitSignal }));
+  });
+  if (res.exitSignal) return 1;
+  return res.exitCode ?? 1;
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  void runNodeMain()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+}

package/scripts/smoke-obsidian-api.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+/**
+ * In-process smoke test for the Obsidian API routes.
+ *
+ * Purpose: verify empirically that the new PUT/DELETE endpoints — and
+ * the `path=` CLI semantics they rely on — actually work against the
+ * real Obsidian CLI and a real vault. The vitest suite mocks the
+ * ObsidianService entirely, so it cannot catch wrong argument names,
+ * missing CLI flags, or vault-level semantic mismatches.
+ *
+ * Strategy: mount the freshly-built routes against a real
+ * ObsidianService pointing at the real vault, then drive the full
+ * CRUD lifecycle via Hono's in-process `app.request`. No daemon
+ * restart, no network, no port conflict.
+ *
+ * Safety:
+ *   - All writes target a single `__smoketest_obsidian_api.md` path
+ *     prefixed with `__` so it's visually obvious in the vault.
+ *   - The lifecycle ends with DELETE, so a successful run leaves no
+ *     residue.
+ *   - On any failure we attempt a best-effort DELETE before exiting.
+ */
+
+import { createObsidianRoutes } from "../packages/daemon/dist/api/routes/obsidian.js";
+import { ObsidianService } from "../packages/daemon/dist/services/obsidian.js";
+
+const TEST_PATH = "__smoketest_obsidian_api";
+const VAULT_PATH =
+  process.env.PA_EXTERNAL_OBSIDIAN_VAULT_PATH ??
+  process.env.PA_OBSIDIAN_VAULT_PATH ??
+  "/Users/test/Library/Mobile Documents/iCloud~md~obsidian/Documents/personal-agent";
+const VAULT_NAME =
+  process.env.PA_EXTERNAL_OBSIDIAN_VAULT_NAME ??
+  process.env.PA_OBSIDIAN_VAULT_NAME ??
+  "personal-agent";
+
+const config = {
+  externalObsidianVaultPath: VAULT_PATH,
+  externalObsidianVaultName: VAULT_NAME,
+};
+
+const service = new ObsidianService(config);
+const app = createObsidianRoutes({ obsidianService: service });
+
+let pass = 0;
+let fail = 0;
+const failures = [];
+
+function ok(label, cond, detail) {
+  if (cond) {
+    pass += 1;
+    console.log(`  \u2713 ${label}`);
+  } else {
+    fail += 1;
+    failures.push(`${label}${detail ? ` — ${detail}` : ""}`);
+    console.log(`  \u2717 ${label}${detail ? ` — ${detail}` : ""}`);
+  }
+}
+
+async function request(method, path, body) {
+  const init = { method };
+  if (body !== undefined) {
+    init.headers = { "Content-Type": "application/json" };
+    init.body = JSON.stringify(body);
+  }
+  const res = await app.request(path, init);
+  let json = null;
+  try {
+    json = await res.json();
+  } catch {}
+  return { status: res.status, json };
+}
+
+async function bestEffortCleanup() {
+  try {
+    await request("DELETE", `/obsidian/notes/${TEST_PATH}`);
+  } catch {}
+}
+
+async function main() {
+  console.log(`Vault: ${VAULT_PATH}`);
+  console.log(`Test path: ${TEST_PATH}.md`);
+  console.log();
+
+  // --- Precondition: status ---
+  console.log("1. Precondition");
+  const status = await request("GET", "/obsidian/status");
+  ok("status=200", status.status === 200);
+  ok("available=true", status.json?.available === true, JSON.stringify(status.json));
+  ok("obsidianRunning=true", status.json?.obsidianRunning === true, JSON.stringify(status.json));
+  if (status.json?.obsidianRunning !== true) {
+    console.error("\nObsidian app is not running — aborting smoke test.");
+    process.exit(2);
+  }
+
+  // Make sure we start clean (in case a previous run crashed mid-lifecycle).
+  await bestEffortCleanup();
+
+  // --- Step 2: PUT creates a new note (idempotent create-or-replace) ---
+  console.log("\n2. PUT create-path");
+  const body1 = "# Smoke test v1\n\nLine A\n";
+  const put1 = await request("PUT", `/obsidian/notes/${TEST_PATH}`, { content: body1 });
+  ok("PUT status=200", put1.status === 200, `got ${put1.status} ${JSON.stringify(put1.json)}`);
+  ok("PUT status field=updated", put1.json?.status === "updated");
+
+  // --- Step 3: GET returns the created content ---
+  console.log("\n3. GET read back");
+  const get1 = await request("GET", `/obsidian/notes/${TEST_PATH}`);
+  ok("GET status=200", get1.status === 200);
+  ok(
+    "GET content matches v1",
+    typeof get1.json?.content === "string" && get1.json.content.includes("Line A"),
+    `got ${JSON.stringify(get1.json?.content)?.slice(0, 80)}`,
+  );
+
+  // --- Step 4: PUT overwrites with new content ---
+  console.log("\n4. PUT overwrite");
+  const body2 = "# Smoke test v2\n\nLine B only\n";
+  const put2 = await request("PUT", `/obsidian/notes/${TEST_PATH}`, { content: body2 });
+  ok("PUT status=200", put2.status === 200);
+
+  const get2 = await request("GET", `/obsidian/notes/${TEST_PATH}`);
+  ok("GET status=200", get2.status === 200);
+  ok(
+    "GET content matches v2",
+    typeof get2.json?.content === "string"
+      && get2.json.content.includes("Line B only")
+      && !get2.json.content.includes("Line A"),
+    `got ${JSON.stringify(get2.json?.content)?.slice(0, 80)}`,
+  );
+
+  // --- Step 5: DELETE removes the note ---
+  console.log("\n5. DELETE");
+  const del1 = await request("DELETE", `/obsidian/notes/${TEST_PATH}`);
+  ok("DELETE status=200", del1.status === 200, `got ${del1.status} ${JSON.stringify(del1.json)}`);
+  ok("DELETE status field=deleted", del1.json?.status === "deleted");
+  ok("DELETE permanent=false (default)", del1.json?.permanent === false);
+
+  // --- Step 6: DELETE again → 404 (idempotent) ---
+  console.log("\n6. DELETE idempotent 404");
+  const del2 = await request("DELETE", `/obsidian/notes/${TEST_PATH}`);
+  ok("Second DELETE status=404", del2.status === 404, `got ${del2.status} ${JSON.stringify(del2.json)}`);
+  ok("error=not_found", del2.json?.error === "not_found");
+
+  // --- Step 7: GET after delete → 404 ---
+  console.log("\n7. GET after delete");
+  const get3 = await request("GET", `/obsidian/notes/${TEST_PATH}`);
+  ok("GET status=404", get3.status === 404, `got ${get3.status} ${JSON.stringify(get3.json)}`);
+
+  // --- Summary ---
+  console.log();
+  console.log("─".repeat(48));
+  console.log(`Passed: ${pass}   Failed: ${fail}`);
+  if (fail > 0) {
+    console.log("\nFailures:");
+    for (const f of failures) console.log(`  - ${f}`);
+    process.exit(1);
+  }
+  console.log("All smoke checks passed.");
+}
+
+main().catch(async (err) => {
+  console.error("Smoke test threw:", err);
+  await bestEffortCleanup();
+  process.exit(1);
+});

package/scripts/start.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { ensureBuild, log } from "./run-node.mjs";
+import { openBrowser, waitForHttpReady } from "./browser.mjs";
+
+const IS_WINDOWS = process.platform === "win32";
+const requireFromScript = createRequire(import.meta.url);
+
+/**
+ * Resolve the `next` binary for the current OS — see bin/aitne.mjs
+ * for the full rationale. Duplicated rather than shared to keep these
+ * scripts dependency-free of one another at module-load time.
+ */
+function resolveNextBin(dashboardDir) {
+  try {
+    requireFromScript.resolve("next/dist/bin/next");
+    return process.execPath;
+  } catch {
+    // Fall through to legacy .bin probing.
+  }
+  const binDir = path.join(dashboardDir, "node_modules", ".bin");
+  if (IS_WINDOWS) {
+    const direct = path.join(dashboardDir, "node_modules", "next", "dist", "bin", "next");
+    if (fs.existsSync(direct)) return process.execPath;
+    const cmd = path.join(binDir, "next.cmd");
+    if (fs.existsSync(cmd)) return cmd;
+  }
+  return path.join(binDir, "next");
+}
+
+function nextSpawnArgs(dashboardDir, nextBin, userArgs) {
+  if (nextBin === process.execPath) {
+    try {
+      return [requireFromScript.resolve("next/dist/bin/next"), ...userArgs];
+    } catch {
+      // Fall through to Windows legacy direct-path probing.
+    }
+    const direct = path.join(
+      dashboardDir, "node_modules", "next", "dist", "bin", "next",
+    );
+    return [direct, ...userArgs];
+  }
+  return userArgs;
+}
+
+/**
+ * Start daemon + dashboard together.
+ *
+ * 1. Build TypeScript if stale
+ * 2. Spawn daemon (personal-agent.mjs)
+ * 3. Spawn dashboard (next dev)
+ * 4. Auto-open browser when dashboard is ready (unless --no-open)
+ * 5. Ctrl+C stops both
+ */
+
+const DASHBOARD_PORT = parseInt(process.env.PA_DASHBOARD_PORT || "3000", 10);
+const noOpen = process.argv.slice(2).includes("--no-open");
+const children = [];
+let shuttingDown = false;
+
+// ── 1. Build ──
+
+const cwd = process.cwd();
+const buildCode = await ensureBuild(cwd);
+if (buildCode !== 0) process.exit(buildCode);
+
+// ── 2. Spawn daemon ──
+
+log("Starting daemon...");
+const daemon = spawn(process.execPath, ["personal-agent.mjs"], {
+  cwd,
+  env: process.env,
+  stdio: "inherit",
+});
+children.push(daemon);
+
+// ── 3. Spawn dashboard ──
+
+log("Starting dashboard...");
+// Resolve dashboard via package.json so this works in both workspace dev
+// (pnpm symlinks node_modules/@aitne/dashboard → packages/dashboard) and
+// global installs (where @aitne/dashboard is a sibling node_modules entry).
+let dashboardDir;
+try {
+  dashboardDir = path.dirname(requireFromScript.resolve("@aitne/dashboard/package.json"));
+} catch {
+  dashboardDir = path.join(cwd, "packages/dashboard");
+}
+const nextBin = resolveNextBin(dashboardDir);
+const dashArgs = nextSpawnArgs(dashboardDir, nextBin, [
+  "dev", "--port", String(DASHBOARD_PORT),
+]);
+const dashboard = spawn(nextBin, dashArgs, {
+  cwd: dashboardDir,
+  env: process.env,
+  stdio: "inherit",
+  windowsHide: true,
+  shell: IS_WINDOWS && nextBin.toLowerCase().endsWith(".cmd"),
+});
+children.push(dashboard);
+
+// ── 4. Auto-open browser ──
+
+if (!noOpen) {
+  const url = `http://localhost:${DASHBOARD_PORT}`;
+  waitForHttpReady(url, {
+    // `next dev` can take ~30s on a cold boot; give it headroom.
+    timeoutMs: 60_000,
+    liveness: [
+      () => !shuttingDown,
+      () => !daemon.killed,
+      () => !dashboard.killed,
+    ],
+  })
+    .then(async (ready) => {
+      if (!ready) {
+        if (!shuttingDown) log("Dashboard did not become ready in time");
+        return;
+      }
+      log(`Dashboard ready — opening ${url}`);
+      await openBrowser(url);
+    })
+    .catch((err) => {
+      if (!shuttingDown) log(`Browser-open error: ${err?.message ?? err}`);
+    });
+}
+
+// ── 5. Graceful shutdown ──
+
+function shutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log(`${signal} received, shutting down...`);
+  for (const child of children) {
+    if (!child.killed) child.kill(signal);
+  }
+}
+
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+if (process.platform === "win32") {
+  process.on("SIGBREAK", () => shutdown("SIGBREAK"));
+}
+
+// Exit when both children exit
+let exited = 0;
+const exitCodes = [];
+for (const child of children) {
+  child.on("exit", (code) => {
+    exitCodes.push(code ?? 1);
+    exited++;
+    if (exited >= children.length) {
+      process.exit(Math.max(...exitCodes));
+    }
+  });
+}