@forloop-cc/forloop-cli 0.2.2 → 0.2.3

package/README.md

@@ -99,10 +99,7 @@ That's it. You're connected.
 
 Visit the ForLoop settings page to generate a token:
 
-| Environment | URL |
-|-------------|-----|
 | Production | https://forloop.cc/profile?tab=api-tokens |
-| Development | https://dev.forloop.cc/profile?tab=api-tokens |
 
 Tokens start with `floop_`. Create a token with at least these scopes:
 - `sprint:read`, `sprint:write`
@@ -132,69 +129,6 @@ forloop auth logout          # Remove saved token
 
 ---
 
-## Environments
-
-ForLoop has two environments — **Production** and **Development**. By default, the CLI connects to production. Use the development environment when you want to test features or work on staging data without affecting production.
-
-### Production (default)
-
-No extra setup needed. The CLI connects to `https://api.forloop.cc` automatically.
-
-```bash
-forloop sprint list
-```
-
-### Development
-
-The development environment connects to `https://api.dev.forloop.cc`. You need two things:
-
-1. **A dev API token** — create one at https://dev.forloop.cc/profile?tab=api-tokens
-2. **Environment variables** — the CLI requires explicit opt-in for security:
-
-```bash
-export FORLOOP_ENV=development
-export FORLOOP_ALLOW_DEV=true
-forloop auth login --api-key floop_xxxxx
-```
-
-> **Security note:** `FORLOOP_ALLOW_DEV=true` is required because dev API tokens have fewer restrictions. This flag prevents accidentally using a dev token against production data. Set it only when you intend to use the dev environment.
-
-### One-Liner for Dev
-
-```bash
-FORLOOP_ENV=development FORLOOP_ALLOW_DEV=true forloop sprint list
-```
-
-### Persistent Dev Setup
-
-To always use dev for a specific project, add an `opencode.json` in your project root:
-
-```json
-{
-  "forloop": {
-    "apiUrl": "https://api.dev.forloop.cc",
-    "allowDev": true
-  }
-}
-```
-
-Or set it globally in `~/.config/opencode/config.json`:
-
-```json
-{
-  "forloop": {
-    "apiUrl": "https://api.dev.forloop.cc",
-    "allowDev": true
-  }
-}
-```
-
-| Question | Answer |
-|----------|--------|
-| What happens if I don't set `FORLOOP_ALLOW_DEV=true`? | The CLI will ignore your dev URL and connect to production instead, with a warning message |
-| Can I switch between prod and dev per-command? | Yes, the `--api-url` flag or `FORLOOP_ENV` env var overrides the config |
-| Do I need separate tokens for prod and dev? | Yes — create one token at each environment's settings page |
-
 ---
 
 ## Commands
@@ -419,9 +353,7 @@ These flags work with every command:
 | Variable | Purpose |
 |----------|---------|
 | `FORLOOP_API_KEY` | API token (alternative to `forloop auth login`) |
-| `FORLOOP_API_URL` | Override the API base URL |
-| `FORLOOP_ENV` | Set to `production` or `development` |
-| `FORLOOP_ALLOW_DEV` | Set to `true` to enable dev environment URLs |
+| `FORLOOP_API_URL` | Override the API base URL (e.g., `https://api.dev.forloop.cc`) |
 | `FORLOOP_SPRINT_ID` | Default sprint ID for commands that auto-detect it |
 
 ---
@@ -561,8 +493,7 @@ The CLI resolves configuration from these sources, in priority order:
 ```json
 {
   "forloop": {
-    "apiUrl": "https://api.dev.forloop.cc",
-    "allowDev": true
+    "apiUrl": "https://api.forloop.cc"
   }
 }
 ```
@@ -572,8 +503,7 @@ The CLI resolves configuration from these sources, in priority order:
 ```json
 {
   "forloop": {
-    "apiUrl": "https://api.forloop.cc",
-    "allowDev": false
+    "apiUrl": "https://api.forloop.cc"
   }
 }
 ```
@@ -600,23 +530,11 @@ export FORLOOP_API_KEY=floop_xxxxx
 
 Tokens must start with `floop_`. Double-check you copied the entire token from https://forloop.cc/profile?tab=api-tokens.
 
-### "Dev API URL ignored"
-
-The CLI refuses dev URLs unless you explicitly opt in:
-
-```bash
-export FORLOOP_ALLOW_DEV=true
-export FORLOOP_ENV=development
-```
-
-This is a security measure — dev tokens should never accidentally hit production APIs.
-
 ### "Forbidden" or "Not Found" on Specific Resources
 
 Some resources (organizations, stories, files) return 403/404 when you don't have access or they don't exist in your current environment. Try:
-- Checking you're in the right environment (prod vs dev)
 - Verifying the resource ID exists with `forloop sprint get --id <id>`
-- Checking that your token has the required scopes
+- Checking your token has the required scopes
 
 ### Verbose Debugging
 

package/dist/forloop

@@ -28,7 +28,7 @@ function buildSchema(options) {
 }
 function scanCommandPath(argv, globalOptions = []) {
   const globalSchema = buildSchema(globalOptions);
-  const path3 = [];
+  const path6 = [];
   let i = 0;
   while (i < argv.length) {
     const arg = argv[i];
@@ -48,10 +48,10 @@ function scanCommandPath(argv, globalOptions = []) {
       i++;
       continue;
     }
-    path3.push(arg);
+    path6.push(arg);
     i++;
   }
-  return path3;
+  return path6;
 }
 function parseFlags(argv, options) {
   const schema = buildSchema(options);
@@ -142,8 +142,727 @@ var GLOBAL_OPTIONS = [
   { flag: "--version", description: "Print version" }
 ];
 
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/token-storage.ts
+import { promises as fs } from "fs";
+import path from "path";
+var getTokenPath = () => {
+  return path.join(
+    process.env.HOME || process.env.USERPROFILE || ".",
+    ".config",
+    "forloop",
+    "tokens.json"
+  );
+};
+async function loadTokens() {
+  const tokenPath = getTokenPath();
+  try {
+    const content = await fs.readFile(tokenPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        version: "1.0",
+        note: "ForLoop API tokens - do not share",
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    throw error;
+  }
+}
+async function saveTokens(tokens) {
+  const tokenPath = getTokenPath();
+  const configDir = path.dirname(tokenPath);
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(
+    tokenPath,
+    JSON.stringify(tokens, null, 2),
+    { mode: 384 }
+  );
+}
+async function getToken(profile) {
+  const tokens = await loadTokens();
+  if (profile && tokens.profiles?.[profile]) {
+    return tokens.profiles[profile];
+  }
+  if (tokens.default) return tokens.default;
+  if (tokens.profiles?.["default"]) return tokens.profiles["default"];
+  return null;
+}
+async function setToken(token, profile) {
+  const tokens = await loadTokens();
+  tokens.version = "1.0";
+  tokens.note = "ForLoop API tokens - do not share";
+  if (profile) {
+    if (!tokens.profiles) {
+      tokens.profiles = {};
+    }
+    tokens.profiles[profile] = token;
+  } else {
+    tokens.default = token;
+  }
+  tokens.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTokens(tokens);
+}
+async function clearToken(profile) {
+  const tokens = await loadTokens();
+  if (profile) {
+    if (tokens.profiles) {
+      delete tokens.profiles[profile];
+    }
+  } else {
+    delete tokens.default;
+  }
+  tokens.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTokens(tokens);
+}
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/config.ts
+import fs2 from "fs";
+import path2 from "path";
+var PROD_API_URL = "https://api.forloop.cc";
+var DEV_API_URL = "https://api.dev.forloop.cc";
+var PROD_TOKENS_URL = "https://forloop.cc/profile?tab=api-tokens";
+var DEV_TOKENS_URL = "https://dev.forloop.cc/profile?tab=api-tokens";
+var readJsonFileIfExists = (filePath) => {
+  try {
+    if (!fs2.existsSync(filePath)) return null;
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var getHomeDir = () => {
+  return process.env.HOME || process.env.USERPROFILE || "";
+};
+var getProjectConfig = () => {
+  return readJsonFileIfExists(path2.join(process.cwd(), "opencode.json"));
+};
+var getGlobalConfig = () => {
+  const home = getHomeDir();
+  if (!home) return null;
+  return readJsonFileIfExists(path2.join(home, ".config", "opencode", "config.json"));
+};
+var getNested = (obj, keys) => {
+  let cur = obj;
+  for (const key of keys) {
+    if (!cur || typeof cur !== "object") return void 0;
+    cur = cur[key];
+  }
+  return cur;
+};
+var isTruthy = (value) => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toLowerCase() === "true" || value === "1";
+  return false;
+};
+var normalizeUrl = (value) => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed;
+};
+var isDevUrl = (apiUrl) => {
+  return apiUrl.includes("api.dev.forloop.cc") || apiUrl.includes("dev.forloop.cc");
+};
+var resolveAllowDev = (projectConfig, globalConfig) => {
+  return isTruthy(process.env.FORLOOP_ALLOW_DEV) || isTruthy(getNested(projectConfig, ["forloop", "allowDev"])) || isTruthy(getNested(globalConfig, ["forloop", "allowDev"]));
+};
+var resolveApiUrl = (projectConfig, globalConfig, allowDev) => {
+  const envApiUrl = normalizeUrl(process.env.FORLOOP_API_URL || process.env.FORLOOP_API_BASE);
+  if (envApiUrl) {
+    if (isDevUrl(envApiUrl) && !allowDev) {
+      console.warn("[ForLoop Config] Dev API URL ignored (set FORLOOP_ALLOW_DEV=true to enable)");
+      return PROD_API_URL;
+    }
+    return envApiUrl;
+  }
+  const envName = normalizeUrl(process.env.FORLOOP_ENV);
+  if (envName) {
+    if (envName === "production") return PROD_API_URL;
+    if (envName === "development") {
+      if (!allowDev) {
+        console.warn("[ForLoop Config] FORLOOP_ENV=development ignored (set FORLOOP_ALLOW_DEV=true to enable)");
+        return PROD_API_URL;
+      }
+      return DEV_API_URL;
+    }
+  }
+  const projectApiUrl = normalizeUrl(getNested(projectConfig, ["forloop", "apiUrl"]));
+  if (projectApiUrl) {
+    if (isDevUrl(projectApiUrl) && !allowDev) {
+      console.warn("[ForLoop Config] Project dev API URL ignored (set forloop.allowDev=true or FORLOOP_ALLOW_DEV=true)");
+      return PROD_API_URL;
+    }
+    return projectApiUrl;
+  }
+  const globalApiUrl = normalizeUrl(getNested(globalConfig, ["forloop", "apiUrl"]));
+  if (globalApiUrl) {
+    if (isDevUrl(globalApiUrl) && !allowDev) {
+      console.warn("[ForLoop Config] Global dev API URL ignored (set forloop.allowDev=true or FORLOOP_ALLOW_DEV=true)");
+      return PROD_API_URL;
+    }
+    return globalApiUrl;
+  }
+  return PROD_API_URL;
+};
+var detectEnvironment = (apiUrl) => {
+  if (apiUrl.includes("dev.forloop.cc")) {
+    return "development";
+  }
+  if (apiUrl.includes("api.forloop.cc")) {
+    return "production";
+  }
+  return "custom";
+};
+var getConfig = () => {
+  const projectConfig = getProjectConfig();
+  const globalConfig = getGlobalConfig();
+  const allowDev = resolveAllowDev(projectConfig, globalConfig);
+  const apiUrl = resolveApiUrl(projectConfig, globalConfig, allowDev);
+  return {
+    apiUrl,
+    environment: detectEnvironment(apiUrl),
+    tokenStorage: "global",
+    debug: process.env.FORLOOP_DEBUG === "true",
+    allowDev
+  };
+};
+var getTokensUrl = () => {
+  const config = getConfig();
+  if (config.environment === "development") return DEV_TOKENS_URL;
+  return PROD_TOKENS_URL;
+};
+var isLambdaExecution = () => {
+  const forced = (process.env.FORLOOP_EXECUTION_CONTEXT || "").toLowerCase();
+  if (forced === "lambda" || forced === "aws_lambda" || forced === "aws-lambda") return true;
+  return !!(process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.AWS_EXECUTION_ENV || process.env.LAMBDA_TASK_ROOT);
+};
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/auth.ts
+function detectTokenType(token) {
+  if (!token) return null;
+  if (token.startsWith("floop_")) {
+    return "api_key";
+  }
+  const parts = token.split(".");
+  if (parts.length === 3 && parts.every((p) => p.length > 0)) {
+    const base64urlRegex = /^[A-Za-z0-9_-]+$/;
+    if (parts.every((p) => base64urlRegex.test(p))) {
+      return "jwt";
+    }
+  }
+  return null;
+}
+async function validateToken(providedToken) {
+  const token = providedToken || await getToken();
+  if (!token) {
+    return {
+      valid: false,
+      error: "No API token configured. Please create a token at " + getTokensUrl()
+    };
+  }
+  const tokenType = detectTokenType(token);
+  if (!tokenType) {
+    return {
+      valid: false,
+      error: "Unrecognized token format. Use either a ForLoop API key (floop_*) or a valid JWT token."
+    };
+  }
+  if (tokenType === "jwt") {
+    const isLambda = isLambdaExecution();
+    if (!isLambda) {
+      return {
+        valid: false,
+        error: "JWT tokens are only supported in Lambda execution. Please use a ForLoop API key (floop_*) for local execution."
+      };
+    }
+    return {
+      valid: true,
+      token,
+      tokenType: "jwt"
+    };
+  }
+  return {
+    valid: true,
+    token,
+    tokenType: "api_key"
+  };
+}
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/api-client.ts
+var APIError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "APIError";
+  }
+};
+var ForLoopAPIClient = class {
+  config;
+  defaultHeaders;
+  tokenType;
+  jwtExchangePromise;
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      retryCount: 3,
+      ...config
+    };
+    this.defaultHeaders = {
+      "Content-Type": "application/json"
+    };
+    this.tokenType = detectTokenType(config.token);
+    this.jwtExchangePromise = null;
+  }
+  setToken(token) {
+    this.config.token = token;
+    this.tokenType = detectTokenType(token);
+  }
+  async ensureOpencodeApiToken(endpoint) {
+    if (this.tokenType !== "jwt") return;
+    if (!endpoint.startsWith("/api/opencode/")) return;
+    if (endpoint.startsWith("/api/opencode/auth/tokens")) return;
+    if (!this.jwtExchangePromise) {
+      this.jwtExchangePromise = this.exchangeJwtForApiToken();
+    }
+    const token = await this.jwtExchangePromise;
+    this.setToken(token);
+  }
+  async exchangeJwtForApiToken() {
+    const url = `${this.config.baseUrl}/api/opencode/auth/tokens`;
+    const jwt = this.config.token;
+    const scopes = [
+      "sprint:read",
+      "sprint:write",
+      "story:read",
+      "story:write",
+      "story:delete",
+      "agent:read",
+      "agent:query",
+      "profile:read",
+      "organization:read",
+      "organization:write",
+      "organization:delete"
+    ];
+    const name = `lambda-planner-${Date.now()}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.defaultHeaders,
+        Authorization: `Bearer ${jwt}`
+      },
+      body: JSON.stringify({
+        name,
+        expiresIn: "7d",
+        scopes
+      }),
+      signal: AbortSignal.timeout(this.config.timeout)
+    });
+    if (!response.ok) {
+      throw await this.parseError(response);
+    }
+    const payload = await response.json();
+    const token = typeof payload?.token === "string" ? payload.token.trim() : "";
+    if (!token) {
+      throw new APIError("invalid_token_exchange", "Token exchange returned empty token", 500);
+    }
+    await setToken(token);
+    return token;
+  }
+  /**
+   * Get auth headers based on token type
+   * - JWT tokens: Authorization: Bearer <token>
+   * - API keys: X-API-Token: <token>
+   */
+  getAuthHeaders() {
+    const headers = {};
+    if (this.tokenType === "jwt") {
+      headers["Authorization"] = `Bearer ${this.config.token}`;
+    } else {
+      headers["X-API-Token"] = this.config.token;
+    }
+    return headers;
+  }
+  async request(endpoint, options = {}) {
+    await this.ensureOpencodeApiToken(endpoint);
+    const url = `${this.config.baseUrl}${endpoint}`;
+    let lastError = null;
+    for (let attempt = 1; attempt <= this.config.retryCount; attempt++) {
+      try {
+        const response = await fetch(url, {
+          ...options,
+          headers: {
+            ...this.defaultHeaders,
+            ...this.getAuthHeaders(),
+            // Dynamic auth headers based on token type
+            ...options.headers || {}
+          },
+          signal: AbortSignal.timeout(this.config.timeout)
+        });
+        if (!response.ok) {
+          const error = await this.parseError(response);
+          throw error;
+        }
+        return response.json();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof APIError && error.status >= 400 && error.status < 500) {
+          throw error;
+        }
+        if (attempt < this.config.retryCount) {
+          await this.sleep(Math.pow(2, attempt) * 100);
+        }
+      }
+    }
+    throw lastError || new Error("Request failed");
+  }
+  async parseError(response) {
+    try {
+      const body = await response.json();
+      return new APIError(body.error || "UnknownError", body.message || response.statusText, response.status);
+    } catch {
+      return new APIError("UnknownError", response.statusText, response.status);
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async listSprints(params) {
+    const query = new URLSearchParams(params);
+    const response = await this.request(`/api/opencode/sprints?${query}`);
+    return Array.isArray(response) ? response : response.data || [];
+  }
+  async getSprint(id, options) {
+    const query = new URLSearchParams({
+      includeStories: options?.includeStories !== false ? "true" : "false",
+      includeFiles: options?.includeFiles !== false ? "true" : "false"
+    });
+    return this.request(`/api/opencode/sprints/${id}?${query}`);
+  }
+  async createSprint(data) {
+    return this.request("/api/opencode/sprints", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateSprint(id, data) {
+    return this.request(`/api/opencode/sprints/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteSprint(id) {
+    await this.request(`/api/opencode/sprints/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async createStory(data) {
+    return this.request("/api/opencode/stories", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getStory(id, options) {
+    const params = new URLSearchParams();
+    if (options?.includeComments) params.set("includeComments", "true");
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.request(`/api/opencode/stories/${id}${query}`);
+  }
+  async updateStory(id, data) {
+    return this.request(`/api/opencode/stories/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteStory(id) {
+    await this.request(`/api/opencode/stories/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async listTemplates() {
+    return this.request("/api/opencode/templates");
+  }
+  async getUserProfile() {
+    return this.request("/api/opencode/user/profile");
+  }
+  async getUserQuotas() {
+    return this.request("/api/opencode/user/quotas");
+  }
+  async getOrganizationQuotas(orgId) {
+    return this.request(`/api/opencode/organization/${orgId}/quotas`);
+  }
+  async listOrganizations() {
+    return this.request("/api/opencode/organizations");
+  }
+  async getOwnedOrganizations() {
+    return this.request("/api/opencode/organizations/owned");
+  }
+  async getOrganization(id) {
+    return this.request(`/api/opencode/organizations/${id}`);
+  }
+  async createOrganization(data) {
+    return this.request("/api/opencode/organizations", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateOrganization(id, data) {
+    return this.request(`/api/opencode/organizations/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteOrganization(id) {
+    await this.request(`/api/opencode/organizations/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async chatWithAI(request) {
+    return this.request("/api/opencode/agents/chat", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async getDeveloperStatus(sprintId) {
+    return this.request(`/api/opencode/sprints/${sprintId}/developer-status`);
+  }
+  async getStorySuggestions(sprintId, storyId) {
+    return this.request("/api/opencode/agents/suggestions", {
+      method: "POST",
+      body: JSON.stringify({ sprintId, storyId })
+    });
+  }
+  async getAITasks(sprintId) {
+    const query = sprintId ? new URLSearchParams({ sprintId: String(sprintId) }) : new URLSearchParams();
+    return this.request(`/api/opencode/agents/tasks?${query}`);
+  }
+  async getSprintSummaries(sprintId) {
+    return this.request(`/api/opencode/agents/summary?sprintId=${sprintId}`);
+  }
+  async getAgentSuggestions(request) {
+    return this.request("/api/agents/suggestions", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async getStoryBreakdown(storyId) {
+    return this.request(`/api/agents/stories/${storyId}/breakdown`);
+  }
+  async getStoryEstimate(storyId) {
+    return this.request(`/api/agents/stories/${storyId}/estimate`);
+  }
+  async getConversationHistory(params) {
+    const query = new URLSearchParams();
+    if (params?.sprintId) query.append("sprintId", String(params.sprintId));
+    if (params?.limit) query.append("limit", String(params.limit));
+    return this.request(`/api/opencode/messages?${query}`);
+  }
+  async clearConversationHistory(params) {
+    const query = new URLSearchParams();
+    if (params?.sprintId) query.append("sprintId", String(params.sprintId));
+    query.append("confirm", "true");
+    return this.request(`/api/opencode/messages?${query}`, {
+      method: "DELETE"
+    });
+  }
+  async createPresignedUpload(data) {
+    return this.request("/api/opencode/files/presign", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async completeUpload(data) {
+    return this.request("/api/opencode/files/complete", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getSprintFiles(sprintId) {
+    return this.request(`/api/opencode/files/sprint/${sprintId}`);
+  }
+  async deleteFile(fileId) {
+    await this.request(`/api/opencode/files/${fileId}`, {
+      method: "DELETE"
+    });
+  }
+  async logFileRead(fileId) {
+    await this.request(`/api/opencode/files/${fileId}/read`, {
+      method: "POST"
+    });
+  }
+  async getFileDownloadUrl(fileId) {
+    return this.request(`/api/opencode/files/download/${fileId}`);
+  }
+  async getFileOpenUrl(fileId) {
+    return this.request(`/api/opencode/files/open-url/${fileId}`);
+  }
+  async updateFilePosition(fileId, data) {
+    return this.request(`/api/opencode/files/${fileId}/position`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async listAiAgents() {
+    const response = await this.request("/api/opencode/ai/agents");
+    return response.agents || [];
+  }
+  async updateSprintAiAgents(sprintId, enabledAgentKeys) {
+    const response = await this.request(`/api/opencode/sprints/${sprintId}/ai-agents`, {
+      method: "PUT",
+      body: JSON.stringify({ enabledAgentKeys })
+    });
+    return response.sprintAiAgents || [];
+  }
+  async updateSchedule(storyId, data) {
+    return this.updateStory(storyId, {
+      title: data.title,
+      description: data.description,
+      metadata: data
+    });
+  }
+  async recordMessage(data) {
+    return this.request("/api/opencode/messages", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async removeMessage(messageId, sprintId, sessionId) {
+    await this.request(`/api/opencode/messages/${encodeURIComponent(messageId)}`, {
+      method: "DELETE",
+      body: JSON.stringify({ sprintId, sessionId })
+    });
+  }
+};
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/sprint-tools.ts
+import { tool } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/capabilities/context-resolver.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs3 from "fs";
+import * as path3 from "path";
+var execAsync = promisify(exec);
+async function getCurrentBranch(directory) {
+  try {
+    const result = await execAsync("git rev-parse --abbrev-ref HEAD", {
+      cwd: directory
+    });
+    return result.stdout.trim();
+  } catch (error) {
+    throw new Error("Git not available or not in a repository");
+  }
+}
+async function resolveSprintFromBranch(branch) {
+  const match = branch.match(/sprint-(\d+)/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return null;
+}
+async function resolveSprintId(providedId, directory) {
+  if (providedId) {
+    return { sprintId: providedId, source: "provided" };
+  }
+  const envSprintId = process.env.FORLOOP_SPRINT_ID;
+  if (envSprintId) {
+    return { sprintId: parseInt(envSprintId, 10), source: "env" };
+  }
+  const manifestSprintId = getActiveSprintIdFromManifest(directory);
+  if (manifestSprintId) {
+    return { sprintId: manifestSprintId, source: "manifest" };
+  }
+  try {
+    const branch = await getCurrentBranch(directory);
+    const sprintId = await resolveSprintFromBranch(branch);
+    if (sprintId) {
+      return { sprintId, branch, source: "branch" };
+    }
+  } catch (error) {
+  }
+  return { source: "config" };
+}
+function getActiveSprintIdFromManifest(directory) {
+  const candidates = [];
+  if (directory) {
+    candidates.push(path3.join(directory, ".forloop", "manifest.json"));
+  }
+  const home = process.env.HOME;
+  if (home) {
+    candidates.push(path3.join(home, ".forloop", "manifest.json"));
+  }
+  for (const filePath of candidates) {
+    try {
+      if (!fs3.existsSync(filePath)) continue;
+      const raw = fs3.readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const id = parsed?.activeSprintId;
+      if (Number.isFinite(id)) return Number(id);
+    } catch {
+    }
+  }
+  return null;
+}
+var DEFAULT_HOME = "/tmp/home";
+function getSprintDir(sprintId) {
+  return `sprint-${sprintId}`;
+}
+function getForloopRoot(sprintId) {
+  const home = process.env.HOME || DEFAULT_HOME;
+  const root = path3.join(home, ".forloop");
+  if (sprintId !== void 0) {
+    return path3.join(root, getSprintDir(sprintId));
+  }
+  return root;
+}
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/story-tools.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/template-tools.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/user-tools.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/organization-tools.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/file-tools.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/schedule-tools.ts
+import { tool as tool7 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/folder-tools.ts
+import { tool as tool8 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/sync-tools.ts
+import { tool as tool9 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/agent-tools.ts
+import { tool as tool10 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/agent-suggestion-tools.ts
+import { tool as tool11 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/agent-sprint-tools.ts
+import { tool as tool12 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/ai-trigger-tools.ts
+import { tool as tool13 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/tools/developer-status-tool.ts
+import { tool as tool14 } from "@opencode-ai/plugin";
+
+// node_modules/@forloop-cc/forloop-opencode-plugin-planner/plugins/hooks/shell-env.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+
 // src/commands/auth/index.ts
-import { getToken, setToken, clearToken, validateToken } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createAuthCommands() {
   return {
     "auth login": createAuthLoginCommand(),
@@ -211,7 +930,6 @@ function createAuthLogoutCommand() {
 }
 
 // src/commands/story.ts
-import { ForLoopAPIClient, getToken as getToken2, getConfig } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createStoryCommands() {
   return {
     "story create": createStoryCreateCommand(),
@@ -222,7 +940,7 @@ function createStoryCommands() {
 }
 async function getClient() {
   const config = getConfig();
-  const token = await getToken2();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured. Run: forloop auth login --api-key <token>");
     process.exit(1);
@@ -412,7 +1130,6 @@ function createStoryDeleteCommand() {
 }
 
 // src/commands/sprint.ts
-import { ForLoopAPIClient as ForLoopAPIClient2, getToken as getToken3, resolveSprintId as resolveSprintId2, getConfig as getConfig2 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createSprintCommands() {
   return {
     "sprint get": createSprintGetCommand(),
@@ -423,13 +1140,13 @@ function createSprintCommands() {
   };
 }
 async function getClient2() {
-  const config = getConfig2();
-  const token = await getToken3();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured. Run: forloop auth login --api-key <token>");
     process.exit(1);
   }
-  const client = new ForLoopAPIClient2({ token, baseUrl: config.apiUrl });
+  const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl });
   return { client };
 }
 function formatDate(dateString) {
@@ -450,7 +1167,7 @@ function createSprintGetCommand() {
       const resolved = await getClient2();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId2(flags.id);
+      const resolution = await resolveSprintId(flags.id);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved. Use --id, set FORLOOP_SPRINT_ID, or use a sprint-XXX branch.");
         process.exit(1);
@@ -599,7 +1316,6 @@ function createSprintDeleteCommand() {
 }
 
 // src/commands/org.ts
-import { ForLoopAPIClient as ForLoopAPIClient3, getToken as getToken4, getConfig as getConfig3 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createOrgCommands() {
   return {
     "org list": createOrgListCommand(),
@@ -609,13 +1325,13 @@ function createOrgCommands() {
   };
 }
 async function getClient3() {
-  const config = getConfig3();
-  const token = await getToken4();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured. Run: forloop auth login --api-key <token>");
     process.exit(1);
   }
-  return { client: new ForLoopAPIClient3({ token, baseUrl: config.apiUrl }) };
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl }) };
 }
 function createOrgListCommand() {
   return defineCommand({
@@ -723,7 +1439,6 @@ function createOrgUpdateCommand() {
 }
 
 // src/commands/template.ts
-import { ForLoopAPIClient as ForLoopAPIClient4, getToken as getToken5, getConfig as getConfig4 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createTemplateCommands() {
   return {
     "template list": createTemplateListCommand()
@@ -736,13 +1451,13 @@ function createTemplateListCommand() {
     usage: "forloop template list",
     examples: ["forloop template list"],
     async run(_config) {
-      const config = getConfig4();
-      const token = await getToken5();
+      const config = getConfig();
+      const token = await getToken();
       if (!token) {
         console.error("Error: No API token configured.");
         process.exit(1);
       }
-      const client = new ForLoopAPIClient4({ token, baseUrl: config.apiUrl });
+      const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl });
       const templates = await client.listTemplates();
       const active = templates.filter((t) => !t.deletedAt);
       if (!active.length) {
@@ -764,7 +1479,6 @@ function createTemplateListCommand() {
 }
 
 // src/commands/agent.ts
-import { ForLoopAPIClient as ForLoopAPIClient5, getToken as getToken6, resolveSprintId as resolveSprintId3, getConfig as getConfig5 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createAgentCommands() {
   return {
     "agent history": createAgentHistoryCommand(),
@@ -773,13 +1487,13 @@ function createAgentCommands() {
   };
 }
 async function getClient4() {
-  const config = getConfig5();
-  const token = await getToken6();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured.");
     process.exit(1);
   }
-  return { client: new ForLoopAPIClient5({ token, baseUrl: config.apiUrl }) };
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl }) };
 }
 function createAgentHistoryCommand() {
   return defineCommand({
@@ -795,7 +1509,7 @@ function createAgentHistoryCommand() {
       const resolved = await getClient4();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId3(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       const sprintId = resolution.sprintId || flags.sprint;
       const history = await client.getConversationHistory({
         sprintId,
@@ -866,7 +1580,7 @@ function createDeveloperStatusCommand() {
       const resolved = await getClient4();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId3(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
@@ -878,11 +1592,11 @@ function createDeveloperStatusCommand() {
         console.log(`Sprint #${resolution.sprintId}: ${sprint.storiesDone || 0}/${sprint.storiesTotal || 0} stories done.`);
         return;
       }
-      const exec = status.execution || {};
+      const exec3 = status.execution || {};
       const task = status.task || {};
-      console.log(`Developer Task: ${exec.status}`);
+      console.log(`Developer Task: ${exec3.status}`);
       console.log(`Sprint: #${resolution.sprintId}`);
-      if (exec.startedAt) console.log(`Started: ${new Date(exec.startedAt).toLocaleString()}`);
+      if (exec3.startedAt) console.log(`Started: ${new Date(exec3.startedAt).toLocaleString()}`);
       if (task.branchName) console.log(`Branch: ${task.branchName}`);
       if (task.errorMessage) console.log(`Error: ${task.errorMessage}`);
       console.log(`Progress: ${sprint.storiesDone || 0}/${sprint.storiesTotal || 0} done, ${sprint.storiesInProgress || 0} in progress.`);
@@ -891,7 +1605,6 @@ function createDeveloperStatusCommand() {
 }
 
 // src/commands/user.ts
-import { ForLoopAPIClient as ForLoopAPIClient6, getToken as getToken7, getConfig as getConfig6 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createUserCommands() {
   return {
     "user profile": createUserProfileCommand(),
@@ -900,13 +1613,13 @@ function createUserCommands() {
   };
 }
 async function getClient5() {
-  const config = getConfig6();
-  const token = await getToken7();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured.");
     process.exit(1);
   }
-  return { client: new ForLoopAPIClient6({ token, baseUrl: config.apiUrl }) };
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl }) };
 }
 function createUserProfileCommand() {
   return defineCommand({
@@ -966,9 +1679,8 @@ function createOrgQuotasCommand() {
 }
 
 // src/commands/file.ts
-import { ForLoopAPIClient as ForLoopAPIClient7, getToken as getToken8, getConfig as getConfig7 } from "@forloop-cc/forloop-opencode-plugin-planner";
-import * as fs from "fs";
-import * as path from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 function createFileCommands() {
   return {
     "file upload": createFileUploadCommand(),
@@ -978,13 +1690,13 @@ function createFileCommands() {
   };
 }
 async function getClient6() {
-  const config = getConfig7();
-  const token = await getToken8();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured.");
     process.exit(1);
   }
-  return { client: new ForLoopAPIClient7({ token, baseUrl: config.apiUrl }) };
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl }) };
 }
 var mimeTypes = {
   ".png": "image/png",
@@ -1023,13 +1735,13 @@ function createFileUploadCommand() {
       if (!resolved) return;
       const { client } = resolved;
       const filePath = flags.path;
-      if (!fs.existsSync(filePath)) {
+      if (!fs4.existsSync(filePath)) {
         console.error(`Error: File not found: ${filePath}`);
         process.exit(1);
       }
-      const fileContent = fs.readFileSync(filePath);
-      const fileName = path.basename(filePath);
-      const ext = path.extname(fileName);
+      const fileContent = fs4.readFileSync(filePath);
+      const fileName = path4.basename(filePath);
+      const ext = path4.extname(fileName);
       const contentType = mimeTypes[ext] || "application/octet-stream";
       const presign = await client.createPresignedUpload({
         sprintId: flags.sprint,
@@ -1132,7 +1844,6 @@ function createFileDownloadCommand() {
 }
 
 // src/commands/folder.ts
-import { ForLoopAPIClient as ForLoopAPIClient8, getToken as getToken9, getConfig as getConfig8 } from "@forloop-cc/forloop-opencode-plugin-planner";
 function createFolderCommands() {
   return {
     "folder create": createFolderCreateCommand()
@@ -1151,13 +1862,13 @@ function createFolderCreateCommand() {
     ],
     examples: ['forloop folder create --title "Project Docs" --sprint 1 --permissions team'],
     async run(_config, flags) {
-      const config = getConfig8();
-      const token = await getToken9();
+      const config = getConfig();
+      const token = await getToken();
       if (!token) {
         console.error("Error: No API token configured.");
         process.exit(1);
       }
-      const client = new ForLoopAPIClient8({ token, baseUrl: config.apiUrl });
+      const client = new ForLoopAPIClient({ token, baseUrl: config.apiUrl });
       const story = await client.createStory({
         title: flags.title,
         description: flags.description,
@@ -1172,9 +1883,8 @@ function createFolderCreateCommand() {
 }
 
 // src/commands/sync.ts
-import { ForLoopAPIClient as ForLoopAPIClient9, getToken as getToken10, resolveSprintId as resolveSprintId4, getConfig as getConfig9, getForloopRoot } from "@forloop-cc/forloop-opencode-plugin-planner";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function createSyncCommands() {
   return {
     "sync aivy-folder": createSyncAivyFolderCommand(),
@@ -1184,13 +1894,13 @@ function createSyncCommands() {
   };
 }
 async function getClient7() {
-  const config = getConfig9();
-  const token = await getToken10();
+  const config = getConfig();
+  const token = await getToken();
   if (!token) {
     console.error("Error: No API token configured.");
     process.exit(1);
   }
-  return { client: new ForLoopAPIClient9({ token, baseUrl: config.apiUrl }) };
+  return { client: new ForLoopAPIClient({ token, baseUrl: config.apiUrl }) };
 }
 function createSyncAivyFolderCommand() {
   return defineCommand({
@@ -1206,7 +1916,7 @@ function createSyncAivyFolderCommand() {
       const resolved = await getClient7();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId4(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
@@ -1243,7 +1953,7 @@ function createAivyDocGetCommand() {
       const resolved = await getClient7();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId4(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
@@ -1277,14 +1987,14 @@ function createS3ToLocalCommand() {
       const resolved = await getClient7();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId4(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
       }
       const files = await client.getSprintFiles(resolution.sprintId);
       const localRoot = getForloopRoot(resolution.sprintId);
-      fs2.mkdirSync(localRoot, { recursive: true });
+      fs5.mkdirSync(localRoot, { recursive: true });
       let downloaded = 0;
       let skipped = 0;
       for (const file of files) {
@@ -1299,9 +2009,9 @@ function createS3ToLocalCommand() {
         if (res.ok) {
           const buf = Buffer.from(await res.arrayBuffer());
           const kind = name.startsWith("knowledge-") ? "knowledge" : name.startsWith("plan-") ? "plan" : name.startsWith("task-") ? "task" : "other";
-          const dir = path2.join(localRoot, kind);
-          fs2.mkdirSync(dir, { recursive: true });
-          fs2.writeFileSync(path2.join(dir, name), buf);
+          const dir = path5.join(localRoot, kind);
+          fs5.mkdirSync(dir, { recursive: true });
+          fs5.writeFileSync(path5.join(dir, name), buf);
           downloaded++;
         }
       }
@@ -1325,18 +2035,18 @@ function createLocalToS3Command() {
       const resolved = await getClient7();
       if (!resolved) return;
       const { client } = resolved;
-      const resolution = await resolveSprintId4(flags.sprint);
+      const resolution = await resolveSprintId(flags.sprint);
       if (!resolution.sprintId) {
         console.error("Error: No sprint ID resolved.");
         process.exit(1);
       }
       const filePath = flags.path;
-      if (!fs2.existsSync(filePath)) {
+      if (!fs5.existsSync(filePath)) {
         console.error(`Error: File not found: ${filePath}`);
         process.exit(1);
       }
-      const fileBuf = fs2.readFileSync(filePath);
-      const fileName = path2.basename(filePath);
+      const fileBuf = fs5.readFileSync(filePath);
+      const fileName = path5.basename(filePath);
       const contentType = "text/markdown";
       const folder = flags.folder || "project";
       const presign = await client.createPresignedUpload({
@@ -1367,12 +2077,12 @@ function createLocalToS3Command() {
 var CommandRegistry = class {
   root = { children: /* @__PURE__ */ new Map() };
   constructor(commands) {
-    for (const [path3, cmd] of Object.entries(commands)) {
-      this.register(path3, cmd);
+    for (const [path6, cmd] of Object.entries(commands)) {
+      this.register(path6, cmd);
     }
   }
-  register(path3, command) {
-    const parts = path3.split(" ");
+  register(path6, command) {
+    const parts = path6.split(" ");
     let node = this.root;
     for (const part of parts) {
       if (!node.children.has(part)) {
@@ -1652,10 +2362,7 @@ Tip: ${suggestion}
 }
 
 // src/main.ts
-import { getConfig as getConfig10 } from "@forloop-cc/forloop-opencode-plugin-planner";
-import { getToken as getToken11 } from "@forloop-cc/forloop-opencode-plugin-planner";
-import { detectTokenType } from "@forloop-cc/forloop-opencode-plugin-planner";
-var CLI_VERSION = "0.2.2";
+var CLI_VERSION = "0.2.3";
 process.on("SIGINT", () => {
   process.stderr.write("\nInterrupted. Exiting.\n");
   process.exit(130);
@@ -1682,7 +2389,7 @@ async function main() {
   if (commandPath.length === 0) {
     registry.printHelp([], process.stderr);
     try {
-      const token2 = await getToken11();
+      const token2 = await getToken();
       if (token2) {
         const tokenType = detectTokenType(token2);
         const masked = token2.slice(0, 8) + "..." + token2.slice(-4);
@@ -1703,8 +2410,8 @@ async function main() {
   const { command, extra } = registry.resolve(commandPath);
   const flags = parseFlags(argv, [...GLOBAL_OPTIONS, ...command.options ?? []]);
   if (extra.length > 0) flags._positional = extra;
-  const pluginConfig = getConfig10();
-  const token = await getToken11();
+  const pluginConfig = getConfig();
+  const token = await getToken();
   const isNoAuth = NO_AUTH_COMMANDS.some(
     (cmd) => cmd.every((c, i) => commandPath[i] === c)
   );
@@ -1715,7 +2422,7 @@ async function main() {
     process.exit(3);
   }
   const cliConfig = {
-    region: pluginConfig.apiUrl.includes("dev.forloop.cc") ? "dev" : "global",
+    region: "global",
     apiUrl: pluginConfig.apiUrl,
     serverLambdaUrl: "",
     environment: pluginConfig.environment,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forloop-cc/forloop-cli",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Command-line interface for the ForLoop AI development platform",
   "type": "module",
   "license": "MIT",