@lanes-sh/link 0.2.2 → 0.3.1

package/src/cli/commands/profile/declare.ts

@@ -0,0 +1,154 @@
+import { listProfiles, loadProfileConfig, ConfigError, type TargetConfig } from '#profile';
+import { ask, isInteractive } from '../../prompt.ts';
+import { print, style } from '../../output.ts';
+
+/**
+ * The targets a new profile declares, and where their values come from.
+ *
+ * `profile add` used to emit exactly one target — `local`, hard-coded in the
+ * template — while accepting a `--target` it dropped on the floor. So the
+ * command that creates a profile could not create the thing a profile is mostly
+ * *for*: somewhere to run.
+ *
+ * A `local` target is derivable and never asked about: a path under the
+ * workspace, an encrypted file beside it. Anything else names a cloud account,
+ * and this is the one place in the CLI where guessing those is actively harmful.
+ * `deploy`'s survey proposes a *fresh* project id (`lanes-link-<random>`),
+ * which is right for a first deploy and exactly wrong here — pressing return
+ * would build a second, separate deployment rather than adding this profile to
+ * the one the operator already has. So the defaults come from a sibling profile
+ * that already declares the same target name, and the service name is the only
+ * one derived, because that is the one field that has to differ per profile.
+ */
+
+export interface DeclaredTarget {
+  readonly name: string;
+  /** Rendered YAML, indented two spaces, ready to sit under `targets:`. */
+  readonly block: string;
+  /** Which profile the values were taken from, when they were taken from one. */
+  readonly from?: string;
+}
+
+/** The `local` target, which is the same shape in every profile. */
+export function localBlock(profile: string, name = 'local'): string {
+  return (
+    `  ${name}:\n` +
+    `    credentials: { adapter: file, path: ./data/${profile}/credentials.enc }\n` +
+    `    storage: { adapter: filesystem, path: ./data/${profile} }\n`
+  );
+}
+
+/**
+ * A sibling profile's declaration of the same target name, if there is one.
+ *
+ * The first match wins rather than the operator being asked which — two
+ * profiles declaring `cloud` against different projects is possible and rare,
+ * and the values are shown and editable at the prompt either way.
+ */
+export async function siblingTarget(
+  workspaceRoot: string,
+  target: string,
+  exclude: string,
+): Promise<{ profile: string; declared: TargetConfig } | null> {
+  for (const name of await listProfiles(workspaceRoot)) {
+    if (name === exclude) continue;
+
+    try {
+      const { config } = await loadProfileConfig(workspaceRoot, name);
+      const declared = config.targets[target];
+      if (declared) return { profile: name, declared };
+    } catch {
+      // A profile that will not parse is not a source of defaults, and saying
+      // so here would report a broken sibling as a problem with this command.
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Ask for what a non-local target needs, pre-filled from a sibling.
+ *
+ * Refuses rather than inventing when there is nobody to ask and nothing to copy
+ * — the same bargain `connect --non-interactive` makes. A profile written with
+ * a guessed project id parses, deploys, and points at the wrong account.
+ */
+export async function askTarget(input: {
+  readonly target: string;
+  readonly profile: string;
+  readonly sibling: { profile: string; declared: TargetConfig } | null;
+  readonly nonInteractive?: boolean;
+}): Promise<DeclaredTarget> {
+  const { target, profile, sibling } = input;
+
+  if (!sibling) {
+    throw new ConfigError(
+      `No profile in this workspace declares a target called "${target}", so there is\n` +
+        'nothing to copy its adapters from.\n' +
+        `  lanes link profile add ${profile} --target local\n` +
+        `  lanes link deploy --profile ${profile} --target ${target}\n` +
+        '  The deploy surveys for what it does not know and writes the block.',
+    );
+  }
+
+  const declared = sibling.declared;
+  const project = declared.credentials.project ?? '';
+  const bucket = declared.storage.bucket ?? '';
+
+  // The one field that must differ: two profiles served by one project need two
+  // services, which is what makes them separately deployable.
+  const service = `lanes-link-${profile}-mcp`;
+
+  if (input.nonInteractive === true || !isInteractive()) {
+    return {
+      name: target,
+      block: cloudBlock({ target, project, bucket, service, declared }),
+      from: sibling.profile,
+    };
+  }
+
+  print(style.dim(`  ${target} — defaults from profile "${sibling.profile}"`));
+
+  const answeredProject = (await ask(`  Cloud project [${project}]: `)) || project;
+  const answeredBucket = (await ask(`  Bucket [${bucket}]: `)) || bucket;
+  const answeredService = (await ask(`  Service [${service}]: `)) || service;
+
+  return {
+    name: target,
+    block: cloudBlock({
+      target,
+      project: answeredProject,
+      bucket: answeredBucket,
+      service: answeredService,
+      declared,
+    }),
+    from: sibling.profile,
+  };
+}
+
+/** One target's YAML, carrying over the adapters the sibling chose. */
+function cloudBlock(input: {
+  target: string;
+  project: string;
+  bucket: string;
+  service: string;
+  declared: TargetConfig;
+}): string {
+  const { declared } = input;
+  const deploy = declared.deploy;
+
+  return (
+    `  ${input.target}:\n` +
+    `    credentials: { adapter: ${declared.credentials.adapter}, project: ${input.project} }\n` +
+    `    storage: { adapter: ${declared.storage.adapter}, bucket: ${input.bucket} }\n` +
+    `    vault: { adapter: ${declared.vault?.adapter ?? 'secret'} }\n` +
+    (deploy
+      ? `    deploy:\n` +
+        `      platform: ${deploy.platform}\n` +
+        `      project: ${input.project}\n` +
+        `      region: ${deploy.region}\n` +
+        `      service: ${input.service}\n` +
+        `      access: ${deploy.access}\n`
+      : '')
+  );
+}

package/src/cli/commands/profile/removal.ts

@@ -119,6 +119,23 @@ export async function removalPlan(
       continue;
     }
 
+    // A repository this profile keeps memory and skills in is not this
+    // command's to empty, and it is not reachable from here either: the routing
+    // that points memory at a repository is applied by `openRuntime`, and this
+    // plan is built on `openBlobStoreFor`, which opens the target's own declared
+    // storage. That is the right answer — deleting a profile must not delete
+    // somebody's repository — and it is a surprising one, because
+    // `rm -r data/<profile>` used to be the whole of "what could this profile
+    // reach". So it is said before the operator confirms rather than discovered
+    // afterwards.
+    if (declared.knowledge) {
+      warnings.push(
+        `Target "${name}" keeps this profile's memory and skills in ${declared.knowledge.repo}. ` +
+          'Nothing here touches a repository, so they survive this removal — delete them there ' +
+          'if you want them gone.',
+      );
+    }
+
     // Secrets first, and this ordering is load-bearing rather than tidy:
     // `layout.credentials(p)` is `data/<p>/credentials.enc`, *inside* the blob
     // root `data/<p>`. For the file adapter the credential store is itself a

package/src/cli/commands/profile/remove.ts

@@ -12,12 +12,12 @@ import {
 import { parseDocument } from 'yaml';
 import { rm } from 'node:fs/promises';
 import { terminalPrompter, type Prompter } from '../../prompt.ts';
-import { announce, emit, fail, ok, print, style } from '../../output.ts';
+import { announceProfile, emit, fail, ok, print, style } from '../../output.ts';
 import {
   buildRegistryWithWorkspace,
   openBlobStoreFor,
   openSecretStoreFor,
-  resolveProfile,
+  resolveProfileOnly,
   type GlobalFlags,
 } from '../../runtime.ts';
 import { removalPlan, renderPlan, type RemovalItem, type RemovalPlan } from './removal.ts';
@@ -250,10 +250,10 @@ export interface RemoveFlags extends GlobalFlags {
  * in the tool.
  */
 export async function removeProfile(name: string, flags: RemoveFlags): Promise<void> {
-  const { resolution, config } = await resolveProfile({ ...flags, profile: name });
-  announce(resolution);
+  const { selection, config } = await resolveProfileOnly({ ...flags, profile: name });
+  announceProfile(selection);
 
-  const root = resolution.workspaceRoot;
+  const root = selection.workspaceRoot;
   const registry = await buildRegistryWithWorkspace(root, name);
   const files = workspaceFiles(root);
 

package/src/cli/commands/profile.ts

@@ -1,8 +1,8 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { parseDocument } from 'yaml';
 import {
+  ConfigError,
   WORKSPACE_FILE,
   listProfiles,
   profilePath,
@@ -10,6 +10,7 @@ import {
   resolveWorkspaceRoot,
 } from '#profile';
 import { newProfileTemplate, newWorkspaceTemplate } from '../config-edit.ts';
+import { askTarget, localBlock, siblingTarget } from './profile/declare.ts';
 import { emit, ok, print, style, table } from '../output.ts';
 
 /**
@@ -32,7 +33,10 @@ export interface ProfileCreated {
   readonly name: string;
   readonly path: string;
   readonly port: number;
-  readonly isDefault: boolean;
+  /** Every target the new profile declares, in the order they were named. */
+  readonly targets: readonly string[];
+  /** Which sibling supplied each non-local target's adapters, where one did. */
+  readonly copiedFrom: Readonly<Record<string, string>>;
 }
 
 export interface ProfileListing {
@@ -41,10 +45,17 @@ export interface ProfileListing {
   readonly profiles: ReadonlyArray<{ readonly name: string; readonly path: string }>;
 }
 
-/** Write a new profile, and the workspace file if this is the first one. */
+/**
+ * Write a new profile, and the workspace file if this is the first one.
+ *
+ * The targets are the argument that used to be missing. `--target` was accepted
+ * and dropped here, and the template could only ever emit `local` — so the
+ * command reported success and produced a profile that could not reach the
+ * deployment the operator had just told it about.
+ */
 export async function createProfile(
   name: string,
-  options: { default?: boolean },
+  options: { targets: readonly string[]; nonInteractive?: boolean },
 ): Promise<ProfileCreated> {
   const root = resolveWorkspaceRoot();
   const path = profilePath(root, name);
@@ -58,23 +69,37 @@ export async function createProfile(
   const existing = await listProfiles(root);
   const port = FIRST_PORT + existing.length;
 
-  const workspaceFile = join(root, WORKSPACE_FILE);
-  const isFirst = existing.length === 0;
-  const isDefault = options.default === true || isFirst;
+  // Everything that can fail — a target nobody declares, a prompt nobody can
+  // answer — happens before the first write, so a refusal leaves the workspace
+  // exactly as it was rather than half a profile behind.
+  const blocks: string[] = [];
+  const copiedFrom: Record<string, string> = {};
 
-  if (!existsSync(workspaceFile)) {
-    await writeFile(workspaceFile, newWorkspaceTemplate(isDefault ? name : undefined), {
-      mode: 0o600,
+  for (const target of options.targets) {
+    if (target === 'local') {
+      blocks.push(localBlock(name));
+      continue;
+    }
+
+    const declared = await askTarget({
+      target,
+      profile: name,
+      sibling: await siblingTarget(root, target, name),
+      ...(options.nonInteractive === true ? { nonInteractive: true } : {}),
     });
-  } else if (options.default) {
-    const document = parseDocument(await Bun.file(workspaceFile).text());
-    document.set('default_profile', name);
-    await writeFile(workspaceFile, document.toString({ lineWidth: 0 }), { mode: 0o600 });
+
+    blocks.push(declared.block);
+    if (declared.from) copiedFrom[target] = declared.from;
   }
 
-  await writeFile(path, newProfileTemplate(name, port), { mode: 0o600 });
+  const workspaceFile = join(root, WORKSPACE_FILE);
+  if (!existsSync(workspaceFile)) {
+    await writeFile(workspaceFile, newWorkspaceTemplate(), { mode: 0o600 });
+  }
 
-  return { name, path, port, isDefault };
+  await writeFile(path, newProfileTemplate(name, port, blocks.join('')), { mode: 0o600 });
+
+  return { name, path, port, targets: options.targets, copiedFrom };
 }
 
 /**
@@ -99,18 +124,36 @@ export async function readProfiles(): Promise<ProfileListing> {
 
 export async function profileAdd(
   name: string,
-  options: { default?: boolean; json?: boolean },
+  options: { targets: readonly string[]; nonInteractive?: boolean; json?: boolean },
 ): Promise<void> {
+  if (options.targets.length === 0) {
+    throw new ConfigError(
+      'Say which targets this profile declares:\n' +
+        `  lanes link profile add ${name} --target local\n` +
+        `  lanes link profile add ${name} --target local --target cloud\n` +
+        '\n' +
+        '  A target is where a profile runs — a credential store and a blob store.\n' +
+        '  There is no default to inherit before the profile exists.',
+    );
+  }
+
   const created = await createProfile(name, options);
 
   return emit(options.json, created, () => {
     print(ok(`created profile ${style.bold(created.name)}`));
-    print(`      config  ${created.path}`);
-    print(`      port    ${created.port}`);
-    if (created.isDefault) print(`      set as the workspace default`);
+    print(`      config   ${created.path}`);
+    print(`      port     ${created.port}`);
+    print(`      targets  ${created.targets.join(', ')}`);
+
+    for (const [target, from] of Object.entries(created.copiedFrom)) {
+      print(`      ${style.dim(`${target} adapters copied from profile "${from}"`)}`);
+    }
+
     print();
     print(
-      style.dim('Next: lanes link connect example    # add a connection, no credentials needed'),
+      style.dim(
+        `Next: lanes link connect example --profile ${created.name} --target ${created.targets[0]}`,
+      ),
     );
   });
 }
@@ -121,7 +164,7 @@ export async function profileList(options: { json?: boolean } = {}): Promise<voi
   return emit(options.json, listing, () => {
     if (listing.profiles.length === 0) {
       print(style.dim(`No profiles in ${listing.root}.`));
-      print(style.dim('Create one with: lanes link profile add personal --default'));
+      print(style.dim('Create one with: lanes link profile add personal --target local'));
       return;
     }
 
@@ -136,19 +179,24 @@ export async function profileList(options: { json?: boolean } = {}): Promise<voi
   });
 }
 
-export async function profileDefault(name: string): Promise<void> {
-  const root = resolveWorkspaceRoot();
-  if (!existsSync(profilePath(root, name))) throw new Error(`Profile "${name}" does not exist`);
-
-  const workspaceFile = join(root, WORKSPACE_FILE);
-  const document = existsSync(workspaceFile)
-    ? parseDocument(await Bun.file(workspaceFile).text())
-    : parseDocument(newWorkspaceTemplate());
-
-  document.set('default_profile', name);
-  await writeFile(workspaceFile, document.toString({ lineWidth: 0 }), { mode: 0o600 });
-
-  print(ok(`default profile is now ${style.bold(name)}`));
+/**
+ * `lanes link profile default <name>` — removed.
+ *
+ * It wrote `default_profile`, which nothing reads (ADR-037). A command that
+ * writes a key nothing reads reports success and changes nothing observable,
+ * which is the failure this change exists to remove.
+ *
+ * A refusal rather than a deletion, for one release: falling through to
+ * "Unknown: lanes link profile default" would send someone hunting a typo in a
+ * command they have run for months.
+ */
+export function profileDefault(name: string | undefined): never {
+  throw new ConfigError(
+    'lanes link profile default was removed.\n' +
+      '  Nothing reads default_profile any more — pass --profile on every command:\n' +
+      `    lanes link status --profile ${name ?? '<name>'} --target <target>\n` +
+      '  If the key is still in lanes-link.yaml it is inert, and safe to delete.',
+  );
 }
 
 // The bundled agent skill used to be printed from here, because `installRoot`

package/src/cli/commands/secrets.ts

@@ -1,7 +1,7 @@
 import { ConfigError } from '#profile';
 import { assertValidSecretRef } from '#secrets';
-import { announce, heading, ok, print, style } from '../output.ts';
-import { openSecretStoreFor, resolveProfile, type GlobalFlags } from '../runtime.ts';
+import { announce, announceProfile, heading, ok, print, style } from '../output.ts';
+import { openSecretStoreFor, resolveProfile, resolveProfileOnly, type GlobalFlags } from '../runtime.ts';
 
 /**
  * `lanes link secrets` — moving credential values between a profile's targets.
@@ -35,11 +35,11 @@ export async function secretsPush(flags: SecretsFlags): Promise<void> {
     throw new ConfigError(`--from and --to are both "${flags.from}"; there is nothing to copy.`);
   }
 
-  const { resolution, config } = await resolveProfile(flags);
-  announce(resolution);
+  const { selection, config } = await resolveProfileOnly(flags);
+  announceProfile(selection);
 
-  const source = await openSecretStoreFor(config, resolution.workspaceRoot, flags.from);
-  const destination = await openSecretStoreFor(config, resolution.workspaceRoot, flags.to);
+  const source = await openSecretStoreFor(config, selection.workspaceRoot, flags.from);
+  const destination = await openSecretStoreFor(config, selection.workspaceRoot, flags.to);
 
   const refs = await source.list();
   if (refs.length === 0) {

package/src/cli/commands/setup.ts

@@ -1,5 +1,5 @@
 import { planAll, planFor, type ProviderPlan } from '#providers/setup/plan.ts';
-import { emit, heading, print, style, table } from '../output.ts';
+import { announce, emit, heading, print, style, table } from '../output.ts';
 import { missingRequirements } from './connect/requirements.ts';
 import { openRuntime, type GlobalFlags } from '../runtime.ts';
 
@@ -24,6 +24,7 @@ export async function setupPlan(provider: string | undefined, flags: SetupFlags)
   try {
     const context = {
       profile: runtime.resolution.profile,
+      target: runtime.resolution.target,
       connections: runtime.config.connections.map((c) => `${c.provider}.${c.id}`),
       // Declaring an `oauth_apps` entry is how a profile says "use my own
       // client". Without this the plan would tell someone who has already
@@ -55,16 +56,19 @@ export async function setupPlan(provider: string | undefined, flags: SetupFlags)
             ),
           );
 
-      return emit(
-        flags.json,
-        { ...plan, missing: [...missing] },
-        () => renderOne(plan, missing),
-      );
+      // Inside the render callback, not before it: `emit` returns the JSON
+      // early, so this is where a line of prose is safe. `connect` needs its
+      // own guard because its announce has to precede a browser.
+      return emit(flags.json, { ...plan, missing: [...missing] }, () => {
+        announce(runtime.resolution);
+        renderOne(plan, missing);
+      });
     }
 
     const plans = planAll(manifests, context);
 
     return emit(flags.json, { profile: context.profile, providers: plans }, () => {
+      announce(runtime.resolution);
       heading(`Connected in ${style.bold(context.profile)}`);
       const done = plans.filter((plan) => plan.connected.length > 0);
       if (done.length === 0) print(style.dim('  nothing yet'));
@@ -139,6 +143,18 @@ function renderOne(plan: ProviderPlan, missing: ReadonlySet<string>): void {
       plan.steps.forEach((step, index) => print(`  ${index + 1}. ${step}`));
     }
   }
+
+  // The other alternative, and for the same reason it is down here: it is what
+  // to do when the line above is refused by somebody who is not the reader.
+  if (plan.tokenCommand && plan.pastedCredential) {
+    heading('Or paste a token you already hold');
+    print(`  ${plan.tokenCommand}`);
+    print(`  ${style.dim(`Asks for the ${plan.pastedCredential}.`)}`);
+    if (plan.steps.length > 0 && !plan.ownClientCommand) {
+      print();
+      plan.steps.forEach((step, index) => print(`  ${index + 1}. ${step}`));
+    }
+  }
   if (plan.browser) {
     print();
     print(