@prestack/thread 0.1.3 → 0.1.5

package/dist/core/files.js

@@ -1,171 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import * as disk from 'node:fs';
-import { dirname, join } from 'node:path';
-const CHANNEL = 'THREAD_CHANNEL';
-const WAITING = 180000;
-function overFiles(dir) {
-    const idle = new Int32Array(new SharedArrayBuffer(4));
-    let spun = 0;
-    const ask = (body) => {
-        spun += 1;
-        const name = `${dir}/${String(process.pid)}-${String(spun)}`;
-        disk.writeFileSync(`${name}.asking`, JSON.stringify(body));
-        disk.renameSync(`${name}.asking`, `${name}.order`);
-        const until = Date.now() + WAITING;
-        for (;;) {
-            let held;
-            try {
-                held = disk.readFileSync(`${name}.answer`, 'utf8');
-            }
-            catch {
-                held = undefined;
-            }
-            if (held !== undefined) {
-                disk.rmSync(`${name}.answer`, { force: true });
-                const said = JSON.parse(held);
-                if (said.answered === 'refused')
-                    throw new Error(String(said.because));
-                return said;
-            }
-            if (Date.now() > until)
-                throw new Error('nothing answered ' +
-                    String(body.order) +
-                    ' ' +
-                    String(body.at) +
-                    ' for three minutes, so this stopped waiting rather than spinning forever. Whoever was answering is gone. It waits longer than a server waits before giving up on a run, on purpose: if an answer were still coming it would have arrived. Nothing here is half-written — one order is one file, and it was either answered or it was not.');
-            Atomics.wait(idle, 0, 0, 2);
-        }
-    };
-    return {
-        kind: (at) => ask({ order: 'kind', at }).held,
-        read: (at) => ask({ order: 'read', at }).said,
-        write: (at, said) => {
-            ask({ order: 'write', at, said });
-        },
-        list: (at) => ask({ order: 'list', at }).held,
-        stat: (at) => ask({ order: 'stat', at }).held,
-        remove: (at) => {
-            ask({ order: 'remove', at });
-        },
-        real: (at) => ask({ order: 'real', at }).at,
-        fetch: (at) => ask({ order: 'fetch', at }).said,
-    };
-}
-const WHERE = process.env[CHANNEL];
-let answering = WHERE !== undefined && WHERE !== '' ? overFiles(WHERE) : undefined;
-export function answeredBy(one) {
-    answering = one;
-}
-const asked = (at) => (typeof at === 'string' ? answering : undefined);
-export function attached() {
-    return answering !== undefined;
-}
-export function kind(at) {
-    const one = answering;
-    if (one !== undefined)
-        return one.kind(at);
-    const held = disk.statSync(at, { throwIfNoEntry: false });
-    if (held === undefined)
-        return 'none';
-    return held.isFile() ? 'file' : held.isDirectory() ? 'folder' : 'other';
-}
-export function existsSync(at) {
-    return typeof at === 'string' ? kind(at) !== 'none' : disk.existsSync(at);
-}
-export function readFileSync(at, how) {
-    const one = asked(at);
-    return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(at);
-}
-export function writeFileSync(at, said, how) {
-    const one = asked(at);
-    if (one !== undefined) {
-        one.write(at, said);
-        return;
-    }
-    if (typeof at === 'string')
-        disk.mkdirSync(dirname(at), { recursive: true });
-    disk.writeFileSync(at, said, how ?? 'utf8');
-}
-export function readdirSync(at, how) {
-    const one = asked(at);
-    if (one === undefined)
-        return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how);
-    const held = one.list(at);
-    return how === undefined
-        ? held.map((each) => each.name)
-        : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }));
-}
-export function statSync(at, how) {
-    const one = asked(at);
-    if (one === undefined)
-        return (how === undefined ? disk.statSync(at) : disk.statSync(at, how));
-    const path = at;
-    const held = one.kind(path);
-    if (held === 'none') {
-        if (how !== undefined)
-            return undefined;
-        throw new Error(`${path} is not there, so nothing can be said about it.`);
-    }
-    const measured = one.stat(path);
-    return {
-        name: path,
-        size: measured.size,
-        modified: measured.modified,
-        mtimeMs: measured.modified,
-        isFile: () => held === 'file',
-        isDirectory: () => held === 'folder',
-    };
-}
-export function rmSync(at, how) {
-    const one = asked(at);
-    if (one === undefined)
-        disk.rmSync(at, how);
-    else
-        one.remove(at);
-}
-export function renameSync(from, to) {
-    const one = asked(from);
-    if (one === undefined) {
-        disk.renameSync(from, to);
-        return;
-    }
-    one.write(to, one.read(from));
-    one.remove(from);
-}
-export function appendFileSync(at, said) {
-    const one = asked(at);
-    if (one === undefined) {
-        disk.appendFileSync(at, said);
-        return;
-    }
-    const path = at;
-    one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`);
-}
-export function realpathSync(at) {
-    const one = asked(at);
-    return one === undefined ? disk.realpathSync(at) : one.real(at);
-}
-export function manager(into) {
-    if (disk.existsSync(join(into, 'pnpm-lock.yaml')))
-        return ['pnpm', 'add'];
-    if (disk.existsSync(join(into, 'yarn.lock')))
-        return ['yarn', 'add'];
-    if (disk.existsSync(join(into, 'bun.lockb')))
-        return ['bun', 'add'];
-    return ['npm', 'install'];
-}
-export function installing(at) {
-    const tool = manager(at)[0] ?? 'npm';
-    const ran = spawnSync(tool, ['install'], { cwd: at, encoding: 'utf8', shell: false });
-    const said = `${ran.stdout ?? ''}${ran.stderr ?? ''}`.trim();
-    if (ran.error !== undefined)
-        throw new Error(`${tool} is not on this machine, so what ${at} depends on cannot be fetched. Put ${tool} on this machine, ` +
-            'or take away the lockfile that picked it and another one is used.');
-    if (ran.status !== 0)
-        throw new Error(`${tool} could not install what ${at} depends on. It said: ${said === '' ? `nothing, and exited ${String(ran.status)}` : said}`);
-    return said;
-}
-export function fetching(at) {
-    const one = answering;
-    return one === undefined ? installing(at) : one.fetch(at);
-}

package/dist/core/files.ts

@@ -1,222 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import * as disk from 'node:fs'
-import { dirname, join } from 'node:path'
-
-export type Kind = 'file' | 'folder' | 'other' | 'none'
-
-export interface Listed {
-  readonly name: string
-  readonly kind: Exclude<Kind, 'none'>
-}
-
-export interface Measured {
-  readonly size: number
-  readonly modified: number
-}
-
-export interface Answering {
-  readonly kind: (at: string) => Kind
-  readonly read: (at: string) => string
-  readonly write: (at: string, said: string) => void
-  readonly list: (at: string) => readonly Listed[]
-  readonly stat: (at: string) => Measured
-  readonly remove: (at: string) => void
-  readonly real: (at: string) => string
-  readonly fetch: (at: string) => string
-}
-
-const CHANNEL = 'THREAD_CHANNEL'
-
-const WAITING = 180000
-
-function overFiles(dir: string): Answering {
-  const idle = new Int32Array(new SharedArrayBuffer(4))
-  let spun = 0
-
-  const ask = (body: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>> => {
-    spun += 1
-    const name = `${dir}/${String(process.pid)}-${String(spun)}`
-    disk.writeFileSync(`${name}.asking`, JSON.stringify(body))
-    disk.renameSync(`${name}.asking`, `${name}.order`)
-    const until = Date.now() + WAITING
-    for (;;) {
-      let held: string | undefined
-      try {
-        held = disk.readFileSync(`${name}.answer`, 'utf8')
-      } catch {
-        held = undefined
-      }
-      if (held !== undefined) {
-        disk.rmSync(`${name}.answer`, { force: true })
-        const said = JSON.parse(held) as Readonly<Record<string, unknown>>
-        if (said.answered === 'refused') throw new Error(String(said.because))
-        return said
-      }
-      if (Date.now() > until)
-        throw new Error(
-          'nothing answered ' +
-            String(body.order) +
-            ' ' +
-            String(body.at) +
-            ' for three minutes, so this stopped waiting rather than spinning forever. Whoever was answering is gone. It waits longer than a server waits before giving up on a run, on purpose: if an answer were still coming it would have arrived. Nothing here is half-written — one order is one file, and it was either answered or it was not.',
-        )
-      Atomics.wait(idle, 0, 0, 2)
-    }
-  }
-
-  return {
-    kind: (at) => ask({ order: 'kind', at }).held as Kind,
-    read: (at) => ask({ order: 'read', at }).said as string,
-    write: (at, said) => {
-      ask({ order: 'write', at, said })
-    },
-    list: (at) => ask({ order: 'list', at }).held as readonly Listed[],
-    stat: (at) => ask({ order: 'stat', at }).held as Measured,
-    remove: (at) => {
-      ask({ order: 'remove', at })
-    },
-    real: (at) => ask({ order: 'real', at }).at as string,
-    fetch: (at) => ask({ order: 'fetch', at }).said as string,
-  }
-}
-
-const WHERE = process.env[CHANNEL]
-
-let answering: Answering | undefined = WHERE !== undefined && WHERE !== '' ? overFiles(WHERE) : undefined
-
-export function answeredBy(one: Answering | undefined): void {
-  answering = one
-}
-
-const asked = (at: unknown): Answering | undefined => (typeof at === 'string' ? answering : undefined)
-
-export function attached(): boolean {
-  return answering !== undefined
-}
-
-export function kind(at: string): Kind {
-  const one = answering
-  if (one !== undefined) return one.kind(at)
-  const held = disk.statSync(at, { throwIfNoEntry: false })
-  if (held === undefined) return 'none'
-  return held.isFile() ? 'file' : held.isDirectory() ? 'folder' : 'other'
-}
-
-export function existsSync(at: disk.PathLike): boolean {
-  return typeof at === 'string' ? kind(at) !== 'none' : disk.existsSync(at)
-}
-
-export function readFileSync(at: disk.PathOrFileDescriptor, how?: BufferEncoding): string {
-  const one = asked(at)
-  return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(at as string)
-}
-
-export function writeFileSync(at: disk.PathOrFileDescriptor, said: string, how?: BufferEncoding): void {
-  const one = asked(at)
-  if (one !== undefined) {
-    one.write(at as string, said)
-    return
-  }
-  if (typeof at === 'string') disk.mkdirSync(dirname(at), { recursive: true })
-  disk.writeFileSync(at, said, how ?? 'utf8')
-}
-
-export interface Named {
-  readonly name: string
-  readonly isFile: () => boolean
-  readonly isDirectory: () => boolean
-}
-
-export function readdirSync(at: disk.PathLike): string[]
-export function readdirSync(at: disk.PathLike, how: { readonly withFileTypes: true }): readonly Named[]
-export function readdirSync(at: disk.PathLike, how?: { readonly withFileTypes: true }): string[] | readonly Named[] {
-  const one = asked(at)
-  if (one === undefined) return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how)
-  const held = one.list(at as string)
-  return how === undefined
-    ? held.map((each) => each.name)
-    : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }))
-}
-
-export interface Held extends Named, Measured {
-  readonly mtimeMs: number
-}
-
-export function statSync(at: disk.PathLike): Held
-export function statSync(at: disk.PathLike, how: { readonly throwIfNoEntry: false }): Held | undefined
-export function statSync(at: disk.PathLike, how?: { readonly throwIfNoEntry: false }): Held | undefined {
-  const one = asked(at)
-  if (one === undefined) return (how === undefined ? disk.statSync(at) : disk.statSync(at, how)) as Held | undefined
-  const path = at as string
-  const held = one.kind(path)
-  if (held === 'none') {
-    if (how !== undefined) return undefined
-    throw new Error(`${path} is not there, so nothing can be said about it.`)
-  }
-  const measured = one.stat(path)
-  return {
-    name: path,
-    size: measured.size,
-    modified: measured.modified,
-    mtimeMs: measured.modified,
-    isFile: () => held === 'file',
-    isDirectory: () => held === 'folder',
-  }
-}
-
-export function rmSync(at: disk.PathLike, how?: disk.RmOptions): void {
-  const one = asked(at)
-  if (one === undefined) disk.rmSync(at, how)
-  else one.remove(at as string)
-}
-
-export function renameSync(from: disk.PathLike, to: disk.PathLike): void {
-  const one = asked(from)
-  if (one === undefined) {
-    disk.renameSync(from, to)
-    return
-  }
-  one.write(to as string, one.read(from as string))
-  one.remove(from as string)
-}
-
-export function appendFileSync(at: disk.PathOrFileDescriptor, said: string): void {
-  const one = asked(at)
-  if (one === undefined) {
-    disk.appendFileSync(at, said)
-    return
-  }
-  const path = at as string
-  one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`)
-}
-
-export function realpathSync(at: disk.PathLike): string {
-  const one = asked(at)
-  return one === undefined ? disk.realpathSync(at as string) : one.real(at as string)
-}
-
-export function manager(into: string): readonly string[] {
-  if (disk.existsSync(join(into, 'pnpm-lock.yaml'))) return ['pnpm', 'add']
-  if (disk.existsSync(join(into, 'yarn.lock'))) return ['yarn', 'add']
-  if (disk.existsSync(join(into, 'bun.lockb'))) return ['bun', 'add']
-  return ['npm', 'install']
-}
-
-export function installing(at: string): string {
-  const tool = manager(at)[0] ?? 'npm'
-  const ran = spawnSync(tool, ['install'], { cwd: at, encoding: 'utf8', shell: false })
-  const said = `${ran.stdout ?? ''}${ran.stderr ?? ''}`.trim()
-  if (ran.error !== undefined)
-    throw new Error(
-      `${tool} is not on this machine, so what ${at} depends on cannot be fetched. Put ${tool} on this machine, ` +
-        'or take away the lockfile that picked it and another one is used.',
-    )
-  if (ran.status !== 0)
-    throw new Error(`${tool} could not install what ${at} depends on. It said: ${said === '' ? `nothing, and exited ${String(ran.status)}` : said}`)
-  return said
-}
-
-export function fetching(at: string): string {
-  const one = answering
-  return one === undefined ? installing(at) : one.fetch(at)
-}

package/dist/integrations/module.d.ts

@@ -1,6 +0,0 @@
-export declare function ran(name: string): Promise<void>;
-export declare function run(declared: {
-    readonly name: string;
-    readonly module: string;
-    readonly requires: readonly string[];
-}): Promise<void>;

package/dist/integrations/module.js

@@ -1,153 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { spawnSync } from 'node:child_process';
-import { argv, stderr, stdout } from 'node:process';
-import { answer, asking, given, unasked, wordsIn } from "../core/answers.js";
-import { readFileSync } from "../core/files.js";
-import { exit } from "../core/invoked.js";
-import { valuesIn } from "../core/rows.js";
-import { findTree, inTree } from "../core/tree.js";
-import { REACH, reachOf } from "./target.js";
-import { opened } from "./vault.js";
-const PRODUCTION = '--production';
-const METHOD = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/;
-function isClass(fn) {
-    return /^class[\s{]/.test(Function.prototype.toString.call(fn));
-}
-const ASKS = [
-    {
-        key: 'args',
-        says: 'a JSON value — an array for positional arguments, anything else for one, blank for none',
-    },
-];
-const TAKES = ASKS.map((one) => one.key);
-const ASKED = ASKS.map((one) => `\`${one.key}\`: ${one.says}`);
-export async function ran(name) {
-    const say = (because) => {
-        stderr.write(`${name}: ${because}\n`);
-        exit(1);
-    };
-    const tree = findTree();
-    let targets = [];
-    try {
-        const taken = valuesIn(readFileSync(inTree(tree, 'targets.ts')));
-        targets = taken.TARGETS ?? [];
-    }
-    catch {
-        return say('`_threads/targets.ts` could not be read, so nothing says what this integration is.');
-    }
-    const mine = targets.find((one) => one.id === `${REACH.cli}${name}` || one.id === `${REACH.module}${name}`);
-    if (mine === undefined) {
-        return say(`no target called \`${REACH.cli}${name}\` or \`${REACH.module}${name}\` is declared here, so this command should ` +
-            'not exist. Declare it with `thread create target`, or take its row out of `_threads/derivation.ts`.');
-    }
-    const does = mine.offers ?? [];
-    const passed = argv.slice(2);
-    const sub = passed[0];
-    if (sub === undefined) {
-        stdout.write(`${name}: ${mine.describes}\n\n${String(does.length)} command(s), read off \`${mine.uses ?? ''}\` when \`${mine.id}\` was declared:\n` +
-            `${does.join(', ') || '(none were readable — name them with `thread create target edit`)'}\n\n` +
-            `thread run ${name} <command> [anything else] — arguments and flags reach \`${mine.uses ?? ''}\` untouched.\n` +
-            `It takes ${String(ASKED.length)} answer(s): ${ASKED.join('; ')}.\n`);
-        exit(0);
-    }
-    if (!does.includes(sub)) {
-        return say(`\`${sub}\` is not one of the ${String(does.length)} command(s) \`${mine.uses ?? ''}\` stated when \`${mine.id}\` ` +
-            `was declared. It declared: ${does.join(', ') || '(nothing)'}. If the tool has changed, read it again with ` +
-            `\`thread create target edit ${mine.id}\`.`);
-    }
-    if (reachOf(mine.id) === 'module') {
-        return run({ name, module: mine.uses ?? '', requires: mine.requires });
-    }
-    const went = spawnSync(mine.uses ?? '', passed, { cwd: tree.at, stdio: 'inherit' });
-    exit(went.status ?? 1);
-}
-export async function run(declared) {
-    const refuse = (because) => {
-        stderr.write(`${declared.name}: ${because}\n`);
-        exit(1);
-    };
-    const method = wordsIn([])[0];
-    if (method === undefined) {
-        return refuse(`takes the method to call, dot-separated for a namespaced one — e.g. \`thread run ${declared.name} customers.list\`.`);
-    }
-    if (!METHOD.test(method)) {
-        return refuse(`\`${method}\` is not a method path — one name, or names joined by dots, e.g. \`customers.list\``);
-    }
-    const piped = given();
-    unasked(piped, TAKES, `\`thread run ${declared.name} ${method}\``);
-    const { ask, shut } = asking(piped);
-    const typed = (piped.length > 0
-        ? (answer(piped, TAKES[0] ?? 'args') ?? '')
-        : await ask('args', 'args, as JSON — an array for positional arguments, anything else for one (blank for none): ')).trim();
-    shut();
-    let args = [];
-    if (typed !== '') {
-        let parsed;
-        try {
-            parsed = JSON.parse(typed);
-        }
-        catch (thrown) {
-            return refuse(`that is not JSON: ${thrown instanceof Error ? thrown.message : String(thrown)}. Nothing was called.`);
-        }
-        args = Array.isArray(parsed) ? parsed : [parsed];
-    }
-    const env = argv.includes(PRODUCTION) ? 'production' : 'sandbox';
-    const opening = opened(findTree().at, declared.requires, env);
-    let resolved;
-    try {
-        resolved = await opening(declared.requires);
-    }
-    catch (thrown) {
-        return refuse(thrown instanceof Error ? thrown.message : String(thrown));
-    }
-    const credentials = declared.requires.map((one) => resolved[one] ?? '');
-    let mod;
-    try {
-        mod = (await import(__rewriteRelativeImportExtension(declared.module)));
-    }
-    catch (thrown) {
-        return refuse(`\`${declared.module}\` could not be imported: ${thrown instanceof Error ? thrown.message : String(thrown)}. It was ` +
-            `installed when this was declared — if it is gone, \`npm install ${declared.module}\` puts it back.`);
-    }
-    const entry = mod.default ?? mod;
-    const asFunction = entry;
-    const asConstructor = entry;
-    const REACHES = new Set(['constructor', '__proto__', 'prototype']);
-    const client = typeof entry !== 'function' ? entry : isClass(asFunction) ? Reflect.construct(asConstructor, credentials) : asFunction(...credentials);
-    let owner = client;
-    let target = client;
-    for (const segment of method.split('.')) {
-        if (REACHES.has(segment)) {
-            return refuse(`\`${segment}\` is not an operation of \`${declared.module}\` — it is a step every JavaScript value has, and ` +
-                'walking to it leaves what was installed. What may run here is what the module exports, and a person fixed that ' +
-                'set when they declared it.');
-        }
-        owner = target;
-        target = target?.[segment];
-    }
-    if (typeof target !== 'function') {
-        return refuse(`\`${method}\` on \`${declared.module}\` is ${target === undefined ? 'nothing' : `a ${typeof target}`}, not a method that can be called`);
-    }
-    let result;
-    try {
-        result = await target.apply(owner, args);
-    }
-    catch (thrown) {
-        return refuse(`\`${method}\` on \`${declared.module}\` threw: ${thrown instanceof Error ? thrown.message : String(thrown)}`);
-    }
-    stdout.write(`${declared.name}: ${method} (${env})\n`);
-    try {
-        stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-    }
-    catch {
-        stdout.write(`${String(result)}\n`);
-    }
-    exit(0);
-}