@turns/dev 0.0.7 → 0.0.9

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/dist/file-search.js

@@ -0,0 +1,182 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveBrowsePath } from "./file-browsing.js";
+/** Kept in step with the Durable Object's recursive search result limit. */
+export const MAX_FILE_SEARCH_RESULTS = 200;
+/** Typeahead must not leave a filesystem walk running after its browser query
+ * has already been superseded. A timed-out walk returns the useful prefix it
+ * found before it was stopped. */
+export const FILE_SEARCH_TIMEOUT_MS = 1_000;
+function isoTime(value) {
+    return Number.isFinite(value) ? new Date(value).toISOString() : '';
+}
+function pathIsInside(directory, candidate) {
+    const relative = path.relative(directory, candidate);
+    return relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function fileSearchEntry(directory, candidate) {
+    if (!pathIsInside(directory, candidate))
+        return null;
+    let link;
+    let stat;
+    try {
+        link = fs.lstatSync(candidate);
+        stat = fs.statSync(candidate);
+    }
+    catch {
+        return null;
+    }
+    const kind = stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : 'other';
+    const relative = path.relative(directory, candidate).split(path.sep).join('/');
+    return {
+        name: path.basename(candidate),
+        path: candidate,
+        displayName: relative,
+        kind,
+        ...(stat.isFile() ? { size: stat.size } : {}),
+        ...(Number.isFinite(stat.mtimeMs) ? { modifiedAt: isoTime(stat.mtimeMs) } : {}),
+        ...(link.isSymbolicLink() ? { symlink: true } : {}),
+    };
+}
+/**
+ * Run one NUL-delimited path enumerator without involving a shell.
+ *
+ * Queries are matched literally in this process, so punctuation in a browser
+ * query cannot become a glob, regular expression, command option, or shell
+ * fragment. Killing after the result cap also prevents a broad query from
+ * walking a huge tree merely to return entries the client cannot display.
+ */
+function enumeratePaths({ command, args, directory, query, limit, timeoutMs }) {
+    return new Promise((resolve, reject) => {
+        const entries = new Map();
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        let pending = '';
+        let stopped = false;
+        let timedOut = false;
+        let killTimer;
+        const stop = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => child.kill('SIGKILL'), 100);
+            killTimer.unref?.();
+        };
+        const consider = (rawPath) => {
+            const emitted = String(rawPath || '');
+            if (!emitted)
+                return;
+            const absolute = path.normalize(path.isAbsolute(emitted) ? emitted : path.resolve(directory, emitted));
+            if (!pathIsInside(directory, absolute))
+                return;
+            const relativeParts = path.relative(directory, absolute).split(path.sep);
+            // `rg --files` emits regular files rather than directories. Considering
+            // every prefix reconstructs matching directory observations too, and it
+            // preserves the cache's existing "match anywhere in the relative path"
+            // semantics for descendants of a matching directory.
+            for (let length = 1; length <= relativeParts.length; length += 1) {
+                const relative = relativeParts.slice(0, length).join('/');
+                if (!relative.toLowerCase().includes(query))
+                    continue;
+                const candidate = path.join(directory, ...relativeParts.slice(0, length));
+                if (!entries.has(candidate)) {
+                    const entry = fileSearchEntry(directory, candidate);
+                    if (entry)
+                        entries.set(candidate, entry);
+                }
+                if (entries.size >= limit) {
+                    stop();
+                    break;
+                }
+            }
+        };
+        const consume = (chunk, final = false) => {
+            pending += chunk;
+            let boundary = pending.indexOf('\0');
+            while (boundary !== -1) {
+                consider(pending.slice(0, boundary));
+                pending = pending.slice(boundary + 1);
+                boundary = pending.indexOf('\0');
+            }
+            if (final && pending)
+                consider(pending);
+        };
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => consume(chunk));
+        child.on('error', (error) => {
+            clearTimeout(killTimer);
+            reject(error);
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            stop();
+        }, timeoutMs);
+        timeout.unref?.();
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            clearTimeout(killTimer);
+            consume('', true);
+            const sorted = [...entries.values()]
+                .sort((left, right) => {
+                if (left.kind === 'directory' && right.kind !== 'directory')
+                    return -1;
+                if (left.kind !== 'directory' && right.kind === 'directory')
+                    return 1;
+                return left.path.localeCompare(right.path);
+            })
+                .slice(0, limit);
+            // Missing tools are tried by the caller. Permission races and partial
+            // walks remain useful if they produced any safe entries.
+            if (code === 0 || stopped || timedOut || sorted.length)
+                resolve(sorted);
+            else
+                reject(new Error(`${command} exited with status ${code}.`));
+        });
+    });
+}
+/**
+ * Find recursive path-name matches on the machine for directory typeahead.
+ *
+ * Ripgrep is preferred because its parallel directory walker is normally the
+ * quickest way to enumerate a project tree. Minimal installations fall back
+ * to POSIX `find`; both emit NUL-delimited names and are filtered literally.
+ */
+export async function searchMachinePaths({ requested, query, workingDirectory = '', allowedDirectories = [], limit = MAX_FILE_SEARCH_RESULTS, timeoutMs = FILE_SEARCH_TIMEOUT_MS, tools = ['rg', 'find'], }) {
+    const needle = String(query || '')
+        .trim()
+        .toLowerCase()
+        .slice(0, 500);
+    const resolved = resolveBrowsePath(String(requested || ''), { workingDirectory, allowedDirectories });
+    if (!resolved.stat.isDirectory())
+        throw new Error(`Not a searchable directory: ${resolved.path}`);
+    if (!needle)
+        return { directory: resolved.path, entries: [] };
+    const boundedLimit = Math.max(1, Math.min(MAX_FILE_SEARCH_RESULTS, Number(limit) || MAX_FILE_SEARCH_RESULTS));
+    const boundedTimeout = Math.max(25, Number(timeoutMs) || FILE_SEARCH_TIMEOUT_MS);
+    let lastError = null;
+    for (const tool of tools) {
+        try {
+            const args = tool === 'rg'
+                ? ['--files', '--hidden', '--no-ignore', '--no-messages', '--null', '--', resolved.path]
+                : tool === 'find'
+                    ? [resolved.path, '-print0']
+                    : [];
+            if (!args.length)
+                continue;
+            const entries = await enumeratePaths({
+                command: tool,
+                args,
+                directory: resolved.path,
+                query: needle,
+                limit: boundedLimit,
+                timeoutMs: boundedTimeout,
+            });
+            return { directory: resolved.path, entries };
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error('No filesystem search tool is available.');
+}

package/dist/queue-worker.js

@@ -8,6 +8,7 @@ import { anchorId, connectExistingAgentAnchors, launchAgentAnchor, waitForAgentT
 import { assertAllowedWorkingDirectory, workingDirectoryIsAllowed } from "./directory-policy.js";
 import { browseMachinePath } from "./file-browsing.js";
 import { applyFileEdit } from "./file-edits.js";
+import { searchMachinePaths } from "./file-search.js";
 import { nativeDescriptorAgentSessionId, nativeDescriptorWorkingDirectory } from "./local-session-sources.js";
 import { compactRuntimeValue } from "./native-record-compaction.js";
 import { createSecretRedactor } from "./secret-redaction.js";
@@ -1069,6 +1070,39 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             });
         }
     };
+    /** Refresh recursive path-name matches for directory typeahead.
+     *
+     * Like browsing, this is a machine filesystem operation rather than a
+     * harness operation, so stopped sessions remain searchable. The helper
+     * canonicalizes and allowlists the directory before starting a bounded
+     * ripgrep/find walk; only metadata crosses the control socket. */
+    const handleFileSearch = async (message, replyRpc) => {
+        const sessionId = String(message.sessionId || '');
+        try {
+            const searched = await searchMachinePaths({
+                requested: String(message.directory || ''),
+                query: String(message.query || ''),
+                workingDirectory: await browseWorkingDirectory(sessionId),
+                allowedDirectories: options.allowedDirectories || [],
+            });
+            replyRpc.notify({
+                type: 'session.file.search.result',
+                requestId: message.requestId,
+                sessionId,
+                ok: true,
+                ...searched,
+            });
+        }
+        catch (error) {
+            replyRpc.notify({
+                type: 'session.file.search.result',
+                requestId: message.requestId,
+                sessionId,
+                ok: false,
+                error: redactor.redactText(error?.message || String(error)),
+            });
+        }
+    };
     /**
      * Apply one queued browser edit, and report how it went.
      *
@@ -1139,6 +1173,8 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             void handleInteractionAnswer(message, rpc);
         if (message.type === 'session.file.browse.request')
             void handleFileBrowse(message, rpc);
+        if (message.type === 'session.file.search.request')
+            void handleFileSearch(message, rpc);
         if (message.type === 'session.file.edit.request')
             void handleFileEdit(message, rpc);
     });
@@ -1153,6 +1189,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 type: 'machine.register',
                 machineId: machine,
                 machineHostname: os.hostname(),
+                capabilities: { fileSearch: true },
                 workerId,
                 workerInstanceId,
                 anchorSessionIds: [...anchors.keys()],

package/package.json

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