@asiyst/cli 1.0.8 → 1.1.1

package/dist/index.js

@@ -1,42 +1,414 @@
 #!/usr/bin/env node
 
-// src/ui/output.ts
-var ok = (label, detail = "") => console.log(`  \u2713 ${label}${detail ? ` (${detail})` : ""}`);
-var fail = (label, detail = "") => console.log(`  \u2717 ${label}${detail ? `: ${detail}` : ""}`);
-function projectChecks(project) {
-  project.packageJson ? ok("Project detected", typeof project.packageJson.name === "string" ? project.packageJson.name : project.cwd) : fail("Project not detected", "package.json is missing");
-  ok("Framework detected", project.framework);
-  ok("Language detected", project.language);
-  ok("Node.js detected", process.version);
-  ok("Package manager detected", project.packageManager);
-  project.sdkVersion ? ok("@asiyst/sdk detected", project.sdkVersion) : fail("@asiyst/sdk is not installed", "npm install @asiyst/sdk");
-}
-function homeStatus(project, connection = "Not connected") {
-  console.log("\n  PROJECT STATUS");
-  console.log(`    Project          ${typeof project.packageJson?.name === "string" ? project.packageJson.name : "Not detected"}`);
-  console.log(`    Framework        ${project.framework}`);
-  console.log(`    Language         ${project.language}`);
-  console.log(`    Node.js          ${process.version}`);
-  console.log(`    Package Manager  ${project.packageManager}`);
-  console.log(`    @asiyst/sdk      ${project.sdkVersion || "Not installed"}`);
-  console.log("\n  ASIYST STATUS");
-  console.log(`    Connection       ${connection}`);
-  console.log(`    Avatar           Not configured`);
-  console.log(`    AI Provider      Not configured`);
-  console.log(`    Project ID       ${project.config.projectId || "\u2014"}`);
-  if (connection === "Not connected") console.log("\n  Run 'connect' to link this project.");
-}
-function printVerification(results) {
-  console.log("\n  Asiyst Installation Verification\n");
-  for (const result of results) result.ok ? ok(result.name, result.detail) : fail(result.name, result.detail);
-  const success = results.length > 0 && results.every((result) => result.ok);
-  if (success) console.log("\n  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  ASIYST IS READY \u2713");
-  return success;
+// src/config/api.ts
+var PRODUCTION_API_ORIGIN = "https://nqhxpgsjofzqudyqkqib.supabase.co/functions/v1/api";
+var CLI_API_BASE_URL = PRODUCTION_API_ORIGIN;
+var VERIFY_KEY_PATH = "/auth/api-key/verify";
+var VERIFY_KEY_URL = `${CLI_API_BASE_URL}${VERIFY_KEY_PATH}`;
+var ASIYST_WEB_URL = "https://asiyst.com";
+var ASIIYST_WEB_URL = ASIYST_WEB_URL;
+var REQUEST_TIMEOUT_MS = 15e3;
+function readEnv(env, ...keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value) return value;
+  }
+  return void 0;
+}
+function isLocalUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+  } catch {
+    return /localhost|127\.0\.0\.1|::1/i.test(value);
+  }
+}
+function resolveApiBaseUrl(env = process.env) {
+  const explicit = readEnv(env, "ASIYST_API_URL", "ASIIYST_API_URL");
+  const development = readEnv(env, "ASIYST_API_MODE", "ASIIYST_API_MODE") === "development";
+  if (explicit) {
+    if (isLocalUrl(explicit)) {
+      return CLI_API_BASE_URL;
+    }
+    return explicit.replace(/\/+$/, "");
+  }
+  if (development) {
+    return CLI_API_BASE_URL;
+  }
+  return CLI_API_BASE_URL;
+}
+function isDebugEnabled(env = process.env) {
+  return readEnv(env, "ASIYST_DEBUG", "ASIIYST_DEBUG") === "1" || readEnv(env, "ASIYST_DEBUG", "ASIIYST_DEBUG") === "true";
+}
+
+// src/config/ids.ts
+var PUBLIC_IDENTIFIER_PATTERN = /^(?=.{1,128}$)[A-Za-z0-9_][A-Za-z0-9_-]*$/;
+var USER_ID_PATTERN = /^[A-Za-z0-9_]{24}$/;
+var AVATAR_ID_PATTERN = /^[A-Za-z0-9]{10}$/;
+function isValidPublicIdentifier(value) {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > 128) return false;
+  if (trimmed === "undefined" || trimmed === "null") return false;
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(trimmed)) {
+    return false;
+  }
+  return PUBLIC_IDENTIFIER_PATTERN.test(trimmed);
+}
+function isValidUserId(value) {
+  return typeof value === "string" && value.trim() !== "undefined" && value.trim() !== "null" && USER_ID_PATTERN.test(value.trim());
+}
+function isValidAvatarId(value) {
+  return typeof value === "string" && value.trim() !== "undefined" && value.trim() !== "null" && AVATAR_ID_PATTERN.test(value.trim());
+}
+function parseProjectIdArgument(argv = []) {
+  const length = argv.length;
+  for (let index = 0; index < length; index += 1) {
+    const entry = argv[index];
+    if (entry === "--project-id" || entry === "--projectId") {
+      const next = argv[index + 1];
+      return typeof next === "string" ? next : "";
+    }
+    if (entry.startsWith("--project-id=") || entry.startsWith("--projectId=")) {
+      return entry.slice(entry.indexOf("=") + 1);
+    }
+  }
+  return void 0;
+}
+
+// src/api/errors.ts
+var ApiError = class extends Error {
+  constructor(message, status, code = "UNKNOWN") {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiError";
+  }
+  status;
+  code;
+};
+function errorCodeFromStatus(status, bodyCode) {
+  if (bodyCode === "INVALID_API_KEY") return "INVALID_API_KEY";
+  if (bodyCode === "API_KEY_REVOKED") return "API_KEY_REVOKED";
+  if (bodyCode === "FORBIDDEN") return "FORBIDDEN";
+  if (bodyCode === "PROJECT_NOT_FOUND") return "PROJECT_NOT_FOUND";
+  if (bodyCode === "AVATAR_NOT_FOUND") return "AVATAR_NOT_FOUND";
+  if (bodyCode === "AVATAR_ALREADY_IMPORTED") return "AVATAR_ALREADY_IMPORTED";
+  if (bodyCode === "RATE_LIMITED") return "RATE_LIMITED";
+  if (bodyCode === "INTERNAL_ERROR") return "INTERNAL_ERROR";
+  if (status === 401) return "INVALID_API_KEY";
+  if (status === 403) return "FORBIDDEN";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "CONFLICT";
+  if (status === 400 || status === 422) return "INVALID_REQUEST";
+  if (status === 429) return "RATE_LIMITED";
+  if (status >= 500) return "INTERNAL_ERROR";
+  return "UNKNOWN";
+}
+function friendlyApiMessage(error, endpointUrl) {
+  if (error.code === "INVALID_API_KEY") return "\u2717 Invalid API key.";
+  if (error.code === "API_KEY_REVOKED") {
+    return "\u2717 This API key has been revoked.\nCreate a new key from:\nhttps://asiyst.com";
+  }
+  if (error.code === "FORBIDDEN") {
+    return "\u2717 This API key does not have permission to access this resource.";
+  }
+  if (error.code === "NOT_FOUND") {
+    return endpointUrl ? `\u2717 Asiyst API endpoint was not found.
+Verify that the CLI is using:
+${endpointUrl}` : "\u2717 Asiyst API endpoint was not found.";
+  }
+  if (error.code === "TIMEOUT") return "Connection to Asiyst timed out.";
+  if (error.code === "NETWORK") return "\u2717 Unable to reach Asiyst API.";
+  if (error.code === "MALFORMED_RESPONSE") return "Received an unexpected response from Asiyst.";
+  if (error.code === "RATE_LIMITED") return "\u2717 Too many requests. Try again shortly.";
+  if (error.code === "PROJECT_NOT_FOUND") return "\u2717 Authorized project was not found.";
+  if (error.code === "CONFLICT") return "\u2717 The request conflicts with the current project state.";
+  if (error.code === "INVALID_REQUEST") return "\u2717 The request was invalid.";
+  if (error.code === "AVATAR_NOT_FOUND") return "\u2717 Avatar was not found.";
+  if (error.code === "AVATAR_ALREADY_IMPORTED") return "\u2717 This avatar is already imported into the project.";
+  if (error.code === "INTERNAL_ERROR") return "\u2717 Asiyst is temporarily unavailable.";
+  return "\u2717 Asiyst request failed.";
+}
+
+// src/api/auth.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function bearerToken(apiKey) {
+  const trimmed = apiKey.trim();
+  return trimmed.toLowerCase().startsWith("bearer ") ? trimmed.slice(7).trim() : trimmed;
+}
+function projectFromBody(body) {
+  const nested = asRecord(body.project) ?? asRecord(body.data);
+  const nestedProject = nested ? asRecord(nested.project) ?? nested : void 0;
+  return nestedProject ?? body;
+}
+function parseVerifyKeyResponse(value, apiKey) {
+  const body = asRecord(value);
+  if (!body) throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  if (body.valid === false) {
+    const code = typeof body.code === "string" ? body.code : void 0;
+    if (code === "API_KEY_REVOKED" || body.revoked === true) {
+      throw new ApiError("This API key has been revoked.", 401, "API_KEY_REVOKED");
+    }
+    throw new ApiError("The Asiyst API key was rejected.", 401, "INVALID_API_KEY");
+  }
+  if (body.valid !== void 0 && body.valid !== true) {
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  }
+  const project = projectFromBody(body);
+  if (!project) throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  const projectIdCandidate = project.projectId ?? project.project_id ?? project.projectID ?? project.id;
+  const projectId = typeof projectIdCandidate === "string" && isValidPublicIdentifier(projectIdCandidate) ? projectIdCandidate.trim() : void 0;
+  if (!projectId) {
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  }
+  const website = project.website ?? project.websiteUrl ?? project.url ?? project.domain ?? project.website_url;
+  const projectName = project.projectName ?? project.name ?? project.title;
+  const publicKey = project.publicKey ?? project.public_key ?? project.publishableKey;
+  const userId = project.userId ?? project.user_id ?? project.asiystUserId ?? project.asiyst_user_id ?? body.userId ?? body.user_id ?? body.asiystUserId ?? body.asiyst_user_id;
+  return {
+    projectId,
+    projectName: typeof projectName === "string" ? projectName : void 0,
+    website: typeof website === "string" ? website : void 0,
+    publicKey: typeof publicKey === "string" ? publicKey : void 0,
+    apiKey,
+    userId: typeof userId === "string" && isValidPublicIdentifier(userId) ? userId : void 0
+  };
+}
+async function verifyApiKey(api, apiKey, expected) {
+  const token = bearerToken(apiKey);
+  if (!token) throw new ApiError("Invalid API key.", 401, "INVALID_API_KEY");
+  const value = await api.request(VERIFY_KEY_PATH, {
+    method: "POST",
+    headers: {
+      Authorization: "Bearer " + token,
+      "X-Asiyst-API-Key": token
+    },
+    body: JSON.stringify({
+      apiKey: token,
+      ...expected?.userId ? { userId: expected.userId } : {},
+      ...expected?.projectId ? { projectId: expected.projectId } : {}
+    })
+  });
+  return parseVerifyKeyResponse(value, token);
+}
+
+// src/browser/open.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function openBrowser(url) {
+  const command = process.platform === "win32" ? "rundll32.exe" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+  try {
+    await execFileAsync(command, args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/config/credentials.ts
+import { execFile as execFile2 } from "child_process";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+function configDir() {
+  if (process.platform === "win32") return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "asiyst");
+  if (process.platform === "darwin") return join(homedir(), "Library", "Application Support", "asiyst");
+  return join(homedir(), ".config", "asiyst");
+}
+function storePath() {
+  return join(configDir(), "credentials.json");
+}
+function accountFor(cwd) {
+  return resolve(cwd);
+}
+function readStore() {
+  const path = storePath();
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function writeStore(data) {
+  mkdirSync(configDir(), { recursive: true, mode: 448 });
+  writeFileSync(storePath(), JSON.stringify(data, null, 2), { encoding: "utf8", mode: 384 });
+}
+async function dpapiProtect(plaintext) {
+  if (process.platform !== "win32") return void 0;
+  const script = [
+    "Add-Type -AssemblyName System.Security",
+    "$bytes = [System.Text.Encoding]::UTF8.GetBytes($env:ASIYST_DPAPI_PAYLOAD)",
+    "$protected = [System.Security.Cryptography.ProtectedData]::Protect($bytes, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)",
+    "[Convert]::ToBase64String($protected)"
+  ].join("; ");
+  try {
+    const { stdout: stdout3 } = await execFileAsync2("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+      env: { ...process.env, ASIYST_DPAPI_PAYLOAD: plaintext },
+      windowsHide: true
+    });
+    const value = stdout3.trim();
+    return value || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function dpapiUnprotect(payload) {
+  if (process.platform !== "win32") return void 0;
+  const script = [
+    "Add-Type -AssemblyName System.Security",
+    "$protected = [Convert]::FromBase64String($env:ASIYST_DPAPI_PAYLOAD)",
+    "$bytes = [System.Security.Cryptography.ProtectedData]::Unprotect($protected, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)",
+    "[System.Text.Encoding]::UTF8.GetString($bytes)"
+  ].join("; ");
+  try {
+    const { stdout: stdout3 } = await execFileAsync2("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+      env: { ...process.env, ASIYST_DPAPI_PAYLOAD: payload },
+      windowsHide: true
+    });
+    const value = stdout3.trim();
+    return value || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function windowsBlobPath() {
+  return join(configDir(), "credentials.dpapi");
+}
+async function saveConnection(cwd, connection) {
+  const account = accountFor(cwd);
+  const next = { ...readStore(), [account]: connection };
+  if (process.platform === "win32") {
+    const protectedBlob = await dpapiProtect(JSON.stringify(next));
+    if (protectedBlob) {
+      mkdirSync(configDir(), { recursive: true, mode: 448 });
+      writeFileSync(windowsBlobPath(), protectedBlob, { encoding: "utf8", mode: 384 });
+      if (existsSync(storePath())) unlinkSync(storePath());
+      return;
+    }
+  }
+  writeStore(next);
+}
+async function loadConnection(cwd) {
+  const account = accountFor(cwd);
+  if (process.platform === "win32" && existsSync(windowsBlobPath())) {
+    const decrypted = await dpapiUnprotect(readFileSync(windowsBlobPath(), "utf8"));
+    if (decrypted) {
+      try {
+        const parsed = JSON.parse(decrypted);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          const entry2 = parsed[account];
+          if (entry2 && typeof entry2.apiKey === "string" && typeof entry2.projectId === "string") return entry2;
+        }
+      } catch {
+        return void 0;
+      }
+    }
+  }
+  const entry = readStore()[account];
+  if (entry && typeof entry.apiKey === "string" && typeof entry.projectId === "string") return entry;
+  return void 0;
+}
+async function clearConnection(cwd) {
+  const account = accountFor(cwd);
+  if (process.platform === "win32" && existsSync(windowsBlobPath())) {
+    const decrypted = await dpapiUnprotect(readFileSync(windowsBlobPath(), "utf8"));
+    let next2 = {};
+    if (decrypted) {
+      try {
+        const parsed = JSON.parse(decrypted);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) next2 = { ...parsed };
+      } catch {
+        next2 = {};
+      }
+    }
+    delete next2[account];
+    if (Object.keys(next2).length === 0) {
+      unlinkSync(windowsBlobPath());
+      return;
+    }
+    const protectedBlob = await dpapiProtect(JSON.stringify(next2));
+    if (protectedBlob) {
+      writeFileSync(windowsBlobPath(), protectedBlob, { encoding: "utf8", mode: 384 });
+      return;
+    }
+  }
+  const next = readStore();
+  delete next[account];
+  if (Object.keys(next).length === 0 && existsSync(storePath())) unlinkSync(storePath());
+  else writeStore(next);
+}
+
+// src/config/project.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+var PROJECT_CONFIG_DIR = ".asiyst";
+var PROJECT_CONFIG_FILE = "config.json";
+function projectConfigPath(cwd) {
+  return join2(resolve2(cwd), PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+}
+function readProjectMetadata(cwd) {
+  const path = projectConfigPath(cwd);
+  if (!existsSync2(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    const body = parsed;
+    if (typeof body.apiKey === "string") delete body.apiKey;
+    return {
+      projectId: typeof body.projectId === "string" ? body.projectId : void 0,
+      projectName: typeof body.projectName === "string" ? body.projectName : void 0,
+      website: typeof body.website === "string" ? body.website : void 0,
+      publicKey: typeof body.publicKey === "string" ? body.publicKey : void 0,
+      userId: typeof body.userId === "string" ? body.userId : void 0,
+      avatarId: typeof body.avatarId === "string" ? body.avatarId : void 0,
+      connected: body.connected === true
+    };
+  } catch {
+    return void 0;
+  }
+}
+function writeProjectMetadata(cwd, connection) {
+  const dir = join2(resolve2(cwd), PROJECT_CONFIG_DIR);
+  mkdirSync2(dir, { recursive: true });
+  const existing = readProjectMetadata(cwd) ?? {};
+  const next = {
+    ...existing,
+    projectId: connection.projectId,
+    projectName: connection.projectName,
+    website: connection.website,
+    publicKey: connection.publicKey,
+    userId: connection.userId,
+    avatarId: connection.avatarId,
+    connected: true
+  };
+  writeFileSync2(projectConfigPath(cwd), `${JSON.stringify(next, null, 2)}
+`, { encoding: "utf8" });
+}
+function clearProjectMetadata(cwd) {
+  const path = projectConfigPath(cwd);
+  if (!existsSync2(path)) return;
+  const existing = readProjectMetadata(cwd) ?? {};
+  const next = {
+    ...existing,
+    connected: false
+  };
+  writeFileSync2(path, `${JSON.stringify(next, null, 2)}
+`, { encoding: "utf8" });
 }
 
 // src/detection/project.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
 function dependencyVersion(pkg) {
   const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
   for (const section of sections) {
@@ -48,30 +420,37 @@ function dependencyVersion(pkg) {
   }
   return void 0;
 }
+function hasDependency(deps, name) {
+  return typeof deps[name] === "string";
+}
 function detectFramework(cwd, pkg) {
   const deps = Object.assign({}, pkg?.dependencies, pkg?.devDependencies);
-  if (typeof deps.next === "string") return "Next.js";
-  if (typeof deps.react === "string") return "React";
-  if (typeof deps.vite === "string") return "Vite";
-  if (typeof deps.vue === "string") return "Vue";
-  if (existsSync(resolve(cwd, "vite.config.ts")) || existsSync(resolve(cwd, "vite.config.js"))) return "Vite";
-  if (existsSync(resolve(cwd, "next.config.js")) || existsSync(resolve(cwd, "next.config.mjs"))) return "Next.js";
-  return "Vanilla JavaScript/TypeScript";
+  if (hasDependency(deps, "next") || existsSync3(resolve3(cwd, "next.config.js")) || existsSync3(resolve3(cwd, "next.config.mjs")) || existsSync3(resolve3(cwd, "next.config.ts"))) {
+    return "Next.js";
+  }
+  if (hasDependency(deps, "nuxt")) return "Nuxt";
+  if (hasDependency(deps, "vue") || existsSync3(resolve3(cwd, "vue.config.js"))) return "Vue";
+  if (hasDependency(deps, "react")) return "React";
+  if (hasDependency(deps, "vite") || existsSync3(resolve3(cwd, "vite.config.ts")) || existsSync3(resolve3(cwd, "vite.config.js")) || existsSync3(resolve3(cwd, "vite.config.mjs"))) {
+    return "Vite";
+  }
+  if (pkg) return existsSync3(resolve3(cwd, "tsconfig.json")) ? "Vanilla TypeScript" : "Vanilla JavaScript";
+  return "Unknown";
 }
 function detectProject(cwd = process.cwd()) {
-  const path = resolve(cwd, "package.json");
+  const path = resolve3(cwd, "package.json");
   let packageJson = null;
-  if (existsSync(path)) {
+  if (existsSync3(path)) {
     try {
-      const value = JSON.parse(readFileSync(path, "utf8"));
+      const value = JSON.parse(readFileSync3(path, "utf8"));
       if (value && typeof value === "object" && !Array.isArray(value)) packageJson = value;
     } catch {
       packageJson = null;
     }
   }
   const env = process.env;
-  const packageManager = existsSync(resolve(cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync(resolve(cwd, "yarn.lock")) ? "yarn" : existsSync(resolve(cwd, "bun.lockb")) || existsSync(resolve(cwd, "bun.lock")) ? "bun" : "npm";
-  const sourceFiles = ["tsconfig.json", "src", "app"].some((entry) => existsSync(resolve(cwd, entry)));
+  const packageManager = existsSync3(resolve3(cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync3(resolve3(cwd, "yarn.lock")) ? "yarn" : existsSync3(resolve3(cwd, "bun.lockb")) || existsSync3(resolve3(cwd, "bun.lock")) ? "bun" : "npm";
+  const sourceFiles = ["tsconfig.json", "src", "app"].some((entry) => existsSync3(resolve3(cwd, entry)));
   return {
     cwd,
     packageJson,
@@ -86,263 +465,298 @@ function detectProject(cwd = process.cwd()) {
   };
 }
 
-// src/config/api.ts
-var CLI_API_BASE_URL = "https://asiyst.com/api/v1";
-var ASIIYST_WEB_URL = "https://asiyst.com";
+// src/ui/output.ts
+var ok = (label, detail = "") => console.log(`\u2713 ${label}${detail ? ` (${detail})` : ""}`);
+var fail = (label, detail = "") => console.log(`\u2717 ${label}${detail ? `: ${detail}` : ""}`);
+function projectChecks(project) {
+  project.packageJson ? ok("Project detected", typeof project.packageJson.name === "string" ? project.packageJson.name : project.cwd) : fail("Project not detected", "package.json is missing");
+  if (project.framework === "Unknown") fail("Framework detected", "No supported project type was identified.");
+  else ok("Framework detected", project.framework);
+  ok("Language detected", project.language);
+  ok("Node.js detected", process.version);
+  ok("Package manager detected", project.packageManager);
+  project.sdkVersion ? ok("@asiyst/sdk detected", project.sdkVersion) : console.log("@asiyst/sdk is not installed. You can connect the project now and install the SDK later.");
+}
+function homeStatus() {
+  console.log("\nConnect your project to Asiyst to view stats.\n");
+}
 
-// src/api/client.ts
-var ApiError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "ApiError";
-  }
-  status;
-};
-var ApiClient = class {
-  constructor(baseUrl = process.env.ASIIYST_API_URL || CLI_API_BASE_URL, fetcher = fetch) {
-    this.fetcher = fetcher;
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
+// src/ui/selector.ts
+import { stdin, stdout } from "process";
+import { clearLine, cursorTo, emitKeypressEvents, moveCursor } from "readline";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+function moveSelection(active, optionCount, direction) {
+  if (optionCount === 0) return 0;
+  return direction === "up" ? Math.max(0, active - 1) : Math.min(optionCount - 1, active + 1);
+}
+function clearSelectorFrame(output, previousLineCount) {
+  if (previousLineCount <= 0) return;
+  cursorTo(output, 0);
+  for (let i = 0; i < previousLineCount - 1; i += 1) {
+    moveCursor(output, 0, -1);
   }
-  fetcher;
-  baseUrl;
-  async request(path, init) {
-    let response;
-    try {
-      response = await this.fetcher(`${this.baseUrl}${path}`, {
-        ...init,
-        headers: { Accept: "application/json", "Content-Type": "application/json", ...init?.headers }
-      });
-    } catch (error) {
-      throw new ApiError(`Unable to reach Asiyst API at ${this.baseUrl}${path}. Check your internet connection, DNS, TLS/HTTPS, or whether the service is unavailable.`);
-    }
-    const body = await response.json().catch(() => void 0);
-    if (!response.ok) {
-      const detail = response.status === 401 ? "Authentication is required." : response.status === 403 ? "The request is not authorized." : response.status === 404 ? "The requested resource was not found." : response.status === 409 ? "The request conflicts with the current project state." : response.status === 422 ? "The request data was invalid." : response.status === 429 ? "Too many requests; try again shortly." : response.status >= 500 ? "Asiyst is temporarily unavailable." : "The request was rejected.";
-      throw new ApiError(`Asiyst API returned HTTP ${response.status}. ${detail}`, response.status);
-    }
-    if (body === void 0) {
-      throw new ApiError(`Asiyst API returned an invalid JSON response (HTTP ${response.status}).`, response.status);
+  for (let line = 0; line < previousLineCount; line += 1) {
+    cursorTo(output, 0);
+    clearLine(output, 0);
+    if (line < previousLineCount - 1) {
+      moveCursor(output, 0, 1);
     }
-    return body;
   }
-  health() {
-    return this.request("/health").then((body) => {
-      if (!body || typeof body !== "object" || Array.isArray(body)) {
-        throw new ApiError("Asiyst API health endpoint returned an invalid response.");
-      }
-      return body;
-    });
-  }
-  createSession() {
-    return this.request("/cli/sessions", { method: "POST", body: JSON.stringify({}) }).then((value) => {
-      if (!value || typeof value !== "object") throw new ApiError("Asiyst returned an invalid session response");
-      const session = value;
-      if (typeof session.sessionId !== "string" || typeof session.connectUrl !== "string" || typeof session.expiresAt !== "string") {
-        throw new ApiError("Asiyst returned an invalid session response");
-      }
-      const url = new URL(session.connectUrl);
-      if (url.protocol !== "https:") {
-        throw new ApiError("Asiyst returned an insecure connection URL");
-      }
-      return { sessionId: session.sessionId, connectUrl: url.toString(), expiresAt: session.expiresAt };
-    });
-  }
-  sessionStatus(sessionId) {
-    return this.request(`/cli/sessions/${encodeURIComponent(sessionId)}/status`);
+  cursorTo(output, 0);
+  for (let i = 0; i < previousLineCount - 1; i += 1) {
+    moveCursor(output, 0, -1);
   }
-  projectInfo(projectId) {
-    return this.request(`/cli/projects/${encodeURIComponent(projectId)}`);
-  }
-  verify(projectId, publicKey, domain) {
-    return this.request("/cli/verification", {
-      method: "POST",
-      body: JSON.stringify({ projectId, publicKey, domain })
-    }).then((value) => {
-      if (!Array.isArray(value) || !value.every((item) => item && typeof item === "object" && typeof item.name === "string" && typeof item.ok === "boolean")) {
-        throw new ApiError("Asiyst returned an invalid verification response");
-      }
-      return value;
-    });
+}
+function renderSelectorFrame(output, previousLineCount, lines) {
+  if (lines.length === 0) return 0;
+  if (previousLineCount > 0) {
+    cursorTo(output, 0);
+    for (let i = 0; i < previousLineCount - 1; i += 1) {
+      moveCursor(output, 0, -1);
+    }
   }
-};
-
-// src/config/local.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-function configWarning(cwd) {
-  const envPath = resolve2(cwd, ".env");
-  if (existsSync2(envPath)) {
-    const ignored = existsSync2(resolve2(cwd, ".gitignore")) && readFileSync2(resolve2(cwd, ".gitignore"), "utf8").split(/\r?\n/).some((line) => line.trim() === ".env" || line.trim() === ".env.*");
-    if (!ignored) return "Your .env file is not clearly ignored by .gitignore; do not commit public or private configuration accidentally.";
+  for (let i = 0; i < lines.length; i += 1) {
+    cursorTo(output, 0);
+    clearLine(output, 0);
+    output.write(lines[i]);
+    if (i < lines.length - 1) {
+      output.write("\n");
+    }
   }
-  return void 0;
+  return lines.length;
 }
-
-// src/browser/open.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-async function openBrowser(url) {
-  const command = process.platform === "win32" ? "rundll32.exe" : process.platform === "darwin" ? "open" : "xdg-open";
-  const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
-  try {
-    await execFileAsync(command, args);
-    return true;
-  } catch {
-    return false;
-  }
+function restoreTerminal(wasRaw) {
+  stdout.write(SHOW_CURSOR);
+  if (stdin.isTTY) stdin.setRawMode?.(wasRaw);
 }
-
-// src/ui/selector.ts
-import { stdin, stdout } from "process";
-import { emitKeypressEvents } from "readline";
-var escape = "\x1B[";
-var width = () => Math.max(40, (stdout.columns || 80) - 2);
-var fit = (value) => value.length > width() ? `${value.slice(0, width() - 1)}\u2026` : value;
-function selectOption(title, options, prompt = "> ") {
-  if (!stdin.isTTY || !stdout.isTTY) return Promise.resolve({ type: "cancelled", input: "" });
-  return new Promise((resolve4) => {
-    let input = "";
+function selectOption(title, options) {
+  if (!stdin.isTTY || !stdout.isTTY) return Promise.resolve({ type: "cancelled" });
+  return new Promise((resolve5) => {
     let active = 0;
-    let visible = true;
     let renderedLines = 0;
     let settled = false;
-    const filtered = () => {
-      const query = input.trim().toLowerCase();
-      return query ? options.filter((option) => option.label.toLowerCase().includes(query) || String(option.value).toLowerCase().includes(query)) : options;
-    };
-    const clear = () => {
-      if (renderedLines === 0) return;
-      stdout.write(`${escape}${renderedLines}A`);
-      for (let line = 0; line < renderedLines; line += 1) stdout.write(`${escape}2K${line < renderedLines - 1 ? `${escape}1B` : ""}`);
-      stdout.write(`${escape}${renderedLines}A`);
-    };
-    const render = () => {
-      clear();
-      const matches = filtered();
-      if (active >= matches.length) active = Math.max(0, matches.length - 1);
-      const lines = [`${title}`, `${prompt}${fit(input)}`];
-      if (visible) {
-        if (matches.length === 0) lines.push("  No matching commands.");
-        else lines.push(...matches.map((option, index) => `${index === active ? "\u276F" : " "} ${fit(option.label)}`));
-        lines.push("\u2191\u2193 Navigate  Enter Select  Esc Cancel");
-      }
-      stdout.write(`${lines.join("\n")}
-`);
-      renderedLines = lines.length;
-    };
-    const finish = (result) => {
+    const wasRaw = Boolean(stdin.isRaw);
+    const enabled = options.filter((option) => !option.disabled);
+    const finish = (result, confirmation) => {
       if (settled) return;
       settled = true;
       stdin.off("keypress", onKeypress);
-      clear();
-      stdin.setRawMode?.(false);
+      clearSelectorFrame(stdout, renderedLines);
+      restoreTerminal(wasRaw);
       stdin.pause();
-      stdout.write("\n");
-      resolve4(result);
+      if (confirmation) stdout.write(`${confirmation}
+`);
+      resolve5(result);
+    };
+    const render = () => {
+      const lines = [title, "", ...enabled.map((option, index) => `${index === active ? "\u276F" : " "} ${option.label}`)];
+      renderedLines = renderSelectorFrame(stdout, renderedLines, lines);
     };
-    const onKeypress = (value, key) => {
-      if (key.ctrl && key.name === "c") return finish({ type: "cancelled", input });
-      if (key.ctrl && key.name === "d") return finish({ type: "exit", input });
-      if (key.name === "escape") {
-        return finish({ type: "cancelled", input });
+    const onKeypress = (_value, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") {
+        clearSelectorFrame(stdout, renderedLines);
+        restoreTerminal(wasRaw);
+        stdin.pause();
+        stdout.write("\n");
+        process.exit(130);
       }
+      if (key.name === "escape") return finish({ type: "cancelled" });
       if (key.name === "up" || key.name === "down") {
-        const matches = filtered();
-        if (matches.length > 0) active = key.name === "up" ? (active + matches.length - 1) % matches.length : (active + 1) % matches.length;
-        visible = true;
+        active = moveSelection(active, enabled.length, key.name);
         return render();
       }
       if (key.name === "return" || key.name === "enter") {
-        const matches = filtered();
-        const selected = matches[active];
-        if (selected) return finish({ type: "selected", value: selected.value, input });
-        return finish({ type: "cancelled", input });
-      }
-      if (key.name === "tab") {
-        const matches = filtered();
-        if (matches.length === 1) input = matches[0].value;
-        else if (matches.length > 1) active = (active + 1) % matches.length;
-        visible = true;
-        return render();
-      }
-      if (key.name === "backspace") {
-        input = input.slice(0, -1);
-        visible = true;
-        return render();
-      }
-      const sequence = key.sequence || value;
-      if (/^[\x20-\x7e]+$/.test(sequence)) {
-        input += sequence;
-        active = 0;
-        visible = true;
-        return render();
+        const selected = enabled[active];
+        if (!selected) return finish({ type: "cancelled" });
+        return finish({ type: "selected", value: selected.value }, `\u2713 ${selected.label} selected.`);
       }
     };
     emitKeypressEvents(stdin);
     stdin.setRawMode?.(true);
     stdin.resume();
+    stdout.write(HIDE_CURSOR);
     stdin.on("keypress", onKeypress);
     render();
   });
 }
 
-// src/commands/shared.ts
-async function connect(api = new ApiClient()) {
-  await api.health();
-  const session = await api.createSession();
-  console.log(`Opening Asiyst...
-${session.connectUrl}`);
-  if (!await openBrowser(session.connectUrl)) console.log("Automatic browser opening failed; open the URL above.");
-  console.log("\u25CF Waiting for authentication\n\u25CF Waiting for project selection\n\u25CF Waiting for connection");
-  const expires = Date.parse(session.expiresAt);
-  for (; ; ) {
-    const result = await api.sessionStatus(session.sessionId);
-    if (result.state === "completed") return { session, project: result.project };
-    if (result.state === "expired") throw new Error("Connection session expired.");
-    if (result.state === "cancelled") throw new Error("Connection session was cancelled.");
-    if (Number.isFinite(expires) && Date.now() >= expires) throw new Error("Connection session expired.");
-    await new Promise((resolve4) => setTimeout(resolve4, 2e3));
-  }
+// src/ui/secret.ts
+import { stdin as stdin2, stdout as stdout2 } from "process";
+import { emitKeypressEvents as emitKeypressEvents2 } from "readline";
+async function readSecret(prompt) {
+  if (!stdin2.isTTY) return void 0;
+  return new Promise((resolve5) => {
+    let value = "";
+    let settled = false;
+    const wasRaw = Boolean(stdin2.isRaw);
+    stdout2.write(prompt);
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      stdin2.off("keypress", onKeypress);
+      if (stdin2.isTTY) stdin2.setRawMode?.(wasRaw);
+      stdin2.pause();
+      stdout2.write("\n");
+      resolve5(result);
+    };
+    const onKeypress = (chunk, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") {
+        finish(void 0);
+        process.exit(130);
+      }
+      if (key.name === "escape") return finish(void 0);
+      if (key.name === "return" || key.name === "enter") return finish(value.trim());
+      if (key.name === "backspace") {
+        value = value.slice(0, -1);
+        return;
+      }
+      const sequence = key.sequence || chunk;
+      if (sequence && /^[\x20-\x7e]+$/.test(sequence)) value += sequence;
+    };
+    emitKeypressEvents2(stdin2);
+    stdin2.setRawMode?.(true);
+    stdin2.resume();
+    stdin2.on("keypress", onKeypress);
+  });
 }
-async function confirm(question) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return true;
-  const result = await selectOption(question, [
-    { label: "Yes", value: true },
-    { label: "No", value: false }
-  ]);
-  return result.type === "selected" && result.value;
+async function readInput(prompt) {
+  if (!stdin2.isTTY) return void 0;
+  return new Promise((resolve5) => {
+    let value = "";
+    const onData = (chunk) => {
+      value += String(chunk);
+      const newline = value.search(/[\r\n]/);
+      if (newline >= 0) {
+        stdin2.off("data", onData);
+        resolve5(value.slice(0, newline).trim());
+      }
+    };
+    stdout2.write(prompt);
+    stdin2.resume();
+    stdin2.on("data", onData);
+  });
 }
 
 // src/config/trust.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join, resolve as resolve3 } from "path";
-var trustFile = join(homedir(), ".config", "asiyst", "trusted-folders.json");
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve4 } from "path";
+var trustFile = join3(homedir2(), ".config", "asiyst", "trusted-folders.json");
 function readTrusted() {
-  if (!existsSync3(trustFile)) return [];
+  if (!existsSync4(trustFile)) return [];
   try {
-    const parsed = JSON.parse(readFileSync3(trustFile, "utf8"));
+    const parsed = JSON.parse(readFileSync4(trustFile, "utf8"));
     return Array.isArray(parsed) && parsed.every((item) => typeof item === "string") ? parsed : [];
   } catch {
     return [];
   }
 }
 function isTrusted(cwd) {
-  return readTrusted().includes(resolve3(cwd));
+  return readTrusted().includes(resolve4(cwd));
 }
 function trustFolder(cwd) {
-  const folder = resolve3(cwd);
+  const folder = resolve4(cwd);
   const trusted = readTrusted();
   if (!trusted.includes(folder)) trusted.push(folder);
-  mkdirSync(join(homedir(), ".config", "asiyst"), { recursive: true, mode: 448 });
-  writeFileSync(trustFile, JSON.stringify(trusted, null, 2), { encoding: "utf8", mode: 384 });
+  mkdirSync3(join3(homedir2(), ".config", "asiyst"), { recursive: true, mode: 448 });
+  writeFileSync3(trustFile, JSON.stringify(trusted, null, 2), { encoding: "utf8", mode: 384 });
 }
 function revokeTrust(cwd) {
-  const folder = resolve3(cwd);
+  const folder = resolve4(cwd);
   const trusted = readTrusted().filter((item) => item !== folder);
-  if (existsSync3(trustFile)) writeFileSync(trustFile, JSON.stringify(trusted, null, 2), { encoding: "utf8", mode: 384 });
+  if (existsSync4(trustFile)) writeFileSync3(trustFile, JSON.stringify(trusted, null, 2), { encoding: "utf8", mode: 384 });
+}
+
+// src/api/client.ts
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function bodyErrorCode(body) {
+  const record = asRecord2(body);
+  const code = record?.code ?? record?.errorCode ?? asRecord2(record?.error)?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+var ApiClient = class {
+  constructor(baseUrl = resolveApiBaseUrl(), fetcher = fetch) {
+    this.fetcher = fetcher;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  fetcher;
+  baseUrl;
+  async request(path, init) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    const headers = new Headers(init?.headers);
+    headers.set("Accept", "application/json");
+    if (!headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+    let response;
+    try {
+      response = await this.fetcher(url, {
+        ...init,
+        headers,
+        signal: init?.signal || controller.signal
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw new ApiError("Connection to Asiyst timed out.", void 0, "TIMEOUT");
+      }
+      throw new ApiError("Unable to reach Asiyst API.", void 0, "NETWORK");
+    } finally {
+      clearTimeout(timeout);
+    }
+    const rawText = await response.text();
+    let body;
+    if (rawText) {
+      try {
+        body = JSON.parse(rawText);
+      } catch {
+        body = void 0;
+      }
+    }
+    if (!response.ok) {
+      const code = errorCodeFromStatus(response.status, bodyErrorCode(body));
+      if (code === "API_KEY_REVOKED" || bodyErrorCode(body) === "API_KEY_REVOKED") {
+        throw new ApiError("This API key has been revoked.", response.status, "API_KEY_REVOKED");
+      }
+      throw new ApiError(`Asiyst API returned HTTP ${response.status}.`, response.status, code);
+    }
+    if (rawText && body === void 0) {
+      if (isDebugEnabled()) {
+        throw new ApiError("Asiyst API returned an invalid JSON response.", response.status, "MALFORMED_RESPONSE");
+      }
+      throw new ApiError("Received an unexpected response from Asiyst.", response.status, "MALFORMED_RESPONSE");
+    }
+    return body === void 0 ? {} : body;
+  }
+  async health() {
+    try {
+      const body = await this.request("/health");
+      const record = asRecord2(body);
+      if (record) return record;
+    } catch {
+    }
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  }
+};
+
+// src/commands/shared.ts
+async function confirm(question) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const result = await selectOption(question, [
+    { label: "Yes", value: true },
+    { label: "No", value: false }
+  ]);
+  return result.type === "selected" && result.value;
+}
+function createApiClient() {
+  return new ApiClient();
 }
 
 // src/commands/trust.ts
@@ -368,63 +782,280 @@ function revokeTrustCommand(cwd = process.cwd()) {
   console.log("\u2713 Folder trust revoked.");
 }
 
-// src/commands/init.ts
-async function initCommand(cwd = process.cwd(), api = new ApiClient()) {
+// src/commands/connect.ts
+async function retryOrCancel(message) {
+  console.log(message);
+  const result = await selectOption("Options:", [
+    { label: "Retry", value: true },
+    { label: "Cancel", value: false }
+  ]);
+  return result.type === "selected" && result.value;
+}
+function printApiFailure(error) {
+  if (error instanceof ApiError) {
+    return friendlyApiMessage(error, error.code === "NOT_FOUND" ? VERIFY_KEY_URL : void 0);
+  }
+  if (isDebugEnabled() && error instanceof Error) return `\u2717 ${error.message}`;
+  return "\u2717 Unable to reach Asiyst API.";
+}
+async function promptForProjectId() {
+  const value = await readInput("Enter your Project ID: ");
+  if (value === void 0) {
+    console.log("Connection cancelled.");
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    console.log("Project ID is required. Use: asiyst connect --project-id <PROJECT_ID>");
+    return void 0;
+  }
+  return trimmed;
+}
+async function promptForUserId() {
+  const value = await readInput("Enter your Asiyst User ID: ");
+  if (value === void 0) {
+    console.log("Connection cancelled.");
+    return void 0;
+  }
+  if (!isValidUserId(value)) {
+    console.log("Invalid User ID. It must be a 24-character public Asiyst account ID.");
+    return void 0;
+  }
+  return value.trim();
+}
+async function connectCommand(cwd = process.cwd(), api = createApiClient(), cliProjectId) {
+  console.log(`Project folder:
+${cwd}`);
   if (!await ensureTrusted(cwd)) return;
   const project = detectProject(cwd);
-  if (!project.packageJson) throw new Error("No package.json found. Run this command from your website project.");
-  console.log(`Detected ${project.framework} project.`);
-  if (!project.sdkVersion) {
-    console.log("\n@asiyst/sdk is not installed.\nRun: npm install @asiyst/sdk");
+  projectChecks(project);
+  if (project.framework === "Unknown") {
+    console.log("No supported framework was detected in this folder.");
+  }
+  const shouldConnect = await selectOption("Connect this project to Asiyst?", [
+    { label: "Yes", value: true },
+    { label: "No", value: false }
+  ]);
+  if (shouldConnect.type !== "selected" || !shouldConnect.value) {
+    console.log("Connection cancelled.");
     return;
   }
-  if (!await confirm("Connect this project to Asiyst?")) return;
-  const result = await connect(api);
-  ok("Asiyst account connected");
-  ok("Project connected", result.project?.projectName);
-  if (result.project?.projectId) {
-    console.log(`
-Project ID: ${result.project.projectId}
-Public Key: ${result.project.publicKey || project.config.publicKey || "Use the public key from the Asiyst project settings."}`);
+  const projectIdArg = cliProjectId ?? parseProjectIdArgument(process.argv.slice(2));
+  if (projectIdArg === "") {
+    console.log("Project ID is required. Use: asiyst connect --project-id <PROJECT_ID>");
+    return;
+  }
+  let projectId = typeof projectIdArg === "string" ? projectIdArg.trim() : "";
+  if (!projectId) {
+    projectId = await promptForProjectId() || "";
+  }
+  if (!projectId) {
+    console.log("Project ID is required. Use: asiyst connect --project-id <PROJECT_ID>");
+    return;
+  }
+  if (!isValidPublicIdentifier(projectId)) {
+    console.log("Invalid Project ID. Use a public project ID such as K8mP2xQ7_vL4N9cR5T1zB6Y3");
+    return;
+  }
+  const userId = await promptForUserId();
+  if (!userId) return;
+  console.log("Opening Asiyst...");
+  if (!await openBrowser(ASIIYST_WEB_URL)) {
+    console.log(`Open this URL manually:
+${ASIIYST_WEB_URL}`);
+  }
+  console.log("Register or log in, complete onboarding, create or select a project, then create an API key.");
+  for (; ; ) {
+    const apiKey = await readSecret("Paste your Asiyst API key: ");
+    if (apiKey === void 0) {
+      console.log("Connection cancelled.");
+      return;
+    }
+    if (!apiKey) {
+      fail("Invalid API key.");
+      continue;
+    }
+    try {
+      const connected = await verifyApiKey(api, apiKey, { userId, projectId });
+      if (connected.projectId && connected.projectId !== projectId) {
+        console.log("The provided Project ID does not match the authenticated project.");
+        return;
+      }
+      const finalConnection = { ...connected, projectId, userId };
+      ok("API key verified.");
+      ok("Project ID verified.");
+      await saveConnection(cwd, finalConnection);
+      writeProjectMetadata(cwd, finalConnection);
+      ok("Project connected successfully.");
+      console.log(`
+Project ID:
+${projectId}`);
+      if (connected.projectName) console.log(`
+Project:
+${connected.projectName}`);
+      if (connected.website) console.log(`
+Website:
+${connected.website}`);
+      return;
+    } catch (error) {
+      const message = printApiFailure(error);
+      const code = error instanceof ApiError ? error.code : "NETWORK";
+      if (code === "INVALID_API_KEY") {
+        console.log(message);
+        continue;
+      }
+      if (code === "API_KEY_REVOKED" || code === "FORBIDDEN" || code === "NOT_FOUND" || code === "MALFORMED_RESPONSE") {
+        console.log(message);
+        return;
+      }
+      if (!await retryOrCancel(message)) {
+        console.log("Connection cancelled.");
+        return;
+      }
+    }
   }
-  const warning = configWarning(cwd);
-  if (warning) console.log(`
-Warning: ${warning}`);
-  console.log('\nUse the public SDK API:\n\nimport { Asiyst } from "@asiyst/sdk";\n\nawait Asiyst.init({ projectId: "PROJECT_ID", publicKey: "PUBLIC_KEY" });');
-  console.log("\nRun `npx asiyst verify` after starting your website.");
 }
 
 // src/commands/login.ts
-async function loginCommand(api = new ApiClient()) {
-  await connect(api);
-  console.log("\u2713 Already connected to Asiyst.");
+async function loginCommand() {
+  await connectCommand(process.cwd(), createApiClient());
+}
+
+// src/commands/disconnect.ts
+async function disconnectCommand(cwd = process.cwd()) {
+  if (!await confirm("Disconnect this project?")) {
+    console.log("Disconnect cancelled.");
+    return;
+  }
+  await clearConnection(cwd);
+  clearProjectMetadata(cwd);
+  console.log("\u2713 Local connection information removed.");
+  console.log("The cloud project and API key were not changed.");
 }
 
 // src/commands/logout.ts
-function logoutCommand() {
-  console.log("\u2713 Local CLI session information removed (the CLI does not store passwords or private credentials).");
+async function logoutCommand() {
+  await disconnectCommand();
 }
 
 // src/commands/status.ts
-async function statusCommand(cwd = process.cwd(), api = new ApiClient()) {
-  const project = detectProject(cwd);
-  console.log(`Project: ${typeof project.packageJson?.name === "string" ? project.packageJson.name : "Unknown"}
-SDK: ${project.sdkVersion || "Not connected"}`);
-  if (!project.config.projectId || !project.config.publicKey) {
-    console.log("\nProject: Not connected\nSDK: Not connected\nAvatar: Not configured\n\nStatistics:\nConnect your website to show stats.");
+async function statusCommand(cwd = process.cwd(), api = createApiClient()) {
+  const stored = await loadConnection(cwd);
+  if (!stored?.apiKey) {
+    const metadata = readProjectMetadata(cwd);
+    if (metadata?.connected && metadata.projectId) {
+      console.log("\u2713 Connected");
+      console.log(`Project:
+${metadata.projectId}`);
+      if (metadata.userId) console.log(`User ID:
+${metadata.userId}`);
+      return;
+    }
+    console.log("Connect your website to show stats.");
     return;
   }
-  const info = await api.projectInfo(project.config.projectId);
-  console.log(`
-Project: ${info.connectionStatus || "Connected"}
-SDK: ${project.sdkVersion}
-Avatar: ${info.avatarStatus || "Not configured"}`);
-  console.log("\nStatistics:");
-  console.log(info.lastSdkConnection ? `Last SDK heartbeat: ${info.lastSdkConnection}` : "No SDK heartbeat recorded.");
+  if (!stored.userId || !stored.projectId) {
+    console.log("\u2717 Connection is missing a User ID or Project ID. Please run:\nasiyst connect");
+    return;
+  }
+  try {
+    const connected = await verifyApiKey(api, stored.apiKey, {
+      userId: stored.userId,
+      projectId: stored.projectId
+    });
+    const projectId = stored.projectId || connected.projectId;
+    const userId = stored.userId || connected.userId;
+    console.log("\u2713 Connected");
+    if (userId) console.log(`
+User ID:
+${userId}`);
+    console.log(`
+Project ID:
+${projectId || connected.projectName || "Unknown"}`);
+    console.log("\nAPI Key:\n\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022");
+    if (stored.avatarId) console.log(`
+Avatar:
+${stored.avatarId}`);
+    if (connected.website) console.log(`
+Website:
+${connected.website}`);
+  } catch (error) {
+    if (error instanceof ApiError && error.code === "API_KEY_REVOKED") {
+      console.log("\u2717 API key revoked.");
+      console.log("Create a new key from:\nhttps://asiyst.com");
+      return;
+    }
+    if (error instanceof ApiError && (error.code === "INVALID_API_KEY" || error.code === "FORBIDDEN")) {
+      console.log("\u2717 Connection invalid.");
+      return;
+    }
+    console.log("\u2717 Connection invalid.");
+  }
+}
+
+// src/api/projects.ts
+async function verifyInstallation(api, projectId, publicKey, domain) {
+  const value = await api.request("/cli/verification", {
+    method: "POST",
+    body: JSON.stringify({ projectId, publicKey, domain })
+  });
+  if (!Array.isArray(value) || !value.every((item) => item && typeof item === "object" && typeof item.name === "string" && typeof item.ok === "boolean")) {
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  }
+  return value;
+}
+function requireIdentifier(value, name, valid) {
+  const trimmed = value.trim();
+  if (!valid(trimmed)) throw new ApiError(`Invalid ${name}.`, 400, "INVALID_REQUEST");
+  return trimmed;
+}
+function parseAvatarImportResponse(value, projectId, userId, avatarId) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ApiError("Received an unexpected response from Asiyst.", 200, "MALFORMED_RESPONSE");
+  }
+  const body = value;
+  const imported = body.imported === true || body.success === true || body.status === "imported";
+  if (!imported) {
+    const code = typeof body.code === "string" ? body.code : "IMPORT_FAILED";
+    const supportedCode = ["AVATAR_NOT_FOUND", "AVATAR_ALREADY_IMPORTED", "FORBIDDEN", "PROJECT_NOT_FOUND", "CONFLICT"].includes(code) ? code : "IMPORT_FAILED";
+    throw new ApiError(typeof body.message === "string" ? body.message : "Avatar import was not completed.", 200, supportedCode);
+  }
+  const returnedAvatarId = body.avatarId ?? body.avatar_id;
+  if (returnedAvatarId !== void 0 && returnedAvatarId !== avatarId) {
+    throw new ApiError("The API returned a different avatar than requested.", 200, "AVATAR_MISMATCH");
+  }
+  return {
+    imported: true,
+    avatarId,
+    projectId,
+    userId,
+    avatarName: typeof body.avatarName === "string" ? body.avatarName : void 0
+  };
+}
+async function importAvatar(api, input) {
+  const userId = requireIdentifier(input.userId, "User ID", isValidUserId);
+  const projectId = requireIdentifier(input.projectId, "Project ID", isValidPublicIdentifier);
+  const avatarId = requireIdentifier(input.avatarId, "Avatar ID", isValidAvatarId);
+  const apiKey = input.apiKey.trim();
+  if (!apiKey) throw new ApiError("An API key is required.", 401, "INVALID_API_KEY");
+  const value = await api.request(`/cli/projects/${encodeURIComponent(projectId)}/avatars/import`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "X-Asiyst-API-Key": apiKey
+    },
+    body: JSON.stringify({ userId, projectId, avatarId })
+  });
+  return parseAvatarImportResponse(value, projectId, userId, avatarId);
 }
 
 // src/commands/verify.ts
-async function verifyCommand(cwd = process.cwd(), api = new ApiClient()) {
+function printVerificationSafe(results) {
+  console.log("\nAsiyst Installation Verification\n");
+  for (const result of results) result.ok ? ok(result.name, result.detail) : fail(result.name, result.detail);
+  return results.length > 0 && results.every((result) => result.ok);
+}
+async function verifyCommand(cwd = process.cwd()) {
   const project = detectProject(cwd);
   if (!project.packageJson) {
     fail("Project detected", "package.json is missing");
@@ -432,105 +1063,180 @@ async function verifyCommand(cwd = process.cwd(), api = new ApiClient()) {
     return;
   }
   ok("Project detected");
-  if (!project.sdkVersion) {
-    fail("SDK installed", "npm install @asiyst/sdk");
-    process.exitCode = 1;
-    return;
-  }
-  ok("SDK installed", project.sdkVersion);
-  if (!project.config.projectId || !project.config.publicKey) {
-    fail("Configuration found", "set ASIIYST_PROJECT_ID and ASIIYST_PUBLIC_KEY");
+  const stored = await loadConnection(cwd);
+  if (!stored) {
+    fail("Configuration found", "run asiyst connect");
     process.exitCode = 1;
     return;
   }
   ok("Configuration found");
   try {
-    const results = await api.verify(project.config.projectId, project.config.publicKey, process.env.ASIIYST_DOMAIN);
-    if (!printVerification(results)) process.exitCode = 1;
+    const results = await verifyInstallation(createApiClient(), stored.projectId, stored.publicKey || "", process.env.ASIIYST_DOMAIN);
+    if (!printVerificationSafe(results)) process.exitCode = 1;
   } catch (error) {
     fail("API reachable", error instanceof Error ? error.message : "verification failed");
     process.exitCode = 1;
   }
 }
 
+// src/config/version.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath } from "url";
+function readCurrentVersion() {
+  if ("1.1.1") return "1.1.1";
+  try {
+    const packageJson = JSON.parse(readFileSync5(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
+    if (packageJson && typeof packageJson === "object" && typeof packageJson.version === "string") {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync5(fileURLToPath(new URL("../../package.json", import.meta.url)), "utf8"));
+    if (packageJson && typeof packageJson === "object" && typeof packageJson.version === "string" && packageJson.name === "@asiyst/cli") {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+
 // src/commands/doctor.ts
-async function doctorCommand(cwd = process.cwd(), api = new ApiClient()) {
-  const project = detectProject(cwd);
+async function doctorCommand(cwd = process.cwd(), api = createApiClient()) {
+  ok("CLI version", readCurrentVersion());
+  ok("Executable", process.argv[1] || "unknown");
+  ok("API base", api.baseUrl || CLI_API_BASE_URL);
+  ok("Verify endpoint", VERIFY_KEY_URL);
   ok("System", process.platform);
   ok("Node.js", process.version);
-  ok("npm", "available through npm");
+  const project = detectProject(cwd);
   project.packageJson ? ok("Project", cwd) : fail("Project", "package.json is missing");
   project.sdkVersion ? ok("SDK", project.sdkVersion) : fail("SDK", "not installed");
-  project.config.projectId && project.config.publicKey ? ok("Configuration") : fail("Configuration", "public project values are missing");
+  const stored = await loadConnection(cwd);
+  stored ? ok("Local credential", "present") : fail("Local credential", "not connected");
   try {
     await api.health();
-    ok("Asiyst API", "HTTPS health endpoint reachable");
+    ok("Asiyst API", "health endpoint reachable");
   } catch (error) {
     fail("Asiyst API", error instanceof Error ? error.message : "unreachable");
   }
-  if (project.config.projectId && project.config.publicKey) {
-    try {
-      await api.projectInfo(project.config.projectId);
-      ok("Project connection");
-    } catch (error) {
-      fail("Project connection", error instanceof Error ? error.message : "unavailable");
-    }
-  }
 }
 
 // src/commands/dashboard.ts
 async function dashboardCommand() {
-  const configured = process.env.ASIIYST_DASHBOARD_URL || `${ASIIYST_WEB_URL}/dashboard`;
-  const parsed = new URL(configured);
-  if (parsed.protocol !== "https:") throw new Error("Configured dashboard URL must use HTTPS.");
-  const url = parsed.toString();
-  if (!await openBrowser(url)) console.log(`Open ${url}`);
+  const url = ASIIYST_WEB_URL;
+  if (!await openBrowser(url)) console.log(`Open this URL manually:
+${url}`);
   else console.log(`Opening ${url}`);
 }
 
 // src/commands/avatar.ts
-async function avatarCommand(cwd = process.cwd(), api = new ApiClient()) {
-  const project = detectProject(cwd);
-  if (!project.config.projectId) {
-    console.log("Avatar\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nNo avatar configured.\n\nCreate your avatar in the Asiyst dashboard.");
-    const url = `${ASIIYST_WEB_URL}/dashboard`;
+function parseAvatarId(argv) {
+  const index = argv.findIndex((value) => value === "--avatar-id");
+  if (index >= 0) return argv[index + 1];
+  const inline = argv.find((value) => value.startsWith("--avatar-id="));
+  return inline?.slice("--avatar-id=".length);
+}
+async function avatarImportCommand(cwd = process.cwd(), api = createApiClient(), suppliedAvatarId) {
+  const stored = await loadConnection(cwd);
+  if (!stored?.apiKey || !stored.userId || !stored.projectId) {
+    console.log("No project is connected. Please run:\nasiyst connect");
+    return;
+  }
+  const avatarId = suppliedAvatarId ?? await readInput("Enter your Avatar ID: ");
+  if (!avatarId || !isValidAvatarId(avatarId)) {
+    console.log("Invalid Avatar ID. It must contain exactly 10 alphanumeric characters.");
+    return;
+  }
+  try {
+    const result = await importAvatar(api, {
+      userId: stored.userId,
+      projectId: stored.projectId,
+      apiKey: stored.apiKey,
+      avatarId
+    });
+    await saveConnection(cwd, { ...stored, avatarId: result.avatarId });
+    console.log(`\u2713 Avatar ${result.avatarId} imported into project ${result.projectId}.`);
+  } catch (error) {
+    if (error instanceof ApiError) {
+      if (error.code === "FORBIDDEN") console.log("\u2717 You do not have permission to import an avatar into this project.");
+      else if (error.code === "NOT_FOUND") console.log("\u2717 Project or avatar was not found.");
+      else if (error.code === "CONFLICT" || error.code === "AVATAR_ALREADY_IMPORTED") console.log("\u2717 This avatar is already imported into the project.");
+      else console.log(`\u2717 ${error.message}`);
+      return;
+    }
+    console.log("\u2717 Unable to import the avatar.");
+  }
+}
+async function avatarCommand(cwd = process.cwd(), argv = process.argv.slice(2)) {
+  if (argv[0] === "import") {
+    await avatarImportCommand(cwd, createApiClient(), parseAvatarId(argv));
+    return;
+  }
+  const stored = await loadConnection(cwd);
+  if (!stored) {
+    console.log("Connect your project to Asiyst to view avatar information.");
+    const url = ASIIYST_WEB_URL;
     if (await openBrowser(url)) console.log(`Opening ${url}`);
-    else console.log(`Open ${url}`);
+    else console.log(`Open this URL manually:
+${url}`);
     return;
   }
-  const info = await api.projectInfo(project.config.projectId);
-  console.log(`Avatar
-\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-Status        ${info.avatarStatus || "Not configured"}
-
-Configure your avatar in the Asiyst dashboard.`);
+  console.log(`Avatar configuration is managed at ${ASIIYST_WEB_URL}.`);
+  if (!await openBrowser(ASIIYST_WEB_URL)) console.log(`Open this URL manually:
+${ASIIYST_WEB_URL}`);
 }
 
-// src/update/check.ts
-import { execFileSync } from "child_process";
-import { readFileSync as readFileSync5 } from "fs";
+// src/commands/interactive.ts
+function interactiveHelp() {
+  console.log(`
+Asiyst CLI
 
-// src/config/version.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { fileURLToPath } from "url";
-function readCurrentVersion() {
-  for (const packageUrl of [
-    new URL("../package.json", import.meta.url),
-    new URL("../../package.json", import.meta.url),
-    new URL("../../../package.json", import.meta.url)
-  ]) {
-    try {
-      const packageJson = JSON.parse(readFileSync4(fileURLToPath(packageUrl), "utf8"));
-      if (packageJson && typeof packageJson === "object" && typeof packageJson.version === "string") {
-        return packageJson.version;
-      }
-    } catch {
+Usage: asiyst [command]
+
+Commands
+  connect       Connect this project to Asiyst
+  avatar import Import an avatar into the connected project
+  status        Show connection status
+  health        Check Asiyst API connectivity
+  disconnect    Remove local connection information
+  help          Show available commands
+  version       Show CLI version
+
+Also available
+  trust         Trust this project folder
+  revoke-trust  Revoke folder trust
+  doctor        Run diagnostics
+  update        Check for CLI updates
+
+Examples
+  asiyst connect
+  asiyst status
+  asiyst disconnect
+`);
+}
+async function interactiveHome() {
+  homeStatus();
+  for (; ; ) {
+    const result = await selectOption("What would you like to do?", [
+      { label: "Connect", value: "connect" },
+      { label: "Status", value: "status" },
+      { label: "Help", value: "help" },
+      { label: "Exit", value: "exit" }
+    ]);
+    if (result.type !== "selected" || result.value === "exit") {
+      break;
     }
+    if (result.value === "connect") await connectCommand();
+    else if (result.value === "status") await statusCommand();
+    else if (result.value === "help") interactiveHelp();
+    else if (result.value === "version") console.log(readCurrentVersion());
   }
-  return "0.2.0";
 }
 
 // src/update/check.ts
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync6 } from "fs";
 var PACKAGE_NAME = "@asiyst/cli";
 var REGISTRY_URL = "https://registry.npmjs.org/%40asiyst%2Fcli/latest";
 var TIMEOUT_MS = 800;
@@ -602,7 +1308,7 @@ function detectInstallKind(executablePath = process.argv[1] ?? "", env = process
 }
 function installedVersion(packageRoot) {
   try {
-    const value = JSON.parse(readFileSync5(`${packageRoot}/package.json`, "utf8"));
+    const value = JSON.parse(readFileSync6(`${packageRoot}/package.json`, "utf8"));
     return value && typeof value === "object" && typeof value.version === "string" ? value.version : void 0;
   } catch {
     return void 0;
@@ -663,102 +1369,65 @@ ${error instanceof Error ? error.message : "Installation could not be verified."
   }
 }
 
-// src/commands/interactive.ts
-function resolveInput(value) {
-  const input = value.trim().toLowerCase();
-  if (/^(connect|connect my website|connect this website|connect website|init)/.test(input)) return "connect";
-  if (/^(status|check status|check .*installation)/.test(input)) return "status";
-  if (/diagnos|doctor/.test(input)) return "diagnostics";
-  if (/dashboard/.test(input)) return "dashboard";
-  if (/avatar|configure my avatar|create avatar/.test(input)) return "avatar";
-  if (/update|upgrade/.test(input)) return "update";
-  if (/^(help|\?)$/.test(input)) return "help";
-  if (/^(version|--version)$/.test(input)) return "version";
-  return input;
-}
-function interactiveHelp() {
-  console.log("\nASIYST CLI\n\nUsage: asiyst [command]\n\nCommands\n  connect       Connect this project to Asiyst\n  status        Show project and Asiyst status\n  diagnostics   Run diagnostics\n  dashboard     Open Asiyst dashboard\n  avatar        Configure avatar\n  update        Check for and install CLI updates\n  help          Show available commands\n  version       Show CLI version\n  trust         Trust this project folder\n  revoke-trust  Revoke folder trust\n  logout        Remove local CLI session information\n\nExamples\n  asiyst connect\n  asiyst status\n  asiyst update");
-}
-async function interactiveHome() {
-  homeStatus(detectProject());
-  console.log("\nWelcome to Asiyst CLI.\nUse UP/DOWN to select a command, or type a command.\n");
-  const suggestions = [
-    { label: "Connect this project", value: "connect" },
-    { label: "Check project status", value: "status" },
-    { label: "Run diagnostics", value: "diagnostics" },
-    { label: "Open dashboard", value: "dashboard" },
-    { label: "Configure avatar", value: "avatar" },
-    { label: "Update CLI", value: "update" },
-    { label: "Help", value: "help" },
-    { label: "Exit", value: "exit" }
-  ];
-  for (; ; ) {
-    const result = await selectOption("What would you like to do?", suggestions, "\u203A ");
-    if (result.type === "exit") break;
-    if (result.type !== "selected") continue;
-    const command = resolveInput(result.input || String(result.value));
-    if (command === "exit" || command === "quit") {
-      const confirmed = await selectOption("Exit Asiyst?", [
-        { label: "Yes", value: true },
-        { label: "No", value: false }
-      ]);
-      if (confirmed.type === "selected") {
-        if (confirmed.value) break;
-      }
-      continue;
-    }
-    if (command === "connect") await initCommand();
-    else if (command === "status") await statusCommand();
-    else if (command === "diagnostics") await doctorCommand();
-    else if (command === "dashboard") await dashboardCommand();
-    else if (command === "avatar") await avatarCommand();
-    else if (command === "update") await updateCommand();
-    else if (command === "logout") logoutCommand();
-    else if (command === "trust") await trustCommand();
-    else if (command === "revoke-trust") revokeTrustCommand();
-    else if (command === "help") interactiveHelp();
-    else if (command === "version") console.log(readCurrentVersion());
-    else console.log(`I don't recognize that command: ${result.input}
-Run 'asiyst help' for available commands.`);
+// src/commands/health.ts
+async function healthCommand(api = createApiClient()) {
+  try {
+    await api.health();
+    console.log("\u2713 Asiyst API is reachable.");
+  } catch {
+    console.log("\u2717 Unable to reach Asiyst API.");
   }
 }
 
 // src/index.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { realpathSync } from "fs";
 var CLI_VERSION = readCurrentVersion();
 function help() {
   interactiveHelp();
 }
 async function main(argv = process.argv.slice(2)) {
   const command = argv[0] || "";
+  const projectId = parseProjectIdArgument(argv);
   if (command !== "update" && !argv.includes("--version") && !argv.includes("-v") && !argv.includes("--help") && !argv.includes("-h")) {
     await notifyIfUpdateAvailable();
   }
   if (command === "--help" || command === "-h") return help();
   if (command === "--version" || command === "-v") return console.log(CLI_VERSION);
-  if (command === "init" || command === "connect") return initCommand();
+  if (command === "init") return connectCommand(process.cwd(), void 0, projectId);
+  if (command === "connect") return connectCommand(process.cwd(), void 0, projectId);
   if (command === "login") return loginCommand();
   if (command === "logout") return logoutCommand();
+  if (command === "disconnect") return disconnectCommand();
   if (command === "status") return statusCommand();
   if (command === "verify") return verifyCommand();
+  if (command === "health") return healthCommand();
   if (command === "doctor") return doctorCommand();
   if (command === "diagnostics") return doctorCommand();
   if (command === "dashboard") return dashboardCommand();
-  if (command === "avatar") return avatarCommand();
+  if (command === "avatar") return avatarCommand(process.cwd(), argv.slice(1));
   if (command === "trust") return trustCommand();
   if (command === "revoke-trust") return revokeTrustCommand();
   if (command === "update") return updateCommand();
   if (command === "help") return help();
   if (command === "version") return console.log(CLI_VERSION);
   if (!process.stdin.isTTY) {
-    const project = detectProject();
-    projectChecks(project);
-    console.log("\nRun `npx @asiyst/cli connect` to connect this project, or `npx @asiyst/cli --help` for commands.");
+    help();
     return;
   }
   return interactiveHome();
 }
-if (process.argv[1] && fileURLToPath2(import.meta.url) === process.argv[1]) {
+function isDirectExecution() {
+  if (!process.argv[1]) return false;
+  try {
+    const entryPath = realpathSync(fileURLToPath2(import.meta.url));
+    const execPath = realpathSync(process.argv[1]);
+    return entryPath.toLowerCase() === execPath.toLowerCase();
+  } catch {
+    return true;
+  }
+}
+if (isDirectExecution()) {
   main().catch((error) => {
     console.error(`
 Error: ${error instanceof Error ? error.message : "command failed"}`);
@@ -767,6 +1436,7 @@ Error: ${error instanceof Error ? error.message : "command failed"}`);
 }
 export {
   CLI_VERSION,
+  connectCommand as initCommand,
   main
 };
 //# sourceMappingURL=index.js.map