natureco-cli 5.9.7 → 5.12.0

package/src/tools/file_state.js

@@ -0,0 +1,73 @@
+const fs = require('fs');
+const crypto = require('crypto');
+
+const FILE_STATES = new Map();
+
+function hashFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash('sha256').update(content).digest('hex');
+  } catch { return null; }
+}
+
+async function fileState(params) {
+  const { action, file, path: filePath } = params;
+  const targetFile = file || filePath;
+  if (!targetFile) return { success: false, error: 'file gerekli' };
+
+  if (action === 'track') {
+    if (!fs.existsSync(targetFile)) return { success: false, error: 'Dosya bulunamadi: ' + targetFile };
+    const hash = hashFile(targetFile);
+    FILE_STATES.set(targetFile, { hash, mtime: fs.statSync(targetFile).mtimeMs, trackedAt: Date.now() });
+    return { success: true, file: targetFile, hash, status: 'tracking' };
+  }
+
+  if (action === 'check') {
+    if (!FILE_STATES.has(targetFile)) return { success: false, error: 'Dosya takip edilmiyor. Once track kullanin.' };
+    const prev = FILE_STATES.get(targetFile);
+    if (!fs.existsSync(targetFile)) return { success: true, file: targetFile, status: 'deleted', previous: prev };
+    const current = { hash: hashFile(targetFile), mtime: fs.statSync(targetFile).mtimeMs };
+    const changed = current.hash !== prev.hash;
+    FILE_STATES.set(targetFile, { ...current, trackedAt: prev.trackedAt });
+    return { success: true, file: targetFile, changed, status: changed ? 'modified' : 'unchanged', previous: prev.hash, current: current.hash };
+  }
+
+  if (action === 'list') {
+    const entries = [];
+    for (const [f, state] of FILE_STATES) {
+      const exists = fs.existsSync(f);
+      entries.push({ file: f, trackedAt: new Date(state.trackedAt).toISOString(), exists, hash: exists ? hashFile(f) : null });
+    }
+    return { success: true, tracked: entries };
+  }
+
+  if (action === 'untrack') {
+    FILE_STATES.delete(targetFile);
+    return { success: true, message: targetFile + ' takipten cikarildi' };
+  }
+
+  if (action === 'diff') {
+    if (!FILE_STATES.has(targetFile)) return { success: false, error: 'Dosya takip edilmiyor' };
+    if (!fs.existsSync(targetFile)) return { success: false, error: 'Dosya bulunamadi' };
+    const prev = FILE_STATES.get(targetFile);
+    const current = hashFile(targetFile);
+    return { success: true, file: targetFile, changed: current !== prev.hash, oldHash: prev.hash, newHash: current };
+  }
+
+  return { success: false, error: 'Gecersiz action: ' + action };
+}
+
+module.exports = {
+  name: 'file_state',
+  description: 'Dosya degisiklik takibi: track/check/list/untrack/diff. Hash bazli degisim tespiti.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'track, check, list, untrack, diff', enum: ['track', 'check', 'list', 'untrack', 'diff'] },
+      file: { type: 'string', description: 'Dosya yolu' },
+      path: { type: 'string', description: 'Alternatif dosya yolu (file ile ayni)' },
+    },
+    required: ['action'],
+  },
+  async execute(params) { return await fileState(params); },
+};

package/src/tools/google_meet.js

@@ -0,0 +1,71 @@
+const { execSync } = require('child_process');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const IS_MAC = os.platform() === 'darwin';
+
+async function googleMeet(params) {
+  const { action, meetingUrl, title, durationMinutes, email } = params;
+
+  if (action === 'create') {
+    if (!IS_MAC) return { success: false, error: 'Google Meet olusturma su an sadece macOS\'ta destekleniyor (Calendar entegrasyonu ile)' };
+    try {
+      const script = `
+        tell application "Calendar"
+          set newEvent to make new event at end of calendar 1 with properties {summary:"${(title || 'NatureCo Meet').replace(/"/g, '\\"')}", start date:(current date), end date:((current date) + ${(durationMinutes || 30) * 60})}
+          set URL of newEvent to "https://meet.google.com/new"
+          return "https://meet.google.com/new"
+        end tell
+      `;
+      const result = execSync('osascript -e \'' + script.replace(/'/g, "'\\''") + '\'', { timeout: 10000 }).toString().trim();
+      return { success: true, meetingUrl: result, title: title || 'NatureCo Meet', message: 'Toplanti olusturuldu. URL: ' + result };
+    } catch (e) {
+      return { success: false, error: 'Calendar ile meet olusturulamadi: ' + e.message };
+    }
+  }
+
+  if (action === 'open') {
+    if (!meetingUrl) return { success: false, error: 'meetingUrl gerekli' };
+    try {
+      if (IS_MAC) {
+        execSync('open "' + meetingUrl + '"', { timeout: 5000 });
+      } else if (os.platform() === 'win32') {
+        execSync('start "" "' + meetingUrl + '"', { timeout: 5000 });
+      } else {
+        execSync('xdg-open "' + meetingUrl + '"', { timeout: 5000 });
+      }
+      return { success: true, meetingUrl, message: 'Meet acildi: ' + meetingUrl };
+    } catch (e) {
+      return { success: false, error: 'Meet acilamadi: ' + e.message };
+    }
+  }
+
+  if (action === 'info') {
+    return {
+      success: true,
+      note: 'Google Meet bot ozelligi icin Chrome Extension veya Puppeteer/Playwright ile otomasyon gerekli. Su an: create (Calendar) ve open (browser) destekleniyor.',
+      supportedActions: ['create', 'open'],
+      requirements: 'create: macOS + Calendar izni. open: her platform.',
+    };
+  }
+
+  return { success: false, error: 'Gecersiz action: ' + action + ' (create, open, info)' };
+}
+
+module.exports = {
+  name: 'google_meet',
+  description: 'Google Meet toplantisi: create (Calendar ile), open (browser ile), info.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'create, open, info', enum: ['create', 'open', 'info'] },
+      meetingUrl: { type: 'string', description: '(open) Meet URL' },
+      title: { type: 'string', description: '(create) Toplanti basligi' },
+      durationMinutes: { type: 'number', description: '(create) Sure (dakika, default: 30)' },
+      email: { type: 'string', description: 'Davet edilecek email' },
+    },
+    required: ['action'],
+  },
+  async execute(params) { return await googleMeet(params); },
+};

package/src/tools/homeassistant.js

@@ -0,0 +1,84 @@
+const https = require('https');
+
+async function homeassistant(params) {
+  const { action, entityId, domain, service, data, state, attributes } = params;
+
+  const baseUrl = process.env.HASS_URL || process.env.HOME_ASSISTANT_URL;
+  const token = process.env.HASS_TOKEN || process.env.HOME_ASSISTANT_TOKEN;
+
+  if (!baseUrl || !token) {
+    return { success: false, error: 'HASS_URL ve HASS_TOKEN ortam degiskenleri gerekli (orn: http://homeassistant.local:8123)' };
+  }
+
+  const apiUrl = baseUrl.replace(/\/+$/, '') + '/api';
+
+  function hassApi(method, path, body) {
+    return new Promise((resolve) => {
+      const url = apiUrl + path;
+      const opts = { method, headers: { 'Authorization': 'Bearer ' + token, 'Content-Type': 'application/json' }, timeout: 10000 };
+      const req = https.request(url, opts, (res) => {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, data: JSON.parse(data) }); } catch { resolve({ status: res.statusCode, data }); }
+        });
+      });
+      req.on('error', (e) => resolve({ status: 0, error: e.message }));
+      if (body) req.write(JSON.stringify(body));
+      req.end();
+    });
+  }
+
+  if (action === 'get_states') {
+    const res = await hassApi('GET', '/states');
+    if (res.status !== 200) return { success: false, error: 'Home Assistant API: ' + (res.data?.message || res.status) };
+    const entities = (Array.isArray(res.data) ? res.data : []).map(e => ({
+      entityId: e.entity_id, state: e.state,
+      friendlyName: e.attributes?.friendly_name,
+      lastChanged: e.last_changed,
+    }));
+    return { success: true, count: entities.length, entities };
+  }
+
+  if (action === 'get_state') {
+    if (!entityId) return { success: false, error: 'entityId gerekli' };
+    const res = await hassApi('GET', '/states/' + entityId);
+    if (res.status !== 200) return { success: false, error: 'Entity bulunamadi: ' + entityId };
+    return { success: true, entityId, state: res.data.state, attributes: res.data.attributes, lastChanged: res.data.last_changed };
+  }
+
+  if (action === 'call_service') {
+    if (!domain || !service) return { success: false, error: 'domain ve service gerekli' };
+    const res = await hassApi('POST', '/services/' + domain + '/' + service, data || {});
+    return { success: res.status === 200, domain, service, status: res.status, result: res.data, entityId };
+  }
+
+  if (action === 'set_state') {
+    if (!entityId) return { success: false, error: 'entityId gerekli' };
+    const body = { state: state || 'on' };
+    if (attributes) body.attributes = attributes;
+    const res = await hassApi('POST', '/states/' + entityId, body);
+    return { success: res.status === 200, entityId, state: res.data?.state, attributes: res.data?.attributes };
+  }
+
+  return { success: false, error: 'Gecersiz action: ' + action + ' (get_states, get_state, call_service, set_state)' };
+}
+
+module.exports = {
+  name: 'homeassistant',
+  description: 'Home Assistant akilli ev kontrolu: get_states/get_state/call_service/set_state. HASS_URL ve HASS_TOKEN ortam degiskenleri gerekli.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'get_states, get_state, call_service, set_state', enum: ['get_states', 'get_state', 'call_service', 'set_state'] },
+      entityId: { type: 'string', description: 'Entity ID (orn: light.living_room)' },
+      domain: { type: 'string', description: '(call_service) Domain (orn: light, switch, climate)' },
+      service: { type: 'string', description: '(call_service) Service (orn: turn_on, turn_off)' },
+      data: { type: 'object', description: '(call_service) Servis verisi' },
+      state: { type: 'string', description: '(set_state) Yeni state' },
+      attributes: { type: 'object', description: '(set_state) Opsiyonel attribute' },
+    },
+    required: ['action'],
+  },
+  async execute(params) { return await homeassistant(params); },
+};

package/src/tools/microsoft_graph.js

@@ -0,0 +1,103 @@
+const https = require('https');
+
+async function microsoftGraph(params) {
+  const { action, endpoint, method, body, userId, messageId, eventId, fileId, query } = params;
+
+  const accessToken = process.env.MS_GRAPH_TOKEN || process.env.MICROSOFT_GRAPH_TOKEN;
+
+  if (!accessToken) {
+    return { success: false, error: 'MS_GRAPH_TOKEN ortam degiskeni gerekli. (az login + erisim tokeni alinmalidir)' };
+  }
+
+  function graphApi(method, path, body) {
+    return new Promise((resolve) => {
+      const url = 'https://graph.microsoft.com/v1.0' + path;
+      const opts = { method, headers: { 'Authorization': 'Bearer ' + accessToken, 'Content-Type': 'application/json' }, timeout: 15000 };
+      const req = https.request(url, opts, (res) => {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, data: JSON.parse(data) }); } catch { resolve({ status: res.statusCode, data }); }
+        });
+      });
+      req.on('error', (e) => resolve({ status: 0, error: e.message }));
+      req.on('timeout', () => { req.destroy(); resolve({ status: 0, error: 'Timeout' }); });
+      if (body) req.write(JSON.stringify(body));
+      req.end();
+    });
+  }
+
+  if (action === 'send_email') {
+    if (!params.to || !params.subject || !params.body) {
+      return { success: false, error: 'to, subject, body gerekli' };
+    }
+    const emailBody = {
+      message: {
+        subject: params.subject,
+        body: { contentType: 'Text', content: params.body },
+        toRecipients: [{ emailAddress: { address: params.to } }],
+      },
+    };
+    if (params.cc) emailBody.message.ccRecipients = [{ emailAddress: { address: params.cc } }];
+    const res = await graphApi('POST', '/me/sendMail', emailBody);
+    return { success: res.status === 202, message: 'Email gonderildi: ' + params.to, status: res.status, error: res.data?.error?.message };
+  }
+
+  if (action === 'list_emails') {
+    const top = params.top || 10;
+    const res = await graphApi('GET', `/me/messages?$top=${top}&$select=subject,from,receivedDateTime,isRead`);
+    if (res.status !== 200) return { success: false, error: 'Graph API: ' + (res.data?.error?.message || res.status) };
+    const emails = (res.data.value || []).map(m => ({
+      id: m.id, subject: m.subject, from: m.from?.emailAddress?.address, receivedAt: m.receivedDateTime, isRead: m.isRead,
+    }));
+    return { success: true, count: emails.length, emails };
+  }
+
+  if (action === 'list_calendar_events') {
+    const top = params.top || 10;
+    const res = await graphApi('GET', `/me/events?$top=${top}&$select=subject,start,end,location`);
+    if (res.status !== 200) return { success: false, error: 'Graph API: ' + (res.data?.error?.message || res.status) };
+    const events = (res.data.value || []).map(e => ({
+      id: e.id, subject: e.subject, start: e.start?.dateTime, end: e.end?.dateTime, location: e.location?.displayName,
+    }));
+    return { success: true, count: events.length, events };
+  }
+
+  if (action === 'list_files') {
+    const res = await graphApi('GET', '/me/drive/root/children?$select=name,size,lastModifiedDateTime,folder');
+    if (res.status !== 200) return { success: false, error: 'Graph API: ' + (res.data?.error?.message || res.status) };
+    const files = (res.data.value || []).map(f => ({
+      id: f.id, name: f.name, size: f.size, lastModified: f.lastModifiedDateTime, isFolder: !!f.folder,
+    }));
+    return { success: true, count: files.length, files };
+  }
+
+  if (action === 'custom') {
+    if (!endpoint) return { success: false, error: 'endpoint gerekli (orn: /me/contacts)' };
+    const res = await graphApi(method || 'GET', endpoint, body);
+    return { success: res.status < 400, status: res.status, data: res.data, error: res.data?.error?.message };
+  }
+
+  return { success: false, error: 'Gecersiz action: ' + action + ' (send_email, list_emails, list_calendar_events, list_files, custom)' };
+}
+
+module.exports = {
+  name: 'microsoft_graph',
+  description: 'Microsoft Graph API (Office 365): email gonder/Liste, takvim, dosyalar. MS_GRAPH_TOKEN ortam degiskeni gerekli.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'send_email, list_emails, list_calendar_events, list_files, custom', enum: ['send_email', 'list_emails', 'list_calendar_events', 'list_files', 'custom'] },
+      to: { type: 'string', description: '(send_email) Alici email' },
+      subject: { type: 'string', description: '(send_email) Konu' },
+      body: { type: 'string', description: '(send_email) Icerik' },
+      cc: { type: 'string', description: '(send_email) CC' },
+      top: { type: 'number', description: 'Maksimum sonuc sayisi' },
+      endpoint: { type: 'string', description: '(custom) Ozel Graph API endpoint (orn: /me/contacts)' },
+      method: { type: 'string', description: '(custom) HTTP method (default: GET)' },
+      query: { type: 'string', description: 'Arama sorgusu' },
+    },
+    required: ['action'],
+  },
+  async execute(params) { return await microsoftGraph(params); },
+};

package/src/tools/pii_redact.js

@@ -0,0 +1,50 @@
+const PATTERNS = [
+  { name: 'email', regex: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, replacement: '[EMAIL]' },
+  { name: 'phone', regex: /\b(\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{2,4}\b/g, replacement: '[PHONE]' },
+  { name: 'ssn', regex: /\b\d{3}-\d{2}-\d{4}\b/g, replacement: '[SSN]' },
+  { name: 'credit_card', regex: /\b(?:\d{4}[-\s]?){3}\d{4}\b/g, replacement: '[CREDIT_CARD]' },
+  { name: 'ip', regex: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, replacement: '[IP]' },
+  { name: 'api_key', regex: /\b(sk[-_][a-zA-Z0-9]{20,}|api[-_]key[-_][a-zA-Z0-9]{16,}|[Aa][Kk][Ii][Aa][-\w]{20,})\b/g, replacement: '[API_KEY]' },
+  { name: 'token', regex: /\b(ghp_|gho_|ghu_|ghs_|ghr_)[a-zA-Z0-9]{36,}\b/g, replacement: '[TOKEN]' },
+  { name: 'aws_key', regex: /\b(AKIA[0-9A-Z]{16})\b/g, replacement: '[AWS_KEY]' },
+];
+
+async function piiRedact(params) {
+  const { text, mode = 'mask', preserveTypes } = params;
+  if (!text) return { success: false, error: 'text gerekli' };
+
+  const preserve = new Set((preserveTypes || []).map(s => s.toLowerCase()));
+  let redacted = text;
+  const findings = [];
+
+  for (const pattern of PATTERNS) {
+    if (preserve.has(pattern.name)) continue;
+    let match;
+    pattern.regex.lastIndex = 0;
+    while ((match = pattern.regex.exec(redacted)) !== null) {
+      findings.push({ type: pattern.name, index: match.index, length: match[0].length });
+    }
+    if (mode === 'mask') {
+      redacted = redacted.replace(pattern.regex, pattern.replacement);
+    } else if (mode === 'partial') {
+      redacted = redacted.replace(pattern.regex, (m) => m.slice(0, 3) + '*'.repeat(Math.max(0, m.length - 6)) + m.slice(-3));
+    }
+  }
+
+  return { success: true, redacted, findings: findings.length > 0 ? findings : undefined, totalFindings: findings.length };
+}
+
+module.exports = {
+  name: 'pii_redact',
+  description: 'PII/gizli veri maskeleme: email, telefon, SSN, kredi karti, IP, API key, token, AWS key.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      text: { type: 'string', description: 'Redakte edilecek metin' },
+      mode: { type: 'string', description: 'mask (tamamen gizle) veya partial (ilk/son 3 karakter gorunur)', enum: ['mask', 'partial'] },
+      preserveTypes: { type: 'array', description: 'Korunacak PII tipleri (orn: ["email","phone"])', items: { type: 'string' } },
+    },
+    required: ['text'],
+  },
+  async execute(params) { return await piiRedact(params); },
+};

package/src/tools/send_message.js

@@ -0,0 +1,39 @@
+async function sendMessage(params) {
+  const { to, message, platform, subject } = params;
+  if (!to || !message) return { success: false, error: 'to ve message gerekli' };
+
+  const platform_lc = (platform || '').toLowerCase();
+
+  if (platform_lc === 'terminal' || platform_lc === 'console' || !platform) {
+    return { success: true, platform: 'terminal', to, message, delivered: true, note: 'Mesaj terminale yazdirildi (dis ortama gonderilmedi)' };
+  }
+
+  if (platform_lc === 'email') {
+    if (!process.env.EMAIL_HOST || !process.env.EMAIL_USER) {
+      return { success: false, error: 'Email icin EMAIL_HOST ve EMAIL_USER ortam degiskenleri gerekli' };
+    }
+    return { success: true, platform: 'email', to, subject: subject || 'NatureCo Mesaj', message, delivered: 'pending', note: 'Email gonderme ayarlanmadi (smtp yapilandirmasi gerekli)' };
+  }
+
+  if (platform_lc === 'webhook') {
+    return { success: true, platform: 'webhook', to, message, delivered: 'pending', note: 'Webhook entegrasyonu icin gateway yapilandirmasi gerekli' };
+  }
+
+  return { success: false, error: 'Desteklenmeyen platform: ' + platform + ' (terminal, email, webhook)' };
+}
+
+module.exports = {
+  name: 'send_message',
+  description: 'Platformlar arasi mesaj gonderimi: terminal, email, webhook (diger platformlar icin gateway yapilandirmasi gerekli).',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      to: { type: 'string', description: 'Alici (email adresi, kullanici adi, kanal)' },
+      message: { type: 'string', description: 'Mesaj icerigi' },
+      platform: { type: 'string', description: 'Hedef platform: terminal, email, webhook', enum: ['terminal', 'email', 'webhook'] },
+      subject: { type: 'string', description: 'Opsiyonel: konu (email icin)' },
+    },
+    required: ['to', 'message'],
+  },
+  async execute(params) { return await sendMessage(params); },
+};

package/src/tools/session_search.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const path = require('path');
+
+const SESSIONS_DIR = path.join(process.env.HOME || process.env.USERPROFILE || __dirname, '.natureco', 'sessions');
+
+function getAllMessages() {
+  const messages = [];
+  if (!fs.existsSync(SESSIONS_DIR)) return messages;
+  const files = fs.readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, file), 'utf8'));
+      const sessionName = file.replace('.json', '');
+      if (Array.isArray(data.messages)) {
+        for (const msg of data.messages) {
+          messages.push({ session: sessionName, role: msg.role, content: msg.content, timestamp: msg.timestamp || data.savedAt });
+        }
+      } else if (Array.isArray(data)) {
+        for (const msg of data) {
+          messages.push({ session: sessionName, role: msg.role, content: msg.content, timestamp: msg.timestamp });
+        }
+      }
+    } catch {}
+  }
+  return messages;
+}
+
+async function sessionSearch(params) {
+  const { query, session, limit = 10 } = params;
+  if (!query) return { success: false, error: 'query gerekli' };
+
+  const allMessages = getAllMessages();
+  const filtered = session ? allMessages.filter(m => m.session === session) : allMessages;
+  const q = query.toLowerCase();
+
+  const results = filtered
+    .filter(m => m.content && m.content.toLowerCase().includes(q))
+    .slice(0, limit)
+    .map(m => ({
+      session: m.session,
+      role: m.role,
+      snippet: m.content.length > 200 ? m.content.slice(0, 200) + '...' : m.content,
+      timestamp: m.timestamp,
+    }));
+
+  return { success: true, query, totalMatches: results.length, results, searchedSessions: session ? [session] : undefined };
+}
+
+module.exports = {
+  name: 'session_search',
+  description: 'Gecmis oturumlarda metin aramasi: tum oturumlar veya belirli bir oturum icinde ara.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Aranacak metin' },
+      session: { type: 'string', description: 'Opsiyonel: belirli bir oturum (dosya adi)' },
+      limit: { type: 'number', description: 'Maksimum sonuc sayisi (default: 10)' },
+    },
+    required: ['query'],
+  },
+  async execute(params) { return await sessionSearch(params); },
+};

package/src/tools/spotify.js

@@ -0,0 +1,93 @@
+const https = require('https');
+
+async function spotify(params) {
+  const { action, query, trackId, deviceId, volumePercent, clientId, clientSecret } = params;
+
+  const cid = clientId || process.env.SPOTIFY_CLIENT_ID;
+  const csecret = clientSecret || process.env.SPOTIFY_CLIENT_SECRET;
+
+  if (!cid || !csecret) {
+    return { success: false, error: 'SPOTIFY_CLIENT_ID ve SPOTIFY_CLIENT_SECRET ortam degiskenleri gerekli' };
+  }
+
+  async function getToken() {
+    const auth = Buffer.from(cid + ':' + csecret).toString('base64');
+    return new Promise((resolve) => {
+      const data = 'grant_type=client_credentials';
+      const req = https.request('https://accounts.spotify.com/api/token', {
+        method: 'POST',
+        headers: { 'Authorization': 'Basic ' + auth, 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(data) },
+        timeout: 10000,
+      }, (res) => {
+        let body = '';
+        res.on('data', c => body += c);
+        res.on('end', () => {
+          try { resolve(JSON.parse(body).access_token); } catch { resolve(null); }
+        });
+      });
+      req.on('error', () => resolve(null));
+      req.write(data);
+      req.end();
+    });
+  }
+
+  function spotifyApi(method, path, token, body) {
+    return new Promise((resolve) => {
+      const opts = { hostname: 'api.spotify.com', path, method, headers: { 'Authorization': 'Bearer ' + token }, timeout: 10000 };
+      const req = https.request(opts, (res) => {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, data: JSON.parse(data) }); } catch { resolve({ status: res.statusCode, data }); }
+        });
+      });
+      req.on('error', (e) => resolve({ status: 0, error: e.message }));
+      if (body) req.write(JSON.stringify(body));
+      req.end();
+    });
+  }
+
+  const token = await getToken();
+  if (!token) return { success: false, error: 'Spotify token alinamadi' };
+
+  if (action === 'search') {
+    if (!query) return { success: false, error: 'query gerekli' };
+    const res = await spotifyApi('GET', '/v1/search?q=' + encodeURIComponent(query) + '&type=track,album,artist&limit=10', token);
+    if (res.status !== 200) return { success: false, error: 'Spotify API: ' + (res.data?.error?.message || res.status) };
+    return { success: true, query, tracks: res.data.tracks?.items?.map(t => ({ id: t.id, name: t.name, artist: t.artists?.map(a => a.name).join(', '), album: t.album?.name, url: t.external_urls?.spotify })) || [],
+      albums: res.data.albums?.items?.map(a => ({ id: a.id, name: a.name, artist: a.artists?.map(a => a.name).join(', ') })) || [] };
+  }
+
+  if (action === 'get_track') {
+    if (!trackId) return { success: false, error: 'trackId gerekli' };
+    const res = await spotifyApi('GET', '/v1/tracks/' + trackId, token);
+    if (res.status !== 200) return { success: false, error: 'Spotify API: ' + (res.data?.error?.message || res.status) };
+    const t = res.data;
+    return { success: true, track: { id: t.id, name: t.name, artist: t.artists?.map(a => a.name).join(', '), album: t.album?.name, duration: t.duration_ms, url: t.external_urls?.spotify, preview: t.preview_url } };
+  }
+
+  if (action === 'play' || action === 'pause' || action === 'next' || action === 'previous') {
+    return { success: true, action, note: 'Playback kontrolu Spotify Premium + cihaz auth gerektirir. Token tipi "client_credentials" yetmez. "authorization_code" flow gerekli.' };
+  }
+
+  return { success: false, error: 'Gecersiz action: ' + action + ' (search, get_track, play, pause, next, previous)' };
+}
+
+module.exports = {
+  name: 'spotify',
+  description: 'Spotify arama ve bilgi alma. SPOTIFY_CLIENT_ID ve SPOTIFY_CLIENT_SECRET ortam degiskenleri gerekli.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'search, get_track, play, pause, next, previous', enum: ['search', 'get_track', 'play', 'pause', 'next', 'previous'] },
+      query: { type: 'string', description: '(search) Arama sorgusu' },
+      trackId: { type: 'string', description: '(get_track) Spotify track ID' },
+      deviceId: { type: 'string', description: '(play/pause) Cihaz ID' },
+      volumePercent: { type: 'number', description: 'Ses seviyesi (0-100)' },
+      clientId: { type: 'string', description: 'Spotify Client ID (default: SPOTIFY_CLIENT_ID env)' },
+      clientSecret: { type: 'string', description: 'Spotify Client Secret (default: SPOTIFY_CLIENT_SECRET env)' },
+    },
+    required: ['action'],
+  },
+  async execute(params) { return await spotify(params); },
+};

package/src/tools/url_safety.js

@@ -0,0 +1,65 @@
+const https = require('https');
+const http = require('http');
+
+const BLOCKED_DOMAINS = new Set([
+  'malware.test', 'phishing.test', 'evil.com', 'malicious.com',
+  'hackers.org', 'pwned.com', 'ransomware.test',
+]);
+
+async function urlSafety(params) {
+  const { url, checkType = 'basic' } = params;
+  if (!url) return { success: false, error: 'url gerekli' };
+
+  const issues = [];
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { success: false, error: 'Gecersiz URL', safe: false };
+  }
+
+  if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+    issues.push('Desteklenmeyen protokol: ' + parsed.protocol);
+  }
+
+  const domain = parsed.hostname.toLowerCase();
+  if (BLOCKED_DOMAINS.has(domain)) {
+    issues.push('Bilinen tehlikeli domain: ' + domain);
+  }
+
+  if (checkType === 'full' || checkType === 'resolve') {
+    try {
+      const code = await new Promise((resolve) => {
+        const req = (parsed.protocol === 'https:' ? https : http).get(url, { timeout: 5000 }, (res) => {
+          resolve(res.statusCode);
+          res.resume();
+        });
+        req.on('error', () => resolve(0));
+        req.on('timeout', () => { req.destroy(); resolve(0); });
+      });
+      if (code >= 400) issues.push('HTTP ' + code + ' dondu');
+    } catch { issues.push('Baglanti hatasi'); }
+  }
+
+  return {
+    safe: issues.length === 0,
+    issues: issues.length > 0 ? issues : undefined,
+    domain,
+    protocol: parsed.protocol,
+    url: parsed.href,
+  };
+}
+
+module.exports = {
+  name: 'url_safety',
+  description: 'URL guvenlik taramasi: domain kara liste, HTTP durum kodu kontrolu.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      url: { type: 'string', description: 'Kontrol edilecek URL' },
+      checkType: { type: 'string', description: 'basic (domain kontrol) veya full (domain + HTTP resolve)', enum: ['basic', 'full'] },
+    },
+    required: ['url'],
+  },
+  async execute(params) { return await urlSafety(params); },
+};