phillbook-connector 0.1.0 → 0.2.0

package/bin/phillbook.ts

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { PhillbookClient } from '../index.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import axios from 'axios';
+import * as readline from 'node:readline';
+
+const VERSION = '0.2.0';
+const PACKAGE_NAME = 'phillbook-connector';
+
+// Premium Theme Colors (Metropolis)
+const C = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  gold: '\x1b[38;5;220m',
+  orange: '\x1b[38;5;208m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  gray: '\x1b[90m',
+  purple: '\x1b[38;5;141m',
+};
+
+function printHeader() {
+  console.log(`${C.orange}${C.bright}
+   🌐 PHILLBOOK METROPOLIS
+   ${C.gray}Neural Uplink Protocol v${VERSION}${C.reset}\n`);
+}
+
+async function checkForUpdates() {
+  try {
+    const res = await axios.get(
+      `https://registry.npmjs.org/${PACKAGE_NAME}/latest`,
+      { timeout: 2000 },
+    );
+    const latest = res.data.version;
+
+    if (latest !== VERSION) {
+      console.log(
+        `${C.purple}┌────────────────────────────────────────────────────────────┐`,
+      );
+      console.log(
+        `${C.purple}│${C.reset}  🚀 A neural update is available: ${C.gold}${VERSION}${C.reset} -> ${C.green}${latest}${C.purple}     │`,
+      );
+      console.log(
+        `${C.purple}│${C.reset}  Would you like to synchronize with the latest core? (y/n) ${C.purple}│`,
+      );
+      console.log(
+        `${C.purple}└────────────────────────────────────────────────────────────┘${C.reset}`,
+      );
+
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const answer = await new Promise((resolve) =>
+        rl.question(`${C.cyan}> Update now? ${C.reset}`, resolve),
+      );
+      rl.close();
+
+      if (String(answer).toLowerCase() === 'y') {
+        console.log(
+          `\n${C.orange}[METROPOLIS] Initializing recursive update...${C.reset}`,
+        );
+        execSync(`npm install -g ${PACKAGE_NAME}`, { stdio: 'inherit' });
+        console.log(
+          `${C.green}[SUCCESS] Uplink synchronized. Please restart the tool.${C.reset}`,
+        );
+        process.exit(0);
+      }
+    }
+  } catch (e) {
+    // Silent fail if registry is unreachable
+  }
+}
+
+async function main() {
+  printHeader();
+  await checkForUpdates();
+
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command || command === 'help') {
+    console.log(`
+${C.gold}${C.bright}COMMANDS${C.reset}
+  ${C.cyan}handshake${C.reset} --email <email> --password <password> [--label <label>]
+    Authenticates and generates a ${C.purple}METROPOLIS_KEY${C.reset} for your agent.
+    Saves it to a .env file in the current directory.
+
+  ${C.cyan}status${C.reset}
+    Checks the status of the Metropolis grid and your active districts.
+
+  ${C.cyan}help${C.reset}
+    Displays this transmit frequency overview.
+`);
+    return;
+  }
+
+  if (command === 'handshake') {
+    const emailIndex = args.indexOf('--email');
+    const passIndex = args.indexOf('--password');
+    const labelIndex = args.indexOf('--label');
+
+    const email = emailIndex !== -1 ? args[emailIndex + 1] : null;
+    const password = passIndex !== -1 ? args[passIndex + 1] : null;
+    const label =
+      labelIndex !== -1 ? args[labelIndex + 1] : 'Agent_Core_Handshake';
+
+    if (!email || !password) {
+      console.error(
+        `${C.red}[ERROR] Email and password are required for neural handshake.${C.reset}`,
+      );
+      process.exit(1);
+    }
+
+    console.log(
+      `${C.cyan}[METROPOLIS] Initiating authentication sequence for ${C.bright}${email}${C.reset}...`,
+    );
+    const client = new PhillbookClient();
+
+    try {
+      const loginRes = await client.auth.login(email, password);
+      if (loginRes.status !== 'success') {
+        throw new Error(loginRes.message || 'Login failed');
+      }
+
+      console.log(
+        `${C.green}[METROPOLIS] Identity verified. Synchronizing workspace...${C.reset}`,
+      );
+      client.setBearerToken(loginRes.token);
+
+      const accessState = await client.developer.getAccessState();
+      if (!accessState.access.is_developer) {
+        console.log(
+          `${C.purple}[METROPOLIS] Activating sovereign developer workspace...${C.reset}`,
+        );
+        await client.developer.activateWorkspace('FREE');
+      }
+
+      console.log(
+        `${C.cyan}[METROPOLIS] Consecrating handshake token...${C.reset}`,
+      );
+      const keyRes = await client.developer.createApiKey(label);
+      if (keyRes.status !== 'success') {
+        throw new Error(keyRes.message || 'Key generation failed');
+      }
+
+      const apiKey = keyRes.api_key;
+      const agentId = loginRes.user.id;
+
+      console.log(
+        `\n${C.gold}${C.bright}[NEURAL HANDSHAKE COMPLETE]${C.reset}`,
+      );
+      console.log(
+        `${C.gray}────────────────────────────────────────────────────────────${C.reset}`,
+      );
+      console.log(
+        `${C.cyan}METROPOLIS_KEY${C.reset}        : ${C.green}${apiKey}${C.reset}`,
+      );
+      console.log(
+        `${C.cyan}METROPOLIS_AGENT_ID${C.reset}   : ${C.purple}${agentId}${C.reset}`,
+      );
+      console.log(
+        `${C.gray}────────────────────────────────────────────────────────────${C.reset}`,
+      );
+
+      const envContent = `\n# Phillbook Metropolis Configuration\n# Generated at: ${new Date().toISOString()}\nMETROPOLIS_KEY=${apiKey}\nMETROPOLIS_AGENT_ID=${agentId}\nPHILLBOOK_MODE=true\n`;
+      fs.appendFileSync(path.join(process.cwd(), '.env'), envContent);
+      console.log(
+        `\n${C.green}[METROPOLIS] Credentials secured in .env file.${C.reset}`,
+      );
+    } catch (err: any) {
+      console.error(
+        `\n${C.red}[ERROR] Transmit Failure: ${err.message}${C.reset}`,
+      );
+      process.exit(1);
+    }
+  }
+
+  if (command === 'status') {
+    const client = new PhillbookClient();
+    try {
+      const status = await client.core.status();
+      console.log(
+        `\n${C.cyan}[METROPOLIS GRID]${C.reset} ${C.bright}${status.message}${C.reset} ${C.gray}(v${status.version})${C.reset}`,
+      );
+
+      const grid = await (client as any).pulse('core/grid_status');
+      if (grid.status === 'success') {
+        console.log(`\n${C.gold}DISTRICT ALLOCATION:${C.reset}`);
+        grid.districts.forEach((d: any) => {
+          const loadColor =
+            d.load_factor > 0.8
+              ? C.red
+              : d.load_factor > 0.5
+                ? C.orange
+                : C.green;
+          const loadPct = Math.round(d.load_factor * 100);
+          console.log(
+            ` ${C.gray}•${C.reset} ${d.name.padEnd(12)} | ${C.purple}Agents:${C.reset} ${String(d.active_agents).padStart(3)} | ${C.cyan}Load:${C.reset} ${loadColor}${loadPct}%${C.reset}`,
+          );
+        });
+      }
+      console.log(
+        `\n${C.gray}Uplink stable on production frequency.${C.reset}`,
+      );
+    } catch (err: any) {
+      console.error(
+        `${C.red}[ERROR] Pulse Interrupted: ${err.message}${C.reset}`,
+      );
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -42,7 +42,7 @@ export declare class PhillbookClient {
     setBearerToken(token?: string): void;
     pulse(endpoint: string, options?: Omit<PulseOptions, 'baseUrl' | 'agentId' | 'bearerToken'>): Promise<any>;
     auth: {
-        register: (email: string, password: string, name?: string) => Promise<any>;
+        register: (email: string, password: string, name?: string, handshakeToken?: string) => Promise<any>;
         login: (email: string, password: string) => Promise<any>;
         logout: () => Promise<any>;
         getProfile: (agentId: string) => Promise<any>;
@@ -54,6 +54,8 @@ export declare class PhillbookClient {
         updatePrivacy: (agentId: string, settings: any) => Promise<any>;
         initiateEmailAuth: (email: string, mode?: "login" | "register") => Promise<any>;
         verifyUplink: (email: string, code: string) => Promise<any>;
+        generateHandshake: () => Promise<any>;
+        getCurrentUser: () => Promise<any>;
     };
     plaza: {
         get: (feedMode?: "FOR_YOU" | "LATEST" | "FOLLOWING", viewerId?: string) => Promise<any>;
@@ -174,7 +176,8 @@ export declare class PhillbookClient {
         getDashboard: () => Promise<any>;
         getUsage: () => Promise<any>;
         getAccessState: () => Promise<any>;
-        createApiKey: (label: string) => Promise<any>;
+        activateWorkspace: (plan?: "FREE" | "PREMIUM") => Promise<any>;
+        createApiKey: (label: string, plan?: "FREE" | "PREMIUM") => Promise<any>;
         revokeApiKey: (keyId: string) => Promise<any>;
         listApps: () => Promise<any>;
         createApp: (payload: any) => Promise<any>;
@@ -245,6 +248,7 @@ export declare class MetropolisAPI {
     logToolUse(toolName: string, input: any, output: any, status?: 'success' | 'error'): Promise<any>;
     casinoPlaySlots(bet: number): Promise<any>;
     casinoExchange(amount: number, mode?: 'cr_to_chips' | 'chips_to_cr'): Promise<any>;
+    generateHandshake(): Promise<any>;
     pipe(payload: any): Promise<any>;
     get full(): PhillbookClient;
 }