@dk/jolly 0.1.6 → 0.1.7

package/dist/bootstrap.js

@@ -11,43 +11,66 @@ class SaleorCloudClient {
     }
   }
   async request(endpoint, options) {
-    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+    const mergedOptions = {
+      method: options?.method || "GET",
       ...options,
       headers: {
-        Authorization: `Bearer ${this.token}`,
+        Authorization: `Token ${this.token}`,
         "Content-Type": "application/json",
         ...options?.headers
       }
-    });
+    };
+    const response = await fetch(`${this.baseUrl}${endpoint}`, mergedOptions);
     if (!response.ok) {
-      throw new Error(`API error: ${response.status} ${response.statusText}`);
+      const body = await response.text();
+      throw new Error(`API error: ${response.status} ${response.statusText} - ${body}`);
     }
     return response.json();
   }
-  async getStores() {
-    return this.request("/stores");
+  async getOrganizations() {
+    return this.request("/organizations");
   }
-  async createStore(name, region = "us-east-1") {
-    return this.request("/stores", {
+  async getProjects(organizationSlug) {
+    return this.request(`/organizations/${organizationSlug}/projects`);
+  }
+  async createProject(organizationSlug, name, region) {
+    return this.request(`/organizations/${organizationSlug}/projects`, {
       method: "POST",
       body: JSON.stringify({ name, region })
     });
   }
-  async getEnvironments(storeId) {
-    return this.request(`/stores/${storeId}/environments`);
+  async getEnvironments(organizationSlug, projectSlug) {
+    return this.request(`/organizations/${organizationSlug}/projects/${projectSlug}/environments`);
   }
-  async createEnvironment(storeId, name) {
-    return this.request(`/stores/${storeId}/environments`, {
+  async createEnvironment(organizationSlug, projectSlug, name, region) {
+    return this.request(`/organizations/${organizationSlug}/projects/${projectSlug}/environments`, {
       method: "POST",
-      body: JSON.stringify({ name })
+      body: JSON.stringify({ name, region })
     });
   }
+  async getEnvironment(organizationSlug, projectSlug, environmentSlug) {
+    return this.request(`/organizations/${organizationSlug}/projects/${projectSlug}/environments/${environmentSlug}`);
+  }
   async registerApp(environmentId, appType, name) {
     return this.request(`/environments/${environmentId}/apps`, {
       method: "POST",
       body: JSON.stringify({ type: appType, name })
     });
   }
+  async getStores() {
+    return this.getOrganizations();
+  }
+  async createStore(name, region = "us-east-1") {
+    const { organizations } = await this.getOrganizations();
+    if (organizations.length === 0) {
+      throw new Error("No organizations found. Create one at https://cloud.saleor.io");
+    }
+    return this.createProject(organizations[0].slug, name, region);
+  }
+  async createEnvironmentFromStore(storeId, name) {
+    const { environments } = await this.getEnvironments(storeId, "default");
+    return this.createEnvironment(storeId, environments.length > 0 ? environments[0].project?.slug || "default" : "default", name, "default");
+  }
 }
 
 // src/api/auth.ts
@@ -129,8 +152,8 @@ async function createStore(name, region) {
   try {
     const result = await client.createStore(name, region);
     console.log(success(`Store created successfully!`));
-    console.log(info(`Store ID: ${result.store.id}`));
-    console.log(info(`Dashboard: https://cloud.saleor.io/stores/${result.store.id}`));
+    console.log(info(`Project slug: ${result.project.slug}`));
+    console.log(info(`Dashboard: https://cloud.saleor.io/organizations/default/projects/${result.project.slug}`));
   } catch (err) {
     console.log(error(`Failed to create store: ${err}`));
     process.exit(1);

package/dist/index.js

@@ -33,43 +33,66 @@ class SaleorCloudClient {
     }
   }
   async request(endpoint, options) {
-    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+    const mergedOptions = {
+      method: options?.method || "GET",
       ...options,
       headers: {
-        Authorization: `Bearer ${this.token}`,
+        Authorization: `Token ${this.token}`,
         "Content-Type": "application/json",
         ...options?.headers
       }
-    });
+    };
+    const response = await fetch(`${this.baseUrl}${endpoint}`, mergedOptions);
     if (!response.ok) {
-      throw new Error(`API error: ${response.status} ${response.statusText}`);
+      const body = await response.text();
+      throw new Error(`API error: ${response.status} ${response.statusText} - ${body}`);
     }
     return response.json();
   }
-  async getStores() {
-    return this.request("/stores");
+  async getOrganizations() {
+    return this.request("/organizations");
   }
-  async createStore(name, region = "us-east-1") {
-    return this.request("/stores", {
+  async getProjects(organizationSlug) {
+    return this.request(`/organizations/${organizationSlug}/projects`);
+  }
+  async createProject(organizationSlug, name, region) {
+    return this.request(`/organizations/${organizationSlug}/projects`, {
       method: "POST",
       body: JSON.stringify({ name, region })
     });
   }
-  async getEnvironments(storeId) {
-    return this.request(`/stores/${storeId}/environments`);
+  async getEnvironments(organizationSlug, projectSlug) {
+    return this.request(`/organizations/${organizationSlug}/projects/${projectSlug}/environments`);
   }
-  async createEnvironment(storeId, name) {
-    return this.request(`/stores/${storeId}/environments`, {
+  async createEnvironment(organizationSlug, projectSlug, name, region) {
+    return this.request(`/organizations/${organizationSlug}/projects/${projectSlug}/environments`, {
       method: "POST",
-      body: JSON.stringify({ name })
+      body: JSON.stringify({ name, region })
     });
   }
+  async getEnvironment(organizationSlug, projectSlug, environmentSlug) {
+    return this.request(`/organizations/${organizationSlug}/projects/${projectSlug}/environments/${environmentSlug}`);
+  }
   async registerApp(environmentId, appType, name) {
     return this.request(`/environments/${environmentId}/apps`, {
       method: "POST",
       body: JSON.stringify({ type: appType, name })
     });
   }
+  async getStores() {
+    return this.getOrganizations();
+  }
+  async createStore(name, region = "us-east-1") {
+    const { organizations } = await this.getOrganizations();
+    if (organizations.length === 0) {
+      throw new Error("No organizations found. Create one at https://cloud.saleor.io");
+    }
+    return this.createProject(organizations[0].slug, name, region);
+  }
+  async createEnvironmentFromStore(storeId, name) {
+    const { environments } = await this.getEnvironments(storeId, "default");
+    return this.createEnvironment(storeId, environments.length > 0 ? environments[0].project?.slug || "default" : "default", name, "default");
+  }
 }
 
 // src/api/auth.ts
@@ -198,8 +221,8 @@ async function createStore(name, region) {
   try {
     const result = await client.createStore(name, region);
     console.log(success(`Store created successfully!`));
-    console.log(info(`Store ID: ${result.store.id}`));
-    console.log(info(`Dashboard: https://cloud.saleor.io/stores/${result.store.id}`));
+    console.log(info(`Project slug: ${result.project.slug}`));
+    console.log(info(`Dashboard: https://cloud.saleor.io/organizations/default/projects/${result.project.slug}`));
   } catch (err) {
     console.log(error(`Failed to create store: ${err}`));
     process.exit(1);
@@ -208,19 +231,19 @@ async function createStore(name, region) {
 async function listStores() {
   const token = requireToken();
   const client = new SaleorCloudClient(token);
-  console.log(info("Fetching stores..."));
+  console.log(info("Fetching organizations..."));
   try {
-    const result = await client.getStores();
-    if (result.stores.length === 0) {
-      console.log(info("No stores found. Create one with: jolly store create --name <name>"));
+    const { organizations } = await client.getOrganizations();
+    if (organizations.length === 0) {
+      console.log(info("No organizations found. Create one at https://cloud.saleor.io"));
       return;
     }
-    console.log(success(`Found ${result.stores.length} store(s):
+    console.log(success(`Found ${organizations.length} organization(s):
 `));
-    for (const store of result.stores) {
-      console.log(`  ${store.name} (${store.id})`);
-      console.log(`    Region: ${store.region}`);
-      console.log(`    Created: ${new Date(store.created_at).toLocaleDateString()}`);
+    for (const org of organizations) {
+      console.log(`  ${org.name} (${org.slug})`);
+      console.log(`    Email: ${org.owner_email}`);
+      console.log(`    Created: ${new Date(org.created).toLocaleDateString()}`);
       console.log();
     }
   } catch (err) {
@@ -228,15 +251,15 @@ async function listStores() {
     process.exit(1);
   }
 }
-async function createEnvironment(storeId, name) {
+async function createEnvironment(organizationSlug, name) {
   const token = requireToken();
   const client = new SaleorCloudClient(token);
-  console.log(info(`Creating environment: ${name} for store ${storeId}...`));
+  console.log(info(`Creating environment: ${name} for organization ${organizationSlug}...`));
   try {
-    const result = await client.createEnvironment(storeId, name);
+    const { environment } = await client.createEnvironment(organizationSlug, "default", name, "us-east-1");
     console.log(success(`Environment created successfully!`));
-    console.log(info(`Environment ID: ${result.environment.id}`));
-    console.log(info(`API URL will be available at: https://${result.environment.id}.saleor.cloud`));
+    console.log(info(`Environment key: ${environment.key}`));
+    console.log(info(`Domain: ${environment.domain}`));
   } catch (err) {
     console.log(error(`Failed to create environment: ${err}`));
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dk/jolly",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Saleor project bootstrapper and agent configurator",
   "type": "module",
   "bin": {

package/src/api/client.ts

@@ -10,63 +10,136 @@ export class SaleorCloudClient {
   }
 
   async request<T>(endpoint: string, options?: RequestInit): Promise<T> {
-    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+    const mergedOptions: RequestInit = {
+      method: options?.method || 'GET',
       ...options,
       headers: {
-        'Authorization': `Bearer ${this.token}`,
+        'Authorization': `Token ${this.token}`,
         'Content-Type': 'application/json',
         ...options?.headers,
       },
-    });
+    };
+
+    const response = await fetch(`${this.baseUrl}${endpoint}`, mergedOptions);
 
     if (!response.ok) {
-      throw new Error(`API error: ${response.status} ${response.statusText}`);
+      const body = await response.text();
+      throw new Error(`API error: ${response.status} ${response.statusText} - ${body}`);
     }
 
-    return response.json();
+    return response.json() as T;
   }
 
-  async getStores() {
-    return this.request<{ stores: Store[] }>('/stores');
+  // Organizations
+  async getOrganizations() {
+    return this.request<{ organizations: Organization[] }>('/organizations');
   }
 
-  async createStore(name: string, region: string = 'us-east-1') {
-    return this.request<{ store: Store }>('/stores', {
+  // Projects
+  async getProjects(organizationSlug: string) {
+    return this.request<{ projects: Project[] }>(`/organizations/${organizationSlug}/projects`);
+  }
+
+  async createProject(organizationSlug: string, name: string, region: string) {
+    return this.request<{ project: Project }>(`/organizations/${organizationSlug}/projects`, {
       method: 'POST',
       body: JSON.stringify({ name, region }),
     });
   }
 
-  async getEnvironments(storeId: string) {
-    return this.request<{ environments: Environment[] }>(`/stores/${storeId}/environments`);
+  // Environments
+  async getEnvironments(organizationSlug: string, projectSlug: string) {
+    return this.request<{ environments: Environment[] }>(
+      `/organizations/${organizationSlug}/projects/${projectSlug}/environments`
+    );
   }
 
-  async createEnvironment(storeId: string, name: string) {
-    return this.request<{ environment: Environment }>(`/stores/${storeId}/environments`, {
-      method: 'POST',
-      body: JSON.stringify({ name }),
-    });
+  async createEnvironment(organizationSlug: string, projectSlug: string, name: string, region: string) {
+    return this.request<{ environment: Environment; task: Task }>(
+      `/organizations/${organizationSlug}/projects/${projectSlug}/environments`,
+      {
+        method: 'POST',
+        body: JSON.stringify({ name, region }),
+      }
+    );
   }
 
+  async getEnvironment(organizationSlug: string, projectSlug: string, environmentSlug: string) {
+    return this.request<Environment>(
+      `/organizations/${organizationSlug}/projects/${projectSlug}/environments/${environmentSlug}`
+    );
+  }
+
+  // Apps
   async registerApp(environmentId: string, appType: string, name: string) {
     return this.request<{ app: App }>(`/environments/${environmentId}/apps`, {
       method: 'POST',
       body: JSON.stringify({ type: appType, name }),
     });
   }
+
+  // Backward compatibility methods
+  async getStores() {
+    return this.getOrganizations();
+  }
+
+  async createStore(name: string, region: string = 'us-east-1') {
+    // Create organization as "store" - requires org slug
+    // For now, create in first available org
+    const { organizations } = await this.getOrganizations();
+    if (organizations.length === 0) {
+      throw new Error('No organizations found. Create one at https://cloud.saleor.io');
+    }
+    return this.createProject(organizations[0].slug, name, region);
+  }
+
+  async createEnvironmentFromStore(storeId: string, name: string) {
+    // storeId is used as organization slug for backward compatibility
+    const { environments } = await this.getEnvironments(storeId, 'default');
+    // Create sandbox environment
+    return this.createEnvironment(storeId, environments.length > 0 ? environments[0].project?.slug || 'default' : 'default', name, 'default');
+  }
 }
 
-export interface Store {
-  id: string;
+export interface Organization {
+  slug: string;
+  name: string;
+  created: string;
+  company_name?: string;
+  owner_email: string;
+}
+
+export interface Project {
+  slug: string;
   name: string;
   region: string;
-  created_at: string;
+  created: string;
+  billing_period?: { start: string };
+  sandboxes: { count: number };
 }
 
 export interface Environment {
+  key: string;
+  name: string;
+  domain: string;
+  service: {
+    version: string;
+    type: string;
+    region: string;
+  };
+  created: string;
+  project: { name: string; slug: string };
+}
+
+export interface Task {
+  id: string;
+  status: string;
+}
+
+export interface Store {
   id: string;
   name: string;
-  store_id: string;
+  region: string;
   created_at: string;
 }
 

package/src/commands/store.ts

@@ -11,8 +11,8 @@ export async function createStore(name: string, region: string): Promise<void> {
   try {
     const result = await client.createStore(name, region);
     console.log(success(`Store created successfully!`));
-    console.log(info(`Store ID: ${result.store.id}`));
-    console.log(info(`Dashboard: https://cloud.saleor.io/stores/${result.store.id}`));
+    console.log(info(`Project slug: ${result.project.slug}`));
+    console.log(info(`Dashboard: https://cloud.saleor.io/organizations/default/projects/${result.project.slug}`));
   } catch (err) {
     console.log(error(`Failed to create store: ${err}`));
     process.exit(1);
@@ -23,21 +23,21 @@ export async function listStores(): Promise<void> {
   const token = requireToken();
   const client = new SaleorCloudClient(token);
 
-  console.log(info('Fetching stores...'));
+  console.log(info('Fetching organizations...'));
 
   try {
-    const result = await client.getStores();
+    const { organizations } = await client.getOrganizations();
 
-    if (result.stores.length === 0) {
-      console.log(info('No stores found. Create one with: jolly store create --name <name>'));
+    if (organizations.length === 0) {
+      console.log(info('No organizations found. Create one at https://cloud.saleor.io'));
       return;
     }
 
-    console.log(success(`Found ${result.stores.length} store(s):\n`));
-    for (const store of result.stores) {
-      console.log(`  ${store.name} (${store.id})`);
-      console.log(`    Region: ${store.region}`);
-      console.log(`    Created: ${new Date(store.created_at).toLocaleDateString()}`);
+    console.log(success(`Found ${organizations.length} organization(s):\n`));
+    for (const org of organizations) {
+      console.log(`  ${org.name} (${org.slug})`);
+      console.log(`    Email: ${org.owner_email}`);
+      console.log(`    Created: ${new Date(org.created).toLocaleDateString()}`);
       console.log();
     }
   } catch (err) {
@@ -46,17 +46,17 @@ export async function listStores(): Promise<void> {
   }
 }
 
-export async function createEnvironment(storeId: string, name: string): Promise<void> {
+export async function createEnvironment(organizationSlug: string, name: string): Promise<void> {
   const token = requireToken();
   const client = new SaleorCloudClient(token);
 
-  console.log(info(`Creating environment: ${name} for store ${storeId}...`));
+  console.log(info(`Creating environment: ${name} for organization ${organizationSlug}...`));
 
   try {
-    const result = await client.createEnvironment(storeId, name);
+    const { environment } = await client.createEnvironment(organizationSlug, 'default', name, 'us-east-1');
     console.log(success(`Environment created successfully!`));
-    console.log(info(`Environment ID: ${result.environment.id}`));
-    console.log(info(`API URL will be available at: https://${result.environment.id}.saleor.cloud`));
+    console.log(info(`Environment key: ${environment.key}`));
+    console.log(info(`Domain: ${environment.domain}`));
   } catch (err) {
     console.log(error(`Failed to create environment: ${err}`));
     process.exit(1);

package/src/test/command-handlers.test.ts

@@ -36,67 +36,72 @@ describe('Command Handlers', () => {
   describe('Store Handlers', () => {
     Given('a valid token and successful API', () => {
       When('calling createStore', () => {
-        Then('it should call POST /stores with name and region', async () => {
+        Then('it should call POST /organizations/:slug/projects with name and region', async () => {
           const fetchMock = mockFetch({
-            '/stores': { store: fixtures.store },
+            '/organizations': { organizations: [fixtures.organization] },
+            '/organizations/my-org/projects': { project: fixtures.project },
           });
 
           const { createStore } = await import('../commands/store');
           await createStore('my-store', 'us-east-1');
 
-          expect(fetchMock).toHaveBeenCalledTimes(1);
-          const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toContain('/stores');
-          expect(opts.method).toBe('POST');
-          expect(JSON.parse(opts.body)).toEqual({ name: 'my-store', region: 'us-east-1' });
+          expect(fetchMock).toHaveBeenCalled();
+          const createCall = fetchMock.mock.calls.find(([url]: [string]) => 
+            (url as string).includes('/organizations/my-org/projects')
+          );
+          expect(createCall).toBeDefined();
+          expect(createCall?.[1].method).toBe('POST');
+          expect(JSON.parse(createCall?.[1].body)).toEqual({ name: 'my-store', region: 'us-east-1' });
         });
       });
 
       When('calling listStores with results', () => {
-        Then('it should display store names and IDs', async () => {
+        Then('it should display organization names and slugs', async () => {
           mockFetch({
-            '/stores': { stores: [fixtures.store, fixtures.store2] },
+            '/organizations': { organizations: [fixtures.organization, fixtures.organization2] },
           });
 
           const { listStores } = await import('../commands/store');
           await listStores();
 
           const allOutput = console_.logs.join('\n');
-          expect(allOutput).toContain('my-store');
-          expect(allOutput).toContain('store-1');
-          expect(allOutput).toContain('other-store');
-          expect(allOutput).toContain('store-2');
+          expect(allOutput).toContain('My Organization');
+          expect(allOutput).toContain('my-org');
+          expect(allOutput).toContain('Other Organization');
+          expect(allOutput).toContain('other-org');
         });
       });
 
       When('calling listStores with empty results', () => {
         Then('it should display a helpful message', async () => {
           mockFetch({
-            '/stores': { stores: [] },
+            '/organizations': { organizations: [] },
           });
 
           const { listStores } = await import('../commands/store');
           await listStores();
 
           const infoMessages = tuiCalls.filter(c => c.fn === 'info').map(c => c.msg).join('\n');
-          expect(infoMessages).toContain('No stores found');
+          expect(infoMessages).toContain('No organizations found');
         });
       });
 
       When('calling createEnvironment', () => {
-        Then('it should call POST /stores/:id/environments', async () => {
+        Then('it should call POST /organizations/:slug/projects/:slug/environments', async () => {
           const fetchMock = mockFetch({
-            '/stores/store-1/environments': { environment: fixtures.environment },
+            '/organizations/my-org/projects/default/environments': { environment: fixtures.environment },
           });
 
           const { createEnvironment } = await import('../commands/store');
-          await createEnvironment('store-1', 'staging');
-
-          expect(fetchMock).toHaveBeenCalledTimes(1);
-          const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toContain('/stores/store-1/environments');
-          expect(opts.method).toBe('POST');
-          expect(JSON.parse(opts.body)).toEqual({ name: 'staging' });
+          await createEnvironment('my-org', 'staging');
+
+          expect(fetchMock).toHaveBeenCalled();
+          const createCall = fetchMock.mock.calls.find(([url]: [string]) => 
+            (url as string).includes('/organizations/my-org/projects/default/environments')
+          );
+          expect(createCall).toBeDefined();
+          expect(createCall?.[1].method).toBe('POST');
+          expect(JSON.parse(createCall?.[1].body)).toEqual({ name: 'staging', region: 'us-east-1' });
         });
       });
     });
@@ -137,7 +142,7 @@ describe('Command Handlers', () => {
           const { createEnvironment } = await import('../commands/store');
 
           try {
-            await createEnvironment('bad-store', 'staging');
+            await createEnvironment('bad-org', 'staging');
           } catch {}
 
           expect(exitSpy).toHaveBeenCalledWith(1);
@@ -194,15 +199,15 @@ describe('Command Handlers', () => {
       When('calling createApp', () => {
         Then('it should register the hosted app via API', async () => {
           const fetchMock = mockFetch({
-            '/environments/env-1/apps': { app: fixtures.app },
+            '/environments/staging/apps': { app: fixtures.app },
           });
 
           const { createApp } = await import('../commands/app');
-          await createApp('pay-app', 'payment', 'env-1', 'dummy');
+          await createApp('pay-app', 'payment', 'staging', 'dummy');
 
           expect(fetchMock).toHaveBeenCalledTimes(1);
           const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toContain('/environments/env-1/apps');
+          expect(url).toContain('/environments/staging/apps');
           expect(opts.method).toBe('POST');
         });
       });
@@ -216,7 +221,7 @@ describe('Command Handlers', () => {
           const { createApp } = await import('../commands/app');
 
           try {
-            await createApp('pay-app', 'payment', 'env-1', 'dummy');
+            await createApp('pay-app', 'payment', 'staging', 'dummy');
           } catch {}
 
           expect(exitSpy).toHaveBeenCalledWith(1);

package/src/test/e2e-flows.test.ts

@@ -36,30 +36,31 @@ describe('End-to-End Flows', () => {
   describe('Store Creation Flow', () => {
     Given('a valid token and working API', () => {
       When('creating a store end-to-end', () => {
-        Then('it should call API and display store ID and dashboard URL', async () => {
+        Then('it should call API and display project slug and dashboard URL', async () => {
           const fetchMock = mockFetch({
-            '/stores': { store: fixtures.store },
+            '/organizations': { organizations: [fixtures.organization] },
+            '/organizations/my-org/projects': { project: fixtures.project },
           });
 
           const { createStore } = await import('../commands/store');
           await createStore('my-store', 'us-east-1');
 
-          expect(fetchMock).toHaveBeenCalledTimes(1);
+          expect(fetchMock).toHaveBeenCalled();
 
           const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('store-1');
-          expect(allTui).toContain('cloud.saleor.io/stores/store-1');
+          expect(allTui).toContain('my-store');
+          expect(allTui).toContain('cloud.saleor.io');
         });
       });
     });
   });
 
   describe('Store List Flow', () => {
-    Given('a valid token and multiple stores', () => {
+    Given('a valid token and multiple organizations', () => {
       When('listing stores end-to-end', () => {
-        Then('it should display all stores with regions and dates', async () => {
+        Then('it should display all organizations with emails and dates', async () => {
           mockFetch({
-            '/stores': { stores: [fixtures.store, fixtures.store2] },
+            '/organizations': { organizations: [fixtures.organization, fixtures.organization2] },
           });
 
           const { listStores } = await import('../commands/store');
@@ -67,31 +68,31 @@ describe('End-to-End Flows', () => {
 
           const allTui = tuiCalls.map(c => c.msg).join('\n');
           const allConsole = console_.logs.join('\n');
-          expect(allTui).toContain('2 store(s)');
-          expect(allConsole).toContain('my-store');
-          expect(allConsole).toContain('us-east-1');
-          expect(allConsole).toContain('other-store');
-          expect(allConsole).toContain('eu-west-1');
+          expect(allTui).toContain('2 organization(s)');
+          expect(allConsole).toContain('My Organization');
+          expect(allConsole).toContain('owner@example.com');
+          expect(allConsole).toContain('Other Organization');
+          expect(allConsole).toContain('other@example.com');
         });
       });
     });
   });
 
   describe('Environment Creation Flow', () => {
-    Given('a valid token and existing store', () => {
+    Given('a valid token and existing organization', () => {
       When('creating an environment end-to-end', () => {
-        Then('it should call API and display environment ID and URL', async () => {
+        Then('it should call API and display environment key and domain', async () => {
           const fetchMock = mockFetch({
-            '/stores/store-1/environments': { environment: fixtures.environment },
+            '/organizations/my-org/projects/default/environments': { environment: fixtures.environment },
           });
 
           const { createEnvironment } = await import('../commands/store');
-          await createEnvironment('store-1', 'staging');
+          await createEnvironment('my-org', 'staging');
 
-          expect(fetchMock).toHaveBeenCalledTimes(1);
+          expect(fetchMock).toHaveBeenCalled();
 
           const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('env-1');
+          expect(allTui).toContain('staging');
           expect(allTui).toContain('saleor.cloud');
         });
       });
@@ -103,11 +104,11 @@ describe('End-to-End Flows', () => {
       When('creating a payment app with environment', () => {
         Then('it should register via API and display app ID', async () => {
           const fetchMock = mockFetch({
-            '/environments/env-1/apps': { app: fixtures.app },
+            '/environments/staging/apps': { app: fixtures.app },
           });
 
           const { createApp } = await import('../commands/app');
-          await createApp('my-payment', 'payment', 'env-1', 'stripe');
+          await createApp('my-payment', 'payment', 'staging', 'stripe');
 
           expect(fetchMock).toHaveBeenCalledTimes(1);
 
@@ -138,7 +139,7 @@ describe('End-to-End Flows', () => {
       When('attempting any store operation', () => {
         Then('it should fail fast with auth error before API call', async () => {
           withoutToken();
-          const fetchMock = mockFetch({ '/stores': { stores: [] } });
+          const fetchMock = mockFetch({ '/organizations': { organizations: [] } });
 
           const { listStores } = await import('../commands/store');
 
@@ -173,37 +174,55 @@ describe('End-to-End Flows', () => {
 
   describe('API Client Request Construction', () => {
     Given('a SaleorCloudClient', () => {
-      When('creating a store', () => {
+      When('listing organizations', () => {
+        Then('it should send correct URL, method, and headers', async () => {
+          const fetchMock = mockFetch({
+            '/organizations': { organizations: [fixtures.organization] },
+          });
+
+          const { SaleorCloudClient } = await import('../api/client');
+          const client = new SaleorCloudClient(fixtures.token);
+          await client.getOrganizations();
+
+          expect(fetchMock).toHaveBeenCalledTimes(1);
+          const [url, opts] = fetchMock.mock.calls[0];
+          expect(url).toBe('https://cloud.saleor.io/api/organizations');
+          expect(opts.method).toBe('GET');
+          expect(opts.headers.Authorization).toBe(`Token ${fixtures.token}`);
+        });
+      });
+
+      When('creating a project', () => {
         Then('it should send correct URL, method, headers, and body', async () => {
           const fetchMock = mockFetch({
-            '/stores': { store: fixtures.store },
+            '/organizations/default/projects': { project: fixtures.project },
           });
 
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
-          await client.createStore('test-store', 'eu-west-1');
+          await client.createProject('default', 'test-store', 'eu-west-1');
 
           expect(fetchMock).toHaveBeenCalledTimes(1);
           const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toBe('https://cloud.saleor.io/api/stores');
+          expect(url).toBe('https://cloud.saleor.io/api/organizations/default/projects');
           expect(opts.method).toBe('POST');
-          expect(opts.headers.Authorization).toBe(`Bearer ${fixtures.token}`);
+          expect(opts.headers.Authorization).toBe(`Token ${fixtures.token}`);
           expect(JSON.parse(opts.body)).toEqual({ name: 'test-store', region: 'eu-west-1' });
         });
       });
 
       When('registering an app', () => {
-        Then('it should send correct URL with environment ID', async () => {
+        Then('it should send correct URL with environment key', async () => {
           const fetchMock = mockFetch({
-            '/environments/env-1/apps': { app: fixtures.app },
+            '/environments/staging/apps': { app: fixtures.app },
           });
 
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
-          await client.registerApp('env-1', 'payment', 'my-app');
+          await client.registerApp('staging', 'payment', 'my-app');
 
           const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toBe('https://cloud.saleor.io/api/environments/env-1/apps');
+          expect(url).toBe('https://cloud.saleor.io/api/environments/staging/apps');
           expect(JSON.parse(opts.body)).toEqual({ type: 'payment', name: 'my-app' });
         });
       });

package/src/test/entry-points.test.ts

@@ -50,7 +50,10 @@ describe('Entry Points', () => {
       When('bootstrap calls createStore', () => {
         Then('it should pass project name and default region', async () => {
           withToken();
-          mockFetch({ '/stores': { store: fixtures.store } });
+          mockFetch({
+            '/organizations': { organizations: [fixtures.organization] },
+            '/organizations/my-org/projects': { project: fixtures.project },
+          });
 
           const { createStore } = await import('../commands/store');
           await createStore('my-project', 'us-east-1');

package/src/test/error-handling.test.ts

@@ -76,7 +76,7 @@ describe('Error Handling', () => {
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
 
-          await expect(client.getStores()).rejects.toThrow('401');
+          await expect(client.getOrganizations()).rejects.toThrow('401');
         });
       });
 
@@ -87,7 +87,7 @@ describe('Error Handling', () => {
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
 
-          await expect(client.createStore('test', 'us-east-1')).rejects.toThrow('403');
+          await expect(client.createProject('test-org', 'test', 'us-east-1')).rejects.toThrow('403');
         });
       });
 
@@ -98,7 +98,7 @@ describe('Error Handling', () => {
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
 
-          await expect(client.getEnvironments('store-1')).rejects.toThrow('500');
+          await expect(client.getEnvironments('test-org', 'test-project')).rejects.toThrow('500');
         });
       });
 
@@ -109,7 +109,7 @@ describe('Error Handling', () => {
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
 
-          await expect(client.createEnvironment('bad-id', 'staging')).rejects.toThrow('404');
+          await expect(client.createEnvironment('bad-org', 'bad-project', 'staging', 'us-east-1')).rejects.toThrow('404');
         });
       });
     });
@@ -118,17 +118,17 @@ describe('Error Handling', () => {
   describe('API Request Headers', () => {
     Given('a SaleorCloudClient with a token', () => {
       When('making any request', () => {
-        Then('it should include Authorization Bearer header', async () => {
+        Then('it should include Authorization Token header', async () => {
           const fetchMock = mockFetch({
-            '/stores': { stores: [] },
+            '/organizations': { organizations: [] },
           });
 
           const { SaleorCloudClient } = await import('../api/client');
           const client = new SaleorCloudClient(fixtures.token);
-          await client.getStores();
+          await client.getOrganizations();
 
           const [, opts] = fetchMock.mock.calls[0];
-          expect(opts.headers.Authorization).toBe(`Bearer ${fixtures.token}`);
+          expect(opts.headers.Authorization).toBe(`Token ${fixtures.token}`);
           expect(opts.headers['Content-Type']).toBe('application/json');
         });
       });

package/src/test/mocks.ts

@@ -1,44 +1,84 @@
 import { mock, spyOn } from 'bun:test';
-import type { Store, Environment, App } from '../api/client';
+import type { Organization, Project, Environment, App } from '../api/client';
 
 export const fixtures = {
   token: 'test-token-abc123',
 
-  store: {
-    id: 'store-1',
+  // New API structure: Organizations → Projects → Environments
+  organization: {
+    slug: 'my-org',
+    name: 'My Organization',
+    created: '2025-01-01T00:00:00Z',
+    owner_email: 'owner@example.com',
+    company_name: 'My Company',
+  } satisfies Organization,
+
+  organization2: {
+    slug: 'other-org',
+    name: 'Other Organization',
+    created: '2025-06-15T00:00:00Z',
+    owner_email: 'other@example.com',
+  } satisfies Organization,
+
+  project: {
+    slug: 'my-store',
     name: 'my-store',
     region: 'us-east-1',
-    created_at: '2025-01-01T00:00:00Z',
-  } satisfies Store,
+    created: '2025-01-01T00:00:00Z',
+    sandboxes: { count: 2 },
+  } satisfies Project,
 
-  store2: {
-    id: 'store-2',
+  project2: {
+    slug: 'other-store',
     name: 'other-store',
     region: 'eu-west-1',
-    created_at: '2025-06-15T00:00:00Z',
-  } satisfies Store,
+    created: '2025-06-15T00:00:00Z',
+    sandboxes: { count: 1 },
+  } satisfies Project,
 
   environment: {
-    id: 'env-1',
+    key: 'staging',
     name: 'staging',
-    store_id: 'store-1',
-    created_at: '2025-01-02T00:00:00Z',
+    domain: 'staging-my-store.saleor.cloud',
+    service: {
+      version: '3.15.0',
+      type: 'main',
+      region: 'us-east-1',
+    },
+    created: '2025-01-02T00:00:00Z',
+    project: { name: 'my-store', slug: 'my-store' },
   } satisfies Environment,
 
   app: {
     id: 'app-1',
     name: 'my-app',
     type: 'payment',
-    environment_id: 'env-1',
+    environment_id: 'staging',
   } satisfies App,
+
+  // Backward compat aliases (for tests that haven't been migrated yet)
+  store: {
+    id: 'my-org',
+    name: 'My Organization',
+    region: 'us-east-1',
+    created_at: '2025-01-01T00:00:00Z',
+  },
+  store2: {
+    id: 'other-org',
+    name: 'Other Organization',
+    region: 'eu-west-1',
+    created_at: '2025-06-15T00:00:00Z',
+  },
 };
 
 export function mockFetch(routes: Record<string, unknown>): ReturnType<typeof mock> {
   const handler = mock((url: string | URL | Request, init?: RequestInit) => {
     const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
 
-    for (const [pattern, body] of Object.entries(routes)) {
-      if (urlStr.includes(pattern)) {
+    const sortedEntries = Object.entries(routes).sort((a, b) => b[0].length - a[0].length);
+
+    for (const [pattern, body] of sortedEntries) {
+      if (urlStr.endsWith(pattern)) {
         return Promise.resolve(new Response(JSON.stringify(body), {
           status: 200,
           headers: { 'Content-Type': 'application/json' },