@ai-accounts/ts-core 0.2.0

package/dist/index.js

@@ -0,0 +1,453 @@
+// src/protocol/wire.ts
+var WIRE_PROTOCOL_VERSION = 1;
+
+// src/client/index.ts
+async function toError(r) {
+  let code = "http_error";
+  let message = r.statusText;
+  try {
+    const body = await r.json();
+    if (body.error) {
+      code = body.error.code ?? code;
+      message = body.error.message ?? message;
+    }
+  } catch {
+  }
+  const err = new Error(message);
+  err.code = code;
+  err.status = r.status;
+  return err;
+}
+var AiAccountsClient = class {
+  baseUrl;
+  token;
+  _fetch;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this.token = opts.token;
+    this._fetch = opts.fetch ?? fetch;
+  }
+  headers() {
+    const h = { "content-type": "application/json" };
+    if (this.token) h["authorization"] = `Bearer ${this.token}`;
+    return h;
+  }
+  async listBackends() {
+    const r = await this._fetch(`${this.baseUrl}/api/v1/backends/`, {
+      headers: this.headers()
+    });
+    if (!r.ok) throw await toError(r);
+    return await r.json();
+  }
+  async createBackend(input) {
+    const r = await this._fetch(`${this.baseUrl}/api/v1/backends/`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ config: {}, ...input })
+    });
+    if (!r.ok) throw await toError(r);
+    return await r.json();
+  }
+  async getBackend(id) {
+    const r = await this._fetch(
+      `${this.baseUrl}/api/v1/backends/${encodeURIComponent(id)}`,
+      { headers: this.headers() }
+    );
+    if (!r.ok) throw await toError(r);
+    return await r.json();
+  }
+  async deleteBackend(id) {
+    const r = await this._fetch(
+      `${this.baseUrl}/api/v1/backends/${encodeURIComponent(id)}`,
+      { method: "DELETE", headers: this.headers() }
+    );
+    if (!r.ok) throw await toError(r);
+  }
+  async detectBackend(id) {
+    return this.postAction(id, "detect");
+  }
+  async loginBackend(id, flowKind, inputs) {
+    return this.postAction(id, "login", { flow_kind: flowKind, inputs });
+  }
+  async pollBackendLogin(id, handle) {
+    const r = await this._fetch(
+      `${this.baseUrl}/api/v1/backends/${encodeURIComponent(id)}/login/poll`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ handle })
+      }
+    );
+    if (!r.ok) throw await toError(r);
+    return await r.json();
+  }
+  async validateBackend(id) {
+    return this.postAction(id, "validate");
+  }
+  async startOnboarding() {
+    const r = await this._fetch(`${this.baseUrl}/api/v1/onboarding`, {
+      method: "POST",
+      headers: this.headers()
+    });
+    if (!r.ok) throw await toError(r);
+    return await r.json();
+  }
+  async getOnboarding(id) {
+    const r = await this._fetch(
+      `${this.baseUrl}/api/v1/onboarding/${encodeURIComponent(id)}`,
+      { headers: this.headers() }
+    );
+    if (!r.ok) throw await toError(r);
+    return await r.json();
+  }
+  async detectForOnboarding(id) {
+    return this.onboardingAction(id, "detect");
+  }
+  async pickOnboardingKind(id, kind, displayName) {
+    return this.onboardingAction(id, "pick", {
+      kind,
+      display_name: displayName
+    });
+  }
+  async beginOnboardingLogin(id, flowKind, inputs) {
+    return this.onboardingAction(id, "login", {
+      flow_kind: flowKind,
+      inputs
+    });
+  }
+  async pollOnboardingLogin(id, handle) {
+    return this.onboardingAction(id, "login/poll", { handle });
+  }
+  async finalizeOnboarding(id) {
+    return this.onboardingAction(id, "finalize");
+  }
+  async postAction(id, action, body) {
+    const r = await this._fetch(
+      `${this.baseUrl}/api/v1/backends/${encodeURIComponent(id)}/${action}`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      }
+    );
+    if (!r.ok) throw await toError(r);
+    return await r.json();
+  }
+  async onboardingAction(id, action, body) {
+    const r = await this._fetch(
+      `${this.baseUrl}/api/v1/onboarding/${encodeURIComponent(id)}/${action}`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      }
+    );
+    if (!r.ok) throw await toError(r);
+    return await r.json();
+  }
+};
+
+// src/machines/accountWizard.ts
+function createAccountWizard(opts) {
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => listeners.forEach((l) => l());
+  let state = "idle";
+  let kind;
+  let detection;
+  let backend;
+  let error;
+  return {
+    get state() {
+      return state;
+    },
+    get kind() {
+      return kind;
+    },
+    get detection() {
+      return detection;
+    },
+    get backend() {
+      return backend;
+    },
+    get error() {
+      return error;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    start() {
+      state = "picking_kind";
+      kind = void 0;
+      detection = void 0;
+      backend = void 0;
+      error = void 0;
+      emit();
+    },
+    async pickKind(chosen) {
+      kind = chosen;
+      state = "detecting";
+      emit();
+      try {
+        backend = await opts.client.createBackend({
+          kind: chosen,
+          display_name: opts.defaultDisplayName ?? `${chosen} account`
+        });
+        detection = await opts.client.detectBackend(backend.id);
+        if (!detection.installed) {
+          state = "error";
+          error = `${chosen} CLI is not installed on the host`;
+          emit();
+          return;
+        }
+        state = "entering_credential";
+      } catch (e) {
+        state = "error";
+        error = e instanceof Error ? e.message : "failed to create backend";
+      }
+      emit();
+    },
+    async submitCredential(flowKind, inputs) {
+      if (!backend) {
+        state = "error";
+        error = "no backend in progress";
+        emit();
+        return;
+      }
+      state = "validating";
+      emit();
+      try {
+        const response = await opts.client.loginBackend(backend.id, flowKind, inputs);
+        if (response.kind === "pending") {
+          state = "error";
+          error = "OAuth flows are not supported in AccountWizard; use OnboardingFlow instead";
+          emit();
+          return;
+        }
+        backend = await opts.client.validateBackend(backend.id);
+        state = "done";
+      } catch (e) {
+        state = "error";
+        error = e.message ?? "validation failed";
+      }
+      emit();
+    },
+    reset() {
+      state = "idle";
+      kind = void 0;
+      detection = void 0;
+      backend = void 0;
+      error = void 0;
+      emit();
+    }
+  };
+}
+
+// src/machines/onboardingFlow.ts
+function createOnboardingFlow(opts) {
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => listeners.forEach((l) => l());
+  let state = "idle";
+  let onboardingId;
+  let kinds;
+  let selectedKind;
+  let selectedBackend;
+  let oauthChallenge;
+  let createdBackendId;
+  let error;
+  let pollCancelled = false;
+  const pollIntervalMs = opts.pollIntervalMs ?? 2e3;
+  const timeoutMs = opts.timeoutMs ?? 15 * 60 * 1e3;
+  function setError(msg) {
+    state = "error";
+    error = msg;
+    emit();
+  }
+  async function finalize() {
+    if (!onboardingId) return;
+    state = "validating";
+    emit();
+    try {
+      const final = await opts.client.finalizeOnboarding(onboardingId);
+      createdBackendId = final.created_backend_id ?? void 0;
+      state = "done";
+      emit();
+    } catch (e) {
+      setError(e.message ?? "finalize failed");
+    }
+  }
+  function schedulePoll(handle) {
+    pollCancelled = false;
+    const deadline = Date.now() + timeoutMs;
+    const tick = async () => {
+      if (pollCancelled || state !== "oauth_polling") return;
+      if (Date.now() > deadline) {
+        setError("OAuth login timed out");
+        return;
+      }
+      if (!onboardingId) {
+        setError("no onboarding session");
+        return;
+      }
+      try {
+        const result = await opts.client.pollOnboardingLogin(onboardingId, handle);
+        if (pollCancelled || state !== "oauth_polling") return;
+        if (result.kind === "complete") {
+          await finalize();
+          return;
+        }
+        setTimeout(tick, pollIntervalMs);
+      } catch (e) {
+        setError(e.message ?? "polling error");
+      }
+    };
+    setTimeout(tick, pollIntervalMs);
+  }
+  return {
+    get state() {
+      return state;
+    },
+    get kinds() {
+      return kinds;
+    },
+    get selectedKind() {
+      return selectedKind;
+    },
+    get selectedBackend() {
+      return selectedBackend;
+    },
+    get oauthChallenge() {
+      return oauthChallenge;
+    },
+    get createdBackendId() {
+      return createdBackendId;
+    },
+    get error() {
+      return error;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    async start() {
+      try {
+        const session = await opts.client.startOnboarding();
+        onboardingId = session.id;
+        state = "started";
+        emit();
+      } catch (e) {
+        setError(e.message ?? "failed to start onboarding");
+      }
+    },
+    async detect() {
+      if (!onboardingId) {
+        setError("not started");
+        return;
+      }
+      state = "detecting";
+      emit();
+      try {
+        const detect = await opts.client.detectForOnboarding(onboardingId);
+        kinds = Object.entries(detect.results).map(([id, detection]) => ({
+          id,
+          detection
+        }));
+        state = "picking_kind";
+        emit();
+      } catch (e) {
+        setError(e.message ?? "detect failed");
+      }
+    },
+    async pickKind(chosen) {
+      if (!onboardingId) {
+        setError("not started");
+        return;
+      }
+      try {
+        selectedBackend = await opts.client.pickOnboardingKind(
+          onboardingId,
+          chosen,
+          `${chosen} account`
+        );
+        selectedKind = chosen;
+        state = "entering_credential";
+        emit();
+      } catch (e) {
+        setError(e.message ?? "pickKind failed");
+      }
+    },
+    async submitApiKey(apiKey) {
+      if (!onboardingId) {
+        setError("not started");
+        return;
+      }
+      state = "validating";
+      emit();
+      try {
+        const response = await opts.client.beginOnboardingLogin(onboardingId, "api_key", {
+          api_key: apiKey
+        });
+        if (response.kind !== "complete") {
+          setError("unexpected pending response from api_key flow");
+          return;
+        }
+        await finalize();
+      } catch (e) {
+        setError(e.message ?? "login failed");
+      }
+    },
+    async submitOauthDevice() {
+      if (!onboardingId) {
+        setError("not started");
+        return;
+      }
+      state = "oauth_challenge";
+      emit();
+      try {
+        const response = await opts.client.beginOnboardingLogin(onboardingId, "oauth_device", {});
+        if (response.kind !== "pending" || !response.oauth) {
+          setError("expected pending OAuth response");
+          return;
+        }
+        oauthChallenge = response.oauth;
+        state = "oauth_polling";
+        emit();
+        schedulePoll(response.oauth.handle);
+      } catch (e) {
+        setError(e.message ?? "OAuth start failed");
+      }
+    },
+    cancelOAuth() {
+      pollCancelled = true;
+      state = "entering_credential";
+      oauthChallenge = void 0;
+      emit();
+    },
+    reset() {
+      pollCancelled = true;
+      state = "idle";
+      onboardingId = void 0;
+      kinds = void 0;
+      selectedKind = void 0;
+      selectedBackend = void 0;
+      oauthChallenge = void 0;
+      createdBackendId = void 0;
+      error = void 0;
+      emit();
+    }
+  };
+}
+
+// src/index.ts
+var version = "0.0.0";
+export {
+  AiAccountsClient,
+  WIRE_PROTOCOL_VERSION,
+  createAccountWizard,
+  createOnboardingFlow,
+  version
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@ai-accounts/ts-core",
+  "version": "0.2.0",
+  "description": "Framework-agnostic TypeScript client and protocol for ai-accounts",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "typecheck": "tsc --noEmit"
+  }
+}