@phyzess/pappra 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/hosts/integration/bundle-export.js

@@ -0,0 +1,128 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { getPackageRoot } from '../../package-info.js';
+import { isPathInside } from '../../schemas/paths.js';
+import { loadHostBundle } from './bundle.js';
+import { renderHookConfigPatch } from './templates.js';
+function pluginHookExpression(host) {
+    return host === 'claude'
+        ? '${CLAUDE_PLUGIN_ROOT}/hooks/pappra-hook.mjs'
+        : './hooks/pappra-hook.mjs';
+}
+function hostManifest(host, version) {
+    if (host === 'claude' || host === 'codex') {
+        // Codex reads the Claude plugin manifest path, so one manifest serves both.
+        return {
+            path: '.claude-plugin/plugin.json',
+            value: {
+                name: 'pappra',
+                version,
+                description: 'Portable workspace knowledge and continuity for coding agents.',
+                author: { name: 'phyzess' },
+                hooks: './hooks/hooks.json',
+            },
+        };
+    }
+    return {
+        path: 'package.json',
+        value: {
+            name: '@phyzess/pappra-pi',
+            version,
+            description: 'Pappra Pi package: bounded lifecycle hooks and skill.',
+            type: 'module',
+            pi: {
+                extensions: ['./extensions/pappra/index.ts'],
+                skills: ['./skills'],
+            },
+            peerDependencies: { '@earendil-works/pi-coding-agent': '*' },
+        },
+    };
+}
+/**
+ * Writes a host-native plugin/package directory. This is an artifact export: it
+ * does not register the plugin with a host, and it never claims the host will
+ * load or trust it.
+ */
+export async function exportHostPluginBundle(options) {
+    const outRoot = resolve(options.outDir);
+    if (options.marketplace === true && options.host === 'pi') {
+        throw new Error('Pi installs a directory directly; a marketplace wrapper is not supported.');
+    }
+    const pluginPrefix = options.marketplace === true ? 'pappra/' : '';
+    const pluginRoot = options.marketplace === true ? join(outRoot, 'pappra') : outRoot;
+    const payload = await loadHostBundle(options.host, options.packageVersion, {
+        hookSource: join(getPackageRoot(), 'dist/hosts/integration/pappra-hook.mjs'),
+        hookExpression: pluginHookExpression(options.host),
+    });
+    const written = [];
+    const writeEntry = async (path, bytes) => {
+        const target = join(outRoot, ...path.split('/'));
+        if (!isPathInside(outRoot, target)) {
+            throw new Error(`Unsafe plugin bundle path: ${path}`);
+        }
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, bytes);
+        written.push(path);
+    };
+    for (const [path, bytes] of payload.contents) {
+        // Plugin manifests point at hooks/hooks.json directly; the rendered
+        // templates are only an intermediate artifact.
+        if (path.startsWith('templates/'))
+            continue;
+        await writeEntry(`${pluginPrefix}${path}`, bytes);
+    }
+    const expression = pluginHookExpression(options.host);
+    if (options.host === 'pi') {
+        const entry = payload.contents.get('templates/pi/entry.ts');
+        const runtime = payload.contents.get('templates/pi/runtime.mjs');
+        if (entry === undefined || runtime === undefined) {
+            throw new Error('Pi plugin bundle is missing its extension entry.');
+        }
+        // The generated entry imports ./runtime.mjs, so both files share one directory.
+        await writeEntry(`${pluginPrefix}extensions/pappra/index.ts`, entry);
+        await writeEntry(`${pluginPrefix}extensions/pappra/runtime.mjs`, runtime);
+    }
+    else {
+        const patch = renderHookConfigPatch(options.host, expression);
+        await writeEntry(`${pluginPrefix}hooks/hooks.json`, Buffer.from(`${JSON.stringify(patch, null, 2)}\n`));
+    }
+    const manifest = hostManifest(options.host, options.packageVersion);
+    await writeEntry(`${pluginPrefix}${manifest.path}`, Buffer.from(`${JSON.stringify(manifest.value, null, 2)}\n`));
+    if (options.marketplace === true) {
+        await writeEntry('.claude-plugin/marketplace.json', Buffer.from(`${JSON.stringify({
+            name: 'pappra-local',
+            owner: { name: 'phyzess' },
+            description: 'Local Pappra plugin marketplace exported by pappra host bundle.',
+            plugins: [
+                {
+                    name: 'pappra',
+                    source: './pappra',
+                    description: 'Portable workspace knowledge and continuity for coding agents.',
+                    author: { name: 'phyzess' },
+                },
+            ],
+        }, null, 2)}\n`));
+    }
+    return {
+        host: options.host,
+        outDir: pluginRoot,
+        files: written.sort((left, right) => left.localeCompare(right)),
+        pluginManifest: `${pluginPrefix}${manifest.path}`,
+        hookConfig: options.host === 'pi' ? null : `${pluginPrefix}hooks/hooks.json`,
+        registration: options.host === 'claude'
+            ? [
+                'Register the directory as a local plugin or marketplace entry; Pappra does not add it to host settings.',
+                'Claude Code substitutes ${CLAUDE_PLUGIN_ROOT} at hook execution time.',
+            ]
+            : options.host === 'codex'
+                ? [
+                    'Package the directory as a Codex plugin; hook paths are relative to the plugin root.',
+                    'Review the plugin before trusting it; Pappra does not install or trust it.',
+                ]
+                : [
+                    'Install the directory as a Pi package, for example `pi install ./pappra-pi`.',
+                    'Pi installs package dependencies and requires project trust before loading.',
+                ],
+        verification: 'unsupported',
+    };
+}

package/dist/hosts/integration/bundle.d.ts

@@ -11,6 +11,9 @@ export declare function installPathForBundleFile(host: HostName, sourcePath: str
  */
 export declare function loadHostBundle(host: HostName, packageVersion: string, options?: {
     readonly assetsRoot?: string;
-    readonly runtimeEntry?: string;
+    /** Absolute path of the bundled, dependency-free hook file. */
+    readonly hookSource?: string;
+    /** Command-line path expression used inside the host hook configuration. */
+    readonly hookExpression?: string;
     readonly observedAt?: string;
 }): Promise<HostBundlePayload>;

package/dist/hosts/integration/bundle.js

@@ -55,8 +55,26 @@ export async function loadHostBundle(host, packageVersion, options = {}) {
             kind: source.endsWith('/SKILL.md') ? 'skill' : 'reference',
         });
     }
-    const template = renderHostTemplate(host, options.runtimeEntry ??
-        join(packageRoot(), 'dist/hosts/integration/hook-entry.js'));
+    const hookSource = options.hookSource ??
+        join(packageRoot(), 'dist/hosts/integration/pappra-hook.mjs');
+    const hookBytes = await readFile(hookSource);
+    contents.set('hooks/pappra-hook.mjs', hookBytes);
+    files.push({
+        path: 'hooks/pappra-hook.mjs',
+        digest: sha256Digest(hookBytes),
+        kind: 'hook',
+    });
+    if (host === 'pi') {
+        const runtimePath = join(dirname(hookSource), 'pappra-extension-runtime.mjs');
+        const runtimeBytes = await readFile(runtimePath);
+        contents.set('templates/pi/runtime.mjs', runtimeBytes);
+        files.push({
+            path: 'templates/pi/runtime.mjs',
+            digest: sha256Digest(runtimeBytes),
+            kind: 'extension',
+        });
+    }
+    const template = renderHostTemplate(host, options.hookExpression ?? hookSource);
     contents.set(template.path, template.bytes);
     files.push({
         path: template.path,