@askthew/mcp-plugin 0.2.8 → 0.4.2

package/dist/lib/free-tier-policy.js

@@ -0,0 +1,68 @@
+import fs from "node:fs";
+import { credentialsPath, readJsonFile } from "./paths.js";
+import { loadLocalIdentity } from "./local-identity.js";
+function clean(value) {
+    return String(value ?? "").trim().replace(/^['"]/, "").replace(/['"]$/, "");
+}
+export function loadCliCredentials(env = process.env) {
+    const explicitToken = clean(env.ASKTHEW_CLI_TOKEN);
+    if (explicitToken) {
+        return {
+            userId: clean(env.ASKTHEW_USER_ID) || "local",
+            cliToken: explicitToken,
+            cliTokenId: clean(env.ASKTHEW_CLI_TOKEN_ID) || "env",
+            apiUrl: clean(env.ASKTHEW_API_URL) || undefined,
+            telemetryOptOut: env.ASKTHEW_TELEMETRY === "off",
+        };
+    }
+    const localIdentity = loadLocalIdentity(env);
+    if (localIdentity) {
+        return {
+            email: localIdentity.emailClaim,
+            userId: localIdentity.installId,
+            cliToken: localIdentity.installId,
+            cliTokenId: localIdentity.installId,
+            apiUrl: localIdentity.apiUrl,
+            telemetryOptOut: localIdentity.telemetryOptOut,
+            identityKind: "local_install",
+            installId: localIdentity.installId,
+            localIdentity,
+        };
+    }
+    const creds = readJsonFile(credentialsPath(env));
+    if (!creds?.cliToken || !creds.userId || !creds.cliTokenId) {
+        return null;
+    }
+    return creds;
+}
+export function resolveMcpMode(env = process.env) {
+    const installToken = clean(env.ASKTHEW_INSTALL_TOKEN);
+    if (installToken) {
+        return {
+            mode: "paid",
+            installToken,
+            reason: "workspace_install_token",
+        };
+    }
+    const credentials = loadCliCredentials(env);
+    if (credentials?.cliToken) {
+        return {
+            mode: "free",
+            cliCredentials: credentials,
+            reason: "cli_free_tier_credentials",
+        };
+    }
+    if (clean(env.ASKTHEW_FREE_MODE) === "1" || clean(env.ASKTHEW_FREE_MODE).toLowerCase() === "true") {
+        return {
+            mode: "free_pending_auth",
+            reason: fs.existsSync(credentialsPath(env)) ? "invalid_cli_credentials" : "free_mode_no_credentials",
+        };
+    }
+    return {
+        mode: "unauthenticated",
+        reason: "no_identity",
+    };
+}
+export function isTelemetryOptedOut(env = process.env, credentials = loadCliCredentials(env)) {
+    return env.ASKTHEW_TELEMETRY === "off" || credentials?.telemetryOptOut === true;
+}

package/dist/lib/local-identity.d.ts

@@ -0,0 +1,44 @@
+export interface LocalInstallIdentity {
+    installId: string;
+    privateKey: string;
+    publicKey: string;
+    claimCode: string;
+    emailClaim?: string;
+    createdAt: string;
+    registeredAt?: string;
+    registrationError?: string;
+    apiUrl?: string;
+    telemetryOptOut?: boolean;
+}
+export interface PublicInstallIdentity {
+    installId: string;
+    publicKey: string;
+    claimCode: string;
+    emailClaim?: string;
+    createdAt: string;
+    registeredAt?: string;
+    registrationError?: string;
+    apiUrl?: string;
+    telemetryOptOut?: boolean;
+}
+export declare function loadLocalIdentity(env?: NodeJS.ProcessEnv): LocalInstallIdentity | null;
+export declare function publicIdentity(identity: LocalInstallIdentity): PublicInstallIdentity;
+export declare function ensureLocalIdentity(input?: {
+    emailClaim?: string | null;
+    apiUrl?: string;
+    telemetryOptOut?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): LocalInstallIdentity;
+export declare function markLocalIdentityRegistered(input: {
+    registeredAt?: string;
+    registrationError?: string;
+    env?: NodeJS.ProcessEnv;
+}): LocalInstallIdentity | null;
+export declare function signLocalIdentityPayload(input: {
+    identity: LocalInstallIdentity;
+    body: string;
+    timestamp?: string;
+}): {
+    timestamp: string;
+    signature: string;
+};

package/dist/lib/local-identity.js

@@ -0,0 +1,81 @@
+import crypto from "node:crypto";
+import { identityPath, readJsonFile, writePrivateJson } from "./paths.js";
+function normalizeEmail(email) {
+    const value = String(email ?? "").trim().toLowerCase();
+    return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(value) ? value : undefined;
+}
+function generateClaimCode() {
+    return crypto.randomBytes(6).toString("base64url").toUpperCase();
+}
+export function loadLocalIdentity(env = process.env) {
+    const identity = readJsonFile(identityPath(env));
+    if (!identity?.installId || !identity.privateKey || !identity.publicKey || !identity.claimCode) {
+        return null;
+    }
+    return identity;
+}
+export function publicIdentity(identity) {
+    return {
+        installId: identity.installId,
+        publicKey: identity.publicKey,
+        claimCode: identity.claimCode,
+        emailClaim: identity.emailClaim,
+        createdAt: identity.createdAt,
+        registeredAt: identity.registeredAt,
+        registrationError: identity.registrationError,
+        apiUrl: identity.apiUrl,
+        telemetryOptOut: identity.telemetryOptOut,
+    };
+}
+export function ensureLocalIdentity(input = {}) {
+    const env = input.env ?? process.env;
+    const existing = loadLocalIdentity(env);
+    const emailClaim = normalizeEmail(input.emailClaim);
+    if (existing) {
+        const next = {
+            ...existing,
+            ...(emailClaim ? { emailClaim } : {}),
+            ...(input.apiUrl ? { apiUrl: input.apiUrl } : {}),
+            ...(typeof input.telemetryOptOut === "boolean" ? { telemetryOptOut: input.telemetryOptOut } : {}),
+        };
+        writePrivateJson(identityPath(env), next);
+        return next;
+    }
+    const keyPair = crypto.generateKeyPairSync("ed25519", {
+        privateKeyEncoding: { type: "pkcs8", format: "pem" },
+        publicKeyEncoding: { type: "spki", format: "pem" },
+    });
+    const identity = {
+        installId: crypto.randomUUID(),
+        privateKey: keyPair.privateKey,
+        publicKey: keyPair.publicKey,
+        claimCode: generateClaimCode(),
+        ...(emailClaim ? { emailClaim } : {}),
+        ...(input.apiUrl ? { apiUrl: input.apiUrl } : {}),
+        ...(typeof input.telemetryOptOut === "boolean" ? { telemetryOptOut: input.telemetryOptOut } : {}),
+        createdAt: new Date().toISOString(),
+    };
+    writePrivateJson(identityPath(env), identity);
+    return identity;
+}
+export function markLocalIdentityRegistered(input) {
+    const env = input.env ?? process.env;
+    const identity = loadLocalIdentity(env);
+    if (!identity)
+        return null;
+    const next = {
+        ...identity,
+        registeredAt: input.registrationError ? identity.registeredAt : (input.registeredAt ?? new Date().toISOString()),
+        registrationError: input.registrationError,
+    };
+    writePrivateJson(identityPath(env), next);
+    return next;
+}
+export function signLocalIdentityPayload(input) {
+    const timestamp = input.timestamp ?? new Date().toISOString();
+    const signature = crypto.sign(null, Buffer.from(`${timestamp}.${input.body}`), input.identity.privateKey).toString("base64url");
+    return {
+        timestamp,
+        signature,
+    };
+}

package/dist/lib/local-store.d.ts

@@ -0,0 +1,130 @@
+export type SignalKind = "setup_complete" | "session_checkpoint" | "direction_change" | "implementation_update" | "verification_result" | "final_summary";
+export type DecisionStatus = "proposed" | "committed" | "shipped" | "abandoned";
+export interface LocalSignalInput {
+    sessionId: string;
+    sequence: number;
+    kind: SignalKind;
+    summary: string;
+    evidence?: unknown[];
+    filesTouched?: string[];
+    commandsRun?: string[];
+    metadata?: Record<string, unknown>;
+    scopeKey?: string | null;
+}
+export interface LocalSignal {
+    id: number;
+    sessionId: string;
+    sequence: number;
+    kind: SignalKind;
+    summary: string;
+    evidence: unknown[];
+    filesTouched: string[];
+    commandsRun: string[];
+    metadata: Record<string, unknown>;
+    capturedAt: string;
+    scopeKey?: string | null;
+}
+export interface LocalDecision {
+    id: string;
+    sessionId: string | null;
+    headline: string;
+    why: string | null;
+    status: DecisionStatus;
+    alignment: "aligned" | "orthogonal" | "conflicts" | "ambiguous" | null;
+    files: string[];
+    sourceSignalIds: number[];
+    rawContent: string;
+    createdAt: string;
+    updatedAt: string;
+    uploadedAt: string | null;
+    scopeKey?: string | null;
+    proposedAt?: string | null;
+    committedAt?: string | null;
+    shippedAt?: string | null;
+    abandonedAt?: string | null;
+}
+export interface LocalDecisionInput {
+    id?: string;
+    sessionId?: string | null;
+    headline?: string;
+    why?: string | null;
+    status?: DecisionStatus;
+    alignment?: LocalDecision["alignment"];
+    files?: string[];
+    sourceSignalIds?: number[];
+    rawContent: string;
+    scopeKey?: string | null;
+}
+export interface TelemetryOutboxRow {
+    id: number;
+    payload: Record<string, unknown>;
+    createdAt: string;
+    attempts: number;
+    lastAttemptAt: string | null;
+    deliveredAt: string | null;
+}
+export declare class LocalStore {
+    private readonly storePath;
+    private data;
+    private db;
+    private jsonMode;
+    private jsonPath;
+    private constructor();
+    static open(input?: {
+        path?: string;
+    }): LocalStore;
+    get usingJsonFallback(): boolean;
+    close(): void;
+    migrate(): void;
+    getMeta(key: string): string;
+    setMeta(key: string, value: string): void;
+    insertSignal(input: LocalSignalInput): LocalSignal;
+    listSignals(input?: {
+        sessionId?: string;
+        scopeKey?: string | null;
+        since?: string;
+        limit?: number;
+        cursor?: string;
+        uploaded?: boolean;
+    }): LocalSignal[];
+    getSignal(id: number): LocalSignal | null;
+    mostRecentSessionId(input?: {
+        scopeKey?: string | null;
+    }): any;
+    createDecision(input: LocalDecisionInput): LocalDecision;
+    updateDecision(id: string, patch: Partial<Omit<LocalDecision, "id" | "createdAt">>): LocalDecision | null;
+    deleteDecision(id: string): boolean;
+    getDecision(id: string): LocalDecision | null;
+    listDecisions(input?: {
+        status?: DecisionStatus;
+        limit?: number;
+        since?: string;
+        cursor?: string;
+        sessionId?: string;
+        scopeKey?: string | null;
+        pendingUploadOnly?: boolean;
+    }): LocalDecision[];
+    listSessionIds(input?: {
+        limit?: number;
+        scopeKey?: string | null;
+    }): string[];
+    listSignalsByIds(ids: number[]): LocalSignal[];
+    getDecisionForSignal(signalId: number): LocalDecision | null;
+    enqueueTelemetry(payload: Record<string, unknown>): number;
+    listTelemetryOutbox(input?: {
+        undeliveredOnly?: boolean;
+        limit?: number;
+    }): TelemetryOutboxRow[];
+    markTelemetryAttempt(id: number, delivered: boolean): void;
+    stats(): {
+        signals: number;
+        decisions: number;
+        decisionsByStatus: Record<string, number>;
+        lastSessionId: string | null;
+        jsonFallback: boolean;
+    };
+    private openDatabase;
+    private persistJson;
+    private nextJsonId;
+    private addColumnIfMissing;
+}