@turns/dev 0.0.7 → 0.0.8

package/README.md

@@ -39,14 +39,19 @@ never prunes saved upload cursors, so it cannot make the sessions it filtered
 out replay from their first byte the next time the daemon starts.
 
 The server is selected with `--server URL` or `TURNS_ORIGIN`. Its normalized
-origin is saved in `~/.config/turns/credentials.json` and reused by later
-invocations and daemon starts. On Linux the other persistent files are:
+origin is saved and reused by later invocations and daemon starts. On Linux,
+Turns uses the XDG config/state directories and installs this user service:
 
 - `~/.config/turns/machine-id`
 - `~/.local/state/turns/native-upload-state.json`
 - `~/.local/state/turns/letta-sessions/*.json` (Letta conversation-to-project associations)
 - `~/.config/systemd/user/turns.service`
 
+On macOS, credentials and daemon state live under
+`~/Library/Application Support/turns/`, and `turns install` creates the per-user
+LaunchAgent `~/Library/LaunchAgents/dev.turns.cli.plist`. Its output is written
+to `~/Library/Application Support/turns/daemon.log`.
+
 The credential file contains a seven-day access token and a signed refresh
 token. The CLI refreshes the access token at least once every 24 hours. A new
 machine opens a one-time turns.dev URL, waits on an authentication WebSocket,
@@ -72,8 +77,9 @@ An explicit file browse may upload up to 199 MB to the same private R2 prefix.
 The daemon streams the file from disk and the Worker hands that request stream
 straight to R2, so neither process retains the complete file in memory.
 
-The systemd unit uses `KillMode=process`: restarting the uploader leaves its
-detached agent-anchor processes running so in-flight harness turns continue.
+The systemd unit uses `KillMode=process`, and the macOS LaunchAgent uses
+`AbandonProcessGroup`: restarting the uploader leaves its detached agent-anchor
+processes running so in-flight harness turns continue.
 For a foreground daemon restricted to one or more directory trees, repeat
 `--directory`. Both transcript discovery and agent launches enforce the
 canonical prefix, including protection against symlinks that escape it:

package/dist/daemon.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import { spawnSync } from 'node:child_process';
@@ -36,6 +37,7 @@ export function canonicalDaemonCliEntry(cliDirectory = HERE) {
 }
 export const SYSTEMD_SERVICE_NAME = 'turns.service';
 export const LEGACY_SYSTEMD_SERVICE_NAME = 'turns-native-uploader.service';
+export const MAC_LAUNCH_AGENT_LABEL = 'dev.turns.cli';
 function systemdQuote(value) {
     return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%')}"`;
 }
@@ -59,6 +61,62 @@ Environment=NODE_NO_WARNINGS=1
 WantedBy=default.target
 `;
 }
+function xmlEscape(value) {
+    return String(value)
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&apos;');
+}
+export function macLaunchAgentPlist({ cliEntry = canonicalDaemonCliEntry(), execPath = process.execPath, workingDirectory = os.homedir(), logPath = applicationPaths().daemonLog, pathEnvironment = process.env.PATH || '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin', } = {}) {
+    const arguments_ = [
+        execPath,
+        '--max-old-space-size=256',
+        '--max-semi-space-size=8',
+        '--experimental-strip-types',
+        cliEntry,
+        'daemon',
+        'run',
+    ];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${MAC_LAUNCH_AGENT_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${arguments_.map((value) => `    <string>${xmlEscape(value)}</string>`).join('\n')}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(workingDirectory)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
+  <key>AbandonProcessGroup</key>
+  <true/>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>NODE_NO_WARNINGS</key>
+    <string>1</string>
+    <key>PATH</key>
+    <string>${xmlEscape(pathEnvironment)}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(logPath)}</string>
+</dict>
+</plist>
+`;
+}
 function systemctl(arguments_, { spawnSyncImpl = spawnSync, allowFailure = false } = {}) {
     const result = spawnSyncImpl('systemctl', ['--user', ...arguments_], { encoding: 'utf8', stdio: 'pipe' });
     if (!allowFailure && result.status !== 0) {
@@ -66,6 +124,16 @@ function systemctl(arguments_, { spawnSyncImpl = spawnSync, allowFailure = false
     }
     return result;
 }
+function launchctl(arguments_, { spawnSyncImpl = spawnSync, allowFailure = false } = {}) {
+    const result = spawnSyncImpl('/bin/launchctl', arguments_, { encoding: 'utf8', stdio: 'pipe' });
+    if (!allowFailure && result.status !== 0) {
+        throw new Error(String(result.stderr || result.stdout || `launchctl ${arguments_.join(' ')} failed`).trim());
+    }
+    return result;
+}
+function macLaunchTarget(userId) {
+    return `gui/${userId}/${MAC_LAUNCH_AGENT_LABEL}`;
+}
 export function installLinuxDaemon({ paths = applicationPaths(), spawnSyncImpl = spawnSync, } = {}) {
     fs.mkdirSync(path.dirname(paths.linuxService), { recursive: true, mode: 0o700 });
     const unit = linuxServiceUnit();
@@ -115,20 +183,63 @@ export function linuxDaemonStatus({ spawnSyncImpl = spawnSync } = {}) {
         status: String(result.stdout || result.stderr || 'unknown').trim(),
     };
 }
-export function installDaemon(options = {}) {
-    if (process.platform !== 'linux') {
-        throw new Error('Automatic daemon installation is currently supported on Linux with systemd.');
-    }
-    return installLinuxDaemon(options);
+export function installMacDaemon({ paths = applicationPaths(), spawnSyncImpl = spawnSync, userId = process.getuid?.(), } = {}) {
+    if (userId === undefined)
+        throw new Error('Could not determine the macOS user ID for launchd.');
+    fs.mkdirSync(path.dirname(paths.macLaunchAgent), { recursive: true, mode: 0o700 });
+    fs.mkdirSync(path.dirname(paths.daemonLog), { recursive: true, mode: 0o700 });
+    const target = macLaunchTarget(userId);
+    const temporary = `${paths.macLaunchAgent}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, macLaunchAgentPlist({ workingDirectory: os.homedir(), logPath: paths.daemonLog }), { mode: 0o644 });
+    fs.renameSync(temporary, paths.macLaunchAgent);
+    // A loaded job retains its previous definition. Boot it out after the atomic
+    // replacement so a reinstall always starts the command from the current CLI.
+    launchctl(['bootout', target], { spawnSyncImpl, allowFailure: true });
+    launchctl(['enable', target], { spawnSyncImpl });
+    launchctl(['bootstrap', `gui/${userId}`, paths.macLaunchAgent], { spawnSyncImpl });
+    launchctl(['kickstart', '-k', target], { spawnSyncImpl });
+    return paths.macLaunchAgent;
 }
-export function uninstallDaemon(options = {}) {
-    if (process.platform !== 'linux') {
-        throw new Error('Automatic daemon removal is currently supported on Linux with systemd.');
+export function uninstallMacDaemon({ paths = applicationPaths(), spawnSyncImpl = spawnSync, userId = process.getuid?.(), } = {}) {
+    if (userId === undefined)
+        throw new Error('Could not determine the macOS user ID for launchd.');
+    launchctl(['bootout', macLaunchTarget(userId)], { spawnSyncImpl, allowFailure: true });
+    try {
+        fs.unlinkSync(paths.macLaunchAgent);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            throw error;
     }
-    return uninstallLinuxDaemon(options);
 }
-export function daemonStatus(options = {}) {
-    if (process.platform !== 'linux')
+export function macDaemonStatus({ spawnSyncImpl = spawnSync, userId = process.getuid?.(), } = {}) {
+    if (userId === undefined)
         return { active: false, status: 'unsupported' };
-    return linuxDaemonStatus(options);
+    const result = launchctl(['print', macLaunchTarget(userId)], { spawnSyncImpl, allowFailure: true });
+    if (result.status !== 0)
+        return { active: false, status: 'not running' };
+    const output = String(result.stdout || result.stderr || '');
+    const state = /^\s*state = (.+?)\s*$/mu.exec(output)?.[1] || 'loaded';
+    return { active: state === 'running', status: state };
+}
+export function installDaemon({ platform = process.platform, ...options } = {}) {
+    if (platform === 'linux')
+        return installLinuxDaemon(options);
+    if (platform === 'darwin')
+        return installMacDaemon(options);
+    throw new Error('Automatic daemon installation is supported on Linux with systemd and macOS with launchd.');
+}
+export function uninstallDaemon({ platform = process.platform, ...options } = {}) {
+    if (platform === 'linux')
+        return uninstallLinuxDaemon(options);
+    if (platform === 'darwin')
+        return uninstallMacDaemon(options);
+    throw new Error('Automatic daemon removal is supported on Linux with systemd and macOS with launchd.');
+}
+export function daemonStatus({ platform = process.platform, ...options } = {}) {
+    if (platform === 'linux')
+        return linuxDaemonStatus(options);
+    if (platform === 'darwin')
+        return macDaemonStatus(options);
+    return { active: false, status: 'unsupported' };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",