driggsby 0.8.0 → 0.9.0

package/dist/import/import-target.js

@@ -0,0 +1,49 @@
+// What `import <FILE or ID>` names: a file on this machine (read once,
+// size-checked, and hashed, so Driggsby can say whether it already has it
+// before any upload), or an import's ID. A file wins over an ID-shaped
+// name, so a file that happens to be called imp_... still imports.
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { CliError } from "../cli-error.js";
+import { quotedForTerminal, sanitizeForTerminal, wrapProse } from "../terminal-text.js";
+import {} from "./import-client.js";
+import { isImportRef } from "./import-view.js";
+export const MAX_FILE_BYTES = 10 * 1024 * 1024;
+export async function resolveTarget(typed) {
+    const info = await stat(typed).catch(() => null);
+    if (info === null) {
+        if (isImportRef(typed)) {
+            return { kind: "ref", ref: typed };
+        }
+        throw new CliError(wrapProse(`There's no file at ${quotedForTerminal(typed, 200)}. Check the path and run the command again.`), 1);
+    }
+    if (!info.isFile()) {
+        throw new CliError(wrapProse(`${quotedForTerminal(typed, 200)} is a folder, not a file. Name the statement's CSV file itself.`), 1);
+    }
+    if (info.size > MAX_FILE_BYTES) {
+        const megabytes = (info.size / 1024 / 1024).toFixed(1);
+        throw new CliError(`Refused: the file is ${megabytes} MB, and statement imports take files up to 10 MB.\n` +
+            "Nothing was imported.\n\nNext:\n  Export a shorter date range from the bank and import each part.", 1);
+    }
+    const bytes = new Uint8Array(await readFile(typed));
+    return {
+        kind: "file",
+        file: { name: basename(typed), bytes },
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        typed,
+    };
+}
+// A file over the limit was never imported, so there's nothing of it to undo.
+export async function tooLargeToImport(typed) {
+    const info = await stat(typed).catch(() => null);
+    return info !== null && info.isFile() && info.size > MAX_FILE_BYTES;
+}
+// A typed path as a copy-paste-safe shell word: stripped of terminal
+// control bytes, never read as a flag (a leading "-" gets "./"), bare when
+// it's plain, otherwise single-quoted with any single quote spelled out.
+export function shellWord(value) {
+    const cleaned = sanitizeForTerminal(value);
+    const shown = cleaned.startsWith("-") ? `./${cleaned}` : cleaned;
+    return /^[A-Za-z0-9_./@%+=:,-]+$/.test(shown) ? shown : `'${shown.replaceAll("'", "'\\''")}'`;
+}

package/dist/import/import-view.js

@@ -0,0 +1,124 @@
+// What Driggsby says about one statement import, read defensively: every
+// field is checked for its type, and anything else is dropped, so a server
+// change can never crash a render or slip an unexpected shape through.
+// Strings are still untrusted text; the renderer sanitizes and quotes them.
+const STATES = new Set([
+    "reading",
+    "waiting",
+    "importing",
+    "categorizing",
+    "done",
+    "stopped",
+    "undoing",
+    "undone",
+]);
+export const ACCOUNT_REF = /^acct_[A-Za-z0-9_-]{1,64}$/;
+const IMPORT_REF = /^imp_[A-Za-z0-9_-]{12}$/;
+export function isImportRef(value) {
+    return IMPORT_REF.test(value);
+}
+export function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function text(value) {
+    return typeof value === "string" ? value : null;
+}
+function count(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
+}
+function optionalCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+}
+// null when the payload isn't an import Driggsby described.
+export function readImportView(value) {
+    const record = asRecord(value);
+    const ref = text(record?.import_ref);
+    const state = text(record?.state);
+    if (record === null || ref === null || !isImportRef(ref) || state === null || !STATES.has(state)) {
+        return null;
+    }
+    const counts = asRecord(record.counts);
+    const dates = asRecord(record.dates);
+    const leftOut = asRecord(record.left_out);
+    const progress = asRecord(record.progress);
+    const stopped = asRecord(record.stopped);
+    const from = text(dates?.from);
+    const to = text(dates?.to);
+    return {
+        ref,
+        file: text(record.file) ?? "statement.csv",
+        state: state,
+        lines: optionalCount(record.lines),
+        bytes: optionalCount(record.bytes),
+        startedAt: text(record.started_at),
+        finishedAt: text(record.finished_at),
+        account: text(asRecord(record.account)?.label),
+        accountRef: refText(asRecord(record.account)?.ref),
+        newAccount: record.new_account === true,
+        counts: counts === null
+            ? null
+            : { new: count(counts.new), alreadyInDriggsby: count(counts.already_in_driggsby), pending: count(counts.pending) },
+        dates: from !== null && to !== null ? { from, to } : null,
+        leftOut: { notPosted: count(leftOut?.not_posted), unreadable: count(leftOut?.unreadable), balance: count(leftOut?.balance) },
+        nothingNew: text(record.nothing_new),
+        categorized: typeof record.categorized === "boolean" ? record.categorized : null,
+        question: readQuestion(record.question),
+        progress: progress === null
+            ? null
+            : {
+                categorized: count(progress.categorized),
+                total: count(progress.total),
+                secondsLeft: optionalCount(progress.seconds_left),
+            },
+        stopped: stopped === null ? null : { code: text(stopped.code) ?? "stopped", message: text(stopped.message) ?? "" },
+    };
+}
+function readQuestion(value) {
+    const record = asRecord(value);
+    const kind = text(record?.kind);
+    const prompt = text(record?.prompt);
+    if (record === null || kind === null || prompt === null) {
+        return null;
+    }
+    return { kind, prompt, choices: readChoices(record.choices) };
+}
+// Each choice keeps exactly one answer the CLI knows how to send.
+export function readChoices(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const entries = value;
+    return entries.flatMap((entry) => {
+        const record = asRecord(entry);
+        const label = text(record?.label);
+        const answer = asRecord(record?.answer);
+        if (label === null || answer === null) {
+            return [];
+        }
+        const flags = [
+            ["--dates", answer.dates],
+            ["--amounts", answer.amounts],
+        ];
+        const found = flags.filter(([, answerValue]) => typeof answerValue === "string" && /^[A-Za-z0-9_-]{1,64}$/.test(answerValue));
+        const [chosen] = found;
+        return found.length === 1 && chosen !== undefined ? [{ label, flag: chosen[0], value: chosen[1] }] : [];
+    });
+}
+export function refText(value) {
+    return typeof value === "string" && ACCOUNT_REF.test(value) ? value : null;
+}
+export function readUndoPreview(value) {
+    const record = asRecord(value);
+    if (record === null || typeof record.undoable !== "boolean") {
+        return null;
+    }
+    return {
+        undoable: record.undoable,
+        cancels: record.cancels === true,
+        transactions: count(record.transactions),
+        edited: count(record.edited),
+        keptForLaterImports: count(record.kept_for_later_imports),
+        accountRemoved: record.account_removed === true,
+        message: text(record.message),
+    };
+}

package/dist/main.js

@@ -11,6 +11,7 @@ import { runInit } from "./init/init-command.js";
 import { runRollback } from "./deploy/rollback-command.js";
 import { runVersions } from "./deploy/versions-command.js";
 import { runQuery } from "./query/query-command.js";
+import { runImport } from "./import/import-command.js";
 import { runItems } from "./items/items-command.js";
 import { runRules } from "./rules/rules-command.js";
 import { runLogin, runLoginWithCode } from "./login/login.js";
@@ -54,6 +55,8 @@ async function run(argv) {
             return await runRules({ action: command.action, params: command.params, yes: command.yes });
         case "items":
             return await runItems({ action: command.action, params: command.params, yes: command.yes });
+        case "import":
+            return await runImport(command.options);
     }
 }
 try {

package/dist/rules/rules-rpc.js

@@ -16,13 +16,13 @@ const MAX_SERVER_MESSAGE_CHARS = 1_000;
 export const RULES_NOT_AVAILABLE_MESSAGE = "This sign-in can't use transaction rules. Sign in again and approve the request:\n" +
     "  npx driggsby@latest login\n" +
     "If rules still aren't available after that, they aren't open to your account yet.";
-export async function callRuleTool(session, tool, toolArguments) {
+export async function callRuleTool(session, tool, toolArguments, timeoutMs = RULES_CALL_TIMEOUT_MS) {
     const payload = await postMcp(session, {
         jsonrpc: "2.0",
         id: 1,
         method: "tools/call",
         params: { name: tool, arguments: toolArguments },
-    });
+    }, timeoutMs);
     return interpretToolCall(payload);
 }
 // The rule tools' own descriptions and input schemas, from the tools/list
@@ -89,7 +89,7 @@ export function interpretToolCall(payload) {
 function firstText(content) {
     return Array.isArray(content) ? asRecord(content[0])?.text : undefined;
 }
-async function postMcp(session, body) {
+async function postMcp(session, body, timeoutMs = RULES_CALL_TIMEOUT_MS) {
     // Bare headers on purpose: the Driggsby endpoint refuses anything that
     // looks like a browser call (an Origin or Sec-Fetch-Site header), and
     // Node's fetch sends neither on its own.
@@ -99,7 +99,7 @@ async function postMcp(session, body) {
         body: JSON.stringify(body),
         // The bearer token must never travel to a redirect target.
         redirect: "error",
-        signal: AbortSignal.timeout(RULES_CALL_TIMEOUT_MS),
+        signal: AbortSignal.timeout(timeoutMs),
     });
     if (response.status === 401) {
         throw new CliError(SIGN_IN_AGAIN_MESSAGE, 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driggsby",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Set up and build on Driggsby, the MCP server for personal finance.",
   "license": "Apache-2.0 AND OFL-1.1",
   "repository": {
@@ -30,7 +30,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@driggsby/deploy": "0.8.0",
-    "@driggsby/sdk": "0.8.0"
+    "@driggsby/deploy": "0.9.0",
+    "@driggsby/sdk": "0.9.0"
   }
 }