@lanes-sh/link 0.2.2 → 0.3.0

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/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(

package/src/cli/commands/target.ts

@@ -1,12 +1,12 @@
+import { describeKnowledge } from '#deployments/knowledge.ts';
 import {
-  TARGET_ENV,
-  askedTarget,
   loadProfileConfig,
   resolveSelection,
   undeclaredTarget,
   type Config,
-  type Resolution,
+  type ProfileSelection,
 } from '#profile';
+import { ConfigError } from '#profile';
 import { deployedUrl, deploymentIdentity, type DeploymentIdentity } from '../endpoint-url.ts';
 import { ConfigDocument } from '../config-edit.ts';
 import { announce, emit, heading, ok, print, style, table, waiting, warn } from '../output.ts';
@@ -33,13 +33,20 @@ import type { GlobalFlags } from '../runtime.ts';
 
 export interface TargetSummary {
   readonly name: string;
-  /** `instance.default_target` — what the file says. */
-  readonly isDefault: boolean;
-  /** What this shell resolves to right now, which may not be the above. */
+  /** Whether this is the one `--target` named, when it named any. */
   readonly isSelected: boolean;
   readonly credentials: string;
   readonly storage: string;
   readonly vault: string;
+  /**
+   * Where memory and skills are kept, when that is not `storage` above.
+   *
+   * Null is the ordinary answer. It is here because a `knowledge:` block moves
+   * two of the four things this target holds, and the config file would
+   * otherwise be the only witness — a `storage: filesystem` row that is true of
+   * the log and the state and false of the owner's own notes.
+   */
+  readonly knowledge: string | null;
   /** Whether a deployment is declared. Free, and always present. */
   readonly deployed: boolean;
   readonly deployment: DeploymentIdentity | null;
@@ -51,9 +58,8 @@ export interface TargetListing {
   readonly root: string;
   readonly profile: string;
   readonly path: string;
-  readonly default: string;
-  readonly selected: string;
-  readonly selectedSource: 'flag' | 'environment' | 'config-default';
+  /** What `--target` named, when it named anything. */
+  readonly selected: string | null;
   /**
    * Whether `selected` names a target that exists.
    *
@@ -84,46 +90,40 @@ export interface TargetFlags extends GlobalFlags {
 async function survey(
   flags: TargetFlags,
   options: { urls?: boolean; env?: Record<string, string | undefined> } = {},
-): Promise<{ resolution: Resolution; config: Config; listing: TargetListing }> {
-  const env = options.env ?? (process.env as Record<string, string | undefined>);
-
+): Promise<{ selection: ProfileSelection; config: Config; listing: TargetListing }> {
   const selection = await resolveSelection({
     ...(flags.profile !== undefined ? { profileFlag: flags.profile } : {}),
-    ...(flags.target !== undefined ? { targetFlag: flags.target } : {}),
     ...(options.env !== undefined ? { env: options.env } : {}),
   });
 
   const { config } = await loadProfileConfig(selection.workspaceRoot, selection.profile);
 
-  const asked = askedTarget(flags.target, env);
-  const selected = asked.target ?? config.instance.default_target;
+  const selected = flags.target ?? null;
   const names = Object.keys(config.targets);
 
   const summaries: TargetSummary[] = names.map((name) => {
     const declared = config.targets[name]!;
     return {
       name,
-      isDefault: name === config.instance.default_target,
       isSelected: name === selected,
       credentials: declared.credentials.adapter,
       storage: declared.storage.adapter,
       vault: declared.vault?.adapter ?? 'file',
+      knowledge: declared.knowledge ? describeKnowledge(declared.knowledge) : null,
       deployed: declared.deploy !== undefined,
       deployment: deploymentIdentity(declared.deploy),
     };
   });
 
   return {
-    resolution: { ...selection, target: selected, targetSource: asked.source ?? 'config-default' },
+    selection,
     config,
     listing: {
       root: selection.workspaceRoot,
       profile: selection.profile,
       path: selection.profilePath,
-      default: config.instance.default_target,
       selected,
-      selectedSource: asked.source ?? 'config-default',
-      selectedDeclared: names.includes(selected),
+      selectedDeclared: selected === null || names.includes(selected),
       // Asking the platform is opt-in: one `gcloud` subprocess per deployable
       // target, and the profiles that make this command worth running are
       // exactly the ones with several. A discovery command that takes ten
@@ -161,15 +161,15 @@ async function withUrls(
 }
 
 export async function targetList(flags: TargetFlags): Promise<void> {
-  const { resolution, listing } = await survey(flags, { urls: flags.urls === true });
+  const { listing } = await survey(flags, { urls: flags.urls === true });
 
   return emit(flags.json, listing, () => {
-    announce(resolution);
+    print(style.dim(`${listing.profile}  ${listing.path}`));
     print();
 
     table(
       listing.targets.map((target) => [
-        `  ${target.isDefault ? style.green('*') : ' '} ${target.isSelected ? style.cyan('→') : ' '}`,
+        `  ${target.isSelected ? style.cyan('→') : ' '}`,
         style.bold(target.name),
         style.dim(target.credentials),
         style.dim(target.storage),
@@ -178,27 +178,21 @@ export async function targetList(flags: TargetFlags): Promise<void> {
     );
 
     print();
-    print(style.dim(`  ${style.green('*')}  instance.default_target — what commands run against`));
-    print(style.dim(`  ${style.cyan('→')}  what this shell resolves to right now`));
 
-    // Printed only when the two disagree, which is the whole reason both markers
-    // exist. Saying it every time would train people to stop reading it.
-    if (listing.selectedSource === 'environment') {
-      print(
-        style.dim(
-          `     ${TARGET_ENV}=${listing.selected} is set in this shell and overrides the file.`,
-        ),
-      );
+    // This command takes no required `--target`, and that is not an oversight:
+    // it is the command you run to find out what to pass. Requiring the answer
+    // as input would be circular, and it has to keep working in the state every
+    // other command fails in — which is what `selectedDeclared` reports.
+    if (listing.selected === null) {
+      print(style.dim('  Every other command names one of these with --target.'));
+      return;
     }
 
+    print(style.dim(`  ${style.cyan('→')}  the target you named`));
+
     if (!listing.selectedDeclared) {
       print();
-      print(
-        warn(
-          `"${listing.selected}" is not declared here — every command will refuse until it is ` +
-            (listing.selectedSource === 'environment' ? `unset (${TARGET_ENV}).` : 'corrected.'),
-        ),
-      );
+      print(warn(`"${listing.selected}" is not declared here — every command naming it will refuse.`));
     }
   });
 }
@@ -215,50 +209,25 @@ function deploymentCell(target: TargetSummary): string {
 }
 
 /**
- * `lanes link target use <name>` — rewrite `instance.default_target`.
+ * `lanes link target use <name>` — removed.
  *
- * The persisted half of the switch, and a *declared* one: the value lands in the
- * profile YAML, where the operator can read it, `check` validates it, and every
- * command prints that it came from there. That is the distinction `#profile`'s
- * `workspace.ts` draws — what was rejected is hidden per-shell state in a
- * dotfile nothing prints, not a default written where defaults already live.
+ * It wrote `instance.default_target`, which nothing reads (ADR-037). A command
+ * that writes a key nothing reads is worse than no command at all: it reports
+ * success and changes nothing observable, which is the exact failure this whole
+ * change exists to remove.
+ *
+ * Kept as a refusal rather than deleted outright, for one release. Falling
+ * through to `Unknown: lanes link target use` would send someone hunting a typo
+ * in a command they have run for months.
  */
-export async function targetUse(name: string | undefined, flags: GlobalFlags): Promise<void> {
-  if (!name) throw new Error('Usage: lanes link target use <name>');
-
-  const selection = await resolveSelection({
-    ...(flags.profile !== undefined ? { profileFlag: flags.profile } : {}),
-  });
-  const { config } = await loadProfileConfig(selection.workspaceRoot, selection.profile);
-
-  // Where this profile stands before the edit, not what the edit will make true.
-  announce({
-    ...selection,
-    target: config.instance.default_target,
-    targetSource: 'config-default',
-  });
-
-  // `name` is an argument being validated, not a selection being resolved, so
-  // no environment gets a say in whether it exists.
-  if (!(name in config.targets)) throw undeclaredTarget(name, config);
-
-  if (config.instance.default_target === name) {
-    print(ok(`${style.bold(name)} is already the default`));
-    return;
-  }
-
-  const document = await ConfigDocument.open(selection.workspaceRoot, selection.profile);
-  document.setIn(['instance', 'default_target'], name);
-  await document.save();
-
-  print(ok(`default target is now ${style.bold(name)}`));
-
-  // Otherwise the operator edits the file, sees nothing change, and concludes
-  // the command is broken. The variable is the thing that is winning.
-  const fromEnv = process.env[TARGET_ENV];
-  if (fromEnv && fromEnv !== name) {
-    print(warn(`${TARGET_ENV}=${fromEnv} is set in this shell, and still wins over the file.`));
-  }
+export function targetUse(name: string | undefined): never {
+  throw new ConfigError(
+    'lanes link target use was removed.\n' +
+      '  Nothing reads instance.default_target any more — pass --target on every\n' +
+      '  command instead:\n' +
+      `    lanes link status --profile <name> --target ${name ?? '<target>'}\n` +
+      '  If the key is still in your profile it is inert, and safe to delete.',
+  );
 }
 
 /**
@@ -271,10 +240,20 @@ export async function targetUse(name: string | undefined, flags: GlobalFlags): P
  */
 export async function targetShow(name: string | undefined, flags: TargetFlags): Promise<void> {
   const { config, listing } = await survey(flags);
+
+  // Positionally or by flag, but one of them: this command's whole subject is a
+  // single target, and there is no default left to mean "the one you would have
+  // got". `list` is the command for "I do not know which".
   const wanted = name ?? listing.selected;
-  const summary = listing.targets.find((candidate) => candidate.name === wanted);
+  if (!wanted) {
+    throw new ConfigError(
+      'Usage: lanes link target show <name> --profile <name>\n' +
+        `  Declared here: ${listing.targets.map((one) => one.name).join(', ') || 'none'}`,
+    );
+  }
 
-  if (!summary) throw undeclaredTarget(wanted, config, listing.selectedSource);
+  const summary = listing.targets.find((candidate) => candidate.name === wanted);
+  if (!summary) throw undeclaredTarget(wanted, config, listing.profile);
 
   const url = summary.deployment
     ? await waiting('asking the platform for an address', () =>
@@ -290,6 +269,9 @@ export async function targetShow(name: string | undefined, flags: TargetFlags):
       ['  credentials', summary.credentials],
       ['  storage', summary.storage],
       ['  vault', summary.vault],
+      ...(summary.knowledge
+        ? [['  knowledge', summary.knowledge, style.dim('memory and skills')]]
+        : []),
     ]);
 
     if (!summary.deployment) {