lattris 0.1.3 → 0.2.0

package/dist/entry/use.js

@@ -0,0 +1,127 @@
+import { dirname, join, resolve, sep } from 'node:path';
+import { formatPerson } from "../entry/session.js";
+import { HELP_TOKENS } from "../request/flags.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { BINDING_FILE, clearBinding, findBinding, machinesRoot, resolveActorDir, resolveSessionHome, sessionDir, writeBinding } from "../store/session-home.js";
+import { refusal } from "../store/exit.js";
+const USE_HELP = [
+    'use — bind this directory to an actor.',
+    '',
+    'Usage:',
+    '  lattris use <name|path>   Bind: an email or short name resolves inside ~/lattris-machines',
+    '                            (canonical dir = the account email; short names match too);',
+    '                            a path (contains / or starts with . or ~) is used as-is.',
+    '  lattris use               Show the effective binding and who it acts as.',
+    '  lattris use --clear       Remove THIS directory’s binding (never an ancestor’s).',
+    '',
+    'Resolution order for every command: --as or LATTRIS_HOME, then the nearest',
+    '.lattris walking up from the current directory (stopping below $HOME), then the',
+    'default state home. The binding file is personal, machine-local state — gitignore it.',
+    '',
+    'A .lattris is honoured only when it is a plain file naming a directory under',
+    '~/lattris-machines, or one lattris use made on this machine. Every command',
+    'refuses any other; if you wrote it, run lattris use there to trust it.'
+].join('\n');
+const UNVERIFIED = 'session present, identity unverified (not signed in, or API unreachable)';
+const describeIdentity = async (cfg, io) => {
+    try {
+        const accessToken = await io.token(cfg);
+        const result = await io.api(accessToken, `${cfg.apiUrl}/person/me`);
+        if (!result.ok) {
+            return result.answer.kind === 'page'
+                ? UNVERIFIED
+                : 'session present, identity unverified (API refused)';
+        }
+        return `acts as ${formatPerson(result.data)}`;
+    }
+    catch {
+        return UNVERIFIED;
+    }
+};
+const insideGitRepo = (machine) => {
+    let dir = machine.cwd;
+    while (dir.startsWith(machine.home + sep)) {
+        if (machine.files.existsSync(join(dir, '.git')))
+            return true;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return false;
+};
+export const use = async (cfg, io, args) => {
+    if (args.some((a) => HELP_TOKENS.has(a))) {
+        io.stdout.write(`${USE_HELP}\n`);
+        return;
+    }
+    if (args.length > 1 || (args[0]?.startsWith('--') && args[0] !== '--clear')) {
+        return refusal(`Usage: lattris use <name|path> | lattris use | lattris use --clear\n`);
+    }
+    const machine = io.store;
+    const { existsSync } = machine.files;
+    const cwd = machine.cwd;
+    if (args.length === 0) {
+        const home = resolveSessionHome(machine);
+        const rung = home.bindingFile
+            ? `bound via ${home.bindingFile}`
+            : machine.env.LATTRIS_HOME
+                ? 'LATTRIS_HOME'
+                : 'the default state home';
+        const sDir = sessionDir(io.store);
+        const hasSession = existsSync(join(sDir, 'session.json'));
+        io.stdout.write(`session home: ${sDir}  (${rung}, env=${io.store.envName})\n`);
+        if (!hasSession) {
+            io.stdout.write(home.bindingFile
+                ? `no session there — run lattris login here, or lattris use --clear.\n`
+                : `no session — run lattris login.\n`);
+            return;
+        }
+        io.stdout.write(`${await describeIdentity(cfg, io)}\n`);
+        return;
+    }
+    if (args[0] === '--clear') {
+        const ancestor = findBinding(machine, dirname(cwd));
+        io.stdout.write(clearBinding(machine, cwd) ? 'Binding cleared.\n' : 'No binding in this directory.\n');
+        if (ancestor?.trusted) {
+            io.stdout.write(`Note: an ancestor binding is still in effect — ${ancestor.bindingFile} → ${ancestor.machineDir}. Clear it there if you mean to.\n`);
+        }
+        else if (ancestor) {
+            io.stdout.write(`Note: an ancestor binding, ${sanitizeForTerminal(ancestor.bindingFile, Infinity)}, is not trusted, so commands here are refused until it is cleared or made there with lattris use.\n`);
+        }
+        return;
+    }
+    const ref = args[0];
+    let target;
+    if (ref.includes(sep) || ref.startsWith('.') || ref.startsWith('~')) {
+        target = resolve(cwd, ref.replace(/^~(?=\/|$)/, machine.home));
+    }
+    else {
+        const resolved = resolveActorDir(machine.files, ref, machinesRoot(machine));
+        if (resolved.ambiguous) {
+            return refusal(`'${ref}' is ambiguous: ${resolved.ambiguous.join(', ')}. Use the full email.\n`);
+        }
+        target = resolved.dir ?? join(machinesRoot(machine), ref);
+    }
+    if (!existsSync(target)) {
+        return refusal(`No machine dir at ${target}. Provision the actor first (provision-actor.sh), or pass an explicit path.\n`);
+    }
+    const bindEnv = io.store.envExplicit ? io.store.envName : undefined;
+    writeBinding(machine, cwd, target, bindEnv);
+    io.stdout.write(`Bound: ${cwd} → ${target}${bindEnv ? ` (env=${bindEnv})` : ''}\n`);
+    const envSubdir = bindEnv ?? 'local';
+    const sessionCheck = existsSync(join(target, envSubdir, 'session.json')) || existsSync(join(target, 'session.json'));
+    if (!sessionCheck) {
+        io.stdout.write('No session there yet — run lattris login from this directory.\n');
+    }
+    else {
+        io.stdout.write(`${await describeIdentity(cfg, io)}\n`);
+    }
+    if (insideGitRepo(machine)) {
+        const ignored = machine.run('git', ['check-ignore', '-q', BINDING_FILE], cwd);
+        if (ignored.status !== 0) {
+            io.stdout.write('Tip: add .lattris to .gitignore — the binding is personal, machine-local state.\n');
+        }
+    }
+};
+//# sourceMappingURL=use.js.map

package/dist/help.js

@@ -0,0 +1,65 @@
+import { USAGE_LINES } from "./nouns/words.js";
+import { renderRunHint } from "./render/text.js";
+export const commandHelpText = (registry, command, args) => {
+    if (command === undefined)
+        return null;
+    const nounFirst = registry.nouns.find((n) => n.grammar === 'noun-first' &&
+        n.helpBeforeAuth &&
+        [n.words.singular, ...(n.words.aliases ?? [])].includes(command));
+    if (nounFirst)
+        return nounFirst.help;
+    const verb = registry.verbs[command];
+    if (!verb?.helpBeforeAuth || verb.help === undefined)
+        return null;
+    return typeof verb.help === 'string' ? verb.help : verb.help(args);
+};
+export const missingActorDirVerdict = (actor, dirExists, command) => {
+    if (dirExists)
+        return null;
+    if (command === 'login' || command === 'use' || command === 'setup')
+        return null;
+    return (`No machine dir for ${actor} — check the spelling, or log in as them first: ` +
+        `${renderRunHint(['--as', actor, 'login'])}\n`);
+};
+export const usage = (term) => {
+    term.stdout.write([
+        'lattris — first-party CLI for the Lattris platform',
+        '',
+        'Usage:',
+        ...USAGE_LINES,
+        '',
+        'Exit codes:',
+        '  0  success',
+        '  1  unexpected or transport failure',
+        '  2  usage — bad or missing flag, unknown command',
+        '  3  not authenticated — no session, refresh failed, or a 401',
+        '  4  a door must be walked first',
+        '',
+        'Config (env overrides; localdev defaults shown):',
+        '  LATTRIS_ISSUER          Hydra public base   (http://localhost:4444)',
+        '  LATTRIS_API             lattris-api base     (http://localhost:54301)',
+        '  LATTRIS_CLIENT_ID       OAuth client id      (lattris-cli)',
+        '  LATTRIS_REDIRECT_PORT   loopback callback    (4577)',
+        '  LATTRIS_SESSION_ID      names this session on every note write (required off a terminal)',
+        '  LATTRIS_AGENT           a readable label for it (optional)',
+        '',
+        'Session resolution (which identity a command acts as), in order:',
+        '  0. --as <email|name>         per-invocation: resolves inside ~/lattris-machines',
+        '                               (email exact; a short name matches its <name>@* dir)',
+        '  1. LATTRIS_HOME              a session home named outright',
+        '  2. nearest .lattris binding  walking up from cwd, stopping below $HOME',
+        '  3. ~/.local/state/lattris    the default ($XDG_STATE_HOME honoured)',
+        '',
+        'Environment resolution (which API endpoints to use), in order:',
+        '  0. --env <name>              per-invocation (e.g. --env prod)',
+        '  1. .lattris env= field       default for this workspace',
+        '  2. LATTRIS_ENV               explicit env var',
+        '  3. "local"                   the default',
+        '',
+        'Per-env sessions live in subdirectories: ~/lattris-machines/<actor>/<env>/session.json.',
+        'Environments are configured in ~/.config/lattris/environments.json; built-in',
+        'local + prod work with no file. Env vars (LATTRIS_API etc.) still override.',
+        ''
+    ].join('\n'));
+};
+//# sourceMappingURL=help.js.map