vibelet 0.1.38 → 1.0.1

package/README.md

@@ -0,0 +1,80 @@
+# Vibelet
+
+`@vibelet/cli` is a cross-platform CLI that installs and manages the Vibelet daemon for remote coding sessions. The same package is also published as `vibelet`.
+
+Official website: https://vibelet.icu
+
+## Requirements
+
+- macOS / Linux / Windows
+- Node.js 18 or newer
+
+## Install
+
+```bash
+npx @vibelet/cli
+npx vibelet
+```
+
+Or install it globally:
+
+```bash
+npm install -g @vibelet/cli
+npm install -g vibelet
+vibelet
+```
+
+The CLI prints the official website on each run so users can always jump back to the main docs and download page.
+
+## Commands
+
+```bash
+vibelet              # Install/start daemon, auto-enable remote access, and print pairing QR code
+vibelet start        # Same as above
+vibelet stop         # Stop the daemon
+vibelet restart      # Restart the daemon
+vibelet status       # Show service and daemon status
+vibelet logs         # Print recent daemon logs
+vibelet reset        # Reset pairings and print a fresh QR code
+vibelet --help       # Show help
+vibelet --version    # Show CLI version
+```
+
+## Options
+
+```bash
+vibelet --local                      # Skip the default Cloudflare Tunnel for this run
+vibelet --remote --force             # Force a fresh tunnel URL
+vibelet --relay <url>                  # Use a tunnel URL for remote access
+vibelet --relay ""                     # Clear saved relay URL
+vibelet --host <ip>                    # Set primary host/IP advertised for connections
+vibelet --fallback-hosts <ip1>,<ip2>   # Comma-separated fallback IPs
+```
+
+Remote access is enabled by default for `vibelet`, `vibelet start`, `vibelet restart`, and `vibelet reset`. Use `--local` when you want a LAN-only QR code for that run.
+
+## Release
+
+```bash
+pnpm publish:dual:dry-run
+pnpm publish:dual
+```
+
+The dual publish script builds once, then publishes the same CLI bundle to both `@vibelet/cli` and `vibelet`. The dry-run path stages both packages and validates them with `npm pack --dry-run` without touching the registry.
+
+## Notes
+
+- The npm package publishes the CLI plus a minified daemon runtime bundle.
+- The package is intended for end users of the macOS host daemon, not for importing as a library.
+- The daemon keeps `~/.vibelet/data/audit.jsonl` and `~/.vibelet/logs/daemon.*.log` size-bounded by trimming the oldest content in place.
+- Environment variables:
+  | Variable | Default | Description |
+  |----------|---------|-------------|
+  | `VIBE_PORT` | `9876` | Daemon listen port |
+  | `VIBE_IDLE_TIMEOUT_MS` | `1800000` (30 min) | Idle timeout before a driver is released (0 = disabled) |
+  | `VIBE_TURN_STALL_TIMEOUT_MS` | `300000` (5 min) | Max inactivity for an in-flight turn (0 = disabled) |
+  | `VIBE_AUDIT_MAX_BYTES` | `8388608` (8 MB) | Max audit.jsonl size before trimming |
+  | `VIBE_DAEMON_LOG_MAX_BYTES` | `16777216` (16 MB) | Max daemon log file size before trimming |
+  | `VIBE_STORAGE_HOUSEKEEPING_INTERVAL_MS` | `300000` (5 min) | Log trimming check interval |
+  | `CLAUDE_PATH` | auto-detect | Path to Claude binary |
+  | `CODEX_PATH` | auto-detect | Path to Codex binary |

package/bin/cloudflared-quick-tunnel.mjs

@@ -0,0 +1,11 @@
+const QUICK_TUNNEL_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com(?=$|[\s"',)\]])/g;
+
+export function extractQuickTunnelUrl(logContent) {
+  if (typeof logContent !== 'string' || logContent.length === 0) {
+    return null;
+  }
+
+  const match = QUICK_TUNNEL_URL_PATTERN.exec(logContent);
+  QUICK_TUNNEL_URL_PATTERN.lastIndex = 0;
+  return match?.[0] ?? null;
+}

package/bin/cloudflared-resolver.mjs

@@ -0,0 +1,171 @@
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'node:fs';
+import { delimiter, dirname, isAbsolute, join, resolve } from 'node:path';
+
+const npmFallbackCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+const npmFallbackArgs = ['--yes', '--package=cloudflared', 'cloudflared'];
+const npmFallbackDescription = `npx ${npmFallbackArgs.join(' ')}`;
+const require = createRequire(import.meta.url);
+
+function defaultResolveCloudflaredPackageJsonPath() {
+  if (process.env.VIBELET_CLOUDFLARED_PACKAGE_JSON) {
+    return process.env.VIBELET_CLOUDFLARED_PACKAGE_JSON;
+  }
+  return require.resolve('cloudflared/package.json');
+}
+
+function getExecutableCandidates(name, pathExtValue = process.env.PATHEXT ?? '') {
+  if (process.platform !== 'win32') {
+    return [name];
+  }
+
+  const extensions = pathExtValue
+    .split(';')
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => (entry.startsWith('.') ? entry : `.${entry}`))
+    .map((entry) => entry.toLowerCase());
+
+  return [name, ...extensions.map((entry) => `${name}${entry}`)];
+}
+
+export function findExecutableInPath(name, {
+  pathValue = process.env.PATH ?? '',
+  pathExtValue = process.env.PATHEXT ?? '',
+} = {}) {
+  if (!pathValue) return null;
+
+  for (const dir of pathValue.split(delimiter)) {
+    if (!dir) continue;
+    for (const candidate of getExecutableCandidates(name, pathExtValue)) {
+      const candidatePath = join(dir, candidate);
+      if (existsSync(candidatePath)) {
+        return candidatePath;
+      }
+    }
+  }
+
+  return null;
+}
+
+export function resolveInstalledCloudflaredCliPath({
+  resolvePackageJsonPath = defaultResolveCloudflaredPackageJsonPath,
+} = {}) {
+  let packageJsonPath;
+  try {
+    packageJsonPath = resolvePackageJsonPath();
+  } catch {
+    return null;
+  }
+
+  let packageJson;
+  try {
+    packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  } catch {
+    return null;
+  }
+
+  const relativeBinPath = typeof packageJson.bin === 'string'
+    ? packageJson.bin
+    : packageJson.bin?.cloudflared;
+
+  if (typeof relativeBinPath !== 'string' || !relativeBinPath) {
+    return null;
+  }
+
+  const cliPath = isAbsolute(relativeBinPath)
+    ? relativeBinPath
+    : resolve(dirname(packageJsonPath), relativeBinPath);
+
+  return existsSync(cliPath) ? cliPath : null;
+}
+
+export function resolveCloudflaredLaunchSpec({
+  pathValue = process.env.PATH ?? '',
+  pathExtValue = process.env.PATHEXT ?? '',
+  resolvePackageJsonPath,
+} = {}) {
+  const directPath = findExecutableInPath('cloudflared', { pathValue, pathExtValue });
+  if (directPath) {
+    return {
+      command: directPath,
+      args: [],
+      source: 'path',
+      description: directPath,
+      urlTimeoutMs: 30_000,
+    };
+  }
+
+  const dependencyCliPath = resolveInstalledCloudflaredCliPath({ resolvePackageJsonPath });
+  if (dependencyCliPath) {
+    return {
+      command: process.execPath,
+      args: [dependencyCliPath],
+      source: 'dependency',
+      description: dependencyCliPath,
+      urlTimeoutMs: 90_000,
+    };
+  }
+
+  return {
+    command: npmFallbackCommand,
+    args: [...npmFallbackArgs],
+    source: 'npm',
+    description: npmFallbackDescription,
+    urlTimeoutMs: 90_000,
+  };
+}
+
+export function summarizeCloudflaredLog(logContent, {
+  maxLines = 8,
+  maxChars = 1200,
+} = {}) {
+  const lines = logContent
+    .split(/\r?\n/u)
+    .map((line) => line.trimEnd())
+    .filter(Boolean);
+
+  if (lines.length === 0) {
+    return '';
+  }
+
+  const tail = lines.slice(-maxLines).join('\n');
+  if (tail.length <= maxChars) {
+    return tail;
+  }
+
+  return tail.slice(tail.length - maxChars);
+}
+
+export function formatCloudflaredFailureMessage({
+  launchSpec,
+  logContent = '',
+  logPath,
+  err = null,
+  phase = 'exit',
+}) {
+  const launchSuffix = launchSpec?.source === 'npm'
+    ? ' via npm fallback (npx --yes --package=cloudflared cloudflared)'
+    : launchSpec?.source === 'dependency'
+      ? ' via bundled cloudflared dependency'
+      : '';
+
+  if (phase === 'spawn') {
+    return `Failed to start cloudflared${launchSuffix}: ${err?.message ?? 'unknown error'}`;
+  }
+
+  if (phase === 'timeout') {
+    const summary = summarizeCloudflaredLog(logContent);
+    if (summary) {
+      return `Timed out waiting for tunnel URL (${Math.round((launchSpec?.urlTimeoutMs ?? 30_000) / 1000)}s)${launchSuffix}.\nRecent stderr:\n${summary}`;
+    }
+    return `Timed out waiting for tunnel URL (${Math.round((launchSpec?.urlTimeoutMs ?? 30_000) / 1000)}s)${launchSuffix}. Check network/proxy settings and ${logPath}.`;
+  }
+
+  const summary = summarizeCloudflaredLog(logContent);
+  if (summary) {
+    return `cloudflared exited before producing a tunnel URL${launchSuffix}.\nRecent stderr:\n${summary}`;
+  }
+
+  return `cloudflared exited before producing a tunnel URL${launchSuffix}. Check ${logPath}.`;
+}

package/bin/vibelet-runtime-policy.mjs

@@ -0,0 +1,36 @@
+export function shouldReuseHealthyDaemon({
+  command,
+  daemonHealthy,
+  hasExplicitConfigOverrides,
+}) {
+  if (!daemonHealthy) return false;
+  if (command !== 'default' && command !== 'start') return false;
+  return !hasExplicitConfigOverrides;
+}
+
+export function doesHealthMatchRequestedConnectionConfig({
+  health,
+  relayUrl = '',
+  canonicalHost = '',
+  fallbackHosts = '',
+  localMode = false,
+}) {
+  if (!health) return false;
+
+  const currentRelayUrl = typeof health.relayUrl === 'string' ? health.relayUrl : '';
+  if (relayUrl) {
+    return currentRelayUrl === relayUrl;
+  }
+
+  if (localMode) {
+    return currentRelayUrl === '';
+  }
+
+  if (canonicalHost) {
+    if (fallbackHosts) return false;
+    return currentRelayUrl === '' && health.canonicalHost === canonicalHost;
+  }
+
+  if (fallbackHosts) return false;
+  return currentRelayUrl === '';
+}

package/bin/vibelet.cjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+const { realpathSync } = require('node:fs');
+const { dirname, join } = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+const entryPath = join(dirname(realpathSync(__filename)), 'vibelet.mjs');
+
+import(pathToFileURL(entryPath).href).catch((error) => {
+  console.error(error);
+  process.exit(1);
+});