@ulpi/cli 0.1.5 → 0.1.7

package/dist/{ci-JQ56YIKC.js → ci-COZRTPGQ.js}

@@ -1,6 +1,6 @@
 import {
   buildPrompt
-} from "./chunk-AV5RB3N2.js";
+} from "./chunk-76D3BYJD.js";
 import {
   external_exports
 } from "./chunk-KIKPIH6N.js";
@@ -38,12 +38,13 @@ var JobConfigSchema = external_exports.object({
   repoUrl: external_exports.string().url(),
   ref: external_exports.string(),
   baseBranch: external_exports.string(),
-  prNumber: external_exports.number().int().positive(),
+  prNumber: external_exports.number().int().positive().optional(),
   repoFullName: external_exports.string(),
   instruction: external_exports.string(),
   jiraContext: external_exports.string().optional(),
   timeoutMinutes: external_exports.number().int().positive().default(1440),
-  envVars: external_exports.record(external_exports.string()).optional()
+  envVars: external_exports.record(external_exports.string()).optional(),
+  autoCommitIgnore: external_exports.array(external_exports.string()).default([".pnpm-store/", "node_modules/", ".claude/"])
 });
 var JobResultSchema = external_exports.object({
   jobId: external_exports.string(),
@@ -69,8 +70,8 @@ var JobSchema = external_exports.object({
   startedAt: external_exports.string().datetime().optional(),
   completedAt: external_exports.string().datetime().optional(),
   cancelledBy: external_exports.string().optional(),
-  commentId: external_exports.number().int().positive(),
-  commentAuthor: external_exports.string()
+  commentId: external_exports.number().int().positive().optional(),
+  commentAuthor: external_exports.string().optional()
 });
 var GitHubAppAuthSchema = external_exports.object({
   appId: external_exports.string(),
@@ -157,6 +158,26 @@ var JiraReferenceSchema = external_exports.object({
   key: external_exports.string(),
   url: external_exports.string().url()
 });
+var JiraSprintSchema = external_exports.object({
+  id: external_exports.number().int(),
+  name: external_exports.string(),
+  state: external_exports.string(),
+  // "active", "closed", "future"
+  startDate: external_exports.string().optional(),
+  endDate: external_exports.string().optional()
+});
+var SprintImportConfigSchema = external_exports.object({
+  jiraBaseUrl: external_exports.string().url(),
+  email: external_exports.string().email(),
+  apiToken: external_exports.string(),
+  sprintId: external_exports.number().int().positive()
+});
+var JiraSprintImportSchema = external_exports.object({
+  sprintId: external_exports.number().int(),
+  tasks: external_exports.array(external_exports.unknown()),
+  // TrackerTask[] — imported at runtime
+  warnings: external_exports.array(external_exports.string())
+});
 
 // src/commands/ci.ts
 async function runCi(args, projectDir) {
@@ -185,7 +206,7 @@ async function runCiJob(args) {
   let jobId = "";
   let configJson = "";
   let outputPath = "";
-  let model = "claude-sonnet-4-20250514";
+  let model = process.env.ULPI_CLAUDE_MODEL ?? "claude-opus-4-6";
   for (let i = 0; i < args.length; i++) {
     switch (args[i]) {
       case "--job-id":
@@ -250,6 +271,7 @@ async function runCiJob(args) {
     process.exit(1);
   }
   console.log(chalk.blue(`[ulpi-ci] Using claude at: ${claudePath}`));
+  logClaudeMdFiles(projectDir);
   const claudeArgs = [
     "--print",
     "--verbose",
@@ -261,8 +283,9 @@ async function runCiJob(args) {
   ];
   console.log(chalk.blue("[ulpi-ci] Spawning Claude Code..."));
   const result = await spawnClaude(claudePath, claudeArgs, prompt, config.timeoutMinutes * 60 * 1e3);
-  commitUnstagedWork(process.cwd());
+  commitUnstagedWork(process.cwd(), config.autoCommitIgnore);
   await postSessionFinalize(process.cwd());
+  await exportShadowBranches(process.cwd());
   const baseBranch = config.baseBranch;
   let diff = "";
   let filesChanged = [];
@@ -327,7 +350,7 @@ async function initUlpiSubsystems(projectDir) {
     if (fs.existsSync(guardsPath)) {
       console.log(chalk.blue("[ulpi-ci] guards.yml found \u2014 rules will be enforced"));
     } else {
-      const { loadBundledTemplates, composeTemplates, resolveTemplate } = await import("./dist-XG2GG5SD.js");
+      const { loadBundledTemplates, composeTemplates, resolveTemplate } = await import("./dist-HU5RZAON.js");
       const stackConfig = {
         name: path.basename(projectDir),
         runtime: stack.runtime?.id ?? "unknown",
@@ -369,14 +392,14 @@ async function initUlpiSubsystems(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Could not detect stack/generate guards.yml: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { installHooks } = await import("./hooks-installer-K2JXEBNN.js");
+    const { installHooks } = await import("./hooks-installer-YEYTYA6Q.js");
     installHooks(projectDir);
     console.log(chalk.blue("[ulpi-ci] Hooks installed"));
   } catch (err) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Could not install hooks: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { installMcpServer, installMemoryMcpServer } = await import("./mcp-installer-TOYDP77X.js");
+    const { installMcpServer, installMemoryMcpServer } = await import("./mcp-installer-PQU3XOGO.js");
     installMcpServer(projectDir);
     installMemoryMcpServer(projectDir);
     console.log(chalk.blue("[ulpi-ci] MCP servers registered"));
@@ -389,10 +412,10 @@ async function initUlpiSubsystems(projectDir) {
   } catch {
   }
   try {
-    const { historyBranchExists, initHistoryBranch } = await import("./dist-5R4RYNQO.js");
+    const { historyBranchExists, initHistoryBranch } = await import("./dist-YCNWHSLN.js");
     if (!historyBranchExists(projectDir)) {
       const projectName = path.basename(projectDir);
-      const version = true ? "0.1.5" : "0.0.0";
+      const version = true ? "0.1.7" : "0.0.0";
       initHistoryBranch(projectDir, projectName, version);
       console.log(chalk.blue("[ulpi-ci] History branch initialized"));
     } else {
@@ -402,8 +425,8 @@ async function initUlpiSubsystems(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Could not init history: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG, initMemoryBranch } = await import("./dist-7WLLPWWB.js");
-    const { projectMemoryDir } = await import("./dist-GWGTAHNM.js");
+    const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG, initMemoryBranch } = await import("./dist-JLU26AB6.js");
+    const { projectMemoryDir } = await import("./dist-NUXMDXZ3.js");
     if (!isMemoryInitialized(projectDir)) {
       const memDir = projectMemoryDir(projectDir);
       fs.mkdirSync(memDir, { recursive: true });
@@ -418,11 +441,11 @@ async function initUlpiSubsystems(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Could not init memory: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { resolveApiKey } = await import("./dist-GWGTAHNM.js");
+    const { resolveApiKey } = await import("./dist-NUXMDXZ3.js");
     const hasOpenAiKey = !!resolveApiKey("openai");
     const hasUlpiKey = !!resolveApiKey("ulpi");
     if (hasOpenAiKey || hasUlpiKey) {
-      const { runInitPipeline } = await import("./dist-6MFVWIFF.js");
+      const { runInitPipeline } = await import("./dist-YFFG2ZD6.js");
       console.log(chalk.blue("[ulpi-ci] Indexing codebase..."));
       await runInitPipeline(projectDir, (progress) => {
         if (progress.message) {
@@ -490,8 +513,22 @@ function writeYamlFields(obj, lines, indent) {
     }
   }
 }
-function commitUnstagedWork(cwd) {
+function commitUnstagedWork(cwd, ignorePatterns = []) {
   try {
+    if (ignorePatterns.length > 0) {
+      const gitignorePath = path.join(cwd, ".gitignore");
+      try {
+        const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf-8") : "";
+        const missing = ignorePatterns.filter((p) => !existing.includes(p));
+        if (missing.length > 0) {
+          const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
+          fs.appendFileSync(gitignorePath, `${separator}# Added by ULPI CI worker
+${missing.join("\n")}
+`);
+        }
+      } catch {
+      }
+    }
     const status = execFileSync("git", ["status", "--porcelain"], {
       cwd,
       encoding: "utf-8",
@@ -500,10 +537,11 @@ function commitUnstagedWork(cwd) {
     if (!status) return;
     const fileCount = status.split("\n").filter(Boolean).length;
     console.log(chalk.blue(`[ulpi-ci] Committing ${fileCount} uncommitted files...`));
-    execFileSync("git", ["add", "-A"], { cwd, timeout: 3e4 });
-    execFileSync("git", ["commit", "-m", "wip: auto-commit from ULPI CI worker"], {
+    execFileSync("git", ["add", "-A"], { cwd, timeout: 6e5, maxBuffer: 50 * 1024 * 1024 });
+    execFileSync("git", ["commit", "--no-verify", "-m", "wip: auto-commit from ULPI CI worker"], {
       cwd,
-      timeout: 3e4
+      timeout: 6e5,
+      maxBuffer: 50 * 1024 * 1024
     });
     console.log(chalk.blue("[ulpi-ci] WIP commit created"));
   } catch (err) {
@@ -522,8 +560,8 @@ async function postSessionFinalize(projectDir) {
       writeHistoryEntry,
       readBranchMeta,
       DEFAULT_HISTORY_CONFIG
-    } = await import("./dist-5R4RYNQO.js");
-    const { loadActiveGuards } = await import("./dist-5R4RYNQO.js");
+    } = await import("./dist-YCNWHSLN.js");
+    const { loadActiveGuards } = await import("./dist-YCNWHSLN.js");
     if (historyBranchExists(projectDir)) {
       const commits = listBranchOnlyCommits(projectDir, 50);
       const meta = readBranchMeta(projectDir);
@@ -563,9 +601,9 @@ async function postSessionFinalize(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: History backfill failed: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { isMemoryInitialized, classifySession } = await import("./dist-7WLLPWWB.js");
-    const { ULPI_GLOBAL_DIR } = await import("./dist-GWGTAHNM.js");
-    const { JsonSessionStore } = await import("./dist-XD4YI27T.js");
+    const { isMemoryInitialized, classifySession } = await import("./dist-JLU26AB6.js");
+    const { ULPI_GLOBAL_DIR } = await import("./dist-NUXMDXZ3.js");
+    const { JsonSessionStore } = await import("./dist-6M4MZWZW.js");
     if (isMemoryInitialized(projectDir)) {
       const store = new JsonSessionStore(ULPI_GLOBAL_DIR, projectDir);
       const latest = store.getLatestForProject(projectDir);
@@ -586,6 +624,66 @@ async function postSessionFinalize(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Memory classify failed: ${err instanceof Error ? err.message : String(err)}`));
   }
 }
+async function exportShadowBranches(projectDir) {
+  try {
+    const { getCodemapStatus, exportIndex } = await import("./dist-YFFG2ZD6.js");
+    const { getCurrentBranch } = await import("./dist-NUXMDXZ3.js");
+    const branch = getCurrentBranch(projectDir);
+    const status = getCodemapStatus(projectDir, branch);
+    if (status.initialized) {
+      const result = await exportIndex(projectDir, branch);
+      console.log(chalk.blue(`[ulpi-ci] Codemap exported to ${result.branchName} (${result.filesExported} files)`));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Codemap export failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  try {
+    const { isMemoryInitialized, exportMemories } = await import("./dist-JLU26AB6.js");
+    if (isMemoryInitialized(projectDir)) {
+      const result = await exportMemories(projectDir);
+      console.log(chalk.blue(`[ulpi-ci] Memory exported to ${result.branchName} (${result.memoriesExported} memories, ${result.filesExported} files)`));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Memory export failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+}
+function logClaudeMdFiles(projectDir) {
+  const rootMd = path.join(projectDir, "CLAUDE.md");
+  if (fs.existsSync(rootMd)) {
+    const stat = fs.statSync(rootMd);
+    console.log(chalk.blue(`[ulpi-ci] Found CLAUDE.md (${stat.size} bytes)`));
+  } else {
+    console.log(chalk.yellow("[ulpi-ci] No CLAUDE.md in workspace root"));
+  }
+  const claudeDir = path.join(projectDir, ".claude");
+  if (fs.existsSync(claudeDir)) {
+    const items = [];
+    try {
+      for (const entry of fs.readdirSync(claudeDir, { recursive: true })) {
+        if (entry.endsWith(".md") || entry === "settings.local.json") {
+          items.push(entry);
+        }
+      }
+    } catch {
+    }
+    console.log(chalk.blue(`[ulpi-ci] .claude/ contents: ${items.length > 0 ? items.join(", ") : "(empty)"}`));
+  } else {
+    console.log(chalk.yellow("[ulpi-ci] No .claude/ directory in workspace"));
+  }
+  try {
+    const nested = [];
+    for (const entry of fs.readdirSync(projectDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        const nestedMd = path.join(projectDir, entry.name, "CLAUDE.md");
+        if (fs.existsSync(nestedMd)) nested.push(entry.name);
+      }
+    }
+    if (nested.length > 0) {
+      console.log(chalk.blue(`[ulpi-ci] Nested CLAUDE.md: ${nested.join(", ")}`));
+    }
+  } catch {
+  }
+}
 function findClaudeBinary() {
   try {
     const result = execFileSync("which", ["claude"], { encoding: "utf-8", timeout: 5e3 });
@@ -662,7 +760,7 @@ function spawnClaude(claudePath, args, prompt, timeoutMs) {
   return new Promise((resolve) => {
     const proc = spawn(claudePath, args, {
       cwd: process.cwd(),
-      env: process.env,
+      env: { ...process.env, ULPI_RUN_MODE: "ci" },
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";

package/dist/cloud-2F3NLVHN.js

@@ -0,0 +1,274 @@
+import {
+  loadCloudGatewayConfig,
+  loadUlpiSettings,
+  removeCloudGatewayConfig,
+  saveCloudGatewayConfig
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/cloud.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as https from "https";
+import * as http from "http";
+import chalk from "chalk";
+function getFlag(args, flag) {
+  const prefix = `--${flag}=`;
+  const withEq = args.find((a) => a.startsWith(prefix));
+  if (withEq) return withEq.slice(prefix.length);
+  const idx = args.indexOf(`--${flag}`);
+  if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith("--")) return args[idx + 1];
+  return void 0;
+}
+function fetchJson(url, apiKey) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const mod = parsedUrl.protocol === "https:" ? https : http;
+    const req = mod.request(
+      {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || (parsedUrl.protocol === "https:" ? 443 : 80),
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Accept": "application/json"
+        },
+        timeout: 1e4
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          try {
+            if ((res.statusCode ?? 0) >= 400) {
+              reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+            } else {
+              resolve(JSON.parse(data));
+            }
+          } catch {
+            reject(new Error(`Invalid JSON response: ${data}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+    req.end();
+  });
+}
+function mcpJsonPath(projectDir) {
+  return path.join(projectDir, ".mcp.json");
+}
+function readMcpJson(projectDir) {
+  const filePath = mcpJsonPath(projectDir);
+  if (fs.existsSync(filePath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      return { mcpServers: data.mcpServers ?? {} };
+    } catch {
+    }
+  }
+  return { mcpServers: {} };
+}
+function writeMcpJson(projectDir, mcpServers) {
+  const filePath = mcpJsonPath(projectDir);
+  fs.writeFileSync(filePath, JSON.stringify({ mcpServers }, null, 2) + "\n", "utf-8");
+}
+var CLOUD_MCP_KEY = "ulpi-cloud";
+function readJsonConfig(filePath) {
+  if (fs.existsSync(filePath)) {
+    try {
+      return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    } catch {
+    }
+  }
+  return {};
+}
+function writeJsonConfig(filePath, config) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function getAgentConfigTargets() {
+  const home = os.homedir();
+  const targets = [];
+  const claudePath = path.join(home, ".claude", "settings.json");
+  targets.push({ name: "Claude Code", configPath: claudePath });
+  return targets;
+}
+function writeCloudMcpToAgentConfig(configPath, entry) {
+  const config = readJsonConfig(configPath);
+  const mcpServers = config.mcpServers ?? {};
+  if (mcpServers[CLOUD_MCP_KEY]) return false;
+  mcpServers[CLOUD_MCP_KEY] = entry;
+  config.mcpServers = mcpServers;
+  writeJsonConfig(configPath, config);
+  return true;
+}
+function removeCloudMcpFromAgentConfig(configPath) {
+  if (!fs.existsSync(configPath)) return false;
+  const config = readJsonConfig(configPath);
+  const mcpServers = config.mcpServers ?? {};
+  if (!mcpServers[CLOUD_MCP_KEY]) return false;
+  delete mcpServers[CLOUD_MCP_KEY];
+  config.mcpServers = mcpServers;
+  writeJsonConfig(configPath, config);
+  return true;
+}
+async function runConnect(args, projectDir) {
+  const settings = loadUlpiSettings();
+  const cloudApiUrl = getFlag(args, "url") ?? settings.ulpiUrl ?? process.env.ULPI_CLOUD_URL ?? "https://api.ulpi.io";
+  const apiKey = getFlag(args, "key") ?? settings.apiKeys?.ulpi ?? process.env.ULPI_API_KEY;
+  if (!apiKey) {
+    console.error(chalk.red("Error: API key required."));
+    console.error(chalk.dim("Provide via --key=<apiKey>, settings.json apiKeys.ulpi, or ULPI_API_KEY env var."));
+    console.error(chalk.dim("Run: ulpi config set apiKeys.ulpi <your-key>"));
+    process.exit(1);
+  }
+  const orgId = getFlag(args, "org");
+  if (!orgId) {
+    console.error(chalk.red("Error: Organization ID required."));
+    console.error(chalk.dim("Provide via --org=<orgId>"));
+    process.exit(1);
+  }
+  const connectionUrl = `${cloudApiUrl}/api/orgs/${encodeURIComponent(orgId)}/gateway/connection`;
+  console.log(chalk.dim(`Fetching gateway info from ${connectionUrl}...`));
+  let gatewayInfo;
+  try {
+    const response = await fetchJson(connectionUrl, apiKey);
+    const conn = response.connection;
+    if (!conn || typeof conn.url !== "string" || typeof conn.transport !== "string") {
+      console.error(chalk.red("Error: Invalid gateway response from cloud API."));
+      console.error(chalk.dim(`Response: ${JSON.stringify(response)}`));
+      process.exit(1);
+    }
+    gatewayInfo = { url: conn.url, transport: conn.transport };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Error: Failed to fetch gateway connection info.`));
+    console.error(chalk.dim(message));
+    process.exit(1);
+  }
+  const { mcpServers } = readMcpJson(projectDir);
+  mcpServers[CLOUD_MCP_KEY] = {
+    url: gatewayInfo.url,
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  };
+  writeMcpJson(projectDir, mcpServers);
+  console.log(chalk.green("  Written to .mcp.json"));
+  const cloudEntry = {
+    url: gatewayInfo.url,
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+  const agentTargets = getAgentConfigTargets();
+  for (const target of agentTargets) {
+    const written = writeCloudMcpToAgentConfig(target.configPath, cloudEntry);
+    if (written) {
+      console.log(chalk.green(`  Written to ${target.name} (${chalk.dim(target.configPath)})`));
+    } else {
+      console.log(chalk.dim(`  ${target.name}: already configured`));
+    }
+  }
+  saveCloudGatewayConfig({
+    orgId,
+    url: gatewayInfo.url,
+    transport: gatewayInfo.transport,
+    cloudApiUrl,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log("");
+  console.log(chalk.green("Connected to Cloud MCP Gateway."));
+  console.log(`  Org:       ${chalk.cyan(orgId)}`);
+  console.log(`  Gateway:   ${chalk.cyan(gatewayInfo.url)}`);
+  console.log(`  Transport: ${chalk.cyan(gatewayInfo.transport)}`);
+  console.log("");
+  console.log(chalk.dim("Restart your agent session for the new MCP server to take effect."));
+}
+function runStatus() {
+  const config = loadCloudGatewayConfig();
+  if (!config) {
+    console.log(chalk.yellow("Not connected to any Cloud MCP Gateway."));
+    console.log(chalk.dim("Run: ulpi cloud connect --org=<orgId> --key=<apiKey>"));
+    return;
+  }
+  console.log(chalk.bold("Cloud MCP Gateway Status\n"));
+  console.log(`  Org:         ${chalk.cyan(config.orgId)}`);
+  console.log(`  Gateway URL: ${chalk.cyan(config.url)}`);
+  console.log(`  Transport:   ${chalk.cyan(config.transport)}`);
+  console.log(`  Cloud API:   ${chalk.dim(config.cloudApiUrl)}`);
+  console.log(`  Connected:   ${chalk.dim(config.connectedAt)}`);
+}
+function runDisconnect(projectDir) {
+  let removed = false;
+  const { mcpServers } = readMcpJson(projectDir);
+  if (mcpServers[CLOUD_MCP_KEY]) {
+    delete mcpServers[CLOUD_MCP_KEY];
+    writeMcpJson(projectDir, mcpServers);
+    console.log(chalk.green("  Removed from .mcp.json"));
+    removed = true;
+  }
+  const agentTargets = getAgentConfigTargets();
+  for (const target of agentTargets) {
+    const wasRemoved = removeCloudMcpFromAgentConfig(target.configPath);
+    if (wasRemoved) {
+      console.log(chalk.green(`  Removed from ${target.name} (${chalk.dim(target.configPath)})`));
+      removed = true;
+    }
+  }
+  const configRemoved = removeCloudGatewayConfig();
+  if (configRemoved) {
+    removed = true;
+  }
+  if (removed) {
+    console.log("");
+    console.log(chalk.green("Disconnected from Cloud MCP Gateway."));
+    console.log(chalk.dim("Restart your agent session for changes to take effect."));
+  } else {
+    console.log(chalk.yellow("No cloud gateway connection found."));
+  }
+}
+function printUsage() {
+  console.log(`
+Usage: ulpi cloud <subcommand> [options]
+
+Subcommands:
+  connect      Connect local agent to cloud MCP gateway
+  status       Show current cloud connection status
+  disconnect   Remove cloud gateway from agent configs
+
+Connect Options:
+  --url=<url>    Cloud API URL (default: https://api.ulpi.io)
+  --org=<orgId>  Organization ID (required)
+  --key=<key>    API key (or set via ULPI_API_KEY env / ulpi config)
+
+Examples:
+  ulpi cloud connect --org=org-abc123 --key=sk-...
+  ulpi cloud status
+  ulpi cloud disconnect
+`.trim());
+}
+async function runCloud(args, projectDir) {
+  const sub = args[0];
+  switch (sub) {
+    case "connect":
+      return runConnect(args.slice(1), projectDir);
+    case "status":
+      return runStatus();
+    case "disconnect":
+      return runDisconnect(projectDir);
+    default:
+      printUsage();
+  }
+}
+export {
+  runCloud
+};