@hs-x/cli 0.4.2-next.1 → 0.4.2

package/dist/commands/sync.js

@@ -0,0 +1,771 @@
+import * as Args from '@effect/cli/Args';
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import { RuntimeSyncOperationsError, createRuntimeSyncOperationsClient, createRuntimeSyncRunRequest, } from '@hs-x/runtime';
+import { Config, Effect, Option } from 'effect';
+import { activeSession } from '../account-store.js';
+import { cliError } from '../cli-error.js';
+import { accountIdOption, controlPlaneUrlOption, jsonOption, projectIdOption, runHandler, } from '../cli/kit.js';
+import { DEFAULT_CONTROL_PLANE_URL } from '../config.js';
+import { isMachineOutput } from '../output-context.js';
+import { readLocalProjectContext } from '../project-context.js';
+import { discoverProjectRuntimeBindings, discoverProjects, resolveAccountId, resolveProjectSelection, resolveRuntimeBinding, } from '../project-picker.js';
+import { isInteractive, promptConfirm } from '../prompt.js';
+import { AccountStore } from '../services/account-store.js';
+import { ControlPlaneClient } from '../services/control-plane.js';
+import { Cwd } from '../services/cwd.js';
+import { Reporter } from '../services/reporter.js';
+import { loadTenantStateStore } from '../tenant-state.js';
+import { resolveFlagsContext } from './flags.js';
+const syncIdArg = Args.text({ name: 'sync-id' });
+const poisonRowArg = Args.text({ name: 'row-key' });
+const runIdArg = Args.text({ name: 'run-id' });
+const portalOption = Options.text('portal').pipe(Options.withAlias('portal-id'), Options.optional);
+const environmentOption = Options.text('environment').pipe(Options.optional);
+const envOption = Options.text('env').pipe(Options.optional);
+const appIdOption = Options.integer('app-id').pipe(Options.optional);
+const runtimeOriginOption = Options.text('runtime-origin').pipe(Options.optional);
+const cloudflareApiTokenOption = Options.text('cloudflare-api-token').pipe(Options.optional);
+const limitOption = Options.integer('limit').pipe(Options.withDefault(20));
+const previewOption = Options.boolean('preview').pipe(Options.withDefault(false));
+const yesOption = Options.boolean('yes').pipe(Options.withAlias('y'), Options.withDefault(false));
+const identityOptions = {
+    accountId: accountIdOption,
+    projectId: projectIdOption,
+    environment: environmentOption,
+    env: envOption,
+    appId: appIdOption,
+    runtimeOrigin: runtimeOriginOption,
+    cloudflareApiToken: cloudflareApiTokenOption,
+    controlPlaneUrl: controlPlaneUrlOption,
+    json: jsonOption,
+};
+function operationsError(error) {
+    if (!(error instanceof RuntimeSyncOperationsError)) {
+        return cliError('HSX_E_API_NETWORK', error instanceof Error ? error.message : String(error));
+    }
+    if (error.status === 401 || error.status === 403) {
+        return cliError('HSX_E_API_UNAUTHORIZED', error.message);
+    }
+    if (error.status === 404)
+        return cliError('HSX_E_API_NOT_FOUND', error.message);
+    if (error.status >= 500)
+        return cliError('HSX_E_API_SERVER', error.message);
+    return cliError('HSX_E_API_BAD_REQUEST', error.message);
+}
+function resolveSyncContext(opts) {
+    return Effect.gen(function* () {
+        const root = yield* Cwd;
+        const accounts = yield* AccountStore;
+        const stored = yield* accounts.load;
+        const session = activeSession(stored);
+        const forceDirect = Option.isSome(opts.runtimeOrigin) || Option.isSome(opts.cloudflareApiToken) || !session;
+        if (!forceDirect) {
+            return yield* resolveControlPlaneSyncContext(opts, root, stored);
+        }
+        return yield* resolveDirectSyncContext(opts, root);
+    });
+}
+function resolveDirectSyncContext(opts, root) {
+    return Effect.gen(function* () {
+        const envProjectId = yield* Config.string('HSX_PROJECT_ID').pipe(Config.withDefault(''), Effect.orDie);
+        const envAppId = yield* Config.string('HSX_APP_ID').pipe(Config.withDefault(''), Effect.orDie);
+        const envHubSpotAppId = yield* Config.string('HSX_HUBSPOT_APP_ID').pipe(Config.withDefault(''), Effect.orDie);
+        const envRuntimeBaseUrl = yield* Config.string('HSX_RUNTIME_BASE_URL').pipe(Config.withDefault(''), Effect.orDie);
+        const envEnvironment = yield* Config.string('HSX_ENVIRONMENT').pipe(Config.withDefault(''), Effect.orDie);
+        const local = yield* Effect.promise(() => readLocalProjectContext(root));
+        const argv = Option.match(opts.cloudflareApiToken, {
+            onNone: () => [],
+            onSome: (token) => ['--cloudflare-api-token', token],
+        });
+        const tenant = yield* Effect.tryPromise({
+            try: () => loadTenantStateStore({ argv, root }),
+            catch: (cause) => cliError('HSX_E_INPUT_INVALID', cause instanceof Error ? cause.message : String(cause)),
+        });
+        if (!tenant) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', 'No deployed tenant state was found. Run `hs-x deploy` in this checkout first.'));
+        }
+        const resolved = yield* Effect.tryPromise({
+            try: () => resolveFlagsContext({
+                stateStore: tenant.stateStore,
+                local,
+                explicitProjectId: Option.getOrUndefined(opts.projectId),
+                envProjectId: envProjectId || undefined,
+                explicitEnvironment: Option.getOrUndefined(opts.environment) ?? Option.getOrUndefined(opts.env),
+                envEnvironment: envEnvironment || undefined,
+                explicitAppId: Option.getOrUndefined(opts.appId),
+                envAppId: envAppId || undefined,
+                compatibilityEnvAppId: envHubSpotAppId || undefined,
+                explicitRuntimeOrigin: Option.getOrUndefined(opts.runtimeOrigin),
+                envRuntimeOrigin: envRuntimeBaseUrl || undefined,
+                allowPrompt: false,
+            }),
+            catch: (cause) => cliError('HSX_E_INPUT_INVALID', cause instanceof Error ? cause.message : String(cause)),
+        });
+        const scope = {
+            accountId: resolved.binding.tenantScopeAccountId,
+            projectId: resolved.projectId,
+            environment: resolved.environment,
+            hubSpotAppId: resolved.hubSpotAppId,
+        };
+        return {
+            runtimeBaseUrl: resolved.runtimeBaseUrl,
+            grantSecret: resolved.binding.syncGrantSecretValue,
+            scope,
+            client: createRuntimeSyncOperationsClient({
+                runtimeBaseUrl: resolved.runtimeBaseUrl,
+                grantSecret: resolved.binding.syncGrantSecretValue,
+                scope,
+            }),
+        };
+    });
+}
+function resolveControlPlaneSyncContext(opts, root, stored) {
+    return Effect.gen(function* () {
+        const local = yield* Effect.promise(() => readLocalProjectContext(root));
+        const envAccountId = yield* Config.string('HSX_ACCOUNT_ID').pipe(Config.withDefault(''), Effect.orDie);
+        const envProjectId = yield* Config.string('HSX_PROJECT_ID').pipe(Config.withDefault(''), Effect.orDie);
+        const envEnvironment = yield* Config.string('HSX_ENVIRONMENT').pipe(Config.withDefault(''), Effect.orDie);
+        const envAppId = yield* Config.string('HSX_APP_ID').pipe(Config.withDefault(''), Effect.orDie);
+        const envHubSpotAppId = yield* Config.string('HSX_HUBSPOT_APP_ID').pipe(Config.withDefault(''), Effect.orDie);
+        const envControlPlaneUrl = yield* Config.string('HSX_CONTROL_PLANE_URL').pipe(Config.withDefault(''), Effect.orDie);
+        const accountId = resolveAccountId({
+            ...(Option.getOrUndefined(opts.accountId)
+                ? { explicitAccountId: Option.getOrUndefined(opts.accountId) }
+                : {}),
+            ...(envAccountId ? { envAccountId } : {}),
+            ...(local.projectBinding?.accountId
+                ? { localAccountId: local.projectBinding.accountId }
+                : {}),
+            ...(stored.defaultAccountId ? { defaultAccountId: stored.defaultAccountId } : {}),
+        });
+        if (!accountId) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', 'Sync operations require an HS-X account. Run `hs-x login`, or pass --account-id.'));
+        }
+        const controlPlaneUrl = Option.getOrUndefined(opts.controlPlaneUrl) ??
+            (envControlPlaneUrl || DEFAULT_CONTROL_PLANE_URL);
+        const cp = yield* ControlPlaneClient;
+        const request = (input) => Effect.runPromise(cp.fetch({
+            controlPlaneUrl,
+            path: input.path,
+            ...(input.method ? { method: input.method } : {}),
+            ...(input.body === undefined ? {} : { body: input.body }),
+        }));
+        return yield* Effect.tryPromise({
+            try: async () => {
+                const projects = await discoverProjects({ accountId, controlPlane: { request } });
+                const selectedProjectId = Option.getOrUndefined(opts.projectId) ??
+                    (envProjectId || local.projectBinding?.projectId);
+                const project = await resolveProjectSelection({
+                    accountId,
+                    projects,
+                    ...(selectedProjectId ? { explicitProjectId: selectedProjectId } : {}),
+                    ...(local.projectBinding?.projectId
+                        ? { localProjectId: local.projectBinding.projectId }
+                        : {}),
+                    allowPrompt: false,
+                });
+                const bindings = await discoverProjectRuntimeBindings({
+                    accountId,
+                    projectId: project.id,
+                    controlPlane: { request },
+                });
+                const appIdRaw = envAppId || envHubSpotAppId || undefined;
+                const explicitAppId = Option.getOrUndefined(opts.appId) ??
+                    (appIdRaw === undefined ? undefined : Number(appIdRaw));
+                const selectedEnvironment = Option.getOrUndefined(opts.environment) ??
+                    Option.getOrUndefined(opts.env) ??
+                    (envEnvironment || undefined);
+                const binding = await resolveRuntimeBinding({
+                    project,
+                    bindings,
+                    ...(selectedEnvironment ? { explicitEnvironment: selectedEnvironment } : {}),
+                    ...(explicitAppId === undefined ? {} : { explicitAppId }),
+                    ...(local.hubSpotBinding?.appId ? { localAppId: local.hubSpotBinding.appId } : {}),
+                    allowPrompt: false,
+                });
+                const base = `/v1/accounts/${encodeURIComponent(accountId)}/projects/${encodeURIComponent(project.id)}/hubspot-apps/${binding.hubSpotAppId}`;
+                const query = `?environment=${encodeURIComponent(binding.environment)}`;
+                const [secretResponse, runtimeResponse] = await Promise.all([
+                    request({ path: `${base}/sync-grant-secret${query}` }),
+                    request({ path: `${base}/install-runtime${query}` }),
+                ]);
+                if (!secretResponse.ok || !runtimeResponse.ok) {
+                    throw new Error(`Sync operations binding is unavailable (secret ${secretResponse.status}, runtime ${runtimeResponse.status}).`);
+                }
+                const secretBody = (await secretResponse.json());
+                const runtimeBody = (await runtimeResponse.json());
+                if (!secretBody.syncGrantSecret || !runtimeBody.runtimeBaseUrl) {
+                    throw new Error('Sync operations binding is incomplete. Re-deploy the linked project.');
+                }
+                const runtimeOrigin = new URL(runtimeBody.runtimeBaseUrl);
+                const loopbackHttp = runtimeOrigin.protocol === 'http:' &&
+                    ['127.0.0.1', 'localhost', '[::1]'].includes(runtimeOrigin.hostname);
+                if ((runtimeOrigin.protocol !== 'https:' && !loopbackHttp) ||
+                    runtimeOrigin.username ||
+                    runtimeOrigin.password) {
+                    throw new Error('The registered tenant Worker URL is not a safe HTTPS origin.');
+                }
+                const scope = {
+                    accountId,
+                    projectId: project.id,
+                    environment: binding.environment,
+                    hubSpotAppId: binding.hubSpotAppId,
+                };
+                return {
+                    runtimeBaseUrl: runtimeOrigin.origin,
+                    grantSecret: secretBody.syncGrantSecret,
+                    scope,
+                    client: createRuntimeSyncOperationsClient({
+                        runtimeBaseUrl: runtimeOrigin.origin,
+                        grantSecret: secretBody.syncGrantSecret,
+                        scope,
+                    }),
+                };
+            },
+            catch: (cause) => cliError('HSX_E_INPUT_INVALID', cause instanceof Error ? cause.message : String(cause)),
+        });
+    });
+}
+function duration(run) {
+    if (!run.finishedAt)
+        return undefined;
+    const ms = Date.parse(run.finishedAt) - Date.parse(run.startedAt);
+    if (!Number.isFinite(ms) || ms < 0)
+        return undefined;
+    return ms < 1_000 ? `${ms}ms` : `${(ms / 1_000).toFixed(ms < 10_000 ? 1 : 0)}s`;
+}
+function runDetail(run) {
+    const counts = [
+        run.delivered !== undefined ? `${run.delivered} delivered` : undefined,
+        run.quarantined !== undefined ? `${run.quarantined} quarantined` : undefined,
+        run.pages !== undefined ? `${run.pages} pages` : undefined,
+        duration(run),
+    ].filter((value) => value !== undefined);
+    return [run.key.portalId, run.trigger, ...counts].join(' · ');
+}
+function runRows(runs) {
+    return runs.map((run) => ({
+        status: run.outcome === 'completed'
+            ? 'ok'
+            : run.outcome === 'failed'
+                ? 'fail'
+                : 'warn',
+        key: run.startedAt,
+        value: run.outcome,
+        detail: runDetail(run),
+        ...(run.error ? { hint: run.error } : {}),
+    }));
+}
+function poisonRows(rows) {
+    return rows.map((row) => ({
+        status: 'fail',
+        key: row.rowKey || '(missing row key)',
+        value: `${row.failureKind} · ${row.category}`,
+        detail: [
+            row.objectType,
+            `${row.attemptCount} attempt${row.attemptCount === 1 ? '' : 's'}`,
+            row.updatedAt,
+        ].join(' · '),
+        hint: row.message,
+    }));
+}
+function previewRows(rows) {
+    return rows.map((row) => ({
+        status: row.valid ? 'ok' : 'fail',
+        key: row.rowKey ?? '(missing row key)',
+        value: row.valid ? 'valid' : (row.category ?? 'invalid'),
+        ...(row.valid && row.properties
+            ? { detail: JSON.stringify(row.properties) }
+            : row.message
+                ? { hint: row.message }
+                : {}),
+    }));
+}
+function reportPreview(reporter, syncId, portalId, preview) {
+    return Effect.gen(function* () {
+        yield* reporter.header(`${syncId} · portal ${portalId} · preview`);
+        yield* reporter.rows([
+            {
+                status: preview.invalid > 0 ? 'warn' : 'ok',
+                key: 'sample',
+                value: `${preview.valid} valid · ${preview.invalid} invalid`,
+                detail: `${preview.fetched} fetched${preview.truncated ? ' · sample truncated' : ''}`,
+            },
+            { key: 'target', value: preview.objectType, detail: `id property ${preview.idProperty}` },
+        ]);
+        if (preview.rows.length > 0)
+            yield* reporter.rows(previewRows(preview.rows));
+        else
+            yield* reporter.info('The current source page is empty.');
+        yield* reporter.done('sync preview — no state or HubSpot writes');
+    });
+}
+function statusRows(status) {
+    const latest = status.latestRun;
+    const state = status.state;
+    return [
+        ...(state?.pausedAt
+            ? [
+                {
+                    status: 'warn',
+                    key: 'control',
+                    value: 'paused',
+                    detail: `since ${state.pausedAt}`,
+                    hint: 'Resume with `hs-x sync state resume`.',
+                },
+            ]
+            : []),
+        {
+            status: state?.status === 'failed'
+                ? 'fail'
+                : state?.status === 'running'
+                    ? 'warn'
+                    : 'ok',
+            key: 'state',
+            value: state?.status ?? 'never run',
+            ...(state?.lease ? { detail: `lease until ${state.lease.expiresAt}` } : {}),
+            ...(state?.lastError ? { hint: state.lastError } : {}),
+        },
+        { key: 'schedule', value: status.schedule === undefined ? 'manual' : String(status.schedule) },
+        {
+            key: 'cursor',
+            value: state?.cursorUpdatedAt ?? 'not established',
+            ...(state?.cursor !== undefined ? { detail: JSON.stringify(state.cursor) } : {}),
+        },
+        {
+            status: status.poisonCount > 0 ? 'warn' : 'ok',
+            key: 'poison',
+            value: String(status.poisonCount),
+            ...(status.poisonCount > 0
+                ? { hint: 'Inspect quarantined rows with `hs-x sync poison list`.' }
+                : {}),
+        },
+        latest
+            ? {
+                status: latest.outcome === 'completed'
+                    ? 'ok'
+                    : latest.outcome === 'failed'
+                        ? 'fail'
+                        : 'warn',
+                key: 'last run',
+                value: `${latest.startedAt} · ${latest.outcome}`,
+                detail: runDetail(latest),
+                ...(latest.error ? { hint: latest.error } : {}),
+            }
+            : { key: 'last run', value: 'none' },
+    ];
+}
+function statusBody(syncId, portal, opts) {
+    return Effect.gen(function* () {
+        const portalId = Option.getOrUndefined(portal);
+        if (!portalId) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', '`hs-x sync status` requires --portal <id>.'));
+        }
+        const { client } = yield* resolveSyncContext(opts);
+        const status = yield* Effect.tryPromise({
+            try: () => client.status({ capabilityId: syncId, portalId }),
+            catch: operationsError,
+        });
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data({ status });
+            yield* reporter.done();
+            return;
+        }
+        yield* reporter.header(`${syncId} · portal ${portalId}`);
+        yield* reporter.rows(statusRows(status));
+        yield* reporter.done('sync status');
+    });
+}
+function runsBody(syncId, portal, limit, opts) {
+    return Effect.gen(function* () {
+        if (!Number.isInteger(limit) || limit < 1 || limit > 200) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', '--limit must be an integer from 1 to 200.'));
+        }
+        const { client } = yield* resolveSyncContext(opts);
+        const portalId = Option.getOrUndefined(portal);
+        const runs = yield* Effect.tryPromise({
+            try: () => client.runs({
+                capabilityId: syncId,
+                ...(portalId ? { portalId } : {}),
+                limit,
+            }),
+            catch: operationsError,
+        });
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data({ runs });
+            yield* reporter.done();
+            return;
+        }
+        yield* reporter.header(`${syncId}${portalId ? ` · portal ${portalId}` : ''}`);
+        if (runs.length === 0)
+            yield* reporter.info('No sync runs recorded.');
+        else
+            yield* reporter.rows(runRows(runs));
+        yield* reporter.done(`${runs.length} run${runs.length === 1 ? '' : 's'}`);
+    });
+}
+function logEvents(run) {
+    return [
+        {
+            timestamp: run.startedAt,
+            level: 'info',
+            event: 'sync.run.started',
+            message: `${run.trigger} run started for portal ${run.key.portalId}`,
+        },
+        ...(run.finishedAt
+            ? [
+                {
+                    timestamp: run.finishedAt,
+                    level: run.outcome === 'failed' ? 'error' : 'info',
+                    event: `sync.run.${run.outcome}`,
+                    message: run.error ??
+                        `${run.delivered ?? 0} delivered, ${run.quarantined ?? 0} quarantined, ${run.pages ?? 0} pages`,
+                },
+            ]
+            : []),
+    ];
+}
+function logsBody(syncId, runId, portal, opts) {
+    return Effect.gen(function* () {
+        const { client } = yield* resolveSyncContext(opts);
+        const portalId = Option.getOrUndefined(portal);
+        const run = yield* Effect.tryPromise({
+            try: () => client.run({
+                capabilityId: syncId,
+                runId,
+                ...(portalId ? { portalId } : {}),
+            }),
+            catch: operationsError,
+        });
+        if (!run) {
+            return yield* Effect.fail(cliError('HSX_E_API_NOT_FOUND', `No visible sync run named '${runId}' was found.`));
+        }
+        const events = logEvents(run);
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data({ run, events });
+            yield* reporter.done();
+            return;
+        }
+        yield* reporter.header(`${syncId} · ${runId}`);
+        yield* reporter.rows(events.map((event) => ({
+            status: event.level === 'error' ? 'fail' : 'ok',
+            key: event.timestamp,
+            value: event.event,
+            detail: event.message,
+        })));
+        yield* reporter.done(`${events.length} durable lifecycle event${events.length === 1 ? '' : 's'}`);
+    });
+}
+function stateGetBody(syncId, portal, opts) {
+    return Effect.gen(function* () {
+        const portalId = Option.getOrUndefined(portal);
+        if (!portalId) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', '`hs-x sync state get` requires --portal <id>.'));
+        }
+        const { client } = yield* resolveSyncContext(opts);
+        const status = yield* Effect.tryPromise({
+            try: () => client.status({ capabilityId: syncId, portalId }),
+            catch: operationsError,
+        });
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data({
+                capability_id: syncId,
+                portal_id: portalId,
+                state: status.state ?? null,
+                checkpoints: status.checkpoints,
+            });
+            yield* reporter.done();
+            return;
+        }
+        yield* reporter.header(`${syncId} · portal ${portalId} · state`);
+        yield* reporter.rows(statusRows({ ...status, latestRun: undefined, poisonCount: 0 }).filter((row) => ['control', 'state', 'cursor'].includes(row.key)));
+        yield* reporter.rows([
+            {
+                key: 'checkpoints',
+                value: String(status.checkpoints.length),
+                ...(status.checkpoints.length > 0
+                    ? { detail: status.checkpoints.map((checkpoint) => checkpoint.chunkId).join(', ') }
+                    : {}),
+            },
+        ]);
+        yield* reporter.done('sync state');
+    });
+}
+function stateResetBody(syncId, portal, yes, opts) {
+    return Effect.gen(function* () {
+        const portalId = Option.getOrUndefined(portal);
+        if (!portalId) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', '`hs-x sync state reset` requires --portal <id>.'));
+        }
+        if (!yes) {
+            if (opts.json || isMachineOutput() || !isInteractive()) {
+                return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', 'Resetting sync state requires explicit consent outside an interactive terminal. Re-run with --yes.'));
+            }
+            const confirmed = yield* Effect.promise(() => promptConfirm({
+                message: `Reset cursor, checkpoints, attempts, and errors for ${syncId} in portal ${portalId}?`,
+                default: false,
+            }));
+            if (confirmed !== true) {
+                return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', 'Sync state reset cancelled.'));
+            }
+        }
+        const { client } = yield* resolveSyncContext(opts);
+        const result = yield* Effect.tryPromise({
+            try: () => client.resetState({ capabilityId: syncId, portalId }),
+            catch: operationsError,
+        });
+        if (!result.reset) {
+            return yield* Effect.fail(cliError('HSX_E_API_CONFLICT', `Sync state cannot be reset while ${result.ownerId} holds the lease until ${result.expiresAt}.`));
+        }
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data({ result });
+            yield* reporter.done();
+            return;
+        }
+        yield* reporter.header(`${syncId} · portal ${portalId}`);
+        yield* reporter.rows([
+            {
+                status: 'ok',
+                key: 'state',
+                value: result.existed ? 'reset' : 'already empty',
+                detail: 'cursor, checkpoints, attempts, and last error cleared',
+            },
+        ]);
+        yield* reporter.done('sync state reset');
+    });
+}
+function statePauseBody(syncId, portal, paused, yes, opts) {
+    const action = paused ? 'pause' : 'resume';
+    return Effect.gen(function* () {
+        const portalId = Option.getOrUndefined(portal);
+        if (!portalId) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', `\`hs-x sync state ${action}\` requires --portal <id>.`));
+        }
+        if (!yes) {
+            if (opts.json || isMachineOutput() || !isInteractive()) {
+                return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', `${paused ? 'Pausing' : 'Resuming'} a sync requires explicit consent outside an interactive terminal. Re-run with --yes.`));
+            }
+            const confirmed = yield* Effect.promise(() => promptConfirm({
+                message: `${paused ? 'Pause' : 'Resume'} ${syncId} for portal ${portalId}?`,
+                default: false,
+            }));
+            if (confirmed !== true) {
+                return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', `Sync ${action} cancelled.`));
+            }
+        }
+        const { client } = yield* resolveSyncContext(opts);
+        const result = yield* Effect.tryPromise({
+            try: () => client.setPaused({ capabilityId: syncId, portalId, paused }),
+            catch: operationsError,
+        });
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data({ result });
+            yield* reporter.done();
+            return;
+        }
+        yield* reporter.header(`${syncId} · portal ${portalId}`);
+        yield* reporter.rows([
+            {
+                status: result.paused ? 'warn' : 'ok',
+                key: 'control',
+                value: result.paused ? 'paused' : 'running',
+                detail: result.changed ? 'state changed' : 'already in this state',
+            },
+        ]);
+        yield* reporter.done(`sync ${action}`);
+    });
+}
+function poisonBody(syncId, portal, opts) {
+    return Effect.gen(function* () {
+        const portalId = Option.getOrUndefined(portal);
+        if (!portalId) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', '`hs-x sync poison list` requires --portal <id>.'));
+        }
+        const { client } = yield* resolveSyncContext(opts);
+        const rows = yield* Effect.tryPromise({
+            try: () => client.poison({ capabilityId: syncId, portalId }),
+            catch: operationsError,
+        });
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data({ rows });
+            yield* reporter.done();
+            return;
+        }
+        yield* reporter.header(`${syncId} · portal ${portalId} · poison rows`);
+        if (rows.length === 0)
+            yield* reporter.info('No quarantined rows.');
+        else
+            yield* reporter.rows(poisonRows(rows));
+        yield* reporter.done(`${rows.length} poison row${rows.length === 1 ? '' : 's'}`);
+    });
+}
+function poisonRetryBody(syncId, rowKey, portal, yes, opts) {
+    return Effect.gen(function* () {
+        const portalId = Option.getOrUndefined(portal);
+        if (!portalId) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', '`hs-x sync poison retry` requires --portal <id>.'));
+        }
+        if (!yes) {
+            if (opts.json || isMachineOutput() || !isInteractive()) {
+                return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', 'Retrying a poison row performs a HubSpot write and requires explicit consent outside an interactive terminal. Re-run with --yes.'));
+            }
+            const confirmed = yield* Effect.promise(() => promptConfirm({
+                message: `Retry poison row ${rowKey} for ${syncId} in portal ${portalId}?`,
+                default: false,
+            }));
+            if (confirmed !== true) {
+                return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', 'Poison retry cancelled.'));
+            }
+        }
+        const { client } = yield* resolveSyncContext(opts);
+        const result = yield* Effect.tryPromise({
+            try: () => client.retryPoison({ capabilityId: syncId, portalId, rowKey }),
+            catch: operationsError,
+        });
+        if (!result.retried) {
+            return yield* Effect.fail(cliError(result.reason === 'not_found' ? 'HSX_E_API_NOT_FOUND' : 'HSX_E_API_CONFLICT', result.message));
+        }
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data({ result });
+            yield* reporter.done();
+            return;
+        }
+        yield* reporter.header(`${syncId} · portal ${portalId}`);
+        yield* reporter.rows([
+            {
+                status: 'ok',
+                key: rowKey,
+                value: 'delivered',
+                detail: `${result.objectType} · poison row removed after confirmed upsert`,
+            },
+        ]);
+        yield* reporter.done('poison retry');
+    });
+}
+function runBody(syncId, portal, preview, limit, opts) {
+    return Effect.gen(function* () {
+        const portalId = Option.getOrUndefined(portal);
+        if (!portalId) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', '`hs-x sync run` requires --portal <id>.'));
+        }
+        if (preview && (!Number.isInteger(limit) || limit < 1 || limit > 100)) {
+            return yield* Effect.fail(cliError('HSX_E_INPUT_INVALID', '--limit must be an integer from 1 to 100 for preview.'));
+        }
+        const context = yield* resolveSyncContext(opts);
+        if (preview) {
+            const result = yield* Effect.tryPromise({
+                try: () => context.client.preview({ capabilityId: syncId, portalId, limit }),
+                catch: operationsError,
+            });
+            const reporter = yield* Reporter;
+            if (reporter.mode !== 'human') {
+                yield* reporter.data({ preview: result });
+                yield* reporter.done();
+                return;
+            }
+            yield* reportPreview(reporter, syncId, portalId, result);
+            return;
+        }
+        const payload = yield* Effect.tryPromise({
+            try: async () => {
+                const request = await createRuntimeSyncRunRequest({
+                    runtimeBaseUrl: context.runtimeBaseUrl,
+                    grantSecret: context.grantSecret,
+                    scope: context.scope,
+                    capabilityId: syncId,
+                    trigger: 'manual',
+                    body: { install: { portalId } },
+                });
+                const response = await fetch(request);
+                const body = (await response.json().catch(() => ({})));
+                if (!response.ok || body.ok !== true) {
+                    const message = typeof body.message === 'string'
+                        ? body.message
+                        : `Sync run request failed with status ${response.status}.`;
+                    throw new RuntimeSyncOperationsError(response.status, message, typeof body.error === 'string' ? body.error : undefined);
+                }
+                return body;
+            },
+            catch: operationsError,
+        });
+        const reporter = yield* Reporter;
+        if (reporter.mode !== 'human') {
+            yield* reporter.data(payload);
+            yield* reporter.done();
+            return;
+        }
+        const runId = typeof payload.runId === 'string' ? payload.runId : undefined;
+        const result = typeof payload.result === 'object' && payload.result !== null
+            ? payload.result
+            : undefined;
+        yield* reporter.header(`${syncId} · portal ${portalId}`);
+        yield* reporter.rows([
+            { status: 'ok', key: 'run', value: runId ?? 'completed' },
+            ...(result
+                ? [
+                    {
+                        key: 'delivery',
+                        value: `${String(result.delivered ?? 0)} delivered`,
+                        detail: `${String(result.quarantined ?? 0)} quarantined · ${String(result.pages ?? 0)} pages`,
+                    },
+                ]
+                : []),
+        ]);
+        yield* reporter.done('sync run');
+    });
+}
+const syncStatusCmd = Command.make('status', { syncId: syncIdArg, portal: portalOption, ...identityOptions }, ({ syncId, portal, ...opts }) => runHandler('sync status', { json: opts.json }, statusBody(syncId, portal, opts)));
+const syncRunsCmd = Command.make('runs', { syncId: syncIdArg, portal: portalOption, limit: limitOption, ...identityOptions }, ({ syncId, portal, limit, ...opts }) => runHandler('sync runs', { json: opts.json }, runsBody(syncId, portal, limit, opts)));
+const syncLogsCmd = Command.make('logs', {
+    syncId: syncIdArg,
+    runId: runIdArg,
+    portal: portalOption,
+    ...identityOptions,
+}, ({ syncId, runId, portal, ...opts }) => runHandler('sync logs', { json: opts.json }, logsBody(syncId, runId, portal, opts)));
+const syncStateGetCmd = Command.make('get', { syncId: syncIdArg, portal: portalOption, ...identityOptions }, ({ syncId, portal, ...opts }) => runHandler('sync state get', { json: opts.json }, stateGetBody(syncId, portal, opts)));
+const syncStateResetCmd = Command.make('reset', { syncId: syncIdArg, portal: portalOption, yes: yesOption, ...identityOptions }, ({ syncId, portal, yes, ...opts }) => runHandler('sync state reset', { json: opts.json }, stateResetBody(syncId, portal, yes, opts)));
+function makeSyncStatePauseCmd(name, paused) {
+    return Command.make(name, { syncId: syncIdArg, portal: portalOption, yes: yesOption, ...identityOptions }, ({ syncId, portal, yes, ...opts }) => runHandler(`sync state ${name}`, { json: opts.json }, statePauseBody(syncId, portal, paused, yes, opts)));
+}
+const syncStatePauseCmd = makeSyncStatePauseCmd('pause', true);
+const syncStateResumeCmd = makeSyncStatePauseCmd('resume', false);
+const syncStateCmd = Command.make('state').pipe(Command.withSubcommands([
+    syncStateGetCmd,
+    syncStateResetCmd,
+    syncStatePauseCmd,
+    syncStateResumeCmd,
+]));
+const syncPoisonRetryCmd = Command.make('retry', {
+    syncId: syncIdArg,
+    rowKey: poisonRowArg,
+    portal: portalOption,
+    yes: yesOption,
+    ...identityOptions,
+}, ({ syncId, rowKey, portal, yes, ...opts }) => runHandler('sync poison retry', { json: opts.json }, poisonRetryBody(syncId, rowKey, portal, yes, opts)));
+const syncPoisonListCmd = Command.make('list', { syncId: syncIdArg, portal: portalOption, ...identityOptions }, ({ syncId, portal, ...opts }) => runHandler('sync poison list', { json: opts.json }, poisonBody(syncId, portal, opts)));
+const syncPoisonCmd = Command.make('poison').pipe(Command.withSubcommands([syncPoisonListCmd, syncPoisonRetryCmd]));
+const syncRunCmd = Command.make('run', {
+    syncId: syncIdArg,
+    portal: portalOption,
+    preview: previewOption,
+    limit: limitOption,
+    ...identityOptions,
+}, ({ syncId, portal, preview, limit, ...opts }) => runHandler('sync run', { json: opts.json }, runBody(syncId, portal, preview, limit, opts)));
+export const syncCmd = Command.make('sync').pipe(Command.withSubcommands([
+    syncStatusCmd,
+    syncRunsCmd,
+    syncLogsCmd,
+    syncStateCmd,
+    syncPoisonCmd,
+    syncRunCmd,
+]));
+//# sourceMappingURL=sync.js.map