@sequenceholdings/studio-cli 0.1.21 → 0.1.24

package/dist/pipeline/lifecycle.js

@@ -5,9 +5,34 @@
 import { getAccessToken, NotLoggedInError } from '../auth.js';
 import { AtlasApiError, getJson, postJson } from '../atlas-client.js';
 import { resolveEnvWithDiscovery } from '../config.js';
-import { isFullSha, requiresPinnedSha } from './pinning.js';
 const LOG = '[seq-studio]';
 const TERMINAL = new Set(['active', 'failed', 'retired']);
+const POLL_INTERVAL_MS = 2000;
+const HEARTBEAT_INTERVAL_MS = 20_000;
+const FIRST_PARTY_TARGETS = [
+    { id: 'dev', label: 'Development', requiresApproval: false },
+    { id: 'staging', label: 'Staging', requiresApproval: false },
+    { id: 'production', label: 'Production', requiresApproval: true },
+    { id: 'banksouth', label: 'BankSouth', requiresApproval: true },
+];
+function formatElapsed(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    const min = Math.floor(totalSec / 60);
+    const sec = totalSec % 60;
+    return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
+}
+function deploymentProgressSuffix(detail) {
+    if (detail.triggerRunId)
+        return ` (trigger ${detail.triggerRunId})`;
+    return '';
+}
+function deploymentStatusLabel(detail) {
+    if (detail.statusDetail)
+        return `${detail.status} — ${detail.statusDetail}`;
+    return detail.status;
+}
 async function envAndToken(args) {
     const requested = typeof args.flags.e === 'string' ? args.flags.e : typeof args.flags.env === 'string' ? args.flags.env : undefined;
     if (!requested) {
@@ -31,21 +56,32 @@ function flagString(flags, key) {
         throw new Error(`--${key} requires a value`);
     return value;
 }
-/**
- * The CLI's local dev-loop env is named `local` — chosen so `-e local` lines
- * up with `seqapi -e local` / `artifact-studio --env local` (see `config.ts`
- * `BUILT_IN_ENV_URLS`). There is no `local` in the server's deploy-lifecycle
- * enum (`DEPLOY_ENVIRONMENTS` in `atlas/src/server/services/data-pipelines/schema.ts`
- * is `dev | staging | production | banksouth`); the server's name for that
- * same developer-loop target is `dev` (`targetFactsForEnvironment` treats
- * `dev` as the one target exempt from a `lakebase_branch` binding). Map at
- * this one boundary — every lifecycle request body funnels through here —
- * so the CLI never sends the wire-invalid `local` and every other env name
- * passes through unchanged.
- */
 export function deployEnvironmentForEnv(env) {
     return env.name === 'local' ? 'dev' : env.name;
 }
+async function resolvePipelineTarget({ args, env, token, }) {
+    const requested = flagString(args.flags, 'target');
+    const inferredId = requested ?? deployEnvironmentForEnv(env);
+    if (!requested) {
+        const firstPartyTarget = FIRST_PARTY_TARGETS.find((target) => target.id === inferredId);
+        if (firstPartyTarget)
+            return firstPartyTarget;
+    }
+    const response = await getJson({
+        baseUrl: env.url,
+        token,
+        path: '/api/data-pipelines/targets',
+    });
+    const targets = response.targets;
+    const matchingTarget = targets.find((target) => target.id === inferredId);
+    if (matchingTarget)
+        return matchingTarget;
+    if (!requested && targets.length === 1)
+        return targets[0];
+    const available = targets.map((target) => target.id).join(', ') || 'none';
+    throw new Error(`could not select a pipeline target for '${env.name}'; available targets: ${available}. ` +
+        'Pass --target <id> explicitly.');
+}
 export async function pipelinePlanCommand(args) {
     const repo = flagString(args.flags, 'repo');
     const ref = flagString(args.flags, 'ref');
@@ -55,13 +91,21 @@ export async function pipelinePlanCommand(args) {
     }
     const { env, token } = await envAndToken(args);
     const json = args.flags.json === true || args.flags.json === 'true';
+    let target;
+    try {
+        target = await resolvePipelineTarget({ args, env, token });
+    }
+    catch (error) {
+        console.error(`${LOG} plan failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
     let response;
     try {
         response = await postJson({
             baseUrl: env.url,
             token,
             path: '/api/data-pipelines/pipelines/plan',
-            body: { repo, ref, environment: deployEnvironmentForEnv(env) },
+            body: { repo, ref, environment: target.id },
         });
     }
     catch (error) {
@@ -86,8 +130,12 @@ export async function pipelineDeployCommand(args) {
     const deploymentId = flagString(args.flags, 'deployment-id');
     const approvedBy = flagString(args.flags, 'approved-by');
     const { env, token } = await envAndToken(args);
-    if (requiresPinnedSha(env.name) && ref && !isFullSha(ref)) {
-        console.error(`${LOG} deploy to ${env.name} requires a pinned 40-hex commit SHA (got '${ref}')`);
+    let target;
+    try {
+        target = await resolvePipelineTarget({ args, env, token });
+    }
+    catch (error) {
+        console.error(`${LOG} deploy failed: ${error instanceof Error ? error.message : String(error)}`);
         return 1;
     }
     let enqueue;
@@ -96,19 +144,19 @@ export async function pipelineDeployCommand(args) {
             // Direct execute of a persisted plan.
             const stageId = flagString(args.flags, 'stage-id');
             if (!stageId) {
-                console.error('usage: seq-studio pipeline deploy --deployment-id <id> --stage-id <id> -e <env> [--approved-by <sub>] [--no-wait]');
+                console.error('usage: seq-studio pipeline deploy --deployment-id <id> --stage-id <id> -e <env> [--target <id>] [--approved-by <sub>] [--no-wait]');
                 return 1;
             }
             enqueue = await postJson({
                 baseUrl: env.url,
                 token,
                 path: `/api/data-pipelines/stages/${stageId}/deploy`,
-                body: { deploymentId, ...(approvedBy ? { approvedBy } : {}) },
+                body: { deploymentId, environment: target.id, ...(approvedBy ? { approvedBy } : {}) },
             });
         }
         else {
             if (!repo || !ref) {
-                console.error('usage: seq-studio pipeline deploy --repo pipelines/<slug> --ref <sha> -e <env> [--approved-by <sub>] [--no-wait]');
+                console.error('usage: seq-studio pipeline deploy --repo pipelines/<slug> --ref <sha|branch> -e <env> [--target <id>] [--approved-by <sub>] [--no-wait]');
                 return 1;
             }
             // Plan then deploy the first planning deployment.
@@ -116,7 +164,7 @@ export async function pipelineDeployCommand(args) {
                 baseUrl: env.url,
                 token,
                 path: '/api/data-pipelines/pipelines/plan',
-                body: { repo, ref, environment: deployEnvironmentForEnv(env) },
+                body: { repo, ref, environment: target.id },
             });
             if (plan.plan.hasDestructive) {
                 console.error(`${LOG} plan has destructive findings — refusing to deploy`);
@@ -140,6 +188,7 @@ export async function pipelineDeployCommand(args) {
                 path: `/api/data-pipelines/stages/${stageId}/deploy`,
                 body: {
                     deploymentId: firstId,
+                    environment: target.id,
                     ...(approvedBy ? { approvedBy } : {}),
                 },
             });
@@ -168,8 +217,16 @@ export async function pipelinePromoteCommand(args) {
         return 1;
     }
     const { env, token } = await envAndToken(args);
-    if (requiresPinnedSha(env.name) && !approvedBy) {
-        console.error(`${LOG} promote to ${env.name} requires --approved-by <your sub/email> (approvals are self-recorded)`);
+    let target;
+    try {
+        target = await resolvePipelineTarget({ args, env, token });
+    }
+    catch (error) {
+        console.error(`${LOG} promote failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+    if (target.requiresApproval && !approvedBy) {
+        console.error(`${LOG} promote to ${target.id} requires --approved-by <your sub/email> (approvals are self-recorded)`);
         return 1;
     }
     const stageId = await resolveStageIdBySlug({ baseUrl: env.url, token, slug: stage, repo });
@@ -181,7 +238,7 @@ export async function pipelinePromoteCommand(args) {
             path: `/api/data-pipelines/stages/${stageId}/promote`,
             body: {
                 version,
-                environment: deployEnvironmentForEnv(env),
+                environment: target.id,
                 ...(approvedBy ? { approvedBy } : {}),
             },
         });
@@ -207,6 +264,14 @@ export async function pipelineRunNowCommand(args) {
     }
     const { env, token } = await envAndToken(args);
     const json = args.flags.json === true || args.flags.json === 'true';
+    let target;
+    try {
+        target = await resolvePipelineTarget({ args, env, token });
+    }
+    catch (error) {
+        console.error(`${LOG} run-now failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
     let stageId;
     try {
         stageId = await resolveStageIdBySlug({ baseUrl: env.url, token, slug: stage, repo });
@@ -221,7 +286,7 @@ export async function pipelineRunNowCommand(args) {
             baseUrl: env.url,
             token,
             path: `/api/data-pipelines/stages/${stageId}/run`,
-            body: { environment: deployEnvironmentForEnv(env) },
+            body: { environment: target.id },
         });
     }
     catch (error) {
@@ -235,7 +300,7 @@ export async function pipelineRunNowCommand(args) {
         console.log(JSON.stringify(response, null, 2));
     }
     else {
-        console.log(`${LOG} run-now ${stage} → ${deployEnvironmentForEnv(env)}`);
+        console.log(`${LOG} run-now ${stage} → ${target.id}`);
         console.log(`${LOG} invocation ${response.invocationId} (${response.status})`);
         console.log(`${LOG} ${response.databricks_url}`);
     }
@@ -250,8 +315,16 @@ export async function pipelineRollbackCommand(args) {
         return 1;
     }
     const { env, token } = await envAndToken(args);
-    if (requiresPinnedSha(env.name) && !approvedBy) {
-        console.error(`${LOG} rollback in ${env.name} requires --approved-by <your sub/email> (approvals are explicit even for rollbacks)`);
+    let target;
+    try {
+        target = await resolvePipelineTarget({ args, env, token });
+    }
+    catch (error) {
+        console.error(`${LOG} rollback failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+    if (target.requiresApproval && !approvedBy) {
+        console.error(`${LOG} rollback in ${target.id} requires --approved-by <your sub/email> (approvals are explicit even for rollbacks)`);
         return 1;
     }
     const stageId = await resolveStageIdBySlug({ baseUrl: env.url, token, slug: stage, repo });
@@ -262,7 +335,7 @@ export async function pipelineRollbackCommand(args) {
             token,
             path: `/api/data-pipelines/stages/${stageId}/rollback`,
             body: {
-                environment: deployEnvironmentForEnv(env),
+                environment: target.id,
                 ...(approvedBy ? { approvedBy } : {}),
             },
         });
@@ -295,26 +368,165 @@ function printFindingsTable(findings) {
 async function pollDeployment({ baseUrl, token, deploymentId, }) {
     const started = Date.now();
     const timeoutMs = 15 * 60 * 1000;
+    let lastLoggedLabel = null;
+    let lastLogAt = started;
     while (Date.now() - started < timeoutMs) {
         const detail = await getJson({
             baseUrl,
             token,
             path: `/api/data-pipelines/deployments/${deploymentId}`,
         });
-        console.log(`${LOG} deployment ${deploymentId}: ${detail.status}`);
+        const elapsedMs = Date.now() - started;
         if (TERMINAL.has(detail.status)) {
+            const elapsed = formatElapsed(elapsedMs);
+            const progressSuffix = deploymentProgressSuffix(detail);
             if (detail.status === 'active') {
-                console.log(`${LOG} deploy succeeded`);
+                console.log(`${LOG} deployment ${deploymentId} succeeded (${elapsed})${progressSuffix}`);
                 return 0;
             }
-            console.error(`${LOG} deploy ended '${detail.status}': ${detail.statusDetail ?? ''}`);
+            const detailText = detail.statusDetail ? `: ${detail.statusDetail}` : '';
+            console.error(`${LOG} deployment ${deploymentId} ended ${detail.status} (${elapsed})${detailText}${progressSuffix}`);
             return 1;
         }
-        await new Promise((r) => setTimeout(r, 2000));
+        const progressSuffix = deploymentProgressSuffix(detail);
+        const statusLabel = deploymentStatusLabel(detail);
+        if (statusLabel !== lastLoggedLabel) {
+            console.log(`${LOG} deployment ${deploymentId}: ${statusLabel} (${formatElapsed(elapsedMs)})${progressSuffix}`);
+            lastLoggedLabel = statusLabel;
+            lastLogAt = Date.now();
+        }
+        else if (Date.now() - lastLogAt >= HEARTBEAT_INTERVAL_MS) {
+            console.log(`${LOG} deployment ${deploymentId}: still ${statusLabel} (${formatElapsed(elapsedMs)})${progressSuffix}`);
+            lastLogAt = Date.now();
+        }
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
     }
-    console.error(`${LOG} timed out waiting for deployment ${deploymentId}`);
+    console.error(`${LOG} timed out waiting for deployment ${deploymentId} (${formatElapsed(Date.now() - started)})`);
     return 1;
 }
+export async function pipelineAdoptCommand(args) {
+    const stage = flagString(args.flags, 'stage');
+    const ref = flagString(args.flags, 'ref');
+    const nativeId = flagString(args.flags, 'native-id');
+    const approvedBy = flagString(args.flags, 'approved-by');
+    if (!stage || !ref || !nativeId || !approvedBy) {
+        console.error('usage: seq-studio pipeline adopt --stage <slug> --ref <sha|branch> -e <env> ' +
+            '--native-id <id> --approved-by <you> [--resource-key <key>] [--kind job|dlt_pipeline] ' +
+            '[--old-source-removal-pr <url>] [--repo pipelines/<slug>] [--json]');
+        return 1;
+    }
+    const { env, token } = await envAndToken(args);
+    const json = args.flags.json === true || args.flags.json === 'true';
+    let target;
+    try {
+        target = await resolvePipelineTarget({ args, env, token });
+    }
+    catch (error) {
+        console.error(`${LOG} adopt failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+    const repo = flagString(args.flags, 'repo');
+    const resourceKey = flagString(args.flags, 'resource-key') ?? stage.replace(/-/g, '_');
+    const kind = flagString(args.flags, 'kind') ?? 'job';
+    if (kind !== 'job' && kind !== 'dlt_pipeline') {
+        console.error(`${LOG} --kind must be job or dlt_pipeline`);
+        return 1;
+    }
+    const oldSourceRemovalPr = flagString(args.flags, 'old-source-removal-pr');
+    const stageId = await resolveStageIdBySlug({
+        baseUrl: env.url,
+        token,
+        slug: stage,
+        repo,
+    });
+    try {
+        const response = await postJson({
+            baseUrl: env.url,
+            token,
+            path: `/api/data-pipelines/stages/${stageId}/adopt`,
+            body: {
+                environment: target.id,
+                ref,
+                bindings: [{ resourceKey, nativeId, kind }],
+                approvedBy,
+                ...(oldSourceRemovalPr ? { oldSourceRemovalPr } : {}),
+            },
+        });
+        if (json) {
+            console.log(JSON.stringify(response, null, 2));
+        }
+        else {
+            console.log(`${LOG} enqueued adopt for ${stage} → ${resourceKey}=${nativeId} ` +
+                `(trigger=${response.triggerRunId}). Worker binds on Trigger; ` +
+                `confirm with plan or stage_resources once the run completes.`);
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof AtlasApiError) {
+            console.error(`${LOG} adopt failed: ${error.message}`);
+            return 1;
+        }
+        throw error;
+    }
+}
+export async function pipelineUnbindCommand(args) {
+    const stage = flagString(args.flags, 'stage');
+    const ref = flagString(args.flags, 'ref');
+    const approvedBy = flagString(args.flags, 'approved-by');
+    if (!stage || !ref || !approvedBy) {
+        console.error('usage: seq-studio pipeline unbind --stage <slug> --ref <sha|branch> -e <env> ' +
+            '--approved-by <you> [--resource-key <key>] [--repo pipelines/<slug>] [--json]');
+        return 1;
+    }
+    const { env, token } = await envAndToken(args);
+    const json = args.flags.json === true || args.flags.json === 'true';
+    let target;
+    try {
+        target = await resolvePipelineTarget({ args, env, token });
+    }
+    catch (error) {
+        console.error(`${LOG} unbind failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+    const repo = flagString(args.flags, 'repo');
+    const resourceKey = flagString(args.flags, 'resource-key');
+    const stageId = await resolveStageIdBySlug({
+        baseUrl: env.url,
+        token,
+        slug: stage,
+        repo,
+    });
+    try {
+        const response = await postJson({
+            baseUrl: env.url,
+            token,
+            path: `/api/data-pipelines/stages/${stageId}/unbind`,
+            body: {
+                environment: target.id,
+                ref,
+                approvedBy,
+                ...(resourceKey ? { resourceKeys: [resourceKey] } : {}),
+            },
+        });
+        if (json) {
+            console.log(JSON.stringify(response, null, 2));
+        }
+        else {
+            console.log(`${LOG} enqueued unbind for ${stage}` +
+                (resourceKey ? ` (${resourceKey})` : '') +
+                ` (trigger=${response.triggerRunId}). Remote object is never deleted.`);
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof AtlasApiError) {
+            console.error(`${LOG} unbind failed: ${error.message}`);
+            return 1;
+        }
+        throw error;
+    }
+}
 /**
  * Stage identity is `(repo, slug)` — a bare slug can be ambiguous across
  * Pipelines. `--repo pipelines/<domain>` scopes the lookup server-side; an

package/dist/pipeline/templates.js

@@ -116,6 +116,7 @@ const SERVING_BODY = `
 source:
   stage: my-gold-stage
   output: gold.my_table
+  # catalog: src_example   # optional; omit to use the deploy catalog
 projection:
   # The served contract (inline columns or schema_ref):
   columns:
@@ -139,7 +140,8 @@ expose:
 #   table: my_table
 #   mode: referenced
 `;
-const ENTRYPOINT_STUB = `"""Entrypoint stub for the {{name}} stage.
+const ENTRYPOINT_STUB = `# Databricks notebook source
+"""Entrypoint stub for the {{name}} stage.
 
 The platform invokes this per the stage spec ({{name}}.stage.yml).
 Decoders and transforms stay pure — bronze materialization, envelope

package/dist/repos/commands.d.ts

@@ -44,6 +44,58 @@ export declare function reposCloneCommand(args: ParsedArgs, deps?: {
  * so askpass never sends ATLAS_GIT_PAT to an attacker-controlled host.
  */
 export declare function normalizeCloneUrl(raw: string, env: ResolvedEnv): string;
+type DiscoveredCliCheck = {
+    name: string;
+    script?: string;
+    command?: string[];
+    source: 'autodiscover' | 'ci.json';
+};
+/**
+ * Pure discovery shared by `repos ci show` / `import`. Mirrors atlas
+ * `discoverCiChecks` / `parseCiJson` so CLI preview matches execution.
+ */
+export declare function discoverCliChecks({ ciJson, packageScripts, }: {
+    ciJson?: unknown;
+    packageScripts?: Record<string, string>;
+}): {
+    ok: true;
+    checks: DiscoveredCliCheck[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Load `.seq/ci.json` / `package.json` for CI preview.
+ *
+ * Matches the runner: only a true 404 means "file absent". Invalid JSON and
+ * non-404 API errors fail closed (no silent package.json fallback over a bad
+ * `.seq/ci.json`).
+ */
+export declare function loadRemoteCiSources({ ctx, repoId, ref, }: {
+    ctx: CommandContext;
+    repoId: string;
+    ref: string;
+}): Promise<{
+    ok: true;
+    ciJson?: unknown;
+    packageScripts?: Record<string, string>;
+} | {
+    ok: false;
+    error: string;
+}>;
+/**
+ * Discover CI checks from a remote repo tip (pure preview — no Settings write).
+ * Uses the same autodiscovery rules as the platform runner (PLA-378).
+ */
+export declare function reposCiShowCommand(args: ParsedArgs): Promise<number>;
+/** Add a check-run name to Settings `requiredChecks` (merge-blocking). */
+export declare function reposCiRequireCommand(args: ParsedArgs): Promise<number>;
+/**
+ * Set requiredChecks to every check discovered on the tip (opt-in bulk require).
+ */
+export declare function reposCiImportCommand(args: ParsedArgs): Promise<number>;
+export declare function reposCiCommand(args: ParsedArgs): Promise<number>;
 export declare function reposDeleteCommand(args: ParsedArgs): Promise<number>;
-export declare const REPOS_USAGE = "usage:\n  seq-studio repos list -e <env> [--namespace <slug>] [--mine]      repos visible on the environment\n  seq-studio repos namespaces [create <slug>] -e <env>              list or create namespaces\n  seq-studio repos show <ns>/<name> -e <env>                        repo detail (branches, clone URL)\n  seq-studio repos create <ns>/<name> -e <env> [--default-branch b] create an empty repo\n  seq-studio repos clone <ns>/<name> -e <env> [--ref r] [--out dir] [--force]\n  seq-studio repos clone --url <https://\u2026/repos/<id>/git> -e <env> [--ref r] [--out dir]\n  seq-studio repos clone --id <uuid> -e <env> [--ref r] [--out dir]\n                                                                    smart-HTTP when ATLAS_GIT_PAT is set;\n                                                                    otherwise JSON materialize (<ns>/<name>)\n  seq-studio repos pull <ns>/<name> -e <env> [--ref r] [--out dir] [--force]\n                                                                    materialize the tree at a ref (JSON API)\n  seq-studio repos delete <ns>/<name> -e <env> [--yes]              delete a repo (confirm prompt)\n\n  Flags: -e/--env <env> (required; see: seq-studio envs list)\n\n  clone prefers real git clone (PAT via askpass \u2014 never written into the remote\n  URL). Without ATLAS_GIT_PAT, <ns>/<name> falls back to the JSON API and prints\n  how to get a PAT (seq-studio or Atlas UI /settings/tokens).\n  PAT without Auth0 login: use --url from Repositories \u2192 Clone (or --id <uuid>).\n  --ref accepts a branch, tag, or commit SHA (SHA \u2192 clone then checkout).\n\n  Authenticate JSON API calls with: seq-studio login\n  Authenticate git clone/push with: ATLAS_GIT_PAT (from Atlas Settings \u2192 Tokens)\n";
+export declare const REPOS_USAGE = "usage:\n  seq-studio repos list -e <env> [--namespace <slug>] [--mine]      repos visible on the environment\n  seq-studio repos namespaces [create <slug>] -e <env>              list or create namespaces\n  seq-studio repos show <ns>/<name> -e <env>                        repo detail (branches, clone URL)\n  seq-studio repos create <ns>/<name> -e <env> [--default-branch b] create an empty repo\n  seq-studio repos clone <ns>/<name> -e <env> [--ref r] [--out dir] [--force]\n  seq-studio repos clone --url <https://\u2026/repos/<id>/git> -e <env> [--ref r] [--out dir]\n  seq-studio repos clone --id <uuid> -e <env> [--ref r] [--out dir]\n                                                                    smart-HTTP when ATLAS_GIT_PAT is set;\n                                                                    otherwise JSON materialize (<ns>/<name>)\n  seq-studio repos pull <ns>/<name> -e <env> [--ref r] [--out dir] [--force]\n                                                                    materialize the tree at a ref (JSON API)\n  seq-studio repos delete <ns>/<name> -e <env> [--yes]              delete a repo (confirm prompt)\n  seq-studio repos ci show <ns>/<name> -e <env> [--ref r]           preview discovered CI checks\n  seq-studio repos ci require <ns>/<name> --check <name> -e <env>   reserved (refuses write until sandboxed runner)\n  seq-studio repos ci import <ns>/<name> -e <env> [--ref r]         reserved (refuses write until sandboxed runner)\n\n  Flags: -e/--env <env> (required; see: seq-studio envs list)\n\n  clone prefers real git clone (PAT via askpass \u2014 never written into the remote\n  URL). Without ATLAS_GIT_PAT, <ns>/<name> falls back to the JSON API and prints\n  how to get a PAT (seq-studio or Atlas UI /settings/tokens).\n  PAT without Auth0 login: use --url from Repositories \u2192 Clone (or --id <uuid>).\n  --ref accepts a branch, tag, or commit SHA (SHA \u2192 clone then checkout).\n\n  Authenticate JSON API calls with: seq-studio login\n  Authenticate git clone/push with: ATLAS_GIT_PAT (from Atlas Settings \u2192 Tokens)\n";
 export declare function runReposCommand(sub: string | undefined, args: ParsedArgs): Promise<number>;
+export {};