@eighty4/c2 0.0.1 → 0.0.2-1

package/README.md

@@ -4,8 +4,6 @@ Blow up your `cloud-init` developer workflows!
 
 ## Getting started
 
-`c2` publishes only TypeScript requiring Node >=23 to run.
-
 ```shell
 npm i -g @eighty4/c2
 c2 -h

package/lib/attachments.spec.ts

@@ -0,0 +1,53 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { join } from 'node:path'
+import { collectAttachments } from '#c2/attachments.ts'
+import { makeFile, makeTempDir, removeDir } from '#c2/fs.testing.ts'
+
+let tmpDir: string
+
+beforeEach(async () => (tmpDir = await makeTempDir()))
+
+afterEach(async () => await removeDir(tmpDir))
+
+test('collect cloud config yml', async () => {
+    await makeFile('init-cloud.yml', 'whoopie', tmpDir)
+    expect(await collectAttachments(tmpDir)).toStrictEqual([
+        {
+            path: join(tmpDir, 'init-cloud.yml'),
+            content: 'whoopie',
+            filename: 'init-cloud.yml',
+            type: 'cloud-config',
+        },
+    ])
+})
+
+test('collect shell script', async () => {
+    await makeFile('init-cloud.sh', 'whoopie', tmpDir)
+    expect(await collectAttachments(tmpDir)).toStrictEqual([
+        {
+            path: join(tmpDir, 'init-cloud.sh'),
+            content: 'whoopie',
+            filename: 'init-cloud.sh',
+            type: 'x-shellscript',
+        },
+    ])
+})
+
+test('sorts attachments by filename', async () => {
+    await makeFile('01-init-cloud.sh', 'whoopie', tmpDir)
+    await makeFile('02-init-cloud.sh', 'whoopie', tmpDir)
+    expect(await collectAttachments(tmpDir)).toStrictEqual([
+        {
+            path: join(tmpDir, '01-init-cloud.sh'),
+            content: 'whoopie',
+            filename: '01-init-cloud.sh',
+            type: 'x-shellscript',
+        },
+        {
+            path: join(tmpDir, '02-init-cloud.sh'),
+            content: 'whoopie',
+            filename: '02-init-cloud.sh',
+            type: 'x-shellscript',
+        },
+    ])
+})

package/lib/build.spec.ts

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { buildUserData } from '#c2/build.ts'
+import { makeFile, makeTempDir, removeDir } from '#c2/fs.testing.ts'
+
+let tmpDir: string
+
+beforeEach(async () => {
+    tmpDir = await makeTempDir()
+})
+
+afterEach(async () => removeDir(tmpDir))
+
+test('build user data of single file', async () => {
+    const initCloudYml = 'whoopie'
+    await makeFile('init-cloud.yml', initCloudYml, tmpDir)
+    expect(await buildUserData(tmpDir)).toStrictEqual('whoopie')
+})
+
+test('build user data of single file with template expression', async () => {
+    const whoopie = await makeTempDir()
+    await makeFile('whoopie', 'whoopie', whoopie)
+    await makeFile(
+        'init-cloud.yml',
+        `\${{ file('${whoopie}/whoopie')}}`,
+        tmpDir,
+    )
+    expect(await buildUserData(tmpDir)).toStrictEqual('whoopie')
+    await removeDir(whoopie)
+})
+
+test('build user data multipart message', async () => {
+    await makeFile('1-init-cloud.yml', 'whoopie', tmpDir)
+    await makeFile('2-init-cloud.sh', 'cushion', tmpDir)
+    const boundary = Bun.randomUUIDv7()
+    expect(
+        await buildUserData(tmpDir, { attachmentBoundary: boundary }),
+    ).toStrictEqual(
+        `Content-Type: multipart/mixed; boundary=${boundary}
+MIME-Version: 1.0
+Number-Attachments: 2
+--${boundary}
+Content-Type: text/cloud-config; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="1-init-cloud.yml"
+
+whoopie
+--${boundary}
+Content-Type: text/x-shellscript; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="2-init-cloud.sh"
+
+cushion
+--${boundary}
+`,
+    )
+})
+
+test('build user data multipart with template expression', async () => {
+    const whoopie = await makeTempDir()
+    await makeFile('whoopie', 'whoopie', whoopie)
+    await makeFile(
+        '1-init-cloud.yml',
+        `\${{ file('${whoopie}/whoopie')}}`,
+        tmpDir,
+    )
+    await makeFile('2-init-cloud.sh', 'cushion', tmpDir)
+    const boundary = Bun.randomUUIDv7()
+    expect(
+        await buildUserData(tmpDir, { attachmentBoundary: boundary }),
+    ).toStrictEqual(
+        `Content-Type: multipart/mixed; boundary=${boundary}
+MIME-Version: 1.0
+Number-Attachments: 2
+--${boundary}
+Content-Type: text/cloud-config; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="1-init-cloud.yml"
+
+whoopie
+--${boundary}
+Content-Type: text/x-shellscript; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="2-init-cloud.sh"
+
+cushion
+--${boundary}
+`,
+    )
+})

package/lib/c2.api.ts

@@ -0,0 +1 @@
+export { type BuildUserDataOpts, buildUserData } from '#c2/build.ts'

package/lib/cli.spec.ts

@@ -0,0 +1,70 @@
+import { expect, test } from 'bun:test'
+import { parseArgs } from '#c2/cli.ts'
+
+test('parseArgs', () => {
+    expect(
+        parseArgs([
+            '/Users/who/.bun/bin/bun',
+            '/Users/who/user-data/c2.ts',
+            'user_data_dir',
+        ]),
+    ).toStrictEqual({
+        base64: false,
+        userDataDir: 'user_data_dir',
+    })
+})
+
+test('parseArgs errors without USER_DATA_DIR', () => {
+    expect(() =>
+        parseArgs(['/Users/who/.bun/bin/bun', '/Users/who/user-data/c2.ts']),
+    ).toThrow()
+})
+
+test('parseArgs errors with extra USER_DATA_DIR', () => {
+    expect(() =>
+        parseArgs([
+            '/Users/who/.bun/bin/bun',
+            '/Users/who/user-data/c2.ts',
+            'user_data_dir',
+            'some_other_arg',
+        ]),
+    ).toThrow('')
+})
+
+test('parseArgs with --base64', () => {
+    expect(
+        parseArgs([
+            '/Users/who/.bun/bin/bun',
+            '/Users/who/user-data/c2.ts',
+            '--base64',
+            'user_data_dir',
+        ]),
+    ).toStrictEqual({
+        base64: true,
+        userDataDir: 'user_data_dir',
+    })
+})
+
+test('parseArgs with --http PORT', () => {
+    expect(
+        parseArgs([
+            '/Users/who/.bun/bin/bun',
+            '/Users/who/user-data/c2.ts',
+            '--http',
+            '6666',
+            'user_data_dir',
+        ]),
+    ).toStrictEqual({ httpPort: 6666, userDataDir: 'user_data_dir' })
+})
+
+test('parseArgs with --http bunk', () => {
+    expect(() =>
+        parseArgs([
+            '/Users/who/.bun/bin/bun',
+            '/Users/who/user-data/c2.ts',
+            '--http',
+            'bunk',
+            'user_data_dir',
+        ]),
+    ).toThrow('--http bunk is not a valid http port')
+})

package/lib/expression.spec.ts

@@ -0,0 +1,74 @@
+import { afterAll, afterEach, beforeEach, expect, test } from 'bun:test'
+import { join } from 'node:path'
+import { evalTemplateExpressions } from '#c2/expression.ts'
+import { makeFile, makeTempDir, removeDir } from '#c2/fs.testing.ts'
+
+let files: Array<string> = []
+let tmpDir: string
+
+beforeEach(async () => (tmpDir = await makeTempDir()))
+
+afterEach(async () => await removeDir(tmpDir))
+
+afterAll(async () => {
+    for (const p of files) {
+        await Bun.file(p).delete()
+    }
+})
+
+test('env() found', async () => {
+    const envVar = 'C2_TEST_' + Bun.randomUUIDv7().substring(0, 8).toUpperCase()
+    Bun.env[envVar] = Bun.randomUUIDv7()
+    expect(await evalTemplateExpressions(`\${{ env('${envVar}') }}`)).toBe(
+        Bun.env[envVar],
+    )
+    delete Bun.env[envVar]
+})
+
+test('env() not found', async () => {
+    const envVar = 'C2_TEST_' + Bun.randomUUIDv7().substring(0, 8).toUpperCase()
+    expect(() => evalTemplateExpressions(` \${{ env('${envVar}') }}`)).toThrow(
+        `env var \`${envVar}\` does not exist`,
+    )
+})
+
+test('file() not found', async () => {
+    const path = join(await makeTempDir(), 'whoopie')
+    expect(() => evalTemplateExpressions(`\${{ file('${path}') }}`)).toThrow(
+        `ENOENT: no such file or directory, open '${path}'`,
+    )
+})
+
+test('file() absolute', async () => {
+    const content = Bun.randomUUIDv7()
+    const path = await makeFile('.user-data', content, tmpDir)
+    expect(await evalTemplateExpressions(`\${{ file('${path}') }}`)).toBe(
+        content,
+    )
+})
+
+test('file() home', async () => {
+    const content = Bun.randomUUIDv7()
+    const filename = `.user-data.${Bun.randomUUIDv7()}`
+    const path = join(Bun.env.HOME!, filename)
+    await makeFile(path, content)
+    files.push(path)
+    expect(await evalTemplateExpressions(`\${{ file('~/${filename}') }}`)).toBe(
+        content,
+    )
+})
+
+test('file() relative', async () => {
+    const content = Bun.randomUUIDv7()
+    const filename = `.user-data.${Bun.randomUUIDv7()}`
+    await makeFile(filename, content, tmpDir)
+    const prevPwd = process.cwd()
+    process.chdir(tmpDir)
+    try {
+        expect(
+            await evalTemplateExpressions(`\${{ file('${filename}') }}`),
+        ).toBe(content)
+    } finally {
+        process.chdir(prevPwd)
+    }
+})

package/lib/fs.testing.ts

@@ -0,0 +1,21 @@
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+export async function makeFile(
+    path: string,
+    content: string,
+    pathPrefix?: string,
+): Promise<string> {
+    const p = !!pathPrefix ? join(pathPrefix, path) : path
+    await Bun.file(p).write(content)
+    return p
+}
+
+export async function makeTempDir(): Promise<string> {
+    return await mkdtemp(join(tmpdir(), 'c2-test-'))
+}
+
+export async function removeDir(p: string): Promise<void> {
+    await rm(p, { force: true, recursive: true })
+}

package/lib_js/attachments.js

@@ -0,0 +1,31 @@
+import { readDirListing, readToString } from '#c2/fs.ts';
+export async function collectAttachments(dir) {
+    const result = [];
+    for (const filename of await readDirListing(dir)) {
+        const path = `${dir}/${filename}`;
+        const content = await readToString(path);
+        const type = resolveAttachmentType(filename, content);
+        result.push({ content, filename, path, type });
+    }
+    return result.sort(compareAttachmentFilenames);
+}
+function compareAttachmentFilenames(a1, a2) {
+    if (a1.filename === a2.filename)
+        return 0;
+    if (a1.filename > a2.filename)
+        return 1;
+    return -1;
+}
+export function resolveAttachmentType(filename, content) {
+    if (filename.endsWith('.yml') ||
+        (filename.endsWith('.yaml') &&
+            content.trim().startsWith('#cloud-config'))) {
+        return 'cloud-config';
+    }
+    else if (filename.endsWith('.sh')) {
+        return 'x-shellscript';
+    }
+    else {
+        throw new Error(`unsupported file type ${filename}`);
+    }
+}

package/lib_js/build.js

@@ -0,0 +1,42 @@
+import { collectAttachments } from '#c2/attachments.ts';
+import { evalTemplateExpressions } from '#c2/expression.ts';
+import { readToString } from '#c2/fs.ts';
+export async function buildUserData(userDataDir, opts) {
+    const attachments = await collectAttachments(userDataDir);
+    switch (attachments.length) {
+        case 0:
+            throw new Error(`nothing found in dir ${userDataDir}`);
+        case 1:
+            return evalTemplateExpressions(await readToString(attachments[0].path));
+        default:
+            return buildMultipartUserData(attachments, opts?.attachmentBoundary);
+    }
+}
+function createBoundary() {
+    return new Date().toISOString();
+}
+async function buildMultipartUserData(attachments, boundary = createBoundary()) {
+    let result = `Content-Type: multipart/mixed; boundary=${boundary}
+MIME-Version: 1.0
+Number-Attachments: ${attachments.length}
+--${boundary}
+`;
+    for (const attachment of attachments) {
+        let content;
+        try {
+            content = await evalTemplateExpressions(attachment.content);
+        }
+        catch (e) {
+            throw new Error(`error templating ${attachment.filename}: ${e.message}`);
+        }
+        result += `Content-Type: text/${attachment.type}; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="${attachment.filename}"
+
+${content}
+--${boundary}
+`;
+    }
+    return result;
+}

package/lib_js/c2.api.js

@@ -0,0 +1 @@
+export { buildUserData } from '#c2/build.ts';

package/lib_js/c2.bin.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { buildUserData } from '#c2/build.ts';
+import { parseArgs } from '#c2/cli.ts';
+import { doesDirExist } from '#c2/fs.ts';
+let args;
+try {
+    args = parseArgs();
+}
+catch (e) {
+    if (e.message) {
+        console.error(e.message);
+    }
+}
+if (!args || args.help) {
+    const optional = (s) => `\u001b[90m${s}\u001b[0m`;
+    const required = (s) => `\u001b[1m${s}\u001b[0m`;
+    errorExit(`c2 ${optional('[[--base64] | [--http PORT]]')} ${required('USER_DATA_DIR')}`);
+}
+if (args.httpPort) {
+    errorExit('--http PORT is not yet implemented');
+}
+if (!(await doesDirExist(args.userDataDir))) {
+    errorExit(`${args.userDataDir} directory does not exist`);
+}
+try {
+    const userData = await buildUserData(args.userDataDir);
+    console.log(args.base64 ? btoa(userData) : userData);
+}
+catch (e) {
+    errorExit(e.message);
+}
+function errorExit(msg) {
+    console.error(msg);
+    process.exit(1);
+}

package/lib_js/cli.js

@@ -0,0 +1,44 @@
+export function parseArgs(args) {
+    if (!args) {
+        args = process.argv;
+    }
+    args = [...args];
+    while (!args.shift().endsWith('/c2.ts')) { }
+    let base64 = false;
+    let httpPort;
+    let userData = [];
+    let expectHttpPort = false;
+    for (const arg of args) {
+        if (expectHttpPort) {
+            expectHttpPort = false;
+            httpPort = parseInt(arg, 10);
+            if (isNaN(httpPort)) {
+                throw new Error(`--http ${arg} is not a valid http port`);
+            }
+        }
+        else if (arg === '-h' || arg === '--help') {
+            return { help: true };
+        }
+        else if (arg === '--base64') {
+            base64 = true;
+        }
+        else if (arg === '--http') {
+            expectHttpPort = true;
+        }
+        else {
+            userData.push(arg);
+        }
+    }
+    switch (userData.length) {
+        case 1:
+            const userDataDir = userData[0];
+            if (typeof httpPort !== 'undefined') {
+                return { httpPort, userDataDir };
+            }
+            else {
+                return { base64, userDataDir };
+            }
+        default:
+            throw new Error();
+    }
+}

package/lib_js/expression.js

@@ -0,0 +1,47 @@
+import MagicString from 'magic-string';
+import { readToString } from '#c2/fs.ts';
+export async function evalTemplateExpressions(content) {
+    const regex = new RegExp(/\${{\s*(.*)\s*}}/g);
+    let match;
+    const expressions = [];
+    while ((match = regex.exec(content)) != null) {
+        expressions.push({
+            index: match.index,
+            innie: match[1],
+            outie: match[0],
+        });
+    }
+    if (!expressions.length) {
+        return content;
+    }
+    const ms = new MagicString(content);
+    for (const expression of expressions) {
+        ms.update(expression.index, expression.index + expression.outie.length, await evaluate(expression.innie));
+    }
+    return ms.toString();
+}
+async function evaluate(expression) {
+    let match;
+    if ((match = expression.match(/env\(\s*'(.*)'\s*\)/)) != null) {
+        const envVarKey = match[1];
+        if (!/[A-Z_]+/.test(envVarKey)) {
+            throw new Error(`env var expression \`${envVarKey}\` is not valid syntax`);
+        }
+        const envVarValue = process.env[envVarKey];
+        if (!envVarValue) {
+            throw new Error(`env var \`${envVarKey}\` does not exist`);
+        }
+        return envVarValue;
+    }
+    else if ((match = expression.match(/file\(\s*'(.*)'\s*\)/)) != null) {
+        let path = match[1];
+        if (path.startsWith('~/')) {
+            if (!process.env.HOME) {
+                throw new Error(`file \`${path}\` cannot be resolved without env var HOME`);
+            }
+            path = `${process.env.HOME}${path.substring(1)}`;
+        }
+        return readToString(path);
+    }
+    throw new Error(`unsupported expression: ${expression}`);
+}

package/lib_js/fs.js

@@ -0,0 +1,15 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+export async function doesDirExist(p) {
+    try {
+        return (await stat(p)).isDirectory();
+    }
+    catch (ignore) {
+        return false;
+    }
+}
+export async function readDirListing(p) {
+    return readdir(p);
+}
+export async function readToString(p) {
+    return readFile(p, 'utf8');
+}

package/lib_js/fs.testing.js

@@ -0,0 +1,14 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export async function makeFile(path, content, pathPrefix) {
+    const p = !!pathPrefix ? join(pathPrefix, path) : path;
+    await Bun.file(p).write(content);
+    return p;
+}
+export async function makeTempDir() {
+    return await mkdtemp(join(tmpdir(), 'c2-test-'));
+}
+export async function removeDir(p) {
+    await rm(p, { force: true, recursive: true });
+}

package/lib_types/attachments.d.ts

@@ -0,0 +1,10 @@
+export type AttachmentType = 'cloud-config' | 'x-shellscript';
+export interface Attachment {
+    path: string;
+    content: string;
+    filename: string;
+    type: AttachmentType;
+}
+export declare function collectAttachments(dir: string): Promise<Array<Attachment>>;
+export declare function resolveAttachmentType(filename: string, content: string): AttachmentType;
+//# sourceMappingURL=attachments.d.ts.map

package/lib_types/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../lib/attachments.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,eAAe,CAAA;AAE7D,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,cAAc,CAAA;CACvB;AAED,wBAAsB,kBAAkB,CACpC,GAAG,EAAE,MAAM,GACZ,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAS5B;AAWD,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GAChB,cAAc,CAYhB"}

package/lib_types/build.d.ts

@@ -0,0 +1,5 @@
+export type BuildUserDataOpts = {
+    attachmentBoundary?: string;
+};
+export declare function buildUserData(userDataDir: string, opts?: BuildUserDataOpts): Promise<string>;
+//# sourceMappingURL=build.d.ts.map

package/lib_types/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../lib/build.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,iBAAiB,GAAG;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED,wBAAsB,aAAa,CAC/B,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,iBAAiB,GACzB,OAAO,CAAC,MAAM,CAAC,CAYjB"}

package/lib_types/c2.api.d.ts

@@ -0,0 +1,2 @@
+export { type BuildUserDataOpts, buildUserData } from '#c2/build.ts';
+//# sourceMappingURL=c2.api.d.ts.map

package/lib_types/c2.api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c2.api.d.ts","sourceRoot":"","sources":["../lib/c2.api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA"}

package/lib_types/c2.bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=c2.bin.d.ts.map

package/lib_types/c2.bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c2.bin.d.ts","sourceRoot":"","sources":["../lib/c2.bin.ts"],"names":[],"mappings":""}

package/lib_types/cli.d.ts

@@ -0,0 +1,10 @@
+export type ParsedArgs = {
+    help: true;
+} | {
+    help?: false;
+    base64?: boolean;
+    httpPort?: number;
+    userDataDir: string;
+};
+export declare function parseArgs(args?: Array<string>): ParsedArgs;
+//# sourceMappingURL=cli.d.ts.map

package/lib_types/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../lib/cli.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAChB;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACd;IACI,IAAI,CAAC,EAAE,KAAK,CAAA;IACZ,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACtB,CAAA;AAEP,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,UAAU,CAsC1D"}

package/lib_types/expression.d.ts

@@ -0,0 +1,2 @@
+export declare function evalTemplateExpressions(content: string): Promise<string>;
+//# sourceMappingURL=expression.d.ts.map

package/lib_types/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../lib/expression.ts"],"names":[],"mappings":"AASA,wBAAsB,uBAAuB,CACzC,OAAO,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,CAuBjB"}

package/lib_types/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function doesDirExist(p: string): Promise<boolean>;
+export declare function readDirListing(p: string): Promise<Array<string>>;
+export declare function readToString(p: string): Promise<string>;
+//# sourceMappingURL=fs.d.ts.map

package/lib_types/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../lib/fs.ts"],"names":[],"mappings":"AAEA,wBAAsB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAM9D;AAED,wBAAsB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAEtE;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAE7D"}

package/lib_types/fs.testing.d.ts

@@ -0,0 +1,4 @@
+export declare function makeFile(path: string, content: string, pathPrefix?: string): Promise<string>;
+export declare function makeTempDir(): Promise<string>;
+export declare function removeDir(p: string): Promise<void>;
+//# sourceMappingURL=fs.testing.d.ts.map

package/lib_types/fs.testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.testing.d.ts","sourceRoot":"","sources":["../lib/fs.testing.ts"],"names":[],"mappings":"AAIA,wBAAsB,QAAQ,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAEnD;AAED,wBAAsB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExD"}

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@eighty4/c2",
-  "version": "0.0.1",
+  "version": "0.0.2-1",
   "author": "Adam McKee <adam.be.g84d@gmail.com>",
   "repository": "https://github.com/eighty4/c2",
   "homepage": "https://github.com/eighty4/c2",
   "keywords": [
     "devops",
-    "cloud init",
+    "cloud-init",
     "cloud config",
-    "user data"
+    "user data",
+    "linux",
+    "cloud"
   ],
   "description": "Cross platform cloud config tooling for cloud-init",
   "license": "BSD-2-Clause",
@@ -17,20 +19,19 @@
     "bun": ">=1.2",
     "node": ">=23"
   },
-  "main": "lib/build.ts",
   "bin": {
-    "c2": "./c2.ts"
+    "c2": "./lib_js/c2.bin.js"
   },
+  "main": "./lib_js/c2.api.js",
+  "imports": {
+    "#c2/*.js": "./lib_js/*.js",
+    "#c2/*.ts": "./lib/*.ts"
+  },
+  "types": "./lib_types",
   "scripts": {
+    "build": "tsc",
     "fmtcheck": "prettier --check .",
-    "typecheck": "tsc"
-  },
-  "imports": {
-    "#c2/fs.ts": {
-      "bun": "./lib/fs.bun.ts",
-      "node": "./lib/fs.node.ts"
-    },
-    "#c2/*": "./lib/*"
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "magic-string": "0.30.17"
@@ -42,10 +43,9 @@
     "typescript": "5.8.2"
   },
   "files": [
-    "lib/**/*.ts",
-    "!lib/**/*.spec.ts",
-    "!lib/fs.testing.ts",
-    "CHANGELOG.md",
-    "c2.ts"
+    "lib/*",
+    "lib_js/*",
+    "lib_types/*",
+    "CHANGELOG.md"
   ]
 }

package/lib/fs.bun.ts

@@ -1,5 +0,0 @@
-export { doesDirExist, readDirListing } from '#c2/fs.node.ts'
-
-export async function readToString(p: string): Promise<string> {
-    return Bun.file(p).text()
-}