fss-link 1.5.7 → 1.6.0

package/scripts/quick-install.sh

@@ -0,0 +1,195 @@
+#!/bin/bash
+
+# FSS Link Quick Install Script
+# Universal installer that detects OS and runs appropriate installation
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+log_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Detect operating system
+detect_os() {
+    case "$(uname -s)" in
+        Darwin)
+            OS="macos"
+            ;;
+        Linux)
+            OS="linux"
+            ;;
+        CYGWIN*|MINGW32*|MSYS*|MINGW*)
+            OS="windows"
+            ;;
+        *)
+            log_error "Unsupported operating system: $(uname -s)"
+            exit 1
+            ;;
+    esac
+    
+    log_info "Detected OS: $OS"
+}
+
+# Download installation script
+download_installer() {
+    local script_name="install-${OS}.sh"
+    local script_url="https://raw.githubusercontent.com/FSSCoding/fss-link/main/scripts/${script_name}"
+    
+    log_info "Downloading $script_name..."
+    
+    if command -v curl &> /dev/null; then
+        curl -fsSL "$script_url" -o "$script_name"
+    elif command -v wget &> /dev/null; then
+        wget -q "$script_url" -O "$script_name"
+    else
+        log_error "Neither curl nor wget found. Please install one of them."
+        exit 1
+    fi
+    
+    if [ -f "$script_name" ]; then
+        chmod +x "$script_name"
+        log_success "Downloaded $script_name"
+        return 0
+    else
+        log_error "Failed to download $script_name"
+        return 1
+    fi
+}
+
+# Run the appropriate installer
+run_installer() {
+    local script_name="install-${OS}.sh"
+    
+    if [ "$OS" = "windows" ]; then
+        # For Windows, we need PowerShell
+        log_info "For Windows installation, please run:"
+        log_info "PowerShell -ExecutionPolicy Bypass -File install-windows.ps1"
+        return 0
+    fi
+    
+    log_info "Running $script_name..."
+    ./"$script_name" "$@"
+    
+    # Clean up
+    rm -f "$script_name"
+}
+
+# NPM fallback installation
+npm_install() {
+    log_info "Attempting direct NPM installation..."
+    
+    if command -v npm &> /dev/null; then
+        npm install -g fss-link
+        
+        if command -v fss-link &> /dev/null; then
+            log_success "FSS Link installed via NPM"
+            log_info "Run 'fss-link --help' to get started"
+            return 0
+        else
+            log_error "NPM installation succeeded but fss-link command not found"
+            return 1
+        fi
+    else
+        log_error "NPM not found. Please install Node.js 20+ first."
+        return 1
+    fi
+}
+
+# Main function
+main() {
+    echo "🚀 FSS Link Universal Quick Installer"
+    echo "====================================="
+    echo ""
+    
+    # Handle help flag
+    if [ "${1:-}" = "--help" ] || [ "${1:-}" = "-h" ]; then
+        cat << EOF
+FSS Link Universal Quick Installer
+
+Usage: $0 [options]
+
+Options:
+  --help, -h     Show this help message
+  --npm-only     Skip OS-specific installer, use NPM directly
+  --version, -v  Show script version
+
+This script will:
+1. Detect your operating system
+2. Download the appropriate installation script
+3. Run the OS-specific installer
+4. Verify the installation
+
+Supported Systems:
+  - Linux (Ubuntu, Debian, CentOS, Fedora, Arch, openSUSE)
+  - macOS (10.15+)
+  - Windows (10+)
+
+Requirements:
+  - Node.js 20.0.0 or higher
+  - Build tools for native dependencies
+  - Internet connection for downloading
+
+Examples:
+  curl -fsSL https://raw.githubusercontent.com/FSSCoding/fss-link/main/scripts/quick-install.sh | bash
+  bash quick-install.sh --npm-only
+EOF
+        exit 0
+    fi
+    
+    # Handle version flag
+    if [ "${1:-}" = "--version" ] || [ "${1:-}" = "-v" ]; then
+        echo "FSS Link Universal Quick Installer v1.0.0"
+        exit 0
+    fi
+    
+    # Handle NPM-only installation
+    if [ "${1:-}" = "--npm-only" ]; then
+        npm_install
+        exit $?
+    fi
+    
+    # Detect OS
+    detect_os
+    
+    # Try downloading and running OS-specific installer
+    if download_installer; then
+        run_installer "$@"
+    else
+        log_warning "OS-specific installer download failed, trying NPM installation..."
+        npm_install
+    fi
+    
+    # Final verification
+    if command -v fss-link &> /dev/null; then
+        VERSION=$(fss-link --version 2>/dev/null || echo "unknown")
+        log_success "🎉 FSS Link installation complete!"
+        log_info "Version: $VERSION"
+        log_info "Run 'fss-link --help' to get started"
+    else
+        log_error "Installation may have failed - fss-link command not found"
+        log_info "Try running: npm install -g fss-link"
+        exit 1
+    fi
+}
+
+# Run main function with all arguments
+main "$@"

package/scripts/sandbox_command.js

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import stripJsonComments from 'strip-json-comments';
+import os from 'os';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import dotenv from 'dotenv';
+
+const argv = yargs(hideBin(process.argv)).option('q', {
+  alias: 'quiet',
+  type: 'boolean',
+  default: false,
+}).argv;
+
+let fssLinkSandbox = process.env.FSS_LINK_SANDBOX;
+
+if (!fssLinkSandbox) {
+  const userSettingsFile = join(os.homedir(), '.fss-link', 'settings.json');
+  if (existsSync(userSettingsFile)) {
+    const settings = JSON.parse(
+      stripJsonComments(readFileSync(userSettingsFile, 'utf-8')),
+    );
+    if (settings.sandbox) {
+      fssLinkSandbox = settings.sandbox;
+    }
+  }
+}
+
+if (!fssLinkSandbox) {
+  let currentDir = process.cwd();
+  while (true) {
+    const fssLinkEnv = join(currentDir, '.fss-link', '.env');
+    const regularEnv = join(currentDir, '.env');
+    if (existsSync(fssLinkEnv)) {
+      dotenv.config({ path: fssLinkEnv, quiet: true });
+      break;
+    } else if (existsSync(regularEnv)) {
+      dotenv.config({ path: regularEnv, quiet: true });
+      break;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  fssLinkSandbox = process.env.FSS_LINK_SANDBOX;
+}
+
+fssLinkSandbox = (fssLinkSandbox || '').toLowerCase();
+
+const commandExists = (cmd) => {
+  const checkCommand = os.platform() === 'win32' ? 'where' : 'command -v';
+  try {
+    execSync(`${checkCommand} ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    if (os.platform() === 'win32') {
+      try {
+        execSync(`${checkCommand} ${cmd}.exe`, { stdio: 'ignore' });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+};
+
+let command = '';
+if (['1', 'true'].includes(fssLinkSandbox)) {
+  if (commandExists('docker')) {
+    command = 'docker';
+  } else if (commandExists('podman')) {
+    command = 'podman';
+  } else {
+    console.error(
+      'ERROR: install docker or podman or specify command in FSS_LINK_SANDBOX',
+    );
+    process.exit(1);
+  }
+} else if (fssLinkSandbox && !['0', 'false'].includes(fssLinkSandbox)) {
+  if (commandExists(fssLinkSandbox)) {
+    command = fssLinkSandbox;
+  } else {
+    console.error(
+      `ERROR: missing sandbox command '${fssLinkSandbox}' (from FSS_LINK_SANDBOX)`,
+    );
+    process.exit(1);
+  }
+} else {
+  if (os.platform() === 'darwin' && process.env.SEATBELT_PROFILE !== 'none') {
+    if (commandExists('sandbox-exec')) {
+      command = 'sandbox-exec';
+    } else {
+      process.exit(1);
+    }
+  } else {
+    process.exit(1);
+  }
+}
+
+if (!argv.q) {
+  console.log(command);
+}
+process.exit(0);

package/scripts/start.js

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law_or_agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { spawn, execSync } from 'child_process';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8'));
+
+// check build status, write warnings to file for app to display if needed
+execSync('node ./scripts/check-build-status.js', {
+  stdio: 'inherit',
+  cwd: root,
+});
+
+const nodeArgs = [];
+let sandboxCommand = undefined;
+try {
+  sandboxCommand = execSync('node scripts/sandbox_command.js', {
+    cwd: root,
+  })
+    .toString()
+    .trim();
+} catch {
+  // ignore
+}
+// if debugging is enabled and sandboxing is disabled, use --inspect-brk flag
+// note with sandboxing this flag is passed to the binary inside the sandbox
+// inside sandbox SANDBOX should be set and sandbox_command.js should fail
+if (process.env.DEBUG && !sandboxCommand) {
+  if (process.env.SANDBOX) {
+    const port = process.env.DEBUG_PORT || '9229';
+    nodeArgs.push(`--inspect-brk=0.0.0.0:${port}`);
+  } else {
+    nodeArgs.push('--inspect-brk');
+  }
+}
+
+nodeArgs.push(join(root, 'packages', 'cli'));
+nodeArgs.push(...process.argv.slice(2));
+
+const env = {
+  ...process.env,
+  CLI_VERSION: pkg.version,
+  DEV: 'true',
+};
+
+if (process.env.DEBUG) {
+  // If this is not set, the debugger will pause on the outer process rather
+  // than the relaunched process making it harder to debug.
+  env.GEMINI_CLI_NO_RELAUNCH = 'true';
+}
+const child = spawn('node', nodeArgs, { stdio: 'inherit', env });
+
+child.on('close', (code) => {
+  process.exit(code);
+});

package/scripts/telemetry.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+
+const projectRoot = join(import.meta.dirname, '..');
+
+const SETTINGS_DIRECTORY_NAME = '.fss-link';
+const USER_SETTINGS_DIR = join(
+  process.env.HOME || process.env.USERPROFILE || process.env.HOMEPATH || '',
+  SETTINGS_DIRECTORY_NAME,
+);
+const USER_SETTINGS_PATH = join(USER_SETTINGS_DIR, 'settings.json');
+const WORKSPACE_SETTINGS_PATH = join(
+  projectRoot,
+  SETTINGS_DIRECTORY_NAME,
+  'settings.json',
+);
+
+let settingsTarget = undefined;
+
+function loadSettingsValue(filePath) {
+  try {
+    if (existsSync(filePath)) {
+      const content = readFileSync(filePath, 'utf-8');
+      const jsonContent = content.replace(/\/\/[^\n]*/g, '');
+      const settings = JSON.parse(jsonContent);
+      return settings.telemetry?.target;
+    }
+  } catch (e) {
+    console.warn(
+      `⚠️ Warning: Could not parse settings file at ${filePath}: ${e.message}`,
+    );
+  }
+  return undefined;
+}
+
+settingsTarget = loadSettingsValue(WORKSPACE_SETTINGS_PATH);
+
+if (!settingsTarget) {
+  settingsTarget = loadSettingsValue(USER_SETTINGS_PATH);
+}
+
+let target = settingsTarget || 'local';
+const allowedTargets = ['local', 'gcp'];
+
+const targetArg = process.argv.find((arg) => arg.startsWith('--target='));
+if (targetArg) {
+  const potentialTarget = targetArg.split('=')[1];
+  if (allowedTargets.includes(potentialTarget)) {
+    target = potentialTarget;
+    console.log(`⚙️  Using command-line target: ${target}`);
+  } else {
+    console.error(
+      `🛑 Error: Invalid target '${potentialTarget}'. Allowed targets are: ${allowedTargets.join(', ')}.`,
+    );
+    process.exit(1);
+  }
+} else if (settingsTarget) {
+  console.log(
+    `⚙️ Using telemetry target from settings.json: ${settingsTarget}`,
+  );
+}
+
+const scriptPath = join(
+  projectRoot,
+  'scripts',
+  target === 'gcp' ? 'telemetry_gcp.js' : 'local_telemetry.js',
+);
+
+try {
+  console.log(`🚀 Running telemetry script for target: ${target}.`);
+  execSync(`node ${scriptPath}`, { stdio: 'inherit', cwd: projectRoot });
+} catch (error) {
+  console.error(`🛑 Failed to run telemetry script for target: ${target}`);
+  console.error(error);
+  process.exit(1);
+}

package/scripts/telemetry_gcp.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { spawn, execSync } from 'child_process';
+import {
+  OTEL_DIR,
+  BIN_DIR,
+  fileExists,
+  waitForPort,
+  ensureBinary,
+  manageTelemetrySettings,
+  registerCleanup,
+} from './telemetry_utils.js';
+
+const OTEL_CONFIG_FILE = path.join(OTEL_DIR, 'collector-gcp.yaml');
+const OTEL_LOG_FILE = path.join(OTEL_DIR, 'collector-gcp.log');
+
+const getOtelConfigContent = (projectId) => `
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: "localhost:4317"
+processors:
+  batch:
+    timeout: 1s
+exporters:
+  googlecloud:
+    project: "${projectId}"
+    metric:
+      prefix: "custom.googleapis.com/gemini_cli"
+    log:
+      default_log_name: "gemini_cli"
+  debug:
+    verbosity: detailed
+service:
+  telemetry:
+    logs:
+      level: "debug"
+    metrics:
+      level: "none"
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [googlecloud]
+    metrics:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [googlecloud, debug]
+    logs:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [googlecloud, debug]
+`;
+
+async function main() {
+  console.log('✨ Starting Local Telemetry Exporter for Google Cloud ✨');
+
+  let collectorProcess;
+  let collectorLogFd;
+
+  const originalSandboxSetting = manageTelemetrySettings(
+    true,
+    'http://localhost:4317',
+    'gcp',
+  );
+  registerCleanup(
+    () => [collectorProcess].filter((p) => p), // Function to get processes
+    () => [collectorLogFd].filter((fd) => fd), // Function to get FDs
+    originalSandboxSetting,
+  );
+
+  const projectId = process.env.OTLP_GOOGLE_CLOUD_PROJECT;
+  if (!projectId) {
+    console.error(
+      '🛑 Error: OTLP_GOOGLE_CLOUD_PROJECT environment variable is not exported.',
+    );
+    console.log(
+      '   Please set it to your Google Cloud Project ID and try again.',
+    );
+    console.log('   `export OTLP_GOOGLE_CLOUD_PROJECT=your-project-id`');
+    process.exit(1);
+  }
+  console.log(`✅ Using OTLP Google Cloud Project ID: ${projectId}`);
+
+  console.log('\n🔑 Please ensure you are authenticated with Google Cloud:');
+  console.log(
+    '  - Run `gcloud auth application-default login` OR ensure `GOOGLE_APPLICATION_CREDENTIALS` environment variable points to a valid service account key.',
+  );
+  console.log(
+    '  - The account needs "Cloud Trace Agent", "Monitoring Metric Writer", and "Logs Writer" roles.',
+  );
+
+  if (!fileExists(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+
+  const otelcolPath = await ensureBinary(
+    'otelcol-contrib',
+    'open-telemetry/opentelemetry-collector-releases',
+    (version, platform, arch, ext) =>
+      `otelcol-contrib_${version}_${platform}_${arch}.${ext}`,
+    'otelcol-contrib',
+    false, // isJaeger = false
+  ).catch((e) => {
+    console.error(`🛑 Error getting otelcol-contrib: ${e.message}`);
+    return null;
+  });
+  if (!otelcolPath) process.exit(1);
+
+  console.log('🧹 Cleaning up old processes and logs...');
+  try {
+    execSync('pkill -f "otelcol-contrib"');
+    console.log('✅ Stopped existing otelcol-contrib process.');
+  } catch (_e) {
+    /* no-op */
+  }
+  try {
+    fs.unlinkSync(OTEL_LOG_FILE);
+    console.log('✅ Deleted old GCP collector log.');
+  } catch (e) {
+    if (e.code !== 'ENOENT') console.error(e);
+  }
+
+  if (!fileExists(OTEL_DIR)) fs.mkdirSync(OTEL_DIR, { recursive: true });
+  fs.writeFileSync(OTEL_CONFIG_FILE, getOtelConfigContent(projectId));
+  console.log(`📄 Wrote OTEL collector config to ${OTEL_CONFIG_FILE}`);
+
+  console.log(`🚀 Starting OTEL collector for GCP... Logs: ${OTEL_LOG_FILE}`);
+  collectorLogFd = fs.openSync(OTEL_LOG_FILE, 'a');
+  collectorProcess = spawn(otelcolPath, ['--config', OTEL_CONFIG_FILE], {
+    stdio: ['ignore', collectorLogFd, collectorLogFd],
+    env: { ...process.env },
+  });
+
+  console.log(
+    `⏳ Waiting for OTEL collector to start (PID: ${collectorProcess.pid})...`,
+  );
+
+  try {
+    await waitForPort(4317);
+    console.log(`✅ OTEL collector started successfully on port 4317.`);
+  } catch (err) {
+    console.error(`🛑 Error: OTEL collector failed to start on port 4317.`);
+    console.error(err.message);
+    if (collectorProcess && collectorProcess.pid) {
+      process.kill(collectorProcess.pid, 'SIGKILL');
+    }
+    if (fileExists(OTEL_LOG_FILE)) {
+      console.error('📄 OTEL Collector Log Output:');
+      console.error(fs.readFileSync(OTEL_LOG_FILE, 'utf-8'));
+    }
+    process.exit(1);
+  }
+
+  collectorProcess.on('error', (err) => {
+    console.error(`${collectorProcess.spawnargs[0]} process error:`, err);
+    process.exit(1);
+  });
+
+  console.log(`\n✨ Local OTEL collector for GCP is running.`);
+  console.log(
+    '\n🚀 To send telemetry, run the Gemini CLI in a separate terminal window.',
+  );
+  console.log(`\n📄 Collector logs are being written to: ${OTEL_LOG_FILE}`);
+  console.log(
+    `📄 Tail collector logs in another terminal: tail -f ${OTEL_LOG_FILE}`,
+  );
+  console.log(`\n📊 View your telemetry data in Google Cloud Console:`);
+  console.log(
+    `   - Logs: https://console.cloud.google.com/logs/query;query=logName%3D%22projects%2F${projectId}%2Flogs%2Fgemini_cli%22?project=${projectId}`,
+  );
+  console.log(
+    `   - Metrics: https://console.cloud.google.com/monitoring/metrics-explorer?project=${projectId}`,
+  );
+  console.log(
+    `   - Traces: https://console.cloud.google.com/traces/list?project=${projectId}`,
+  );
+  console.log(`\nPress Ctrl+C to exit.`);
+}
+
+main();