v1.0.63: version bump for update-flow testing (no functional change)

Per Pete: staff Macs restart Stream Deck/the plugin process often enough
that the one-shot 10s-post-launch check is sufficient; the periodic
recheck was unwanted complexity.

com.pdma.notion-timer.sdPlugin/bin/plugin.js

@@ -6438,7 +6438,7 @@ async function stopTimer(token, entryId) {
 }
 
 // src/plugin.ts
-var CURRENT_VERSION = "1.0.39";
+var CURRENT_VERSION = "1.0.63";
 var GITEA_BASE = "https://gitea.pdmarf.co.uk/pdm/stream_deck_notion_timer/raw/branch/stable-rebuild";
 var SIGNING_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEAN7ko8TUpuPzPAJuKAZCRjV0c4ZSlou5d9pUAF6o12b4=
@@ -6460,12 +6460,17 @@ async function checkForUpdates(sendStatus) {
   try {
     const resp = await fetchWithTimeout2(`${GITEA_BASE}/version.json`);
     if (!resp.ok) {
+      plugin_default.logger.warn(`Update check: version.json fetch returned ${resp.status}`);
       sendStatus?.("Update check failed");
       return;
     }
     const { version } = await resp.json();
-    if (!/^\d+\.\d+\.\d+$/.test(version)) return;
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+      plugin_default.logger.warn(`Update check: version.json had unexpected content: ${JSON.stringify(version)}`);
+      return;
+    }
     if (!isNewerVersion(version, CURRENT_VERSION)) {
+      plugin_default.logger.info(`Update check: up to date (v${CURRENT_VERSION}, server has v${version})`);
       sendStatus?.(`Already up to date (v${CURRENT_VERSION})`);
       return;
     }
@@ -6512,6 +6517,8 @@ async function checkForUpdates(sendStatus) {
     }
     fs3.writeFileSync(__filename, newCode);
     plugin_default.logger.info(`Updated to ${version}, restarting\u2026`);
+    await sendStatus?.(`Updated to v${version}. Click any other button above to confirm version update has been successful.`);
+    await new Promise((resolve) => setTimeout(resolve, 200));
     process.exit(0);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -6567,8 +6574,61 @@ function isConfigured(g) {
 function buttonTitle(projectName) {
   return projectName.replace(/^[\p{Extended_Pictographic}\uFE0F\s]+/u, "").trim();
 }
+var ELAPSED_CHECK_MS = 60 * 60 * 1e3;
+var DIALOG_TIMEOUT_SECONDS = 300;
+async function promptContinue(title) {
+  const { execFile: execFile3 } = await import("node:child_process");
+  const safeTitle = title.replace(/[\\"]/g, "");
+  const script = `display dialog "Timer for ${safeTitle} has been running for over an hour.
+
+Should it continue?" buttons {"Stop", "Continue"} default button "Continue" giving up after ${DIALOG_TIMEOUT_SECONDS}`;
+  return new Promise((resolve) => {
+    execFile3("osascript", ["-e", script], (err, stdout) => {
+      if (err || /gave up:true/.test(String(stdout))) {
+        resolve("timeout");
+        return;
+      }
+      resolve(/button returned:Stop/.test(String(stdout)) ? "stop" : "continue");
+    });
+  });
+}
 var TimerToggle = class extends SingletonAction {
   projectCache = /* @__PURE__ */ new Map();
+  keyDownBusy = false;
+  elapsedCheckTimer = null;
+  clearElapsedCheck() {
+    if (this.elapsedCheckTimer) clearTimeout(this.elapsedCheckTimer);
+    this.elapsedCheckTimer = null;
+  }
+  scheduleElapsedCheck(entryId, actionId, title) {
+    this.clearElapsedCheck();
+    this.elapsedCheckTimer = setTimeout(() => {
+      this.checkElapsed(entryId, actionId, title);
+    }, ELAPSED_CHECK_MS);
+  }
+  async checkElapsed(entryId, actionId, title) {
+    if (memRunningEntryId !== entryId) return;
+    const answer = await promptContinue(title);
+    if (memRunningEntryId !== entryId) return;
+    if (answer === "continue") {
+      this.scheduleElapsedCheck(entryId, actionId, title);
+      return;
+    }
+    try {
+      const global = await getGlobal();
+      await stopTimer(global.notionToken, entryId);
+    } catch (err) {
+      plugin_default.logger.error("Auto-stop after elapsed-check failed:", err);
+    }
+    setRunningEntry(null, null);
+    this.clearElapsedCheck();
+    for (const action2 of this.actions) {
+      if (action2.id === actionId) {
+        await Promise.all([action2.setState(0), action2.setTitle(title)]);
+        break;
+      }
+    }
+  }
   async onWillAppear(ev) {
     this.projectCache.set(ev.action.id, ev.payload.settings);
     const title = buttonTitle(ev.payload.settings.projectName || "");
@@ -6584,6 +6644,18 @@ var TimerToggle = class extends SingletonAction {
     await sendProjectsToPI();
   }
   async onKeyDown(ev) {
+    if (this.keyDownBusy) {
+      const title = buttonTitle(ev.payload.settings.projectName || "");
+      const shouldBeRunning = memRunningActionId === ev.action.id;
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      await Promise.all([
+        ev.action.setState(shouldBeRunning ? 1 : 0),
+        ev.action.setTitle(shouldBeRunning ? `\u23F1 ${title}` : title)
+      ]);
+      return;
+    }
+    this.keyDownBusy = true;
+    try {
       const { projectId, projectName } = ev.payload.settings;
       const title = buttonTitle(projectName || "");
       const isRunning = memRunningActionId === ev.action.id;
@@ -6612,15 +6684,27 @@ var TimerToggle = class extends SingletonAction {
       }
       try {
         if (isRunning) {
+          try {
             await stopTimer(global.notionToken, memRunningEntryId);
+          } catch (err) {
+            plugin_default.logger.error("Failed to stop timer in Notion (clearing local state anyway):", err);
+          }
           setRunningEntry(null, null);
+          this.clearElapsedCheck();
           await Promise.all([ev.action.setState(0), ev.action.setTitle(title)]);
         } else {
           if (memRunningEntryId) {
+            try {
               await stopTimer(global.notionToken, memRunningEntryId);
+            } catch (err) {
+              plugin_default.logger.error("Failed to stop previous timer in Notion (clearing local state anyway):", err);
+            }
+            setRunningEntry(null, null);
+            this.clearElapsedCheck();
           }
           const entryId = await startTimer(global.notionToken, global.timingDbId, projectId, projectName, global.userId);
           setRunningEntry(entryId, ev.action.id);
+          this.scheduleElapsedCheck(entryId, ev.action.id, title);
           await Promise.all([ev.action.setState(1), ev.action.setTitle(`\u23F1 ${title}`)]);
         }
       } catch (err) {
@@ -6631,13 +6715,37 @@ var TimerToggle = class extends SingletonAction {
         plugin_default.logger.error("Timer toggle failed:", err);
         await ev.action.showAlert();
       }
+    } finally {
+      this.keyDownBusy = false;
+    }
   }
 };
 TimerToggle = __decorateClass([
   action({ UUID: "com.pdma.notion-timer.toggle" })
 ], TimerToggle);
+var NEXTCLOUD_BIN = "/Applications/Nextcloud.app/Contents/MacOS/Nextcloud";
+var LaunchNextcloud = class extends SingletonAction {
+  async onKeyDown(ev) {
+    try {
+      const { spawn } = await import("node:child_process");
+      const child = spawn(NEXTCLOUD_BIN, [], { detached: true, stdio: "ignore" });
+      child.once("error", (err) => {
+        plugin_default.logger.error("Failed to launch Nextcloud:", err);
+      });
+      child.unref();
+      await ev.action.showOk();
+    } catch (err) {
+      plugin_default.logger.error("Failed to launch Nextcloud:", err);
+      await ev.action.showAlert();
+    }
+  }
+};
+LaunchNextcloud = __decorateClass([
+  action({ UUID: "com.pdma.notion-timer.launch-nextcloud" })
+], LaunchNextcloud);
 var timerAction = new TimerToggle();
 plugin_default.actions.registerAction(timerAction);
+plugin_default.actions.registerAction(new LaunchNextcloud());
 plugin_default.ui.onSendToPlugin(async (ev) => {
   if (ev.payload.event === "saveSettings" && ev.payload.settings) {
     await ev.action.setSettings(ev.payload.settings);
@@ -6653,8 +6761,16 @@ plugin_default.ui.onSendToPlugin(async (ev) => {
     await checkForUpdates(send);
   }
 });
+var UPDATE_CHECK_INTERVAL_MS = 30 * 60 * 1e3;
 plugin_default.connect();
-setTimeout(() => checkForUpdates(), 1e4);
+setTimeout(() => {
+  plugin_default.logger.info("Running initial (10s post-launch) update check");
+  checkForUpdates();
+}, 1e4);
+setInterval(() => {
+  plugin_default.logger.info("Running scheduled (30min) update check");
+  checkForUpdates();
+}, UPDATE_CHECK_INTERVAL_MS);
 /*! Bundled license information:
 
 @elgato/schemas/dist/streamdeck/plugins/index.mjs:

com.pdma.notion-timer.sdPlugin/bin/plugin.js.sig

@@ -1 +1,2 @@
-в<╥!Ъ░xR√з└СRё;=▀LI"я╓╢HuэF├ы▐Ос─╒┘	sb▌Y╛{йH│╤Н.JщNЦь1╔l
+`�3i±Þ›‰Àë%��¶7#h�N­ã
+Ÿm!ØlcåÕ“‹¸bø œS>@¸–Iºn@Yp?ÔsäѼx

com.pdma.notion-timer.sdPlugin/imgs/nextcloud-icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 144 144" width="144" height="144">
+  <rect width="144" height="144" rx="16" fill="#0082c9"/>
+  <path d="M72 46c-13.3 0-24.4 9.4-27.1 22a16 16 0 0 0 3.1 31.8h48a16.5 16.5 0 0 0 3.6-32.6C97.3 55.6 85.9 46 72 46z"
+        fill="none" stroke="white" stroke-width="6" stroke-linejoin="round"/>
+</svg>

com.pdma.notion-timer.sdPlugin/manifest.json

@@ -2,7 +2,7 @@
   "Author": "Pete Marfleet",
   "Description": "Toggle Notion time tracking for a project with a single button press.",
   "Name": "Notion Timer",
-  "Version": "1.0.39",
+  "Version": "1.0.40",
   "SDKVersion": 2,
   "Software": { "MinimumVersion": "5.0" },
   "OS": [{ "Platform": "mac", "MinimumVersion": "10.11" }],
@@ -30,6 +30,19 @@
       ],
       "PropertyInspectorPath": "ui/property-inspector.html",
       "SupportedInMultiActions": false
+    },
+    {
+      "Icon": "imgs/nextcloud-icon",
+      "Name": "Launch Nextcloud",
+      "UUID": "com.pdma.notion-timer.launch-nextcloud",
+      "Tooltip": "Launch the Nextcloud desktop client in the background.",
+      "States": [
+        {
+          "Image": "imgs/nextcloud-icon",
+          "TitleAlignment": "bottom"
+        }
+      ],
+      "SupportedInMultiActions": false
     }
   ]
 }

src/plugin.ts

@@ -1,4 +1,4 @@
-const CURRENT_VERSION = "1.0.39";
+const CURRENT_VERSION = "1.0.63";
 const GITEA_BASE = "https://gitea.pdmarf.co.uk/pdm/stream_deck_notion_timer/raw/branch/stable-rebuild";
 const SIGNING_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEAN7ko8TUpuPzPAJuKAZCRjV0c4ZSlou5d9pUAF6o12b4=
@@ -19,13 +19,21 @@ function fetchWithTimeout(url: string): Promise<Response> {
   return fetch(url, { signal: controller.signal }).finally(() => clearTimeout(timer));
 }
 
-async function checkForUpdates(sendStatus?: (msg: string) => void): Promise<void> {
+async function checkForUpdates(sendStatus?: (msg: string) => void | Promise<void>): Promise<void> {
   try {
     const resp = await fetchWithTimeout(`${GITEA_BASE}/version.json`);
-    if (!resp.ok) { sendStatus?.("Update check failed"); return; }
+    if (!resp.ok) {
+      streamDeck.logger.warn(`Update check: version.json fetch returned ${resp.status}`);
+      sendStatus?.("Update check failed");
+      return;
+    }
     const { version } = await resp.json() as { version: string };
-    if (!/^\d+\.\d+\.\d+$/.test(version)) return;
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+      streamDeck.logger.warn(`Update check: version.json had unexpected content: ${JSON.stringify(version)}`);
+      return;
+    }
     if (!isNewerVersion(version, CURRENT_VERSION)) {
+      streamDeck.logger.info(`Update check: up to date (v${CURRENT_VERSION}, server has v${version})`);
       sendStatus?.(`Already up to date (v${CURRENT_VERSION})`);
       return;
     }
@@ -73,6 +81,11 @@ async function checkForUpdates(sendStatus?: (msg: string) => void): Promise<void
 
     fs.writeFileSync(__filename, newCode);
     streamDeck.logger.info(`Updated to ${version}, restarting…`);
+    // Await + a short delay so the message actually reaches the socket before
+    // the process dies. The panel can't reliably learn its own new version
+    // number after this restart, so it just tells the user how to confirm it.
+    await sendStatus?.(`Updated to v${version}. Click any other button above to confirm version update has been successful.`);
+    await new Promise((resolve) => setTimeout(resolve, 200));
     process.exit(0);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -164,9 +177,64 @@ function buttonTitle(projectName: string): string {
   return projectName.replace(/^[\p{Extended_Pictographic}\uFE0F\s]+/u, "").trim();
 }
 
+const ELAPSED_CHECK_MS = 60 * 60 * 1000; // 1 hour
+const DIALOG_TIMEOUT_SECONDS = 300; // 5 minutes
+
+async function promptContinue(title: string): Promise<"stop" | "continue" | "timeout"> {
+  const { execFile } = await import("node:child_process");
+  const safeTitle = title.replace(/[\\"]/g, "");
+  const script = `display dialog "Timer for ${safeTitle} has been running for over an hour.\n\nShould it continue?" buttons {"Stop", "Continue"} default button "Continue" giving up after ${DIALOG_TIMEOUT_SECONDS}`;
+  return new Promise((resolve) => {
+    execFile("osascript", ["-e", script], (err, stdout) => {
+      if (err || /gave up:true/.test(String(stdout))) { resolve("timeout"); return; }
+      resolve(/button returned:Stop/.test(String(stdout)) ? "stop" : "continue");
+    });
+  });
+}
+
 @action({ UUID: "com.pdma.notion-timer.toggle" })
 class TimerToggle extends SingletonAction<TimerSettings> {
   private projectCache = new Map<string, TimerSettings>();
+  private keyDownBusy = false;
+  private elapsedCheckTimer: NodeJS.Timeout | null = null;
+
+  private clearElapsedCheck(): void {
+    if (this.elapsedCheckTimer) clearTimeout(this.elapsedCheckTimer);
+    this.elapsedCheckTimer = null;
+  }
+
+  private scheduleElapsedCheck(entryId: string, actionId: string, title: string): void {
+    this.clearElapsedCheck();
+    this.elapsedCheckTimer = setTimeout(() => {
+      this.checkElapsed(entryId, actionId, title);
+    }, ELAPSED_CHECK_MS);
+  }
+
+  private async checkElapsed(entryId: string, actionId: string, title: string): Promise<void> {
+    if (memRunningEntryId !== entryId) return;
+    const answer = await promptContinue(title);
+    if (memRunningEntryId !== entryId) return;
+
+    if (answer === "continue") {
+      this.scheduleElapsedCheck(entryId, actionId, title);
+      return;
+    }
+
+    try {
+      const global = await getGlobal();
+      await stopTimer(global.notionToken, entryId);
+    } catch (err) {
+      streamDeck.logger.error("Auto-stop after elapsed-check failed:", err);
+    }
+    setRunningEntry(null, null);
+    this.clearElapsedCheck();
+    for (const action of this.actions) {
+      if (action.id === actionId) {
+        await Promise.all([action.setState(0), action.setTitle(title)]);
+        break;
+      }
+    }
+  }
 
   async onWillAppear(ev: WillAppearEvent<TimerSettings>): Promise<void> {
     this.projectCache.set(ev.action.id, ev.payload.settings);
@@ -185,6 +253,26 @@ class TimerToggle extends SingletonAction<TimerSettings> {
   }
 
   async onKeyDown(ev: KeyDownEvent<TimerSettings>): Promise<void> {
+    // Global lock across ALL buttons of this action, not just this one — otherwise
+    // near-simultaneous presses on two different buttons both read memRunningActionId
+    // as "nothing running" and both start a timer in Notion.
+    if (this.keyDownBusy) {
+      // Blocked press: redraw THIS button to match known truth instead of leaving
+      // whatever it was already showing (which can be stale from an out-of-band
+      // Notion edit) — a pure visual correction, no Notion calls. Delayed slightly
+      // because redrawing immediately can collide with Stream Deck's own native
+      // key-press flash animation and get silently dropped.
+      const title = buttonTitle(ev.payload.settings.projectName || "");
+      const shouldBeRunning = memRunningActionId === ev.action.id;
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      await Promise.all([
+        ev.action.setState(shouldBeRunning ? 1 : 0),
+        ev.action.setTitle(shouldBeRunning ? `⏱ ${title}` : title),
+      ]);
+      return;
+    }
+    this.keyDownBusy = true;
+    try {
     const { projectId, projectName } = ev.payload.settings;
     const title = buttonTitle(projectName || "");
     const isRunning = memRunningActionId === ev.action.id;
@@ -211,15 +299,31 @@ class TimerToggle extends SingletonAction<TimerSettings> {
 
     try {
       if (isRunning) {
+        // Stopping the entry in Notion is best-effort: if the page is already
+        // gone/archived (e.g. edited outside the plugin) this throws, but the
+        // local "running" tracking must clear anyway or every future keypress
+        // retries this same doomed stop call and the deck gets stuck forever.
+        try {
           await stopTimer(global.notionToken, memRunningEntryId!);
+        } catch (err) {
+          streamDeck.logger.error("Failed to stop timer in Notion (clearing local state anyway):", err);
+        }
         setRunningEntry(null, null);
+        this.clearElapsedCheck();
         await Promise.all([ev.action.setState(0), ev.action.setTitle(title)]);
       } else {
         if (memRunningEntryId) {
+          try {
             await stopTimer(global.notionToken, memRunningEntryId);
+          } catch (err) {
+            streamDeck.logger.error("Failed to stop previous timer in Notion (clearing local state anyway):", err);
+          }
+          setRunningEntry(null, null);
+          this.clearElapsedCheck();
         }
         const entryId = await startTimer(global.notionToken, global.timingDbId, projectId, projectName, global.userId);
         setRunningEntry(entryId, ev.action.id);
+        this.scheduleElapsedCheck(entryId, ev.action.id, title);
         await Promise.all([ev.action.setState(1), ev.action.setTitle(`⏱ ${title}`)]);
       }
     } catch (err) {
@@ -231,11 +335,37 @@ class TimerToggle extends SingletonAction<TimerSettings> {
       streamDeck.logger.error("Timer toggle failed:", err);
       await ev.action.showAlert();
     }
+    } finally {
+      this.keyDownBusy = false;
+    }
+  }
+}
+
+const NEXTCLOUD_BIN = "/Applications/Nextcloud.app/Contents/MacOS/Nextcloud";
+
+@action({ UUID: "com.pdma.notion-timer.launch-nextcloud" })
+class LaunchNextcloud extends SingletonAction {
+  async onKeyDown(ev: KeyDownEvent): Promise<void> {
+    try {
+      const { spawn } = await import("node:child_process");
+      const child = spawn(NEXTCLOUD_BIN, [], { detached: true, stdio: "ignore" });
+      // "error" (e.g. ENOENT if Nextcloud isn't installed at this path) fires
+      // asynchronously — without this listener it would crash the plugin process.
+      child.once("error", (err) => {
+        streamDeck.logger.error("Failed to launch Nextcloud:", err);
+      });
+      child.unref();
+      await ev.action.showOk();
+    } catch (err) {
+      streamDeck.logger.error("Failed to launch Nextcloud:", err);
+      await ev.action.showAlert();
+    }
   }
 }
 
 const timerAction = new TimerToggle();
 streamDeck.actions.registerAction(timerAction);
+streamDeck.actions.registerAction(new LaunchNextcloud());
 
 streamDeck.ui.onSendToPlugin<{ event: string; settings?: TimerSettings; token?: string }>(async (ev) => {
   if (ev.payload.event === "saveSettings" && ev.payload.settings) {
@@ -253,6 +383,15 @@ streamDeck.ui.onSendToPlugin<{ event: string; settings?: TimerSettings; token?:
   }
 });
 
+const UPDATE_CHECK_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+
 streamDeck.connect();
 
-setTimeout(() => checkForUpdates(), 10_000);
+setTimeout(() => {
+  streamDeck.logger.info("Running initial (10s post-launch) update check");
+  checkForUpdates();
+}, 10_000);
+setInterval(() => {
+  streamDeck.logger.info("Running scheduled (30min) update check");
+  checkForUpdates();
+}, UPDATE_CHECK_INTERVAL_MS);

version.json

@@ -1 +1 @@
-{ "version": "1.0.39" }
+{ "version": "1.0.63" }