@funnelsgrove/cli 0.1.4 → 0.1.5

package/README.md

@@ -24,6 +24,18 @@ fgrove sync up --message 'Update funnel copy'
 fgrove publish --env preview
 ```
 
+GitHub sync workflow:
+
+```bash
+fgrove github status --funnel claimbee-general
+fgrove github connect --funnel claimbee-general --account The-Solid-Grove --repo claimbee-funnel
+fgrove github push --funnel claimbee-general
+fgrove github pull --funnel claimbee-general
+fgrove publish --funnel claimbee-general --env preview
+```
+
+The GitHub commands use the FunnelsGrove API only. When GitHub is connected, `fgrove sync up` pushes the resulting draft to GitHub before returning, and `fgrove publish` waits for the current draft to reach GitHub before publishing. Local `.env*` files remain CLI-local runtime material from `sync down`; they are not sent to GitHub sync.
+
 The package also keeps the longer `funnelsgrove` command as a compatibility alias.
 Use `--api-url` or `FUNNELSGROVE_API_URL` for non-production APIs.
 Use `--config` or `FUNNELSGROVE_CONFIG` to keep test credentials separate from the default `~/.funnelsgrove/config.json`.

package/dist/cli.js

@@ -8,6 +8,8 @@ import { Command } from 'commander';
 import { callTrpcProcedure } from './apiClient.js';
 import { clearActiveContext, getDefaultAuthConfigPath, loadActiveContext, loadAuthToken, saveActiveContext, saveAuthToken, } from './authStore.js';
 import { buildSyncManifest, chunkChangedSourceFiles, collectChangedSourceFiles, collectSourceFiles, readSyncManifest, writeSourceFiles, writeSyncManifest, } from './localSync.js';
+import { formatGitHubConnectRows, formatGitHubJobRows, formatGitHubStatusRows, } from './githubOutput.js';
+import { syncGitHubDraftIfConnected } from './githubSyncFlow.js';
 import { isKnownTemplate, KNOWN_TEMPLATE_SLUGS, reskinFunnel } from './reskin.js';
 import { syncTemplateDocs, TEMPLATE_DOCS_DIR } from './templateDocs.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -213,6 +215,34 @@ const printRows = (rows, columns) => {
         console.log(columns.map((column) => row[column] || '').join('\t'));
     }
 };
+const printValueRows = (rows) => {
+    for (const row of rows) {
+        console.log(row.join('\t'));
+    }
+};
+const summarizeGitHubSyncResult = (result) => {
+    if (result.status === 'not_connected') {
+        return null;
+    }
+    if (result.status === 'draft_missing') {
+        throw new Error('Cannot sync GitHub before publish because this funnel has no draft version.');
+    }
+    const remoteSha = result.remoteSha ? ` ${result.remoteSha}` : '';
+    return result.status === 'completed'
+        ? `GitHub synced${remoteSha}`
+        : `GitHub already synced${remoteSha}`;
+};
+const syncGitHubDraftForCli = async (input) => {
+    const summary = summarizeGitHubSyncResult(await syncGitHubDraftIfConnected({
+        callApi,
+        token: input.token,
+        workspaceId: input.workspaceId,
+        funnelId: input.funnelId,
+    }));
+    if (summary) {
+        console.log(summary);
+    }
+};
 const addExamples = (command, examples) => command.addHelpText('after', `\nExamples:\n${examples.map((example) => `  $ ${example}`).join('\n')}`);
 const program = new Command();
 program
@@ -452,6 +482,11 @@ addExamples(syncCommand
         : null;
     if (changes && changes.files.length === 0 && changes.deletedPaths.length === 0) {
         console.log('No local changes to sync.');
+        await syncGitHubDraftForCli({
+            token,
+            workspaceId: target.workspaceId,
+            funnelId: target.funnelId,
+        });
         return;
     }
     let result = null;
@@ -499,6 +534,11 @@ addExamples(syncCommand
         funnelId: target.funnelId,
         draftVersionId: result.versionId,
     }));
+    await syncGitHubDraftForCli({
+        token,
+        workspaceId: target.workspaceId,
+        funnelId: target.funnelId,
+    });
     const deletedSummary = deletedFileCount > 0 ? ` and removed ${deletedFileCount} files` : '';
     console.log(`Synced ${syncedFileCount} files${deletedSummary} to draft v${result.versionSeq} (${result.versionId})`);
 });
@@ -529,6 +569,11 @@ addExamples(program
     if (publishEnv === 'production' && !options.domain?.trim()) {
         throw new Error('--domain is required when publishing production');
     }
+    await syncGitHubDraftForCli({
+        token,
+        workspaceId: target.workspaceId,
+        funnelId: target.funnelId,
+    });
     const result = await callApi({
         path: 'funnels.publish',
         type: 'mutation',
@@ -542,6 +587,130 @@ addExamples(program
     });
     console.log(`${result.deploymentUrl}\tv${result.publishedVersionSeq}\t${result.publishedVersionId}`);
 });
+const githubCommand = addExamples(program.command('github').description('Manage GitHub funnel sync'), [
+    'fgrove github status --funnel claimbee-general',
+    'fgrove github connect --funnel claimbee-general --account The-Solid-Grove --repo claimbee-funnel',
+    'fgrove github push --funnel claimbee-general',
+    'fgrove github pull --funnel claimbee-general',
+]);
+addExamples(githubCommand
+    .command('status')
+    .description('Show GitHub sync status for a funnel')
+    .option('--workspace <id-or-slug-or-name>', 'Workspace id, slug, or name')
+    .option('--funnel <id-or-slug>', 'Funnel id or slug')
+    .option('--dir <path>', 'Local source directory for reading sync manifest', '.'), [
+    'fgrove github status --funnel claimbee-general',
+    'fgrove github status --dir ./claimbee-funnel',
+])
+    .action(async (options) => {
+    const token = await readAuthToken();
+    const target = await resolveSyncTarget({
+        token,
+        workspace: options.workspace,
+        funnel: options.funnel,
+        dir: options.dir,
+    });
+    const result = await callApi({
+        path: 'github.status',
+        type: 'query',
+        token,
+        data: {
+            workspaceId: target.workspaceId,
+            funnelId: target.funnelId,
+        },
+    });
+    printValueRows(formatGitHubStatusRows(result));
+});
+addExamples(githubCommand
+    .command('connect')
+    .description('Connect a funnel to a GitHub repository and queue the initial push')
+    .option('--workspace <id-or-slug-or-name>', 'Workspace id, slug, or name')
+    .option('--funnel <id-or-slug>', 'Funnel id or slug')
+    .option('--dir <path>', 'Local source directory for reading sync manifest', '.')
+    .option('--installation <id>', 'Workspace GitHub installation row id')
+    .option('--account <login>', 'GitHub organization or user login')
+    .option('--repo <name>', 'GitHub repository name'), [
+    'fgrove github connect --funnel claimbee-general --account The-Solid-Grove --repo claimbee-funnel',
+    'fgrove github connect --dir ./claimbee-funnel --account The-Solid-Grove --repo claimbee-funnel',
+])
+    .action(async (options) => {
+    const token = await readAuthToken();
+    const target = await resolveSyncTarget({
+        token,
+        workspace: options.workspace,
+        funnel: options.funnel,
+        dir: options.dir,
+    });
+    const result = await callApi({
+        path: 'github.connectFunnel',
+        type: 'mutation',
+        token,
+        data: {
+            workspaceId: target.workspaceId,
+            funnelId: target.funnelId,
+            installationId: options.installation,
+            accountLogin: options.account,
+            repoName: options.repo,
+        },
+    });
+    printValueRows(formatGitHubConnectRows(result));
+});
+addExamples(githubCommand
+    .command('push')
+    .description('Queue a push of the current FunnelsGrove draft to GitHub')
+    .option('--workspace <id-or-slug-or-name>', 'Workspace id, slug, or name')
+    .option('--funnel <id-or-slug>', 'Funnel id or slug')
+    .option('--dir <path>', 'Local source directory for reading sync manifest', '.'), [
+    'fgrove github push --funnel claimbee-general',
+    'fgrove github push --dir ./claimbee-funnel',
+])
+    .action(async (options) => {
+    const token = await readAuthToken();
+    const target = await resolveSyncTarget({
+        token,
+        workspace: options.workspace,
+        funnel: options.funnel,
+        dir: options.dir,
+    });
+    const result = await callApi({
+        path: 'github.pushNow',
+        type: 'mutation',
+        token,
+        data: {
+            workspaceId: target.workspaceId,
+            funnelId: target.funnelId,
+        },
+    });
+    printValueRows(formatGitHubJobRows(result));
+});
+addExamples(githubCommand
+    .command('pull')
+    .description('Queue a pull from GitHub into the FunnelsGrove draft')
+    .option('--workspace <id-or-slug-or-name>', 'Workspace id, slug, or name')
+    .option('--funnel <id-or-slug>', 'Funnel id or slug')
+    .option('--dir <path>', 'Local source directory for reading sync manifest', '.'), [
+    'fgrove github pull --funnel claimbee-general',
+    'fgrove github pull --dir ./claimbee-funnel',
+])
+    .action(async (options) => {
+    const token = await readAuthToken();
+    const target = await resolveSyncTarget({
+        token,
+        workspace: options.workspace,
+        funnel: options.funnel,
+        dir: options.dir,
+    });
+    const result = await callApi({
+        path: 'github.pullLatest',
+        type: 'mutation',
+        token,
+        data: {
+            workspaceId: target.workspaceId,
+            funnelId: target.funnelId,
+        },
+    });
+    printValueRows(formatGitHubJobRows(result));
+});
 addExamples(program
     .command('docs')
     .description('Install or refresh local funnel editing docs in a funnel directory')

package/dist/githubOutput.d.ts

@@ -0,0 +1,65 @@
+type Row = string[];
+export type GitHubStatusResponse = {
+    connected: boolean;
+    installUrl: string | null;
+    account: {
+        id: string;
+        accountLogin: string;
+        accountType: string;
+    } | null;
+    installations: Array<{
+        id: string;
+        githubInstallationId: number;
+        accountLogin: string;
+        accountType: string;
+    }>;
+    connection: {
+        id: string;
+        repoOwner: string;
+        repoName: string;
+        repoUrl: string;
+        defaultBranch: string;
+        status: string;
+        lastSyncedRemoteSha: string | null;
+        lastSyncedVersionId: string | null;
+        lastSyncedVersionSeq: number | null;
+    } | null;
+    draftVersionId: string | null;
+    draftVersionSeq: number | null;
+    publishedVersionId: string | null;
+    publishedVersionSeq: number | null;
+    syncJobs: Array<{
+        id: string;
+        direction: string;
+        status: string;
+        triggerSource: string;
+        errorMessage: string | null;
+        targetRemoteSha: string | null;
+        appliedVersionId: string | null;
+        appliedVersionSeq: number | null;
+        createdAt: string;
+        completedAt: string | null;
+    }>;
+};
+export type GitHubConnectResponse = {
+    connection: {
+        repo_owner: string;
+        repo_name: string;
+        repo_url: string;
+        default_branch: string;
+        status: string;
+    };
+    syncJob: {
+        id: string;
+        direction: string;
+        status: string;
+    };
+};
+export type GitHubJobResponse = {
+    status: string;
+    jobId: string | null;
+};
+export declare const formatGitHubStatusRows: (status: GitHubStatusResponse) => Row[];
+export declare const formatGitHubConnectRows: (result: GitHubConnectResponse) => Row[];
+export declare const formatGitHubJobRows: (result: GitHubJobResponse) => Row[];
+export {};

package/dist/githubOutput.js

@@ -0,0 +1,67 @@
+const formatVersion = (seq, id) => {
+    if (!id) {
+        return ['Not published'];
+    }
+    return [seq ? `v${seq}` : 'version', id];
+};
+export const formatGitHubStatusRows = (status) => {
+    const rows = [['connected', String(status.connected)]];
+    if (status.account) {
+        rows.push(['account', status.account.accountLogin, status.account.accountType]);
+    }
+    if (status.connection) {
+        rows.push([
+            'repo',
+            `${status.connection.repoOwner}/${status.connection.repoName}`,
+            status.connection.repoUrl,
+        ]);
+        rows.push(['branch', status.connection.defaultBranch]);
+        rows.push(['status', status.connection.status]);
+        if (status.connection.lastSyncedRemoteSha) {
+            rows.push(['lastRemoteSha', status.connection.lastSyncedRemoteSha]);
+        }
+        if (status.connection.lastSyncedVersionId) {
+            rows.push([
+                'lastVersion',
+                ...formatVersion(status.connection.lastSyncedVersionSeq, status.connection.lastSyncedVersionId),
+            ]);
+        }
+    }
+    else if (status.installUrl) {
+        rows.push(['installUrl', status.installUrl]);
+    }
+    if (status.draftVersionId) {
+        rows.push(['draft', ...formatVersion(status.draftVersionSeq, status.draftVersionId)]);
+    }
+    rows.push(['published', ...formatVersion(status.publishedVersionSeq, status.publishedVersionId)]);
+    for (const job of status.syncJobs) {
+        rows.push([
+            'job',
+            job.id,
+            job.direction,
+            job.status,
+            job.triggerSource,
+            job.targetRemoteSha || '',
+            job.appliedVersionSeq ? `v${job.appliedVersionSeq}` : '',
+            job.errorMessage || '',
+        ].filter((value, index, values) => value || index < values.length - 1));
+    }
+    return rows;
+};
+export const formatGitHubConnectRows = (result) => [
+    [
+        'connected',
+        `${result.connection.repo_owner}/${result.connection.repo_name}`,
+        result.connection.repo_url,
+    ],
+    ['branch', result.connection.default_branch],
+    ['status', result.connection.status],
+    ['syncJob', result.syncJob.id, result.syncJob.direction, result.syncJob.status],
+];
+export const formatGitHubJobRows = (result) => {
+    const rows = [['status', result.status]];
+    if (result.jobId) {
+        rows.push(['job', result.jobId]);
+    }
+    return rows;
+};

package/dist/githubSyncFlow.d.ts

@@ -0,0 +1,27 @@
+type ApiCallInput = {
+    path: string;
+    type: 'query' | 'mutation';
+    data?: unknown;
+    token?: string | null;
+};
+export type GitHubFlowCallApi = <T>(input: ApiCallInput) => Promise<T>;
+export type GitHubSyncFlowResult = {
+    status: 'not_connected';
+} | {
+    status: 'draft_missing';
+} | {
+    status: 'completed' | 'skipped';
+    jobId: string;
+    remoteSha: string | null;
+    versionId: string | null;
+};
+export declare const syncGitHubDraftIfConnected: (input: {
+    callApi: GitHubFlowCallApi;
+    token: string;
+    workspaceId: string;
+    funnelId: string;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}) => Promise<GitHubSyncFlowResult>;
+export {};

package/dist/githubSyncFlow.js

@@ -0,0 +1,75 @@
+const TERMINAL_JOB_STATUSES = new Set(['completed', 'skipped', 'failed']);
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const DEFAULT_TIMEOUT_MS = 600_000;
+const sleepDefault = async (ms) => {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+const findJob = (status, jobId) => {
+    return status.syncJobs.find((job) => job.id === jobId) || null;
+};
+const assertSuccessfulTerminalJob = (job) => {
+    if (job.status === 'failed' || (job.status === 'skipped' && job.errorMessage)) {
+        throw new Error(job.errorMessage || 'GitHub sync failed.');
+    }
+};
+export const syncGitHubDraftIfConnected = async (input) => {
+    const status = await input.callApi({
+        path: 'github.status',
+        type: 'query',
+        token: input.token,
+        data: {
+            workspaceId: input.workspaceId,
+            funnelId: input.funnelId,
+        },
+    });
+    if (!status.connection || status.connection.status === 'disconnected') {
+        return { status: 'not_connected' };
+    }
+    const pushResult = await input.callApi({
+        path: 'github.pushNow',
+        type: 'mutation',
+        token: input.token,
+        data: {
+            workspaceId: input.workspaceId,
+            funnelId: input.funnelId,
+        },
+    });
+    if (pushResult.status === 'not_connected') {
+        return { status: 'not_connected' };
+    }
+    if (pushResult.status === 'draft_missing') {
+        return { status: 'draft_missing' };
+    }
+    if (!pushResult.jobId) {
+        throw new Error(`GitHub sync did not return a job id (status: ${pushResult.status}).`);
+    }
+    const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const sleep = input.sleep || sleepDefault;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        const nextStatus = await input.callApi({
+            path: 'github.status',
+            type: 'query',
+            token: input.token,
+            data: {
+                workspaceId: input.workspaceId,
+                funnelId: input.funnelId,
+            },
+        });
+        const job = findJob(nextStatus, pushResult.jobId);
+        if (job && TERMINAL_JOB_STATUSES.has(job.status)) {
+            assertSuccessfulTerminalJob(job);
+            return {
+                status: job.status,
+                jobId: job.id,
+                remoteSha: job.targetRemoteSha,
+                versionId: job.appliedVersionId,
+            };
+        }
+        await sleep(pollIntervalMs);
+    }
+    throw new Error(`Timed out waiting for GitHub sync job ${pushResult.jobId}.`);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funnelsgrove/cli",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "FunnelsGrove command-line tools for editing, syncing, and publishing funnels",
   "type": "module",
   "bin": {