@latentforce/latentgraph 1.0.0

package/build/utils/auth-resolver.js

@@ -0,0 +1,184 @@
+import * as path from 'path';
+import { getApiKey, setApiKey, setGuestKey, isGuestKey, setProject, readProjectConfig, } from './config.js';
+import { requestGuestKey, fetchProjects, fetchMigrationTemplates, createProject, } from './api-client.js';
+import { promptApiKey, promptKeyChoice, promptSelectProject, promptProjectName, promptCreateOrSelect, promptSelectTemplate, } from './prompts.js';
+/**
+ * Resolve API key from flags, config, or interactive prompts.
+ * Guest flow returns both apiKey and projectId (from guest-key endpoint).
+ */
+export async function resolveApiKey(opts = {}) {
+    const label = opts.commandLabel || 'Shift';
+    const interactive = opts.interactive ?? true;
+    // If both --guest and --api-key, api-key wins
+    if (opts.guest && opts.apiKey) {
+        console.log(`[${label}] ⚠️  Both --guest and --api-key provided; using --api-key.`);
+    }
+    // 1. Explicit --api-key flag
+    if (opts.apiKey) {
+        setApiKey(opts.apiKey);
+        console.log(`[${label}] ✓ API key saved\n`);
+        return { apiKey: opts.apiKey };
+    }
+    // 2. Existing key in config
+    const existingKey = getApiKey();
+    if (existingKey) {
+        if (isGuestKey()) {
+            console.log(`[${label}] ✓ Guest key found\n`);
+        }
+        else {
+            console.log(`[${label}] ✓ API key found\n`);
+        }
+        return { apiKey: existingKey };
+    }
+    // 3. --guest flag
+    if (opts.guest) {
+        return await doGuestFlow(label);
+    }
+    // 4. Interactive fallback
+    if (interactive) {
+        const choice = await promptKeyChoice();
+        if (choice === 'paid') {
+            const apiKey = await promptApiKey();
+            setApiKey(apiKey);
+            console.log(`[${label}] ✓ API key saved\n`);
+            return { apiKey };
+        }
+        else {
+            return await doGuestFlow(label);
+        }
+    }
+    // 5. Non-interactive with no key
+    console.error(`\n❌ No API key found. Provide --api-key <key> or --guest.`);
+    process.exit(1);
+}
+async function doGuestFlow(label) {
+    console.log(`\n[${label}] Requesting guest session...`);
+    try {
+        const resp = await requestGuestKey();
+        setGuestKey(resp.api_key);
+        console.log(`[${label}] ✓ Guest session started\n`);
+        const result = { apiKey: resp.api_key };
+        // Guest endpoint may return a project_id
+        if (resp.project_id) {
+            result.projectId = resp.project_id;
+        }
+        return result;
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to get guest key: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Resolve project from flags, local config, or interactive prompts.
+ * Can create new projects when --project-name is given.
+ */
+export async function resolveProject(opts) {
+    const label = opts.commandLabel || 'Shift';
+    const interactive = opts.interactive ?? true;
+    const projectRoot = opts.projectRoot || process.cwd();
+    // 1. Check existing local config
+    const existingConfig = readProjectConfig(projectRoot);
+    if (existingConfig) {
+        console.log(`[${label}] ✓ Project: ${existingConfig.project_name} (${existingConfig.project_id})\n`);
+        return { projectId: existingConfig.project_id, projectName: existingConfig.project_name };
+    }
+    // 2. Explicit --project-id
+    if (opts.projectId) {
+        const name = opts.projectName || 'CLI Project';
+        setProject(opts.projectId, name, projectRoot);
+        console.log(`[${label}] ✓ Project "${name}" saved (${opts.projectId})\n`);
+        return { projectId: opts.projectId, projectName: name };
+    }
+    // 3. --project-name: try to match existing, else create new
+    if (opts.projectName) {
+        return await resolveByName(opts, projectRoot, label);
+    }
+    // 4. Interactive fallback
+    if (interactive) {
+        return await interactiveProjectSetup(opts.apiKey, opts.template, projectRoot, label);
+    }
+    // 5. Non-interactive with no project info
+    console.error(`\n❌ No project configured. Provide --project-id or --project-name.`);
+    process.exit(1);
+}
+async function resolveByName(opts, projectRoot, label) {
+    const { apiKey, projectName, template } = opts;
+    const interactive = opts.interactive ?? true;
+    // Try to match existing project by name
+    console.log(`[${label}] Looking for project "${projectName}"...`);
+    try {
+        const projects = await fetchProjects(apiKey);
+        const match = projects.find((p) => p.project_name.toLowerCase() === projectName.toLowerCase());
+        if (match) {
+            setProject(match.project_id, match.project_name, projectRoot);
+            console.log(`[${label}] ✓ Found existing project "${match.project_name}" (${match.project_id})\n`);
+            return { projectId: match.project_id, projectName: match.project_name };
+        }
+    }
+    catch {
+        // Can't fetch projects — proceed to create
+    }
+    // No match — create new project
+    console.log(`[${label}] No existing project named "${projectName}". Creating new project...`);
+    return await createNewProject(apiKey, projectName, template, interactive, projectRoot, label);
+}
+async function createNewProject(apiKey, name, templateFlag, interactive, projectRoot, label) {
+    let templateId = templateFlag;
+    if (!templateId) {
+        // Fetch templates and let user select
+        try {
+            const templates = await fetchMigrationTemplates(apiKey);
+            if (templates.length > 0) {
+                if (interactive) {
+                    templateId = await promptSelectTemplate(templates);
+                }
+                else {
+                    // Non-interactive: use first template
+                    templateId = templates[0].template_id;
+                    console.log(`[${label}] Using default template: ${templates[0].name}`);
+                }
+            }
+        }
+        catch {
+            console.log(`[${label}] ⚠️  Could not fetch templates, proceeding without one.`);
+        }
+    }
+    try {
+        const project = await createProject(apiKey, {
+            project_name: name,
+            migration_template_id: templateId,
+        });
+        setProject(project.project_id, project.project_name, projectRoot);
+        console.log(`[${label}] ✓ Created project "${project.project_name}" (${project.project_id})\n`);
+        return { projectId: project.project_id, projectName: project.project_name };
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to create project: ${error.message}`);
+        process.exit(1);
+    }
+}
+async function interactiveProjectSetup(apiKey, templateFlag, projectRoot, label) {
+    // Always ask user what they want to do first
+    const action = await promptCreateOrSelect();
+    if (action === 'select') {
+        let projects = [];
+        try {
+            projects = await fetchProjects(apiKey);
+        }
+        catch {
+            // fetch failed
+        }
+        if (projects.length > 0) {
+            const selected = await promptSelectProject(projects);
+            setProject(selected.project_id, selected.project_name, projectRoot);
+            console.log(`[${label}] ✓ Project "${selected.project_name}" saved\n`);
+            return { projectId: selected.project_id, projectName: selected.project_name };
+        }
+        console.log(`[${label}] No existing projects found. Let's create one.\n`);
+    }
+    // Create new project — suggest directory name as default
+    const defaultName = path.basename(projectRoot);
+    const name = await promptProjectName(defaultName);
+    return await createNewProject(apiKey, name, templateFlag, true, projectRoot, label);
+}

package/build/utils/config.js

@@ -0,0 +1,260 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// Global config location: ~/.shift/config.json
+const GLOBAL_SHIFT_DIR = path.join(os.homedir(), '.shift');
+const GLOBAL_CONFIG_FILE = path.join(GLOBAL_SHIFT_DIR, 'config.json');
+// Local config location: .shift/ in current directory
+const LOCAL_SHIFT_DIR = '.shift';
+const LOCAL_CONFIG_FILE = 'config.json'; // Changed from project.json to match extension
+const DAEMON_PID_FILE = 'daemon.pid';
+const DAEMON_STATUS_FILE = 'daemon.status.json';
+// Default URLs
+const DEFAULT_API_URL = 'https://dev-shift-lite.latentforce.ai';
+const DEFAULT_ORCH_URL = 'https://agent-orch.latentforce.ai';
+const DEFAULT_WS_URL = 'wss://agent-orch.latentforce.ai';
+// Helper to get URL from: 1) env var, 2) global config, 3) default
+function getConfiguredUrl(envVar, configKey, defaultUrl) {
+    // Priority: Environment variable > Global config > Default
+    if (process.env[envVar]) {
+        return process.env[envVar];
+    }
+    const config = readGlobalConfigInternal();
+    if (config?.[configKey]) {
+        return config[configKey];
+    }
+    return defaultUrl;
+}
+// Internal read to avoid circular dependency
+function readGlobalConfigInternal() {
+    try {
+        if (fs.existsSync(GLOBAL_CONFIG_FILE)) {
+            const content = fs.readFileSync(GLOBAL_CONFIG_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Invalid config, treat as not existing
+    }
+    return null;
+}
+// API URLs - Priority: env var > global config > default
+export const API_BASE_URL = getConfiguredUrl('SHIFT_API_URL', 'api_url', DEFAULT_API_URL);
+export const API_BASE_URL_ORCH = getConfiguredUrl('SHIFT_ORCH_URL', 'orch_url', DEFAULT_ORCH_URL);
+export const WS_URL = getConfiguredUrl('SHIFT_WS_URL', 'ws_url', DEFAULT_WS_URL);
+// --- Global Config Functions ---
+export function ensureGlobalShiftDir() {
+    if (!fs.existsSync(GLOBAL_SHIFT_DIR)) {
+        fs.mkdirSync(GLOBAL_SHIFT_DIR, { recursive: true });
+    }
+}
+export function readGlobalConfig() {
+    try {
+        if (fs.existsSync(GLOBAL_CONFIG_FILE)) {
+            const content = fs.readFileSync(GLOBAL_CONFIG_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Invalid config, treat as not existing
+    }
+    return null;
+}
+export function writeGlobalConfig(config) {
+    ensureGlobalShiftDir();
+    fs.writeFileSync(GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function getApiKey() {
+    const config = readGlobalConfig();
+    return config?.api_key || null;
+}
+export function setApiKey(apiKey) {
+    const config = readGlobalConfig() || { api_key: '' };
+    config.api_key = apiKey;
+    delete config.key_type;
+    writeGlobalConfig(config);
+}
+export function setGuestKey(apiKey) {
+    const config = {
+        api_key: apiKey,
+        key_type: 'guest',
+    };
+    writeGlobalConfig(config);
+}
+export function isGuestKey() {
+    const config = readGlobalConfig();
+    return config?.key_type === 'guest';
+}
+export function clearApiKey() {
+    const config = readGlobalConfig() || { api_key: '' };
+    config.api_key = '';
+    delete config.key_type;
+    writeGlobalConfig(config);
+}
+// --- URL Configuration Functions ---
+export function setApiUrl(url) {
+    const config = readGlobalConfig() || { api_key: '' };
+    config.api_url = url;
+    writeGlobalConfig(config);
+}
+export function setOrchUrl(url) {
+    const config = readGlobalConfig() || { api_key: '' };
+    config.orch_url = url;
+    writeGlobalConfig(config);
+}
+export function setWsUrl(url) {
+    const config = readGlobalConfig() || { api_key: '' };
+    config.ws_url = url;
+    writeGlobalConfig(config);
+}
+export function clearUrls() {
+    const config = readGlobalConfig() || { api_key: '' };
+    delete config.api_url;
+    delete config.orch_url;
+    delete config.ws_url;
+    writeGlobalConfig(config);
+}
+export function getConfiguredUrls() {
+    return {
+        api_url: API_BASE_URL,
+        orch_url: API_BASE_URL_ORCH,
+        ws_url: WS_URL,
+    };
+}
+// --- Local Config Functions ---
+export function getLocalShiftDir(projectRoot) {
+    const root = projectRoot || process.cwd();
+    return path.join(root, LOCAL_SHIFT_DIR);
+}
+export function ensureLocalShiftDir(projectRoot) {
+    const dir = getLocalShiftDir(projectRoot);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+const SCAN_TARGET_TEMPLATE = [
+    {
+        language: null,
+        path: '',
+    },
+];
+/**
+ * Create .shift/scan_target.json with a template if it doesn't exist.
+ * Users can edit this file to manually specify scan targets.
+ */
+export function ensureScanTargetFile(projectRoot) {
+    const filePath = path.join(getLocalShiftDir(projectRoot), 'scan_target.json');
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, JSON.stringify(SCAN_TARGET_TEMPLATE, null, 2));
+    }
+}
+export function readProjectConfig(projectRoot) {
+    try {
+        const filePath = path.join(getLocalShiftDir(projectRoot), LOCAL_CONFIG_FILE);
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Invalid config, treat as not existing
+    }
+    return null;
+}
+export function writeProjectConfig(config, projectRoot) {
+    ensureLocalShiftDir(projectRoot);
+    const filePath = path.join(getLocalShiftDir(projectRoot), LOCAL_CONFIG_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+    // Also create .gitignore in .shift folder (matching extension)
+    const gitignorePath = path.join(getLocalShiftDir(projectRoot), '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, '*\n!.gitignore\n!config.json\n!scan_target.json\n');
+    }
+    // Create scan_target.json template if it doesn't exist
+    ensureScanTargetFile(projectRoot);
+}
+export function getProjectId(projectRoot) {
+    const config = readProjectConfig(projectRoot);
+    return config?.project_id || null;
+}
+export function getProjectName(projectRoot) {
+    const config = readProjectConfig(projectRoot);
+    return config?.project_name || null;
+}
+export function setProject(projectId, projectName, projectRoot) {
+    const existing = readProjectConfig(projectRoot);
+    const config = {
+        project_id: projectId,
+        project_name: projectName,
+        agents: existing?.agents || [],
+        created_at: existing?.created_at || new Date().toISOString(),
+    };
+    writeProjectConfig(config, projectRoot);
+}
+// --- Daemon Status Functions ---
+export function getDaemonPidPath(projectRoot) {
+    return path.join(getLocalShiftDir(projectRoot), DAEMON_PID_FILE);
+}
+export function getDaemonStatusPath(projectRoot) {
+    return path.join(getLocalShiftDir(projectRoot), DAEMON_STATUS_FILE);
+}
+export function readDaemonPid(projectRoot) {
+    try {
+        const filePath = getDaemonPidPath(projectRoot);
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8').trim();
+            const pid = parseInt(content, 10);
+            return isNaN(pid) ? null : pid;
+        }
+    }
+    catch {
+        // Error reading PID file
+    }
+    return null;
+}
+export function writeDaemonPid(pid, projectRoot) {
+    ensureLocalShiftDir(projectRoot);
+    const filePath = getDaemonPidPath(projectRoot);
+    fs.writeFileSync(filePath, String(pid));
+}
+export function removeDaemonPid(projectRoot) {
+    const filePath = getDaemonPidPath(projectRoot);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
+export function readDaemonStatus(projectRoot) {
+    try {
+        const filePath = getDaemonStatusPath(projectRoot);
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Invalid status file
+    }
+    return null;
+}
+export function writeDaemonStatus(status, projectRoot) {
+    ensureLocalShiftDir(projectRoot);
+    const filePath = getDaemonStatusPath(projectRoot);
+    fs.writeFileSync(filePath, JSON.stringify(status, null, 2));
+}
+export function removeDaemonStatus(projectRoot) {
+    const filePath = getDaemonStatusPath(projectRoot);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
+// --- Process Check ---
+export function isProcessRunning(pid) {
+    try {
+        // Sending signal 0 checks if process exists without killing it
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/build/utils/machine-id.js

@@ -0,0 +1,46 @@
+import os from 'os';
+import crypto from 'crypto';
+/**
+ * Get the primary MAC address (first non-internal interface)
+ */
+function getPrimaryMacAddress() {
+    const interfaces = os.networkInterfaces();
+    for (const [name, addrs] of Object.entries(interfaces)) {
+        if (!addrs)
+            continue;
+        for (const addr of addrs) {
+            // Skip internal/loopback and addresses without MAC
+            if (addr.internal || !addr.mac || addr.mac === '00:00:00:00:00:00') {
+                continue;
+            }
+            return addr.mac;
+        }
+    }
+    return 'unknown';
+}
+/**
+ * Generate a unique, deterministic machine fingerprint
+ * Uses MAC address + platform for stability
+ * - MAC is globally unique per network interface
+ * - Platform helps distinguish dual-boot scenarios
+ */
+export function generateMachineId() {
+    const mac = getPrimaryMacAddress();
+    const platform = os.platform();
+    // Combine MAC + platform
+    const fingerprintData = `${mac}|${platform}`;
+    // Hash for privacy and fixed length
+    return crypto.createHash('sha256').update(fingerprintData).digest('hex');
+}
+/**
+ * Generate a shorter machine ID (first 16 chars of full hash)
+ */
+export function generateShortMachineId() {
+    return generateMachineId().substring(0, 16);
+}
+export function getMachineFingerprint() {
+    return {
+        machine_id: generateMachineId(),
+        platform: os.platform(),
+    };
+}

package/build/utils/prompts.js

@@ -0,0 +1,114 @@
+import * as readline from 'readline';
+function createReadlineInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+export function prompt(question) {
+    return new Promise((resolve) => {
+        const rl = createReadlineInterface();
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function promptApiKey() {
+    console.log('\nNo Shift API key found.');
+    const apiKey = await prompt('Please paste your Shift API key: ');
+    if (!apiKey) {
+        console.error('Error: API key is required.');
+        process.exit(1);
+    }
+    return apiKey;
+}
+export async function promptProjectId() {
+    console.log('\nNo project configured for this directory.');
+    const projectId = await prompt('Please enter your Shift project ID: ');
+    if (!projectId) {
+        console.error('Error: Project ID is required.');
+        process.exit(1);
+    }
+    return projectId;
+}
+export async function promptSelectProject(projects) {
+    console.log('\nAvailable projects:');
+    console.log('-------------------');
+    projects.forEach((project, index) => {
+        const description = project.description ? ` - ${project.description}` : '';
+        console.log(`  ${index + 1}. ${project.project_name}${description}`);
+    });
+    console.log('');
+    const answer = await prompt(`Select a project (1-${projects.length}): `);
+    const selection = parseInt(answer, 10);
+    if (isNaN(selection) || selection < 1 || selection > projects.length) {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+    return projects[selection - 1];
+}
+export async function promptKeyChoice() {
+    console.log('\nNo Shift API key found.');
+    console.log('');
+    console.log('  1. I have an API key');
+    console.log('  2. Continue as guest');
+    console.log('');
+    const answer = await prompt('Select an option (1 or 2): ');
+    const selection = parseInt(answer, 10);
+    if (selection === 1) {
+        return 'paid';
+    }
+    else if (selection === 2) {
+        return 'guest';
+    }
+    else {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+}
+export async function promptCreateOrSelect() {
+    console.log('\nProject setup:');
+    console.log('');
+    console.log('  1. Select an existing project');
+    console.log('  2. Create a new project');
+    console.log('');
+    const answer = await prompt('Select an option (1 or 2): ');
+    const selection = parseInt(answer, 10);
+    if (selection === 1) {
+        return 'select';
+    }
+    else if (selection === 2) {
+        return 'create';
+    }
+    else {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+}
+export async function promptProjectName(defaultName) {
+    const hint = defaultName ? ` (${defaultName})` : '';
+    const name = await prompt(`Enter project name${hint}: `);
+    const result = name || defaultName || '';
+    if (!result) {
+        console.error('Error: Project name is required.');
+        process.exit(1);
+    }
+    return result;
+}
+export async function promptSelectTemplate(templates) {
+    console.log('\nAvailable migration templates:');
+    console.log('-----------------------------');
+    templates.forEach((tmpl, index) => {
+        const desc = tmpl.description ? ` - ${tmpl.description}` : '';
+        console.log(`  ${index + 1}. ${tmpl.name}${desc}`);
+    });
+    console.log('');
+    const answer = await prompt(`Select a template (1-${templates.length}): `);
+    const selection = parseInt(answer, 10);
+    if (isNaN(selection) || selection < 1 || selection > templates.length) {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+    return templates[selection - 1].template_id;
+}