@controlfront/detect 0.0.1

package/src/commands/init.js

@@ -0,0 +1,309 @@
+import fs from "fs";
+import fetch from "node-fetch";
+import os from "os";
+import path from "path";
+import prompts from "prompts";
+import { fileURLToPath } from "url";
+
+// Polyfill for __dirname in ES modules:
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import { makeUrl, getStoredEnvironment } from "../config/baseUrl.js";
+
+function findGitRepoRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    const gitDir = path.join(dir, ".git");
+    if (fs.existsSync(gitDir)) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export async function runInit() {
+  console.log("🔧 Initializing ControlFront CLI...");
+  const configPath = path.join(os.homedir(), ".cf", "config.json");
+
+  if (!fs.existsSync(configPath)) {
+    console.log("🔐 You are not logged into ControlFront, running `cf login`...");
+    const { runLogin } = await import("./login.js");
+    await runLogin();
+    // After login, re-check config file exists
+    if (!fs.existsSync(configPath)) {
+      console.error(
+        "❌ ~/.cf/config.json still not found after login. Please check your login and try again."
+      );
+      process.exit(1);
+    }
+  }
+
+  const { token, environment } = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "x-cf-cli": "true"
+  };
+  
+  // Log current environment
+  const envDisplay = environment === 'prod' ? 'Production' : 'Development';
+  console.log(`🌐 Using ${envDisplay} environment`);
+
+  // Fetch workspaces
+  const workspaceRes = await fetch(makeUrl(`/api/cli/workspaces`), {
+    method: "GET",
+    headers,
+  });
+  const raw = await workspaceRes.text();
+
+  if (!workspaceRes.ok) {
+    console.error(`❌ API returned ${workspaceRes.status}: ${workspaceRes.statusText}`);
+    console.error("Response body:", raw);
+    process.exit(1);
+  }
+
+  let workspaces;
+  try {
+    workspaces = JSON.parse(raw);
+  } catch (err) {
+    console.error("❌ Failed to parse workspaces response as JSON:", raw);
+    process.exit(1);
+  }
+
+  if (Array.isArray(workspaces) && workspaces.length > 0 && workspaces[0].workspace_id && !workspaces[0].id) {
+    workspaces = workspaces.map(w => ({ id: w.workspace_id, name: w.name }));
+  }
+
+  let workspace;
+
+  // Build workspace choices for prompt
+  const workspaceChoices = (workspaces || []).map(w => ({
+    title: w.name || "(unnamed)",
+    value: w.id
+  }));
+
+  workspaceChoices.push({ title: "➕ Create a new workspace", value: "__create__" });
+
+  // Use environment from config we already loaded
+  const envDisplayPrompt = environment === 'prod' ? 'Production' : 'Development';
+
+  // Prompt user to select existing or create new
+  const wsResponse = await prompts({
+    type: "select",
+    name: "selectedWorkspaceId",
+    message: `Select a ${envDisplayPrompt} workspace to use (or create a new one):`,
+    choices: workspaceChoices
+  });
+
+  if (!wsResponse.selectedWorkspaceId) {
+    console.error("❌ No workspace selected. Aborting.");
+    process.exit(1);
+  }
+
+  if (wsResponse.selectedWorkspaceId === "__create__") {
+    const wsNameResponse = await prompts({
+      type: "text",
+      name: "workspaceName",
+      message: "Enter a name for the new workspace:",
+      initial: "Local"
+    });
+
+    if (!wsNameResponse.workspaceName) {
+      console.error("❌ No workspace name entered. Aborting.");
+      process.exit(1);
+    }
+
+    const createWorkspaceRes = await fetch(makeUrl(`/api/cli/workspaces`), {
+      method: "POST",
+      headers: {
+        ...headers,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ name: wsNameResponse.workspaceName.trim() }),
+    });
+
+    if (!createWorkspaceRes.ok) {
+      const errorText = await createWorkspaceRes.text();
+      console.error("❌ Failed to create workspace:", errorText);
+      process.exit(1);
+    }
+
+    workspace = await createWorkspaceRes.json();
+  } else {
+    // Use existing workspace
+    workspace = workspaces.find(w => w.id === wsResponse.selectedWorkspaceId);
+  }
+
+  const workspaceId = workspace.id || workspace.workspace_id;
+
+  // Fetch projects for the workspace
+  const projRes = await fetch(makeUrl(`/api/cli/workspaces/${workspaceId}/projects`), {
+    method: "GET",
+    headers,
+  });
+
+  const projects = await projRes.json();
+
+  if (!projRes.ok || !Array.isArray(projects)) {
+    console.error("❌ Failed to fetch projects:", projects);
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+  const repoRoot = findGitRepoRoot(cwd);
+  if (!repoRoot) {
+    console.error("❌ Cannot initialize: not inside a git repo.");
+    process.exit(1);
+  }
+  const cfGitFolder = path.join(repoRoot, ".git", "cf");
+  const projectJsonPath = path.join(cfGitFolder, "project.json");
+  if (!fs.existsSync(cfGitFolder)) {
+    fs.mkdirSync(cfGitFolder, { recursive: true });
+  }
+  const folderName = path.basename(cwd);
+
+  // If workspace exists but has no projects yet, provide helpful UX message
+  if (Array.isArray(projects) && projects.length === 0) {
+    let project;
+    console.log(`📭 Workspace "${workspace.name}" has no projects yet.`);
+    console.log("Let's create the first project for this workspace.\n");
+
+    const nameResponse = await prompts({
+      type: "text",
+      name: "projectName",
+      message: "Enter a name for the new project:",
+      initial: folderName,
+    });
+
+    if (!nameResponse.projectName) {
+      console.error("❌ No project name entered. Aborting.");
+      process.exit(1);
+    }
+
+    const createRes = await fetch(makeUrl(`/api/cli/workspaces/${workspaceId}/projects`), {
+      method: "POST",
+      headers: {
+        ...headers,
+        "Content-Type": "application/json",
+        "x-cf-cli": "true"
+      },
+      body: JSON.stringify({ name: nameResponse.projectName }),
+    });
+
+    if (!createRes.ok) {
+      const errorText = await createRes.text();
+      console.error("❌ Failed to create project:", errorText);
+      process.exit(1);
+    }
+
+    project = await createRes.json();
+
+    const normalizedWorkspace = { ...workspace, id: workspaceId };
+
+    // Write/update .git/cf/project.json
+    fs.writeFileSync(
+      projectJsonPath,
+      JSON.stringify({ workspace: normalizedWorkspace, project }, null, 2)
+    );
+
+    // Preserve environment when updating config
+    fs.writeFileSync(configPath, JSON.stringify({ token, environment }, null, 2));
+
+    console.log(`✅ Project "${project.name}" created and workspace initialized.`);
+    return { workspace, project };
+  }
+
+  let project;
+  // Check existing project.json for folder/project name mismatch or missing
+  if (fs.existsSync(projectJsonPath)) {
+    try {
+      const existingProjectJson = JSON.parse(fs.readFileSync(projectJsonPath, "utf8"));
+
+      // If project name matches folder name and project ID is in fetched projects, use it
+      if (
+        existingProjectJson.project?.name === folderName &&
+        projects.some((p) => p.id === existingProjectJson.project?.id)
+      ) {
+        project = existingProjectJson.project;
+        needProjectSelection = false;
+      } else {
+        console.warn(
+          "⚠️ project.json project name does not match this folder name or project not found on server."
+        );
+      }
+    } catch {
+      // Ignore parse errors and prompt user below
+    }
+  }
+
+  // If no valid project found, prompt user to select one
+  if (typeof needProjectSelection === "undefined" || needProjectSelection) {
+    // Always prompt user to select project from list with option to create new
+    const choices = projects.map((p) => ({
+      title: p.name,
+      value: p.id,
+    }));
+    choices.push({ title: "➕ Create a new project", value: "__create__" });
+
+    const response = await prompts({
+      type: "select",
+      name: "selectedProjectId",
+      message: "Select the ControlFront project to use for this folder:",
+      choices,
+    });
+
+    if (!response.selectedProjectId) {
+      console.error("❌ No project selected. Aborting.");
+      process.exit(1);
+    }
+
+    if (response.selectedProjectId === "__create__") {
+      const nameResponse = await prompts({
+        type: "text",
+        name: "projectName",
+        message: "Enter a name for the new project:",
+        initial: folderName,
+      });
+
+      if (!nameResponse.projectName) {
+        console.error("❌ No project name entered. Aborting.");
+        process.exit(1);
+      }
+
+      const createRes = await fetch(makeUrl(`/api/cli/workspaces/${workspaceId}/projects`), {
+        method: "POST",
+        headers: {
+          ...headers,
+          "Content-Type": "application/json",
+          "x-cf-cli": "true"
+        },
+        body: JSON.stringify({ name: nameResponse.projectName }),
+      });
+
+      if (!createRes.ok) {
+        const errorText = await createRes.text();
+        console.error("❌ Failed to create project:", errorText);
+        process.exit(1);
+      }
+
+      project = await createRes.json();
+    } else {
+      project = projects.find((p) => p.id === response.selectedProjectId);
+    }
+  }
+
+  const normalizedWorkspace = { ...workspace, id: workspaceId };
+
+  // Write/update .git/cf/project.json
+  fs.writeFileSync(
+    projectJsonPath,
+    JSON.stringify({ workspace: normalizedWorkspace, project }, null, 2)
+  );
+
+  // Preserve environment when updating config
+  fs.writeFileSync(configPath, JSON.stringify({ token, environment }, null, 2));
+
+
+  console.log(`✅ ControlFront CLI is initialized.`);
+  return { workspace, project };
+}

package/src/commands/login.js

@@ -0,0 +1,71 @@
+import crypto from "crypto";
+import fs from "fs";
+import fetch from "node-fetch";
+import open from "open";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import { resolveBaseUrlForEnv } from "../config/baseUrl.js";
+import { runInit } from "./init.js";
+
+// Polyfill for __dirname in ES modules:
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function runLogin(options = {}) {
+  const isProd = options.prod === true;
+  const environment = isProd ? "prod" : "dev";
+  
+  const code = crypto.randomBytes(16).toString("hex");
+  const cfDir = path.join(os.homedir(), ".cf");
+  const configPath = path.join(cfDir, "config.json");
+
+  if (!fs.existsSync(cfDir)) { fs.mkdirSync(cfDir, { recursive: true }); }
+
+  // Get the URL for the selected environment
+  const envUrl = resolveBaseUrlForEnv(environment);
+  
+  console.log(`🌐 Environment: ${isProd ? '🌐 Production' : '🏠 Development'} - ${envUrl}`);
+  console.log("🔐 Opening browser for login...");
+  
+  const makeEnvUrl = (pathAndQuery) => new URL(pathAndQuery, envUrl + "/").toString();
+  
+  const loginUrl = makeEnvUrl(`/sign-in?redirect_url=/cli-login?code=${code}`);
+  open(loginUrl);
+
+  console.log("⏳ Waiting for authentication...");
+
+  for (let i = 0; i < 30; i++) {
+    try {
+      const res = await fetch(makeEnvUrl(`/api/cli-login-status?code=${code}`));
+      const json = await res.json();
+
+      if (json.token) {
+        console.log("✅ Login successful. Saving credentials...");
+
+        const configData = { token: json.token, environment };
+        fs.writeFileSync(
+          configPath,
+          JSON.stringify(configData, null, 2),
+          'utf8'
+        );
+        
+        // Verify the save worked
+        const saved = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        console.log(`📝 Credentials saved to ~/.cf/config.json (${saved.environment === 'prod' ? 'Production' : 'Development'})`);
+        
+        // Auto-run init after successful login
+        console.log("\n🚀 Initializing project...\n");
+        await runInit();
+        
+        return;
+      }
+    } catch (err) {
+      console.error("❌ Polling error:", err);
+    }
+
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+
+  console.log("❌ Login timed out. Please try again.");
+}

package/src/commands/logout.js

@@ -0,0 +1,44 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+function findGitRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    const gitPath = path.join(dir, ".git");
+    if (fs.existsSync(gitPath) && fs.lstatSync(gitPath).isDirectory()) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export async function runLogout() {
+  const configPath = path.join(os.homedir(), ".cf", "config.json");
+
+  const gitRoot = findGitRoot(process.cwd());
+  let projectConfigPath = null;
+  if (gitRoot) {
+    projectConfigPath = path.join(gitRoot, ".git", "cf", "project.json");
+  }
+
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+    console.log("✅ Logged out and removed credentials.");
+  } else {
+    console.log("ℹ️ No credentials found. Already logged out.");
+  }
+
+  if (projectConfigPath && fs.existsSync(projectConfigPath)) {
+    try {
+      fs.unlinkSync(projectConfigPath);
+      console.log("✅ Removed project link (.git/cf/project.json).");
+    } catch (err) {
+      console.error("❌ Failed to remove project link:", err);
+    }
+  } else {
+    console.log("ℹ️ No project link found.");
+  }
+}