@hcu-lab.me/mcp-device 1.0.9 → 1.0.12

package/dist/mcp-device.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import './bootstrap.js';

package/dist/mcp-device.js

@@ -1,7 +1,29 @@
 #!/usr/bin/env node
-// MCP Device publishes only the authenticated device runtime surface.
-if (process.argv[2] !== 'remote')
-    process.argv.splice(2, 0, 'remote');
-const { runRemote } = await import('./npm-scripts/remote.js');
-await runRemote();
-export {};
+import './bootstrap.js';
+// Context and P1 commands remain isolated local operations.
+if (process.argv[2] === 'context') {
+    const { runContextCli } = await import('./context/cli.js');
+    const result = await runContextCli(process.argv.slice(3));
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    process.exitCode = result.exitCode;
+}
+else if (process.argv[2] === 'logs') {
+    const { runLogPalaceCli } = await import('./log-palace/cli.js');
+    const result = runLogPalaceCli(process.argv.slice(3));
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    process.exitCode = result.exitCode;
+}
+else if (['server', 'plugins', 'knowledge', 'admin', 'state', 'help', '--help', '-h'].includes(process.argv[2])) {
+    const { runPlatformCli } = await import('./platform/cli.js');
+    await runPlatformCli(['--help', '-h'].includes(process.argv[2]) ? 'help' : process.argv[2], process.argv.slice(3));
+}
+else {
+    if (process.argv[2] === 'device')
+        process.argv[2] = 'remote';
+    else if (process.argv[2] !== 'remote')
+        process.argv.splice(2, 0, 'remote');
+    const { runRemote } = await import('./npm-scripts/remote.js');
+    await runRemote();
+}

package/dist/npm-scripts/remote.js

@@ -21,6 +21,7 @@ function commandName() {
 function printRemoteUsage() {
     console.log([
         'Usage: mcp-device [command]',
+        'Core-only distribution; optional plugins require explicit install/enable.',
         '',
         'Commands: start, login, logout, status, install, stop, uninstall'
     ].join('\n'));

package/dist/platform/activity-journal.d.ts

@@ -0,0 +1,16 @@
+/** Bounded platform observations. A receipt describes execution, never validation of a claim. */
+export declare class ActivityJournal {
+    private deviceId;
+    private runtimeId;
+    private maxBytes;
+    private tail;
+    private pending;
+    private closed;
+    private filename;
+    private segmentTime;
+    private readonly directory;
+    constructor(stateRoot: string, deviceId: string, runtimeId: string, maxBytes?: number);
+    private nextSegment;
+    record(tool: string, args: unknown, result?: any, error?: unknown): void;
+    close(): Promise<void>;
+}

package/dist/platform/activity-journal.js

@@ -0,0 +1,68 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+/** Bounded platform observations. A receipt describes execution, never validation of a claim. */
+export class ActivityJournal {
+    constructor(stateRoot, deviceId, runtimeId, maxBytes = 2 * 1024 * 1024) {
+        this.deviceId = deviceId;
+        this.runtimeId = runtimeId;
+        this.maxBytes = maxBytes;
+        this.tail = Promise.resolve();
+        this.pending = 0;
+        this.closed = false;
+        this.segmentTime = 0;
+        this.directory = path.join(stateRoot, 'logs');
+        this.filename = this.nextSegment();
+    }
+    nextSegment() {
+        this.segmentTime = Math.max(Date.now(), this.segmentTime + 1);
+        return path.join(this.directory, `device-activity-${this.segmentTime}-${randomUUID()}.jsonl`);
+    }
+    record(tool, args, result, error) {
+        if (this.closed || this.pending >= 256 || tool.startsWith('knowledge.'))
+            return;
+        const input = args && typeof args === 'object' ? args : {};
+        const paths = {};
+        for (const name of ['path', 'file_path', 'working_directory', 'cwd'])
+            if (typeof input[name] === 'string')
+                paths[name] = input[name].slice(0, 1024);
+        let value = result?.structuredContent ?? result;
+        const text = value?.content?.find?.((part) => part.type === 'text')?.text;
+        if (typeof text === 'string' && text.length < 64 * 1024) {
+            try {
+                value = JSON.parse(text);
+            }
+            catch { /* no raw output is persisted */ }
+        }
+        const exitCode = typeof value?.exitCode === 'number' ? value.exitCode : typeof value?.exit_code === 'number' ? value.exit_code : null;
+        const failed = Boolean(error || result?.isError || value?.isError || value?.success === false || value?.timedOut || (exitCode !== null && exitCode !== 0));
+        const running = !failed && exitCode === null && Boolean(value?.sessionId || value?.session_id);
+        const status = failed ? 'failed' : running ? 'running' : 'completed';
+        const receipt = {
+            version: 1, event_id: randomUUID(), timestamp: new Date().toISOString(), device_id: this.deviceId,
+            session_id: this.runtimeId, toolName: tool.slice(0, 96), arguments: paths,
+            output: `Device tool ${tool.slice(0, 96)} ${status}${exitCode === null ? '' : ' with exit code ' + exitCode}.`,
+            status, exit_code: exitCode,
+            ...(error ? { error: { code: String(error.code ?? 'TOOL_CALL_FAILED').slice(0, 96) } } : {})
+        };
+        const frame = JSON.stringify(receipt) + '\n';
+        this.pending++;
+        this.tail = this.tail.then(async () => {
+            await fs.mkdir(this.directory, { recursive: true });
+            let size = await fs.stat(this.filename).then(stat => stat.size, () => 0);
+            if (size > 0 && size + Buffer.byteLength(frame) > this.maxBytes) {
+                this.filename = this.nextSegment();
+                size = 0;
+            }
+            await fs.appendFile(this.filename, frame, { mode: 0o600 });
+            if (size === 0) {
+                // Stable paths keep exact-source references valid until intentional
+                // retention pruning. Every segment remains discoverable as JSONL.
+                const segments = (await fs.readdir(this.directory)).filter(name => /^device-activity-\d+-[0-9a-f-]+\.jsonl$/.test(name) && name !== path.basename(this.filename)).sort().reverse();
+                for (const name of segments.slice(3))
+                    await fs.rm(path.join(this.directory, name), { force: true });
+            }
+        }).catch(() => { }).finally(() => { this.pending--; });
+    }
+    async close() { this.closed = true; await this.tail; }
+}

package/dist/platform/cli.d.ts

@@ -0,0 +1 @@
+export declare function runPlatformCli(command: string, argv: string[]): Promise<void>;

package/dist/platform/cli.js

@@ -0,0 +1,300 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { spawn } from 'node:child_process';
+import { CapabilityError } from './plugin-contract.js';
+import { resolveRuntimeRoot } from './runtime-root.js';
+import { resolveDevicePluginPolicy } from './plugin-policy.js';
+const packageRoot = fileURLToPath(new URL('../../', import.meta.url));
+const usage = `MCP Device 1.0.12
+  mcp-device start                          Core-only Device runtime
+  mcp-device device [start|status|...]      Alias for the Device-only commands
+  mcp-device server [--runtime-dir DIR] [--host HOST] [--port PORT] [--loopback-port PORT] [--public-url URL] [--skill-root DIR] [--allow-http-lan] [--legacy-knowledge-mcp] [--plugin-policy bundled|core-first]
+  mcp-device admin [--runtime-dir DIR] account|invite ...
+  mcp-device plugins [--runtime-dir DIR] list|install|enable|disable|uninstall|purge|upgrade|configure ...
+  mcp-device plugins install /path/to/palace.plugin.json --enable  Explicit optional Palace installation
+  mcp-device plugins upgrade /path/to/palace.plugin.json  Upgrade an optional plugin safely
+  mcp-device plugins repair-lock              Recover a proved-abandoned/incomplete registry lock
+  mcp-device knowledge [--runtime-dir DIR] search|list|read|ingest|learn|correct|skills [JSON]
+  mcp-device state backup|verify|restore|migrate [--source DIR] [--backup DIR] [--target DIR]
+  mcp-device context ...                   Existing local Context commands
+  mcp-device logs ...                      Existing P1 log search commands
+
+Server state defaults to ~/.mcp-device/server. Device state defaults stay unchanged.
+Server clients, including localhost, use the ordinary account/OAuth and Device pairing flow.
+Install/upgrade takes a local plugin manifest JSON. Disable/uninstall retain plugin data.
+Purge is a separate explicit operation for a disabled plugin. Admin passwords come from HCU_ADMIN_PASSWORD.
+State migration defaults to a reviewable dry run; --apply writes only a new target after verified backups.
+Core includes no bundled plugins or Palace Skill integration. Legacy --plugin-policy values
+are accepted for compatibility; neither value installs or automatically enables Palace.
+`;
+function parse(argv) {
+    const values = {}, flags = new Set(), positional = [];
+    const valued = new Set(['runtime-dir', 'host', 'port', 'loopback-port', 'public-url', 'skill-root', 'project-root', 'source-root', 'plugin-policy', 'config', 'source', 'backup', 'target', 'device-root', 'gateway-root']);
+    const switches = new Set(['help', 'enable', 'bundled', 'apply', 'json', 'allow-http-lan', 'legacy-knowledge-mcp']);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--') {
+            positional.push(...argv.slice(i + 1));
+            break;
+        }
+        if (arg === '-h') {
+            flags.add('help');
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            positional.push(arg);
+            continue;
+        }
+        const equal = arg.indexOf('='), key = arg.slice(2, equal < 0 ? undefined : equal);
+        if (switches.has(key) && equal < 0) {
+            flags.add(key);
+            continue;
+        }
+        if (!valued.has(key))
+            throw new CapabilityError('INVALID_ARGUMENT', 'Unknown option: --' + key);
+        const value = equal < 0 ? argv[++i] : arg.slice(equal + 1);
+        if (!value || value.startsWith('--'))
+            throw new CapabilityError('INVALID_ARGUMENT', 'Missing value for --' + key);
+        (values[key] ?? (values[key] = [])).push(value);
+    }
+    return { values, flags, positional };
+}
+const one = (args, key, fallback) => args.values[key]?.[args.values[key].length - 1] ?? fallback;
+function stateRoot(args, serverDefault = false) {
+    return path.resolve(one(args, 'runtime-dir', process.env.MCP_DEVICE_CONFIG_DIR || path.join(os.homedir(), '.mcp-device', ...(serverDefault ? ['server'] : []))));
+}
+function required(args, key) {
+    const value = one(args, key);
+    if (!value)
+        throw new CapabilityError('INVALID_ARGUMENT', '--' + key + ' is required');
+    return path.resolve(value);
+}
+async function jsonFile(filename) {
+    const text = await fs.readFile(path.resolve(filename), 'utf8');
+    return JSON.parse(text.replace(/^\uFEFF/, ''));
+}
+const print = (value) => process.stdout.write(JSON.stringify(value, null, 2) + '\n');
+const event = (value) => process.stdout.write(JSON.stringify(value) + '\n');
+async function pluginCli(args) {
+    const { PluginHost } = await import('./plugin-host.js');
+    const root = await resolveRuntimeRoot(one(args, 'runtime-dir')), [action = 'list', target, extra] = args.positional;
+    const host = new PluginHost({ stateRoot: root, deviceId: 'local-plugin-management' });
+    let release;
+    await host.load();
+    try {
+        if (action === 'list') {
+            print({ runtime_dir: root, plugins: host.list(), diagnostics: host.diagnostics() });
+            return;
+        }
+        if (action === 'repair-lock') {
+            print({ runtime_dir: root, ...await host.repairRegistryLock() });
+            return;
+        }
+        if (!target)
+            throw new CapabilityError('INVALID_ARGUMENT', 'Plugin id or manifest file is required');
+        if (action === 'install' || action === 'upgrade') {
+            let manifest;
+            if (args.flags.has('bundled')) {
+                const { bundledPluginManifests } = await import('../distribution.js');
+                const bundled = bundledPluginManifests().find(item => item.id === target);
+                if (!bundled)
+                    throw new CapabilityError('PLUGIN_NOT_FOUND', 'Unknown bundled plugin: ' + target);
+                manifest = bundled;
+            }
+            else {
+                manifest = await jsonFile(target);
+                manifest.entry = path.resolve(path.dirname(path.resolve(target)), manifest.entry);
+            }
+            if (action === 'install')
+                await host.install(manifest, { enabled: args.flags.has('enable'), installationSource: args.flags.has('bundled') ? 'distribution' : 'manual' });
+            else {
+                // Migration must not race a running provider in a different process.
+                const { acquireServerLease } = await import('./runtime-lease.js');
+                release = await acquireServerLease(root);
+                await host.upgrade(manifest, { installationSource: args.flags.has('bundled') ? 'distribution' : 'manual' });
+            }
+        }
+        else if (action === 'configure') {
+            if (!extra)
+                throw new CapabilityError('INVALID_ARGUMENT', 'configure requires a settings JSON file');
+            const settings = await jsonFile(extra);
+            if (!settings || Array.isArray(settings) || typeof settings !== 'object')
+                throw new CapabilityError('INVALID_ARGUMENT', 'Plugin settings must be an object');
+            const record = host.list().find(item => item.manifest.id === target);
+            if (record?.enabled)
+                throw new CapabilityError('PLUGIN_STILL_ENABLED', 'Disable the plugin before changing its settings');
+            await host.configure(target, settings);
+        }
+        else if (['enable', 'disable', 'uninstall'].includes(action)) {
+            await host[action](target);
+        }
+        else if (action === 'purge') {
+            const { acquireServerLease } = await import('./runtime-lease.js');
+            release = await acquireServerLease(root);
+            await host.purge(target);
+        }
+        else
+            throw new CapabilityError('INVALID_ARGUMENT', 'Unknown plugins action: ' + action);
+    }
+    finally {
+        await host.close();
+        await release?.();
+    }
+    print({ ok: true, action, plugins: host.list() });
+}
+async function knowledgeCli(args) {
+    const root = await resolveRuntimeRoot(one(args, 'runtime-dir')), [action = 'search', payload = '{}'] = args.positional;
+    if (!['search', 'list', 'read', 'ingest', 'learn', 'correct', 'skills'].includes(action))
+        throw new CapabilityError('INVALID_ARGUMENT', 'Unknown knowledge action');
+    const input = payload.startsWith('@') ? await jsonFile(payload.slice(1)) : JSON.parse(payload);
+    const { acquireServerLease } = await import('./runtime-lease.js');
+    const release = await acquireServerLease(root);
+    let host;
+    try {
+        const { GatewayDeviceIdentity } = await import('../device/gateway-identity.js');
+        const { PluginHost } = await import('./plugin-host.js');
+        const record = await new GatewayDeviceIdentity(path.join(root, 'gateway-identity.json')).loadOrCreate();
+        host = new PluginHost({ stateRoot: root, deviceId: record.deviceId, projectRoots: args.values['project-root']?.map(item => path.resolve(item)), sourceRoots: args.values['source-root']?.map(item => path.resolve(item)) ?? [path.join(root, 'logs')] });
+        await host.start({ skipIds: ['palace'] });
+        print(await host.invoke('knowledge.' + action, input));
+    }
+    finally {
+        await host?.close();
+        await release();
+    }
+}
+async function adminCli(args) {
+    const root = stateRoot(args, true);
+    await fs.mkdir(root, { recursive: true });
+    const child = spawn(process.execPath, [path.join(packageRoot, 'control-plane', 'scripts', 'admin.mjs'), ...args.positional], {
+        stdio: 'inherit', windowsHide: true, env: { ...process.env, MCP_RUNTIME_DIR: root, MCP_GATEWAY_DB_PATH: path.join(root, 'gateway.sqlite') }
+    });
+    await new Promise((resolve, reject) => { child.once('error', reject); child.once('exit', code => { process.exitCode = code ?? 1; resolve(); }); });
+}
+async function serverCli(args) {
+    if (args.positional.length && !(args.positional.length === 1 && args.positional[0] === 'start'))
+        throw new CapabilityError('INVALID_ARGUMENT', 'server accepts only start; use Ctrl-C or the service manager to stop');
+    const root = stateRoot(args, true), port = Number(one(args, 'port', '8104'));
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new CapabilityError('INVALID_ARGUMENT', 'Invalid server port');
+    const localPortInput = one(args, 'loopback-port');
+    const loopbackPort = localPortInput === undefined ? undefined : Number(localPortInput);
+    if (loopbackPort !== undefined && (!Number.isInteger(loopbackPort) || loopbackPort < 1 || loopbackPort > 65535 || loopbackPort === port))
+        throw new CapabilityError('INVALID_ARGUMENT', 'Loopback MCP port must be a distinct port in the range 1..65535');
+    const { acquireServerLease } = await import('./runtime-lease.js');
+    const release = await acquireServerLease(root);
+    process.env.MCP_DEVICE_CONFIG_DIR = root;
+    let core;
+    let runtime;
+    try {
+        const config = one(args, 'config') ? await jsonFile(one(args, 'config')) : {};
+        if (!config || typeof config !== 'object' || Array.isArray(config) || (config.env && (typeof config.env !== 'object' || Array.isArray(config.env))))
+            throw new CapabilityError('INVALID_ARGUMENT', 'Server config must be a JSON object with an optional env object');
+        const publicUrl = one(args, 'public-url');
+        const allowHttpLan = args.flags.has('allow-http-lan');
+        if (allowHttpLan) {
+            if (!publicUrl)
+                throw new CapabilityError('INVALID_ARGUMENT', '--allow-http-lan requires --public-url http://<lan-host>:<port>');
+            let url;
+            try {
+                url = new URL(publicUrl);
+            }
+            catch {
+                throw new CapabilityError('INVALID_ARGUMENT', '--public-url must be a valid absolute URL');
+            }
+            if (url.protocol !== 'http:')
+                throw new CapabilityError('INVALID_ARGUMENT', '--allow-http-lan is only for an explicit http:// LAN public URL');
+        }
+        const configuredSkillRoot = one(args, 'skill-root', process.env.MCP_SKILL_ROOT);
+        const legacySharedSkillRoot = path.join(os.homedir(), '.mcp-device', 'skills');
+        const skillRoot = configuredSkillRoot
+            ? path.resolve(configuredSkillRoot)
+            : await fs.stat(legacySharedSkillRoot).then(stat => stat.isDirectory() ? legacySharedSkillRoot : undefined).catch(() => undefined);
+        const { GatewayDeviceIdentity } = await import('../device/gateway-identity.js');
+        const identity = new GatewayDeviceIdentity(path.join(root, 'gateway-identity.json'));
+        const record = await identity.loadOrCreate();
+        const { createPlatformDeviceCore } = await import('./device-runtime.js');
+        const legacyKnowledgeMcp = args.flags.has('legacy-knowledge-mcp');
+        const cliPluginPolicy = one(args, 'plugin-policy');
+        const selectedPluginPolicy = cliPluginPolicy === undefined
+            ? (config.pluginPolicy === undefined ? resolveDevicePluginPolicy([], process.env) : resolveDevicePluginPolicy(['--plugin-policy', String(config.pluginPolicy)], {}))
+            : resolveDevicePluginPolicy(['--plugin-policy', cliPluginPolicy], {});
+        core = await createPlatformDeviceCore({ deviceId: record.deviceId, stateRoot: root, projectRoots: args.values['project-root']?.map(item => path.resolve(item)), sourceRoots: args.values['source-root']?.map(item => path.resolve(item)), pluginPolicy: selectedPluginPolicy, exposeKnowledgeMcp: legacyKnowledgeMcp });
+        const { createPlatformTools } = await import('./knowledge-mcp.js');
+        const { startServerRuntime } = await import(pathToFileURL(path.join(packageRoot, 'control-plane', 'scripts', 'authenticated-mcp-wrapper.mjs')).href);
+        const configPath = typeof config.configPath === 'string' ? path.resolve(path.dirname(path.resolve(one(args, 'config'))), config.configPath) : undefined;
+        runtime = await startServerRuntime({ core, identity, stateRoot: root, packageRoot, port, loopbackPort, host: one(args, 'host', '127.0.0.1'), publicUrl, allowHttpLan, skillRoot, env: config.env ?? {}, configPath, extraTools: legacyKnowledgeMcp ? await createPlatformTools(root) : [],
+            deviceName: 'localhost',
+            onPairing: (pairing) => event({ event: 'device_pairing_required', pairing }) });
+        event({ event: 'server_ready', version: '1.0.12', url: runtime.baseUrl, ...(runtime.loopbackUrl ? { loopback_url: runtime.loopbackUrl } : {}), device_id: record.deviceId, runtime_dir: root, local_runtime: 'shared-device-core', authentication: 'account-oauth-and-pairing' });
+        await new Promise(resolve => {
+            // A process manager may use Node's private parent/child IPC channel to stop
+            // gracefully on Windows, where kill(SIGTERM) otherwise terminates abruptly.
+            const message = (value) => { if (value?.type === 'mcp-device:shutdown')
+                stop(); };
+            const stop = () => { process.removeListener('SIGINT', stop); process.removeListener('SIGTERM', stop); process.removeListener('message', message); process.removeListener('disconnect', stop); resolve(); };
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+            if (process.send) {
+                process.on('message', message);
+                process.once('disconnect', stop);
+            }
+            runtime.server.once('close', stop);
+        });
+    }
+    finally {
+        if (runtime)
+            await runtime.close();
+        else
+            await core?.close();
+        await release();
+        if (process.connected)
+            process.disconnect();
+    }
+}
+async function stateCli(args) {
+    // The implementation is imported only for explicit state-management commands.
+    const modulePath = new URL('./state-backup.js', import.meta.url).href;
+    const state = await import(modulePath);
+    const [action] = args.positional;
+    if (action === 'backup')
+        print(await state.createStateBackup({ sourceRoot: required(args, 'source'), backupRoot: required(args, 'backup') }));
+    else if (action === 'verify')
+        print(await state.verifyStateBackup({ backupRoot: required(args, 'backup') }));
+    else if (action === 'restore')
+        print(await state.restoreStateBackup({ backupRoot: required(args, 'backup'), targetRoot: required(args, 'target') }));
+    else if (action === 'migrate') {
+        const options = { deviceRoot: required(args, 'device-root'), gatewayRoot: required(args, 'gateway-root'), targetRoot: required(args, 'target'), backupRoot: required(args, 'backup') };
+        const plan = await state.planLegacyMigration(options);
+        print(args.flags.has('apply') ? await state.applyLegacyMigration({ plan }) : plan);
+    }
+    else
+        throw new CapabilityError('INVALID_ARGUMENT', 'Use state backup, verify, restore or migrate');
+}
+export async function runPlatformCli(command, argv) {
+    try {
+        const args = parse(argv);
+        if (command === 'help' || args.flags.has('help')) {
+            process.stdout.write(usage);
+            return;
+        }
+        if (command === 'server')
+            await serverCli(args);
+        else if (command === 'plugins')
+            await pluginCli(args);
+        else if (command === 'knowledge')
+            await knowledgeCli(args);
+        else if (command === 'admin')
+            await adminCli(args);
+        else if (command === 'state')
+            await stateCli(args);
+        else
+            throw new CapabilityError('INVALID_ARGUMENT', 'Unknown platform command');
+    }
+    catch (error) {
+        process.stderr.write(JSON.stringify({ ok: false, code: error.code ?? 'COMMAND_FAILED', error: error.message }) + '\n');
+        process.exitCode = 1;
+    }
+}

package/dist/platform/coordination-lock.d.ts

@@ -0,0 +1,45 @@
+import { type FileHandle } from 'node:fs/promises';
+import { type ProcessNamespace } from './process-identity.js';
+export interface CoordinationLockBody {
+    pid: number;
+    token: string;
+    createdAt?: number;
+    processBirth?: string;
+    namespace?: ProcessNamespace;
+}
+export interface CoordinationObservation {
+    body?: CoordinationLockBody;
+    ageMs: number;
+    mtimeMs: number;
+    size: number;
+}
+export interface CoordinationCodes {
+    busy: string;
+    active: string;
+    recoveryRequired: string;
+}
+export interface CoordinationOptions {
+    nonBlocking?: boolean;
+    breakLock?: boolean;
+    attempts?: number;
+    staleMs?: number;
+    codes: CoordinationCodes;
+    messagePrefix?: string;
+    retainAbandoned?: boolean;
+}
+export declare function coordinationObservation(filename: string): Promise<CoordinationObservation | null>;
+export declare function processAppearsDead(pid: number): boolean;
+export declare function coordinationOwnerAbandoned(body: CoordinationLockBody): Promise<boolean>;
+export declare function createCoordinationLock(filename: string, token?: `${string}-${string}-${string}-${string}-${string}`): Promise<{
+    handle: FileHandle;
+    token: string;
+}>;
+export declare function releaseCoordinationLock(lock: {
+    handle: FileHandle;
+    token: string;
+}, filename: string): Promise<void>;
+export declare function repairCoordinationLock(lockPath: string, options: CoordinationOptions): Promise<{
+    recovered: boolean;
+    reason?: string;
+}>;
+export declare function withCoordinationLock<T>(lockPath: string, work: () => Promise<T>, options: CoordinationOptions): Promise<T>;