@hotmeshio/long-tail 0.1.14 → 0.1.15

package/build/examples/seed-data.d.ts

@@ -0,0 +1,55 @@
+import type { LTEnvelope } from '../types';
+export declare const SEED_USERS: ({
+    external_id: string;
+    display_name: string;
+    email: string;
+    password: string;
+    roles: {
+        role: string;
+        type: "superadmin";
+    }[];
+    oauth_provider?: undefined;
+    oauth_provider_id?: undefined;
+} | {
+    external_id: string;
+    display_name: string;
+    email: string;
+    password: string;
+    roles: {
+        role: string;
+        type: "admin";
+    }[];
+    oauth_provider?: undefined;
+    oauth_provider_id?: undefined;
+} | {
+    external_id: string;
+    display_name: string;
+    email: string;
+    password: string;
+    roles: {
+        role: string;
+        type: "member";
+    }[];
+    oauth_provider?: undefined;
+    oauth_provider_id?: undefined;
+} | {
+    external_id: string;
+    display_name: string;
+    email: string;
+    password: string;
+    oauth_provider: string;
+    oauth_provider_id: string;
+    roles: {
+        role: string;
+        type: "superadmin";
+    }[];
+})[];
+export declare const SEED_ROLES: string[];
+export type SeedWorkflowName = 'reviewContent' | 'kitchenSink' | 'basicEcho' | 'basicSignal';
+export declare const SEED_ENVELOPES: Array<{
+    workflowName: SeedWorkflowName;
+    taskQueue: string;
+    envelope: LTEnvelope;
+    label: string;
+}>;
+export declare const SEED_CHAINS: string[][];

package/build/examples/seed-data.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEED_CHAINS = exports.SEED_ENVELOPES = exports.SEED_ROLES = exports.SEED_USERS = void 0;
+// ── Seed users ───────────────────────────────────────────────────────────────
+exports.SEED_USERS = [
+    {
+        external_id: 'superadmin',
+        display_name: 'Super Admin',
+        email: 'admin@longtail.local',
+        password: 'l0ngt@1l',
+        roles: [{ role: 'superadmin', type: 'superadmin' }],
+    },
+    {
+        external_id: 'admin',
+        display_name: 'Admin User',
+        email: 'admin-user@longtail.local',
+        password: 'l0ngt@1l',
+        roles: [{ role: 'admin', type: 'admin' }],
+    },
+    {
+        external_id: 'engineer',
+        display_name: 'Engineer User',
+        email: 'engineer@longtail.local',
+        password: 'l0ngt@1l',
+        roles: [{ role: 'engineer', type: 'member' }],
+    },
+    {
+        external_id: 'reviewer',
+        display_name: 'Reviewer User',
+        email: 'reviewer@longtail.local',
+        password: 'l0ngt@1l',
+        roles: [{ role: 'reviewer', type: 'member' }],
+    },
+    {
+        external_id: 'mock:test-user-1',
+        display_name: 'Alice Test',
+        email: 'alice@test.local',
+        password: 'l0ngt@1l',
+        oauth_provider: 'mock',
+        oauth_provider_id: 'test-user-1',
+        roles: [{ role: 'superadmin', type: 'superadmin' }],
+    },
+];
+exports.SEED_ROLES = ['reviewer', 'engineer', 'admin', 'superadmin'];
+exports.SEED_ENVELOPES = [
+    // -- Process 1: Clean Review
+    {
+        label: 'Process 1 — Clean Review',
+        workflowName: 'reviewContent',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                contentId: 'process-clean-001',
+                content: 'This is a well-researched article about renewable energy solutions for urban environments. It covers solar panels, wind turbines, and energy storage with thorough citations and balanced analysis.',
+                contentType: 'article',
+            },
+            metadata: {
+                source: 'seed',
+                process: 'clean-review',
+                description: 'Happy path — AI auto-approves high-quality content',
+            },
+        },
+    },
+    // -- Process 2: Flagged for Review
+    {
+        label: 'Process 2 — Flagged for Review',
+        workflowName: 'reviewContent',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                contentId: 'process-flagged-001',
+                content: 'REVIEW_ME This user-submitted blog post discusses alternative medicine claims without citing peer-reviewed sources. The AI flagged it for human review.',
+                contentType: 'blog_post',
+            },
+            metadata: {
+                source: 'seed',
+                process: 'flagged-review',
+                description: 'AI flags content for human review. Log in as reviewer (reviewer/l0ngt@1l) and approve or reject.',
+            },
+        },
+    },
+    // -- Process 3: Wrong Language -> Durable MCP
+    {
+        label: 'Process 3 — Wrong Language',
+        workflowName: 'reviewContent',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                contentId: 'process-language-001',
+                content: 'WRONG_LANGUAGE La energía renovable es el futuro de las ciudades sostenibles. Los paneles solares y las turbinas eólicas pueden reducir significativamente la huella de carbono urbana cuando se combinan con sistemas modernos de almacenamiento de energía.',
+                contentType: 'article',
+            },
+            metadata: {
+                source: 'seed',
+                process: 'wrong-language',
+                description: 'Content arrived in the wrong language. Walk the escalation chain: reviewer → admin → engineer. As engineer, check "Request AI Triage" and describe: "Content is in Spanish, needs translation to English."',
+            },
+        },
+    },
+    // -- Process 4: Kitchen Sink -> Dynamic Triage
+    {
+        label: 'Process 4 — Dynamic Triage',
+        workflowName: 'kitchenSink',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                name: 'Triage Demo',
+                mode: 'full',
+            },
+            metadata: {
+                source: 'seed',
+                process: 'dynamic-triage',
+                description: 'As reviewer, check "Request AI Triage" and write: "This looks fine, just approve it."',
+            },
+        },
+    },
+    // -- Process 5: Basic Echo
+    {
+        label: 'Process 5 — Basic Echo',
+        workflowName: 'basicEcho',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                message: 'Hello from the seed!',
+                sleepSeconds: 2,
+            },
+            metadata: {
+                source: 'seed',
+                process: 'basic-echo',
+                description: 'Minimal durable workflow — echoes a message and reveals IAM context.',
+            },
+        },
+    },
+    // -- Process 6: Basic Signal
+    {
+        label: 'Process 6 — Basic Signal',
+        workflowName: 'basicSignal',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                message: 'Seed deployment needs approval before proceeding.',
+                role: 'reviewer',
+            },
+            metadata: {
+                certified: false,
+                source: 'seed',
+                process: 'basic-signal',
+                description: 'Lightweight signal-based escalation — workflow stays running, no interceptor. Claim the escalation, fill the form, and resolve to resume the workflow.',
+            },
+        },
+    },
+];
+// Escalation chains: reviewer -> admin -> engineer (and cross-links)
+exports.SEED_CHAINS = [
+    ['reviewer', 'admin'],
+    ['reviewer', 'engineer'],
+    ['admin', 'engineer'],
+    ['admin', 'superadmin'],
+    ['engineer', 'admin'],
+    ['engineer', 'superadmin'],
+];

package/build/examples/seed.js

@@ -8,176 +8,19 @@ const db_1 = require("../lib/db");
 const user_1 = require("../services/user");
 const roles_1 = require("../services/user/roles");
 const role_1 = require("../services/role");
-// ── Seed users ───────────────────────────────────────────────────────────────
-const SEED_USERS = [
-    {
-        external_id: 'superadmin',
-        display_name: 'Super Admin',
-        email: 'admin@longtail.local',
-        password: 'l0ngt@1l',
-        roles: [{ role: 'superadmin', type: 'superadmin' }],
-    },
-    {
-        external_id: 'admin',
-        display_name: 'Admin User',
-        email: 'admin-user@longtail.local',
-        password: 'l0ngt@1l',
-        roles: [{ role: 'admin', type: 'admin' }],
-    },
-    {
-        external_id: 'engineer',
-        display_name: 'Engineer User',
-        email: 'engineer@longtail.local',
-        password: 'l0ngt@1l',
-        roles: [{ role: 'engineer', type: 'member' }],
-    },
-    {
-        external_id: 'reviewer',
-        display_name: 'Reviewer User',
-        email: 'reviewer@longtail.local',
-        password: 'l0ngt@1l',
-        roles: [{ role: 'reviewer', type: 'member' }],
-    },
-    {
-        external_id: 'mock:test-user-1',
-        display_name: 'Alice Test',
-        email: 'alice@test.local',
-        password: 'l0ngt@1l',
-        oauth_provider: 'mock',
-        oauth_provider_id: 'test-user-1',
-        roles: [{ role: 'superadmin', type: 'superadmin' }],
-    },
-];
-const SEED_ROLES = ['reviewer', 'engineer', 'admin', 'superadmin'];
-const SEED_ENVELOPES = [
-    // -- Process 1: Clean Review
-    {
-        label: 'Process 1 — Clean Review',
-        workflowName: 'reviewContent',
-        taskQueue: 'long-tail-examples',
-        envelope: {
-            data: {
-                contentId: 'process-clean-001',
-                content: 'This is a well-researched article about renewable energy solutions for urban environments. It covers solar panels, wind turbines, and energy storage with thorough citations and balanced analysis.',
-                contentType: 'article',
-            },
-            metadata: {
-                source: 'seed',
-                process: 'clean-review',
-                description: 'Happy path — AI auto-approves high-quality content',
-            },
-        },
-    },
-    // -- Process 2: Flagged for Review
-    {
-        label: 'Process 2 — Flagged for Review',
-        workflowName: 'reviewContent',
-        taskQueue: 'long-tail-examples',
-        envelope: {
-            data: {
-                contentId: 'process-flagged-001',
-                content: 'REVIEW_ME This user-submitted blog post discusses alternative medicine claims without citing peer-reviewed sources. The AI flagged it for human review.',
-                contentType: 'blog_post',
-            },
-            metadata: {
-                source: 'seed',
-                process: 'flagged-review',
-                description: 'AI flags content for human review. Log in as reviewer (reviewer/l0ngt@1l) and approve or reject.',
-            },
-        },
-    },
-    // -- Process 3: Wrong Language -> Durable MCP
-    {
-        label: 'Process 3 — Wrong Language',
-        workflowName: 'reviewContent',
-        taskQueue: 'long-tail-examples',
-        envelope: {
-            data: {
-                contentId: 'process-language-001',
-                content: 'WRONG_LANGUAGE La energía renovable es el futuro de las ciudades sostenibles. Los paneles solares y las turbinas eólicas pueden reducir significativamente la huella de carbono urbana cuando se combinan con sistemas modernos de almacenamiento de energía.',
-                contentType: 'article',
-            },
-            metadata: {
-                source: 'seed',
-                process: 'wrong-language',
-                description: 'Content arrived in the wrong language. Walk the escalation chain: reviewer → admin → engineer. As engineer, check "Request AI Triage" and describe: "Content is in Spanish, needs translation to English."',
-            },
-        },
-    },
-    // -- Process 4: Kitchen Sink -> Dynamic Triage
-    {
-        label: 'Process 4 — Dynamic Triage',
-        workflowName: 'kitchenSink',
-        taskQueue: 'long-tail-examples',
-        envelope: {
-            data: {
-                name: 'Triage Demo',
-                mode: 'full',
-            },
-            metadata: {
-                source: 'seed',
-                process: 'dynamic-triage',
-                description: 'As reviewer, check "Request AI Triage" and write: "This looks fine, just approve it."',
-            },
-        },
-    },
-    // -- Process 5: Basic Echo
-    {
-        label: 'Process 5 — Basic Echo',
-        workflowName: 'basicEcho',
-        taskQueue: 'long-tail-examples',
-        envelope: {
-            data: {
-                message: 'Hello from the seed!',
-                sleepSeconds: 2,
-            },
-            metadata: {
-                source: 'seed',
-                process: 'basic-echo',
-                description: 'Minimal durable workflow — echoes a message and reveals IAM context.',
-            },
-        },
-    },
-    // -- Process 6: Basic Signal
-    {
-        label: 'Process 6 — Basic Signal',
-        workflowName: 'basicSignal',
-        taskQueue: 'long-tail-examples',
-        envelope: {
-            data: {
-                message: 'Seed deployment needs approval before proceeding.',
-                role: 'reviewer',
-            },
-            metadata: {
-                certified: false,
-                source: 'seed',
-                process: 'basic-signal',
-                description: 'Lightweight signal-based escalation — workflow stays running, no interceptor. Claim the escalation, fill the form, and resolve to resume the workflow.',
-            },
-        },
-    },
-];
-// Escalation chains: reviewer -> admin -> engineer (and cross-links)
-const SEED_CHAINS = [
-    ['reviewer', 'admin'],
-    ['reviewer', 'engineer'],
-    ['admin', 'engineer'],
-    ['admin', 'superadmin'],
-    ['engineer', 'admin'],
-    ['engineer', 'superadmin'],
-];
+const seed_data_1 = require("./seed-data");
 // ── Seed functions ───────────────────────────────────────────────────────────
 async function seedRoles() {
-    for (const role of SEED_ROLES) {
+    for (const role of seed_data_1.SEED_ROLES) {
         try {
             await (0, role_1.createRole)(role);
         }
         catch { /* ON CONFLICT DO NOTHING handles duplicates */ }
     }
-    logger_1.loggerRegistry.info(`[examples] roles verified (${SEED_ROLES.join(', ')})`);
+    logger_1.loggerRegistry.info(`[examples] roles verified (${seed_data_1.SEED_ROLES.join(', ')})`);
 }
 async function seedUsers() {
-    for (const userDef of SEED_USERS) {
+    for (const userDef of seed_data_1.SEED_USERS) {
         try {
             const existing = await (0, user_1.getUserByExternalId)(userDef.external_id);
             if (existing) {
@@ -204,13 +47,13 @@ async function seedUsers() {
     }
 }
 async function seedEscalationChains() {
-    for (const [source, target] of SEED_CHAINS) {
+    for (const [source, target] of seed_data_1.SEED_CHAINS) {
         try {
             await (0, role_1.addEscalationChain)(source, target);
         }
         catch { /* ON CONFLICT DO NOTHING handles duplicates */ }
     }
-    logger_1.loggerRegistry.info(`[examples] escalation chains verified (${SEED_CHAINS.length} entries)`);
+    logger_1.loggerRegistry.info(`[examples] escalation chains verified (${seed_data_1.SEED_CHAINS.length} entries)`);
 }
 /**
  * Seed example workflow configs into lt_config_workflows.
@@ -269,7 +112,7 @@ async function seedExamples(client) {
     await seedRoles();
     await seedUsers();
     await seedEscalationChains();
-    for (const { workflowName, taskQueue, envelope, label } of SEED_ENVELOPES) {
+    for (const { workflowName, taskQueue, envelope, label } of seed_data_1.SEED_ENVELOPES) {
         try {
             const workflowId = `${workflowName}-seed-${hotmesh_1.Durable.guid().slice(0, 8)}`;
             await client.workflow.start({

package/build/lib/cli/auth.d.ts

@@ -0,0 +1,23 @@
+export interface StoredCredentials {
+    server: string;
+    token: string;
+    username: string;
+    password: string;
+    expiresAt: string;
+}
+export interface AuthContext {
+    server: string;
+    token: string;
+}
+/** Resolve auth from env → stored credentials → error */
+export declare function resolveAuth(): Promise<AuthContext>;
+/** Interactive or flag-based login */
+export declare function login(options: {
+    server?: string;
+    username?: string;
+    password?: string;
+}): Promise<void>;
+/** Clear stored credentials */
+export declare function logout(): void;
+/** Get the current server URL (for display purposes) */
+export declare function getServerUrl(): string | null;

package/build/lib/cli/auth.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAuth = resolveAuth;
+exports.login = login;
+exports.logout = logout;
+exports.getServerUrl = getServerUrl;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'longtail');
+const CREDS_FILE = path.join(CONFIG_DIR, 'credentials.json');
+/** Resolve auth from env → stored credentials → error */
+async function resolveAuth() {
+    // 1. Environment variables (CI / scripts)
+    if (process.env.LT_TOKEN && process.env.LT_SERVER) {
+        return { server: process.env.LT_SERVER, token: process.env.LT_TOKEN };
+    }
+    // 2. Stored credentials
+    const creds = loadCredentials();
+    if (!creds) {
+        throw new Error('Not logged in. Run: ltc login');
+    }
+    // 3. Check expiry, auto-refresh if needed
+    if (isExpired(creds.token)) {
+        const fresh = await loginRequest(creds.server, creds.username, creds.password);
+        saveCredentials({ ...creds, token: fresh.token, expiresAt: fresh.expiresAt });
+        return { server: creds.server, token: fresh.token };
+    }
+    return { server: creds.server, token: creds.token };
+}
+/** Interactive or flag-based login */
+async function login(options) {
+    let { server, username, password } = options;
+    // Interactive prompts for missing values
+    if (!server) {
+        server = await prompt('Server URL', 'http://localhost:3000');
+    }
+    if (!username) {
+        username = await prompt('Username');
+    }
+    if (!password) {
+        password = await prompt('Password');
+    }
+    server = server.replace(/\/+$/, '');
+    const result = await loginRequest(server, username, password);
+    saveCredentials({
+        server,
+        token: result.token,
+        username: username,
+        password: password,
+        expiresAt: result.expiresAt,
+    });
+    console.log(`\n  ${picocolors_1.default.green('✓')} Logged in as ${picocolors_1.default.bold(result.displayName || username)} at ${picocolors_1.default.dim(server)}`);
+    console.log(picocolors_1.default.dim(`    Token expires: ${result.expiresAt}\n`));
+}
+/** Clear stored credentials */
+function logout() {
+    if (fs.existsSync(CREDS_FILE)) {
+        fs.unlinkSync(CREDS_FILE);
+        console.log(`\n  ${picocolors_1.default.green('✓')} Logged out. Credentials cleared.\n`);
+    }
+    else {
+        console.log(picocolors_1.default.dim('\n  No stored credentials found.\n'));
+    }
+}
+/** Get the current server URL (for display purposes) */
+function getServerUrl() {
+    if (process.env.LT_SERVER)
+        return process.env.LT_SERVER;
+    const creds = loadCredentials();
+    return creds?.server || null;
+}
+// ── Internal ─────────────────────────────────────────────────────────────
+async function loginRequest(server, username, password) {
+    const res = await fetch(`${server}/api/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ username, password }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.error || `Login failed (HTTP ${res.status})`);
+    }
+    const data = await res.json();
+    const token = data.token;
+    // Decode JWT to get expiry
+    const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+    const expiresAt = new Date(payload.exp * 1000).toISOString();
+    return {
+        token,
+        expiresAt,
+        displayName: data.user?.display_name || data.user?.external_id,
+    };
+}
+function loadCredentials() {
+    try {
+        if (!fs.existsSync(CREDS_FILE))
+            return null;
+        return JSON.parse(fs.readFileSync(CREDS_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveCredentials(creds) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CREDS_FILE, JSON.stringify(creds, null, 2), { mode: 0o600 });
+}
+function isExpired(token) {
+    try {
+        const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+        return Date.now() >= payload.exp * 1000 - 60_000; // 1min buffer
+    }
+    catch {
+        return true;
+    }
+}
+async function prompt(label, defaultValue) {
+    const suffix = defaultValue ? picocolors_1.default.dim(` (${defaultValue})`) : '';
+    process.stdout.write(`  ${label}${suffix}: `);
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.once('data', (chunk) => {
+            data = chunk.toString().trim();
+            resolve(data || defaultValue || '');
+        });
+        process.stdin.resume();
+    });
+}

package/build/lib/cli/client.d.ts

@@ -0,0 +1,6 @@
+export declare class CLIError extends Error {
+    status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+/** Authenticated fetch against the Long Tail API */
+export declare function apiFetch<T = any>(path: string, options?: RequestInit): Promise<T>;

package/build/lib/cli/client.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIError = void 0;
+exports.apiFetch = apiFetch;
+const auth_1 = require("./auth");
+class CLIError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'CLIError';
+    }
+}
+exports.CLIError = CLIError;
+/** Authenticated fetch against the Long Tail API */
+async function apiFetch(path, options) {
+    const { server, token } = await (0, auth_1.resolveAuth)();
+    const url = `${server}/api${path}`;
+    const res = await fetch(url, {
+        ...options,
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+            ...options?.headers,
+        },
+    });
+    const body = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+    if (!res.ok) {
+        throw new CLIError(body.error || `HTTP ${res.status}`, res.status);
+    }
+    return body;
+}

package/build/lib/cli/commands/escalations.d.ts

@@ -0,0 +1,19 @@
+interface ListOptions {
+    status?: string;
+    role?: string;
+    limit?: string;
+    json?: boolean;
+    quiet?: boolean;
+}
+export declare function listEscalations(opts: ListOptions): Promise<void>;
+export declare function getEscalation(id: string, opts: {
+    json?: boolean;
+}): Promise<void>;
+export declare function claimEscalation(id: string, opts: {
+    duration?: string;
+}): Promise<void>;
+export declare function releaseEscalation(id: string): Promise<void>;
+export declare function resolveEscalation(id: string, opts: {
+    data?: string;
+}): Promise<void>;
+export {};