lattris 0.1.4 → 0.2.1

package/dist/request/paste-and-device.js

@@ -0,0 +1,99 @@
+import { createInterface } from 'node:readline';
+export const parsePastedAuth = (line, expectedState) => {
+    const params = new URLSearchParams(line.trim().replace(/^\?/, ''));
+    const code = params.get('code');
+    const state = params.get('state');
+    if (!code || !state)
+        return { kind: 'malformed' };
+    if (state !== expectedState)
+        return { kind: 'mismatch' };
+    return { kind: 'code', code };
+};
+export const waitForPastedCode = (expectedState, input, stderr) => {
+    const rl = createInterface({ input });
+    const code = new Promise((resolve) => {
+        rl.on('line', (line) => {
+            if (line.trim() === '')
+                return;
+            const verdict = parsePastedAuth(line, expectedState);
+            if (verdict.kind === 'code') {
+                rl.close();
+                resolve(verdict.code);
+                return;
+            }
+            stderr.write(verdict.kind === 'mismatch'
+                ? 'That code is from a different sign-in attempt — copy it again from the current browser page.\n'
+                : 'That doesn’t look like the code — copy the whole box from the browser page.\n');
+        });
+    });
+    return {
+        code,
+        close: () => {
+            rl.close();
+            input.unref?.();
+        }
+    };
+};
+export const deviceAuthBody = (cfg) => ({
+    client_id: cfg.clientId,
+    scope: cfg.scopes,
+    audience: cfg.audience
+});
+export const requestDeviceAuth = async (network, cfg) => {
+    const res = await network(`${cfg.issuer}/oauth2/device/auth`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams(deviceAuthBody(cfg)).toString()
+    });
+    if (!res.ok) {
+        const detail = await res.text().catch(() => '');
+        throw new Error(`device authorization endpoint ${res.status}: ${detail.slice(0, 300)}`);
+    }
+    return (await res.json());
+};
+const DEVICE_EXPIRED_MESSAGE = 'The sign-in code expired — run lattris login --device again.';
+const deviceTokenAttempt = async (network, cfg, deviceCode) => {
+    const res = await network(`${cfg.issuer}/oauth2/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            device_code: deviceCode,
+            client_id: cfg.clientId
+        }).toString()
+    });
+    const body = (await res.json().catch(() => ({})));
+    if (res.ok)
+        return { kind: 'token', token: body };
+    switch (body.error) {
+        case 'authorization_pending':
+            return { kind: 'pending' };
+        case 'slow_down':
+            return { kind: 'slow_down' };
+        case 'expired_token':
+            return { kind: 'fail', message: DEVICE_EXPIRED_MESSAGE };
+        case 'access_denied':
+            return { kind: 'fail', message: 'Sign-in was denied.' };
+        default:
+            return {
+                kind: 'fail',
+                message: `token endpoint ${res.status}: ${String(body.error_description ?? body.error ?? '').slice(0, 200)}`
+            };
+    }
+};
+export const pollDeviceToken = async (io, cfg, auth, sleepFn = (ms) => new Promise((r) => setTimeout(r, ms))) => {
+    let interval = (auth.interval ?? 5) * 1000;
+    const deadline = io.now() + auth.expires_in * 1000;
+    while (io.now() < deadline) {
+        const verdict = await deviceTokenAttempt(io.network, cfg, auth.device_code);
+        if (verdict.kind === 'token')
+            return verdict.token;
+        if (verdict.kind === 'fail')
+            throw new Error(verdict.message);
+        if (verdict.kind === 'slow_down')
+            interval += 5000;
+        await sleepFn(interval);
+    }
+    throw new Error(DEVICE_EXPIRED_MESSAGE);
+};
+//# sourceMappingURL=paste-and-device.js.map

package/dist/request/stdin.js

@@ -0,0 +1,22 @@
+import { createInterface } from 'node:readline';
+export const readAll = async (input) => {
+    const chunks = [];
+    for await (const chunk of input)
+        chunks.push(chunk);
+    const text = Buffer.concat(chunks).toString('utf8');
+    return text.endsWith('\n') ? text.slice(0, -1) : text;
+};
+export const ask = (input, output, question) => new Promise((resolve) => {
+    const rl = createInterface({ input, output });
+    let answered = false;
+    rl.once('close', () => {
+        if (!answered)
+            resolve(null);
+    });
+    rl.question(question, (answer) => {
+        answered = true;
+        rl.close();
+        resolve(answer);
+    });
+});
+//# sourceMappingURL=stdin.js.map

package/dist/request/token.js

@@ -0,0 +1,66 @@
+export const emailFromIdToken = (idToken) => {
+    try {
+        const payload = JSON.parse(Buffer.from(idToken.split('.')[1] ?? '', 'base64url').toString());
+        return typeof payload.email === 'string' && payload.email !== '' ? payload.email : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const loginIdentityGate = (homeDir, tokenEmail) => {
+    const dirName = homeDir.split('/').filter(Boolean).at(-1) ?? '';
+    const homeEmail = dirName.includes('@') ? dirName : null;
+    if (!homeEmail)
+        return { save: true };
+    if (!tokenEmail) {
+        return {
+            save: false,
+            message: `Refusing to save: this directory is keyed to ${homeEmail}, but the sign-in ` +
+                `returned no email evidence. Nothing was written — retry the login, or use a ` +
+                `non-email --as home.\n`
+        };
+    }
+    if (homeEmail.toLowerCase() !== tokenEmail.toLowerCase()) {
+        return {
+            save: false,
+            message: `Refusing to save: this directory belongs to ${homeEmail}, but you signed in as ` +
+                `${tokenEmail}. Nothing was written — log in again as ${homeEmail}, ` +
+                `or point --as at ${tokenEmail} instead (\`lattris login\`).\n`
+        };
+    }
+    return { save: true };
+};
+export const toSession = (t, now) => ({
+    accessToken: t.access_token,
+    refreshToken: t.refresh_token,
+    tokenType: t.token_type || 'bearer',
+    expiresAt: Math.floor(now / 1000) + (t.expires_in ?? 0)
+});
+export const postToken = async (network, cfg, body, signal) => {
+    const res = await network(`${cfg.issuer}/oauth2/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams(body).toString(),
+        ...(signal ? { signal } : {})
+    });
+    if (!res.ok) {
+        const detail = await res.text().catch(() => '');
+        throw new Error(`token endpoint ${res.status}: ${detail.slice(0, 300)}`);
+    }
+    return (await res.json());
+};
+export const refreshBody = (cfg, refreshToken) => ({
+    grant_type: 'refresh_token',
+    refresh_token: refreshToken,
+    client_id: cfg.clientId,
+    scope: cfg.scopes
+});
+export const authCodeExchangeBody = (cfg, code, codeVerifier, redirectUri) => ({
+    grant_type: 'authorization_code',
+    code,
+    redirect_uri: redirectUri,
+    client_id: cfg.clientId,
+    code_verifier: codeVerifier
+});
+export const hostedRedirectUri = (cfg) => `${cfg.webUrl}/cli/auth`;
+//# sourceMappingURL=token.js.map

package/dist/request/upload.js

@@ -0,0 +1,6 @@
+export const putToSignedUploadUrl = (network, signedUploadUrl, contentType, bytes) => network(signedUploadUrl, {
+    method: 'PUT',
+    headers: { 'Content-Type': contentType },
+    body: bytes
+});
+//# sourceMappingURL=upload.js.map

package/dist/request/version-check.js

@@ -0,0 +1,79 @@
+import { join } from 'node:path';
+import { readJsonObject } from "../store/json-file.js";
+const VERSION_CHECK_URL = 'https://registry.npmjs.org/lattris/latest';
+const VERSION_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+const VERSION_CHECK_TIMEOUT_MS = 1500;
+const parseVersion = (version) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+    if (!match)
+        return undefined;
+    return {
+        core: [BigInt(match[1]), BigInt(match[2]), BigInt(match[3])],
+        prerelease: match[4] === undefined ? null : match[4].split('.')
+    };
+};
+const compareVersions = (left, right) => {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return undefined;
+    for (let i = 0; i < a.core.length; i++) {
+        if (a.core[i] < b.core[i])
+            return -1;
+        if (a.core[i] > b.core[i])
+            return 1;
+    }
+    if (a.prerelease === null && b.prerelease === null)
+        return 0;
+    if (a.prerelease === null)
+        return 1;
+    if (b.prerelease === null)
+        return -1;
+    const length = Math.max(a.prerelease.length, b.prerelease.length);
+    for (let i = 0; i < length; i++) {
+        const av = a.prerelease[i];
+        const bv = b.prerelease[i];
+        if (av === undefined)
+            return -1;
+        if (bv === undefined)
+            return 1;
+        if (av === bv)
+            continue;
+        const aNumber = /^\d+$/.test(av);
+        const bNumber = /^\d+$/.test(bv);
+        if (aNumber && bNumber)
+            return BigInt(av) < BigInt(bv) ? -1 : 1;
+        if (aNumber !== bNumber)
+            return aNumber ? -1 : 1;
+        return av < bv ? -1 : 1;
+    }
+    return 0;
+};
+export const checkForNewVersion = async (io, { currentVersion, stateDir, now }) => {
+    try {
+        const cachePath = join(stateDir, 'version-check.json');
+        const cache = readJsonObject(io.files, cachePath);
+        if (typeof cache?.checkedAt === 'number' && now - cache.checkedAt <= VERSION_CHECK_TTL_MS) {
+            return;
+        }
+        const response = await io.network(VERSION_CHECK_URL, {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS)
+        });
+        if (!response.ok)
+            return;
+        const body = (await response.json());
+        if (typeof body.version !== 'string' || parseVersion(body.version) === undefined)
+            return;
+        try {
+            io.files.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+            io.files.writeFileSync(cachePath, `${JSON.stringify({ checkedAt: now, latestVersion: body.version })}\n`, { mode: 0o600 });
+        }
+        catch { }
+        if (compareVersions(currentVersion, body.version) === -1) {
+            io.stderr.write(`lattris ${currentVersion} → ${body.version} available: npm update -g lattris\n`);
+        }
+    }
+    catch { }
+};
+//# sourceMappingURL=version-check.js.map

package/dist/store/chains.js

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+import { safeFileName, sessionDir } from "./session-home.js";
+const receiptsPath = (store, conversationId) => {
+    const name = conversationId === null ? undefined : safeFileName(conversationId);
+    return name === undefined ? undefined : join(sessionDir(store), 'chains', `${name}.json`);
+};
+export const loadReceipts = (store, conversationId) => {
+    const path = receiptsPath(store, conversationId);
+    if (path === undefined)
+        return { epochs: {} };
+    try {
+        return JSON.parse(store.files.readFileSync(path, 'utf8'));
+    }
+    catch {
+        return { epochs: {} };
+    }
+};
+export const saveReceipts = (store, conversationId, receipts) => {
+    const path = receiptsPath(store, conversationId);
+    if (path === undefined)
+        return;
+    store.files.mkdirSync(join(sessionDir(store), 'chains'), { recursive: true, mode: 0o700 });
+    store.files.writeFileSync(path, JSON.stringify(receipts, null, 2), { mode: 0o600 });
+};
+//# sourceMappingURL=chains.js.map

package/dist/store/drafts.js

@@ -0,0 +1,48 @@
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+import { safeFileName, sessionDir } from "./session-home.js";
+const draftsDir = (store) => join(sessionDir(store), 'drafts');
+const draftStamp = (store) => new Date(store.now()).toISOString().replace(/[:.]/g, '-');
+const saveDraft = (store, stem, extension, contents) => {
+    const dir = draftsDir(store);
+    const name = safeFileName(stem);
+    if (name === undefined)
+        throw new Error(`could not keep a draft under ${dir}`);
+    const { chmodSync, mkdirSync, writeFileSync } = store.files;
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+        const file = join(dir, `${name}-${draftStamp(store)}-${randomBytes(4).toString('hex')}.${extension}`);
+        try {
+            writeFileSync(file, contents, { mode: 0o600, flag: 'wx' });
+            chmodSync(file, 0o600);
+            return file;
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+        }
+    }
+    throw new Error(`could not keep a draft under ${dir}`);
+};
+export const saveRequestDraft = (store, kind, draft) => saveDraft(store, kind, 'json', `${JSON.stringify(draft, null, 2)}\n`);
+export const saveEditDraft = (store, blockRef, draft) => {
+    const wordsPath = draft.fields.content !== undefined
+        ? saveDraft(store, blockRef, 'md', `${draft.fields.content}\n`)
+        : undefined;
+    const draftPath = saveDraft(store, blockRef, 'json', `${JSON.stringify({ ...draft, wordsFile: wordsPath }, null, 2)}\n`);
+    return { draftPath, wordsPath };
+};
+export const alreadySaved = (sent, current) => {
+    if (sent.content !== undefined && sent.content !== current.content)
+        return false;
+    if (sent.title !== undefined && sent.title !== (current.title ?? undefined))
+        return false;
+    if (sent.aiSummary !== undefined && sent.aiSummary !== (current.aiSummary ?? undefined))
+        return false;
+    if (sent.intent !== undefined && (sent.intent ?? null) !== (current.intent ?? null))
+        return false;
+    if (sent.contributor !== undefined && sent.contributor !== (current.contributor?.id ?? null))
+        return false;
+    return true;
+};
+//# sourceMappingURL=drafts.js.map

package/dist/store/environment.js

@@ -0,0 +1,57 @@
+import { basename, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { EXIT, refusal } from "./exit.js";
+export const stripTrailingSlash = (s) => s.replace(/\/+$/, '');
+export const defaultEnvironmentForEntry = (files, entryUrl) => {
+    const entryPath = fileURLToPath(entryUrl);
+    const entryDir = dirname(entryPath);
+    const isBuiltMain = basename(entryPath) === 'main.js' && basename(entryDir) === 'dist';
+    return isBuiltMain && !files.existsSync(join(entryDir, 'installed-check.js')) ? 'prod' : 'local';
+};
+const environmentsPath = (machine) => join(machine.env.XDG_CONFIG_HOME || join(machine.home, '.config'), 'lattris', 'environments.json');
+const BUILTIN_LOCAL = {
+    issuer: 'http://localhost:4444',
+    api: 'http://localhost:54301',
+    web: 'http://localhost:4500',
+    clientId: 'lattris-cli'
+};
+export const BUILTIN_PROD = {
+    issuer: 'https://api.felix-synthetix.com',
+    api: 'https://lattris.com/api/lattris',
+    web: 'https://lattris.com',
+    clientId: 'lattris-cli'
+};
+const BUILTINS = { local: BUILTIN_LOCAL, prod: BUILTIN_PROD };
+const environmentEntry = (machine, envName) => {
+    try {
+        const registry = JSON.parse(machine.files.readFileSync(environmentsPath(machine), 'utf8'));
+        if (typeof registry === 'object' && registry !== null && Object.hasOwn(registry, envName)) {
+            const entry = registry[envName];
+            if (entry)
+                return entry;
+        }
+    }
+    catch { }
+    return Object.hasOwn(BUILTINS, envName) ? BUILTINS[envName] : undefined;
+};
+export const knownEnvironment = (machine, envName) => environmentEntry(machine, envName) !== undefined;
+const loadEnvironmentEntry = (machine, envName) => environmentEntry(machine, envName) ??
+    refusal(`Unknown environment: ${envName}. Known: local, prod (or add it to ${environmentsPath(machine)}).\n`, EXIT.USAGE);
+export const loadConfig = (store) => {
+    const entry = loadEnvironmentEntry(store, store.envName);
+    if ('exit' in entry)
+        return entry;
+    const env = store.env;
+    return {
+        env: store.envName,
+        issuer: stripTrailingSlash(env.LATTRIS_ISSUER ?? entry.issuer),
+        apiUrl: stripTrailingSlash(env.LATTRIS_API ?? entry.api),
+        clientId: env.LATTRIS_CLIENT_ID ?? entry.clientId,
+        redirectPort: Number(env.LATTRIS_REDIRECT_PORT ?? '4577'),
+        audience: env.LATTRIS_AUDIENCE ?? 'foundations lattris',
+        scopes: env.LATTRIS_SCOPES ?? 'openid offline_access lattris:all:all',
+        webUrl: stripTrailingSlash(env.LATTRIS_WEB_URL ?? entry.web),
+        ...(entry.remember_for !== undefined ? { rememberFor: entry.remember_for } : {})
+    };
+};
+//# sourceMappingURL=environment.js.map

package/dist/store/exit.js

@@ -0,0 +1,13 @@
+export const EXIT = {
+    OK: 0,
+    GENERIC: 1,
+    USAGE: 2,
+    NOAUTH: 3,
+    DOOR: 4
+};
+export const refusal = (message, exit = EXIT.USAGE) => ({
+    message,
+    exit
+});
+export const isRefusal = (value) => typeof value === 'object' && value !== null && 'exit' in value && 'message' in value;
+//# sourceMappingURL=exit.js.map

package/dist/store/io.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=io.js.map

package/dist/store/json-file.js

@@ -0,0 +1,9 @@
+export const readJsonObject = (files, path) => {
+    try {
+        return JSON.parse(files.readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+};
+//# sourceMappingURL=json-file.js.map

package/dist/store/session-home.js

@@ -0,0 +1,189 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { basename, dirname, join, resolve, sep } from 'node:path';
+import { knownEnvironment } from "./environment.js";
+export const stateHome = (machine) => machine.env.XDG_STATE_HOME || join(machine.home, '.local', 'state');
+const stateDir = (machine) => join(stateHome(machine), 'lattris');
+export const machinesRoot = (machine) => {
+    const named = machine.env.LATTRIS_MACHINES_ROOT;
+    return named
+        ? resolve(machine.home, named.replace(/^~(?=\/|$)/, machine.home))
+        : join(machine.home, 'lattris-machines');
+};
+export const BINDING_FILE = '.lattris';
+const madeHerePath = (machine) => join(stateDir(machine), 'bindings.json');
+const present = (files, path) => {
+    try {
+        files.lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const realPathOf = (files, path) => {
+    try {
+        return files.realpathSync(path);
+    }
+    catch {
+        const parent = dirname(path);
+        return parent === path ? path : join(realPathOf(files, parent), basename(path));
+    }
+};
+const bindingKey = (files, bindingFile) => join(realPathOf(files, dirname(bindingFile)), basename(bindingFile));
+const underMachinesRoot = (machine, bindingFile, dir) => {
+    const root = realPathOf(machine.files, machinesRoot(machine));
+    const under = (path) => path.startsWith(root + sep);
+    const from = realPathOf(machine.files, dirname(bindingFile));
+    return under(realPathOf(machine.files, dir)) && from !== root && !under(from);
+};
+const digest = (content) => createHash('sha256').update(content).digest('hex');
+const readMadeHere = (machine) => {
+    try {
+        const made = JSON.parse(machine.files.readFileSync(madeHerePath(machine), 'utf8'));
+        return typeof made === 'object' && made !== null ? made : {};
+    }
+    catch {
+        return {};
+    }
+};
+const wasMadeHere = (machine, bindingFile, content) => {
+    const made = readMadeHere(machine);
+    const key = bindingKey(machine.files, bindingFile);
+    return Object.hasOwn(made, key) && made[key] === digest(content);
+};
+const writeWhole = (machine, file, content, mode) => {
+    const draft = `${file}.${randomUUID()}.new`;
+    try {
+        machine.files.writeFileSync(draft, content, { mode, flag: 'wx' });
+        machine.files.renameSync(draft, file);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST') {
+            try {
+                machine.files.unlinkSync(draft);
+            }
+            catch { }
+        }
+        throw e;
+    }
+};
+const saveMadeHere = (machine, made) => {
+    machine.files.mkdirSync(stateDir(machine), { recursive: true, mode: 0o700 });
+    writeWhole(machine, madeHerePath(machine), `${JSON.stringify(made, null, 2)}\n`, 0o600);
+};
+const readBinding = (machine, bindingFile) => {
+    const refused = { trusted: false, bindingFile };
+    let content;
+    try {
+        if (!machine.files.lstatSync(bindingFile).isFile())
+            return refused;
+        content = machine.files.readFileSync(bindingFile, 'utf8');
+    }
+    catch {
+        return refused;
+    }
+    const lines = content
+        .trim()
+        .split('\n')
+        .map((l) => l.trim());
+    const pathLine = lines[0];
+    const env = lines
+        .slice(1)
+        .find((l) => l.startsWith('env='))
+        ?.slice(4)
+        .trim();
+    if (!pathLine)
+        return refused;
+    if (env && !knownEnvironment(machine, env))
+        return refused;
+    const machineDir = resolve(dirname(bindingFile), pathLine);
+    if (!underMachinesRoot(machine, bindingFile, machineDir) &&
+        !wasMadeHere(machine, bindingFile, content))
+        return refused;
+    return { trusted: true, bindingFile, machineDir, ...(env ? { env } : {}) };
+};
+export const findBinding = (machine, from = machine.cwd) => {
+    let dir = from;
+    while (dir.startsWith(machine.home + sep)) {
+        const bindingFile = join(dir, BINDING_FILE);
+        if (present(machine.files, bindingFile))
+            return readBinding(machine, bindingFile);
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+};
+export const writeBinding = (machine, dir, target, env) => {
+    const bindingFile = join(dir, BINDING_FILE);
+    const content = env ? `${target}\nenv=${env}\n` : `${target}\n`;
+    writeWhole(machine, bindingFile, content, 0o644);
+    if (underMachinesRoot(machine, bindingFile, target))
+        return;
+    saveMadeHere(machine, {
+        ...readMadeHere(machine),
+        [bindingKey(machine.files, bindingFile)]: digest(content)
+    });
+};
+export const clearBinding = (machine, dir) => {
+    const bindingFile = join(dir, BINDING_FILE);
+    if (!present(machine.files, bindingFile))
+        return false;
+    const key = bindingKey(machine.files, bindingFile);
+    machine.files.rmSync(bindingFile);
+    const made = readMadeHere(machine);
+    if (Object.hasOwn(made, key)) {
+        delete made[key];
+        saveMadeHere(machine, made);
+    }
+    return true;
+};
+export const resolveActorDir = (files, actor, root) => {
+    const exact = join(root, actor);
+    if (actor.includes('@') || files.existsSync(exact))
+        return { dir: exact };
+    let entries = [];
+    try {
+        entries = files.readdirSync(root);
+    }
+    catch {
+        return { dir: exact };
+    }
+    const matches = entries.filter((e) => e.startsWith(`${actor}@`)).sort();
+    if (matches.length === 1)
+        return { dir: join(root, matches[0]) };
+    if (matches.length > 1)
+        return { ambiguous: matches };
+    return { dir: exact };
+};
+export const resolveSessionHome = (machine) => {
+    if (machine.env.LATTRIS_HOME)
+        return { dir: machine.env.LATTRIS_HOME };
+    const bound = findBinding(machine);
+    if (bound?.trusted)
+        return { dir: bound.machineDir, bindingFile: bound.bindingFile, bindingEnv: bound.env };
+    return { dir: stateDir(machine), ...(bound ? { untrusted: bound.bindingFile } : {}) };
+};
+export const sessionDir = (store) => {
+    const home = resolveSessionHome(store);
+    const isDefault = !home.bindingFile && !store.env.LATTRIS_HOME;
+    if (isDefault && !store.envExplicit)
+        return home.dir;
+    const envDir = join(home.dir, store.envName);
+    const files = store.files;
+    if (store.envName === 'local' &&
+        !files.existsSync(join(envDir, 'session.json')) &&
+        files.existsSync(join(home.dir, 'session.json'))) {
+        files.mkdirSync(envDir, { recursive: true, mode: 0o700 });
+        files.renameSync(join(home.dir, 'session.json'), join(envDir, 'session.json'));
+        files.chmodSync(join(envDir, 'session.json'), 0o600);
+    }
+    return envDir;
+};
+export const sessionPath = (store) => join(sessionDir(store), 'session.json');
+export const safeFileName = (name) => {
+    const safe = name.replace(/[^A-Za-z0-9._-]/g, '_');
+    return safe === '' || safe === '.' || safe === '..' ? undefined : safe;
+};
+//# sourceMappingURL=session-home.js.map