@factorialco/fcode-cli 3.0.0 → 3.2.0

package/dist/services/dashboard-client.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardApiError = void 0;
 exports.dashboardApiUrl = dashboardApiUrl;
 const node_fetch_1 = require("node-fetch");
 const auth_service_1 = require("./auth-service");
@@ -12,6 +13,45 @@ const global_1 = require("../config/global");
  */
 /** Max the dashboard's list endpoints accept (`listQuerySchema`), so a team is one round trip. */
 const PAGE_SIZE = 200;
+/** A non-2xx answer from the dashboard, carrying the RFC 9457 problem details it sent. */
+class DashboardApiError extends Error {
+    constructor(status, path, detail, code) {
+        super(`Dashboard API ${status} on ${path}: ${detail}`);
+        this.status = status;
+        this.path = path;
+        this.detail = detail;
+        this.code = code;
+        this.name = 'DashboardApiError';
+    }
+}
+exports.DashboardApiError = DashboardApiError;
+const appReadmePath = (id) => `/apps/${id}/readme`;
+function mapApp({ id, name, description, publication_state, logo_content_type }) {
+    return { id, name, description, publicationState: publication_state, logoContentType: logo_content_type ?? null };
+}
+function mapMarketplaceMetadata(raw) {
+    return {
+        fullDescription: raw.full_description,
+        tagline: raw.tagline,
+        datoCategoryId: raw.dato_category_id,
+        supportLink: raw.support_link,
+        helpLink: raw.help_link,
+        datocmsId: raw.datocms_id,
+    };
+}
+function mapRelease(raw) {
+    return {
+        id: raw.id,
+        version: raw.version,
+        comments: raw.comments,
+        status: raw.status,
+        error: raw.error,
+        requestedBy: raw.requested_by,
+        deployedAt: raw.deployed_at,
+        stableAt: raw.stable_at,
+        createdAt: raw.created_at,
+    };
+}
 /**
  * `https://code.factorialhr.com/platform` → `https://code.factorialhr.com/dashboard/api/v1`.
  * The dashboard is served under `/dashboard` on the same origin as the platform; environments
@@ -43,7 +83,52 @@ class DashboardClient {
             sort_by: 'name',
             sort_dir: 'asc',
         });
-        return items.map(({ id, name, description }) => ({ id, name, description }));
+        return items.map(mapApp);
+    }
+    async getApp(appId) {
+        return mapApp(await this.request('GET', `/apps/${appId}`));
+    }
+    async getAppReadme(appId) {
+        const { readme } = await this.request('GET', appReadmePath(appId));
+        return { readme: readme ?? null };
+    }
+    async putAppReadme(appId, readme) {
+        const response = await this.request('PUT', appReadmePath(appId), { body: { readme } });
+        return { readme: response.readme ?? null };
+    }
+    async getAppMarketplace(appId) {
+        const { metadata } = await this.request('GET', `/apps/${appId}/marketplace`);
+        return { metadata: metadata ? mapMarketplaceMetadata(metadata) : null };
+    }
+    /** Full replace: every field travels, nulls included, since an absent key clears on the dashboard. */
+    async putAppMarketplace(appId, input) {
+        const raw = await this.request('PUT', `/apps/${appId}/marketplace`, {
+            body: {
+                full_description: input.fullDescription,
+                tagline: input.tagline,
+                dato_category_id: input.datoCategoryId,
+                support_link: input.supportLink,
+                help_link: input.helpLink,
+            },
+        });
+        return mapMarketplaceMetadata(raw);
+    }
+    async listAppReleases(appId) {
+        const items = await this.getAllPages(`/apps/${appId}/releases`);
+        return items.map(mapRelease);
+    }
+    /** The App's logo bytes, or null when it has none. */
+    async getAppLogo(appId) {
+        return this.getBinary(`/apps/${appId}/logo`);
+    }
+    /** The global workspaces owned by a development team. */
+    async listTeamGlobalWorkspaces(teamId) {
+        const items = await this.getAllPages('/global-workspaces', {
+            owner_development_team_id: teamId,
+            sort_by: 'slug',
+            sort_dir: 'asc',
+        });
+        return items.map(({ id, name, slug, description }) => ({ id, name, slug, description }));
     }
     async getAllPages(path, query = {}) {
         const items = [];
@@ -67,32 +152,62 @@ class DashboardClient {
         return items;
     }
     async get(path, query) {
-        const url = `${this.baseUrl}${path}?${new URLSearchParams(query).toString()}`;
-        let response = await (0, node_fetch_1.default)(url, { headers: await this.headers() });
+        return this.request('GET', path, { query });
+    }
+    async request(method, path, options = {}) {
+        const response = await this.send(method, path, options);
+        return (await response.json());
+    }
+    async getBinary(path) {
+        try {
+            const response = await this.send('GET', path, { accept: 'image/*' });
+            return { buffer: await response.buffer(), contentType: response.headers.get('content-type') ?? '' };
+        }
+        catch (error) {
+            if (error instanceof DashboardApiError && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async send(method, path, { query, body, accept }) {
+        const search = query ? `?${new URLSearchParams(query).toString()}` : '';
+        const url = `${this.baseUrl}${path}${search}`;
+        const init = async () => ({
+            method,
+            headers: await this.headers(accept, body !== undefined),
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        let response = await (0, node_fetch_1.default)(url, await init());
         // The token's group membership is snapshotted at issuance (FCT-61231), so a team joined after
         // login reads as a denial. Re-mint once and retry before believing it.
         if (response.status === 401 || response.status === 403) {
             if (await auth_service_1.default.refreshSession(this.cloudUrl)) {
-                response = await (0, node_fetch_1.default)(url, { headers: await this.headers() });
+                response = await (0, node_fetch_1.default)(url, await init());
             }
         }
         if (!response.ok) {
-            throw new Error(`Dashboard API ${response.status} on ${path}: ${await this.errorDetail(response)}`);
+            const { detail, code } = await this.errorDetail(response);
+            throw new DashboardApiError(response.status, path, detail, code);
         }
-        return (await response.json());
+        return response;
     }
-    async headers() {
+    async headers(accept = 'application/json', withBody = false) {
         const { token } = await this.globalConfig.getAuthInfo(this.cloudUrl);
-        return { accept: 'application/json', authorization: `Bearer ${token.access_token}` };
+        return {
+            accept,
+            authorization: `Bearer ${token.access_token}`,
+            ...(withBody ? { 'content-type': 'application/json' } : {}),
+        };
     }
     async errorDetail(response) {
         try {
             const body = await response.text();
             const parsed = JSON.parse(body);
-            return parsed.detail ?? parsed.message ?? body;
+            return { detail: parsed.detail ?? parsed.message ?? body, code: parsed.code };
         }
         catch {
-            return 'no response body';
+            return { detail: 'no response body' };
         }
     }
 }

package/dist/services/dev-team-service.d.ts

@@ -1,18 +1,27 @@
-import DashboardClient, { DevelopmentTeam, DevelopmentTeamApp } from './dashboard-client';
-import { DevTeamApp, DevTeamMetadata } from '../config/dev-team';
-/** What a team folder has to do to match the team as the dashboard currently describes it. */
-export interface AppSyncPlan {
+import DashboardClient, { DevelopmentTeam, DevelopmentTeamApp, DevelopmentTeamGlobalWorkspace } from './dashboard-client';
+import { DevTeamMetadata } from '../config/dev-team';
+import { AppMetadataSource } from './app-metadata-files';
+/** What the dashboard currently says the team holds. */
+export interface DevTeamRemote {
+    apps: DevelopmentTeamApp[];
+    globalWorkspaces: DevelopmentTeamGlobalWorkspace[];
+}
+export declare function fetchTeamRemote(client: DashboardClient, teamId: string): Promise<DevTeamRemote>;
+/** What a team folder has to do to make one kind of entry match the dashboard. */
+export interface SyncPlan<Remote, Recorded> {
     /** In the team, with no folder yet — cloned. */
-    toClone: DevelopmentTeamApp[];
+    toClone: Remote[];
     /** In the team and already cloned — refreshed and pulled. */
-    toRefresh: DevelopmentTeamApp[];
+    toRefresh: Remote[];
     /** Recorded locally but no longer in the team — reported, never deleted. */
     removed: Array<{
         id: string;
-        app: DevTeamApp;
+        recorded: Recorded;
     }>;
 }
-export declare function planAppSync(metadata: DevTeamMetadata, apps: DevelopmentTeamApp[]): AppSyncPlan;
+export declare function planSync<Remote extends {
+    id: string;
+}, Recorded>(recorded: Record<string, Recorded>, remote: Remote[]): SyncPlan<Remote, Recorded>;
 /**
  * The folder an App gets inside the team root. Names are free text and two Apps may well slugify
  * the same, so the first claimant keeps the plain slug and the next ones are suffixed. Only ever
@@ -20,20 +29,28 @@ export declare function planAppSync(metadata: DevTeamMetadata, apps: Development
  * a renamed App keeps the folder it was cloned into.
  */
 export declare function assignFolder(app: DevelopmentTeamApp, metadata: DevTeamMetadata): string;
-export interface AppSyncOutcome {
+export interface TeamSyncOutcome {
     name: string;
     folder: string;
     action: 'cloned' | 'pulled';
     error?: Error;
+    /** Metadata files kept or not refreshed; reported, never a failure. */
+    warnings?: string[];
+}
+export interface TeamSyncResult {
+    outcomes: TeamSyncOutcome[];
+    /** Folders recorded locally whose App or global workspace has left the team. */
+    removedFolders: string[];
 }
 /**
- * Applies the plan, one App at a time, recording the metadata of each App that lands. A failing
- * App is reported and the run carries on: with a dozen Apps, one bad workspace must not cost the
- * other eleven.
+ * Brings the team folder in line with the dashboard — global workspaces first, since the Apps
+ * inherit from them, then the Apps — one workspace at a time, recording the metadata of each one
+ * that lands. A failing workspace is reported and the run carries on: with a dozen Apps, one bad
+ * workspace must not cost the other eleven.
  */
-export declare function syncApps(rootDir: string, metadata: DevTeamMetadata, plan: AppSyncPlan): Promise<AppSyncOutcome[]>;
-/** Prints the per-App result and reports whether anything failed. */
-export declare function reportOutcomes(outcomes: AppSyncOutcome[], removed: AppSyncPlan['removed']): boolean;
+export declare function syncTeam(rootDir: string, metadata: DevTeamMetadata, remote: DevTeamRemote, source: AppMetadataSource): Promise<TeamSyncResult>;
+/** Prints the per-workspace result and reports whether anything failed. */
+export declare function reportOutcomes({ outcomes, removedFolders }: TeamSyncResult): boolean;
 /**
  * The team to operate on: the one named, the only one the session belongs to, or — when there are
  * several — none, after listing them so the user can pass an id.

package/dist/services/dev-team-service.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.planAppSync = planAppSync;
+exports.fetchTeamRemote = fetchTeamRemote;
+exports.planSync = planSync;
 exports.assignFolder = assignFolder;
-exports.syncApps = syncApps;
+exports.syncTeam = syncTeam;
 exports.reportOutcomes = reportOutcomes;
 exports.resolveTeam = resolveTeam;
 const fs = require("fs-extra");
@@ -10,19 +11,24 @@ const path = require("node:path");
 const color_1 = require("@oclif/color");
 const pull_1 = require("../commands/pull");
 const dev_team_1 = require("../config/dev-team");
+const app_metadata_files_1 = require("./app-metadata-files");
 const skills_installer_1 = require("./skills-installer");
 const dev_slug_1 = require("../utils/dev-slug");
 const workspace_cloner_1 = require("./workspace-cloner");
 const slugify_1 = require("../utils/slugify");
 const cli_1 = require("../utils/cli");
-function planAppSync(metadata, apps) {
-    const remoteIds = new Set(apps.map(({ id }) => id));
+async function fetchTeamRemote(client, teamId) {
+    const [apps, globalWorkspaces] = await Promise.all([client.listTeamApps(teamId), client.listTeamGlobalWorkspaces(teamId)]);
+    return { apps, globalWorkspaces };
+}
+function planSync(recorded, remote) {
+    const remoteIds = new Set(remote.map(({ id }) => id));
     return {
-        toClone: apps.filter(({ id }) => metadata.apps[id] === undefined),
-        toRefresh: apps.filter(({ id }) => metadata.apps[id] !== undefined),
-        removed: Object.entries(metadata.apps)
+        toClone: remote.filter(({ id }) => recorded[id] === undefined),
+        toRefresh: remote.filter(({ id }) => recorded[id] !== undefined),
+        removed: Object.entries(recorded)
             .filter(([id]) => !remoteIds.has(id))
-            .map(([id, app]) => ({ id, app })),
+            .map(([id, entry]) => ({ id, recorded: entry })),
     };
 }
 /**
@@ -44,80 +50,144 @@ function linkSkills(rootDir, appDir, workspaceDir) {
     (0, skills_installer_1.linkSkillsInto)(appDir, rootDir);
     (0, skills_installer_1.linkSkillsInto)(workspaceDir, rootDir);
 }
-/** A committed .gitignore, since each App folder is meant to become its own repository. */
-function writeAppGitIgnore(appDir) {
-    const gitIgnorePath = path.join(appDir, '.gitignore');
+/**
+ * A committed .gitignore keeping the skill links out of the repository: one in each App folder,
+ * since each is meant to become its own repository, and one over the global workspaces.
+ */
+function writeSkillsGitIgnore(dir) {
+    const gitIgnorePath = path.join(dir, '.gitignore');
     if (fs.pathExistsSync(gitIgnorePath)) {
         return;
     }
     fs.outputFileSync(gitIgnorePath, ['# Agent skills are installed once at the development-team root and linked here.', '**/.claude/skills', ''].join('\n'));
 }
 /**
- * Clones one App. The metadata entry is recorded as soon as the directory exists, before the
- * pull that may fail: a half-cloned App has to be recognised as cloned next time, or the retry
- * would try to create it again and stop at "already cloned".
+ * Metadata warnings go into the caller's sink rather than the return value: the workspace pull
+ * that follows may throw, and what was said about the files before that still holds.
  */
-async function cloneApp(rootDir, app, folder, metadata) {
+async function cloneApp(context, app, folder, warnings) {
+    const { rootDir, metadata, source } = context;
     const slug = (0, dev_slug_1.devSlug)(app.id);
     const appDir = path.join(rootDir, folder);
     const workspaceDir = path.join(appDir, dev_team_1.APP_WORKSPACE_DIR);
     cli_1.default.log(color_1.default.cyan(`\n📦 ${app.name} → ${folder}/${dev_team_1.APP_WORKSPACE_DIR} (${slug})`));
     await (0, workspace_cloner_1.scaffoldWorkspace)(workspaceDir, { url: metadata.cloudUrl, slug });
-    metadata.apps[app.id] = { name: app.name, description: app.description, folder, devWorkspaceSlug: slug };
+    const recorded = { name: app.name, description: app.description, folder, devWorkspaceSlug: slug };
+    metadata.apps[app.id] = recorded;
     (0, dev_team_1.writeAppSettings)(appDir, { id: app.id, name: app.name, description: app.description });
-    writeAppGitIgnore(appDir);
+    warnings.push(...(await (0, app_metadata_files_1.syncAppMetadata)(source, appDir, app, recorded)).warnings);
+    writeSkillsGitIgnore(appDir);
     linkSkills(rootDir, appDir, workspaceDir);
     await (0, workspace_cloner_1.runInWorkspace)(workspaceDir, () => pull_1.default.run([]));
 }
-async function refreshApp(rootDir, cloudUrl, app, recorded) {
+async function refreshApp(context, app, recorded, warnings) {
+    const { rootDir, metadata, source } = context;
     const appDir = path.join(rootDir, recorded.folder);
     const workspaceDir = path.join(appDir, dev_team_1.APP_WORKSPACE_DIR);
     cli_1.default.log(color_1.default.cyan(`\n📦 ${app.name} → ${recorded.folder}/${dev_team_1.APP_WORKSPACE_DIR}`));
     // A recorded App whose workspace is gone — a failed first clone, or a directory the user
     // removed — is laid out again rather than failing every pull from here on.
     if (!fs.pathExistsSync(path.join(workspaceDir, '.fcode'))) {
-        await (0, workspace_cloner_1.scaffoldWorkspace)(workspaceDir, { url: cloudUrl, slug: recorded.devWorkspaceSlug });
+        await (0, workspace_cloner_1.scaffoldWorkspace)(workspaceDir, { url: metadata.cloudUrl, slug: recorded.devWorkspaceSlug });
     }
     // Name and description live in the dashboard; the local copy is a mirror refreshed on every
-    // pull. There is deliberately no team:push — pushing happens inside a workspace.
+    // pull. There is deliberately no team:push — code is pushed inside a workspace, and the App's
+    // README.md / MARKETPLACE.md with `fcode app:push`.
     (0, dev_team_1.writeAppSettings)(appDir, { id: app.id, name: app.name, description: app.description });
-    writeAppGitIgnore(appDir);
+    warnings.push(...(await (0, app_metadata_files_1.syncAppMetadata)(source, appDir, app, recorded)).warnings);
+    writeSkillsGitIgnore(appDir);
     recorded.name = app.name;
     recorded.description = app.description;
     linkSkills(rootDir, appDir, workspaceDir);
     await (0, workspace_cloner_1.runInWorkspace)(workspaceDir, () => pull_1.default.run([]));
 }
 /**
- * Applies the plan, one App at a time, recording the metadata of each App that lands. A failing
- * App is reported and the run carries on: with a dozen Apps, one bad workspace must not cost the
- * other eleven.
+ * Clones or refreshes one global workspace. Its slug is the platform team slug — fixed, unique and
+ * filesystem-safe — so the checkout goes straight to `global-workspaces/{slug}` with no folder to
+ * assign and no App-level settings to mirror. Recorded before the pull for the same reason as an
+ * App: a half-cloned checkout must read as cloned on the retry.
  */
-async function syncApps(rootDir, metadata, plan) {
+async function syncGlobalWorkspace(rootDir, workspace, metadata) {
+    const folder = (0, dev_team_1.globalWorkspaceFolder)(workspace.slug);
+    const workspaceDir = path.join(rootDir, folder);
+    cli_1.default.log(color_1.default.cyan(`\n🌐 ${workspace.name} → ${folder}`));
+    if (!fs.pathExistsSync(path.join(workspaceDir, '.fcode'))) {
+        await (0, workspace_cloner_1.scaffoldWorkspace)(workspaceDir, { url: metadata.cloudUrl, slug: workspace.slug });
+    }
+    metadata.globalWorkspaces[workspace.id] = { name: workspace.name, description: workspace.description, slug: workspace.slug };
+    writeSkillsGitIgnore(path.join(rootDir, dev_team_1.GLOBAL_WORKSPACES_DIR));
+    (0, skills_installer_1.linkSkillsInto)(workspaceDir, rootDir);
+    await (0, workspace_cloner_1.runInWorkspace)(workspaceDir, () => pull_1.default.run([]));
+}
+async function syncApps(rootDir, metadata, plan, source) {
     const outcomes = [];
+    const context = { rootDir, metadata, source };
     for (const app of plan.toClone) {
         const folder = assignFolder(app, metadata);
+        const warnings = [];
+        const outcome = { name: app.name, folder, action: 'cloned', warnings };
         try {
-            await cloneApp(rootDir, app, folder, metadata);
-            outcomes.push({ name: app.name, folder, action: 'cloned' });
+            await cloneApp(context, app, folder, warnings);
         }
         catch (error) {
-            outcomes.push({ name: app.name, folder, action: 'cloned', error: error });
+            outcome.error = error;
         }
+        outcomes.push(outcome);
     }
     for (const app of plan.toRefresh) {
         const recorded = metadata.apps[app.id];
+        const warnings = [];
+        const outcome = { name: app.name, folder: recorded.folder, action: 'pulled', warnings };
         try {
-            await refreshApp(rootDir, metadata.cloudUrl, app, recorded);
-            outcomes.push({ name: app.name, folder: recorded.folder, action: 'pulled' });
+            await refreshApp(context, app, recorded, warnings);
         }
         catch (error) {
-            outcomes.push({ name: app.name, folder: recorded.folder, action: 'pulled', error: error });
+            outcome.error = error;
         }
+        outcomes.push(outcome);
     }
     return outcomes;
 }
-/** Prints the per-App result and reports whether anything failed. */
-function reportOutcomes(outcomes, removed) {
+async function syncGlobalWorkspaces(rootDir, metadata, plan) {
+    const outcomes = [];
+    for (const [action, workspaces] of [
+        ['cloned', plan.toClone],
+        ['pulled', plan.toRefresh],
+    ]) {
+        for (const workspace of workspaces) {
+            const folder = (0, dev_team_1.globalWorkspaceFolder)(workspace.slug);
+            try {
+                await syncGlobalWorkspace(rootDir, workspace, metadata);
+                outcomes.push({ name: workspace.name, folder, action });
+            }
+            catch (error) {
+                outcomes.push({ name: workspace.name, folder, action, error: error });
+            }
+        }
+    }
+    return outcomes;
+}
+/**
+ * Brings the team folder in line with the dashboard — global workspaces first, since the Apps
+ * inherit from them, then the Apps — one workspace at a time, recording the metadata of each one
+ * that lands. A failing workspace is reported and the run carries on: with a dozen Apps, one bad
+ * workspace must not cost the other eleven.
+ */
+async function syncTeam(rootDir, metadata, remote, source) {
+    const globalWorkspacePlan = planSync(metadata.globalWorkspaces, remote.globalWorkspaces);
+    const appPlan = planSync(metadata.apps, remote.apps);
+    const outcomes = [
+        ...(await syncGlobalWorkspaces(rootDir, metadata, globalWorkspacePlan)),
+        ...(await syncApps(rootDir, metadata, appPlan, source)),
+    ];
+    const removedFolders = [
+        ...globalWorkspacePlan.removed.map(({ recorded }) => (0, dev_team_1.globalWorkspaceFolder)(recorded.slug)),
+        ...appPlan.removed.map(({ recorded }) => recorded.folder),
+    ];
+    return { outcomes, removedFolders };
+}
+/** Prints the per-workspace result and reports whether anything failed. */
+function reportOutcomes({ outcomes, removedFolders }) {
     cli_1.default.log('');
     for (const outcome of outcomes) {
         if (outcome.error) {
@@ -126,9 +196,12 @@ function reportOutcomes(outcomes, removed) {
         else {
             cli_1.default.log(color_1.default.green(`✅ ${outcome.folder} (${outcome.action})`));
         }
+        for (const warning of outcome.warnings ?? []) {
+            cli_1.default.log(color_1.default.yellow(`   ⚠️  ${warning}`));
+        }
     }
-    for (const { app } of removed) {
-        cli_1.default.log(color_1.default.yellow(`⚠️  ${app.folder} is no longer in the team — the folder was kept, remove it yourself`));
+    for (const folder of removedFolders) {
+        cli_1.default.log(color_1.default.yellow(`⚠️  ${folder} is no longer in the team — the folder was kept, remove it yourself`));
     }
     return outcomes.some(({ error }) => error !== undefined);
 }

package/oclif.manifest.json

@@ -220,7 +220,7 @@
         },
         "prompt": {
           "char": "x",
-          "description": "Prompt for email and password (instead of opening browser)",
+          "description": "Prompt for email and password (instead of opening browser). Make it the default with 'fcode config:set disableBrowserLogin true' or FCODE_DISABLE_BROWSER_LOGIN=true",
           "name": "prompt",
           "allowNo": false,
           "type": "boolean"
@@ -701,6 +701,39 @@
         "test.js"
       ]
     },
+    "app:push": {
+      "aliases": [],
+      "args": {},
+      "description": "Upload the App folder's README.md and MARKETPLACE.md to the dashboard",
+      "examples": [
+        "$ fcode app:push",
+        "$ fcode app:push --force"
+      ],
+      "flags": {
+        "force": {
+          "char": "f",
+          "description": "Force command",
+          "name": "force",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "app:push",
+      "pluginAlias": "@factorialco/fcode-cli",
+      "pluginName": "@factorialco/fcode-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": false,
+      "relativePath": [
+        "dist",
+        "commands",
+        "app",
+        "push.js"
+      ]
+    },
     "config:get": {
       "aliases": [],
       "args": {
@@ -1956,7 +1989,7 @@
           "required": false
         }
       },
-      "description": "Clone every App of a development team into one folder — an App folder each, holding the App's development workspace",
+      "description": "Clone a development team into one folder — an App folder each, holding the App's development workspace, plus the team's global workspaces under global-workspaces/",
       "examples": [
         "$ fcode team:clone",
         "$ fcode team:clone 0f9c1a2b-3d4e-5f60-8a1b-2c3d4e5f6071"
@@ -1988,7 +2021,7 @@
     "team:pull": {
       "aliases": [],
       "args": {},
-      "description": "Pull every App of the development team folder: clones Apps added since the last run and pulls each App's workspace",
+      "description": "Pull the development team folder: clones Apps and global workspaces added since the last run and pulls every workspace",
       "examples": [
         "$ fcode team:pull"
       ],
@@ -2012,7 +2045,7 @@
     "team:status": {
       "aliases": [],
       "args": {},
-      "description": "Show what differs from the cloud in every App workspace of the development team folder",
+      "description": "Show what differs from the cloud in every workspace of the development team folder",
       "examples": [
         "$ fcode team:status"
       ],
@@ -2483,5 +2516,5 @@
       ]
     }
   },
-  "version": "3.0.0"
+  "version": "3.2.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factorialco/fcode-cli",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "packageManager": "pnpm@11.7.0",
   "description": "Factorial Code Command Line Interface",
   "homepage": "https://code.factorialhr.com/docs/cli/",
@@ -127,6 +127,9 @@
       },
       "team": {
         "description": "Work with every App your development team owns, in one folder"
+      },
+      "app": {
+        "description": "Work on the App folder around a workspace: its README, marketplace listing and changelog"
       }
     }
   },