@atlastodo/sdk 0.0.0-stage → 0.1.11-rc.5

package/dist/client.d.ts

@@ -0,0 +1,121 @@
+import { type CreateTaskInput, type FetchLike, type Label, type Project, type Task } from "@atlastodo/client-core";
+/**
+ * A headless Atlas client for integrations, signed in with a personal API token.
+ *
+ * `connect` opens a session with the token, unwraps the account keys the token carries, and pulls
+ * the account into memory, decrypting it on this machine: the server only ever sees ciphertext.
+ * Reads are then local; every write is pushed before its promise resolves. Task rules (recurring
+ * completion, soft deletes, locked tasks) are the app's own, from `@atlastodo/shared`.
+ */
+export interface ConnectOptions {
+    /** The Atlas server, e.g. `https://app.atlastodo.dev` (an `/api` suffix is fine too). */
+    serverUrl: string;
+    /** An `atlas_pat_…` token from Settings → API tokens. */
+    token: string;
+    fetch?: FetchLike;
+    /** IANA zone for due dates and recurrence; the runtime's by default. */
+    timeZone?: string;
+}
+export type TaskStatus = "open" | "completed" | "all";
+export interface TaskQuery {
+    /** A project id or name (case-insensitive). */
+    project?: string;
+    /** Default `open`. */
+    status?: TaskStatus;
+    /** Unix ms bounds on the due date; tasks without one are left out when either is set. */
+    dueBefore?: number;
+    dueAfter?: number;
+    /** A label id or name (case-insensitive). */
+    label?: string;
+    /** Case-insensitive substring of the title or notes. */
+    search?: string;
+    /** The app's filter syntax (`today & p1`, `#Work | @errand`, `overdue`). */
+    filter?: string;
+}
+/** A task as integrations see it: the app's task plus resolved project and label names. */
+export interface TaskView extends Task {
+    project_name: string | null;
+    labels: string[];
+}
+export interface CreateTaskOptions extends Partial<Omit<CreateTaskInput, "title">> {
+    title: string;
+    /** A project name, resolved like `project_id` (ignored when `project_id` is given). */
+    project?: string;
+    /** Label names; unknown ones are an error. */
+    labels?: string[];
+}
+export type TaskPatch = Partial<Pick<Task, "title" | "notes" | "priority" | "due_at" | "start_at" | "recurrence" | "project_id" | "section_id" | "label_ids" | "estimate_min" | "assignee_id">>;
+export interface Changes {
+    /** Pass back as `since` next time. */
+    cursor: number;
+    created: TaskView[];
+    updated: TaskView[];
+    completed: TaskView[];
+    /** Soft-deleted (in the trash) or purged; purged ones carry only their id. */
+    deleted: (TaskView | {
+        id: string;
+    })[];
+}
+export declare class AtlasError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class AtlasClient {
+    private readonly api;
+    private readonly store;
+    private readonly sync;
+    readonly userId: string;
+    private readonly timeZone;
+    private constructor();
+    static connect(opts: ConnectOptions): Promise<AtlasClient>;
+    /** Pull everything, then load the shared projects' keys under the synced trust state. */
+    private initialSync;
+    private syncOrThrow;
+    /** Push pending writes; throws when any did not reach the server. */
+    private push;
+    /** The server cursor this client has pulled up to. */
+    cursor(): number;
+    /** Projects and folders that are neither archived nor in the trash. */
+    projects(): Project[];
+    labels(): Label[];
+    private projectId;
+    private labelId;
+    private view;
+    private rawTask;
+    /** One task by id, trashed or not; null when there is none. */
+    task(id: string): TaskView | null;
+    /** Tasks not in the trash or archived, filtered by `query`. */
+    tasks(query?: TaskQuery): TaskView[];
+    /** Create a task and push it. */
+    createTask(input: CreateTaskOptions): Promise<TaskView>;
+    /**
+     * Create a task from one line in the app's quick-add syntax:
+     * `Pay rent every month on the 1st #Home p1 @bills`.
+     */
+    quickAdd(text: string): Promise<TaskView>;
+    /** Change a task's fields and push. Unchanged values are skipped. */
+    updateTask(id: string, patch: TaskPatch): Promise<TaskView>;
+    /**
+     * Complete a task (no-op when it already is). A recurring task with a due date spawns its next
+     * occurrence, returned as `next`.
+     */
+    completeTask(id: string): Promise<{
+        task: TaskView;
+        next: TaskView | null;
+    }>;
+    reopenTask(id: string): Promise<{
+        task: TaskView;
+        next: TaskView | null;
+    }>;
+    private setCompleted;
+    /** Move a task to the trash, as the app's delete does. */
+    deleteTask(id: string): Promise<void>;
+    /**
+     * Tasks changed on the server after `since` (a cursor from an earlier call or {@link cursor}).
+     * Each task is listed once, under the first of deleted, created, completed, updated that its
+     * changes match, with its current state.
+     */
+    changes(since: number): Promise<Changes>;
+    /** Stop background timers. Every write has already been pushed. */
+    close(): void;
+}

package/dist/dates.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read a due date the way an integration is likely to send one, into the app's convention.
+ * - `null`, `""` or `"none"`: no date.
+ * - A number, or a string of digits: unix milliseconds.
+ * - `YYYY-MM-DD`, `today`, `tomorrow`: that day, at the app's default due time in `timeZone`
+ *   (what picking a day in the app gives).
+ * - `YYYY-MM-DDTHH:MM[:SS]`: that wall time in `timeZone`; with `Z` or an offset, that instant.
+ */
+export declare function parseDue(value: string | number | null | undefined, timeZone?: string, now?: number): number | null;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./client.js";
+export { InvalidApiTokenError } from "@atlastodo/client-core";
+export * from "./dates.js";

package/dist/index.js

@@ -0,0 +1,372 @@
+// src/client.ts
+import {
+  ApiClient,
+  Keyring,
+  LocalStore,
+  SyncClient,
+  deriveApiTokenKeys,
+  hydrateProjectKeys,
+  isProjectCreator,
+  parseApiToken,
+  readKeyTrust,
+  reviveLockedValues,
+  unwrapApiTokenKeys,
+  unwrapSigningKey
+} from "@atlastodo/client-core";
+import {
+  allTasks,
+  createTask,
+  evaluate,
+  parse as parseFilter,
+  parseQuickAdd,
+  softDeleteTask,
+  toProject,
+  toTask,
+  toggleTask,
+  updateTask
+} from "@atlastodo/shared";
+
+class AtlasError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AtlasError";
+  }
+}
+
+class AtlasClient {
+  api;
+  store;
+  sync;
+  userId;
+  timeZone;
+  constructor(api, store, sync, userId, timeZone) {
+    this.api = api;
+    this.store = store;
+    this.sync = sync;
+    this.userId = userId;
+    this.timeZone = timeZone;
+  }
+  static async connect(opts) {
+    const parts = parseApiToken(opts.token);
+    const { auth } = deriveApiTokenKeys(parts);
+    const baseUrl = opts.serverUrl.replace(/\/+$/, "");
+    const api = new ApiClient({
+      baseUrl,
+      fetch: opts.fetch,
+      reauthenticate: async () => (await api.openApiTokenSession(parts.id, auth)).access_token
+    });
+    const session = await api.openApiTokenSession(parts.id, auth);
+    api.setTokens(session.access_token);
+    const { dek, privateKey } = unwrapApiTokenKeys(parts, session.user_id, session);
+    const keyring = new Keyring({ dek, privateKey, publicKey: session.public_key });
+    if (session.encrypted_signing_key && session.signing_public_key) {
+      try {
+        keyring.setSigningKey(unwrapSigningKey(session.encrypted_signing_key, dek, session.signing_public_key));
+      } catch {}
+    }
+    api.setKeyring(keyring);
+    const store = new LocalStore(parts.id, { newId: () => globalThis.crypto.randomUUID() });
+    api.setScopeContext(store, session.user_id);
+    const sync = new SyncClient(store, api, { cursor: 0 });
+    const client = new AtlasClient(api, store, sync, session.user_id, opts.timeZone);
+    await client.initialSync(keyring);
+    return client;
+  }
+  async initialSync(keyring) {
+    await this.syncOrThrow();
+    const result = await hydrateProjectKeys(this.api, keyring, {
+      isCreator: (projectId) => isProjectCreator(this.store, projectId, this.userId),
+      trust: readKeyTrust(this.store),
+      userId: this.userId,
+      trustWriter: this.store
+    });
+    if (result.changed) {
+      reviveLockedValues(this.store, keyring, this.userId, !this.api.isLegacyMigrated());
+      await this.syncOrThrow();
+    }
+  }
+  async syncOrThrow() {
+    const result = await this.sync.sync();
+    if (result.skipped) {
+      throw new AtlasError("sync_skipped", `sync did not run (${result.skipped}); try again later`);
+    }
+  }
+  async push() {
+    await this.syncOrThrow();
+    const pending = this.store.unsyncedOps().length;
+    if (pending > 0) {
+      throw new AtlasError("not_pushed", `${pending} change(s) did not reach the server (a shared project whose key is missing?)`);
+    }
+  }
+  cursor() {
+    return this.sync.currentCursor();
+  }
+  projects() {
+    return this.store.list("project").map((e) => toProject(e.id, e.fields)).filter((p) => p.archived_at == null && p.deleted_at == null).sort((a, b) => a.sort_order - b.sort_order);
+  }
+  labels() {
+    return this.store.list("label").filter((e) => e.fields.deleted_at == null).map((e) => ({
+      id: e.id,
+      owner_id: typeof e.fields.owner_id === "string" ? e.fields.owner_id : "",
+      name: typeof e.fields.name === "string" ? e.fields.name : "",
+      color: typeof e.fields.color === "string" ? e.fields.color : ""
+    }));
+  }
+  projectId(ref) {
+    const lower = ref.toLowerCase();
+    const project = this.projects().find((p) => p.id === ref) ?? this.projects().find((p) => p.name.toLowerCase() === lower);
+    if (!project)
+      throw new AtlasError("unknown_project", `no project "${ref}"`);
+    return project.id;
+  }
+  labelId(ref) {
+    const lower = ref.replace(/^@/, "").toLowerCase();
+    const label = this.labels().find((l) => l.id === ref) ?? this.labels().find((l) => l.name.toLowerCase() === lower);
+    if (!label)
+      throw new AtlasError("unknown_label", `no label "${ref}"`);
+    return label.id;
+  }
+  view(task) {
+    const names = new Map(this.labels().map((l) => [l.id, l.name]));
+    const project = task.project_id ? this.store.get("project", task.project_id) : null;
+    return {
+      ...task,
+      project_name: project && typeof project.name === "string" ? project.name : null,
+      labels: task.label_ids.map((id) => names.get(id)).filter((n) => n != null)
+    };
+  }
+  rawTask(id) {
+    const fields = this.store.get("task", id);
+    if (!fields)
+      throw new AtlasError("unknown_task", `no task "${id}"`);
+    return toTask(id, fields);
+  }
+  task(id) {
+    const fields = this.store.get("task", id);
+    return fields ? this.view(toTask(id, fields)) : null;
+  }
+  tasks(query = {}) {
+    const status = query.status ?? "open";
+    const projectId = query.project ? this.projectId(query.project) : null;
+    const labelId = query.label ? this.labelId(query.label) : null;
+    const search = query.search?.toLowerCase();
+    let filter = null;
+    if (query.filter) {
+      filter = parseFilter(query.filter);
+      if (!filter.ok) {
+        throw new AtlasError("bad_filter", `${filter.error} (at ${filter.at})`);
+      }
+    }
+    const now = Date.now();
+    const labelNames = new Map(this.labels().map((l) => [l.id, l.name]));
+    const ctx = {
+      now,
+      timeZone: this.timeZone,
+      labelsOf: (t) => t.label_ids.map((id) => labelNames.get(id) ?? ""),
+      projectNameOf: (t) => {
+        const p = t.project_id ? this.store.get("project", t.project_id) : null;
+        return p && typeof p.name === "string" ? p.name : null;
+      }
+    };
+    return allTasks(this.store).filter((t) => t.deleted_at == null && t.archived_at == null).filter((t) => status === "all" || t.is_completed === (status === "completed")).filter((t) => projectId == null || t.project_id === projectId).filter((t) => labelId == null || t.label_ids.includes(labelId)).filter((t) => {
+      if (query.dueBefore == null && query.dueAfter == null)
+        return true;
+      if (t.due_at == null)
+        return false;
+      return (query.dueBefore == null || t.due_at < query.dueBefore) && (query.dueAfter == null || t.due_at >= query.dueAfter);
+    }).filter((t) => !search || t.title.toLowerCase().includes(search) || t.notes.toLowerCase().includes(search)).filter((t) => !filter?.ok || evaluate(filter.ast, t, ctx)).map((t) => this.view(t));
+  }
+  async createTask(input) {
+    const { project, labels, ...rest } = input;
+    if (!rest.title?.trim())
+      throw new AtlasError("bad_input", "a task needs a title");
+    const create = { ...rest, title: rest.title.trim() };
+    if (create.project_id)
+      create.project_id = this.projectId(create.project_id);
+    else if (project)
+      create.project_id = this.projectId(project);
+    if (labels?.length) {
+      create.label_ids = [...create.label_ids ?? [], ...labels.map((l) => this.labelId(l))];
+    }
+    if (create.priority != null)
+      create.priority = checkPriority(create.priority);
+    const id = createTask(this.store, create, this.timeZone);
+    await this.push();
+    return this.view(this.rawTask(id));
+  }
+  async quickAdd(text) {
+    const projects = this.projects();
+    const labels = this.labels();
+    const parsed = parseQuickAdd(text, Date.now(), {
+      timeZone: this.timeZone,
+      projectIdByName: (name) => projects.find((p) => p.name.toLowerCase() === name.toLowerCase())?.id ?? null,
+      isKnownLabel: (name) => labels.some((l) => l.name.toLowerCase() === name.toLowerCase())
+    });
+    return this.createTask({ ...parsed.input, labels: parsed.labels });
+  }
+  async updateTask(id, patch) {
+    const task = this.rawTask(id);
+    const clean = {};
+    for (const [key, value] of Object.entries(patch)) {
+      if (value !== undefined)
+        clean[key] = value;
+    }
+    if (clean.project_id)
+      clean.project_id = this.projectId(clean.project_id);
+    if (clean.priority != null)
+      clean.priority = checkPriority(clean.priority);
+    if (clean.label_ids)
+      clean.label_ids = clean.label_ids.map((l) => this.labelId(l));
+    if (!updateTask(this.store, task, clean, this.userId, Date.now(), this.timeZone)) {
+      if (task.locked || this.rawTask(id).locked)
+        throw lockedError(id);
+      return this.view(task);
+    }
+    await this.push();
+    return this.view(this.rawTask(id));
+  }
+  async completeTask(id) {
+    return this.setCompleted(id, true);
+  }
+  async reopenTask(id) {
+    return this.setCompleted(id, false);
+  }
+  async setCompleted(id, completed) {
+    const task = this.rawTask(id);
+    if (task.locked)
+      throw lockedError(id);
+    if (task.is_completed === completed)
+      return { task: this.view(task), next: null };
+    const spawned = toggleTask(this.store, task, this.userId, Date.now(), this.timeZone);
+    await this.push();
+    return {
+      task: this.view(this.rawTask(id)),
+      next: spawned ? this.view(this.rawTask(spawned)) : null
+    };
+  }
+  async deleteTask(id) {
+    const task = this.rawTask(id);
+    if (task.deleted_at != null)
+      return;
+    if (!softDeleteTask(this.store, task))
+      throw lockedError(id);
+    await this.push();
+  }
+  async changes(since) {
+    await this.syncOrThrow();
+    const until = this.cursor();
+    const touched = new Map;
+    let cursor = since;
+    while (cursor < until) {
+      const page = await this.api.syncPull(cursor);
+      for (const op of page.operations) {
+        if (op.entity !== "task")
+          continue;
+        const ops = touched.get(op.entityId) ?? [];
+        ops.push(op);
+        touched.set(op.entityId, ops);
+      }
+      if (page.operations.length === 0 || page.cursor <= cursor)
+        break;
+      cursor = page.cursor;
+    }
+    const out = {
+      cursor: Math.max(until, cursor),
+      created: [],
+      updated: [],
+      completed: [],
+      deleted: []
+    };
+    for (const [id, ops] of touched) {
+      const fields = this.store.get("task", id);
+      const has = (field, pred = () => true) => ops.some((o) => o.op === "set" && o.field === field && pred(o.value));
+      if (!fields) {
+        out.deleted.push({ id });
+        continue;
+      }
+      const view = this.view(toTask(id, fields));
+      if (ops.some((o) => o.op === "delete") || has("deleted_at", (v) => v != null)) {
+        out.deleted.push(view);
+      } else if (has("created_at"))
+        out.created.push(view);
+      else if (has("is_completed", (v) => v === true))
+        out.completed.push(view);
+      else
+        out.updated.push(view);
+    }
+    return out;
+  }
+  close() {
+    this.sync.dispose();
+  }
+}
+function checkPriority(p) {
+  if (p === 1 || p === 2 || p === 3 || p === 4)
+    return p;
+  throw new AtlasError("bad_input", "priority must be 1 (highest) to 4 (none)");
+}
+function lockedError(id) {
+  return new AtlasError("task_locked", `task "${id}" is in a shared project whose key this token cannot open`);
+}
+
+// src/index.ts
+import { InvalidApiTokenError } from "@atlastodo/client-core";
+
+// src/dates.ts
+import { addDays, endOfDay, makeInstant, resolveTimeZone } from "@atlastodo/shared";
+function parseDue(value, timeZone, now = Date.now()) {
+  if (value == null)
+    return null;
+  if (typeof value === "number")
+    return checkMs(value);
+  const text = value.trim();
+  const lower = text.toLowerCase();
+  if (lower === "" || lower === "none")
+    return null;
+  if (/^\d+$/.test(text))
+    return checkMs(Number(text));
+  const tz = resolveTimeZone(timeZone);
+  if (lower === "today")
+    return endOfDay(now, tz);
+  if (lower === "tomorrow")
+    return endOfDay(addDays(now, 1, tz), tz);
+  const date = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (date) {
+    const [, y, m, d] = date.map(Number);
+    checkParts(value, y, m, d);
+    return endOfDay(makeInstant(y, m - 1, d, 12, 0, 0, tz), tz);
+  }
+  const wall = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?$/.exec(text);
+  if (wall) {
+    const [, y, m, d, h, min, s] = wall.map((v) => Number(v ?? 0));
+    checkParts(value, y, m, d, h, min, s);
+    return makeInstant(y, m - 1, d, h, min, s, tz);
+  }
+  const instant = Date.parse(text);
+  if (/^\d{4}-\d{2}-\d{2}T/.test(text) && !Number.isNaN(instant))
+    return instant;
+  throw unreadable(value);
+}
+function unreadable(value) {
+  return new AtlasError("bad_input", `cannot read the date "${value}" (use YYYY-MM-DD, YYYY-MM-DDTHH:MM, ISO 8601 or unix ms)`);
+}
+function checkParts(value, y, m, d, h = 0, min = 0, s = 0) {
+  const daysInMonth = new Date(Date.UTC(y, m, 0)).getUTCDate();
+  if (m < 1 || m > 12 || d < 1 || d > daysInMonth || h > 23 || min > 59 || s > 59) {
+    throw unreadable(value);
+  }
+}
+function checkMs(ms) {
+  if (!Number.isFinite(ms) || Math.abs(ms) > 8640000000000000) {
+    throw new AtlasError("bad_input", `not a timestamp: ${ms}`);
+  }
+  return ms;
+}
+export {
+  AtlasClient,
+  AtlasError,
+  InvalidApiTokenError,
+  parseDue
+};

package/dist/testing.d.ts

@@ -0,0 +1,27 @@
+import { LocalStore, SyncClient, type FetchLike, type WireOp } from "@atlastodo/client-core";
+export declare const USER_ID = "01920000-0000-7000-8000-0000000000aa";
+/**
+ * A stand-in for the server's sync surface: one account's op log, kept as the opaque wire ops the
+ * clients push (ciphertext), like the real server. Enough of the API for the SDK and an app-like
+ * second client.
+ */
+export declare class FakeServer {
+    readonly ops: (WireOp & {
+        seq: number;
+    })[];
+    private seq;
+    readonly token: import("@atlastodo/client-core").ApiTokenParts;
+    readonly keys: {
+        dek: Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+        privateKey: Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+    };
+    sessions: number;
+    revoked: boolean;
+    tokenString(): string;
+    fetch: FetchLike;
+    /** A signed-in app device of the same account, for writes the SDK should see. */
+    appDevice(): Promise<{
+        store: LocalStore;
+        sync: SyncClient;
+    }>;
+}

package/dist/testing.js

@@ -0,0 +1,86 @@
+// src/testing.ts
+import {
+  ApiClient,
+  LocalStore,
+  SyncClient,
+  Keyring,
+  deriveApiTokenKeys,
+  formatApiToken,
+  generateApiToken,
+  randomBytes,
+  wrapKeysForApiToken
+} from "@atlastodo/client-core";
+var USER_ID = "01920000-0000-7000-8000-0000000000aa";
+
+class FakeServer {
+  ops = [];
+  seq = 0;
+  token = generateApiToken();
+  keys = { dek: randomBytes(32), privateKey: randomBytes(32) };
+  sessions = 0;
+  revoked = false;
+  tokenString() {
+    return formatApiToken(this.token);
+  }
+  fetch = async (url, init) => {
+    const u = new URL(String(url));
+    const body = init?.body ? JSON.parse(String(init.body)) : undefined;
+    const json = (status, data) => new Response(data === undefined ? null : JSON.stringify(data), { status });
+    const authed = init?.headers?.authorization;
+    switch (`${init?.method} ${u.pathname}`) {
+      case "POST /auth/api-token/session": {
+        if (this.revoked || body.token_id !== this.token.id || body.auth !== deriveApiTokenKeys(this.token).auth) {
+          return json(401, { error: "unauthorized" });
+        }
+        this.sessions++;
+        return json(200, {
+          access_token: `access-${this.sessions}`,
+          expires_in: 900,
+          token_id: this.token.id,
+          user_id: USER_ID,
+          ...wrapKeysForApiToken(this.token, USER_ID, this.keys)
+        });
+      }
+    }
+    if (this.revoked || !authed?.startsWith("Bearer "))
+      return json(401, { error: "unauthorized" });
+    switch (`${init?.method} ${u.pathname}`) {
+      case "GET /sync/snapshot":
+        return json(200, { operations: this.ops, cursor: this.seq });
+      case "GET /sync/pull": {
+        const since = Number(u.searchParams.get("since"));
+        const page = this.ops.filter((o) => o.seq > since).slice(0, 500);
+        return json(200, {
+          operations: page,
+          from: since,
+          cursor: page.length ? page[page.length - 1].seq : Math.max(since, this.seq)
+        });
+      }
+      case "POST /sync/push": {
+        const from = this.seq;
+        for (const op of body.operations) {
+          if (this.ops.some((o) => o.id === op.id))
+            continue;
+          this.ops.push({ ...op, seq: ++this.seq });
+        }
+        return json(200, { applied: body.operations.length, from, cursor: this.seq });
+      }
+      case "GET /project-keys":
+        return json(200, { keys: [], canonical: {} });
+    }
+    return json(404, { error: `not found: ${init?.method} ${u.pathname}` });
+  };
+  async appDevice() {
+    const api = new ApiClient({ baseUrl: "http://atlas.test", token: "app", fetch: this.fetch });
+    api.setKeyring(new Keyring({ dek: this.keys.dek, privateKey: this.keys.privateKey }));
+    const store = new LocalStore("app-device", { newId: () => crypto.randomUUID() });
+    api.setScopeContext(store, USER_ID);
+    const sync = new SyncClient(store, api, { cursor: 0 });
+    await sync.sync();
+    return { store, sync };
+  }
+}
+export {
+  FakeServer,
+  USER_ID
+};

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@atlastodo/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.11-rc.5",
+  "description": "Headless Atlas client for integrations: signs in with a personal API token and syncs an account's tasks into memory",
+  "license": "AGPL-3.0-only",
+  "homepage": "https://github.com/atlastodo/atlas-todo/tree/main/packages/sdk",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/atlastodo/atlas-todo.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/atlastodo/atlas-todo/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "@atlastodo/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "@atlastodo/source": "./src/testing.ts",
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    },
+    "./test-vectors/*": "./test-vectors/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "test-vectors"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "atlas": {
+    "testVectors": [
+      "parse_due_vectors.json"
+    ]
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build-core-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@atlastodo/client-core": "0.1.11-rc.5",
+    "@atlastodo/shared": "0.1.11-rc.5"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3"
+  }
+}