@aitne-sh/aitne 0.1.8 → 0.1.10

package/scripts/lib/process-identity.mjs

@@ -0,0 +1,193 @@
+/**
+ * Process start-identity helpers for the Aitne launcher (`bin/aitne.mjs`).
+ *
+ * WHY THIS EXISTS — process-lifecycle-2 (CROSS_PLATFORM_REAUDIT_2026-06.md).
+ * The launcher trusts a bare PID: `process.kill(pid, 0)` is true for *any* live
+ * process owning that PID. After an unclean shutdown the stale `daemon.pid` /
+ * `dashboard.pid` can point at a PID the OS has recycled to an unrelated
+ * process, so `aitne start` false-positives "Already running" and `aitne stop`
+ * can `taskkill /T /F` (Windows) or group-kill (POSIX) the wrong process tree.
+ *
+ * FIX — pair the PID with the OS-reported process **start time**, captured at
+ * write time and re-read at check time. A recycled PID has a different start
+ * time, so an exact-string mismatch flags it stale. We compare the *same* OS
+ * field to *itself* on the *same* machine, so no absolute-time conversion,
+ * clock-skew tolerance, or locale handling is needed.
+ *
+ * WHERE THIS LIVES — `scripts/lib/` (plain ESM), because `bin/aitne.mjs` runs
+ * *before* the TypeScript build that produces `@aitne/shared` (running `aitne
+ * start` is what triggers that build) and the published package ships only
+ * `bin` + `scripts` + `agent-assets`. The pure functions here are pinned by a
+ * peer `.test.ts` under the daemon/shared `src` tree (the `ports.mjs`
+ * precedent), so they run under the standard vitest suite. The win32 read branch
+ * carries the usual "no Windows runtime validation" caveat; by construction it
+ * can only *degrade* to the legacy bare-PID behavior, never make things worse.
+ */
+import { execFileSync } from "node:child_process";
+import { accessSync, constants, readFileSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import process from "node:process";
+
+/**
+ * Serialize PID metadata to the pidfile.
+ *
+ * Line 1 is the bare PID so an *older* aitne (which parses only line 1) still
+ * reads files written by this version — downgrade-safe. The identity token is
+ * written as a trailing `key=value` line (not positional) so a future field can
+ * be added without breaking parse order; {@link parsePidMeta} already ignores
+ * unknown keys. An absent token is omitted.
+ */
+export function serializePidMeta({ pid, startToken = null }) {
+  let out = `${pid}\n`;
+  if (startToken != null) {
+    const token = String(startToken).replace(/[\r\n]+/g, " ").trim();
+    if (token.length > 0) out += `start=${token}\n`;
+  }
+  return out;
+}
+
+/**
+ * Parse a pidfile written by {@link serializePidMeta} OR a legacy single-line
+ * (`<pid>\n`) file. Returns `null` if line 1 is not a finite integer. Unknown
+ * trailer keys are ignored, so the format stays forward-compatible.
+ */
+export function parsePidMeta(content) {
+  if (typeof content !== "string") return null;
+  const lines = content.split(/\r?\n/);
+  const pid = Number.parseInt((lines[0] ?? "").trim(), 10);
+  if (!Number.isFinite(pid)) return null;
+  let startToken = null;
+  for (const line of lines.slice(1)) {
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    const val = line.slice(eq + 1).trim();
+    if (key === "start") startToken = val.length > 0 ? val : null;
+  }
+  return { pid, startToken };
+}
+
+/**
+ * Extract field 22 (`starttime`, clock-ticks since boot) from `/proc/<pid>/stat`.
+ *
+ * The `comm` field (field 2) is wrapped in parens and may itself contain spaces
+ * and `)`, so the only safe split point is the LAST `)` — everything after it
+ * is space-separated starting at field 3 (state). field 22 is therefore index
+ * `22 - 3 = 19` in that tail. Boot-relative, so immune to wall-clock changes;
+ * across a reboot the recorded value's epoch is gone, which correctly reads as
+ * a mismatch (stale).
+ */
+export function parseLinuxStat(statContent) {
+  if (typeof statContent !== "string") return null;
+  const close = statContent.lastIndexOf(")");
+  if (close < 0) return null;
+  const fields = statContent.slice(close + 1).trim().split(/\s+/);
+  const starttime = fields[19];
+  return starttime && /^\d+$/.test(starttime) ? starttime : null;
+}
+
+/**
+ * Resolve the PowerShell executable on Windows. Prefer Windows PowerShell 5.1
+ * (`powershell.exe`), fall back to PowerShell 7+ (`pwsh.exe`) for minimal /
+ * Server-Core / pwsh-7-only hosts, else keep the default so a missing host
+ * surfaces a clear ENOENT. Mirrors `browser-history/lifecycle/platform.ts`.
+ */
+/* c8 ignore start -- win32-only path resolution; the POSIX test runner never enters this */
+function resolveWindowsPowerShell() {
+  const pathValue = process.env.PATH ?? "";
+  const exts = process.env.PATHEXT?.split(";").filter(Boolean) ?? [".EXE"];
+  const probe = (name) => {
+    const hasExt = /\.[A-Za-z0-9]+$/.test(name);
+    for (const dir of pathValue.split(delimiter)) {
+      if (!dir) continue;
+      const candidates = hasExt ? [name] : exts.map((e) => `${name}${e}`);
+      for (const c of candidates) {
+        try {
+          accessSync(join(dir, c), constants.X_OK);
+          return true;
+        } catch {
+          // keep scanning
+        }
+      }
+    }
+    return false;
+  };
+  return probe("powershell.exe") ? "powershell.exe" : probe("pwsh.exe") ? "pwsh.exe" : "powershell.exe";
+}
+/* c8 ignore stop */
+
+/**
+ * Read an opaque, OS-native start-time token for `pid`, or `null` if the PID is
+ * gone / the read fails. The token is compared *only* for exact-string equality
+ * against a token captured earlier for the same PID on the same machine, so its
+ * format is irrelevant as long as it is stable for a given process incarnation.
+ *
+ * `deps` is for testing — inject `platform` / `execFileSync` / `readFileSync`
+ * to exercise a branch off its native OS without touching the real system.
+ * Reads use `execFileSync` (never a shell) with a timeout; the PID is numeric,
+ * so there is no injection surface, but args stay arrayed on principle.
+ */
+export function readProcessStartToken(pid, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const exec = deps.execFileSync ?? execFileSync;
+  const readFile = deps.readFileSync ?? readFileSync;
+  if (pid == null || !Number.isFinite(Number(pid))) return null;
+  try {
+    if (platform === "linux") {
+      return parseLinuxStat(readFile(`/proc/${pid}/stat`, "utf8"));
+    }
+    if (platform === "darwin") {
+      const out = exec("ps", ["-o", "lstart=", "-p", String(pid)], {
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5_000,
+        windowsHide: true,
+      });
+      const token = String(out).replace(/[\r\n]+/g, " ").trim();
+      return token.length > 0 ? token : null;
+    }
+    /* c8 ignore start -- win32-only; not reachable from the POSIX test runner */
+    if (platform === "win32") {
+      const ps = resolveWindowsPowerShell();
+      const out = exec(
+        ps,
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `(Get-Process -Id ${Number(pid)} -ErrorAction Stop).StartTime.ToString('o')`,
+        ],
+        { stdio: ["ignore", "pipe", "ignore"], timeout: 5_000, windowsHide: true },
+      );
+      const token = String(out).replace(/[\r\n]+/g, " ").trim();
+      return token.length > 0 ? token : null;
+    }
+    /* c8 ignore stop */
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Classify a pidfile's recorded process against the live system.
+ *
+ * - `stale`              — dead, or alive but the start-time token *differs*
+ *                          (PID recycled). Caller should remove the pidfile.
+ * - `running-ours`       — alive and the start-time token matches.
+ * - `running-unverified` — alive but identity can't be confirmed: a legacy file
+ *                          with no token, or the OS start-time read failed.
+ *                          Caller treats this as running (the pre-fix bare-PID
+ *                          behavior), so the change can never regress; a legacy
+ *                          file self-heals on the next `writePid`.
+ *
+ * `isAlive` / `readToken` are injected so the decision is pure and fully
+ * unit-testable without touching real processes.
+ */
+export function classifyPid(meta, { readToken, isAlive }) {
+  if (meta == null || meta.pid == null) return "stale";
+  if (!isAlive(meta.pid)) return "stale";
+  if (meta.startToken == null) return "running-unverified";
+  const live = readToken(meta.pid);
+  if (live == null) return "running-unverified";
+  return live === meta.startToken ? "running-ours" : "stale";
+}

package/scripts/lib/read-api-token.mjs

@@ -0,0 +1,176 @@
+/**
+ * Cross-platform reader for the daemon's `apiToken` secret.
+ *
+ * CLI scripts (`run-now`, `remint-roadmap-ids`) need the daemon's apiToken to
+ * call Approve-tier `/api/...` routes, but they intentionally must run WITHOUT
+ * a successful `@aitne/shared` build (which only ships `./dist/*.js`). So this
+ * helper re-implements the per-OS read inline, mirroring the secret clients in
+ * `packages/shared/src/`:
+ *
+ *   - darwin → macOS Keychain via `security` (service com.personal-agent.secret.apiToken)
+ *   - win32  → DPAPI: decrypt ~/.personal-agent/secrets/apiToken.dpapi via PowerShell
+ *   - linux  → libsecret (`secret-tool lookup`), else the AES-256-GCM file store
+ *   - WSL / other → the AES-256-GCM file store
+ *
+ * The file-store format/params and the DPAPI script are copied verbatim from
+ * `secret-client-file.ts` / `secret-client-windows.ts` — keep them in sync if
+ * those change. The secret clients hardcode `~/.personal-agent/secrets` (they
+ * do NOT honor PA_DATA_DIR), so this helper uses the same homedir-relative
+ * location to find what the daemon actually wrote.
+ *
+ * Returns the token string, or null when it cannot be read; the caller decides
+ * how to message the failure. Best-effort: never throws (so a CLI never dies
+ * with a raw stack trace on a misconfigured secret store).
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createDecipheriv, scryptSync } from "node:crypto";
+
+const SECRET_NAME = "apiToken";
+const KEYCHAIN_SERVICE = "com.personal-agent.secret.apiToken";
+
+function secretsDir() {
+  return join(homedir(), ".personal-agent", "secrets");
+}
+
+/** @returns {string | null} the daemon apiToken, or null if unreadable. */
+export function readApiToken() {
+  const platform = process.platform;
+  if (platform === "darwin") return readDarwin();
+  if (platform === "win32") return readWindows();
+  if (platform === "linux") {
+    if (!isWsl() && whichSync("secret-tool")) {
+      const fromKeyring = readSecretTool();
+      if (fromKeyring) return fromKeyring;
+    }
+    return readFileStore();
+  }
+  return readFileStore();
+}
+
+function readDarwin() {
+  // Byte-identical to the historical `security` read so macOS cannot regress.
+  try {
+    return execFileSync(
+      "security",
+      ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-w"],
+      { encoding: "utf-8", timeout: 5_000 },
+    ).trim();
+  } catch {
+    return null;
+  }
+}
+
+/** Cross-platform `which`, returning the resolved path or null. */
+function whichSync(cmd) {
+  const tool = process.platform === "win32" ? "where" : "which";
+  try {
+    const out = execFileSync(tool, [cmd], {
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2_000,
+    });
+    return out.toString().split(/\r?\n/)[0]?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function readWindows() {
+  const path = join(secretsDir(), `${SECRET_NAME}.dpapi`);
+  if (!existsSync(path)) return null;
+  const encrypted = readFileSync(path, "utf-8").trim();
+  // Prefer in-box Windows PowerShell 5.1, fall back to PowerShell 7+ (pwsh),
+  // matching the daemon's secret-client-factory resolution order.
+  const psBinary = whichSync("powershell.exe")
+    ? "powershell.exe"
+    : whichSync("pwsh.exe")
+      ? "pwsh.exe"
+      : "powershell.exe";
+  // Mirrors WindowsDpapiSecretClient.get(): DPAPI-decrypt via
+  // ConvertTo-SecureString and marshal back to plaintext. The ciphertext is
+  // passed via stdin, never interpolated into the script, to avoid injection.
+  const script = [
+    "$enc = [System.Console]::In.ReadToEnd().Trim()",
+    "$ss = ConvertTo-SecureString $enc",
+    "$bstr = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($ss)",
+    "try { [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($bstr) }",
+    "finally { [System.Runtime.InteropServices.Marshal]::ZeroFreeBSTR($bstr) }",
+  ].join("; ");
+  try {
+    const out = execFileSync(
+      psBinary,
+      ["-NoProfile", "-NonInteractive", "-Command", script],
+      { input: encrypted, encoding: "utf-8", timeout: 10_000 },
+    );
+    return out.trimEnd() || null;
+  } catch {
+    return null;
+  }
+}
+
+function readSecretTool() {
+  try {
+    const out = execFileSync(
+      "secret-tool",
+      ["lookup", "service", "personal-agent", "key", SECRET_NAME],
+      { encoding: "utf-8", timeout: 5_000 },
+    );
+    return out.replace(/\n$/, "") || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect WSL. WSL reports platform "linux" but cannot use `secret-tool`
+ * (D-Bus / GNOME Keyring typically unavailable), so it uses the file store.
+ */
+function isWsl() {
+  try {
+    return /microsoft|wsl/i.test(readFileSync("/proc/version", "utf-8"));
+  } catch {
+    return false;
+  }
+}
+
+// ── AES-256-GCM file store (mirrors secret-client-file.ts) ────────────────
+const FILE_ALGORITHM = "aes-256-gcm";
+const FILE_KEY_LENGTH = 32; // 256 bits
+const FILE_SCRYPT = { N: 16384, r: 8, p: 1 };
+
+/** Resolve the file-store master password (env, then key file); null if none. */
+function resolveMasterPassword() {
+  if (process.env.PA_MASTER_PASSWORD) return process.env.PA_MASTER_PASSWORD;
+  const keyFilePath = join(secretsDir(), ".master-key");
+  if (!existsSync(keyFilePath)) return null;
+  // Refuse to read a key file with insecure permissions (mirrors the daemon's
+  // 0600/0400 gate); degrade to null rather than risk exposing it.
+  const mode = statSync(keyFilePath).mode & 0o777;
+  if (mode !== 0o600 && mode !== 0o400) return null;
+  return readFileSync(keyFilePath, "utf-8").trim();
+}
+
+function readFileStore() {
+  const path = join(secretsDir(), `${SECRET_NAME}.enc`);
+  if (!existsSync(path)) return null;
+  try {
+    const password = resolveMasterPassword();
+    if (!password) return null;
+    const stored = JSON.parse(readFileSync(path, "utf-8"));
+    const salt = Buffer.from(stored.salt, "hex");
+    const iv = Buffer.from(stored.iv, "hex");
+    const authTag = Buffer.from(stored.authTag, "hex");
+    const ciphertext = Buffer.from(stored.ciphertext, "hex");
+    const key = scryptSync(password, salt, FILE_KEY_LENGTH, FILE_SCRYPT);
+    const decipher = createDecipheriv(FILE_ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    return Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final(),
+    ]).toString("utf-8");
+  } catch {
+    return null;
+  }
+}

package/scripts/start.mjs

@@ -6,6 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import { ensureBuild, log } from "./run-node.mjs";
 import { openBrowser, waitForHttpReady } from "./browser.mjs";
+import { resolveDashboardPort } from "./lib/ports.mjs";
 
 const IS_WINDOWS = process.platform === "win32";
 const requireFromScript = createRequire(import.meta.url);
@@ -57,7 +58,7 @@ function nextSpawnArgs(dashboardDir, nextBin, userArgs) {
  * 5. Ctrl+C stops both
  */
 
-const DASHBOARD_PORT = parseInt(process.env.PA_DASHBOARD_PORT || "3000", 10);
+const DASHBOARD_PORT = resolveDashboardPort();
 const noOpen = process.argv.slice(2).includes("--no-open");
 const children = [];
 let shuttingDown = false;
@@ -92,21 +93,31 @@ try {
 }
 const nextBin = resolveNextBin(dashboardDir);
 const dashArgs = nextSpawnArgs(dashboardDir, nextBin, [
-  "dev", "--port", String(DASHBOARD_PORT),
+  // Bind IPv4 loopback explicitly: with no --hostname, Next binds the
+  // unspecified IPv6 address `::`, and on Windows (IPV6_V6ONLY on) the
+  // 127.0.0.1 readiness probe in bin/aitne.mjs can't reach it. Match the
+  // probe and the daemon's 127.0.0.1-only posture. Byte-identical on
+  // macOS/Linux where the probe already reaches a `::`-bound socket.
+  "dev", "--port", String(DASHBOARD_PORT), "--hostname", "127.0.0.1",
 ]);
-const dashboard = spawn(nextBin, dashArgs, {
+const useShimShell = IS_WINDOWS && nextBin.toLowerCase().endsWith(".cmd");
+const dashCommand = useShimShell ? `"${nextBin}"` : nextBin;
+const dashboard = spawn(dashCommand, dashArgs, {
   cwd: dashboardDir,
   env: process.env,
   stdio: "inherit",
   windowsHide: true,
-  shell: IS_WINDOWS && nextBin.toLowerCase().endsWith(".cmd"),
+  shell: useShimShell,
 });
 children.push(dashboard);
 
 // ── 4. Auto-open browser ──
 
 if (!noOpen) {
-  const url = `http://localhost:${DASHBOARD_PORT}`;
+  // Match the dashboard's 127.0.0.1-only bind above. Using `localhost` here
+  // resolves to `::1` first on Windows, so both the readiness probe AND the
+  // browser open would miss the IPv4-only socket and time out.
+  const url = `http://127.0.0.1:${DASHBOARD_PORT}`;
   waitForHttpReady(url, {
     // `next dev` can take ~30s on a cold boot; give it headroom.
     timeoutMs: 60_000,

package/agent-assets/docs/features/lifestyle/travel-time.md

@@ -1,58 +0,0 @@
----
-schema_version: 1
-slug: features/lifestyle/travel-time
-title: Travel Time
-id: travel-time
-aliases:
-  - door to door
-  - eta
-category: features
-summary: |
-  A skill that estimates door-to-door travel time given an origin
-  and destination — used by schedule-approaching reminders for
-  events with location.
-section: lifestyle
-tags:
-  - lifestyle
-  - travel
-  - skills
-status: stable
-ask_examples:
-  - How long will it take me to get to the airport?
-  - Does the agent know about traffic?
-locale: en-US
-created: 2026-04-25
-updated: 2026-04-25
-keywords:
-  - travel time
-  - departure time
-  - google maps
-  - commute
-  - ETA
-related:
-  - features/lifestyle/travel-bookings
-  - features/operations/schedule-approaching
----
-
-# Travel Time
-
-## In One Sentence
-
-A skill the agent calls to estimate door-to-door travel time before
-a calendar event with a location.
-
-## What It Does
-
-- Reads origin (current location, configured home/work) and
-  destination (event location).
-- Returns a typical-time estimate with mode (drive, transit, walk).
-- Used by `schedule-approaching` reminders to lead-time the alert.
-
-## Where in the Dashboard
-
-There is no operator surface for the travel-time data itself; the
-estimates appear inline in event reminders and morning routines.
-
-## Related
-
-- [Schedule Approaching](../operations/schedule-approaching.md)

package/agent-assets/skills/gmail-lifestyle/references/travel-time-api.md

@@ -1,59 +0,0 @@
----
-kind: reference
-name: travel-time-api
-description: /api/travel-time reference — Google Maps Directions wrapper. Estimate door-to-door duration and compute departure time for a calendar event with location.
----
-
-# `/api/travel-time` reference
-
-Uses the Google Maps Directions API. Prerequisite: `googleMapsApiKey`
-configured in the daemon's secret store, with the Directions API
-enabled.
-
-## GET /api/travel-time
-
-Estimate travel time between two locations.
-
-```bash
-# Transit (default)
-curl -s "http://localhost:8321/api/travel-time?origin=Grand+Central&destination=Times+Square"
-
-# Driving with arrival time
-curl -s "http://localhost:8321/api/travel-time?origin=Brooklyn&destination=Newark&mode=driving&arrival=2026-04-12T14:00:00-04:00"
-```
-
-| Param | Type | Default | Description |
-|-------|------|---------|-------------|
-| `origin` | string | (required) | Origin address or place name |
-| `destination` | string | (required) | Destination address or place name |
-| `mode` | string | transit | driving, transit, walking, bicycling |
-| `arrival` | ISO 8601 | — | Desired arrival time (computes departure time) |
-
-Response:
-
-```json
-{
-  "origin": "Grand Central Terminal, NY",
-  "destination": "Times Square, NY",
-  "mode": "transit",
-  "durationSeconds": 1380,
-  "durationText": "23 mins",
-  "distanceMeters": 8500,
-  "distanceText": "8.5 km",
-  "departBy": "2026-04-12T13:34:00.000Z"
-}
-```
-
-## GET /api/travel-time/for-event/:eventId
-
-```bash
-curl -s "http://localhost:8321/api/travel-time/for-event/abc123?origin=Home&mode=transit"
-```
-
-| Param | Type | Default | Description |
-|-------|------|---------|-------------|
-| `origin` | string | (required) | Your starting location |
-| `mode` | string | transit | Travel mode |
-
-Response includes both `event` and `travelTime` blocks; see the route
-implementation for full shape.