@prestack/thread 0.0.3 → 0.1.1

package/dist/core/client.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { argv, cwd, env, stderr, stdin, stdout } from 'node:process';
+import { createInterface, emitKeypressEvents } from 'node:readline';
+import { kind, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "./files.js";
+import { exit, invoked } from "./invoked.js";
+import { THING } from "./scope.js";
+const HERE = cwd();
+const REASONS = {
+    ENOENT: 'is not there',
+    EACCES: 'is there, and this machine does not allow it',
+    EPERM: 'is there, and this machine does not allow it',
+    EISDIR: 'is a folder, and that order is for a file',
+    ENOTDIR: 'has a file part-way along its path where a folder was expected',
+    ENOTEMPTY: 'still holds something',
+};
+const HOME = (() => {
+    try {
+        return realpathSync(HERE);
+    }
+    catch {
+        return HERE;
+    }
+})();
+function deepest(at) {
+    let found = at;
+    while (kind(found) === 'none') {
+        const up = dirname(found);
+        if (up === found)
+            return found;
+        found = up;
+    }
+    return found;
+}
+function inside(at) {
+    let real;
+    try {
+        real = realpathSync(deepest(resolve(HERE, at)));
+    }
+    catch {
+        return false;
+    }
+    const step = relative(HOME, real);
+    return step === '' || (!step.startsWith('..') && !isAbsolute(step));
+}
+function rootly(at) {
+    const asked = resolve(HERE, at);
+    if (kind(asked) === 'none')
+        return false;
+    try {
+        return realpathSync(asked) === HOME;
+    }
+    catch {
+        return false;
+    }
+}
+const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]', '::1']);
+function local(at) {
+    try {
+        return LOOPBACK.has(new URL(at).hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function why(at, thrown) {
+    const held = thrown instanceof Error ? Reflect.get(thrown, 'code') : undefined;
+    const said = typeof held === 'string' ? REASONS[held] : undefined;
+    if (said !== undefined)
+        return `${at} ${said}.`;
+    return `${at} could not be reached — ${thrown instanceof Error ? thrown.message : String(thrown)}.`;
+}
+export function carry(one) {
+    if (!inside(one.at)) {
+        return {
+            answered: 'refused',
+            because: `${one.at} is outside ${HERE} once its links are followed, and this answers only for what is really inside the repository it was run in.`,
+        };
+    }
+    if (one.order === 'remove' && rootly(one.at)) {
+        return {
+            answered: 'refused',
+            because: `${one.at} is the repository this was run in, and this carries orders inside it rather than taking it away.`,
+        };
+    }
+    try {
+        if (one.order === 'kind')
+            return { answered: 'kind', held: kind(one.at) };
+        if (one.order === 'read')
+            return { answered: 'read', said: readFileSync(one.at) };
+        if (one.order === 'list') {
+            const held = readdirSync(one.at, { withFileTypes: true }).map((each) => ({
+                name: each.name,
+                kind: each.isFile() ? 'file' : each.isDirectory() ? 'folder' : 'other',
+            }));
+            return { answered: 'list', held };
+        }
+        if (one.order === 'stat') {
+            const held = statSync(one.at);
+            return { answered: 'stat', held: { size: held.size, modified: held.mtimeMs } };
+        }
+        if (one.order === 'remove') {
+            rmSync(one.at, { recursive: true, force: true });
+            return { answered: 'removed' };
+        }
+        if (one.order === 'real')
+            return { answered: 'real', at: realpathSync(one.at) };
+        writeFileSync(one.at, one.said);
+        return { answered: 'written' };
+    }
+    catch (thrown) {
+        return { answered: 'refused', because: why(one.at, thrown) };
+    }
+}
+const AT = 'THREAD_SERVER';
+const KEY = 'THREAD_KEY';
+const QUIET = 100;
+async function sending(at, key, body) {
+    const said = await fetch(at, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${key}` },
+        body: JSON.stringify(body),
+    });
+    if (said.status === 401 || said.status === 403)
+        throw new Error(`the key in ${KEY} is not one ${at} accepts`);
+    if (!said.ok)
+        throw new Error(`${at} answered ${String(said.status)}`);
+    return (await said.json());
+}
+export async function talking(at, key, message) {
+    let turn = await sending(at, key, { said: message });
+    let silent = 0;
+    for (;;) {
+        if (turn.say !== undefined && turn.say !== '')
+            stdout.write(`${turn.say}\n`);
+        if (turn.done === true)
+            return 0;
+        const orders = turn.orders ?? [];
+        silent = orders.length === 0 && (turn.say === undefined || turn.say === '') ? silent + 1 : 0;
+        if (silent >= QUIET)
+            break;
+        turn = await sending(at, key, { of: turn.of, answered: orders.map(carry) });
+    }
+    stderr.write(`${THING}: nothing has come back from ${at} for ${String(QUIET)} exchanges, so this stopped waiting. What is already\n` +
+        `in this repository stands, and nothing half-written was left behind — every change is one order, carried\n` +
+        `and answered before the next one is asked for.\n` +
+        `This only ever gives up on silence: a server that keeps asking for files never reaches it, so a run that is\n` +
+        `going nowhere and still talking is one you stop with ctrl-c.\n`);
+    return 1;
+}
+const PROMPT = '> ';
+async function chatting(at, key) {
+    stdout.write(THING +
+        ': talking to ' +
+        at +
+        '. Say what you want built, in a sentence — there is no command here to look up.\n' +
+        'Press Esc to stop a turn. Type while one is running and what you type goes next, when it finishes.\n' +
+        'Ctrl-C to leave.\n\n');
+    const queued = [];
+    let busy = false;
+    const held = createInterface({ input: stdin, output: stdout, prompt: PROMPT });
+    emitKeypressEvents(stdin);
+    stdin.on('keypress', (...said) => {
+        const one = said[1];
+        if (busy && one !== undefined && one.name === 'escape')
+            void sending(at, key, { stop: true }).catch(() => undefined);
+    });
+    const next = async () => {
+        const one = queued.shift();
+        if (one === undefined) {
+            busy = false;
+            held.prompt();
+            return;
+        }
+        busy = true;
+        try {
+            await talking(at, key, one);
+        }
+        catch (thrown) {
+            stderr.write(THING + ': ' + at + ' could not answer — ' + (thrown instanceof Error ? thrown.message : String(thrown)) + '. Nothing was written.\n');
+        }
+        await next();
+    };
+    held.on('line', (line) => {
+        const one = line.trim();
+        if (one.length === 0) {
+            if (!busy)
+                held.prompt();
+            return;
+        }
+        queued.push(one);
+        if (busy) {
+            stdout.write(THING + ': queued — it goes next.\n');
+            return;
+        }
+        void next();
+    });
+    held.prompt();
+    return await new Promise((settle) => {
+        held.on('close', () => {
+            settle(0);
+        });
+    });
+}
+function pointed() {
+    const at = env[AT];
+    if (at === undefined || at.length === 0) {
+        stderr.write(`${THING}: there is nowhere to send that yet. This copy has no server to answer it — ${AT} names one, and\n` +
+            `nothing here is set to one.\n`);
+        return undefined;
+    }
+    if (!local(at)) {
+        stderr.write(`${THING}: ${AT} names ${at}, which is not on this machine, and this only ever talks to a server running\n` +
+            `here. Set ${AT} to a http://localhost address and say it again. Nothing was sent.\n`);
+        return undefined;
+    }
+    return at;
+}
+export async function run(said) {
+    const at = pointed();
+    if (at === undefined)
+        return 1;
+    const key = env[KEY] ?? '';
+    if (said.length === 0)
+        return await chatting(at, key);
+    const message = said.length === 1 ? (said[0] ?? '') : '';
+    if (!message.includes(' ')) {
+        stderr.write(`${THING}: there is no \`${said.join(' ')}\` here, and no other command to find instead. This takes one\n` +
+            `sentence, in quotes, and nothing else — ${THING} "take payments with stripe". Say what you want and it\n` +
+            `is answered where the work happens, never on this machine.\n`);
+        return 1;
+    }
+    try {
+        return await talking(at, key, message);
+    }
+    catch (thrown) {
+        stderr.write(`${THING}: ${at} could not answer — ${thrown instanceof Error ? thrown.message : String(thrown)}. Nothing was\n` +
+            `written, so this repository is as it was.\n`);
+        return 1;
+    }
+}
+if (invoked(import.meta.url))
+    exit(await run(argv.slice(2)));

package/dist/core/client.ts

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+import { dirname, isAbsolute, relative, resolve } from 'node:path'
+import { argv, cwd, env, stderr, stdin, stdout } from 'node:process'
+import { createInterface, emitKeypressEvents } from 'node:readline'
+import { kind, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, type Kind, type Listed, type Measured } from './files.ts'
+import { exit, invoked } from './invoked.ts'
+import { THING } from './scope.ts'
+
+export type Order =
+  | { readonly order: 'kind'; readonly at: string }
+  | { readonly order: 'read'; readonly at: string }
+  | { readonly order: 'list'; readonly at: string }
+  | { readonly order: 'stat'; readonly at: string }
+  | { readonly order: 'remove'; readonly at: string }
+  | { readonly order: 'real'; readonly at: string }
+  | { readonly order: 'write'; readonly at: string; readonly said: string }
+
+export type Answered =
+  | { readonly answered: 'kind'; readonly held: Kind }
+  | { readonly answered: 'read'; readonly said: string }
+  | { readonly answered: 'list'; readonly held: readonly Listed[] }
+  | { readonly answered: 'stat'; readonly held: Measured }
+  | { readonly answered: 'written' }
+  | { readonly answered: 'removed' }
+  | { readonly answered: 'real'; readonly at: string }
+  | { readonly answered: 'refused'; readonly because: string }
+
+const HERE = cwd()
+
+const REASONS: Readonly<Record<string, string>> = {
+  ENOENT: 'is not there',
+  EACCES: 'is there, and this machine does not allow it',
+  EPERM: 'is there, and this machine does not allow it',
+  EISDIR: 'is a folder, and that order is for a file',
+  ENOTDIR: 'has a file part-way along its path where a folder was expected',
+  ENOTEMPTY: 'still holds something',
+}
+
+const HOME = ((): string => {
+  try {
+    return realpathSync(HERE)
+  } catch {
+    return HERE
+  }
+})()
+
+function deepest(at: string): string {
+  let found = at
+  while (kind(found) === 'none') {
+    const up = dirname(found)
+    if (up === found) return found
+    found = up
+  }
+  return found
+}
+
+function inside(at: string): boolean {
+  let real: string
+  try {
+    real = realpathSync(deepest(resolve(HERE, at)))
+  } catch {
+    return false
+  }
+  const step = relative(HOME, real)
+  return step === '' || (!step.startsWith('..') && !isAbsolute(step))
+}
+
+function rootly(at: string): boolean {
+  const asked = resolve(HERE, at)
+  if (kind(asked) === 'none') return false
+  try {
+    return realpathSync(asked) === HOME
+  } catch {
+    return false
+  }
+}
+
+const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]', '::1'])
+
+function local(at: string): boolean {
+  try {
+    return LOOPBACK.has(new URL(at).hostname)
+  } catch {
+    return false
+  }
+}
+
+function why(at: string, thrown: unknown): string {
+  const held: unknown = thrown instanceof Error ? Reflect.get(thrown, 'code') : undefined
+  const said = typeof held === 'string' ? REASONS[held] : undefined
+  if (said !== undefined) return `${at} ${said}.`
+  return `${at} could not be reached — ${thrown instanceof Error ? thrown.message : String(thrown)}.`
+}
+
+export function carry(one: Order): Answered {
+  if (!inside(one.at)) {
+    return {
+      answered: 'refused',
+      because: `${one.at} is outside ${HERE} once its links are followed, and this answers only for what is really inside the repository it was run in.`,
+    }
+  }
+  if (one.order === 'remove' && rootly(one.at)) {
+    return {
+      answered: 'refused',
+      because: `${one.at} is the repository this was run in, and this carries orders inside it rather than taking it away.`,
+    }
+  }
+  try {
+    if (one.order === 'kind') return { answered: 'kind', held: kind(one.at) }
+    if (one.order === 'read') return { answered: 'read', said: readFileSync(one.at) }
+    if (one.order === 'list') {
+      const held = readdirSync(one.at, { withFileTypes: true }).map((each) => ({
+        name: each.name,
+        kind: each.isFile() ? ('file' as const) : each.isDirectory() ? ('folder' as const) : ('other' as const),
+      }))
+      return { answered: 'list', held }
+    }
+    if (one.order === 'stat') {
+      const held = statSync(one.at)
+      return { answered: 'stat', held: { size: held.size, modified: held.mtimeMs } }
+    }
+    if (one.order === 'remove') {
+      rmSync(one.at, { recursive: true, force: true })
+      return { answered: 'removed' }
+    }
+    if (one.order === 'real') return { answered: 'real', at: realpathSync(one.at) }
+    writeFileSync(one.at, one.said)
+    return { answered: 'written' }
+  } catch (thrown) {
+    return { answered: 'refused', because: why(one.at, thrown) }
+  }
+}
+
+export interface Turn {
+  readonly of: string
+  readonly orders?: readonly Order[]
+  readonly say?: string
+  readonly done?: boolean
+}
+
+const AT = 'THREAD_SERVER'
+
+const KEY = 'THREAD_KEY'
+
+const QUIET = 100
+
+async function sending(at: string, key: string, body: unknown): Promise<Turn> {
+  const said = await fetch(at, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${key}` },
+    body: JSON.stringify(body),
+  })
+  if (said.status === 401 || said.status === 403) throw new Error(`the key in ${KEY} is not one ${at} accepts`)
+  if (!said.ok) throw new Error(`${at} answered ${String(said.status)}`)
+  return (await said.json()) as Turn
+}
+
+export async function talking(at: string, key: string, message: string): Promise<number> {
+  let turn = await sending(at, key, { said: message })
+  let silent = 0
+  for (;;) {
+    if (turn.say !== undefined && turn.say !== '') stdout.write(`${turn.say}\n`)
+    if (turn.done === true) return 0
+    const orders = turn.orders ?? []
+    silent = orders.length === 0 && (turn.say === undefined || turn.say === '') ? silent + 1 : 0
+    if (silent >= QUIET) break
+    turn = await sending(at, key, { of: turn.of, answered: orders.map(carry) })
+  }
+  stderr.write(
+    `${THING}: nothing has come back from ${at} for ${String(QUIET)} exchanges, so this stopped waiting. What is already\n` +
+      `in this repository stands, and nothing half-written was left behind — every change is one order, carried\n` +
+      `and answered before the next one is asked for.\n` +
+      `This only ever gives up on silence: a server that keeps asking for files never reaches it, so a run that is\n` +
+      `going nowhere and still talking is one you stop with ctrl-c.\n`,
+  )
+  return 1
+}
+
+const PROMPT = '> '
+
+async function chatting(at: string, key: string): Promise<number> {
+  stdout.write(
+    THING +
+      ': talking to ' +
+      at +
+      '. Say what you want built, in a sentence — there is no command here to look up.\n' +
+      'Press Esc to stop a turn. Type while one is running and what you type goes next, when it finishes.\n' +
+      'Ctrl-C to leave.\n\n',
+  )
+  const queued: string[] = []
+  let busy = false
+  const held = createInterface({ input: stdin, output: stdout, prompt: PROMPT })
+  emitKeypressEvents(stdin)
+  stdin.on('keypress', (...said: readonly unknown[]) => {
+    const one = said[1] as { readonly name?: string } | undefined
+    if (busy && one !== undefined && one.name === 'escape') void sending(at, key, { stop: true }).catch(() => undefined)
+  })
+  const next = async (): Promise<void> => {
+    const one = queued.shift()
+    if (one === undefined) {
+      busy = false
+      held.prompt()
+      return
+    }
+    busy = true
+    try {
+      await talking(at, key, one)
+    } catch (thrown) {
+      stderr.write(THING + ': ' + at + ' could not answer — ' + (thrown instanceof Error ? thrown.message : String(thrown)) + '. Nothing was written.\n')
+    }
+    await next()
+  }
+  held.on('line', (line: string) => {
+    const one = line.trim()
+    if (one.length === 0) {
+      if (!busy) held.prompt()
+      return
+    }
+    queued.push(one)
+    if (busy) {
+      stdout.write(THING + ': queued — it goes next.\n')
+      return
+    }
+    void next()
+  })
+  held.prompt()
+  return await new Promise<number>((settle) => {
+    held.on('close', () => {
+      settle(0)
+    })
+  })
+}
+
+function pointed(): string | undefined {
+  const at = env[AT]
+  if (at === undefined || at.length === 0) {
+    stderr.write(
+      `${THING}: there is nowhere to send that yet. This copy has no server to answer it — ${AT} names one, and\n` +
+        `nothing here is set to one.\n`,
+    )
+    return undefined
+  }
+  if (!local(at)) {
+    stderr.write(
+      `${THING}: ${AT} names ${at}, which is not on this machine, and this only ever talks to a server running\n` +
+        `here. Set ${AT} to a http://localhost address and say it again. Nothing was sent.\n`,
+    )
+    return undefined
+  }
+  return at
+}
+
+export async function run(said: readonly string[]): Promise<number> {
+  const at = pointed()
+  if (at === undefined) return 1
+  const key = env[KEY] ?? ''
+  if (said.length === 0) return await chatting(at, key)
+  const message = said.length === 1 ? (said[0] ?? '') : ''
+  if (!message.includes(' ')) {
+    stderr.write(
+      `${THING}: there is no \`${said.join(' ')}\` here, and no other command to find instead. This takes one\n` +
+        `sentence, in quotes, and nothing else — ${THING} "take payments with stripe". Say what you want and it\n` +
+        `is answered where the work happens, never on this machine.\n`,
+    )
+    return 1
+  }
+
+  try {
+    return await talking(at, key, message)
+  } catch (thrown) {
+    stderr.write(
+      `${THING}: ${at} could not answer — ${thrown instanceof Error ? thrown.message : String(thrown)}. Nothing was\n` +
+        `written, so this repository is as it was.\n`,
+    )
+    return 1
+  }
+}
+
+if (invoked(import.meta.url)) exit(await run(argv.slice(2)))

package/dist/core/descend.d.ts

@@ -5,6 +5,7 @@ export declare const TREE: string;
 export declare const THREAD_AT: string;
 export declare function unkept(at: string): boolean;
 export declare const LISTS: readonly ["declares", "derives", "seeds"];
+export declare const ROW_LISTS: readonly ["declares", "derives", "seeds", "holds"];
 export interface Row {
     readonly at?: string;
     readonly id?: string;
@@ -46,6 +47,7 @@ export declare function configured(): {
     readonly from: string;
     readonly trouble?: string;
 };
+export declare function hosting(options: ts.CompilerOptions): ts.CompilerHost;
 export declare function uncompiled(): readonly Finding[];
 export declare function read(at: string): string | undefined;
 export declare function shapesNamed(): ReadonlyMap<string, readonly string[]>;