edsger 0.60.0 → 0.62.0

package/dist/auth/env-store.js

@@ -19,6 +19,9 @@ const SECRET_KEYS = new Set([
     'GEMINI_API_KEY',
     'EDSGER_MCP_TOKEN',
     'GITHUB_TOKEN',
+    'DD_API_KEY',
+    'DD_APP_KEY',
+    'AWS_SECRET_ACCESS_KEY',
 ]);
 /**
  * Ensure the ~/.edsger directory exists

package/dist/commands/data-flow/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CLI command: edsger data-flow <productId> --flow-id <id>
+ *
+ * Maps the product's data nodes (source/dataset/transform/sink/queue/model)
+ * and the connections between them into a structured flow stored in
+ * flows / flow_nodes / flow_edges (rows tagged type='data').
+ *
+ * The desktop UI creates a pending flows row first, then invokes the CLI
+ * with --flow-id; the CLI flips status running → success/failed and
+ * populates the nodes/edges tables.
+ */
+export interface DataFlowCliOptions {
+    flowId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runDataFlow(productId: string, options: DataFlowCliOptions): Promise<void>;

package/dist/commands/data-flow/index.js

@@ -0,0 +1,46 @@
+/**
+ * CLI command: edsger data-flow <productId> --flow-id <id>
+ *
+ * Maps the product's data nodes (source/dataset/transform/sink/queue/model)
+ * and the connections between them into a structured flow stored in
+ * flows / flow_nodes / flow_edges (rows tagged type='data').
+ *
+ * The desktop UI creates a pending flows row first, then invokes the CLI
+ * with --flow-id; the CLI flips status running → success/failed and
+ * populates the nodes/edges tables.
+ */
+import { runDataFlowPhase } from '../../phases/data-flow/index.js';
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runDataFlow(productId, options) {
+    const { flowId, guidance, verbose } = options;
+    if (!productId) {
+        throw new Error('Product ID is required for data-flow');
+    }
+    if (!flowId) {
+        throw new Error('--flow-id is required (the pending flows row id)');
+    }
+    await registerSession({ command: 'data-flow', productId });
+    logInfo(`Starting data flow generation for product ${productId}`);
+    try {
+        const result = await runDataFlowPhase({
+            productId,
+            flowId,
+            guidance,
+            verbose,
+        });
+        if (result.status === 'success') {
+            logSuccess(result.message);
+            if (result.summary) {
+                logInfo(`\nSummary: ${result.summary}`);
+            }
+        }
+        else {
+            logError(result.message);
+            process.exit(1);
+        }
+    }
+    finally {
+        await deregisterSession();
+    }
+}

package/dist/commands/screen-flow/index.d.ts

@@ -2,11 +2,11 @@
  * CLI command: edsger screen-flow <productId> --flow-id <id>
  *
  * Maps the product's user-facing screens and transitions into a structured
- * flow stored in screen_flows / screen_flow_nodes / screen_flow_edges.
+ * flow stored in flows / flow_nodes / flow_edges (rows tagged type='screen').
  *
- * The desktop UI creates a pending screen_flows row first, then invokes
- * the CLI with --flow-id; the CLI flips status running → success/failed
- * and populates the nodes/edges tables.
+ * The desktop UI creates a pending flows row first, then invokes the CLI
+ * with --flow-id; the CLI flips status running → success/failed and
+ * populates the nodes/edges tables.
  */
 export interface ScreenFlowCliOptions {
     flowId: string;

package/dist/commands/screen-flow/index.js

@@ -2,11 +2,11 @@
  * CLI command: edsger screen-flow <productId> --flow-id <id>
  *
  * Maps the product's user-facing screens and transitions into a structured
- * flow stored in screen_flows / screen_flow_nodes / screen_flow_edges.
+ * flow stored in flows / flow_nodes / flow_edges (rows tagged type='screen').
  *
- * The desktop UI creates a pending screen_flows row first, then invokes
- * the CLI with --flow-id; the CLI flips status running → success/failed
- * and populates the nodes/edges tables.
+ * The desktop UI creates a pending flows row first, then invokes the CLI
+ * with --flow-id; the CLI flips status running → success/failed and
+ * populates the nodes/edges tables.
  */
 import { runScreenFlowPhase } from '../../phases/screen-flow/index.js';
 import { deregisterSession, registerSession, } from '../../system/session-manager.js';
@@ -17,7 +17,7 @@ export async function runScreenFlow(productId, options) {
         throw new Error('Product ID is required for screen-flow');
     }
     if (!flowId) {
-        throw new Error('--flow-id is required (the pending screen_flows row id)');
+        throw new Error('--flow-id is required (the pending flows row id)');
     }
     await registerSession({ command: 'screen-flow', productId });
     logInfo(`Starting screen flow generation for product ${productId}`);

package/dist/commands/sync-aws/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * CLI command: `edsger sync-aws <teamId>`
+ *
+ * Uses the standard AWS credential chain (env vars, ~/.aws/credentials,
+ * IAM role, etc.) to discover services by their `Service` tag and
+ * optionally pull cost data from Cost Explorer.
+ *
+ * Does NOT store AWS credentials — relies on whatever the user's shell
+ * already has configured (same as running `aws` CLI directly).
+ */
+export interface SyncAwsOptions {
+    verbose?: boolean;
+    region?: string;
+    noCost?: boolean;
+}
+export declare function runSyncAws(teamId: string, options?: SyncAwsOptions): Promise<void>;

package/dist/commands/sync-aws/index.js

@@ -0,0 +1,184 @@
+/**
+ * CLI command: `edsger sync-aws <teamId>`
+ *
+ * Uses the standard AWS credential chain (env vars, ~/.aws/credentials,
+ * IAM role, etc.) to discover services by their `Service` tag and
+ * optionally pull cost data from Cost Explorer.
+ *
+ * Does NOT store AWS credentials — relies on whatever the user's shell
+ * already has configured (same as running `aws` CLI directly).
+ */
+import { exec as execCb } from 'child_process';
+import { promisify } from 'util';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
+const exec = promisify(execCb);
+async function runAwsCmd(args, region) {
+    const regionFlag = region ? ` --region ${region}` : '';
+    try {
+        const { stdout } = await exec(`aws ${args}${regionFlag} --output json`, {
+            timeout: 30_000,
+        });
+        return stdout;
+    }
+    catch (err) {
+        const e = err;
+        throw new Error(e.stderr?.trim() || e.message);
+    }
+}
+async function checkAwsCli() {
+    try {
+        await exec('aws --version', { timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runSyncAws(teamId, options = {}) {
+    const { verbose, noCost } = options;
+    const region = options.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1';
+    logInfo(`Starting AWS sync for team ${teamId} (region: ${region})`);
+    if (!(await checkAwsCli())) {
+        logError('AWS CLI not found. Install it from https://aws.amazon.com/cli/ ' +
+            'and configure credentials with `aws configure`.');
+        process.exit(1);
+    }
+    // Verify credentials work
+    try {
+        const identity = await runAwsCmd('sts get-caller-identity', region);
+        const parsed = JSON.parse(identity);
+        logInfo(`Authenticated as ${parsed.Arn} (account ${parsed.Account})`);
+    }
+    catch (err) {
+        logError(`AWS credentials not configured or invalid: ${err instanceof Error ? err.message : String(err)}. ` +
+            'Run `aws configure` or export AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY.');
+        process.exit(1);
+    }
+    // ── Phase 1: Resource discovery by Service tag ──
+    logInfo('Phase 1: Discovering resources by Service tag...');
+    let resources = [];
+    try {
+        let paginationToken;
+        do {
+            const tokenArg = paginationToken
+                ? ` --pagination-token "${paginationToken}"`
+                : '';
+            const raw = await runAwsCmd(`resourcegroupstaggingapi get-resources --tag-filters Key=Service${tokenArg}`, region);
+            const parsed = JSON.parse(raw);
+            resources.push(...parsed.ResourceTagMappingList);
+            paginationToken = parsed.PaginationToken || undefined;
+        } while (paginationToken);
+    }
+    catch (err) {
+        logError(`Failed to query tagged resources: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    logInfo(`Found ${resources.length} tagged resources`);
+    // Group by Service tag value
+    const byService = new Map();
+    for (const res of resources) {
+        const serviceTag = res.Tags.find((t) => t.Key === 'Service')?.Value;
+        if (!serviceTag)
+            continue;
+        if (!byService.has(serviceTag))
+            byService.set(serviceTag, []);
+        byService.get(serviceTag).push(res);
+    }
+    logInfo(`Mapped to ${byService.size} distinct services`);
+    let created = 0;
+    let updated = 0;
+    let componentCount = 0;
+    for (const [serviceName, svcResources] of byService) {
+        const teamTag = svcResources[0]?.Tags.find((t) => t.Key === 'Team')?.Value;
+        // Tier signals
+        const hasMultiAz = svcResources.some((r) => r.ResourceARN.includes(':rds:') || r.ResourceARN.includes(':elasticache:'));
+        const hasLambda = svcResources.some((r) => r.ResourceARN.includes(':lambda:'));
+        const hasEcs = svcResources.some((r) => r.ResourceARN.includes(':ecs:'));
+        const tier = hasMultiAz || (hasEcs && svcResources.length > 3) ? 'critical' : 'standard';
+        const kind = hasLambda && !hasEcs ? 'job' : 'service';
+        if (verbose) {
+            logInfo(`  ${serviceName}: ${svcResources.length} resources, tier=${tier}`);
+        }
+        try {
+            const result = (await callMcpEndpoint('services.upsert_draft', {
+                team_id: teamId,
+                name: serviceName,
+                kind,
+                tier,
+                source: 'aws',
+                source_ref: `aws:${region}:${serviceName}`,
+                field_sources: {
+                    name: { value: serviceName, confidence: 1.0, source: 'aws_tag', source_detail: 'Tag:Service' },
+                    tier: { value: tier, confidence: hasMultiAz ? 0.8 : 0.5, source: 'aws_resource_analysis' },
+                    ...(teamTag ? { owner: { value: teamTag, confidence: 0.8, source: 'aws_tag', source_detail: 'Tag:Team' } } : {}),
+                },
+                needs_review: false,
+            }));
+            if (result.action === 'created')
+                created++;
+            else
+                updated++;
+            // Add resource components
+            for (const res of svcResources) {
+                const arnParts = res.ResourceARN.split(':');
+                const resourceType = arnParts[2] ?? 'unknown';
+                try {
+                    await callMcpEndpoint('services.add_component', {
+                        service_id: result.service.id,
+                        kind: 'aws_resource',
+                        provider: 'aws',
+                        external_id: res.ResourceARN,
+                        metadata: {
+                            resource_type: resourceType,
+                            region,
+                            tags: Object.fromEntries(res.Tags.map((t) => [t.Key, t.Value])),
+                        },
+                    });
+                    componentCount++;
+                }
+                catch {
+                    // ignore duplicates
+                }
+            }
+        }
+        catch (err) {
+            logWarning(`Failed to sync "${serviceName}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ── Phase 2: Cost data (optional) ──
+    if (!noCost) {
+        logInfo('Phase 2: Fetching cost data from Cost Explorer...');
+        const now = new Date();
+        const endDate = now.toISOString().slice(0, 10);
+        const startDate = new Date(now.getTime() - 30 * 24 * 3600 * 1000)
+            .toISOString()
+            .slice(0, 10);
+        try {
+            const raw = await runAwsCmd(`ce get-cost-and-usage ` +
+                `--time-period Start=${startDate},End=${endDate} ` +
+                `--granularity MONTHLY ` +
+                `--metrics BlendedCost ` +
+                `--group-by Type=TAG,Key=Service`, region);
+            const parsed = JSON.parse(raw);
+            for (const period of parsed.ResultsByTime) {
+                for (const group of period.Groups) {
+                    const tagValue = group.Keys[0]?.replace('Service$', '') ?? '';
+                    if (!tagValue || tagValue === '')
+                        continue;
+                    const cost = parseFloat(group.Metrics.BlendedCost.Amount);
+                    if (cost <= 0)
+                        continue;
+                    if (verbose) {
+                        logInfo(`  ${tagValue}: $${cost.toFixed(2)}/month`);
+                    }
+                }
+            }
+            logSuccess('Cost data fetched (displayed above, not yet persisted to DB)');
+        }
+        catch (err) {
+            logWarning(`Cost Explorer query failed (may need ce:GetCostAndUsage permission): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    logSuccess(`AWS sync completed: ${created} created, ${updated} updated, ${componentCount} resource components from ${byService.size} services`);
+}

package/dist/commands/sync-datadog/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * CLI command: `edsger sync-datadog <teamId>`
+ *
+ * Imports services from a Datadog Service Catalog into the edsger service
+ * catalog. Reads DD_API_KEY, DD_APP_KEY, DD_SITE from process.env
+ * (populated by `edsger config set` or desktop credentials).
+ *
+ * Flow:
+ *   1. Fetch all service definitions from Datadog API
+ *   2. Map each to an edsger service (name, tier, owner, repos, dashboards)
+ *   3. Upsert via MCP endpoints (services.upsert_draft, services.add_component)
+ */
+export interface SyncDatadogOptions {
+    verbose?: boolean;
+}
+export declare function runSyncDatadog(teamId: string, options?: SyncDatadogOptions): Promise<void>;

package/dist/commands/sync-datadog/index.js

@@ -0,0 +1,199 @@
+/**
+ * CLI command: `edsger sync-datadog <teamId>`
+ *
+ * Imports services from a Datadog Service Catalog into the edsger service
+ * catalog. Reads DD_API_KEY, DD_APP_KEY, DD_SITE from process.env
+ * (populated by `edsger config set` or desktop credentials).
+ *
+ * Flow:
+ *   1. Fetch all service definitions from Datadog API
+ *   2. Map each to an edsger service (name, tier, owner, repos, dashboards)
+ *   3. Upsert via MCP endpoints (services.upsert_draft, services.add_component)
+ */
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
+function readDatadogEnv() {
+    const apiKey = process.env.DD_API_KEY ?? '';
+    const appKey = process.env.DD_APP_KEY ?? '';
+    const site = process.env.DD_SITE ?? 'datadoghq.com';
+    const missing = [];
+    if (!apiKey)
+        missing.push('DD_API_KEY');
+    if (!appKey)
+        missing.push('DD_APP_KEY');
+    if (missing.length > 0)
+        return { ok: false, missing };
+    return { ok: true, env: { apiKey, appKey, site } };
+}
+function mapTier(ddTier) {
+    if (!ddTier)
+        return 'standard';
+    const lower = ddTier.toLowerCase();
+    if (lower.includes('1') || lower.includes('critical') || lower.includes('high'))
+        return 'critical';
+    if (lower.includes('3') || lower.includes('low') || lower.includes('experiment'))
+        return 'experimental';
+    return 'standard';
+}
+function mapKind(ddType) {
+    if (!ddType)
+        return 'service';
+    const lower = ddType.toLowerCase();
+    if (lower === 'web' || lower === 'website' || lower === 'frontend')
+        return 'website';
+    if (lower === 'library' || lower === 'lib')
+        return 'library';
+    if (lower === 'job' || lower === 'worker' || lower === 'cron')
+        return 'job';
+    return 'service';
+}
+export async function runSyncDatadog(teamId, options = {}) {
+    const { verbose } = options;
+    logInfo(`Starting Datadog service sync for team ${teamId}`);
+    const env = readDatadogEnv();
+    if (!env.ok) {
+        logError(`Datadog not configured. Missing: ${env.missing.join(', ')}. ` +
+            `Configure in the desktop app (Settings → Credentials → Datadog) or ` +
+            `set them with \`edsger config set DD_API_KEY=<key> DD_APP_KEY=<key>\`. ` +
+            `Optional: DD_SITE for non-US1 sites.`);
+        process.exit(1);
+    }
+    const { apiKey, appKey, site } = env.env;
+    // Fetch service definitions from Datadog
+    logInfo(`Fetching service definitions from Datadog (${site})...`);
+    let services = [];
+    try {
+        const res = await fetch(`https://api.${site}/api/v2/services/definitions?page[size]=100`, {
+            headers: {
+                'DD-API-KEY': apiKey,
+                'DD-APPLICATION-KEY': appKey,
+            },
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            logError(`Datadog API returned ${res.status}: ${text}`);
+            process.exit(1);
+        }
+        const json = (await res.json());
+        services = json.data ?? [];
+    }
+    catch (err) {
+        logError(`Failed to fetch from Datadog: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    logInfo(`Found ${services.length} service definitions in Datadog`);
+    let created = 0;
+    let updated = 0;
+    let skipped = 0;
+    let componentCount = 0;
+    for (const svc of services) {
+        const schema = svc.attributes?.schema;
+        if (!schema) {
+            skipped++;
+            continue;
+        }
+        const name = schema['dd-service'] ?? schema.service;
+        if (!name) {
+            skipped++;
+            continue;
+        }
+        if (verbose)
+            logInfo(`Processing: ${name}`);
+        try {
+            // Upsert service
+            const result = (await callMcpEndpoint('services.upsert_draft', {
+                team_id: teamId,
+                name,
+                display_name: schema.application ?? name,
+                description: schema.description ?? null,
+                kind: mapKind(schema.type),
+                tier: mapTier(schema.tier),
+                language: schema.languages?.[0] ?? null,
+                tags: schema.tags ?? [],
+                source: 'datadog',
+                source_ref: `datadog:${name}`,
+                field_sources: {
+                    name: { value: name, confidence: 1.0, source: 'datadog' },
+                    tier: { value: mapTier(schema.tier), confidence: 0.9, source: 'datadog' },
+                    language: { value: schema.languages?.[0], confidence: 1.0, source: 'datadog' },
+                    ...(schema.team ? { owner: { value: schema.team, confidence: 0.9, source: 'datadog' } } : {}),
+                },
+                needs_review: false,
+            }));
+            const serviceId = result.service.id;
+            if (result.action === 'created')
+                created++;
+            else
+                updated++;
+            // Add repo components
+            for (const repo of schema.repos ?? []) {
+                if (!repo.url)
+                    continue;
+                const repoName = repo.url
+                    .replace(/^https?:\/\/github\.com\//, '')
+                    .replace(/\.git$/, '');
+                try {
+                    await callMcpEndpoint('services.add_component', {
+                        service_id: serviceId,
+                        kind: 'repo',
+                        provider: 'github',
+                        external_id: repoName,
+                        url: repo.url,
+                    });
+                    componentCount++;
+                }
+                catch {
+                    if (verbose)
+                        logWarning(`  Failed to add repo: ${repo.url}`);
+                }
+            }
+            // Add link components (dashboards, runbooks, etc.)
+            for (const link of schema.links ?? []) {
+                if (!link.url)
+                    continue;
+                const kind = link.type === 'dashboard' || link.type === 'grafana'
+                    ? 'dashboard'
+                    : link.type === 'runbook' || link.type === 'doc'
+                        ? 'runbook'
+                        : link.type === 'oncall' || link.type === 'pagerduty'
+                            ? 'pagerduty_service'
+                            : 'documentation';
+                try {
+                    await callMcpEndpoint('services.add_component', {
+                        service_id: serviceId,
+                        kind,
+                        provider: 'datadog',
+                        external_id: link.name ?? link.url,
+                        url: link.url,
+                    });
+                    componentCount++;
+                }
+                catch {
+                    if (verbose)
+                        logWarning(`  Failed to add link: ${link.url}`);
+                }
+            }
+            // Add Slack channel
+            const slackContact = (schema.contacts ?? []).find((c) => c.type === 'slack');
+            if (slackContact?.contact) {
+                try {
+                    await callMcpEndpoint('services.add_component', {
+                        service_id: serviceId,
+                        kind: 'slack_channel',
+                        provider: 'slack',
+                        external_id: slackContact.contact,
+                    });
+                    componentCount++;
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        catch (err) {
+            logWarning(`Failed to sync "${name}": ${err instanceof Error ? err.message : String(err)}`);
+            skipped++;
+        }
+    }
+    logSuccess(`Datadog sync completed: ${created} created, ${updated} updated, ${skipped} skipped, ${componentCount} components added`);
+}

package/dist/commands/sync-org-repos/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CLI command: `edsger sync-org-repos <teamId>`
+ *
+ * Reads the team's configured github_org, fetches all repos from that org
+ * via the local `gh` CLI, and creates a product for each repo not yet linked.
+ */
+export interface SyncOrgReposCliOptions {
+    verbose?: boolean;
+    org?: string;
+}
+export declare function runSyncOrgRepos(teamId: string, options?: SyncOrgReposCliOptions): Promise<void>;

package/dist/commands/sync-org-repos/index.js

@@ -0,0 +1,59 @@
+/**
+ * CLI command: `edsger sync-org-repos <teamId>`
+ *
+ * Reads the team's configured github_org, fetches all repos from that org
+ * via the local `gh` CLI, and creates a product for each repo not yet linked.
+ */
+import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
+import { syncOrgRepos } from '../../phases/sync-org-repos/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+const ORG_NAME_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
+export async function runSyncOrgRepos(teamId, options = {}) {
+    const { verbose } = options;
+    if (!hasSupabaseSession()) {
+        logError('Supabase session unavailable. Sign in to the Edsger desktop app to authorize the CLI.');
+        process.exit(1);
+    }
+    const supabase = getSupabase();
+    let orgLogin = options.org;
+    if (!orgLogin) {
+        const { data: team, error } = await supabase
+            .from('teams')
+            .select('github_org')
+            .eq('id', teamId)
+            .single();
+        if (error || !team) {
+            logError(`Team not found: ${teamId}`);
+            process.exit(1);
+        }
+        orgLogin = team.github_org ?? undefined;
+        if (!orgLogin) {
+            logError('No GitHub organization configured for this team. Set it in team settings first, or pass --org <name>.');
+            process.exit(1);
+        }
+    }
+    if (!ORG_NAME_RE.test(orgLogin) || orgLogin.length > 39) {
+        logError(`Invalid GitHub organization name: "${orgLogin}"`);
+        process.exit(1);
+    }
+    const { data: { user }, } = await supabase.auth.getUser();
+    if (!user) {
+        logError('Not authenticated');
+        process.exit(1);
+    }
+    logInfo(`Syncing repos from org "${orgLogin}" into team ${teamId}`);
+    const result = await syncOrgRepos({
+        teamId,
+        orgLogin,
+        userId: user.id,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(result.message);
+        logInfo(`Total: ${result.total} · created: ${result.created} · skipped: ${result.skipped}`);
+    }
+    else {
+        logError(result.message);
+        process.exit(1);
+    }
+}

package/dist/commands/sync-terraform/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * CLI command: `edsger sync-terraform <teamId>`
+ *
+ * Reads the team's terraform_repo_full_name from the DB, clones the repo,
+ * and lets the agent (Claude SDK) analyse .tf files to extract service
+ * identities, AWS resources, module dependencies, and tier signals.
+ *
+ * Unlike sync-datadog (structured API → deterministic mapping), Terraform
+ * HCL is too varied for regex parsing — the agent reads files and reasons
+ * about module structure, variable passing, resource tagging, etc.
+ */
+export interface SyncTerraformOptions {
+    verbose?: boolean;
+    dir?: string;
+}
+export declare function runSyncTerraform(teamId: string, options?: SyncTerraformOptions): Promise<void>;