inplan 0.1.0

package/app/main/index.js

@@ -0,0 +1,769 @@
+import { app, BrowserWindow, ipcMain, dialog, shell } from "electron";
+import { execFile } from "node:child_process";
+import { mkdirSync as mkdirSync$1, readdirSync, unlinkSync, readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync as writeFileSync$1 } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { join as join$1, dirname as dirname$1, resolve as resolve$1 } from "node:path";
+import { appendFileSync, existsSync, readFileSync, mkdirSync, writeFileSync, watch, watchFile, unwatchFile, statSync, openSync, readSync, closeSync } from "fs";
+import { resolve, basename, relative, dirname, join } from "path";
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { homedir as homedir$1 } from "node:os";
+import __cjs_mod__ from "node:module";
+const __filename = import.meta.filename;
+const __dirname = import.meta.dirname;
+const require2 = __cjs_mod__.createRequire(import.meta.url);
+var CONTROL_LOG_VERSION = 1;
+var LogEventType = {
+  EditorPid: "editor_pid",
+  ModeChanged: "mode_changed",
+  DocumentEdited: "document_edited",
+  TurnEnded: "turn_ended",
+  AgentRevised: "agent_revised",
+  AgentRevisionProposed: "agent_revision_proposed",
+  SettingsChanged: "settings_changed",
+  AgentDoneSuggested: "agent_done_suggested",
+  ReloadSuggested: "reload_suggested",
+  /** In-window navigation: the editor followed a Markdown link to a sibling doc.
+   *  Payload `{ path }` is the new doc; the attached agent's `wait` steps down and
+   *  the human's agent re-attaches there (the local analogue of save-locally). */
+  NavigatedTo: "navigated_to",
+  SessionClosed: "session_closed"
+};
+function serializeLogEntry(entry) {
+  return JSON.stringify(entry);
+}
+function parseLogLine(line) {
+  return JSON.parse(line);
+}
+function parseLog(text) {
+  return text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).map(parseLogLine);
+}
+function readLog(path) {
+  if (!existsSync(path)) return [];
+  return parseLog(readFileSync(path, "utf8"));
+}
+function readLogIncrement(path, byteOffset) {
+  if (!existsSync(path)) return { entries: [], offset: 0, reset: byteOffset !== 0 };
+  const size = statSync(path).size;
+  if (size < byteOffset) return { entries: [], offset: 0, reset: true };
+  if (size === byteOffset) return { entries: [], offset: byteOffset, reset: false };
+  const len = size - byteOffset;
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.allocUnsafe(len);
+    const got = readSync(fd, buf, 0, len, byteOffset);
+    const chunk = buf.toString("utf8", 0, got);
+    const lastNl = chunk.lastIndexOf("\n");
+    if (lastNl === -1) return { entries: [], offset: byteOffset, reset: false };
+    const complete = chunk.slice(0, lastNl + 1);
+    return { entries: parseLog(complete), offset: byteOffset + Buffer.byteLength(complete, "utf8"), reset: false };
+  } finally {
+    closeSync(fd);
+  }
+}
+function appendLog(path, entry) {
+  const existing = readLog(path);
+  const seq = existing.length ? existing[existing.length - 1].seq + 1 : 1;
+  const full = {
+    seq,
+    ts: entry.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    actor: entry.actor,
+    type: entry.type,
+    ...entry.payload !== void 0 ? { payload: entry.payload } : {}
+  };
+  appendFileSync(path, serializeLogEntry(full) + "\n");
+  return full;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var FsControlChannel = class {
+  constructor(paths) {
+    this.paths = paths;
+  }
+  paths;
+  // Incremental-read state: bytes already consumed + the entries parsed so far.
+  // Lets readSince parse only newly-appended bytes (O(new)) rather than re-reading
+  // the whole log each poll, while still seeing appends from other processes
+  // (the editor) since it re-stats to the current size every call.
+  byteOffset = 0;
+  parsed = [];
+  append(event) {
+    return Promise.resolve(appendLog(this.paths.logPath, event));
+  }
+  readSince(cursor) {
+    let inc = readLogIncrement(this.paths.logPath, this.byteOffset);
+    if (inc.reset) {
+      this.parsed = [];
+      this.byteOffset = 0;
+      inc = readLogIncrement(this.paths.logPath, 0);
+    }
+    if (inc.entries.length) this.parsed.push(...inc.entries);
+    this.byteOffset = inc.offset;
+    const entries = this.parsed.filter((e) => e.seq > cursor);
+    const next = this.parsed.length ? this.parsed[this.parsed.length - 1].seq : cursor;
+    return Promise.resolve({ entries, cursor: next });
+  }
+  subscribe(onChange) {
+    let timer = null;
+    const fire = () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(onChange, 50);
+    };
+    try {
+      const watcher = watch(this.paths.logPath, fire);
+      return () => {
+        if (timer) clearTimeout(timer);
+        watcher.close();
+      };
+    } catch {
+      const listener = () => fire();
+      watchFile(this.paths.logPath, { interval: 200 }, listener);
+      return () => {
+        if (timer) clearTimeout(timer);
+        unwatchFile(this.paths.logPath, listener);
+      };
+    }
+  }
+  getCursor() {
+    if (!existsSync(this.paths.cursorPath)) return Promise.resolve(0);
+    const n = Number(readFileSync(this.paths.cursorPath, "utf8").trim());
+    return Promise.resolve(Number.isFinite(n) ? n : 0);
+  }
+  setCursor(seq) {
+    writeFileSync(this.paths.cursorPath, String(seq));
+    return Promise.resolve();
+  }
+  claimLock(token) {
+    writeFileSync(this.paths.waitLockPath, token);
+    return Promise.resolve();
+  }
+  isSuperseded(token) {
+    if (!existsSync(this.paths.waitLockPath)) return Promise.resolve(false);
+    return Promise.resolve(readFileSync(this.paths.waitLockPath, "utf8").trim() !== token);
+  }
+  presence() {
+    const log = readLog(this.paths.logPath);
+    for (let i = log.length - 1; i >= 0; i--) {
+      if (log[i].type === LogEventType.EditorPid) {
+        const pid = log[i].payload?.pid;
+        return Promise.resolve(typeof pid === "number" && isProcessAlive(pid));
+      }
+    }
+    return Promise.resolve(false);
+  }
+};
+function sidecarRoot() {
+  if (process.env.INPLAN_SIDECAR_DIR) return process.env.INPLAN_SIDECAR_DIR;
+  const home = process.env.INPLAN_HOME || join(homedir(), ".inplan");
+  return join(home, "sidecars");
+}
+function repoRootOf(absFile) {
+  let dir = dirname(absFile);
+  for (; ; ) {
+    if (existsSync(join(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function docPaths(file) {
+  const abs = resolve(file);
+  const root = repoRootOf(abs);
+  const raw = root ? `${basename(root)}/${relative(root, abs)}` : `${basename(dirname(abs))}/${basename(abs)}`;
+  const label = raw.replace(/[/\\]+/g, "-").replace(/[^A-Za-z0-9._-]/g, "_");
+  const key = `${label}-${createHash("sha1").update(abs).digest("hex").slice(0, 12)}`;
+  const controlDir = join(sidecarRoot(), key);
+  return {
+    file: abs,
+    controlDir,
+    logPath: join(controlDir, "log.jsonl"),
+    canonicalPath: join(controlDir, "canonical.md"),
+    backupsDir: join(controlDir, "backups"),
+    proposedPath: join(controlDir, "proposed.md"),
+    cursorPath: join(controlDir, "cursor"),
+    waitLockPath: join(controlDir, "waitlock"),
+    waitDebugPath: join(controlDir, "wait-debug.log"),
+    statusPath: join(controlDir, "status.json")
+  };
+}
+var DEFAULT_SETTINGS = { autoResolve: true };
+function globalSettingsPath() {
+  const base = process.env.INPLAN_HOME || join(homedir(), ".inplan");
+  return join(base, "settings.json");
+}
+function readGlobalSettings() {
+  const path = globalSettingsPath();
+  if (!existsSync(path)) return { ...DEFAULT_SETTINGS };
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    return { ...DEFAULT_SETTINGS, ...raw };
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+function writeGlobalSettings(settings) {
+  const path = globalSettingsPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(settings, null, 2)}
+`);
+}
+const MAX_BACKUPS = 25;
+class Session {
+  paths;
+  backupSeq = 0;
+  closed = false;
+  /** Latest unsaved state reported by the renderer, for the close prompt. */
+  pendingDirty = false;
+  pendingContent = "";
+  setPending(dirty, content) {
+    this.pendingDirty = dirty;
+    this.pendingContent = content;
+  }
+  get hasUnsaved() {
+    return this.pendingDirty;
+  }
+  get pending() {
+    return this.pendingContent;
+  }
+  constructor(file) {
+    this.paths = docPaths(file);
+    mkdirSync$1(this.paths.controlDir, { recursive: true });
+    mkdirSync$1(this.paths.backupsDir, { recursive: true });
+    this.backupSeq = this.backupSeqs().at(-1) ?? 0;
+  }
+  /** Existing `autosave-<n>.md` sequence numbers in the backups dir, ascending. */
+  backupSeqs() {
+    return readdirSync(this.paths.backupsDir).map((name) => /^autosave-(\d+)\.md$/.exec(name)?.[1]).filter((n) => n != null).map(Number).sort((a, b) => a - b);
+  }
+  /** Keep only the most recent MAX_BACKUPS autosave files. */
+  pruneBackups() {
+    const seqs = this.backupSeqs();
+    for (const n of seqs.slice(0, Math.max(0, seqs.length - MAX_BACKUPS))) {
+      try {
+        unlinkSync(join$1(this.paths.backupsDir, `autosave-${n}.md`));
+      } catch {
+      }
+    }
+  }
+  load() {
+    const content = readFileSync$1(this.paths.file, "utf8");
+    if (!existsSync$1(this.paths.canonicalPath)) {
+      writeFileSync$1(this.paths.canonicalPath, content);
+    }
+    return { path: this.paths.file, content };
+  }
+  save(content, options) {
+    if (options.kind === "backup") {
+      const path = join$1(this.paths.backupsDir, `autosave-${++this.backupSeq}.md`);
+      writeFileSync$1(path, content);
+      this.pruneBackups();
+      return;
+    }
+    writeFileSync$1(this.paths.file, content);
+    writeFileSync$1(this.paths.canonicalPath, content);
+    if (options.kind === "apply") return;
+    const type = options.cadence === "turn" ? LogEventType.TurnEnded : LogEventType.DocumentEdited;
+    appendLog(this.paths.logPath, { actor: "user", type, payload: { bytes: content.length } });
+  }
+  /** Record this editor process's own pid (authoritative for liveness checks). */
+  logEditorPid(pid) {
+    appendLog(this.paths.logPath, { actor: "agent", type: LogEventType.EditorPid, payload: { pid, v: CONTROL_LOG_VERSION } });
+  }
+  logAction(type, payload) {
+    appendLog(this.paths.logPath, { actor: "user", type, ...payload !== void 0 ? { payload } : {} });
+  }
+  /** Record that the editor followed a link away to `path`, so the agent attached
+   *  to THIS doc steps down (its `wait` returns `navigated`) and re-attaches there. */
+  logNavigatedAway(path) {
+    appendLog(this.paths.logPath, { actor: "user", type: LogEventType.NavigatedTo, payload: { path } });
+  }
+  setMode(cadence, acceptance) {
+    appendLog(this.paths.logPath, { actor: "user", type: LogEventType.ModeChanged, payload: { cadence, acceptance } });
+  }
+  /** Global, cross-session settings (loaded by the renderer on launch). */
+  getSettings() {
+    return readGlobalSettings();
+  }
+  /** Persist global settings AND log the change so the agent wakes and the trail records it. */
+  setSettings(settings) {
+    writeGlobalSettings(settings);
+    appendLog(this.paths.logPath, { actor: "user", type: LogEventType.SettingsChanged, payload: settings });
+  }
+  complete(content) {
+    writeFileSync$1(this.paths.file, content);
+    writeFileSync$1(this.paths.canonicalPath, content);
+  }
+  /** The parked Review-mode proposal, if one is pending (the file exists ⇔ undecided). */
+  pendingProposal() {
+    return existsSync$1(this.paths.proposedPath) ? readFileSync$1(this.paths.proposedPath, "utf8") : null;
+  }
+  /** Discard the parked proposal once the human has accepted/rejected it. */
+  clearProposal() {
+    if (existsSync$1(this.paths.proposedPath)) unlinkSync(this.paths.proposedPath);
+  }
+  /** Record why the session ended (logged at most once) so the agent's `wait` can report it. */
+  logClose(reason) {
+    if (this.closed) return;
+    this.closed = true;
+    appendLog(this.paths.logPath, { actor: "user", type: LogEventType.SessionClosed, payload: { reason } });
+  }
+  /**
+   * Drive the editor from the control-log protocol — NOT a raw working-file watch
+   * — so the desktop behaves identically to the web/cloud `pump`. The CLI gate is
+   * the single source of truth: it appends `document_edited` (agent) only for an
+   * accepted edit (the working file then holds it), and `agent_revision_proposed`
+   * for a parked Review proposal (with the working file already reverted to
+   * canonical). Reacting to those events — instead of watching the file — means we
+   * never adopt the agent's body write before the gate decides, which is what used
+   * to produce the empty-diff race in Review (the baseline stayed put).
+   */
+  watch(handlers) {
+    let lastLogSeq = readLog(this.paths.logPath).at(-1)?.seq ?? 0;
+    const onLog = () => {
+      const entries = readLog(this.paths.logPath).filter((e) => e.seq > lastLogSeq);
+      if (entries.length) lastLogSeq = entries.at(-1).seq;
+      this.dispatchLog(entries, handlers);
+    };
+    return new FsControlChannel(this.paths).subscribe(onLog);
+  }
+  /**
+   * Fan a batch of new control-log entries out to the editor callbacks. Pure given
+   * the on-disk sidecars (no watchers) — exposed for tests. An accepted agent edit
+   * (`document_edited`) loads the working file (it now holds the revision); a parked
+   * proposal (`agent_revision_proposed`) loads `proposed.md` for the diff — and is
+   * NOT loaded as an external change, so the editor keeps its doc + the canonical
+   * baseline, and the diff is never empty.
+   */
+  dispatchLog(entries, handlers) {
+    if (!entries.length) return;
+    if (entries.some((e) => e.type === LogEventType.AgentDoneSuggested)) handlers.onAgentDone();
+    if (entries.some((e) => e.type === LogEventType.ReloadSuggested)) handlers.onReload();
+    if (entries.some((e) => e.type === LogEventType.AgentRevisionProposed)) {
+      const proposed = this.pendingProposal();
+      if (proposed != null) handlers.onProposal(proposed);
+    }
+    if (entries.some((e) => e.actor === "agent" && e.type === LogEventType.DocumentEdited) && existsSync$1(this.paths.file)) {
+      try {
+        handlers.onExternalChange(readFileSync$1(this.paths.file, "utf8"));
+      } catch {
+      }
+    }
+    if (entries.some((e) => e.actor === "agent" && (e.type === LogEventType.AgentRevised || e.type === LogEventType.DocumentEdited))) {
+      handlers.onAgentActive();
+    }
+  }
+}
+const EN = { code: "en", label: "English" };
+const ENGLISH_ONLY = { locale: "en", catalogs: {}, available: [EN] };
+function createI18nController(deps) {
+  const base = deps.home || process.env.INPLAN_HOME || join$1(homedir$1(), ".inplan");
+  const cachePath = join$1(base, "i18n-cache.json");
+  let snap = { ...ENGLISH_ONLY };
+  let gen = 0;
+  function persist() {
+    try {
+      mkdirSync$1(dirname$1(cachePath), { recursive: true });
+      writeFileSync$1(cachePath, JSON.stringify(snap));
+    } catch {
+    }
+  }
+  function loadCache() {
+    try {
+      const raw = JSON.parse(readFileSync$1(cachePath, "utf8"));
+      if (raw && typeof raw.locale === "string" && raw.catalogs && Array.isArray(raw.available)) {
+        snap = { locale: raw.locale, catalogs: raw.catalogs, available: raw.available };
+      }
+    } catch {
+    }
+  }
+  async function token() {
+    try {
+      const { stdout } = await deps.runCli(["token"]);
+      return JSON.parse(stdout.trim() || "{}").token ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async function getJson(path, tok) {
+    try {
+      const res = await fetch(`${deps.cloudBase}${path}`, { headers: { authorization: `Bearer ${tok}` } });
+      return res.ok ? await res.json() : null;
+    } catch {
+      return null;
+    }
+  }
+  async function fetchCatalog(code, tok) {
+    const j = await getJson(`/api/v1/i18n/catalog?locale=${encodeURIComponent(code)}`, tok);
+    return j?.catalog ?? null;
+  }
+  function presentEnglish() {
+    snap = { ...ENGLISH_ONLY };
+    deps.onChange();
+  }
+  function toEnglish() {
+    snap = { ...ENGLISH_ONLY };
+    persist();
+    deps.onChange();
+  }
+  async function bootstrap() {
+    const myGen = ++gen;
+    loadCache();
+    const cachedSnap = snap;
+    snap = { ...ENGLISH_ONLY };
+    const tok = await token();
+    if (myGen !== gen) return;
+    if (!tok) return presentEnglish();
+    snap = cachedSnap;
+    const manifest = await getJson("/api/v1/i18n", tok);
+    if (myGen !== gen) return;
+    if (!manifest) return deps.onChange();
+    if (!manifest.entitled) return toEnglish();
+    snap.available = [EN, ...manifest.locales ?? []];
+    if (snap.locale !== "en" && !snap.available.some((l) => l.code === snap.locale)) snap.locale = "en";
+    if (snap.locale !== "en" && !snap.catalogs[snap.locale]) {
+      const cat = await fetchCatalog(snap.locale, tok);
+      if (myGen !== gen) return;
+      if (cat) snap.catalogs = { ...snap.catalogs, [snap.locale]: cat };
+      else snap.locale = "en";
+    }
+    persist();
+    deps.onChange();
+  }
+  async function setLocale(code) {
+    const myGen = ++gen;
+    if (code === snap.locale) return;
+    if (code !== "en" && !snap.available.some((l) => l.code === code)) return;
+    if (code !== "en" && !snap.catalogs[code]) {
+      const tok = await token();
+      if (myGen !== gen || !tok) return;
+      const cat = await fetchCatalog(code, tok);
+      if (myGen !== gen || !cat) return;
+      snap.catalogs = { ...snap.catalogs, [code]: cat };
+    }
+    snap.locale = code;
+    persist();
+    deps.onChange();
+  }
+  return { getSnapshot: () => snap, bootstrap, setLocale };
+}
+const __dirname$1 = dirname$1(fileURLToPath(import.meta.url));
+process.on("uncaughtException", (err) => {
+  process.stderr.write(`[inplan] uncaught exception: ${err instanceof Error ? err.stack ?? err.message : String(err)}
+`);
+});
+process.on("unhandledRejection", (reason) => {
+  process.stderr.write(`[inplan] unhandled rejection: ${String(reason)}
+`);
+});
+function resolveTargetFile() {
+  const args = process.argv.slice(app.isPackaged ? 1 : 2);
+  const candidate = args.find((a) => !a.startsWith("-") && a.endsWith(".md")) ?? args.find((a) => !a.startsWith("-"));
+  if (!candidate) return null;
+  const abs = resolve$1(candidate);
+  return existsSync$1(abs) ? abs : null;
+}
+let session = null;
+let win = null;
+let stopWatching = null;
+const navHistory = [];
+let navIdx = -1;
+function runCli(args) {
+  return new Promise((res) => {
+    const cli = process.env.INPLAN_CLI;
+    if (!cli) {
+      res({ code: -1, stdout: "", stderr: "INPLAN_CLI not set" });
+      return;
+    }
+    execFile(
+      process.execPath,
+      [cli, ...args],
+      { env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" } },
+      (err, stdout, stderr) => {
+        const code = err && typeof err.code === "number" ? Number(err.code) : err ? 1 : 0;
+        res({ code, stdout, stderr });
+      }
+    );
+  });
+}
+const CLOUD_BASE = (process.env.INPLAN_WEB_URL || "https://inplan.ai").replace(/\/$/, "");
+const i18n = createI18nController({
+  runCli: (args) => runCli(args).then((r) => ({ stdout: r.stdout })),
+  cloudBase: CLOUD_BASE,
+  onChange: () => win?.webContents.send("i18n:changed")
+});
+let cloudReachable = false;
+let lastCloudProbe = 0;
+const CLOUD_PROBE_TTL_MS = 6e4;
+async function probeCloud() {
+  lastCloudProbe = Date.now();
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 2500);
+  let ok = false;
+  try {
+    const res = await fetch(`${CLOUD_BASE}/api/v1/healthz`, { signal: ctrl.signal });
+    ok = res.ok;
+  } catch {
+    ok = false;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (ok !== cloudReachable) {
+    cloudReachable = ok;
+    win?.webContents.send("profile:changed");
+  }
+}
+function ensureCloudProbe() {
+  if (Date.now() - lastCloudProbe > CLOUD_PROBE_TTL_MS) void probeCloud();
+}
+async function readProfile() {
+  ensureCloudProbe();
+  const r = await runCli(["whoami"]);
+  let who = {};
+  try {
+    who = JSON.parse(r.stdout.trim() || "{}");
+  } catch {
+  }
+  if (who.signedIn) {
+    return {
+      user: { name: who.email ?? "Signed in", ...who.email ? { email: who.email } : {} },
+      agentLocation: null,
+      // desktop has no live presence room; the web derives it from awareness
+      actions: [
+        { id: "collaborate", label: "Collaborate on Cloud", primary: true },
+        { id: "signout", label: "Sign out", danger: true }
+      ]
+    };
+  }
+  return { user: null, agentLocation: null, actions: cloudReachable ? [{ id: "signin", label: "Sign in…" }] : [] };
+}
+async function collaborateOnCloud() {
+  if (!session) return;
+  if (session.hasUnsaved) session.complete(session.pending);
+  const r = await runCli(["upload", session.paths.file]);
+  let out = {};
+  try {
+    out = JSON.parse(r.stdout.trim() || "{}");
+  } catch {
+  }
+  if (out.status !== "uploaded" || !out.cloudDocId) {
+    dialog.showMessageBoxSync(win, { type: "error", message: "Couldn't move this plan to the cloud.", detail: r.stderr.trim() || "Are you signed in? Run `inplan login`." });
+    return;
+  }
+  const url = out.locator ? `${CLOUD_BASE}/docs/${out.locator.org}/${out.locator.repo}/${out.locator.path}` : `${CLOUD_BASE}/?doc=${out.cloudDocId}`;
+  await shell.openExternal(url);
+  session.logClose("window_closed");
+  app.quit();
+}
+async function checkForUpdate() {
+  const r = await runCli(["update", "--check"]);
+  try {
+    const out = JSON.parse(r.stdout.trim() || "{}");
+    if (out.updateAvailable && out.latest) {
+      win?.webContents.send("app:update-available", { current: out.current ?? "?", latest: out.latest });
+    }
+  } catch {
+  }
+}
+function watchSession() {
+  if (!session) return null;
+  const s = session;
+  return s.watch({
+    onExternalChange: (content) => win?.webContents.send("doc:external-change", { path: s.paths.file, content }),
+    onAgentDone: () => win?.webContents.send("agent:done"),
+    onAgentActive: () => win?.webContents.send("agent:active"),
+    onProposal: (content) => win?.webContents.send("doc:proposal", { content }),
+    onReload: () => win?.webContents.send("agent:reload")
+  });
+}
+function sendNavState() {
+  win?.webContents.send("nav:state", { canBack: navIdx > 0, canForward: navIdx < navHistory.length - 1 });
+}
+function navigateTo(file) {
+  if (!session || !win) return false;
+  if (resolve$1(file) === resolve$1(session.paths.file)) return false;
+  if (session.hasUnsaved) {
+    const choice = dialog.showMessageBoxSync(win, {
+      type: "question",
+      buttons: ["Save", "Don't Save", "Cancel"],
+      defaultId: 0,
+      cancelId: 2,
+      message: "Save changes before leaving this plan?",
+      detail: "Your edits this turn aren't saved to the plan yet."
+    });
+    if (choice === 2) return false;
+    if (choice === 0) session.complete(session.pending);
+  }
+  session.logNavigatedAway(file);
+  stopWatching?.();
+  session = new Session(file);
+  session.logEditorPid(process.pid);
+  stopWatching = watchSession();
+  win.webContents.send("doc:navigated", session.load());
+  return true;
+}
+function createWindow() {
+  win = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    title: "inplan",
+    webPreferences: {
+      preload: join$1(__dirname$1, "../preload/index.mjs"),
+      sandbox: false
+    }
+  });
+  win.webContents.setWindowOpenHandler(({ url }) => {
+    if (/^https?:/.test(url)) void shell.openExternal(url);
+    return { action: "deny" };
+  });
+  win.webContents.on("will-navigate", (event, url) => {
+    if (url !== win?.webContents.getURL()) {
+      event.preventDefault();
+      if (/^https?:/.test(url)) void shell.openExternal(url);
+    }
+  });
+  if (process.env.ELECTRON_RENDERER_URL) {
+    void win.loadURL(process.env.ELECTRON_RENDERER_URL);
+  } else {
+    void win.loadFile(join$1(__dirname$1, "../renderer/index.html"));
+  }
+  win.webContents.once("did-finish-load", () => {
+    void checkForUpdate();
+    void probeCloud();
+    void i18n.bootstrap();
+  });
+  stopWatching = watchSession();
+  let forceClose = false;
+  win.on("close", (e) => {
+    if (forceClose || !session?.hasUnsaved) return;
+    e.preventDefault();
+    const choice = dialog.showMessageBoxSync(win, {
+      type: "question",
+      buttons: ["Save", "Don't Save", "Cancel"],
+      defaultId: 0,
+      cancelId: 2,
+      message: "Save changes before closing?",
+      detail: "Your edits this turn aren't saved to the plan yet."
+    });
+    if (choice === 2) return;
+    if (choice === 0) {
+      session.complete(session.pending);
+      session.logClose("completed");
+    } else {
+      session.logClose("window_closed");
+    }
+    forceClose = true;
+    win.close();
+  });
+  win.on("closed", () => {
+    stopWatching?.();
+    win = null;
+  });
+}
+function registerIpc() {
+  ipcMain.handle("doc:load", () => {
+    if (!session) throw new Error("no document open");
+    return session.load();
+  });
+  ipcMain.handle("doc:save", (_e, content, options) => {
+    session?.save(content, options);
+  });
+  ipcMain.handle("doc:log-action", (_e, type, payload) => {
+    session?.logAction(type, payload);
+  });
+  ipcMain.handle("doc:report-state", (_e, dirty, content) => {
+    session?.setPending(dirty, content);
+  });
+  ipcMain.handle("doc:set-mode", (_e, cadence, acceptance) => {
+    session?.setMode(cadence, acceptance);
+  });
+  ipcMain.handle("settings:get", () => session?.getSettings());
+  ipcMain.handle("settings:set", (_e, settings) => {
+    session?.setSettings(settings);
+  });
+  ipcMain.handle("window:close", () => win?.close());
+  ipcMain.handle("proposal:get", () => session?.pendingProposal() ?? null);
+  ipcMain.handle("proposal:clear", () => {
+    session?.clearProposal();
+  });
+  ipcMain.handle("doc:open", (_e, target) => {
+    const abs = resolve$1("/", target);
+    if (!abs.endsWith(".md") || !existsSync$1(abs)) {
+      process.stderr.write(`[inplan] open-doc: no such .md file: ${abs}
+`);
+      return;
+    }
+    if (navigateTo(abs)) {
+      navHistory.splice(navIdx + 1);
+      navHistory.push(abs);
+      navIdx = navHistory.length - 1;
+      sendNavState();
+    }
+  });
+  ipcMain.handle("nav:go", (_e, dir) => {
+    const target = dir === "back" ? navIdx - 1 : navIdx + 1;
+    if (target < 0 || target >= navHistory.length) return;
+    if (navigateTo(navHistory[target])) {
+      navIdx = target;
+      sendNavState();
+    }
+  });
+  ipcMain.handle("doc:complete", (_e, content) => {
+    session?.complete(content);
+    session?.logClose("completed");
+    app.quit();
+  });
+  ipcMain.handle("app:apply-update", async () => {
+    const r = await runCli(["update"]);
+    try {
+      return { ok: JSON.parse(r.stdout.trim() || "{}").status === "updated" };
+    } catch {
+      return { ok: false };
+    }
+  });
+  ipcMain.handle("profile:get", () => readProfile());
+  ipcMain.handle("profile:action", async (_e, id) => {
+    if (id === "collaborate") {
+      await collaborateOnCloud();
+    } else if (id === "signout") {
+      await runCli(["logout"]);
+      win?.webContents.send("profile:changed");
+      void i18n.bootstrap();
+    } else if (id === "signin") {
+      dialog.showMessageBoxSync(win, {
+        type: "info",
+        message: "Sign in to inplan.ai",
+        detail: "Run `inplan login` in your terminal to connect this app to your inplan.ai account, then reopen this menu."
+      });
+      win?.webContents.send("profile:changed");
+      void i18n.bootstrap();
+    }
+  });
+  ipcMain.handle("i18n:get", () => i18n.getSnapshot());
+  ipcMain.handle("i18n:set-locale", (_e, code) => i18n.setLocale(code));
+}
+void app.whenReady().then(() => {
+  const target = resolveTargetFile();
+  if (target) {
+    session = new Session(target);
+    session.logEditorPid(process.pid);
+    navHistory.push(target);
+    navIdx = 0;
+  }
+  registerIpc();
+  createWindow();
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+app.on("before-quit", () => {
+  session?.logClose("window_closed");
+});
+app.on("window-all-closed", () => {
+  app.quit();
+});