palmier 0.8.1 → 0.8.4

package/palmier-server/spec.md

@@ -12,18 +12,18 @@ The host supports **Linux** (systemd) and **Windows** (Task Scheduler for both d
 
 ### 1.2 Components
 
-* **Host Binary (Node.js):** Runs persistently on the user's host machine as a NATS + HTTP RPC handler. Manages file system operations (task CRUD), OS-level scheduling (systemd), and task generation. Provides a CLI with commands: `palmier init` (provisioning), `palmier pair` (generate pairing code for device pairing), `palmier clients` (manage client tokens), `palmier run <task-id>` (executes a task via the configured agent tool), `palmier uninstall` (stop daemon and remove all scheduled tasks), and `palmier serve` (persistent RPC handler, default command). The `serve` process always starts a local HTTP server (bound to `127.0.0.1` by default, or `0.0.0.0` if LAN mode is enabled) alongside the NATS transport. Exposes a localhost-only MCP server at `/mcp` (streamable HTTP transport) with tools: `notify`, `request-input`, `request-confirmation`, `device-geolocation`, `read-contacts`, `create-contact`, `read-calendar`, `create-calendar-event`, `send-sms-message`, `set-alarm`, `read-battery`, `set-ringer-mode`; and resources: `notifications://device` (device notifications), `sms-messages://device` (SMS messages). Tools and resources are auto-generated as REST endpoints from shared registries (`ToolDefinition[]`, `ResourceDefinition[]`) — zero duplication. Tool REST endpoints are POST with `taskId` query param; resource REST endpoints are GET. `/request-permission` remains a separate endpoint (not part of the MCP registries). MCP resources support subscriptions — clients call `resources/subscribe` and the server holds the POST response open as an SSE stream, pushing `notifications/resources/updated` notifications when the resource data changes. MCP sessions track agent names from `initialize` clientInfo for logging and UI display. `palmier run` is a short-lived process invoked by systemd. Task execution is abstracted through an `AgentTool` interface (`src/agents/agent.ts`) so different AI CLI tools can be supported — each agent implements `getPromptCommandLine()`, `getTaskRunCommandLine()`, and `init()`. The task's `agent` field (e.g., `"claude"`) selects which agent is used.
+* **Host Binary (Node.js):** Runs persistently on the user's host machine as a NATS + HTTP RPC handler. Manages file system operations (task CRUD), OS-level scheduling (systemd), and task generation. Provides a CLI with commands: `palmier init` (provisioning), `palmier pair` (generate pairing code for device pairing), `palmier clients` (manage client tokens), `palmier run <task-id>` (executes a task via the configured agent tool), `palmier uninstall` (stop daemon and remove all scheduled tasks), and `palmier serve` (persistent RPC handler, default command). The `serve` process always starts a local HTTP server (bound to `127.0.0.1` by default, or `0.0.0.0` if LAN mode is enabled) alongside the NATS transport. Exposes a localhost-only MCP server at `/mcp` (streamable HTTP transport) with tools: `notify`, `request-input`, `request-confirmation`, `device-geolocation`, `read-contacts`, `create-contact`, `read-calendar`, `create-calendar-event`, `send-sms-message`, `send-alarm`, `read-battery`, `set-ringer-mode`; and resources: `notifications://device` (device notifications), `sms-messages://device` (SMS messages). Tools and resources are auto-generated as REST endpoints from shared registries (`ToolDefinition[]`, `ResourceDefinition[]`) — zero duplication. Tool REST endpoints are POST with `taskId` query param; resource REST endpoints are GET. `/request-permission` remains a separate endpoint (not part of the MCP registries). MCP resources support subscriptions — clients call `resources/subscribe` and the server holds the POST response open as an SSE stream, pushing `notifications/resources/updated` notifications when the resource data changes. MCP sessions track agent names from `initialize` clientInfo for logging and UI display. `palmier run` is a short-lived process invoked by systemd. Task execution is abstracted through an `AgentTool` interface (`src/agents/agent.ts`) so different AI CLI tools can be supported — each agent implements `getPromptCommandLine()`, `getTaskRunCommandLine()`, and `init()`. The task's `agent` field (e.g., `"claude"`) selects which agent is used.
 
 * **Web Server (Node.js):** Serves the PWA assets (React) via `app.palmier.me` (Cloudflare proxied), manages Web Push VAPID keys, and provides host registration. Uses **PostgreSQL** for persistent storage (host registrations, push subscriptions, FCM tokens). Connects to NATS via TCP to subscribe to `host-event.>` for sending push notifications (confirmations, dismissals, completion/failure). For `POST /api/push/respond` (confirmation responses via push notification action buttons), the Web Server forwards the response to the host via the `task.user_input` NATS RPC. Subscribes to `host.*.push.send` NATS subjects to relay push notification requests from the host CLI. Subscribes to `host.*.fcm.geolocation` to relay device geolocation requests via FCM. Subscribes to `host.*.fcm.contacts`, `host.*.fcm.calendar`, `host.*.fcm.sms`, `host.*.fcm.alarm`, `host.*.fcm.battery`, and `host.*.fcm.ringer` to relay device capability requests via FCM. Provides HTTP endpoints for Android to post responses back (`/api/device/contacts-response`, `/api/device/calendar-response`, `/api/device/sms-response`, `/api/device/alarm-response`, `/api/device/battery-response`, `/api/device/ringer-response`). Co-located with the NATS server on the same machine.
 
 * **Android App (Capacitor):** Native Android wrapper for the PWA. Provides FCM push messaging for receiving data messages in the background, `FusedLocationProviderClient` for GPS access, `NotificationListenerService` for capturing device notifications, `BroadcastReceiver` for incoming SMS, and handlers for contacts, calendar, alarms, battery, and ringer mode. All device tools work while the app is in the background via FCM data messages. When a request arrives via FCM, the appropriate handler executes the action and POSTs the result back to the Web Server. Device capabilities and their permissions:
   - **Notifications**: `NotificationListenerService` — requires notification listener access (system settings toggle)
-  - **SMS receive**: `SmsBroadcastReceiver` — requires `RECEIVE_SMS` + `SEND_SMS` runtime permissions
-  - **SMS send**: `SmsHandler` — requires `SEND_SMS` runtime permission (shared with SMS receive toggle)
+  - **SMS Read**: `SmsBroadcastReceiver` — requires `RECEIVE_SMS` runtime permission
+  - **SMS Send**: `SmsHandler` — requires `SEND_SMS` runtime permission
   - **Contacts**: `ContactsHandler` — requires `READ_CONTACTS` + `WRITE_CONTACTS` runtime permissions
   - **Calendar**: `CalendarHandler` — requires `READ_CALENDAR` + `WRITE_CALENDAR` runtime permissions
   - **Geolocation**: `GeolocationForegroundService` — requires `ACCESS_FINE_LOCATION` runtime permission
-  - **Alarm**: `AlarmHandler` — requires `SET_ALARM` (normal permission, auto-granted)
+  - **Alarm**: `AlarmHandler` + `AlarmActivity` — triggers a full-screen alarm popup with looping ringtone; requires `USE_FULL_SCREEN_INTENT` (Android 14+ requires user grant in settings)
   - **Battery**: `BatteryHandler` — no permission required
   - **Ringer mode**: `RingerHandler` — requires Do Not Disturb access (system settings toggle)
 
@@ -49,6 +49,37 @@ The project is split across two repositories:
 
 * **`palmier`**: The host binary. A standalone Node.js CLI that runs on the user's machine.
 * **`palmier-server`**: Contains both the Web Server (`server/`) and the PWA (`pwa/`, built with Vite + React). Uses **pnpm** for package management with a pnpm workspace.
+* **`palmier-android`**: Capacitor-based Android wrapper that loads the PWA from `app.palmier.me` in a WebView and exposes native device capabilities via a custom plugin.
+
+### 1.5 Android Implementation Details
+
+The Android app is a thin native shell over the remotely-hosted PWA. The design decisions below are non-obvious enough that changing them silently would break assumptions the rest of the system makes.
+
+**Remote-first WebView.** `capacitor.config.json` sets `server.url` to `https://app.palmier.me`; the WebView fetches the PWA from the cloud on every launch. This means PWA updates ship instantly with no APK rebuild, and release builds run `npx cap sync` only (no PWA build step). Consequences:
+
+- **Server mode only.** LAN and Local modes are browser-only. The WebView blocks cleartext `http://<host-ip>:<port>` requests as mixed content, so LAN users must open the PWA from Chrome/Safari directly.
+- **Offline fallback.** When `app.palmier.me` is unreachable, the WebView loads `www/offline.html` (configured via `server.errorPath`), which auto-reloads when connectivity returns.
+- **PWA ships ahead of the APK.** The PWA may reference permission types or native methods that the installed APK doesn't implement yet. `Device.getSupportedPermissions()` returns the set the APK understands; `checkPermission` / `requestPermission` resolve with `{ granted: false, supported: false }` for unknown types rather than throwing. The PWA uses this to hide toggles it can't fulfill.
+
+**Unified `Device` Capacitor plugin.** A single plugin (`DevicePlugin.kt`) exposes the entire native surface — FCM token, permission gate, capability whitelist, installed-app enumeration, email-client availability, deep-link events. This replaces seven per-capability permission plugins. Methods: `getFcmToken`, `getSupportedPermissions`, `checkPermission({type})`, `requestPermission({type})`, `setEnabledCapabilities({capabilities})`, `getInstalledApps`, `hasEmailClient`, `addListener("deepLink", ...)`. Permission types: `location`, `smsRead`, `smsSend`, `contacts`, `calendar`, `notificationListener`, `dnd`, `fullScreenIntent`, `postNotifications`.
+
+**Capability kill-switch (`CapabilityState`).** Local whitelist persisted as a JSON-array string under `enabledCapabilities` in `CapacitorStorage` SharedPreferences, written only by `DevicePlugin.setEnabledCapabilities` from the PWA's derived state. Native receivers (`SmsBroadcastReceiver`, `DeviceNotificationListenerService`) and all FCM handlers consult this before acting — a second line of defense beyond the server-side capability token. If the user disables a capability in the drawer, the native side refuses to relay events or respond to requests even if the server still asks.
+
+**FCM token flow.** The PWA reads the current token on demand via `Device.getFcmToken()`; no cached copy in SharedPreferences. `PalmierFirebaseMessagingService.onNewToken` still re-registers with the relay server itself (using the stored `hostId`) because background token refreshes can fire while the PWA isn't running.
+
+**Deep links.** FCM notification taps pass a relative path (e.g. `/runs/:taskId/:runId`) via an `Intent` extra named `deepLink`. `MainActivity.handleDeepLink` forwards the path to `DevicePlugin.emitDeepLink`, which emits a `deepLink` event the PWA's router handles client-side. If the plugin isn't ready yet (intent arrives before `onPostCreate`), `MainActivity` buffers the path and flushes in `onPostCreate`. No external `intent-filter` is registered — Android 11+ `<queries>` entries are declared so `hasEmailClient` and installed-app enumeration work without `QUERY_ALL_PACKAGES`.
+
+**Notification listener filtering and debounce.** `DeviceNotificationListenerService` drops notifications from (a) Palmier's own `palmier_tasks` channel to avoid feedback loops and (b) the default SMS app (SMS is captured separately via `SmsBroadcastReceiver`, which arrives before the SMS app's notification). Empty-title+body notifications are skipped. A 2-second debounce per `packageName:title` key dedupes rapid updates; the debounce map is LRU-capped at 200 entries.
+
+**SMS capture.** Multi-part SMS arrives as multiple PDUs in a single `SMS_RECEIVED` broadcast. `SmsBroadcastReceiver` groups parts by `displayOriginatingAddress` and concatenates bodies before relaying, otherwise long messages would arrive as fragments.
+
+**Alarm capability.** `AlarmHandler` posts a `CATEGORY_ALARM` notification on the DND-bypassing `palmier_alarms` channel with a full-screen intent targeting `AlarmActivity`. `AlarmActivity` extends `AppCompatActivity`, shows over the lock screen (`setShowWhenLocked`/`setTurnScreenOn` on O_MR1+, legacy window flags below), and plays the default alarm ringtone on the alarm audio stream via `RingtoneManager`. Requires `USE_FULL_SCREEN_INTENT`; Android 14+ requires the user to grant it in per-app settings.
+
+**Email capability.** FCM `send-email` messages post a "Pending email" notification whose tap launches `EmailActivity` — a translucent `Activity` (not `AppCompatActivity`, so `Theme.Translucent` applies) that builds a `mailto:` URI and starts the email app with `ACTION_SENDTO`. The activity auto-finishes on result, returning the user to the previous screen. `hasEmailClient` gates the toggle in the PWA to avoid enabling a capability no installed app can fulfill.
+
+**Location capability.** `GeolocationForegroundService` briefly starts as a foreground service (`FOREGROUND_SERVICE_TYPE_LOCATION` on U+) and uses `FusedLocationProviderClient.getCurrentLocation(PRIORITY_HIGH_ACCURACY)` for a single fix before stopping itself. Requires both `ACCESS_FINE_LOCATION` and `ACCESS_BACKGROUND_LOCATION` on Q+; the plugin requests them sequentially.
+
+**Releases.** GitHub Actions builds a signed APK and creates a release when a `v*` tag is pushed. The workflow runs `npm ci && npx cap sync` — no PWA build step since the WebView loads remotely.
 
 ## 2. Host Provisioning & Device Pairing
 
@@ -227,8 +258,8 @@ requires_confirmation: true
 
 * `"crons"` — `schedule_values` holds cron expressions.
 * `"specific_times"` — `schedule_values` holds local datetime strings (e.g. `"2026-04-20T09:00"`).
-* `"on_new_notification"` — fires once per new Android notification relayed over NATS. No `schedule_values`.
-* `"on_new_sms"` — fires once per new SMS relayed over NATS. No `schedule_values`.
+* `"on_new_notification"` — fires once per new Android notification relayed over NATS. Optional `schedule_values` holds a single-entry packageName filter; empty/unset matches any app.
+* `"on_new_sms"` — fires once per new SMS relayed over NATS. Optional `schedule_values` holds a single-entry sender filter (phone number or alphanumeric shortcode); compared after normalizing away spaces, dashes, parens, plus sign, and case. Empty/unset matches any sender.
 
 For `crons` / `specific_times` the schedule is installed as an OS timer (systemd / Task Scheduler). For the `on_new_*` types the `palmier run` process subscribes directly to the corresponding NATS subject (`host.<hostId>.device.notifications` or `...device.sms`), drains events through a bounded FIFO queue, and invokes the agent once per event with the event payload spliced into the user prompt (mirroring command-triggered mode). These event-driven tasks are not started on save — they launch via `task.run` (the PWA auto-runs them on create, matching command-triggered UX).
 
@@ -313,7 +344,7 @@ Dashboard owns the always-on NATS event subscription and renders pending `confir
 
 4. For updates: if the user changes the `user_prompt` or `agent`, the name is regenerated. If neither changed, the existing name is preserved. Existing tasks with granted permissions show a clickable "Granted Permissions" link to view them.
 
-5. PWA sends `task.create` (or `task.update` with `id`) with the task fields as the message body. The `id` field is **not sent on create** — the host generates a UUID. `schedule_type` and `schedule_values` are omitted when the task has no schedule; `schedule_values` is also omitted for the `on_new_notification` / `on_new_sms` types.
+5. PWA sends `task.create` (or `task.update` with `id`) with the task fields as the message body. The `id` field is **not sent on create** — the host generates a UUID. `schedule_type` and `schedule_values` are omitted when the task has no schedule. For `on_new_notification` / `on_new_sms` types, `schedule_values` is sent only when a filter is configured (single packageName for notifications, single sender for SMS).
 
 6. Host creates/updates the `tasks/<task-id>/TASK.md` file and returns the **full flat task object** (all frontmatter fields at the top level). The PWA uses this response directly to update the UI.
 

package/src/agents/agent.ts

@@ -26,10 +26,6 @@ export interface CommandLine {
   env?: Record<string, string>;
 }
 
-/**
- * Interface that each agent tool must implement.
- * Abstracts how plans are generated and tasks are executed across different AI agents.
- */
 export interface AgentTool {
   /** Return the command and args for a short, non-interactive prompt (e.g. generating a task name). */
   getPromptCommandLine(prompt: string): CommandLine;

package/src/agents/claude.ts

@@ -24,7 +24,7 @@ export class ClaudeAgent implements AgentTool {
       }
     }
 
-    if (followupPrompt) {args.push("-c");} // continue mode for followups
+    if (followupPrompt) {args.push("-c");}
     return { command: "claude", args, stdin: prompt };
   }
 

package/src/agents/codex.ts

@@ -23,8 +23,8 @@ export class CodexAgent implements AgentTool {
         args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
       }
     }
-    if (followupPrompt) {args.push("resume", "--last");} // continue mode for followups
-    args.push("-"); // read prompt from stdin
+    if (followupPrompt) {args.push("resume", "--last");}
+    args.push("-");
 
     return { command: "codex", args, stdin: prompt };
   }

package/src/agents/cursor.ts

@@ -19,7 +19,7 @@ export class Cursor implements AgentTool {
     if (yolo) {
       args.push("--force");
     }
-    if (followupPrompt) {args.push("--continue");} // continue mode for followups
+    if (followupPrompt) {args.push("--continue");}
     args.push("-p", prompt);
 
     return { command: "cursor", args};

package/src/agents/deepagents.ts

@@ -19,7 +19,7 @@ export class DeepAgents implements AgentTool {
     if (yolo) {
       args.push("--auto-approve");
     }
-    if (followupPrompt) {args.push("--resume");} // continue mode for followups
+    if (followupPrompt) {args.push("--resume");}
     args.push("--non-interactive", prompt);
 
     return { command: "deepagents", args};

package/src/agents/gemini.ts

@@ -25,8 +25,9 @@ export class GeminiAgent implements AgentTool {
       args.push("--allowed-tools", tools.join(","));
     }
 
-    if (followupPrompt) {args.push("--resume");} // continue mode for followups
-    args.push("--prompt", "-"); // read prompt from stdin to avoid command line length limits
+    if (followupPrompt) {args.push("--resume");}
+    // Read prompt from stdin to avoid command-line length limits.
+    args.push("--prompt", "-");
     
     return { command: "gemini", args, stdin: prompt };
   }

package/src/agents/goose.ts

@@ -16,7 +16,7 @@ export class GooseAgent implements AgentTool {
     const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
     const args = ["run"];
 
-    if (followupPrompt) {args.push("--resume");} // continue mode for followups
+    if (followupPrompt) {args.push("--resume");}
     args.push("--text", prompt);
 
     return { command: "goose", args, ...(yolo ? { env: { GOOSE_MODE: "auto" } } : {}) };

package/src/agents/hermes.ts

@@ -19,7 +19,7 @@ export class Hermes implements AgentTool {
     if (yolo) {
       args.push("--trust-all-tools");
     }
-    if (followupPrompt) {args.push("--continue");} // continue mode for followups
+    if (followupPrompt) {args.push("--continue");}
     args.push("-q", prompt);
 
     return { command: "hermes", args};

package/src/agents/kiro.ts

@@ -19,7 +19,7 @@ export class Kiro implements AgentTool {
     if (yolo) {
       args.push("--trust-all-tools");
     }
-    if (followupPrompt) {args.push("--resume");} // continue mode for followups
+    if (followupPrompt) {args.push("--resume");}
     args.push("--no-interactive", prompt);
 
     return { command: "kiro-cli", args};

package/src/agents/opencode.ts

@@ -19,7 +19,7 @@ export class OpenCodeAgent implements AgentTool {
     if (yolo) {
       args.push("--dangerously-skip-permissions");
     }
-    if (followupPrompt) {args.push("--continue");} // continue mode for followups
+    if (followupPrompt) {args.push("--continue");}
     args.push(prompt);
 
     return { command: "opencode", args};

package/src/agents/qoder.ts

@@ -19,7 +19,7 @@ export class Qoder implements AgentTool {
     if (yolo) {
       args.push("--yolo");
     }
-    if (followupPrompt) {args.push("-c");} // continue mode for followups
+    if (followupPrompt) {args.push("-c");}
     args.push("-p", prompt);
 
     return { command: "qodercli", args};

package/src/agents/shared-prompt.ts

@@ -12,9 +12,6 @@ const AGENT_INSTRUCTIONS_TEMPLATE = fs.readFileSync(
   "utf-8",
 );
 
-/**
- * Build the full agent prompt: instructions + endpoint docs + task description.
- */
 export function getAgentInstructions(task: ParsedTask, skipPermissions?: boolean): string {
   const port = loadConfig().httpPort ?? 7256;
   const taskDescription = task.frontmatter.user_prompt;

package/src/commands/info.ts

@@ -1,9 +1,6 @@
 import { loadConfig } from "../config.js";
 import { loadClients } from "../client-store.js";
 
-/**
- * Print host connection info for setting up clients.
- */
 export async function infoCommand(): Promise<void> {
   const config = loadConfig();
   const clients = loadClients();
@@ -11,14 +8,12 @@ export async function infoCommand(): Promise<void> {
   console.log(`Host ID:      ${config.hostId}`);
   console.log(`Project root: ${config.projectRoot}`);
 
-  // Detected agents
   if (config.agents && config.agents.length > 0) {
     console.log(`Agents:       ${config.agents.map((a) => a.label).join(", ")}`);
   } else {
     console.log(`Agents:       (none detected — run \`palmier agents\`)`);
   }
 
-  // Clients
   console.log(`Clients:      ${clients.length} active`);
 
   if (clients.length === 0) {

package/src/commands/init.ts

@@ -15,9 +15,6 @@ const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
 const cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;
 const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
 
-/**
- * Interactive wizard to provision this host.
- */
 export async function initCommand(): Promise<void> {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   const ask: AskFn = (q) => new Promise<string>((resolve) => rl.question(q, resolve));
@@ -27,7 +24,6 @@ export async function initCommand(): Promise<void> {
     console.log(`By continuing, you agree to the ${cyan("Terms of Service")} (https://www.palmier.me/terms)`);
     console.log(`and ${cyan("Privacy Policy")} (https://www.palmier.me/privacy).\n`);
 
-    // Detect agents first — abort if none found
     console.log("Detecting installed agents...");
     const agents = await detectAgents();
 
@@ -41,7 +37,6 @@ export async function initCommand(): Promise<void> {
 
     console.log(`  Found: ${green(agents.map((a) => a.label).join(", "))}\n`);
 
-    // LAN mode
     const lanAnswer = await ask("Enable LAN access (direct HTTP from local network)? (y/N): ");
     const lanEnabled = lanAnswer.trim().toLowerCase() === "y";
 
@@ -51,7 +46,6 @@ export async function initCommand(): Promise<void> {
     const parsed = parseInt(portAnswer.trim(), 10);
     if (parsed > 0 && parsed < 65536) httpPort = parsed;
 
-    // Display summary and ask for confirmation before making any changes
     console.log(`\n${bold("Setup summary:")}\n`);
     console.log(`  ${dim("Task storage:")}   ${bold(process.cwd())}`);
     console.log(`                  All tasks and execution data will be stored here.\n`);
@@ -64,7 +58,6 @@ export async function initCommand(): Promise<void> {
     }
     console.log(`  ${dim("Agents:")}         ${agents.map((a) => a.label).join(", ")}\n`);
 
-    // Check for existing tasks to recover
     const existingTasks = listTasks(process.cwd());
     if (existingTasks.length > 0) {
       console.log(`  ${dim("Recover tasks:")}  ${existingTasks.length} existing task(s) found:`);
@@ -81,7 +74,6 @@ export async function initCommand(): Promise<void> {
       return;
     }
 
-    // Register with server
     let existingHostId: string | undefined;
     try { existingHostId = loadConfig().hostId; } catch { /* first init */ }
 
@@ -105,7 +97,6 @@ export async function initCommand(): Promise<void> {
       }
     }
 
-    // Build and save config
     const config: HostConfig = {
       hostId: registerResponse.hostId,
       projectRoot: process.cwd(),
@@ -123,8 +114,8 @@ export async function initCommand(): Promise<void> {
 
     getPlatform().installDaemon(config);
 
-    // Task recovery happens in the daemon (palmier serve) on startup,
-    // since the daemon runs elevated and can create S4U scheduled tasks.
+    // Task recovery runs in the daemon (palmier serve) because that process
+    // is elevated and can create S4U scheduled tasks.
 
     console.log("\nStarting pairing...");
     rl.close();

package/src/commands/pair.ts

@@ -1,4 +1,5 @@
 import * as http from "node:http";
+import * as os from "node:os";
 import { StringCodec } from "nats";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
@@ -21,12 +22,10 @@ function buildPairResponse(config: HostConfig, label?: string) {
   return {
     hostId: config.hostId,
     clientToken: client.token,
+    hostName: os.hostname(),
   };
 }
 
-/**
- * POST to the running serve daemon and long-poll until paired or expired.
- */
 function httpPairRegister(port: number, code: string): Promise<boolean> {
   const body = JSON.stringify({ code, expiryMs: PAIRING_EXPIRY_MS });
 
@@ -60,10 +59,7 @@ function httpPairRegister(port: number, code: string): Promise<boolean> {
   });
 }
 
-/**
- * Generate a pairing code and wait for a PWA client to pair.
- * Listens on NATS (server mode) and HTTP (via serve daemon) in parallel.
- */
+/** Listens on NATS (server mode) and HTTP (via serve daemon) in parallel. */
 export async function pairCommand(): Promise<void> {
   const config = loadConfig();
   const code = generatePairingCode();
@@ -78,7 +74,6 @@ export async function pairCommand(): Promise<void> {
 
   const cleanups: Array<() => void | Promise<void>> = [];
 
-  // Display pairing info
   console.log("");
   console.log("Enter this code in your Palmier app:");
   console.log("");
@@ -86,7 +81,6 @@ export async function pairCommand(): Promise<void> {
   console.log("");
   console.log("Code expires in 1 minute.");
 
-  // NATS pairing (server mode)
   const nc = await connectNats(config);
   const sc = StringCodec();
   const subject = `pair.${code}`;
@@ -116,13 +110,11 @@ export async function pairCommand(): Promise<void> {
     }
   })();
 
-  // HTTP pairing — register with serve daemon's /pair-register endpoint
   (async () => {
     const result = await httpPairRegister(httpPort, code);
     if (result) onPaired();
   })();
 
-  // Wait for pairing or timeout
   const start = Date.now();
   await new Promise<void>((resolve) => {
     const interval = setInterval(() => {
@@ -133,7 +125,6 @@ export async function pairCommand(): Promise<void> {
     }, 500);
   });
 
-  // Cleanup
   for (const cleanup of cleanups) {
     await cleanup();
   }

package/src/commands/restart.ts

@@ -1,8 +1,5 @@
 import { getPlatform } from "../platform/index.js";
 
-/**
- * Restart the palmier serve daemon.
- */
 export async function restartCommand(): Promise<void> {
   const platform = getPlatform();
   await platform.restartDaemon();