remosidian 0.1.0 → 0.1.2

package/dist/remosidian.mjs

@@ -14380,13 +14380,20 @@ var __webpack_exports__ = {};
 
 // EXPORTS
 __nccwpck_require__.d(__webpack_exports__, {
+  gu: () => (/* binding */ buildPairCode),
+  ti: () => (/* binding */ buildPairDeepLink),
   lz: () => (/* binding */ buildPairUri),
+  jO: () => (/* binding */ buildServeArgs),
+  YP: () => (/* binding */ createCompactPairingPayload),
   wX: () => (/* binding */ expandVaultSpec),
   iW: () => (/* binding */ main),
   Zy: () => (/* binding */ parseArgs),
+  Mf: () => (/* binding */ resolveEntrypointHref),
   t0: () => (/* binding */ resolveInvocation)
 });
 
+;// CONCATENATED MODULE: external "node:child_process"
+const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:child_process");
 ;// CONCATENATED MODULE: external "node:fs"
 const external_node_fs_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs");
 ;// CONCATENATED MODULE: external "node:os"
@@ -14712,8 +14719,6 @@ function loadOrCreateDaemonIdentity(port, identityPath) {
     return identity;
 }
 //# sourceMappingURL=identity.js.map
-;// CONCATENATED MODULE: external "node:child_process"
-const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:child_process");
 ;// CONCATENATED MODULE: ../../packages/daemon-core/dist/advertised-hosts.js
 
 
@@ -19580,7 +19585,7 @@ function runFileBackedPluginTurn(input, prompt, options, onDelta) {
 }
 //# sourceMappingURL=chat-plugin-runtime.js.map
 ;// CONCATENATED MODULE: ../remosidian-server/dist/version.js
-const VERSION = '0.1.0';
+const VERSION = '0.1.2';
 //# sourceMappingURL=version.js.map
 ;// CONCATENATED MODULE: ../remosidian-server/dist/chat-runtime.js
 
@@ -28062,6 +28067,7 @@ function startTunnel({ port, logDir, tunnelStatePath, resolveLaunchSpec = resolv
 
 
 
+
 const PROG = 'remosidian';
 const PRIMARY_NPM_PACKAGE = '@remosidian/cli';
 const ALIAS_NPM_PACKAGE = 'remosidian';
@@ -28080,9 +28086,11 @@ function helpText() {
     `  ${PROG} <command> [options]`,
     '',
     'Commands:',
-    '  start                Start the Remosidian server in the foreground',
+    '  start                Start or reuse the Remosidian background daemon',
+    '  serve                Internal foreground daemon entrypoint',
     '  pair                 Open a one-time pairing window and print a QR code',
     '  status               Print the running daemon health snapshot',
+    '  stop                 Stop the background daemon',
     '  reset-pairings       Revoke every paired device (local only)',
     '  init                 Create ~/.remosidian/config.json interactively',
     '  help                 Show this help',
@@ -28104,6 +28112,7 @@ function helpText() {
     '  --bind <address>     Bind to this interface (default 0.0.0.0)',
     '  --agent <name>       AI agent for /Ask: claude or codex (auto-detects)',
     '  --agent-path <path>  Override the agent binary path',
+    '  --foreground         Run the server in the foreground',
     '  --json               Emit a single JSON line instead of human output',
     '  --no-qr              Skip the pairing QR on startup',
   ].join('\n');
@@ -28156,6 +28165,15 @@ function resolveInvocation(argv) {
   return { command, rest, useCurrentDirectoryVault: false };
 }
 
+function resolveEntrypointHref(path) {
+  if (!path) return '';
+  try {
+    return (0,external_node_url_namespaceObject.pathToFileURL)((0,external_node_fs_namespaceObject.realpathSync)((0,external_node_path_namespaceObject.resolve)(path))).href;
+  } catch {
+    return (0,external_node_url_namespaceObject.pathToFileURL)((0,external_node_path_namespaceObject.resolve)(path)).href;
+  }
+}
+
 function expandVaultSpec(spec) {
   const trimmed = spec.trim();
   if (!trimmed) return null;
@@ -28201,6 +28219,69 @@ function resolvePaths(flags) {
   return createRemosidianPaths(dataDir ?? process.env.REMOSIDIAN_HOME ?? '~/.remosidian');
 }
 
+function createRuntimePaths(paths) {
+  const runtimeDir = (0,external_node_path_namespaceObject.join)(paths.dataDir, 'runtime', 'current');
+  const logDir = (0,external_node_path_namespaceObject.join)(paths.dataDir, 'logs');
+  return {
+    runtimeDir,
+    runtimeEntryPath: (0,external_node_path_namespaceObject.join)(runtimeDir, 'dist', 'remosidian.mjs'),
+    pidPath: (0,external_node_path_namespaceObject.join)(paths.dataDir, 'daemon.pid'),
+    logDir,
+    stdoutLogPath: (0,external_node_path_namespaceObject.join)(logDir, 'daemon.stdout.log'),
+    stderrLogPath: (0,external_node_path_namespaceObject.join)(logDir, 'daemon.stderr.log'),
+    pairingQrPath: (0,external_node_path_namespaceObject.join)(paths.dataDir, 'pairing-qr.png'),
+    pairingCodePath: (0,external_node_path_namespaceObject.join)(paths.dataDir, 'pairing-code.txt'),
+  };
+}
+
+function readPidFile(pidPath) {
+  try {
+    const pid = Number((0,external_node_fs_namespaceObject.readFileSync)(pidPath, 'utf8').trim());
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function writePidFile(pidPath, pid) {
+  (0,external_node_fs_namespaceObject.mkdirSync)((0,external_node_path_namespaceObject.dirname)(pidPath), { recursive: true });
+  (0,external_node_fs_namespaceObject.writeFileSync)(pidPath, `${pid}\n`, 'utf8');
+}
+
+function removePidFile(pidPath) {
+  (0,external_node_fs_namespaceObject.rmSync)(pidPath, { force: true });
+}
+
+function remosidian_isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function currentEntrypointPath() {
+  const entryPath = (0,external_node_url_namespaceObject.fileURLToPath)(import.meta.url);
+  try {
+    return (0,external_node_fs_namespaceObject.realpathSync)(entryPath);
+  } catch {
+    return entryPath;
+  }
+}
+
+function installRuntime(paths) {
+  const runtime = createRuntimePaths(paths);
+  (0,external_node_fs_namespaceObject.mkdirSync)((0,external_node_path_namespaceObject.dirname)(runtime.runtimeEntryPath), { recursive: true });
+  (0,external_node_fs_namespaceObject.copyFileSync)(currentEntrypointPath(), runtime.runtimeEntryPath);
+  (0,external_node_fs_namespaceObject.chmodSync)(runtime.runtimeEntryPath, 0o755);
+  return runtime;
+}
+
+function resolveRequestedPort(flags, paths) {
+  return Number(flags.port) || (loadConfigOrNull(paths)?.server?.port ?? 41234);
+}
+
 function readCsvList(value) {
   if (typeof value !== 'string') return [];
   return value
@@ -28331,7 +28412,7 @@ async function resolveRelayForStart(flags, paths, port) {
 
 function renderQrTerminal(payload) {
   return new Promise((resolveTerm, rejectTerm) => {
-    lib.toString(payload, { type: 'terminal', small: true }, (err, str) => {
+    lib.toString(payload, { type: 'terminal', small: true, errorCorrectionLevel: 'M' }, (err, str) => {
       if (err) {
         rejectTerm(err);
         return;
@@ -28343,7 +28424,7 @@ function renderQrTerminal(payload) {
 
 async function writeQrPng(payload, filePath) {
   (0,external_node_fs_namespaceObject.mkdirSync)((0,external_node_path_namespaceObject.dirname)(filePath), { recursive: true });
-  await lib.toFile(filePath, payload, { type: 'png', margin: 1, width: 512 });
+  await lib.toFile(filePath, payload, { type: 'png', errorCorrectionLevel: 'M', margin: 1, scale: 8 });
 }
 
 function printHumanHealth(health) {
@@ -28405,7 +28486,214 @@ function buildPairUri(payload) {
   return `remosidian://pair?v=1&data=${encoded}`;
 }
 
-async function cmdStart(flags, paths) {
+function normalizePairingConnections(payload) {
+  const explicitConnections = Array.isArray(payload.connections)
+    ? payload.connections
+        .filter(
+          (target) =>
+            target &&
+            typeof target.host === 'string' &&
+            Number.isFinite(target.port) &&
+            typeof target.source === 'string' &&
+            typeof target.stability === 'string',
+        )
+        .map((target) => ({
+          kind: target.kind === 'relay' ? 'relay' : 'direct',
+          host: target.host.trim(),
+          port: Math.floor(Number(target.port)),
+          ...(target.secure === true ? { secure: true } : {}),
+          source: target.source,
+          stability: target.stability,
+        }))
+        .filter((target) => target.host && target.port > 0)
+    : [];
+  if (explicitConnections.length > 0) {
+    return explicitConnections;
+  }
+  const fallbackHosts = Array.isArray(payload.fallbackHosts)
+    ? payload.fallbackHosts.filter((host) => typeof host === 'string' && host.trim()).map((host) => host.trim())
+    : [];
+  const port = Number.isFinite(payload.port) && payload.port > 0 ? Math.floor(payload.port) : 41234;
+  return [
+    {
+      kind: 'direct',
+      host: payload.canonicalHost,
+      port,
+      source: 'configured_host',
+      stability: 'stable',
+    },
+    ...fallbackHosts.map((host) => ({
+      kind: 'direct',
+      host,
+      port,
+      source: 'fallback',
+      stability: 'stable',
+    })),
+  ];
+}
+
+function createCompactPairingPayload(payload) {
+  const compact = {
+    t: 'rp',
+    d: payload.daemonId,
+    n: payload.displayName,
+    h: payload.canonicalHost,
+    p: payload.port,
+    c: payload.pairNonce,
+    e: payload.expiresAt,
+  };
+  if (Array.isArray(payload.fallbackHosts) && payload.fallbackHosts.length > 0) {
+    compact.f = payload.fallbackHosts;
+  }
+  const connections = normalizePairingConnections(payload);
+  if (connections.length > 0) {
+    compact.o = connections.map((target) => [
+      target.kind,
+      target.host,
+      target.port,
+      target.source,
+      target.stability,
+      target.secure === true,
+    ]);
+  }
+  if (payload.runtime) {
+    compact.r = payload.runtime;
+  }
+  if (Array.isArray(payload.vaults) && payload.vaults.length > 0) {
+    compact.v = payload.vaults;
+  }
+  return compact;
+}
+
+function buildPairCode(payload) {
+  return JSON.stringify(createCompactPairingPayload(payload));
+}
+
+function buildPairDeepLink(pairingCode) {
+  return `remosidian://pair?data=${encodeURIComponent(pairingCode)}`;
+}
+
+function formatConnectionSummary(target) {
+  const scheme = target.secure === true || target.port === 443 ? 'https' : 'http';
+  return `${scheme}://${target.host}:${target.port} (${target.source}, ${target.stability})`;
+}
+
+async function printPairingQr(pairingPayload, paths) {
+  const runtime = createRuntimePaths(paths);
+  const pairingCode = buildPairCode(pairingPayload);
+  const deepLink = buildPairDeepLink(pairingCode);
+  const qr = await renderQrTerminal(pairingCode);
+  (0,external_node_fs_namespaceObject.writeFileSync)(runtime.pairingCodePath, `${pairingCode}\n`, 'utf8');
+  await writeQrPng(pairingCode, runtime.pairingQrPath).catch(() => undefined);
+  process.stdout.write(`\nScan this QR code with the Remosidian app:\n\n${qr}\n`);
+  process.stdout.write(`If the terminal QR is hard to scan, open this PNG instead:\n${runtime.pairingQrPath}\n`);
+  process.stdout.write(`If this device cannot scan, paste this pairing code in Remosidian:\n${pairingCode}\n`);
+  process.stdout.write(`Pairing code saved to:\n${runtime.pairingCodePath}\n`);
+  process.stdout.write(`Or open this deep link on a device with Remosidian installed:\n${deepLink}\n`);
+}
+
+async function printPairingSummary(port, paths, health = null, flags = {}) {
+  const healthPayload = health ?? (await waitForHealth(port));
+  if (flags.json) {
+    process.stdout.write(`${JSON.stringify({ ok: true, ...healthPayload })}\n`);
+    return;
+  }
+  process.stdout.write(`Remosidian daemon is ready.\n\n`);
+  process.stdout.write(`${printHumanHealth(healthPayload)}\n`);
+  if (flags['no-qr']) {
+    return;
+  }
+  const pairingPayload = await postJson(port, '/pair/open');
+  const connections = normalizePairingConnections(pairingPayload);
+  if (connections.length > 0) {
+    process.stdout.write('\nPairing paths:\n');
+    for (const target of connections) {
+      process.stdout.write(`  - ${formatConnectionSummary(target)}\n`);
+    }
+  }
+  await printPairingQr(pairingPayload, paths);
+}
+
+async function probeHealth(port, timeoutMs = 0) {
+  const deadline = Date.now() + timeoutMs;
+  do {
+    try {
+      const resp = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2000) });
+      if (resp.ok) {
+        return await resp.json();
+      }
+    } catch {
+      // Retry below until timeout.
+    }
+    if (timeoutMs <= 0) break;
+    await new Promise((resolveProbe) => setTimeout(resolveProbe, 250));
+  } while (Date.now() < deadline);
+  return null;
+}
+
+async function waitForHealth(port, timeoutMs = 30_000) {
+  const health = await probeHealth(port, timeoutMs);
+  if (health) {
+    return health;
+  }
+  throw new Error(`Timed out waiting for Remosidian daemon on 127.0.0.1:${port}`);
+}
+
+async function postJson(port, pathname, body = undefined) {
+  const response = await fetch(`http://127.0.0.1:${port}${pathname}`, {
+    method: 'POST',
+    headers: body ? { 'content-type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(`${pathname} failed: ${response.status} ${JSON.stringify(payload)}`);
+  }
+  return payload;
+}
+
+function buildServeArgs(flags) {
+  const args = ['serve'];
+  for (const vault of flags.__vaults ?? []) {
+    args.push('--vault', vault);
+  }
+  const skipFlags = new Set(['__vaults', 'foreground', 'json']);
+  for (const [key, value] of Object.entries(flags)) {
+    if (skipFlags.has(key)) continue;
+    if (key === 'no-qr') continue;
+    if (value === true) {
+      args.push(`--${key}`);
+    } else if (typeof value === 'string') {
+      args.push(`--${key}`, value);
+    }
+  }
+  args.push('--no-qr');
+  return args;
+}
+
+function startDetachedDaemon(paths, flags) {
+  const runtime = installRuntime(paths);
+  (0,external_node_fs_namespaceObject.mkdirSync)(runtime.logDir, { recursive: true });
+  const stdoutFd = (0,external_node_fs_namespaceObject.openSync)(runtime.stdoutLogPath, 'a');
+  const stderrFd = (0,external_node_fs_namespaceObject.openSync)(runtime.stderrLogPath, 'a');
+  try {
+    const child = (0,external_node_child_process_namespaceObject.spawn)(process.execPath, [runtime.runtimeEntryPath, ...buildServeArgs(flags)], {
+      detached: true,
+      stdio: ['ignore', stdoutFd, stderrFd],
+      cwd: process.cwd(),
+      env: { ...process.env },
+      windowsHide: true,
+    });
+    child.unref();
+    writePidFile(runtime.pidPath, child.pid);
+    return child.pid;
+  } finally {
+    (0,external_node_fs_namespaceObject.closeSync)(stdoutFd);
+    (0,external_node_fs_namespaceObject.closeSync)(stderrFd);
+  }
+}
+
+async function cmdServe(flags, paths) {
   const config = loadConfigOrNull(paths);
   const inlineVaults = flags.__vaults.map((spec) => expandVaultSpec(spec)).filter((vault) => Boolean(vault));
   let finalConfig;
@@ -28487,16 +28775,7 @@ async function cmdStart(flags, paths) {
       const openResp = await fetch(`http://127.0.0.1:${server.port}/pair/open`, { method: 'POST' });
       if (openResp.ok) {
         const payload = await openResp.json();
-        const uri = buildPairUri(payload);
-        const qr = await renderQrTerminal(uri);
-        process.stdout.write('\nScan to pair (one-time, expires in 5 min):\n');
-        process.stdout.write(`${qr}\n`);
-        process.stdout.write(`${uri}\n\n`);
-        const qrPath = (0,external_node_path_namespaceObject.join)(paths.dataDir, 'pairing-qr.png');
-        await writeQrPng(uri, qrPath).catch(() => {
-          // PNG export is best-effort.
-        });
-        process.stdout.write(`Saved QR image: ${qrPath}\n`);
+        await printPairingQr(payload, paths);
       }
     } catch (error) {
       process.stderr.write(`[${PROG}] pair payload not available: ${error?.message ?? error}\n`);
@@ -28519,31 +28798,60 @@ async function cmdStart(flags, paths) {
   process.on('SIGHUP', () => void shutdown('SIGHUP'));
 }
 
-async function cmdPair(flags, paths) {
-  const port = Number(flags.port) || (loadConfigOrNull(paths)?.server?.port ?? 41234);
-  const openResp = await fetch(`http://127.0.0.1:${port}/pair/open`, { method: 'POST' });
-  if (!openResp.ok) {
-    process.stderr.write(`[${PROG}] /pair/open failed: ${openResp.status} ${openResp.statusText}\n`);
-    process.exit(1);
+async function cmdStart(flags, paths) {
+  if (flags.foreground) {
+    await cmdServe(flags, paths);
+    return;
+  }
+  const port = resolveRequestedPort(flags, paths);
+  const existing = await probeHealth(port, 1_000);
+  if (existing) {
+    if (!flags.json) {
+      process.stdout.write('Remosidian daemon is already running. Reusing it.\n\n');
+    }
+    await printPairingSummary(port, paths, existing, flags);
+    return;
   }
-  const payload = await openResp.json();
-  const uri = buildPairUri(payload);
+
+  const runtime = createRuntimePaths(paths);
+  const stalePid = readPidFile(runtime.pidPath);
+  if (stalePid && !remosidian_isProcessAlive(stalePid)) {
+    removePidFile(runtime.pidPath);
+  }
+
+  const pid = startDetachedDaemon(paths, flags);
+  const health = await waitForHealth(port);
+  if (!flags.json) {
+    process.stdout.write(`Started Remosidian daemon in the background (pid ${pid}).\n`);
+    process.stdout.write(`Logs: ${runtime.stdoutLogPath} / ${runtime.stderrLogPath}\n\n`);
+  }
+  await printPairingSummary(port, paths, health, flags);
+}
+
+async function cmdPair(flags, paths) {
+  const port = resolveRequestedPort(flags, paths);
+  const payload = await postJson(port, '/pair/open');
+  const pairingCode = buildPairCode(payload);
+  const deepLink = buildPairDeepLink(pairingCode);
   if (flags.json) {
-    process.stdout.write(`${JSON.stringify({ ok: true, payload, uri })}\n`);
+    process.stdout.write(`${JSON.stringify({ ok: true, payload, pairingCode, deepLink })}\n`);
     return;
   }
-  const qr = await renderQrTerminal(uri);
+  const qr = await renderQrTerminal(pairingCode);
   process.stdout.write(`${qr}\n`);
-  process.stdout.write(`${uri}\n`);
+  process.stdout.write(`${pairingCode}\n`);
+  process.stdout.write(`${deepLink}\n`);
   process.stdout.write(`Daemon       ${payload.daemonId} (${payload.displayName})\n`);
   process.stdout.write(`Expires      ${payload.expiresAt}\n`);
-  const qrPath = (0,external_node_path_namespaceObject.join)(paths.dataDir, 'pairing-qr.png');
-  await writeQrPng(uri, qrPath).catch(() => undefined);
-  process.stdout.write(`Saved QR     ${qrPath}\n`);
+  const runtime = createRuntimePaths(paths);
+  (0,external_node_fs_namespaceObject.writeFileSync)(runtime.pairingCodePath, `${pairingCode}\n`, 'utf8');
+  await writeQrPng(pairingCode, runtime.pairingQrPath).catch(() => undefined);
+  process.stdout.write(`Saved QR     ${runtime.pairingQrPath}\n`);
+  process.stdout.write(`Saved code   ${runtime.pairingCodePath}\n`);
 }
 
 async function cmdStatus(flags, paths) {
-  const port = Number(flags.port) || (loadConfigOrNull(paths)?.server?.port ?? 41234);
+  const port = resolveRequestedPort(flags, paths);
   try {
     const resp = await fetch(`http://127.0.0.1:${port}/health`);
     if (!resp.ok) {
@@ -28562,13 +28870,49 @@ async function cmdStatus(flags, paths) {
   }
 }
 
-async function cmdResetPairings(flags, paths) {
-  const port = Number(flags.port) || (loadConfigOrNull(paths)?.server?.port ?? 41234);
-  const resp = await fetch(`http://127.0.0.1:${port}/pair/reset`, { method: 'POST' });
-  if (!resp.ok) {
-    process.stderr.write(`[${PROG}] /pair/reset failed: ${resp.status} ${resp.statusText}\n`);
+async function waitForDaemonExit(port, timeoutMs = 5_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const health = await probeHealth(port, 0);
+    if (!health) {
+      return true;
+    }
+    await new Promise((resolveWait) => setTimeout(resolveWait, 200));
+  }
+  return false;
+}
+
+async function cmdStop(flags, paths) {
+  const port = resolveRequestedPort(flags, paths);
+  const runtime = createRuntimePaths(paths);
+  const pid = readPidFile(runtime.pidPath);
+  if (pid && remosidian_isProcessAlive(pid)) {
+    try {
+      process.kill(pid, 'SIGTERM');
+    } catch {
+      // Process may have exited between the liveness check and kill.
+    }
+    await waitForDaemonExit(port);
+    removePidFile(runtime.pidPath);
+    stopTunnel({ tunnelStatePath: (0,external_node_path_namespaceObject.join)(paths.dataDir, 'tunnel.json') });
+    process.stdout.write('Remosidian daemon stopped.\n');
+    return;
+  }
+  removePidFile(runtime.pidPath);
+  const health = await probeHealth(port, 500);
+  if (health) {
+    process.stderr.write(
+      `[${PROG}] daemon is responding on 127.0.0.1:${port}, but no background PID file exists. Stop the foreground terminal process that started it.\n`,
+    );
     process.exit(1);
   }
+  stopTunnel({ tunnelStatePath: (0,external_node_path_namespaceObject.join)(paths.dataDir, 'tunnel.json') });
+  process.stdout.write('Remosidian daemon is not running.\n');
+}
+
+async function cmdResetPairings(flags, paths) {
+  const port = resolveRequestedPort(flags, paths);
+  await postJson(port, '/pair/reset');
   process.stdout.write('All pairings revoked.\n');
 }
 
@@ -28642,12 +28986,18 @@ async function main() {
     case 'start':
       await cmdStart(parsed.flags, paths);
       return;
+    case 'serve':
+      await cmdServe(parsed.flags, paths);
+      return;
     case 'pair':
       await cmdPair(parsed.flags, paths);
       return;
     case 'status':
       await cmdStatus(parsed.flags, paths);
       return;
+    case 'stop':
+      await cmdStop(parsed.flags, paths);
+      return;
     case 'reset-pairings':
       await cmdResetPairings(parsed.flags, paths);
       return;
@@ -28660,8 +29010,9 @@ async function main() {
   }
 }
 
-const entryHref = process.argv[1] ? new URL(`file://${(0,external_node_path_namespaceObject.resolve)(process.argv[1])}`).href : '';
-if (import.meta.url === entryHref || import.meta.url === `file://${process.argv[1]}`) {
+const entryHref = resolveEntrypointHref(process.argv[1]);
+const moduleHref = resolveEntrypointHref((0,external_node_url_namespaceObject.fileURLToPath)(import.meta.url));
+if (entryHref && moduleHref === entryHref) {
   main().catch((error) => {
     process.stderr.write(`[${PROG}] ${error?.stack ?? error}\n`);
     process.exit(1);
@@ -28670,9 +29021,14 @@ if (import.meta.url === entryHref || import.meta.url === `file://${process.argv[
 
 
 
+var __webpack_exports__buildPairCode = __webpack_exports__.gu;
+var __webpack_exports__buildPairDeepLink = __webpack_exports__.ti;
 var __webpack_exports__buildPairUri = __webpack_exports__.lz;
+var __webpack_exports__buildServeArgs = __webpack_exports__.jO;
+var __webpack_exports__createCompactPairingPayload = __webpack_exports__.YP;
 var __webpack_exports__expandVaultSpec = __webpack_exports__.wX;
 var __webpack_exports__main = __webpack_exports__.iW;
 var __webpack_exports__parseArgs = __webpack_exports__.Zy;
+var __webpack_exports__resolveEntrypointHref = __webpack_exports__.Mf;
 var __webpack_exports__resolveInvocation = __webpack_exports__.t0;
-export { __webpack_exports__buildPairUri as buildPairUri, __webpack_exports__expandVaultSpec as expandVaultSpec, __webpack_exports__main as main, __webpack_exports__parseArgs as parseArgs, __webpack_exports__resolveInvocation as resolveInvocation };
+export { __webpack_exports__buildPairCode as buildPairCode, __webpack_exports__buildPairDeepLink as buildPairDeepLink, __webpack_exports__buildPairUri as buildPairUri, __webpack_exports__buildServeArgs as buildServeArgs, __webpack_exports__createCompactPairingPayload as createCompactPairingPayload, __webpack_exports__expandVaultSpec as expandVaultSpec, __webpack_exports__main as main, __webpack_exports__parseArgs as parseArgs, __webpack_exports__resolveEntrypointHref as resolveEntrypointHref, __webpack_exports__resolveInvocation as resolveInvocation };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remosidian",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Run Remosidian — remote, read/write access to your Obsidian vault from any device",
   "license": "MIT",
   "homepage": "https://lifeos.vip",